C++ Reference

struct vortex::engine::engine_config_t::acquire_config

Public Members

bool preload

bool master

process_graph_t graph

struct vortex::engine::detail::engine_plan_t::acquire_plan

Public Members

processor_sets rotation

size_t output_index

struct vortex::engine::adapter::acquisition : public vortex::engine::adapter<block_t>::detail::base

Public Types

using callback_t = std::function<void(size_t, std::exception_ptr)>

Public Members

std::function< std::optional< cuda::device_t >)> device

std::function<spectra_stream_factory_t()> stream_factory

std::function<shape_t()> output_shape

std::function<size_t()> channels_per_sample

std::function<void()> prepare

std::function<void()> start

std::function<void()> stop

std::function<void(block_t&, spectra_stream_t&, callback_t&&)> next_async

struct vortex::marker::active_lines : public vortex::marker::detail::base

Public Functions

auto operator<=>(const active_lines&) const = default

template<typename block_t>
struct vortex::engine::adapter

Public Types

using spectra_stream_t = typename block_t::spectra_stream_t

using ascan_stream_t = typename block_t::ascan_stream_t

using io_stream_ts = decltype(std::declval<block_t>().streams())

using spectra_stream_factory_t = std::function<spectra_stream_t()>

using ascan_stream_factory_t = std::function<ascan_stream_t()>

using shape_t = std::array<size_t, 3>

template<typename T>
class vortex::sync::aggregator_t

Public Functions

inline aggregator_t(size_t n)

inline void push(size_t index, T o, size_t limit = 0, bool drop = true)

inline bool pop(std::vector<T> &os, bool wait = true)

inline void clear()

inline void finish()

Protected Functions

inline bool _empty()

Protected Attributes

std::atomic_bool _finished = false

std::condition_variable _push_cv

std::condition_variable _pop_cv

std::mutex _mutex

std::vector<std::queue<T>> _queues

template<typename config_t>
class vortex::acquire::alazar_acquisition_t : public vortex::acquire::detail::alazar_acquisition_t<config_t, alazar::board_t>

Subclassed by vortex::acquire::alazar_fft_acquisition_t< config_t >

Public Types

using base_t = detail::alazar_acquisition_t<config_t, alazar::board_t>

using callback_t = typename base_t::callback_t

Public Functions

template<typename V>
inline size_t next(const cpu_viewable<V> &buffer)

template<typename V>
inline size_t next(size_t id, const cpu_viewable<V> &buffer)

template<typename V>
inline void next_async(const cpu_viewable<V> &buffer, callback_t &&callback)

template<typename V>
inline void next_async(size_t id, const cpu_viewable<V> &buffer, callback_t &&callback)

template<typename config_t_, typename board_t_>
class vortex::acquire::detail::alazar_acquisition_t

Public Types

using config_t = config_t_

using board_t = board_t_

using output_element_t = uint16_t

using callback_t = std::function<void(size_t, std::exception_ptr)>

Public Functions

inline alazar_acquisition_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~alazar_acquisition_t()

inline const config_t &config() const

inline const board_t &board() const

inline virtual void initialize(config_t config)

inline virtual void prepare()

inline void start()

inline void stop()

inline bool running() const

Protected Types

using job_t = std::function<void()>

Protected Functions

template<typename V>
inline size_t _next(size_t id, const viewable<V> &buffer_)

template<typename V>
inline void _next_async(size_t id, const viewable<V> &buffer_, callback_t &&callback)

template<typename V>
inline auto _post_block(size_t id, const V &buffer, bool lock_is_held)

template<typename V>
inline auto _wait_block(size_t id, const V &buffer, bool lock_is_held)

inline void _stop(bool lock_is_held)

inline void _worker_loop()

Protected Attributes

std::shared_ptr<spdlog::logger> _log

std::atomic_bool _abort = false

sync::queue_t<job_t> _jobs

std::thread _worker

board_t _board

std::mutex _mutex

config_t _config

template<typename clock_t, typename trigger_t, typename option_t>
struct vortex::acquire::alazar_config_t : public vortex::acquire::detail::alazar_config_t<clock_t, trigger_t, option_t>

Subclassed by vortex::acquire::alazar_fft_config_t< clock_t, trigger_t, option_t >

Public Types

using base_t = detail::alazar_config_t<clock_t, trigger_t, option_t>

Public Functions

inline auto create_board()

inline virtual void validate()

inline virtual void apply(alazar::board_t &board, std::shared_ptr<spdlog::logger> &log)

template<typename clock_t_, typename trigger_t_, typename option_t_>
struct vortex::acquire::detail::alazar_config_t : public vortex::acquire::dso_config_t

Public Types

using clock_t = clock_t_

using trigger_t = trigger_t_

using option_t = option_t_

Public Functions

template<typename board_t>
inline void validate(const board_t &board)

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log)

inline size_t recommended_minimum_records_per_block() const

inline virtual size_t buffer_bytes_per_record() const

inline auto bytes_per_multisample() const

inline auto channel_mask() const

inline virtual size_t channels_per_sample() const override

inline bool samples_per_second_is_known() const

inline auto &samples_per_second()

inline const auto &samples_per_second() const

Public Members

struct vortex::acquire::detail::alazar_config_t::device_t device

clock_t clock = {clock::internal_t{}}

trigger_t trigger = {trigger::single_external_t{}}

std::vector<input_t> inputs

std::vector<option_t> options

std::vector<size_t> resampling

std::chrono::milliseconds acquire_timeout = std::chrono::seconds(1)

bool stop_on_error = true

template<typename T>
class vortex::alazar::alazar_device_tensor_t : public vortex::detail::tensor_impl_t<T>

Public Types

using element_t = T

Public Functions

inline alazar_device_tensor_t()

inline alazar_device_tensor_t(HANDLE handle, cuda::device_t device)

inline ~alazar_device_tensor_t()

inline alazar_device_tensor_t(alazar_device_tensor_t &&o)

inline alazar_device_tensor_t &operator=(alazar_device_tensor_t &&o)

inline const auto &handle() const

inline const auto &device() const

inline virtual size_t underlying_count() const override

Protected Functions

inline virtual void _allocate(size_t count) override

inline void _release()

inline void _reset()

Protected Attributes

size_t _count

cuda::device_t _device

HANDLE _handle

template<typename config_t>
class vortex::acquire::alazar_fft_acquisition_t : public vortex::acquire::alazar_acquisition_t<config_t>

Public Types

using base_t = alazar_acquisition_t<config_t>

using callback_t = typename base_t::callback_t

using base_t = detail::alazar_acquisition_t<config_t, alazar::board_t>

Public Functions

inline virtual void prepare() override

template<typename clock_t, typename trigger_t, typename option_t>
struct vortex::acquire::alazar_fft_config_t : public vortex::acquire::alazar_config_t<clock_t, trigger_t, option_t>

Public Types

using base_t = alazar_config_t<clock_t, trigger_t, option_t>

Public Functions

inline virtual std::array<size_t, 3> shape() const override

inline virtual size_t buffer_bytes_per_record() const override

inline size_t samples_per_ascan() const

inline size_t &ascans_per_block()

inline const size_t &ascans_per_block() const

inline virtual void validate() override

inline virtual void apply(alazar::board_t &board, std::shared_ptr<spdlog::logger> &log) override

Public Members

size_t fft_length = 1024

xt::xtensor<std::complex<float>, 1> spectral_filter

bool include_time_domain = false

xt::xtensor<int16_t, 1> background

Protected Functions

inline auto _fft_record_length() const

template<typename config_t>
class vortex::acquire::alazar_gpu_acquisition_t : public vortex::acquire::detail::alazar_acquisition_t<config_t, alazar::gpu_board_t>

Public Types

using base_t = detail::alazar_acquisition_t<config_t, alazar::gpu_board_t>

using callback_t = typename base_t::callback_t

Public Functions

template<typename V>
inline size_t next(const alazar::alazar_viewable<V> &buffer)

template<typename V>
inline size_t next(size_t id, const alazar::alazar_viewable<V> &buffer)

template<typename V>
inline void next_async(const alazar::alazar_viewable<V> &buffer, callback_t &&callback)

template<typename V>
inline void next_async(size_t id, const alazar::alazar_viewable<V> &buffer, callback_t &&callback)

template<typename clock_t, typename trigger_t, typename option_t>
struct vortex::acquire::alazar_gpu_config_t : public vortex::acquire::detail::alazar_config_t<clock_t, trigger_t, option_t>

Public Types

using base_t = detail::alazar_config_t<clock_t, trigger_t, option_t>

Public Functions

inline auto create_board()

inline virtual void validate()

Public Members

size_t gpu_device_index = 0

template<typename T>
class vortex::alazar::detail::alazar_view_t : public vortex::alazar::alazar_viewable<alazar_view_t<T>>, public vortex::detail::dynamic_view_t<T, fixed_alazar_view_t<T>, alazar_view_t<T>>

Public Types

using base_t = vortex::detail::dynamic_view_t<T, fixed_alazar_view_t<T>, alazar_view_t<T>>

Public Functions

inline alazar_view_t()

template<typename S1>
inline alazar_view_t(T *data, const S1 &shape, const cuda::device_t &device, const HANDLE &handle)

template<typename O, typename S1>
inline alazar_view_t(const O &other, T *data, const S1 &shape)

template<typename V>
inline alazar_view_t(const alazar_viewable<V> &other)

inline const auto &device() const

inline const auto &handle() const

inline bool is_accessible() const

inline bool is_accessible(cuda::device_t device2) const

Protected Attributes

cuda::device_t _device

HANDLE _handle

template<typename derived_t>
class alazar_viewable : public vortex::cuda::cuda_viewable<derived_t>

struct vortex::alazar::detail::alignment_info_t

Public Members

U32 min_record_size

U32 pretrigger_alignment

U32 resolution

struct analog_input_t : public vortex::io::detail::analog_t

Subclassed by vortex::io::channel::analog_voltage_input_t

struct analog_output_t : public vortex::io::detail::analog_t

Subclassed by vortex::io::channel::analog_voltage_output_t

struct vortex::io::detail::analog_t : public vortex::io::detail::base_t

Subclassed by vortex::io::detail::analog_input_t, vortex::io::detail::analog_output_t

Public Functions

inline bool operator==(const analog_t &o) const

Public Members

std::string port_name

double logical_units_per_physical_unit = 1

range_t<float64> limits = {{-10, 10}}

struct vortex::io::channel::analog_voltage_input_t : public vortex::io::detail::analog_input_t

Public Functions

inline void apply(daqmx::daqmx_t &daqmx, std::shared_ptr<spdlog::logger> &log) const

inline bool operator==(const analog_voltage_input_t &o) const

Public Members

daqmx::terminal_t terminal = daqmx::terminal_t::referenced

struct vortex::io::channel::analog_voltage_output_t : public vortex::io::detail::analog_output_t

Public Functions

inline void apply(daqmx::daqmx_t &daqmx, std::shared_ptr<spdlog::logger> &log) const

struct vortex::scan::warp::angular_t

Public Functions

inline angular_t()

inline angular_t(double factor_)

template<typename E1, typename E2>
inline auto forward(xt::xexpression<E1> &in, xt::xexpression<E2> &out) const

template<typename E1, typename E2>
inline auto inverse(xt::xexpression<E1> &in, xt::xexpression<E2> &out) const

template<typename E>
inline void forward(xt::xexpression<E> &inout) const

template<typename E>
inline void inverse(xt::xexpression<E> &inout) const

Public Members

double factor = 2

template<typename T>
struct array

template<>
struct vortex::storage::detail::matlab::array<double>

Public Static Attributes

static constexpr static auto value   = mxDOUBLE_CLASS

static constexpr static auto name   = "float64"

static constexpr static auto flags   = 0

template<>
struct vortex::storage::detail::matlab::array<float>

Public Static Attributes

static constexpr static auto value   = mxSINGLE_CLASS

static constexpr static auto name   = "float32"

static constexpr static auto flags   = 0

template<>
struct vortex::storage::detail::matlab::array<int16_t>

Public Static Attributes

static constexpr static auto value   = mxINT16_CLASS

static constexpr static auto name   = "int16"

static constexpr static auto flags   = 0

template<>
struct vortex::storage::detail::matlab::array<int32_t>

Public Static Attributes

static constexpr static auto value   = mxINT32_CLASS

static constexpr static auto name   = "int32"

static constexpr static auto flags   = 0

template<>
struct vortex::storage::detail::matlab::array<int64_t>

Public Static Attributes

static constexpr static auto value   = mxINT64_CLASS

static constexpr static auto name   = "int64"

static constexpr static auto flags   = 0

template<>
struct vortex::storage::detail::matlab::array<int8_t>

Public Static Attributes

static constexpr static auto value   = mxINT8_CLASS

static constexpr static auto name   = "int8"

static constexpr static auto flags   = 0

template<typename T>
struct vortex::storage::detail::matlab::array<std::complex<T>>

Public Static Attributes

static constexpr static auto value   = array<T>::value

static constexpr static auto flags   = complex_flag

template<>
struct vortex::storage::detail::matlab::array<uint16_t>

Public Static Attributes

static constexpr static auto value   = mxUINT16_CLASS

static constexpr static auto name   = "uint16"

static constexpr static auto flags   = 0

template<>
struct vortex::storage::detail::matlab::array<uint32_t>

Public Static Attributes

static constexpr static auto value   = mxUINT32_CLASS

static constexpr static auto name   = "uint32"

static constexpr static auto flags   = 0

template<>
struct vortex::storage::detail::matlab::array<uint64_t>

Public Static Attributes

static constexpr static auto value   = mxUINT64_CLASS

static constexpr static auto name   = "uint64"

static constexpr static auto flags   = 0

template<>
struct vortex::storage::detail::matlab::array<uint8_t>

Public Static Attributes

static constexpr static auto value   = mxUINT8_CLASS

static constexpr static auto name   = "uint8"

static constexpr static auto flags   = 0

struct vortex::engine::detail::engine_plan_t::ascan_buffer

Public Members

ascan_stream_factory_t factory

std::optional<cuda::device_t> device

shape_t shape

template<typename element_t>
struct ascan_stack_storage : public vortex::endpoint::detail::stack_storage<stack_format_executor_t, simple_stack_t<element_t>, detail::select_ascans_t>

template<typename element_t>
struct ascan_stream_storage : public vortex::endpoint::detail::stream_storage<simple_stream_t<element_t>, detail::select_ascans_t>

struct vortex::acquire::option::auxio_clock_out_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

inline bool operator==(const auxio_clock_out_t &o) const

struct vortex::acquire::option::auxio_pacer_out_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

inline bool operator==(const auxio_pacer_out_t &o) const

Public Members

U32 divider = 2

struct vortex::acquire::option::auxio_trigger_out_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

inline bool operator==(const auxio_trigger_out_t &o) const

struct balance_t

struct vortex::engine::adapter::detail::base

Subclassed by vortex::engine::adapter< block_t >::acquisition, vortex::engine::adapter< block_t >::endpoint, vortex::engine::adapter< block_t >::formatter, vortex::engine::adapter< block_t >::io, vortex::engine::adapter< block_t >::processor

Public Functions

template<typename T>
inline base(const T *target)

inline bool operator==(const base &o) const

inline bool operator<(const base &o) const

Private Members

const void *_target

struct vortex::marker::detail::base

Subclassed by vortex::marker::active_lines, vortex::marker::event, vortex::marker::inactive_lines, vortex::marker::scan_boundary, vortex::marker::segment_boundary, vortex::marker::volume_boundary

Public Types

using flags_t = marker::flags_t<>

Public Functions

inline base()

inline base(counter_t sample_)

auto operator<=>(const base &o) const = default

Public Members

counter_t sample

struct base_t

struct vortex::io::detail::base_t

Subclassed by vortex::io::detail::analog_t, vortex::io::detail::digital_t

Public Functions

inline bool operator==(const base_t &o) const

Public Members

size_t stream = 0

size_t channel = 0

template<typename T, typename shape_t, typename stride_t>
class vortex::detail::base_view_t

Public Types

using element_t = std::decay_t<T>

Public Functions

inline auto valid() const

inline auto data() const

template<typename List>
inline auto data(const List &idxs) const

inline auto data(const std::initializer_list<size_t> &idxs) const

template<typename Iterator>
inline auto data(const Iterator &begin, const Iterator &end) const

template<typename List>
inline auto offset(const List &idxs) const

inline auto offset(const std::initializer_list<size_t> &idxs) const

template<typename Iterator>
inline auto offset(const Iterator &begin, const Iterator &end) const

inline auto count() const

inline auto size_in_bytes() const

inline const auto &shape() const

inline auto shape(size_t idx) const

inline const auto &stride() const

inline auto stride(size_t idx) const

inline auto stride_in_bytes(size_t idx) const

inline auto stride_in_bytes() const

inline auto shape_and_stride() const

inline auto dimension() const

Protected Functions

inline base_view_t(T *data)

inline void _default_stride()

Protected Attributes

T *_data

shape_t _shape

stride_t _stride

template<typename acquire_element_t_, typename process_element_t_, typename analog_element_t_, typename digital_element_t_>
struct vortex::engine::block_t

Public Types

enum stream_index_t

Values:

enumerator galvo_target

enumerator sample_target

enumerator galvo_actual

enumerator sample_actual

enumerator strobes

using acquire_element_t = acquire_element_t_

using process_element_t = process_element_t_

using analog_element_t = analog_element_t_

using digital_element_t = digital_element_t_

using id_t = size_t

using marker_t = default_marker_t

using spectra_stream_t = std::variant<sync::lockable<cuda::cuda_device_tensor_t<acquire_element_t>>, sync::lockable<cuda::cuda_host_tensor_t<acquire_element_t>>>

using ascan_stream_t = std::variant<sync::lockable<cuda::cuda_device_tensor_t<process_element_t>>, sync::lockable<cuda::cuda_host_tensor_t<process_element_t>>>

using scan_stream_t = sync::lockable<cuda::cuda_host_tensor_t<analog_element_t>>

using strobe_stream_t = sync::lockable<cpu_tensor_t<digital_element_t>>

Public Functions

inline auto streams(size_t lead_samples = 0)

inline auto streams(size_t lead_samples = 0) const

Public Members

size_t id

time_t timestamp

counter_t sample

size_t length

std::vector<marker_t> markers

std::vector<spectra_stream_t> spectra

std::vector<ascan_stream_t> ascans

std::unordered_map<size_t, scan_stream_t> galvo_target

scan_stream_t sample_target

scan_stream_t galvo_actual

scan_stream_t sample_actual

std::unordered_map<size_t, strobe_stream_t> strobes

class vortex::alazar::board_t

Public Functions

board_t()

board_t(U32 system_index, U32 board_index)

~board_t()

const info_t &info() const

const HANDLE &handle() const

void configure_clock_external(float level_ratio = 0.5f, coupling_t coupling = coupling_t::AC, clock_edge_t clock_edge = clock_edge_t::rising, U32 decimation = 0)

void configure_clock_internal(size_t samples_per_second, U32 decimation = 0)

void configure_single_trigger_external(size_t range_millivolts = trigger_range_TTL, float level_ratio = 0.0f, size_t delay_samples = 0, trigger_slope_t slope = trigger_slope_t::positive, coupling_t coupling = coupling_t::DC)

void configure_dual_trigger_external(size_t range_millivolts = trigger_range_TTL, float level_ratio_first = 0.0f, float level_ratio_second = 0.0f, size_t delay_samples = 0, trigger_slope_t slope_first = trigger_slope_t::positive, coupling_t coupling = coupling_t::DC)

void configure_input(channel_t channel, coupling_t coupling = coupling_t::DC, size_t range_millivolts = 400, size_t impedance_ohms = 50)

void configure_auxio_trigger_out()

void configure_auxio_clock_out()

void configure_auxio_pacer_out(U32 divider = 2)

void configure_fft_window(U32 samples_per_record, const std::complex<float> *window)

void configure_fft_window(U32 samples_per_record, float *real = nullptr, float *imaginary = nullptr)

void configure_fft_background_subtraction(U32 samples_per_record = 0, const S16 *background_record = nullptr)

void configure_sample_skipping(U32 clocks_per_record = 0, U16 *sample_bitmap = nullptr)

void configure_capture(channel_t channels, U32 samples_per_record, U32 records_per_buffer, U32 records_per_acquisition = infinite_acquisition, long transfer_offset = 0)

void configure_capture_fft(channel_t channels, U32 samples_per_record, U32 records_per_buffer, U32 fft_length, U32 output_format, long transfer_offset = 0)

void start_capture()

void stop_capture()

void post_buffer(void *ptr, size_t size_in_bytes)

void wait_buffer(void *ptr)

void wait_buffer(void *ptr, const std::chrono::milliseconds &timeout)

void set_dual_edge_sampling(U8 channel_mask, bool enable)

void set_ignore_bad_clock(bool enable, double good_seconds = 0.0, double bad_seconds = 0.0)

double buffer_bytes_per_sample() const

size_t samples_per_record() const

size_t record_capture_count() const

size_t pending_buffer_count() const

bool valid() const

bool running() const

Protected Functions

U32 _capture_flags() const

void _configure_external_trigger(size_t range_millivolts, size_t delay_samples, coupling_t coupling)

RETURN_CODE _dsp_aware_abort_capture()

RETURN_CODE _dsp_aware_wait_buffer(void *buffer, U32 timeout_ms)

Protected Attributes

bool _started = false

bool _dsp_active = false

HANDLE _handle = NULL

info_t _info = {0}

template<typename config_t>
class vortex::format::broct_format_executor_t : public vortex::format::stack_format_executor_t<config_t>

Public Types

using base_t = stack_format_executor_t<config_t>

Public Functions

template<typename V1, typename V2>
inline void execute(const cpu_viewable<V1> &volume_buffer_, const cpu_viewable<V2> &block_buffer_, const action::copy &action) const

struct broct_storage : public vortex::endpoint::detail::stack_storage<broct_format_executor_t, broct_storage_t, detail::select_ascans_t, detail::broct_volume_shape_t>

struct vortex::storage::broct_storage_config_t

Public Functions

inline size_t &samples_per_ascan()

inline const size_t &samples_per_ascan() const

inline size_t &ascans_per_bscan()

inline const size_t &ascans_per_bscan() const

inline size_t &bscans_per_volume()

inline const size_t &bscans_per_volume() const

inline auto broct_volume_shape() const

inline auto broct_bscan_shape() const

Public Members

std::string path

std::array<size_t, 3> shape = {{0, 0, 0}}

std::array<double, 3> dimensions = {{1.0, 1.0, 1.0}}

broct_scan_t scan_type = broct_scan_t::rectangular

std::string notes

bool buffering = false

template<typename config_t_>
class vortex::storage::broct_storage_t

Public Types

using config_t = config_t_

using element_t = int8_t

Public Functions

inline broct_storage_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~broct_storage_t()

inline const auto &config() const

inline virtual void open(config_t config)

inline virtual void seek(size_t volume_index, size_t bscan_index)

template<typename V>
inline void write_bscan(size_t index, const cpu_viewable<V> &bscan_)

template<typename V>
inline void write_multi_bscan(size_t index, const cpu_viewable<V> &chunk_)

template<typename V>
inline void write_partial_bscan(size_t bscan_index, size_t ascan_index, const cpu_viewable<V> &chunk_)

template<typename V>
inline void write_volume(const cpu_viewable<V> &volume_)

inline virtual void advance_volume(bool allocate = true)

inline virtual void close()

inline virtual bool ready() const

Protected Functions

inline size_t _volume_size_in_bytes()

inline size_t _bscan_size_in_bytes()

Protected Attributes

std::shared_ptr<spdlog::logger> _log

config_t _config

std::ofstream _out

size_t _header_position

size_t _volume_position

size_t _farthest_write_position

struct vortex::endpoint::detail::broct_volume_shape_t

Public Static Functions

template<typename config_t>
static inline auto shape(const config_t &config)

class buffer_not_ready : public vortex::alazar::exception

class buffer_overflow : public vortex::alazar::exception

class buffer_overflow : public vortex::daqmx::exception

class buffer_underflow : public vortex::daqmx::exception

template<typename ...Ts>
struct vortex::io::channel_t : public std::variant<Ts...>

Public Types

using base_t = std::variant<Ts...>

Public Functions

inline auto apply(daqmx::daqmx_t &daqmx, std::shared_ptr<spdlog::logger> &log) const

inline bool operator==(const channel_t &o) const

template<typename ...Ts>
struct vortex::acquire::clock_t : public std::variant<Ts...>

Public Functions

template<typename board_t>
inline auto apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

inline auto samples_per_second() const

template<typename ...Args>
class vortex::util::completion_worker_pool_t

Public Types

using setup_task_t = std::function<void(size_t)>

using work_t = std::function<std::tuple<Args...>()>

using callback_t = std::function<void(Args...)>

Public Functions

inline completion_worker_pool_t()

inline completion_worker_pool_t(const std::string &prefix, size_t n = 0, setup_task_t &&setup_task = {}, std::shared_ptr<spdlog::logger> log = nullptr)

inline ~completion_worker_pool_t()

inline void post(work_t &&work, callback_t &&callback)

inline void wait_finish()

Protected Attributes

worker_pool_t _work_pool

worker_pool_t _done_pool

struct vortex::format::action::copy

Public Functions

auto operator<=>(const copy&) const = default

Public Members

size_t count

size_t block_offset

size_t buffer_segment

size_t buffer_record

bool reverse

struct vortex::process::copy_processor_config_t

Public Functions

inline std::array<size_t, 3> input_shape() const

inline size_t &records_per_block()

inline const size_t &records_per_block() const

inline size_t &samples_per_record()

inline const size_t &samples_per_record() const

inline size_t channels_per_sample() const

inline std::array<size_t, 3> output_shape() const

inline size_t &ascans_per_block()

inline const size_t &ascans_per_block() const

inline size_t samples_per_ascan() const

inline virtual void validate() const

Public Members

copy::slice_t sample_slice

copy::transform_t sample_transform

size_t slots = 2

size_t channel = 0

Protected Attributes

size_t _ascans_per_block = 1000

size_t _samples_per_record = 1000

template<typename input_element_t_, typename output_element_t_, typename config_t_>
class vortex::process::copy_processor_t

Public Types

using base_t = processor_t<config_t_>

using config_t = config_t_

using input_element_t = input_element_t_

using output_element_t = output_element_t_

using callback_t = std::function<void(std::exception_ptr)>

Public Functions

inline copy_processor_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~copy_processor_t()

inline virtual void initialize(config_t config)

inline virtual void change(config_t new_config)

inline const auto &config() const

template<typename V1, typename V2>
inline void next(const cpu_viewable<V1> &input_buffer, const cpu_viewable<V2> &output_buffer)

template<typename V1, typename V2>
inline void next(size_t id, const cpu_viewable<V1> &input_buffer, const cpu_viewable<V2> &output_buffer)

template<typename V1, typename V2>
inline void next_async(const cpu_viewable<V1> &input_buffer, const cpu_viewable<V2> &output_buffer, callback_t &&callback)

template<typename V1, typename V2>
inline void next_async(size_t id, const cpu_viewable<V1> &input_buffer_, const cpu_viewable<V2> &output_buffer_, callback_t &&callback)

Protected Types

using job_t = std::function<void()>

Protected Functions

template<typename V1, typename V2>
inline auto _process(size_t id, const cpu_viewable<V1> &input_buffer_, const cpu_viewable<V2> &output_buffer_)

Protected Attributes

config_t _config

std::shared_ptr<spdlog::logger> _log

std::optional<util::completion_worker_pool_t<std::exception_ptr>> _pool

std::mutex _mutex

class vortex::sync::counter_t

Public Functions

counter_t(size_t initial = 0)

void set(size_t value)

void operator++(int)

void operator--(int)

void increment()

bool decrement()

size_t query() const

bool wait(size_t value = 0) const

void finish()

Protected Attributes

std::atomic_bool _finished = false

std::atomic<size_t> _count = 0

mutable std::mutex _mutex

mutable std::condition_variable _cv

template<typename config_t_, typename input_assignment_t_, typename output_assignment_t_>
class vortex::process::cpu_processor_t : private vortex::process::processor_t<config_t_>

Public Types

using config_t = config_t_

using input_assignment_t = input_assignment_t_

using output_assignment_t = output_assignment_t_

using input_element_t = typename input_assignment_t::element_t

using output_element_t = typename output_assignment_t::element_t

using block_t = typename input_assignment_t::block_t

using callback_t = std::function<void(block_t*)>

Public Functions

inline virtual ~cpu_processor_t()

inline virtual void initialize(config_t config)

inline virtual void change(config_t &new_config)

inline virtual void next(block_t &block)

inline virtual void next_async(block_t *block)

inline virtual void next_async(block_t *block, sync::event_t *event)

inline virtual void next_async(block_t *block, callback_t &&callback)

Protected Functions

inline void _recalculate()

inline void _shutdown_workers()

inline virtual void _process_block(slot_t &slot, block_t &block, bool append_history)

inline void _worker_loop()

Protected Attributes

sync::queue_t<job_t> _jobs

std::thread _worker

sync::event_t _worker_ready

std::mutex _slot_mutex

slot_t _slot

xt::xtensor<output_element_t, 1> _resample_before_weight

xt::xtensor<output_element_t, 1> _resample_after_weight

xt::xtensor<ptrdiff_t, 1> _resample_before_index

xt::xtensor<ptrdiff_t, 1> _resample_after_index

std::mutex _average_ascan_mutex

xt::xtensor<output_element_t, 2> _average_ascan

size_t _average_ascan_index

size_t _average_ascan_count

fft::fftw_plan_t<output_element_t> _ifft

std::shared_mutex _config_mutex

template<typename tensor_t, typename executor_t>
struct vortex::endpoint::detail::cpu_tensor : public vortex::endpoint::detail::notify

Public Types

using base_t = detail::notify

Public Functions

inline cpu_tensor(std::shared_ptr<executor_t> executor, std::vector<size_t> shape, std::shared_ptr<spdlog::logger> log = nullptr)

template<size_t N>
inline cpu_tensor(std::shared_ptr<executor_t> executor, const std::array<size_t, N> &shape, std::shared_ptr<spdlog::logger> log = nullptr)

inline cpu_tensor(std::shared_ptr<executor_t> executor, std::shared_ptr<sync::lockable<tensor_t>> tensor, std::shared_ptr<spdlog::logger> log = nullptr)

inline const auto &tensor() const

inline const auto &executor() const

inline void allocate(const std::optional<cuda::device_t> spectra, const std::optional<cuda::device_t> &ascans)

template<typename block_t, typename V1, typename V2>
inline void handle(const format::format_plan_t &plan, const block_t &block, const viewable<V1> &spectra, const cuda::cuda_viewable<V2> &ascans)

template<typename block_t, typename V1, typename V2>
inline void handle(const format::format_plan_t &plan, const block_t &block, const viewable<V1> &spectra, const cpu_viewable<V2> &ascans_)

Public Members

aggregate_segment_callback_t aggregate_segment_callback

update_callback_t update_callback

Protected Functions

template<typename Callback, typename ...Args>
inline void _notify(std::shared_ptr<spdlog::logger> log, const Callback &callback, Args&&... args)

inline void _default(std::shared_ptr<spdlog::logger> log, std::vector<size_t> &segments, const format::format_action_t &action)

Protected Attributes

std::shared_ptr<executor_t> _executor

std::optional<std::vector<size_t>> _shape

std::shared_ptr<sync::lockable<tensor_t>> _tensor

std::shared_ptr<spdlog::logger> _log

Private Functions

inline void _check()

template<typename T>
class vortex::cpu_tensor_t : public vortex::detail::tensor_impl_t<T>

Public Types

using element_t = T

Public Functions

inline cpu_tensor_t()

inline ~cpu_tensor_t()

inline cpu_tensor_t(cpu_tensor_t &&o)

inline cpu_tensor_t &operator=(cpu_tensor_t &&o)

inline virtual size_t underlying_count() const override

Protected Functions

inline virtual void _allocate(size_t count) override

Protected Attributes

std::vector<T> _buffer

template<typename T>
class vortex::detail::cpu_view_t : public vortex::cpu_viewable<cpu_view_t<T>>, public vortex::detail::dynamic_view_t<T, fixed_cpu_view_t<T>, cpu_view_t<T>>

Public Types

using base_t = detail::dynamic_view_t<T, fixed_cpu_view_t<T>, cpu_view_t<T>>

Public Functions

template<typename O, typename S1>
inline cpu_view_t(const O &other, T *data, const S1 &shape)

template<typename V>
inline cpu_view_t(const cpu_viewable<V> &other)

inline auto to_xt()

inline auto to_xt() const

template<typename derived_t>
struct cpu_viewable : public vortex::viewable<derived_t>

template<typename T>
struct cuda_complex_t

template<>
struct vortex::cuda::detail::cuda_complex_t<double>

Public Types

using type = cuDoubleComplex

template<>
struct vortex::cuda::detail::cuda_complex_t<float>

Public Types

using type = cuFloatComplex

template<typename T, typename executor_t, typename derived_t>
struct vortex::endpoint::detail::cuda_device_tensor_impl : public vortex::endpoint::detail::cuda_tensor_impl<executor_t, cuda::cuda_device_tensor_t<T>, derived_t>

Subclassed by vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl< T, position_format_executor_t, position_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl< T, spiral_format_executor_t, spiral_galvo_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl< T, executor_t, derived_t >

Public Types

using base_t = cuda_tensor_impl<executor_t, cuda::cuda_device_tensor_t<T>, derived_t>

Public Functions

inline void allocate(const std::optional<cuda::device_t> spectra, const std::optional<cuda::device_t> &ascans)

template<typename block_t, typename V1, typename V2>
inline void handle(const format::format_plan_t &plan, const block_t &block, const viewable<V1> &spectra, const cpu_viewable<V2> &ascans)

template<typename block_t, typename V1, typename V2>
inline void handle(const format::format_plan_t &plan, const block_t &block, const viewable<V1> &spectra, const cuda::cuda_viewable<V2> &ascans_)

template<typename T>
class vortex::cuda::cuda_device_tensor_t : public vortex::detail::tensor_impl_t<T>

Public Types

using element_t = T

Public Functions

inline cuda_device_tensor_t()

inline ~cuda_device_tensor_t()

inline cuda_device_tensor_t(cuda_device_tensor_t &&o)

inline cuda_device_tensor_t &operator=(cuda_device_tensor_t &&o)

inline bool is_accessible() const

inline bool is_accessible(device_t device2) const

inline const auto &device() const

inline virtual size_t underlying_count() const override

Protected Functions

inline virtual void _allocate(size_t count) override

inline void _release()

inline void _reset()

Protected Attributes

size_t _count

device_t _device

template<typename T, typename executor_t, typename derived_t>
struct vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl : public vortex::endpoint::detail::cuda_device_tensor_impl<T, executor_t, derived_t>

Public Types

using base_t = cuda_device_tensor_impl<T, executor_t, derived_t>

Public Functions

template<typename block_t, typename V1, typename V2>
inline void handle(const format::format_plan_t &plan, const block_t &block, const viewable<V1> &spectra, const cpu_viewable<V2> &ascans)

template<typename block_t, typename V1, typename V2>
inline void handle(const format::format_plan_t &plan, const block_t &block, const viewable<V1> &spectra, const cuda::cuda_viewable<V2> &ascans_)

Protected Attributes

cuda::cuda_device_tensor_t<double> _sample_target

cuda::cuda_device_tensor_t<double> _sample_actual

template<typename T, typename executor_t, typename derived_t>
struct vortex::endpoint::detail::cuda_host_tensor_impl : public vortex::endpoint::detail::cuda_tensor_impl<executor_t, cuda::cuda_host_tensor_t<T>, derived_t>

Public Types

using base_t = cuda_tensor_impl<executor_t, cuda::cuda_host_tensor_t<T>, derived_t>

Public Functions

inline void allocate(const std::optional<cuda::device_t> spectra, const std::optional<cuda::device_t> &ascans)

template<typename block_t, typename spectra_stream_t, typename ascan_stream_t>
inline void handle(const format::format_plan_t &plan, const block_t &block, const spectra_stream_t &spectra, const ascan_stream_t &ascans)

Protected Functions

inline void _transfer(std::vector<size_t> segments)

Protected Attributes

cuda::cuda_device_tensor_t<T> _device_buffer

template<typename T>
class vortex::cuda::cuda_host_tensor_t : public vortex::detail::tensor_impl_t<T>

Subclassed by vortex::sync::lockable< cuda::cuda_host_tensor_t< analog_element_t > >

Public Types

using element_t = T

Public Functions

inline cuda_host_tensor_t()

inline ~cuda_host_tensor_t()

inline cuda_host_tensor_t(cuda_host_tensor_t &&o)

inline cuda_host_tensor_t &operator=(cuda_host_tensor_t &&o)

inline virtual size_t underlying_count() const override

Protected Functions

inline virtual void _allocate(size_t count) override

inline void _release()

inline void _reset()

Protected Attributes

size_t _count

template<typename T>
struct vortex::process::cuda_processor_config_t : public vortex::process::processor_config_t<T>

Public Types

using element_t = T

Public Functions

inline virtual void validate() override

Public Members

int device = 0

size_t slots = 2

template<typename input_element_t_, typename output_element_t_, typename float_element_t_, typename index_element_t_, typename config_t_>
class vortex::process::cuda_processor_t : public vortex::process::processor_t<config_t_>

Public Types

using base_t = processor_t<config_t_>

using config_t = config_t_

using input_element_t = input_element_t_

using output_element_t = output_element_t_

using float_element_t = float_element_t_

using index_element_t = index_element_t_

using callback_t = std::function<void(std::exception_ptr)>

Public Functions

inline cuda_processor_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~cuda_processor_t()

inline virtual void initialize(config_t config)

inline virtual void change(config_t new_config)

template<typename V1, typename V2>
inline void next(const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, bool append_history = true)

template<typename V1, typename V2>
inline void next(size_t id, const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, bool append_history = true)

template<typename V1, typename V2>
inline void next_async(const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, callback_t &&callback)

template<typename V1, typename V2>
inline void next_async(size_t id, const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, callback_t &&callback)

template<typename V1, typename V2>
inline void next_async(const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, bool append_history, callback_t &&callback)

template<typename V1, typename V2>
inline void next_async(size_t id, const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, bool append_history, callback_t &&callback)

template<typename V1, typename V2>
inline void next_async(const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, const cuda::event_t *start_event, const cuda::event_t *done_event, callback_t &&callback)

template<typename V1, typename V2>
inline void next_async(size_t id, const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, const cuda::event_t *start_event, const cuda::event_t *done_event, callback_t &&callback)

template<typename V1, typename V2>
inline void next_async(const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, const cuda::event_t *start_event, const cuda::event_t *done_event, bool append_history, callback_t &&callback)

template<typename V1, typename V2>
inline void next_async(size_t id, const cuda::cuda_viewable<V1> &input_buffer, const cuda::cuda_viewable<V2> &output_buffer, const cuda::event_t *start_event, const cuda::event_t *done_event, bool append_history, callback_t &&callback)

Protected Types

using job_t = std::function<void()>

Protected Functions

inline void _recalculate(const config_t &prior, bool lightweight = true)

inline auto &_next_slot()

template<typename V1, typename V2>
inline auto _next_block(slot_t &slot, size_t id, const cuda::cuda_viewable<V1> &input_buffer_, const cuda::cuda_viewable<V2> &output_buffer_, const cuda::event_t *start_event, const cuda::event_t *done_event, bool append_history)

template<typename V1, typename V2>
inline auto _dispatch_block(slot_t &slot, size_t id, size_t count, const cuda::cuda_viewable<V1> &input_buffer_, const cuda::cuda_viewable<V2> &output_buffer_, const cuda::event_t *start_event, const cuda::event_t *done_event, bool append_history)

inline auto _wait_block(slot_t &slot, size_t id)

inline void _worker_loop()

template<typename T>
inline void _sync_with_device(const xt::xtensor<T, 1> &host, cuda::cuda_device_tensor_t<cuda::device_type<T>> &device)

Protected Attributes

std::shared_ptr<spdlog::logger> _log

sync::queue_t<job_t> _jobs

std::thread _worker

std::mutex _mutex

cuda::event_t _update_complete

cuda::stream_t _update_stream

size_t _next_slot_index = 0

std::vector<slot_t> _slots

size_t _fft_plan_length = 0

cuda::cuda_device_tensor_t<index_element_t> _resample_before_index

cuda::cuda_device_tensor_t<index_element_t> _resample_after_index

cuda::cuda_device_tensor_t<float_element_t> _resample_before_weight

cuda::cuda_device_tensor_t<float_element_t> _resample_after_weight

cuda::cuda_device_tensor_t<input_element_t> _average_record_buffer

cuda::cuda_device_tensor_t<float_element_t> _average_record

cuda::cuda_device_tensor_t<uint8_t> _average_internal_storage

size_t _average_record_index

size_t _average_record_count

cuda::cuda_device_tensor_t<cuda::complex<float_element_t>> _complex_filter

template<typename derived_t_>
struct vortex::endpoint::cuda_tensor : public vortex::endpoint::detail::notify

Public Types

using derived_t = derived_t_

Public Functions

inline auto &derived_cast()

inline const auto &derived_cast() const

inline const auto &stream()

Protected Attributes

cuda::stream_t _stream

template<typename executor_t, typename tensor_t, typename derived_t>
struct vortex::endpoint::detail::cuda_tensor_impl : public vortex::endpoint::cuda_tensor<derived_t>

Subclassed by vortex::endpoint::detail::cuda_device_tensor_impl< T, radial_format_executor_t, radial_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_impl< T, stack_format_executor_t, stack_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_host_tensor_impl< T, stack_format_executor_t, stack_cuda_host_tensor< T > >

Public Functions

inline cuda_tensor_impl(std::shared_ptr<executor_t> executor, std::vector<size_t> shape, std::shared_ptr<spdlog::logger> log = nullptr)

template<size_t N>
inline cuda_tensor_impl(std::shared_ptr<executor_t> executor, const std::array<size_t, N> &shape, std::shared_ptr<spdlog::logger> log = nullptr)

inline cuda_tensor_impl(std::shared_ptr<executor_t> executor, std::shared_ptr<sync::lockable<tensor_t>> tensor, std::shared_ptr<spdlog::logger> log = nullptr)

inline const auto &tensor() const

inline const auto &executor() const

Protected Attributes

std::shared_ptr<executor_t> _executor

std::optional<std::vector<size_t>> _shape

std::shared_ptr<sync::lockable<tensor_t>> _tensor

std::shared_ptr<spdlog::logger> _log

Private Functions

inline void _check()

template<typename T>
struct vortex::cuda::detail::cuda_type_t

Public Types

using type = T

template<>
struct vortex::cuda::detail::cuda_type_t<std::complex<double>>

Public Types

using type = cuda_complex_t<double>::type

template<>
struct vortex::cuda::detail::cuda_type_t<std::complex<float>>

Public Types

using type = cuda_complex_t<float>::type

template<typename T>
class vortex::cuda::detail::cuda_view_t : public vortex::cuda::cuda_viewable<cuda_view_t<T>>, public vortex::detail::dynamic_view_t<T, fixed_cuda_view_t<T>, cuda_view_t<T>>

Public Types

using base_t = vortex::detail::dynamic_view_t<T, fixed_cuda_view_t<T>, cuda_view_t<T>>

Public Functions

inline cuda_view_t()

template<typename S1>
inline cuda_view_t(T *data, const S1 &shape, const cuda::device_t &device)

template<typename O, typename S1>
inline cuda_view_t(const O &other, T *data, const S1 &shape)

template<typename V>
inline cuda_view_t(const cuda_viewable<V> &other)

inline const auto &device() const

inline bool is_accessible() const

inline bool is_accessible(device_t device2) const

Protected Attributes

cuda::device_t _device

template<typename derived_t>
class cuda_viewable : public vortex::viewable<derived_t>

Subclassed by vortex::alazar::alazar_viewable< alazar_view_t< T > >, vortex::alazar::alazar_viewable< derived_t >

struct vortex::engine::engine_config_t::cycle_t

Public Members

std::vector<node> subgraph

template<typename channel_t_>
struct vortex::io::daqmx_config_t

Public Types

using channel_t = channel_t_

Public Functions

inline size_t &samples_per_second()

inline const size_t &samples_per_second() const

inline size_t &samples_per_block()

inline const size_t &samples_per_block() const

inline void validate()

Public Members

std::string name = "unknown"

std::string source = "pfi0"

daqmx::edge_t edge = daqmx::edge_t::rising

size_t divisor = 1

struct vortex::io::daqmx_config_t::[anonymous] clock

size_t blocks_to_buffer = 1

seconds readwrite_timeout = seconds(1)

std::vector<channel_t> channels

bool stop_on_error = true

Protected Functions

inline bool _port_name_contains_multiple_channels(const std::string &s)

Protected Attributes

size_t _samples_per_block = 100

size_t _samples_per_second   = 100'000

template<typename config_t_>
class vortex::io::daqmx_io_t

Public Types

using config_t = config_t_

using analog_element_t = float64

using digital_element_t = uInt32

using callback_t = std::function<void(size_t, std::exception_ptr)>

Public Functions

inline daqmx_io_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~daqmx_io_t()

inline const config_t &config() const

inline void initialize(config_t config)

template<typename ...Vs, typename = typename std::enable_if_t<(is_cpu_viewable<Vs> && ...)>>
inline size_t next(size_t count, const std::tuple<Vs...> &streams)

template<typename ...Vs, typename = typename std::enable_if_t<(is_cpu_viewable<Vs> && ...)>>
inline size_t next(size_t id, size_t count, const std::tuple<Vs...> &streams)

template<typename ...Vs, typename = typename std::enable_if_t<(is_cpu_viewable<Vs> && ...)>>
inline void next_async(size_t count, const std::tuple<Vs...> &streams, callback_t &&callback)

template<typename ...Vs, typename = typename std::enable_if_t<(is_cpu_viewable<Vs> && ...)>>
inline void next_async(size_t id, size_t count, const std::tuple<Vs...> &streams, callback_t &&callback)

inline void prepare()

inline void start()

inline void stop()

inline bool running() const

Protected Types

using job_t = std::function<void()>

Protected Functions

template<typename ...Vs>
inline auto _next_block(size_t id, size_t count, const std::tuple<Vs...> &streams)

template<typename ...Vs>
inline size_t _process_block(size_t id, size_t count, const std::tuple<Vs...> &streams)

inline void _worker_loop()

template<typename B>
inline void _check_buffer(const B &buffer, size_t samples, size_t channel)

Protected Attributes

std::shared_ptr<spdlog::logger> _log

std::atomic_bool _abort = false

sync::queue_t<job_t> _jobs

std::thread _worker

xt::xtensor<analog_element_t, 2> _analog_output_buffer

xt::xtensor<analog_element_t, 2> _analog_input_buffer

xt::xtensor<digital_element_t, 2> _digital_output_buffer

xt::xtensor<digital_element_t, 2> _digital_input_buffer

daqmx::daqmx_t _daqmx

std::mutex _mutex

config_t _config

class vortex::daqmx::daqmx_t

Public Functions

daqmx_t()

daqmx_t(std::string task_name)

daqmx_t(const daqmx_t &other) = delete

daqmx_t &operator=(const daqmx_t &other) = delete

daqmx_t(daqmx_t &&other)

daqmx_t &operator=(daqmx_t &&other)

virtual ~daqmx_t()

void create_digital_output(const std::string &line_name)

void create_digital_input(const std::string &line_name)

void create_analog_voltage_output(const std::string &port_name, float64 min, float64 max)

void create_analog_voltage_input(const std::string &port_name, float64 min, float64 max, terminal_t terminal = terminal_t::referenced)

void configure_sample_clock(const std::string &source, sample_mode_t sample_mode, size_t samples_per_second, size_t samples_per_channel, size_t divisor = 1, edge_t edge = edge_t::rising)

void set_output_buffer_size(size_t samples_per_channel)

void set_input_buffer_size(size_t samples_per_channel)

void set_regeneration(bool enable)

void write_analog(size_t samples_per_channel, const xt::xtensor<float64, 2> &buffer)

void write_analog(size_t samples_per_channel, const xt::xtensor<float64, 2> &buffer, const seconds &timeout)

void write_digital(size_t samples_per_channel, const xt::xtensor<uInt32, 2> &buffer)

void write_digital(size_t samples_per_channel, const xt::xtensor<uInt32, 2> &buffer, const seconds &timeout)

void read_analog(size_t samples_per_channel, xt::xtensor<float64, 2> &buffer)

void read_analog(size_t samples_per_channel, xt::xtensor<float64, 2> &buffer, const seconds &timeout)

void read_digital(size_t samples_per_channel, xt::xtensor<uInt32, 2> &buffer)

void read_digital(size_t samples_per_channel, xt::xtensor<uInt32, 2> &buffer, const seconds &timeout)

void start_task()

void stop_task()

void clear_task()

bool valid() const

const std::string &name() const

TaskHandle handle() const

bool running() const

Protected Attributes

TaskHandle _task = nullptr

std::string _name

bool _started = false

template<typename T>
struct datatype_helper

template<>
struct vortex::storage::detail::datatype_helper<double>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<float>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<int16_t>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<int32_t>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<int64_t>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<int8_t>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<uint16_t>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<uint32_t>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<uint64_t>

Public Static Functions

static inline auto value()

template<>
struct vortex::storage::detail::datatype_helper<uint8_t>

Public Static Functions

static inline auto value()

struct vortex::endpoint::detail::default_volume_shape_t

Public Static Functions

template<typename config_t>
static inline auto shape(const config_t &config)

struct detail

template<typename T>
class device_array_t

struct vortex::acquire::detail::alazar_config_t::device_t

Public Members

U32 system_index = 1

U32 board_index = 1

struct vortex::io::channel::digital_input_t : public vortex::io::detail::digital_t

Public Functions

inline void apply(daqmx::daqmx_t &daqmx, std::shared_ptr<spdlog::logger> &log) const

struct vortex::io::channel::digital_output_t : public vortex::io::detail::digital_t

Public Functions

inline void apply(daqmx::daqmx_t &daqmx, std::shared_ptr<spdlog::logger> &log) const

struct vortex::io::detail::digital_t : public vortex::io::detail::base_t

Subclassed by vortex::io::channel::digital_input_t, vortex::io::channel::digital_output_t

Public Functions

inline bool operator==(const digital_t &o) const

Public Members

std::string line_name

Public Static Attributes

static const size_t max_bits = 32

struct vortex::engine::engine_config_t::divide_t

Public Members

std::vector<node> subgraph

struct vortex::acquire::dso_config_t

Subclassed by vortex::acquire::detail::alazar_config_t< clock_t, trigger_t, option_t >, vortex::acquire::detail::alazar_config_t< clock_t_, trigger_t_, option_t_ >

Public Functions

inline virtual ~dso_config_t()

inline virtual std::array<size_t, 3> shape() const

inline virtual size_t channels_per_sample() const

inline size_t &samples_per_record()

inline const size_t &samples_per_record() const

inline size_t &records_per_block()

inline const size_t &records_per_block() const

Protected Attributes

size_t _samples_per_record = 1024

size_t _records_per_block = 1000

struct vortex::alazar::board_t::info_t::dsp_t

Public Functions

double max_trigger_rate_per_fft_length(U32 fft_length) const

Public Members

dsp_module_handle handle

U32 type

U16 major

U16 minor

struct vortex::alazar::board_t::info_t::dsp_t::[anonymous] version

U32 max_record_length

channel_t supported_channels

bool fft_time_domain_supported = false

bool fft_subtractor_supported = false

template<typename T>
struct dtype

template<>
struct vortex::storage::detail::numpy::dtype<double>

Public Static Attributes

static constexpr static auto name   = "float64"

template<>
struct vortex::storage::detail::numpy::dtype<float>

Public Static Attributes

static constexpr static auto name   = "float32"

template<>
struct vortex::storage::detail::numpy::dtype<int16_t>

Public Static Attributes

static constexpr static auto name   = "int16"

template<>
struct vortex::storage::detail::numpy::dtype<int32_t>

Public Static Attributes

static constexpr static auto name   = "int32"

template<>
struct vortex::storage::detail::numpy::dtype<int64_t>

Public Static Attributes

static constexpr static auto name   = "int64"

template<>
struct vortex::storage::detail::numpy::dtype<int8_t>

Public Static Attributes

static constexpr static auto name   = "int8"

template<>
struct vortex::storage::detail::numpy::dtype<std::complex<double>>

Public Static Attributes

static constexpr static auto name   = "complex128"

template<>
struct vortex::storage::detail::numpy::dtype<std::complex<float>>

Public Static Attributes

static constexpr static auto name   = "complex64"

template<>
struct vortex::storage::detail::numpy::dtype<uint16_t>

Public Static Attributes

static constexpr static auto name   = "uint16"

template<>
struct vortex::storage::detail::numpy::dtype<uint32_t>

Public Static Attributes

static constexpr static auto name   = "uint32"

template<>
struct vortex::storage::detail::numpy::dtype<uint64_t>

Public Static Attributes

static constexpr static auto name   = "uint64"

template<>
struct vortex::storage::detail::numpy::dtype<uint8_t>

Public Static Attributes

static constexpr static auto name   = "uint8"

struct vortex::acquire::trigger::dual_external_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

Public Members

size_t range_millivolts = 2500

std::array<float, 2> level_ratios = {0.09f, 0.09f}

size_t delay_samples = 80

alazar::trigger_slope_t initial_slope = alazar::trigger_slope_t::positive

alazar::coupling_t coupling = alazar::coupling_t::DC

template<typename T, typename static_t_, typename dynamic_t>
class vortex::detail::dynamic_view_t : public vortex::detail::base_view_t<T, xt::svector<size_t>, xt::svector<ptrdiff_t>>

Public Functions

inline dynamic_view_t()

template<typename S1>
inline dynamic_view_t(T *data, const S1 &shape)

template<size_t N>
inline dynamic_view_t(const static_t<N> &other)

inline auto index(std::initializer_list<size_t> idx) const

inline auto range(size_t end) const

inline auto range(size_t start, size_t end) const

inline auto morph_right(size_t dim) const

inline bool is_contiguous() const

Protected Types

using base_t = base_view_t<T, xt::svector<size_t>, xt::svector<ptrdiff_t>>

template<size_t N2>
using static_t = typename static_t_::template of_dimension<N2>

struct vortex::engine::adapter::endpoint : public vortex::engine::adapter<block_t>::detail::base

Public Members

std::function<void(const std::optional<cuda::device_t>&, const std::optional<cuda::device_t>&)> allocate

std::function<void(const format::format_plan_t&, const block_t&, const spectra_stream_t&, const ascan_stream_t&)> handle

struct vortex::engine::detail::engine_plan_t::endpoint_plan

Public Members

size_t endpoint_index

template<typename block_t_, typename warp_t>
struct vortex::engine::engine_config_t

Public Types

using block_t = block_t_

using adapter = adapter<block_t>

using node = std::variant<divide_t, cycle_t, typename adapter::processor>

using process_graph_t = node

using format_graph_t = std::set<typename adapter::formatter>

using endpoint_graph_t = std::set<typename adapter::endpoint>

Public Functions

template<typename A, typename... Ns, typename = typename std::enable_if_t<std::tuple_size_v<std::tuple<Ns...>> >= 2> inline void add_acquisition (std::shared_ptr< A > &acquire, bool preload, bool master, Ns &&... nodes)

template<typename A, typename P>
inline void add_acquisition(std::shared_ptr<A> &acquire, bool preload, bool master, std::shared_ptr<P> &process)

template<typename A>
inline void add_acquisition(std::shared_ptr<A> &acquire, bool preload, bool master, process_graph_t graph)

template<typename P, typename ...Fs>
inline void add_processor(const std::shared_ptr<P> &processor, const std::shared_ptr<Fs>&... formatters)

template<typename F, typename ...EPs>
inline void add_formatter(const std::shared_ptr<F> &formatter, const std::shared_ptr<EPs>&... endpoints)

template<typename T>
inline void add_io(std::shared_ptr<T> &io, bool preload = true, bool master = false, size_t lead_samples = 0)

template<typename T>
inline void add_io(std::shared_ptr<T> &io, io_config options)

inline void validate()

Public Members

size_t records_per_block = 1000

size_t blocks_to_allocate = 4

size_t preload_count = 2

size_t blocks_to_acquire = 0

size_t post_scan_records = 0

warp_t scanner_warp = {scan::warp::none_t{}}

size_t galvo_output_channels = 2

size_t galvo_input_channels = 2

std::map<typename adapter::acquisition, acquire_config> acquisitions

std::map<typename adapter::processor, processor_config> processors

std::map<typename adapter::formatter, formatter_config> formatters

std::map<typename adapter::io, io_config> ios

Public Static Functions

template<typename ...Ns>
static inline auto divide(Ns&... nodes)

template<typename ...Ns>
static inline auto cycle(Ns&... nodes)

Protected Static Functions

template<typename N, typename ...Ns, typename = typename std::enable_if_t<std::is_same_v<std::decay_t<N>, node> || std::is_same_v<std::decay_t<N>, divide_t> || std::is_same_v<std::decay_t<N>, cycle_t>>>
static inline void _bind_to_graph(std::vector<node> &subgraph, N &head, Ns&... rest)

template<typename P, typename ...Ns>
static inline void _bind_to_graph(std::vector<node> &subgraph, std::shared_ptr<P> &head, Ns&... rest)

static inline void _bind_to_graph(std::vector<node> &subgraph)

template<typename T, typename ...Ts>
static inline auto _bind_to_set(format_graph_t &graph, T &head, Ts&... rest)

template<typename T, typename ...Ts>
static inline auto _bind_to_set(endpoint_graph_t &graph, T &head, Ts&... rest)

template<typename G>
static inline auto _bind_to_set(G&)

template<typename block_t>
struct vortex::engine::detail::engine_plan_t

Public Types

using adapter = adapter<block_t>

using spectra_stream_t = typename block_t::spectra_stream_t

using acquire_element_t = typename block_t::acquire_element_t

using spectra_stream_factory_t = typename adapter::spectra_stream_factory_t

using ascan_stream_factory_t = typename adapter::ascan_stream_factory_t

using shape_t = typename adapter::shape_t

using channels_t = std::vector<size_t>

using processor_sets = std::vector<std::vector<typename adapter::processor>>

Public Functions

inline engine_plan_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline size_t allocate_spectra_buffer(bool elide, const typename adapter::acquisition &acquisition, spectra_stream_factory_t factory, const std::optional<cuda::device_t> &device, channels_t channels, shape_t shape)

inline size_t allocate_ascan_buffer(ascan_stream_factory_t factory, const std::optional<cuda::device_t> &device, shape_t shape)

Public Members

std::map<typename adapter::acquisition, acquire_plan> acquire

std::map<typename adapter::processor, process_plan> process

std::map<typename adapter::formatter, format_plan> format

std::map<typename adapter::endpoint, endpoint_plan> endpoint

std::vector<spectra_buffer> spectra_buffers

std::vector<ascan_buffer> ascan_buffers

size_t format_counter = 0

size_t endpoint_counter = 0

std::map<cuda::device_t, cuda::stream_t> transfer_streams

std::vector<size_t> io_lead_samples

std::shared_ptr<spdlog::logger> _log

struct vortex::engine::engine_t::engine_status

Public Members

bool active

size_t dispatched_blocks = 0

size_t inflight_blocks = 0

double dispatch_completion = 0

double block_utilization = 0

template<typename config_t_>
class vortex::engine::engine_t

Public Types

using config_t = config_t_

using block_t = typename config_t::block_t

using adapter = adapter<block_t>

using master_plan_t = detail::engine_plan_t<block_t>

using acquisition_t = typename adapter::acquisition

using processor_t = typename adapter::processor

using io_t = typename adapter::io

using formatter_t = typename adapter::formatter

using endpoint_t = typename adapter::endpoint

using acquire_element_t = typename block_t::acquire_element_t

using process_element_t = typename block_t::process_element_t

using analog_element_t = typename block_t::analog_element_t

using digital_elment_t = typename block_t::digital_element_t

using process_sets = typename master_plan_t::processor_sets

using scan_queue_t = scan_queue_t<typename block_t::scan_stream_t::element_t, typename block_t::marker_t>

Public Functions

inline engine_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~engine_t()

inline void initialize(config_t config)

inline auto &scan_queue()

inline const auto &scan_queue() const

inline void prepare()

inline void start()

inline void wait() const

inline auto wait_for(const std::chrono::high_resolution_clock::duration &timeout) const

inline auto done() const

inline void stop()

inline auto status() const

inline const auto &config() const

inline void set_event_callback(event_callback_t &&callback)

inline const auto &event_callback() const

inline void set_job_callback(job_callback_t &&callback)

inline const auto &job_callback() const

Protected Types

using session_t = detail::session_t<config_t, master_plan_t, scan_queue_t, block_t>

Protected Functions

inline auto _expand_acquire_graph(typename config_t::node &c)

inline void _plan_acquire(const acquisition_t &acquire, typename config_t::node &nodes)

inline std::optional<cuda::device_t> _choose_endpoint_device(const endpoint_t &endpoint)

inline void _handle_abort() const

template<typename stream_t, typename descriptor_t>
inline void _allocate_stream(const descriptor_t &desc, stream_t &stream_)

inline void _allocate_blocks()

inline void _release_blocks()

Protected Attributes

std::shared_ptr<scan_queue_t> _scan_queue

std::shared_ptr<spdlog::logger> _log

std::vector<block_t> _blocks

config_t _config

master_plan_t _master_plan

event_callback_t _event_callback

job_callback_t _job_callback

mutable std::exception_ptr _aborting_exception

std::optional<session_t> _session

mutable std::mutex _mutex

template<typename stream_t>
struct vortex::detail::stream_element_is_same::evaluate

Public Static Attributes

static constexpr auto value = std::is_same_v<element_t, typename std::decay_t<stream_t>::derived_t::element_t>

struct vortex::format::action::event

Public Functions

auto operator<=>(const event&) const = default

Public Members

counter_t sample

counter_t id

struct vortex::marker::event : public vortex::marker::detail::base

Public Types

using eid_t = size_t

Public Functions

inline event()

inline event(counter_t sample)

inline event(counter_t sample_, eid_t id_)

auto operator<=>(const event&) const = default

Public Members

eid_t id

class vortex::cuda::event_t

Public Functions

event_t(unsigned int flags = cudaEventDefault)

~event_t()

void sync() const

bool done() const

void record()

void record(const stream_t &stream)

float elapsed(const event_t &start) const

const cudaEvent_t &handle() const

Protected Attributes

cudaEvent_t _event

class vortex::sync::event_t

Public Functions

event_t(bool s = false)

void set()

void unset()

void change(bool s)

bool status() const

bool wait() const

bool wait_for(const std::chrono::high_resolution_clock::duration &timeout) const

void finish()

Protected Attributes

std::atomic_bool _set

std::atomic_bool _finished

mutable std::mutex _mutex

mutable std::condition_variable _cv

class exception : public std::runtime_error

Subclassed by vortex::alazar::buffer_not_ready, vortex::alazar::buffer_overflow, vortex::alazar::unsupported_operation, vortex::alazar::wait_timeout

class exception : public std::runtime_error

class exception : public std::runtime_error

Subclassed by vortex::daqmx::buffer_overflow, vortex::daqmx::buffer_underflow, vortex::daqmx::incomplete_operation, vortex::daqmx::unsupported_operation, vortex::daqmx::wait_timeout

struct vortex::acquire::clock::external_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

Public Members

float level_ratio = 0.5f

alazar::coupling_t coupling = alazar::coupling_t::AC

alazar::clock_edge_t edge = alazar::clock_edge_t::rising

bool dual = false

template<typename T>
class vortex::cuda::fft_plan_t

Public Functions

inline fft_plan_t()

inline ~fft_plan_t()

fft_plan_t(const fft_plan_t&) = delete

fft_plan_t &operator=(const fft_plan_t&) = delete

inline fft_plan_t(fft_plan_t &&o)

inline fft_plan_t &operator=(fft_plan_t &&o)

inline void plan_many(int count, std::vector<int> &n, const stream_t *stream = nullptr)

inline void forward(const cuda_view_t<complex<T>> &in, const cuda_view_t<complex<T>> &out)

inline void inverse(const cuda_view_t<complex<T>> &in, const cuda_view_t<complex<T>> &out)

inline void execute(const cuda_view_t<complex<T>> &in, const cuda_view_t<complex<T>> &out, bool forward)

inline void destroy()

inline bool valid() const

Protected Functions

inline void _reset()

Protected Attributes

cufftHandle _plan = 0

template<typename T>
class vortex::fft::fftw_plan_t

Public Types

using real_t = T

using complex_t = std::complex<T>

Public Functions

inline fftw_plan_t()

inline ~fftw_plan_t()

fftw_plan_t(const fftw_plan_t&) = delete

fftw_plan_t &operator=(const fftw_plan_t&) = delete

inline fftw_plan_t(fftw_plan_t &&o)

inline fftw_plan_t &operator=(fftw_plan_t &&o)

inline void forward(int count, const std::pair<int, int> stride, const std::pair<int, int> &offset, const std::vector<int> &n, complex_t *in, complex_t *out, int flags = FFTW_PRESERVE_INPUT | FFTW_MEASURE)

inline void inverse(int count, const std::pair<int, int> stride, const std::pair<int, int> &offset, const std::vector<int> &n, complex_t *in, complex_t *out, int flags = FFTW_PRESERVE_INPUT | FFTW_MEASURE)

inline void create(bool forward, int count, const std::pair<int, int> stride, const std::pair<int, int> &offset, const std::vector<int> &n, complex_t *in, complex_t *out, int flags = FFTW_PRESERVE_INPUT | FFTW_MEASURE)

inline void execute()

inline void execute(complex_t *in, complex_t *out)

inline void destroy()

inline bool valid() const

Protected Functions

inline std::string _shape_to_string(const std::vector<int> &n)

inline void _reset()

Protected Attributes

fftw_plan _plan = nullptr

template<typename output_element_t_, typename config_t_>
class vortex::acquire::file_acquisition_t

Public Types

using config_t = config_t_

using output_element_t = output_element_t_

using callback_t = std::function<void(size_t, std::exception_ptr)>

Public Functions

inline file_acquisition_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~file_acquisition_t()

inline void initialize(config_t config)

inline const config_t &config() const

inline void prepare()

inline void start()

inline void stop()

template<typename V>
inline size_t next(const cpu_viewable<V> &buffer)

template<typename V>
inline size_t next(size_t id, const cpu_viewable<V> &buffer)

template<typename V>
inline void next_async(const cpu_viewable<V> &buffer, callback_t &&callback)

template<typename V>
inline void next_async(size_t id, const cpu_viewable<V> &buffer, callback_t &&callback)

Protected Functions

inline auto _load(size_t id, const fixed_cpu_view_t<output_element_t, 3> &buffer)

Protected Attributes

config_t _config

std::ifstream _in

std::shared_ptr<spdlog::logger> _log

struct vortex::acquire::file_config_t : public vortex::acquire::null_config_t

Public Members

std::string path

bool loop = true

struct vortex::format::action::finish_scan

Public Functions

auto operator<=>(const finish_scan&) const = default

Public Members

counter_t sample

size_t scan_index

struct vortex::format::action::finish_segment

Public Functions

auto operator<=>(const finish_segment&) const = default

Public Members

counter_t sample

size_t scan_index

size_t volume_index

size_t segment_index_buffer

struct vortex::format::action::finish_volume

Public Functions

auto operator<=>(const finish_volume&) const = default

Public Members

counter_t sample

size_t scan_index

size_t volume_index

template<typename T>
struct fixed_alazar_view_t

template<typename T>
struct fixed_cpu_view_t

template<typename T>
struct fixed_cuda_view_t

template<typename T = uintmax_t, typename index_t = uint8_t>
struct vortex::marker::flags_t

Public Functions

inline flags_t()

inline flags_t(T flags_)

inline void set(index_t idx)

inline void set()

inline void clear(index_t idx)

inline void clear()

inline bool matches(const flags_t &o) const

auto operator<=>(const flags_t&) const = default

Public Members

T value

Public Static Functions

static inline bool matches(const flags_t &a, const flags_t &b)

static inline flags_t all()

static inline flags_t none()

static inline constexpr auto max_unique()

struct vortex::engine::detail::engine_plan_t::format_plan

Public Members

size_t format_index

struct vortex::format::format_planner_config_t

Public Types

using flags_t = marker::segment_boundary::flags_t

Public Functions

inline auto &segments_per_volume()

inline const auto &segments_per_volume() const

inline auto &records_per_segment()

inline const auto &records_per_segment() const

Public Members

std::array<size_t, 2> shape

flags_t mask = flags_t::all()

bool strip_inactive = true

bool adapt_shape = true

template<typename config_t_>
class vortex::format::format_planner_t

Public Types

using config_t = config_t_

Public Functions

inline format_planner_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline const config_t &config() const

inline void initialize(config_t config)

template<typename markers_t>
inline auto next(size_t block_sample, size_t block_length, const markers_t &markers)

template<typename markers_t>
inline void next(format_plan_t &plan, size_t block_sample, size_t block_length, const markers_t &markers)

inline auto finish()

inline void finish(format_plan_t &plan)

inline void reset()

inline const auto &segments_per_volume() const

inline const auto &records_per_segment() const

Protected Functions

inline auto &segments_per_volume()

inline auto &records_per_segment()

inline auto _accepted()

template<typename marker_t>
inline auto _finish_prior(format_plan_t &plan, size_t block_sample, const marker_t &m, size_t active_sample)

inline auto _setup_load(format_plan_t &plan, size_t block_sample, size_t start_sample, size_t end_sample)

inline void _handle_scan(format_plan_t &plan, size_t index)

inline void _handle_volume(format_plan_t &plan, size_t index)

inline void _handle_segment(format_plan_t &plan, size_t index)

Protected Attributes

std::shared_ptr<spdlog::logger> _log

counter_t _active_sample

size_t _buffer_segment_position

ptrdiff_t _buffer_record_position

bool _segment_reversed

bool _segment_accepted

bool _volume_accepted

bool _scan_accepted

bool _lines_active

std::optional<size_t> _last_scan_index

std::optional<size_t> _last_volume_index

std::optional<size_t> _last_segment_index

std::array<size_t, 2> _shape

config_t _config

struct vortex::engine::adapter::formatter : public vortex::engine::adapter<block_t>::detail::base

Public Members

std::function<format::format_plan_t(const block_t&)> next

std::function<void(format::format_plan_t&)> finish

struct vortex::engine::engine_config_t::formatter_config

Public Members

endpoint_graph_t graph

template<typename T, size_t N, typename warp_t>
struct vortex::scan::detail::grid_waypoints_t

Public Functions

inline grid_waypoints_t()

Public Members

xt_point<T, N> offset

T angle = 0

std::array<range_t<T>, N> extents

std::array<size_t, N> shape

warp_t warp = {warp::none_t{}}

struct vortex::storage::hdf5_stack_config_t

Public Functions

inline auto &channels_per_sample()

inline const auto &channels_per_sample() const

inline auto &samples_per_ascan()

inline const auto &samples_per_ascan() const

inline auto &ascans_per_bscan()

inline const auto &ascans_per_bscan() const

inline auto &bscans_per_volume()

inline const auto &bscans_per_volume() const

inline auto volume_shape() const

inline std::array<size_t, 3> bscan_shape() const

inline std::array<size_t, 2> ascan_shape() const

Public Members

std::string path

std::array<size_t, 4> shape = {{0, 0, 0, 1}}

hdf5_stack_header_t header = hdf5_stack_header_t::none

int compression_level = 0

template<typename element_t_, typename config_t_>
class vortex::storage::hdf5_stack_t

Public Types

using config_t = config_t_

using element_t = element_t_

Public Functions

inline hdf5_stack_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~hdf5_stack_t()

inline const auto &config() const

inline virtual void open(config_t config)

template<typename V>
inline void write_partial_bscan(size_t bscan_index, size_t ascan_index, const cpu_viewable<V> &raw_chunk_)

template<typename V>
inline void write_multi_bscan(size_t index, const cpu_viewable<V> &raw_chunk_)

template<typename V>
inline void write_volume(const cpu_viewable<V> &volume)

inline virtual void advance_volume(bool allocate = true)

inline virtual void close()

inline virtual bool ready() const

Public Static Attributes

static constexpr static auto matlab_userblock_size   = 512

Protected Functions

inline void _resize()

Protected Attributes

size_t _volume_index

size_t _volume_allocate

std::shared_ptr<spdlog::logger> _log

config_t _config

H5::H5File _file

H5::DataSet _dataset

struct vortex::alazar::detail::impedance_input_range_t

Public Members

size_t impedance_ohms

std::vector<size_t> input_range_millivolts

struct vortex::marker::inactive_lines : public vortex::marker::detail::base

Public Functions

auto operator<=>(const inactive_lines&) const = default

class incompatible_shape : public std::invalid_argument

class incomplete_operation : public vortex::daqmx::exception

template<size_t I, size_t N, typename T, typename ...Args>
struct vortex::detail::tuple::index_by_pointer

Public Static Functions

static inline ptrdiff_t call(const std::tuple<Args...> &t, const T &val)

template<size_t N, typename T, typename ...Args>
struct vortex::detail::tuple::index_by_pointer<N, N, T, Args...>

Public Static Functions

static inline ptrdiff_t call(const std::tuple<Args...> &t, const T &val)

template<size_t I, size_t N, typename T, typename ...Args>
struct vortex::detail::tuple::index_by_value

Public Static Functions

static inline ptrdiff_t call(const std::tuple<Args...> &t, T &&val)

template<size_t N, typename T, typename ...Args>
struct vortex::detail::tuple::index_by_value<N, N, T, Args...>

Public Static Functions

static inline ptrdiff_t call(const std::tuple<Args...> &t, T &&val)

struct vortex::alazar::board_t::info_t

Public Functions

size_t max_sampling_rate() const

U32 nearest_aligned_samples_per_record(double target_samples_per_record) const

U32 smallest_aligned_samples_per_record(double target_samples_per_record) const

const dsp_t &find_fft_info() const

Public Members

U32 system_index

U32 board_index

U32 serial_number

U32 calibration_date

U32 onboard_memory_size

U8 bits_per_sample

struct vortex::alazar::board_t::info_t::type_t type

struct vortex::alazar::board_t::info_t::pcie_t pcie

std::vector<size_t> supported_sampling_rates

std::vector<input_combination_t> supported_input_combinations

U32 max_pretrigger_samples

U32 min_samples_per_record

U32 sample_alignment_divisor

bool dual_port_memory

bool dual_edge_sampling

std::vector<dsp_t> dsp

struct vortex::alazar::board_t::info_t::input_combination_t

Public Members

size_t impedance_ohms

size_t input_range_millivolts

struct vortex::acquire::input_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

inline size_t bytes_per_sample() const

inline bool operator==(const input_t &o) const

Public Members

alazar::channel_t channel = alazar::channel_t::B

size_t range_millivolts = 400

size_t impedance_ohms = 50

alazar::coupling_t coupling = alazar::coupling_t::DC

struct vortex::acquire::clock::internal_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

Public Members

size_t samples_per_second   = 800'000'000

struct vortex::engine::adapter::io : public vortex::engine::adapter<block_t>::detail::base

Public Types

using callback_t = std::function<void(size_t, std::exception_ptr)>

Public Members

std::function<void()> prepare

std::function<void()> start

std::function<void()> stop

std::function<void(block_t&, io_stream_ts, callback_t&&)> next_async

struct vortex::engine::engine_config_t::io_config

Public Members

bool preload = true

bool master = false

size_t lead_samples = 0

struct vortex::engine::detail::session_t::job_t

Public Members

size_t id = 0

block_t *block

size_t count = 0

std::exception_ptr error

bool last = false

size_t format_ascan_index

size_t format_spectra_index

timing_t timing

struct vortex::process::cpu_processor_t::job_t

Public Members

block_t *block

callback_t callback

struct vortex::util::completion_worker_pool_t::job_t

Public Functions

inline job_t()

inline job_t(work_t &&work_, callback_t &&callback_)

Public Members

work_t work

std::invoke_result_t<work_t> result

sync::event_t done

callback_t callback

struct left_t

template<typename T>
struct vortex::motion::limits_t

Public Members

range_t<T> position = {-10, 10}

T velocity = 100

T acceleration   = 10'000

template<typename T>
struct vortex::copy::transform::linear_t

Public Functions

inline linear_t()

inline linear_t(T scale_, T offset_)

Public Members

T scale

T offset

template<typename T>
struct vortex::sync::lockable : public T

Public Functions

inline lockable(lockable &&o)

inline lockable &operator=(lockable &&o)

inline auto &mutex() const

Private Members

mutable std::shared_mutex _mutex

template<typename T, typename marker_t>
struct vortex::scan::manual_pattern_t

Public Types

using segment_t = segment_t<T, marker_t>

Public Functions

template<typename ...Args>
inline const auto &to_pattern(const Args&...) const

Public Members

std::vector<segment_t> pattern

struct vortex::storage::marker_log_config_t

Public Members

std::string path

bool binary = false

bool buffering = false

struct vortex::endpoint::marker_log_storage

Public Functions

inline marker_log_storage(std::shared_ptr<marker_log_t> storage)

inline void allocate(const std::optional<cuda::device_t> spectra, const std::optional<cuda::device_t> &ascans)

template<typename block_t, typename spectra_stream_t, typename ascan_stream_t>
inline void handle(const format::format_plan_t &plan, const block_t &block, const spectra_stream_t &spectra, const ascan_stream_t &ascans)

inline const auto &storage() const

Protected Attributes

std::shared_ptr<marker_log_t> _storage

template<typename ...Ts>
struct vortex::marker::marker_t : public std::variant<Ts...>

Public Types

using flags_t = marker::detail::base::flags_t

template<typename config_t_>
class vortex::storage::marker::marker_v0_t

Public Types

using config_t = config_t_

Public Functions

inline marker_v0_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~marker_v0_t()

inline const auto &config() const

inline virtual void open(config_t config)

template<typename marker_t>
inline void write(const std::vector<marker_t> &markers)

inline void close()

inline auto ready() const

Protected Functions

template<typename marker_t>
inline void _write_text(std::ostream &out, const marker_t &marker)

template<typename marker_t>
inline void _write_binary(std::ostream &out, const marker_t &marker)

Protected Attributes

std::shared_ptr<spdlog::logger> _log

config_t _config

std::ofstream _out

template<typename T, size_t N, size_t M>
struct vortex::format::detail::matrix_t

Public Members

T v[N][M]

struct none_t

struct none_t

struct vortex::scan::warp::none_t

Public Functions

template<typename E1, typename E2>
inline void forward(xt::xexpression<E1> &in, xt::xexpression<E2> &out) const

template<typename E1, typename E2>
inline void inverse(xt::xexpression<E1> &in, xt::xexpression<E2> &out) const

template<typename E>
inline void forward(xt::xexpression<E> &inout) const

template<typename E>
inline void inverse(xt::xexpression<E> &inout) const

struct vortex::endpoint::detail::notify

Subclassed by vortex::endpoint::cuda_tensor< derived_t >, vortex::endpoint::detail::cpu_tensor< cpu_tensor_t< T >, stack_format_executor_t >, vortex::endpoint::detail::stack_storage< broct_format_executor_t, broct_storage_t, detail::select_ascans_t, detail::broct_volume_shape_t >, vortex::endpoint::detail::stack_storage< stack_format_executor_t, simple_stack_t< element_t >, detail::select_ascans_t >, vortex::endpoint::detail::stack_storage< stack_format_executor_t, simple_stack_t< element_t >, detail::select_spectra_t >, vortex::endpoint::cuda_tensor< derived_t_ >, vortex::endpoint::detail::cpu_tensor< tensor_t, executor_t >, vortex::endpoint::detail::stack_storage< executor_t, storage_t, source_selector_t, volume_shape_t >

Public Types

using update_callback_t = std::function<void()>

using aggregate_segment_callback_t = std::function<void(std::vector<size_t>)>

using segment_callback_t = std::function<void(counter_t, size_t, size_t, size_t)>

using volume_callback_t = std::function<void(counter_t, size_t, size_t)>

using scan_callback_t = std::function<void(counter_t, size_t)>

using event_callback_t = std::function<void(counter_t, size_t)>

Public Members

update_callback_t update_callback

aggregate_segment_callback_t aggregate_segment_callback

segment_callback_t segment_callback

volume_callback_t volume_callback

scan_callback_t scan_callback

event_callback_t event_callback

Protected Functions

inline void _default(std::shared_ptr<spdlog::logger> log, std::vector<size_t> &segments, const format::format_action_t &action)

template<typename Callback, typename ...Args>
inline void _notify(std::shared_ptr<spdlog::logger> log, const Callback &callback, Args&&... args)

struct vortex::endpoint::null

Public Functions

inline void allocate(const std::optional<cuda::device_t> spectra, const std::optional<cuda::device_t> &ascans)

template<typename block_t, typename spectra_stream_t, typename ascan_stream_t>
inline void handle(const format::format_plan_t &plan, const block_t &block, const spectra_stream_t &spectra, const ascan_stream_t &ascans)

template<typename output_element_t_, typename config_t_>
class vortex::acquire::null_acquisition_t

Public Types

using config_t = config_t_

using output_element_t = output_element_t_

using callback_t = std::function<void(size_t, std::exception_ptr)>

Public Functions

inline void initialize(config_t config)

inline const config_t &config() const

inline void prepare()

inline void start()

inline void stop()

template<typename V>
inline size_t next(const viewable<V> &buffer)

template<typename V>
inline size_t next(size_t id, const viewable<V> &buffer)

template<typename V>
inline void next_async(const viewable<V> &buffer, callback_t &&callback)

template<typename V>
inline void next_async(size_t id, const viewable<V> &buffer, callback_t &&callback)

Protected Attributes

config_t _config

struct vortex::acquire::null_config_t

Subclassed by vortex::acquire::file_config_t

Public Functions

inline std::array<size_t, 3> shape() const

inline size_t &channels_per_sample()

inline const size_t &channels_per_sample() const

inline size_t &samples_per_record()

inline const size_t &samples_per_record() const

inline size_t &records_per_block()

inline const size_t &records_per_block() const

Protected Attributes

size_t _samples_per_record = 1024

size_t _records_per_block = 1000

size_t _channels_per_sample = 1

struct vortex::io::null_config_t

Public Functions

inline void validate()

template<typename config_t_>
class vortex::io::null_io_t

Public Types

using config_t = config_t_

using callback_t = std::function<void(size_t, std::exception_ptr)>

Public Functions

inline void prepare()

inline void start()

inline void stop()

inline const config_t &config() const

inline void initialize(config_t config)

template<typename ...Vs>
inline size_t next(size_t count, const std::tuple<Vs...> &streams)

template<typename ...Vs>
inline size_t next(size_t id, size_t count, const std::tuple<Vs...> &streams)

template<typename ...Vs>
inline void next_async(size_t count, const std::tuple<Vs...> &streams, callback_t &&callback)

template<typename ...Vs>
inline void next_async(size_t id, size_t count, const std::tuple<Vs...> &streams, callback_t &&callback)

Protected Attributes

config_t _config

template<typename config_t_>
class vortex::process::null_processor_t : public vortex::process::processor_t<config_t_>

Public Types

using config_t = config_t_

Public Functions

inline virtual void initialize(config_t config)

Protected Attributes

config_t _config

template<typename T>
struct vortex::scan::null_waypoints_t

Public Functions

inline xt::xtensor<T, 3> to_waypoints() const

struct vortex::acquire::option::oct_ignore_bad_clock_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

inline bool operator==(const oct_ignore_bad_clock_t &o) const

Public Members

double good_seconds = 4.95e-6

double bad_seconds = 4.95e-6

template<size_t N>
class vortex::alazar::detail::fixed_alazar_view_t::of_dimension : public vortex::alazar::alazar_viewable<of_dimension<N>>, public vortex::detail::static_view_t<T, N, fixed_alazar_view_t<T>, alazar_view_t<T>>

Public Types

using base_t = vortex::detail::static_view_t<T, N, fixed_alazar_view_t<T>, alazar_view_t<T>>

Public Functions

inline of_dimension()

template<typename S1>
inline of_dimension(T *data, const S1 &shape, const cuda::device_t &device, const HANDLE &handle)

template<typename O, typename S1>
inline of_dimension(const O &other, T *data, const S1 &shape)

template<typename V>
inline of_dimension(const alazar_viewable<V> &other)

inline const auto &device() const

Protected Attributes

cuda::device_t _device

HANDLE _handle

template<size_t N>
class vortex::cuda::detail::fixed_cuda_view_t::of_dimension : public vortex::cuda::cuda_viewable<of_dimension<N>>, public vortex::detail::static_view_t<T, N, fixed_cuda_view_t<T>, cuda_view_t<T>>

Public Types

using base_t = vortex::detail::static_view_t<T, N, fixed_cuda_view_t<T>, cuda_view_t<T>>

Public Functions

inline of_dimension()

template<typename S1>
inline of_dimension(T *data, const S1 &shape, const cuda::device_t &device)

template<typename O, typename S1>
inline of_dimension(const O &other, T *data, const S1 &shape)

template<typename V>
inline of_dimension(const cuda_viewable<V> &other)

inline const auto &device() const

Protected Attributes

cuda::device_t _device

template<size_t N>
class vortex::detail::fixed_cpu_view_t::of_dimension : public vortex::cpu_viewable<of_dimension<N>>, public vortex::detail::static_view_t<T, N, fixed_cpu_view_t<T>, cpu_view_t<T>>

Public Types

using base_t = detail::static_view_t<T, N, fixed_cpu_view_t<T>, cpu_view_t<T>>

Public Functions

template<typename O, typename S1>
inline of_dimension(const O &other, T *data, const S1 &shape)

template<typename V>
inline of_dimension(const cpu_viewable<V> &other)

inline auto to_xt()

inline auto to_xt() const

struct vortex::engine::scan_queue_t::online_scan_queue_t

Public Functions

inline online_scan_queue_t(scan_queue_t &sq)

template<typename S>
inline void append(std::shared_ptr<S> &scan, scan_callback_t &&callback = {}, marker::scan_boundary marker = {})

Protected Attributes

scan_queue_t &_sq

template<typename ...Ts>
struct vortex::acquire::option_t : public std::variant<Ts...>

Public Types

using base_t = std::variant<Ts...>

Public Functions

template<typename board_t>
inline auto apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

inline bool operator==(const option_t &o) const

struct vortex::copy::options_block2block_t

Public Members

size_t count = 0

size_t src_offset = 0

size_t dst_offset = 0

slice_t sample_slice = slice::none_t{}

transform_t sample_transform = transform::none_t{}

struct vortex::copy::options_block2volume_t

Public Members

size_t count = 0

size_t src_offset = 0

std::array<size_t, 2> dst_offset = {{0, 0}}

bool reverse = false

slice_t sample_slice = slice::none_t{}

transform_t sample_transform = transform::none_t{}

struct vortex::motion::options_t

Public Members

bool include_initial = false

bool include_final = false

bool bypass_limits_check = false

template<class ...Ts>
struct overloaded : public vortex::Ts

template<typename T, typename waypoints_t, typename pattern_t>
struct vortex::scan::detail::patterned_config_factory_t : public vortex::scan::detail::segmented_config_t<T>, public waypoints_t, public pattern_t

Public Functions

inline auto to_segments() const

template<typename T, typename marker_t, typename config_t>
class vortex::scan::detail::patterned_scan_factory_t : public vortex::scan::detail::segmented_scan_t<T, marker_t, config_t>

Public Types

using base_t = segmented_scan_t<T, marker_t, config_t>

using segment_t = segment_t<T, marker_t>

Public Functions

inline void initialize(const config_t &config)

inline void change(const config_t &new_config, bool restart = false)

inline void change(const config_t &new_config, bool restart, marker::event::eid_t event_id)

Protected Functions

inline auto _check_and_apply_config(const config_t &new_config)

struct vortex::alazar::board_t::info_t::pcie_t

Public Members

U32 speed

U32 width

double speed_gbps

template<typename T>
struct position_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl<T, position_format_executor_t, position_cuda_device_tensor<T>>

struct vortex::format::position_format_executor_config_t : public vortex::format::stack_format_executor_config_t

Public Functions

inline position_format_executor_config_t()

inline void set()

inline void set(std::array<double, 2> pitch)

inline void set(std::array<double, 2> pitch, std::array<double, 2> offset)

inline void set(std::array<double, 2> pitch, std::array<double, 2> offset, double angle)

Public Members

xt::xtensor_fixed<double, xt::xshape<2, 3>> transform

bool use_target_position = true

std::array<size_t, 2> channels = {0, 1}

template<typename config_t_>
class vortex::format::position_format_executor_t

Public Types

using config_t = config_t_

Public Functions

inline const config_t &config() const

inline void initialize(config_t config)

Protected Attributes

config_t _config

struct post_scan

struct vortex::scan::detail::segmented_scan_t::post_segment

Public Members

counter_t index

struct vortex::scan::detail::segmented_scan_t::pre_scan

Public Members

point_t position

point_t velocity

counter_t index

bool include_start = false

bool fully_buffered = false

struct vortex::scan::detail::segmented_scan_t::pre_segment

Public Members

counter_t index

bool inactive = true

struct vortex::engine::detail::engine_plan_t::process_plan

Public Members

cuda::event_t start

cuda::event_t done

size_t input_index

size_t output_index

struct vortex::engine::adapter::processor : public vortex::engine::adapter<block_t>::detail::base

Public Types

using callback_t = std::function<void(std::exception_ptr)>

Public Members

std::function< std::optional< cuda::device_t >)> device

std::function<ascan_stream_factory_t()> stream_factory

std::function<shape_t()> output_shape

std::function<shape_t()> input_shape

std::function<size_t()> channel

std::function<void(block_t&, const spectra_stream_t&, ascan_stream_t&, cuda::event_t*, cuda::event_t*, callback_t&&)> next_async

struct vortex::engine::engine_config_t::processor_config

Public Members

format_graph_t graph

template<typename T>
struct vortex::process::processor_config_t

Subclassed by vortex::process::cuda_processor_config_t< T >

Public Types

using element_t = T

Public Functions

inline virtual ~processor_config_t()

inline std::array<size_t, 3> input_shape() const

inline size_t &records_per_block()

inline const size_t &records_per_block() const

inline size_t &samples_per_record()

inline const size_t &samples_per_record() const

inline std::array<size_t, 3> output_shape() const

inline size_t &ascans_per_block()

inline const size_t &ascans_per_block() const

inline size_t samples_per_ascan() const

inline virtual void validate()

Public Members

size_t channel = 0

size_t average_window = 0

xt::xtensor<std::complex<T>, 1> spectral_filter

xt::xtensor<T, 1> resampling_samples

bool enable_log10 = true

bool enable_ifft = true

Protected Attributes

size_t _ascans_per_block = 1000

size_t _samples_per_record = 1000

template<typename config_t>
class vortex::process::processor_t

Public Functions

inline const auto &config() const

Protected Attributes

config_t _config

template<typename T>
class vortex::sync::queue_t

Public Functions

inline void push(T o, size_t limit = 0, bool drop = true)

inline bool pop(T &o, bool wait = true)

inline bool peek(const std::function<bool(T&)> &accessor, bool wait = true)

inline void clear()

inline void finish()

Protected Attributes

std::atomic_bool _finished = false

std::condition_variable _push_cv

std::condition_variable _pop_cv

std::mutex _mutex

std::queue<T> _queue

template<typename T>
struct radial_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_impl<T, radial_format_executor_t, radial_cuda_device_tensor<T>>

struct vortex::format::radial_format_executor_config_t : public vortex::format::stack_format_executor_config_t

Public Functions

inline auto &x_extent()

inline const auto &x_extent() const

inline auto &y_extent()

inline const auto &y_extent() const

inline auto &radial_extent()

inline const auto &radial_extent() const

inline auto &angular_extent()

inline const auto &angular_extent() const

inline auto &radial_segments_per_volume()

inline const auto &radial_segments_per_volume() const

inline auto &radial_records_per_segment()

inline const auto &radial_records_per_segment() const

Public Members

std::array<range_t<double>, 2> volume_xy_extent

std::array<range_t<double>, 2> segment_rt_extent

std::array<size_t, 2> radial_shape

template<typename config_t_>
class vortex::format::radial_format_executor_t

Public Types

using config_t = config_t_

Public Functions

inline const config_t &config() const

inline void initialize(config_t config)

Protected Attributes

config_t _config

template<typename T, typename warp_t>
struct vortex::scan::radial_waypoints_t : public vortex::scan::detail::xy_waypoints_t<T, warp_t>

Public Types

using base_t = detail::xy_waypoints_t<T, warp_t>

Public Functions

inline radial_waypoints_t()

inline void set_half_evenly_spaced(size_t n)

inline void set_evenly_spaced(size_t n)

inline void set_aiming()

inline auto to_waypoints() const

inline range_t<T> &volume_extent()

inline const range_t<T> &volume_extent() const

inline size_t &bscans_per_volume()

inline const size_t &bscans_per_volume() const

template<typename T>
struct vortex::range_t

Public Functions

inline T &min()

inline const T &min() const

inline T length() const

inline T &max()

inline const T &max() const

inline bool contains(const T &o)

inline bool operator==(const range_t &o) const

Public Members

std::array<T, 2> val = {-std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity()}

Public Static Functions

static inline range_t symmetric(const T &o)

template<typename T, typename warp_t>
struct vortex::scan::raster_waypoints_t : public vortex::scan::detail::xy_waypoints_t<T, warp_t>

Public Types

using base_t = detail::xy_waypoints_t<T, warp_t>

Public Functions

inline raster_waypoints_t()

inline auto to_waypoints() const

struct vortex::scan::repeated_pattern_t::repeat_flags

Public Members

std::vector<flags_t> flags

struct vortex::scan::repeated_pattern_t::repeat_pack

Public Members

flags_t flags = flags_t::all()

template<typename marker_t>
struct vortex::scan::repeated_pattern_t

Public Types

using flags_t = typename marker_t::flags_t

using repeat_strategy_t = std::variant<repeat_pack, repeat_flags>

Public Functions

template<typename T>
inline auto to_pattern(const xt::xtensor<T, 3> &waypoints) const

template<typename T>
inline auto to_pattern(const std::vector<xt::xtensor<T, 2>> &waypoints) const

template<typename T, typename It>
inline auto to_pattern(const It &waypoints_begin, const It &waypoints_end) const

Public Members

repeat_strategy_t strategy = {repeat_pack{}}

size_t repeat_period = 2

size_t repeat_count = 3

repeat_strategy_t repeat_strategy = {repeat_pack{}}

bool bidirectional_segments = false

struct vortex::format::action::resize

Public Functions

inline auto &segments_per_volume()

inline const auto &segments_per_volume() const

inline auto &records_per_segment()

inline const auto &records_per_segment() const

inline auto operator==(const resize &rhs) const

Public Members

std::array<size_t, 2> shape

struct right_t

template<typename T>
struct vortex::engine::detail::session_t::ring_buffer

Public Members

xt::xtensor<T, 2> buffer

ring_buffer_xt ring

class vortex::ring_buffer_xt

Public Functions

inline ring_buffer_xt()

inline ring_buffer_xt(size_t head, size_t tail)

template<typename B1, typename B2>
inline void store(B1 &buffer, B2 &input, size_t count, size_t offset = 0)

template<typename B1, typename B2>
inline void load(B1 &buffer, B2 &output, size_t count, size_t offset = 0)

inline void reset(size_t head, size_t tail)

inline void clear()

inline const auto &head() const

inline const auto &tail() const

Protected Attributes

size_t _head

size_t _tail

struct vortex::marker::scan_boundary : public vortex::marker::detail::base

Public Functions

inline scan_boundary()

inline scan_boundary(counter_t sample, counter_t sequence, size_t volume_count_hint = 0)

inline scan_boundary(counter_t sample_, counter_t sequence_, size_t volume_count_hint_, flags_t flags_)

auto operator<=>(const scan_boundary&) const = default

Public Members

counter_t sequence

size_t volume_count_hint

flags_t flags

template<typename T>
struct vortex::scan::detail::scan_config_t

Subclassed by vortex::scan::detail::segmented_config_t< T >

Public Functions

inline auto sampling_interval() const

inline virtual void validate() const

Public Members

size_t channels_per_sample = 2

size_t samples_per_second   = 100'000

bool loop = true

bool consolidate = false

template<typename T, typename marker_t>
class vortex::engine::scan_queue_t

Public Types

enum event_t

Values:

enumerator start

enumerator finish

enumerator interrupt

enumerator abort

using element_t = T

using point_t = xt::xtensor<T, 1>

using array_t = xt::xtensor<T, 2>

using scan_callback_t = std::function<void(size_t, event_t)>

using empty_callback_t = std::function<void(online_scan_queue_t&)>

Public Functions

inline scan_queue_t()

inline scan_queue_t(counter_t sample, const point_t &position, const point_t &velocity)

inline void reset()

inline void reset(counter_t sample, const point_t &position, const point_t &velocity)

inline void rebase(counter_t sample)

template<typename S>
inline void append(std::shared_ptr<S> &scan, scan_callback_t &&callback = {}, marker::scan_boundary marker = {})

template<typename S>
inline void interrupt(std::shared_ptr<S> &scan, scan_callback_t &&callback = {}, marker::scan_boundary marker = {})

inline auto generate(std::vector<marker_t> &markers, const fixed_cpu_view_t<T, 2> &buffer, bool zero_order_hold = true)

inline void clear()

inline void set_empty_callback(empty_callback_t &&callback)

inline const auto &empty_callback() const

inline auto state() const

Protected Functions

template<typename S>
inline void _enqueue(std::shared_ptr<S> &scan, scan_callback_t &&callback, marker::scan_boundary marker)

inline void _restart()

inline void _reset(counter_t sample)

inline void _rebase(counter_t sample)

inline void _clear()

inline void _emit(event_t e)

Protected Attributes

std::optional<scan_t> _active_scan

std::queue<scan_t> _queue

bool _marked_inactive = false

bool _include_start = true

counter_t _last_sample

std::optional<point_t> _last_position

std::optional<point_t> _last_velocity

empty_callback_t _empty_callback

mutable std::mutex _mutex

struct vortex::engine::scan_queue_t::scan_t

Public Members

std::function<size_t(std::vector<marker_t>&, const fixed_cpu_view_t<T, 2>&)> generate

std::function< std::tuple< std::optional< point_t >, std::optional< point_t > >)> last

std::function<void(counter_t, point_t, point_t, bool)> restart

std::function<size_t()> channels_per_sample

scan_callback_t callback

marker::scan_boundary marker

template<typename T, typename marker_t_, typename config_t_>
class vortex::scan::detail::scan_t

Public Types

using element_t = T

using config_t = config_t_

using marker_t = marker_t_

using point_t = xt::xtensor<T, 1>

using array_t = xt::xtensor<T, 2>

Public Functions

inline scan_t()

inline scan_t(std::shared_ptr<spdlog::logger> log)

inline virtual ~scan_t()

inline const config_t &config() const

inline virtual void restart(counter_t sample)

inline void prepare()

inline void prepare(size_t count)

template<typename markers_t>
inline size_t next(markers_t &markers, const fixed_cpu_view_t<T, 2> &buffer)

inline auto last() const

inline virtual void consolidate()

inline virtual const array_t &scan_buffer()

inline virtual std::vector<marker_t> scan_markers()

Protected Functions

virtual bool _fully_buffered() = 0

virtual void _prepare_next_chunk() = 0

inline counter_t _next_unbuffered_sample()

inline counter_t _scan_buffer_initial_sample()

inline counter_t _stream_buffer_initial_sample()

inline size_t _stream_buffer_size()

inline size_t _scan_buffer_size()

inline void _consolidate(std::vector<array_t> &buffers)

inline void _discard_scan_buffer()

inline void _discard_stream_buffer()

inline void _shift_scan_markers(ptrdiff_t delta_samples)

inline void _split_scan_buffer(counter_t requested_sample)

inline void _shift_scan_to_stream()

inline void _shift_scan_to_stream(counter_t requested_sample)

inline virtual void _prepare()

inline virtual void _prepare(size_t count)

template<typename markers_t>
inline void _release(markers_t &output_markers, fixed_cpu_view_t<T, 2> output_buffer, size_t offset, std::vector<array_t> &buffers, std::vector<marker_t> &markers, size_t &released, size_t &needed, bool ephemeral)

Protected Attributes

std::shared_ptr<spdlog::logger> _log

std::vector<marker_t> _stream_markers

std::vector<marker_t> _scan_markers

std::vector<array_t> _stream_buffers

std::vector<array_t> _scan_buffers

counter_t _buffer_sample_base

counter_t _active_sample

counter_t _scans_completed = 0

std::pair<std::optional<point_t>, std::optional<point_t>> _last_samples

mutable std::mutex _mutex

config_t _config

Private Functions

inline size_t _length(const std::vector<array_t> &buffer)

struct vortex::sync::event_t::scoped_set_t

Public Functions

inline scoped_set_t(event_t &event_)

inline ~scoped_set_t()

Public Members

event_t &event

struct vortex::marker::segment_boundary : public vortex::marker::detail::base

Public Functions

inline segment_boundary()

inline segment_boundary(counter_t sample, counter_t sequence, bool reversed)

inline segment_boundary(counter_t sample, counter_t sequence, counter_t index_in_volume, bool reversed, size_t record_count_hint = 0)

inline segment_boundary(counter_t sample_, counter_t sequence_, counter_t index_in_volume_, bool reversed_, size_t record_count_hint_, flags_t flags_)

auto operator<=>(const segment_boundary&) const = default

Public Members

counter_t sequence

counter_t index_in_volume

bool reversed

size_t record_count_hint

flags_t flags

template<typename T, typename marker_t>
struct vortex::scan::segment_t

Public Types

using array_t = xt::xtensor<T, 2>

using point_t = xt::xtensor<T, 1>

Public Functions

inline point_t entry_position() const

inline point_t exit_position() const

inline point_t entry_velocity(size_t samples_per_second) const

inline point_t exit_velocity(size_t samples_per_second) const

Public Members

array_t position

std::optional<point_t> entry_delta

std::optional<point_t> exit_delta

std::vector<marker_t> markers

template<typename T>
struct vortex::scan::detail::segmented_config_t : public vortex::scan::detail::scan_config_t<T>

Subclassed by vortex::scan::detail::patterned_config_factory_t< T, waypoints_t, pattern_t >

Public Types

using base_t = scan_config_t<T>

Public Functions

inline segmented_config_t()

inline virtual void validate() const override

Public Members

std::vector<motion::limits_t<T>> limits

bool bypass_limits_check = false

size_t channels_per_sample

template<typename T, typename marker_t_, typename config_t>
class vortex::scan::detail::segmented_scan_t : public vortex::scan::detail::scan_t<T, marker_t_, config_t>

Public Types

using base_t = scan_t<T, marker_t_, config_t>

using marker_t = marker_t_

using segment_t = segment_t<T, marker_t>

using array_t = typename segment_t::array_t

using point_t = typename segment_t::point_t

Public Functions

inline void restart()

inline void restart(counter_t sample, point_t position, point_t velocity, bool include_start)

inline const std::vector<segment_t> &scan_segments() const

Protected Types

using state_t = std::variant<pre_scan, pre_segment, post_segment, post_scan>

Protected Functions

inline virtual void _prepare_next_chunk() override

inline virtual bool _fully_buffered() override

inline virtual void _change_segments(std::vector<segment_t> new_segments, bool restart, std::optional<marker::event::eid_t> change_event_id = {})

inline virtual void _validate_segments(const config_t &cfg, const std::vector<segment_t> &segments)

Protected Attributes

state_t _state = post_scan{}

std::optional<size_t> _samples_per_scan

Private Functions

inline void _copy_and_update_markers(const std::vector<marker_t> &src, std::vector<marker_t> &dst, counter_t sample)

Private Members

std::optional<marker::event::eid_t> _change_event_id

bool _scan_interrupted = true

std::vector<array_t> _post_segments

std::vector<segment_t> _segments

struct vortex::endpoint::detail::select_ascans_t

Public Static Functions

template<typename spectra_stream_t, typename ascan_stream_t>
static inline const auto &select(const spectra_stream_t &spectra, const ascan_stream_t &ascans)

struct vortex::endpoint::detail::select_spectra_t

Public Static Functions

template<typename spectra_stream_t, typename ascan_stream_t>
static inline const auto &select(const spectra_stream_t &spectra, const ascan_stream_t &ascans)

template<typename marker_t>
struct vortex::scan::sequential_pattern_t

Public Types

using flags_t = typename marker_t::flags_t

Public Functions

template<typename T>
inline auto to_pattern(const xt::xtensor<T, 3> &waypoints) const

template<typename T>
inline auto to_pattern(const std::vector<xt::xtensor<T, 2>> &waypoints) const

template<typename T, typename It>
inline auto to_pattern(const It &waypoints_begin, const It &waypoints_end) const

Public Members

bool bidirectional_segments = false

bool bidirectional_volumes = false

flags_t flags = flags_t::all()

struct vortex::engine::session_status_t

Public Functions

inline auto available() const

inline auto progress() const

inline auto utilization() const

Public Members

size_t allocated

size_t inflight

size_t dispatched

size_t limit

template<typename config_t, typename master_plan_t, typename scan_queue_t, typename block_t>
class vortex::engine::detail::session_t

Public Types

using clock_t = std::chrono::high_resolution_clock

Public Functions

inline session_t(config_t &config, master_plan_t &master_plan, std::vector<block_t> &blocks, scan_queue_t &scan_queue, event_callback_t event_callback, job_callback_t job_callback, std::exception_ptr &aborting_exception, std::shared_ptr<spdlog::logger> log)

inline ~session_t()

inline auto done() const

inline void wait() const

inline bool wait_for(const std::chrono::high_resolution_clock::duration &timeout) const

inline void shutdown(bool interrupt = false)

inline auto status() const

Protected Functions

inline void _abort()

inline void _main_loop()

inline void _acquire_loop()

inline void _process_loop()

inline void _format_loop(size_t index, typename config_t::adapter::formatter format)

inline void _recycle_loop()

template<typename T>
inline auto _aggregate_sized(sync::aggregator_t<T> &aggregator, size_t index, T job)

template<typename T>
inline auto _push_unsized(sync::queue_t<T> &queue, T job)

template<typename T>
inline auto _push_unsized(std::vector<sync::queue_t<T>*> queues, T job)

inline void _prepare()

inline void _start(bool master, bool preload)

inline void _stop(bool master)

template<typename V1, typename V2>
inline cuda::stream_t &_choose_stream(const cpu_viewable<V1> &src_, const cuda::cuda_viewable<V2> &dst_)

template<typename V1, typename V2>
inline cuda::stream_t &_choose_stream(const cuda::cuda_viewable<V1> &src_, const viewable<V2> &dst_)

template<typename V1, typename V2>
inline cuda::stream_t &_choose_stream(const cpu_viewable<V1> &src_, const cpu_viewable<V2> &dst_)

template<typename V1, typename V2>
inline void _transfer(size_t channel, cuda::stream_t &stream, const viewable<V1> &src_, const viewable<V2> &dst_, cuda::event_t &done)

inline auto _number_of_acquire_tasks()

inline auto _number_of_format_tasks()

inline void _emit()

inline void _emit(std::exception_ptr error)

inline void _emit(event_t event, std::exception_ptr error = {})

inline auto _max_io_lead_delay() const

Protected Attributes

config_t &_config

master_plan_t &_master_plan

scan_queue_t &_scan_queue

event_callback_t _event_callback

job_callback_t _job_callback

std::exception_ptr &_aborting_exception

std::shared_ptr<spdlog::logger> _log

std::atomic_bool _interrupt = false

std::atomic_bool _shutdown = false

sync::event_t _dispatch

sync::event_t _complete

std::thread _main_thread

std::vector<std::thread> _workers

std::atomic<counter_t> _dispatch_sample = 0

std::atomic<size_t> _dispatch_index = 0

sync::queue_t<block_t*> _available_blocks

sync::aggregator_t<job_t> _acquired_jobs

std::map<typename config_t::adapter::formatter, sync::queue_t<job_t>> processed_jobs_per_format

sync::aggregator_t<job_t> finished_jobs

sync::counter_t _inflight

sync::counter_t _launch

std::unordered_map<size_t, ring_buffer<typename block_t::analog_element_t>> _galvo_target_ring_buffers

std::unordered_map<size_t, ring_buffer<typename block_t::digital_element_t>> _strobe_ring_buffers

struct vortex::simple::simple_engine_config_t

Public Types

using source_t = engine::source_t<double>

Public Members

alazar::channel_t input_channel = alazar::channel_t::B

alazar::channel_t clock_channel = alazar::channel_t::A

bool internal_clock = false

std::string broct_save_path

std::string sample_target_save_path

std::string sample_actual_save_path

source_t swept_source   = { 100'000, 1376, 0.50 }

double galvo_delay = 0.0

std::array<double, 2> dispersion = {{0, 0}}

size_t samples_per_ascan = 2752

size_t ascans_per_bscan = 500

size_t bscans_per_volume = 500

size_t blocks_to_acquire = 0

size_t blocks_to_allocate = 128

size_t ascans_per_block = 500

size_t preload_count = 4

size_t process_slots = 2

class vortex::simple::simple_engine_t

Public Types

using acquisition_t = alazar_acquisition_t

using processor_t = cuda_processor_t<acquisition_t::output_element_t, int8_t>

using io_t = daqmx_io_t

using engine_t = engine_t<acquisition_t::output_element_t, processor_t::output_element_t, io_t::analog_element_t, io_t::digital_element_t>

using callback_t = std::function<void(bool, std::vector<size_t>)>

Public Functions

inline simple_engine_t(std::string log_scope = "")

inline void initialize(simple_engine_config_t config)

template<typename S>
inline void append_scan(std::shared_ptr<S> &scan)

template<typename S>
inline void interrupt_scan(std::shared_ptr<S> &scan)

inline void start(callback_t callback = {})

inline void wait() const

inline bool wait_for(const std::chrono::high_resolution_clock::duration &timeout) const

inline void stop()

inline const auto &volume() const

Protected Attributes

acquisition_t::config_t _acquire_config

std::shared_ptr<acquisition_t> _acquire

processor_t::config_t _process_config

std::shared_ptr<processor_t> _process

io_t::config_t _io_out_config

io_t::config_t _io_in_config

std::shared_ptr<io_t> _io_out

std::shared_ptr<io_t> _io_in

std::shared_ptr<format_planner_t> _stack_format

std::shared_ptr<format_planner_t> _radial_format

stack_format_executor_t::config_t _stack_executor_config

radial_format_executor_t::config_t _radial_executor_config

std::shared_ptr<endpoint::stack_cuda_device_tensor<processor_t::output_element_t>> _stack_tensor_endpoint

std::shared_ptr<endpoint::radial_cuda_device_tensor<processor_t::output_element_t>> _radial_tensor_endpoint

broct_storage_t::config_t _broct_storage_config

broct_format_executor_t::config_t _broct_executor_config

std::shared_ptr<endpoint::broct_storage> _broct_storage_endpoint

stream_dump_t::config_t _sample_target_dump_config

stream_dump_t::config_t _sample_actual_dump_config

std::shared_ptr<endpoint::stream_dump_storage> _sample_target_endpoint

std::shared_ptr<endpoint::stream_dump_storage> _sample_actual_endpoint

std::shared_ptr<sync::lockable<cuda::cuda_device_tensor_t<int8_t>>> _volume

engine_t::config_t _engine_config

engine_t _engine

simple_engine_config_t _config

std::string _log_scope

struct vortex::storage::simple_stack_config_t

Public Functions

inline size_t &samples_per_ascan()

inline const size_t &samples_per_ascan() const

inline size_t &ascans_per_bscan()

inline const size_t &ascans_per_bscan() const

inline size_t &bscans_per_volume()

inline const size_t &bscans_per_volume() const

inline auto volume_shape() const

inline auto bscan_shape() const

Public Members

std::string path

std::array<size_t, 3> shape = {{0, 0, 0}}

bool buffering = false

simple_stack_header_t header = simple_stack_header_t::raw

template<typename element_t_, typename config_t_>
class vortex::storage::simple_stack_t

Public Types

using config_t = config_t_

using element_t = element_t_

Public Functions

inline simple_stack_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~simple_stack_t()

inline const auto &config() const

inline virtual void open(config_t config)

inline virtual void seek(size_t volume_index, size_t bscan_index)

template<typename V>
inline void write_partial_bscan(size_t bscan_index, size_t ascan_index, const cpu_viewable<V> &chunk_)

template<typename V>
inline void write_bscan(size_t index, const cpu_viewable<V> &bscan_)

template<typename V>
inline void write_multi_bscan(size_t index, const cpu_viewable<V> &chunk_)

template<typename V>
inline void write_volume(const cpu_viewable<V> &volume_)

inline virtual void advance_volume(bool allocate = true)

inline virtual void close()

inline virtual bool ready() const

Protected Functions

inline size_t _volume_size_in_bytes()

inline size_t _bscan_size_in_bytes()

inline size_t _ascan_size_in_bytes()

Protected Attributes

std::shared_ptr<spdlog::logger> _log

config_t _config

std::ofstream _out

size_t _header_position

size_t _volume_position

size_t _farthest_write_position

struct vortex::storage::simple_stream_config_t

Public Members

std::string path

bool buffering = false

simple_stream_header_t header = simple_stream_header_t::raw

template<typename element_t_, typename config_t_>
class vortex::storage::simple_stream_t

Public Types

using config_t = config_t_

using element_t = element_t_

Public Functions

inline simple_stream_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~simple_stream_t()

inline const auto &config() const

inline virtual void open(config_t config)

template<typename V, typename = std::enable_if_t<std::is_same_v<std::decay_t<typename V::element_t>, element_t>>>
inline void write(const cpu_viewable<V> &data_)

inline virtual void close()

inline virtual bool ready() const

Protected Attributes

std::shared_ptr<spdlog::logger> _log

config_t _config

std::ofstream _out

struct vortex::copy::slice::simple_t

Public Functions

inline simple_t()

inline simple_t(size_t stop)

inline simple_t(size_t start, size_t stop)

inline simple_t(size_t start_, size_t stop_, size_t step_)

inline size_t count() const

Public Members

size_t start

size_t stop

size_t step

struct vortex::acquire::trigger::single_external_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

Public Members

size_t range_millivolts = 2500

float level_ratio = 0.09f

size_t delay_samples = 80

alazar::trigger_slope_t slope = alazar::trigger_slope_t::positive

alazar::coupling_t coupling = alazar::coupling_t::DC

struct vortex::process::cpu_processor_t::slot_t

Public Members

xt::xtensor<output_element_t, 2> mag

xt::xtensor<std::complex<output_element_t>, 2> pre_fft

xt::xtensor<std::complex<output_element_t>, 2> post_fft

struct vortex::process::cuda_processor_t::slot_t

Public Members

size_t id

cuda::cuda_device_tensor_t<float_element_t> float_records

cuda::cuda_device_tensor_t<float_element_t> float_ascans

cuda::cuda_device_tensor_t<cuda::complex<float_element_t>> complex_ascans

cuda::event_t post_average

cuda::event_t done

cuda::stream_t stream

cuda::fft_plan_t<float_element_t> fft_plan

slot_t *prior = nullptr

template<typename T>
struct vortex::engine::source_t

Public Types

using element_t = T

Public Functions

inline bool has_clock() const

inline auto &clock_edges_seconds()

inline const auto &clock_edges_seconds() const

Public Members

size_t triggers_per_second   = 100'000

size_t clock_rising_edges_per_trigger = 1376

T duty_cycle = 0.5

xt::xtensor<T, 1> clock_rising_edges_seconds

struct vortex::engine::detail::engine_plan_t::spectra_buffer

Public Functions

inline bool operator==(const spectra_buffer &o) const

Public Members

adapter::acquisition acquisition

spectra_stream_factory_t factory

std::optional<cuda::device_t> device

channels_t channels

shape_t shape

template<typename element_t>
struct spectra_stack_storage : public vortex::endpoint::detail::stack_storage<stack_format_executor_t, simple_stack_t<element_t>, detail::select_spectra_t>

template<typename element_t>
struct spectra_stream_storage : public vortex::endpoint::detail::stream_storage<simple_stream_t<element_t>, detail::select_spectra_t>

template<typename T>
struct spiral_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_impl<T, radial_format_executor_t, radial_cuda_device_tensor<T>>

struct vortex::format::spiral_format_executor_config_t : public vortex::format::stack_format_executor_config_t

Public Functions

inline auto &x_extent()

inline const auto &x_extent() const

inline auto &y_extent()

inline const auto &y_extent() const

Public Members

std::array<range_t<double>, 2> volume_xy_extent

template<typename config_t_>
class vortex::format::spiral_format_executor_t

Public Types

using config_t = config_t_

Public Functions

inline const config_t &config() const

inline void initialize(config_t config)

Protected Attributes

config_t _config

template<typename T>
struct spiral_galvo_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl<T, spiral_format_executor_t, spiral_galvo_cuda_device_tensor<T>>

template<typename T, typename warp_t>
struct vortex::scan::spiral_waypoints_t : public vortex::scan::detail::xy_waypoints_t<T, warp_t>

Public Types

using base_t = detail::xy_waypoints_t<T, warp_t>

Public Functions

inline spiral_waypoints_t()

inline void set_hybrid_spiral(T frequency_in, T slew_in, T amp_in, T pitch_in, size_t samples_per_second)

inline auto to_waypoints() const

inline size_t &ascans_per_bscan()

inline const size_t &ascans_per_bscan() const

inline size_t &bscans_per_volume()

inline const size_t &bscans_per_volume() const

Public Members

T cav_omega

T clv_velocity

T amplitude

T pitch

T r_transition

T t_transition

T delta_t

T t_end

template<typename T>
struct stack_cpu_tensor : public vortex::endpoint::detail::cpu_tensor<cpu_tensor_t<T>, stack_format_executor_t>

template<typename T>
struct stack_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_impl<T, stack_format_executor_t, stack_cuda_device_tensor<T>>

template<typename T>
struct stack_cuda_host_tensor : public vortex::endpoint::detail::cuda_host_tensor_impl<T, stack_format_executor_t, stack_cuda_host_tensor<T>>

struct vortex::format::stack_format_executor_config_t

Subclassed by vortex::format::position_format_executor_config_t, vortex::format::radial_format_executor_config_t, vortex::format::spiral_format_executor_config_t

Public Members

bool erase_after_volume = false

copy::slice_t sample_slice = copy::slice::none_t{}

copy::transform_t sample_transform = copy::transform::none_t{}

template<typename config_t_>
class vortex::format::stack_format_executor_t

Public Types

using config_t = config_t_

Public Functions

inline const config_t &config() const

inline void initialize(config_t config)

template<typename V1, typename V2>
inline void execute(const cpu_viewable<V1> &volume_buffer, const cpu_viewable<V2> &block_buffer, const action::copy &action) const

Public Members

config_t _config

template<typename executor_t, typename storage_t, typename source_selector_t, typename volume_shape_t = default_volume_shape_t>
struct vortex::endpoint::detail::stack_storage : public vortex::endpoint::detail::notify

Public Functions

inline stack_storage(std::shared_ptr<storage_t> storage, std::shared_ptr<spdlog::logger> log)

inline stack_storage(std::shared_ptr<executor_t> executor, std::shared_ptr<storage_t> storage, std::shared_ptr<spdlog::logger> log)

inline stack_storage(std::shared_ptr<executor_t> executor, std::shared_ptr<storage_t> storage, buffer_strategy_t buffer_strategy, std::shared_ptr<spdlog::logger> log)

inline void allocate(const std::optional<cuda::device_t> spectra, const std::optional<cuda::device_t> &ascans)

template<typename block_t, typename spectra_stream_t, typename ascan_stream_t>
inline void handle(const format::format_plan_t &plan, const block_t &block, const spectra_stream_t &spectra, const ascan_stream_t &ascans)

inline const auto &executor() const

inline const auto &storage() const

inline const auto &stream() const

Protected Functions

template<typename shape_t>
inline auto _buffer_shape(const shape_t &in)

template<typename shape_t, typename block_t>
inline auto _buffer_shape(const shape_t &in, const block_t &block)

inline void _transfer(std::vector<size_t> segments)

inline void _transfer(const format::action::copy &a)

Protected Attributes

std::shared_ptr<executor_t> _executor

std::shared_ptr<storage_t> _storage

buffer_strategy_t _buffer_strategy

std::shared_ptr<spdlog::logger> _log

cuda::stream_t _stream

cuda::cuda_device_tensor_t<typename storage_t::element_t> _device_buffer

cuda::cuda_host_tensor_t<typename storage_t::element_t> _host_buffer

template<typename T>
struct vortex::motion::state_t

Public Members

T position

T velocity

template<typename T, size_t N, typename static_t_, typename dynamic_t>
class vortex::detail::static_view_t : public vortex::detail::base_view_t<T, std::array<size_t, N>, std::array<ptrdiff_t, N>>

Public Functions

inline static_view_t()

template<typename S1>
inline static_view_t(T *data, const S1 &shape)

inline static_view_t(const dynamic_t &other)

Protected Types

using base_t = base_view_t<T, std::array<size_t, N>, std::array<ptrdiff_t, N>>

template<size_t N2>
using static_t = typename static_t_::template of_dimension<N2>

struct vortex::storage::stream_dump_config_t

Public Members

std::string path

size_t stream = 0

size_t divisor = 1

bool buffering = false

struct vortex::endpoint::stream_dump_storage

Public Functions

inline stream_dump_storage(std::shared_ptr<stream_dump_t> storage, size_t lead_samples = 0)

inline void allocate(const std::optional<cuda::device_t> spectra, const std::optional<cuda::device_t> &ascans)

template<typename block_t, typename spectra_stream_t, typename ascan_stream_t>
inline void handle(const format::format_plan_t &plan, const block_t &block, const spectra_stream_t &spectra, const ascan_stream_t &ascans)

inline const auto &storage() const

Protected Attributes

size_t _lead_samples

std::shared_ptr<stream_dump_t> _storage

template<typename config_t_>
class vortex::storage::dump::stream_dump_v0_t

Public Types

using config_t = config_t_

Public Functions

inline stream_dump_v0_t(std::shared_ptr<spdlog::logger> log = nullptr)

inline virtual ~stream_dump_v0_t()

inline const auto &config() const

inline virtual void open(config_t config)

template<typename ...Vs, typename = typename std::enable_if_t<(is_cpu_viewable<Vs> && ...)>>
inline void next(size_t id, const std::tuple<Vs...> &streams)

inline void close()

inline auto ready() const

Protected Functions

template<typename V>
inline void _dump(const cpu_viewable<V> &buffer_)

Protected Attributes

std::shared_ptr<spdlog::logger> _log

config_t _config

std::ofstream _out

template<typename element_t>
struct stream_element_is_same

template<typename storage_t, typename source_selector_t>
struct vortex::endpoint::detail::stream_storage

Public Functions

inline stream_storage(std::shared_ptr<storage_t> storage)

inline void allocate(const std::optional<cuda::device_t> spectra, const std::optional<cuda::device_t> &ascans)

template<typename block_t, typename spectra_stream_t, typename ascan_stream_t>
inline void handle(const format::format_plan_t &plan, const block_t &block, const spectra_stream_t &spectra, const ascan_stream_t &ascans)

inline const auto &storage() const

Protected Functions

template<typename V>
inline void _handle(const cpu_viewable<V> &source)

template<typename V>
inline void _handle(const cuda::cuda_viewable<V> &source_)

Protected Attributes

cuda::stream_t _stream

cuda::cuda_host_tensor_t<typename storage_t::element_t> _host_buffer

std::shared_ptr<storage_t> _storage

class vortex::cuda::stream_t

Public Functions

stream_t(unsigned int flags = cudaStreamNonBlocking)

~stream_t()

stream_t(const stream_t&) = delete

stream_t &operator=(const stream_t&) = delete

stream_t(stream_t &&o)

stream_t &operator=(stream_t &&o)

const cudaStream_t &handle() const

void sync() const

void wait(const event_t &event) const

bool ready() const

Public Static Functions

static stream_t default_()

Protected Attributes

cudaStream_t _stream

class vortex::cuda::surface_t

Public Functions

surface_t()

template<typename T>
inline surface_t(const device_array_t<T> &array)

~surface_t()

surface_t(const surface_t&) = delete

surface_t &operator=(const surface_t&) = delete

surface_t(surface_t &&o)

surface_t &operator=(surface_t &&o)

bool valid() const

const cudaSurfaceObject_t &handle() const

Protected Attributes

cudaSurfaceObject_t _surface

struct vortex::storage::detail::matlab::tag

Public Functions

inline tag(std::ostream &out, uint32_t type, bool defer_padding = false)

inline ~tag()

inline void extend(size_t count)

Private Members

std::ostream &_out

bool _defer_padding

size_t _extra = 0

std::streampos _length_field

std::streampos _start

struct vortex::scan::warp::telecentric_t

Public Functions

inline telecentric_t()

inline telecentric_t(double galvo_lens_spacing_)

inline telecentric_t(double galvo_lens_spacing_, double scale_)

template<typename E1, typename E2>
inline auto forward(xt::xexpression<E1> &in, xt::xexpression<E2> &out) const

template<typename E1, typename E2>
inline auto inverse(xt::xexpression<E1> &in, xt::xexpression<E2> &out) const

template<typename E>
inline void forward(xt::xexpression<E> &inout) const

template<typename E>
inline void inverse(xt::xexpression<E> &inout) const

Public Members

double galvo_lens_spacing = 100

double scale = 2 * pi / 180

template<typename T>
class vortex::detail::tensor_impl_t

Subclassed by vortex::cuda::cuda_device_tensor_t< float_element_t >, vortex::cuda::cuda_device_tensor_t< double >, vortex::cuda::cuda_device_tensor_t< index_element_t >, vortex::cuda::cuda_device_tensor_t< uint8_t >, vortex::cuda::cuda_device_tensor_t< typename storage_t::element_t >, vortex::cuda::cuda_device_tensor_t< input_element_t >, vortex::cuda::cuda_device_tensor_t< cuda::complex< float_element_t > >, vortex::cuda::cuda_host_tensor_t< typename storage_t::element_t >, vortex::alazar::alazar_device_tensor_t< T >, vortex::cpu_tensor_t< T >, vortex::cuda::cuda_device_tensor_t< T >, vortex::cuda::cuda_host_tensor_t< T >

Public Functions

inline tensor_impl_t()

inline virtual ~tensor_impl_t()

tensor_impl_t(const tensor_impl_t&) = delete

tensor_impl_t &operator=(const tensor_impl_t&) = delete

inline tensor_impl_t(tensor_impl_t &&o)

inline tensor_impl_t &operator=(tensor_impl_t &&o)

template<typename shape_t>
inline void resize(const shape_t &s, bool shrink = true)

template<typename U>
inline void resize(std::initializer_list<U> &&s, bool shrink = true)

inline void shrink()

inline void clear()

inline auto data()

inline const auto data() const

inline auto count() const

virtual size_t underlying_count() const = 0

inline auto size_in_bytes() const

inline auto underlying_size_in_bytes() const

inline auto dimension() const

inline const auto &shape() const

inline auto shape(size_t idx) const

inline const auto &stride() const

inline auto stride(size_t idx) const

inline auto stride_in_bytes(size_t idx) const

inline auto stride_in_bytes() const

inline auto valid() const

Protected Functions

virtual void _allocate(size_t n) = 0

template<typename shape_t>
inline void _resize(const shape_t &s, bool shrink)

Protected Attributes

T *_ptr

xt::svector<size_t> _shape

xt::svector<ptrdiff_t> _stride

class vortex::cuda::texture_t

Public Functions

texture_t()

template<typename T>
inline texture_t(const device_array_t<T> &array, const cudaTextureDesc &texture_desc)

~texture_t()

texture_t(const texture_t&) = delete

texture_t &operator=(const texture_t&) = delete

texture_t(texture_t &&o)

texture_t &operator=(texture_t &&o)

bool valid() const

void reset()

const cudaTextureObject_t &handle() const

Protected Attributes

cudaTextureObject_t _texture

struct vortex::engine::timing_t

Public Members

vortex::time_t create

vortex::time_t service

vortex::time_t scan

vortex::time_t acquire

vortex::time_t process

vortex::time_t format

vortex::time_t recycle

template<typename ...Ts>
struct vortex::acquire::trigger_t : public std::variant<Ts...>

Public Functions

template<typename board_t>
inline auto apply(board_t &board, std::shared_ptr<spdlog::logger> &log) const

struct vortex::alazar::board_t::info_t::type_t

Public Members

U32 id

std::string model

template<typename T, typename ...Ts>
struct unique : public std::type_identity<T>

template<typename T, typename ...Ts>
struct unique : public std::type_identity<T>

template<typename ...Ts, typename U, typename ...Us>
struct unique<std::tuple<Ts...>, U, Us...> : public std::conditional_t<(std::is_same_v<U, Ts> || ...), unique<std::tuple<Ts...>, Us...>, unique<std::tuple<Ts..., U>, Us...>>

template<typename ...Ts, typename U, typename ...Us>
struct unique<std::variant<Ts...>, U, Us...> : public std::conditional_t<(std::is_same_v<U, Ts> || ...), unique<std::variant<Ts...>, Us...>, unique<std::variant<Ts..., U>, Us...>>

class unsupported_operation : public vortex::alazar::exception

class unsupported_operation : public vortex::daqmx::exception

class unsupported_view : public std::invalid_argument

template<typename derived_t_>
struct vortex::viewable

Subclassed by vortex::cpu_viewable< of_dimension< N > >, vortex::cpu_viewable< cpu_view_t< T > >, vortex::cuda::cuda_viewable< cuda_view_t< T > >, vortex::cuda::cuda_viewable< of_dimension< N > >

Public Types

using derived_t = derived_t_

Public Functions

inline auto &derived_cast()

inline const auto &derived_cast() const

struct vortex::marker::volume_boundary : public vortex::marker::detail::base

Public Functions

inline volume_boundary()

inline volume_boundary(counter_t sample, counter_t sequence, bool reversed)

inline volume_boundary(counter_t sample, counter_t sequence, counter_t index_in_scan, bool reversed, size_t segment_count_hint = 0)

inline volume_boundary(counter_t sample_, counter_t sequence_, counter_t index_in_scan_, bool reversed_, size_t segment_count_hint_, flags_t flags_)

auto operator<=>(const volume_boundary&) const = default

Public Members

counter_t sequence

counter_t index_in_scan

bool reversed

size_t segment_count_hint

flags_t flags

class wait_timeout : public vortex::alazar::exception

class wait_timeout : public vortex::daqmx::exception

template<typename ...Ts>
struct vortex::scan::warp_t : public std::variant<Ts...>

Public Functions

template<typename T1, typename T2>
inline auto forward(T1 &in, T2 &out) const

template<typename T1>
inline auto forward(T1 &inout) const

template<typename T1, typename T2>
inline auto inverse(T1 &in, T2 &out) const

template<typename T1>
inline auto inverse(T1 &inout) const

class vortex::util::worker_pool_t

Public Types

using setup_task_t = std::function<void(size_t)>

using task_t = std::function<void()>

Public Functions

inline worker_pool_t()

inline worker_pool_t(const std::string &name, size_t n = 0, setup_task_t &&setup_task = {}, std::shared_ptr<spdlog::logger> log = nullptr)

inline ~worker_pool_t()

inline void post(task_t &&task)

inline void wait_finish()

Protected Functions

inline void _loop(size_t id, std::string name)

Protected Attributes

std::vector<std::thread> _threads

vortex::sync::queue_t<task_t> _tasks

setup_task_t _setup_task

std::shared_ptr<spdlog::logger> _log

template<typename T, typename warp_t>
struct vortex::scan::detail::xy_waypoints_t : public vortex::scan::detail::grid_waypoints_t<T, 2, warp_t>

Subclassed by vortex::scan::radial_waypoints_t< T, warp_t >, vortex::scan::raster_waypoints_t< T, warp_t >, vortex::scan::spiral_waypoints_t< T, warp_t >

Public Types

using base_t = grid_waypoints_t<T, 2, warp_t>

Public Functions

inline range_t<T> &bscan_extent()

inline const range_t<T> &bscan_extent() const

inline range_t<T> &volume_extent()

inline const range_t<T> &volume_extent() const

inline range_t<T> &segment_extent()

inline const range_t<T> &segment_extent() const

inline size_t &ascans_per_bscan()

inline const size_t &ascans_per_bscan() const

inline size_t &bscans_per_volume()

inline const size_t &bscans_per_volume() const

inline size_t &samples_per_segment()

inline const size_t &samples_per_segment() const

inline size_t &segments_per_volume()

inline const size_t &segments_per_volume() const

inline xy_waypoints_t()

namespace std

namespace vortex

Typedefs

using null_acquire_config_t = acquire::null_config_t

template<typename T>
using null_acquisition_t = acquire::null_acquisition_t<T, null_acquire_config_t>

using file_config_t = acquire::file_config_t

template<typename T>
using file_acquisition_t = acquire::file_acquisition_t<T, file_config_t>

using counter_t = size_t

using delta_t = ptrdiff_t

using time_t = std::chrono::high_resolution_clock::time_point

template<typename T, size_t N>
using xt_point = xt::xtensor_fixed<double, xt::xshape<N>>

using seconds = std::chrono::duration<double>

using format_planner_t = format::format_planner_t<format::format_planner_config_t>

using stack_format_executor_t = format::stack_format_executor_t<format::stack_format_executor_config_t>

using broct_format_executor_t = format::broct_format_executor_t<format::stack_format_executor_config_t>

using position_format_executor_t = format::position_format_executor_t<format::position_format_executor_config_t>

using radial_format_executor_t = format::radial_format_executor_t<format::radial_format_executor_config_t>

using spiral_format_executor_t = format::spiral_format_executor_t<format::spiral_format_executor_config_t>

using null_io_config_t = io::null_config_t

using null_io_t = io::null_io_t<null_io_config_t>

using default_marker_t = vortex::marker::marker_t<marker::scan_boundary, marker::volume_boundary, marker::segment_boundary, marker::active_lines, marker::inactive_lines, marker::event>

template<typename T, size_t N>
using fixed_cpu_view_t = typename detail::fixed_cpu_view_t<T>::template of_dimension<N>

using null_processor_t = process::null_processor_t<process::processor_config_t<float>>

template<typename input_element_t, typename output_element_t>
using copy_processor_t = process::copy_processor_t<input_element_t, output_element_t, process::copy_processor_config_t>

using stream_dump_t = storage::stream_dump_t<storage::stream_dump_config_t>

using marker_log_t = storage::marker_log_t<storage::marker_log_config_t>

template<typename element_t>
using simple_stream_t = storage::simple_stream_t<element_t, storage::simple_stream_config_t>

template<typename element_t>
using simple_stack_t = storage::simple_stack_t<element_t, storage::simple_stack_config_t>

using broct_storage_t = storage::broct_storage_t<storage::broct_storage_config_t>

using interrupt_callback_t = std::function<void()>

template<typename ...Ts>
using unique_tuple = typename detail::tuple::unique<std::tuple<>, Ts...>::type

template<typename ...Ts>
using unique_variant = typename variant::detail::unique<std::variant<>, Ts...>::type

Functions

template<typename T>
auto xt_row(T &m, ptrdiff_t r)

template<typename T>
auto xt_row(const T &m, ptrdiff_t r)

template<typename T>
auto xt_col(T &m, ptrdiff_t c)

template<typename T>
auto xt_col(const T &m, ptrdiff_t c)

template<typename T>
T modulo(T a, T b)

template<typename logger_t, typename ...args_t>
void raise(std::shared_ptr<logger_t> logger, const std::string &msg, args_t... args)

template<typename logger_t, typename ...args_t>
void raise(std::shared_ptr<logger_t> logger, std::exception_ptr e = {})

std::string to_string(const std::exception &e, size_t level = 0)

std::string to_string(const std::exception_ptr &error)

template<typename container_t>
std::string join(const container_t &n, const std::string &sep)

template<typename container_t>
std::string shape_to_string(const container_t &n, const std::string &sep = " x ")

template<size_t N, typename T>
auto to_array(std::vector<T> in)

template<size_t N, typename T>
auto to_array(xt::svector<T> in)

template<typename S1, typename S2>
bool equal(const S1 &a, const S2 &b)

template<size_t N, typename Input>
auto tail(const Input &in)

template<typename stride_t, typename ...indexes_t>
size_t strided_offset(const stride_t &stride, indexes_t... vals)

template<typename S1, typename S2>
bool shape_is_compatible(const S1 &s1, const S2 &s2)

VORTEX_VIEW_AS_IMPL(is_cpu_viewable, cpu)

template<typename T>
auto view(cpu_tensor_t<T> &obj)

template<typename T>
auto view(const cpu_tensor_t<T> &obj)

template<typename T>
auto view(xt::xarray<T> &obj)

template<typename T>
auto view(const xt::xarray<T> &obj)

template<typename T, size_t N>
auto view(xt::xtensor<T, N> &obj)

template<typename T, size_t N>
auto view(const xt::xtensor<T, N> &obj)

template<typename T, typename U>
T downcast(U o)

template<typename T, typename = std::enable_if_t<std::is_enum_v<T>>>
static std::underlying_type_t<T> cast(const T &v)

bool check_keyboard_interrupt()

void _signal_handler(int sig)

void setup_keyboard_interrupt()

void setup_tcp_low_latency()

void setup_realtime()

void set_thread_name(const std::string &name)

void setup_keyboard_interrupt(interrupt_callback_t &&callback)

template<typename T, typename ...stream_ts, typename function_t>
inline void select(const std::tuple<stream_ts...> &streams, size_t index, function_t &&function)

template<typename T, typename ...stream_ts, typename function_t>
inline void select(const std::tuple<const stream_ts...> &streams, size_t index, function_t &&function)

template<typename ...stream_ts, typename function_t>
inline void select_any(const std::tuple<stream_ts...> &streams, size_t idx, function_t &&function)

template<typename ...stream_ts, typename function_t>
inline void select_any(const std::tuple<const stream_ts...> &streams, size_t idx, function_t &&function)

template<typename Tuple, typename Function>
inline void for_each_tuple(Tuple &&tup, Function &&func)

template<class Func, class Tuple, size_t N = 0>
inline void runtime_get(Tuple &tup, size_t idx, const Func &func)

template<class Func, class Tuple, size_t N = 0>
inline void runtime_get(const Tuple &tup, size_t idx, const Func &func)

template<typename Condition, class Func, class Tuple, size_t N = 0>
inline void runtime_get_condition(Tuple &tup, size_t idx, const Func &func)

template<typename Condition, class Func, class Tuple, size_t N = 0>
inline void runtime_get_condition(const Tuple &tup, size_t idx, const Func &func)

template<typename T, typename ...Args>
ptrdiff_t index_by_value(const std::tuple<Args...> &t, T &&val)

template<typename T, typename ...Args>
ptrdiff_t index_by_pointer(const std::tuple<Args...> &t, const T &val)

template<class ...Ts>
overloaded(Ts...) -> overloaded<Ts...>

template<typename T, typename F>
void for_each(T &list, F &&function)

template<typename T, typename F>
void for_each(const T &list, F &&function)

template<typename T, typename F>
void for_each_key(T &map, F &&function)

template<typename T, typename F>
void for_each_key(const T &map, F &&function)

template<typename T, typename F>
void for_each_key_value(T &map, F &&function)

template<typename T, typename F>
void for_each_key_value(const T &map, F &&function)

Variables

constexpr auto pi = std::numbers::pi

constexpr auto I = std::complex<double>(0, 1)

template<typename T>
constexpr bool is_cpu_viewable = std::is_base_of_v<cpu_viewable<std::decay_t<T>>, std::decay_t<T>>

template<typename T>
constexpr bool is_viewable = std::is_base_of_v<viewable<std::decay_t<T>>, std::decay_t<T>>

static sig_atomic_t _keyboard_interrupt = 0

static std::function<void()> _keyboard_callback

namespace vortex::acquire

Typedefs

using default_clock_t = clock_t<clock::internal_t, clock::external_t>

using default_trigger_t = trigger_t<trigger::single_external_t, trigger::dual_external_t>

using default_option_t = option_t<option::auxio_trigger_out_t, option::auxio_clock_out_t, option::auxio_pacer_out_t, option::oct_ignore_bad_clock_t>

namespace clock

namespace detail

namespace option

namespace trigger

namespace vortex::alazar

Typedefs

template<typename T, size_t N>
using fixed_alazar_view_t = typename detail::fixed_alazar_view_t<T>::template of_dimension<N>

Enums

enum channel_t

Values:

enumerator A

enumerator B

enumerator C

enumerator D

enumerator E

enumerator F

enumerator G

enumerator H

enumerator I

enumerator J

enumerator K

enumerator L

enumerator M

enumerator N

enumerator O

enumerator P

enum coupling_t

Values:

enumerator DC

enumerator AC

enum clock_edge_t

Values:

enumerator rising

enumerator falling

enum trigger_slope_t

Values:

enumerator positive

enumerator negative

Functions

channel_t operator~(const channel_t &a)

channel_t operator&(const channel_t &a, const channel_t &b)

channel_t operator|(const channel_t &a, const channel_t &b)

channel_t operator^(const channel_t &a, const channel_t &b)

channel_t &operator&=(channel_t &a, const channel_t &b)

channel_t &operator|=(channel_t &a, const channel_t &b)

channel_t &operator^=(channel_t &a, const channel_t &b)

std::string to_string(const channel_t &v)

std::string to_string(const coupling_t &v)

std::vector<board_t> enumerate()

std::string to_string(RETURN_CODE rc)

VORTEX_VIEW_AS_IMPL(is_alazar_viewable, alazar)

template<typename T>
auto view(alazar_device_tensor_t<T> &obj)

template<typename T>
auto view(const alazar_device_tensor_t<T> &obj)

Variables

constexpr size_t trigger_range_TTL = 0

constexpr U32 infinite_acquisition = 0x7fffffff

template<typename T>
constexpr bool is_alazar_viewable = std::is_base_of_v<alazar_viewable<std::decay_t<T>>, std::decay_t<T>>

namespace vortex::alazar::detail

Functions

template<typename ...Args>
const void handle_error(RETURN_CODE rc, const std::string &msg, Args... args)

_LOOKUP_DECLARE(lookup_board_kind, U32, std::string)

_LOOKUP_DECLARE(lookup_sampling_rate, size_t, U32)

_LOOKUP_DECLARE(lookup_supported_sampling_rate, std::string, std::vector<size_t>)

_LOOKUP_DECLARE(lookup_impedance_ohms, size_t, U32)

_LOOKUP_DECLARE(lookup_input_range_millivolts, size_t, U32)

_LOOKUP_DECLARE(lookup_supported_impedance_ohms_input_range_millivolts, std::string, std::vector<impedance_input_range_t>)

_LOOKUP_DECLARE(lookup_trigger_range_volts, size_t, U32)

_LOOKUP_DECLARE(lookup_alignment, std::string, const alignment_info_t&)

namespace vortex::copy

Typedefs

using slice_t = std::variant<copy::slice::none_t, copy::slice::simple_t>

using transform_t = std::variant<transform::none_t, transform::linear_t<double>>

Functions

template<typename V1, typename V2>
void copy(const cpu_viewable<V1> &src_, const cpu_viewable<V2> &dst_, const options_block2volume_t &options)

template<typename V1, typename V2>
void copy(const cpu_viewable<V1> &src_, const cpu_viewable<V2> &dst_, const options_block2block_t &options)

namespace vortex::copy::detail

Functions

template<typename E1, typename E2>
void copy_by_xtensor(const xt::xexpression<E1> &viewed_src_, xt::xexpression<E2> &viewed_dst_, const options_block2volume_t &o)

template<typename E1, typename E2>
void copy_by_xtensor(const xt::xexpression<E1> &viewed_src_, xt::xexpression<E2> &viewed_dst_, const options_block2block_t &o)

namespace vortex::copy::slice

Functions

inline auto to_simple(slice_t slice, size_t max)

namespace vortex::copy::transform

Functions

template<typename T>
inline auto to_linear(transform_t transform)

namespace vortex::cuda

Typedefs

using device_t = int

template<typename T>
using complex = typename detail::cuda_complex_t<T>::type

template<typename T>
using device_type = typename detail::cuda_type_t<T>::type

template<typename T, size_t N>
using fixed_cuda_view_t = typename detail::fixed_cuda_view_t<T>::template of_dimension<N>

Functions

template<typename V1, typename V2>
void copy(const viewable<V1> &src_, const viewable<V2> &dst_, const stream_t *stream = nullptr)

template<typename V1, typename V2>
void copy(const viewable<V1> &src, const viewable<V2> &dst, size_t count, const stream_t *stream = nullptr)

template<typename V1, typename V2>
void copy(const viewable<V1> &src_, size_t src_offset, const viewable<V2> &dst_, size_t dst_offset, size_t count, const stream_t *stream = nullptr)

template<typename V1, typename V2>
void copy(const viewable<V1> &src, size_t src_pitch, const viewable<V2> &dst, size_t dst_pitch, size_t rows, size_t cols, const stream_t *stream = nullptr)

template<typename V1, typename V2>
void copy(const viewable<V1> &src_, size_t src_offset, size_t src_pitch, const viewable<V2> &dst_, size_t dst_offset, size_t dst_pitch, size_t rows, size_t cols, const stream_t *stream = nullptr)

device_t device(device_t index)

device_t device()

void peer_access(cuda::device_t device_visible_to, cuda::device_t device_visible_from, bool enable)

bool peer_access(cuda::device_t device_visible_to, cuda::device_t device_visible_from)

VORTEX_VIEW_AS_IMPL(is_cuda_viewable, cuda)

template<typename T>
auto view(cuda_device_tensor_t<T> &obj)

template<typename T>
auto view(const cuda_device_tensor_t<T> &obj)

template<typename T>
auto view(cuda_host_tensor_t<T> &obj)

template<typename T>
auto view(const cuda_host_tensor_t<T> &obj)

Variables

static constexpr auto invalid_device = -1

template<typename T>
constexpr bool is_cuda_viewable = std::is_base_of_v<cuda_viewable<std::decay_t<T>>, std::decay_t<T>>

namespace vortex::cuda::detail

Functions

template<typename V1, typename V2>
constexpr auto kind(const cuda_viewable<V1>&, const cuda_viewable<V2>&)

template<typename V1, typename V2>
constexpr auto kind(const cuda_viewable<V1>&, const cpu_viewable<V2>&)

template<typename V1, typename V2>
constexpr auto kind(const cpu_viewable<V1>&, const cuda_viewable<V2>&)

template<typename V1, typename V2>
constexpr auto kind(const cpu_viewable<V1>&, const cpu_viewable<V2>&)

template<typename T>
void memset(T *ptr, int value, size_t count, const stream_t *stream)

template<typename T, typename U, typename = typename std::enable_if_t<std::is_same_v<cuda::device_type<T>, cuda::device_type<U>>>>
void memcpy(T *dst, const U *src, size_t count, cudaMemcpyKind kind, const stream_t *stream)

template<typename T, typename U, typename = typename std::enable_if_t<std::is_same_v<cuda::device_type<T>, cuda::device_type<U>>>>
void memcpy(T *dst, size_t dst_pitch, const U *src, size_t src_pitch, size_t width, size_t height, cudaMemcpyKind kind, const stream_t *stream)

template<typename ...Args>
void handle_error(cudaError_t error, const std::string &msg, Args... args)

namespace vortex::daqmx

Enums

enum edge_t

Values:

enumerator rising

enumerator falling

enum terminal_t

Values:

enumerator referenced

enumerator unreferenced

enumerator differential

enumerator pseudodifferential

enum sample_mode_t

Values:

enumerator finite

enumerator continuous

enumerator hardware

Functions

std::string to_string(int32 error)

namespace vortex::detail

Functions

template<typename stride_t>
size_t strided_offset(const stride_t &stride, size_t level)

template<typename stride_t, typename index_t, typename ...indexes_t>
size_t strided_offset(const stride_t &stride, size_t level, index_t val, indexes_t... vals)

template<typename To, typename Convert, typename From>
void check_upper(From o)

template<typename To, typename Convert, typename From>
void check_lower(From o)

namespace tuple

namespace vortex::endpoint

Enums

enum buffer_strategy_t

Values:

enumerator none

enumerator segment

enumerator volume

namespace vortex::endpoint::detail

Functions

template<typename T, typename = typename std::enable_if_t<std::is_integral_v<T>>>
auto combine(const std::vector<T> &segments)

namespace vortex::engine

Typedefs

using event_callback_t = std::function<void(event_t, std::exception_ptr)>

using job_callback_t = std::function<void(size_t, session_status_t, timing_t)>

Enums

enum event_t

Values:

enumerator launch

enumerator start

enumerator run

enumerator stop

enumerator complete

enumerator shutdown

enumerator exit

enumerator error

enumerator abort

Functions

template<typename T = double, typename E>
xt::xtensor<T, 1> find_rising_edges(const xt::xexpression<E> &signal_, size_t samples_per_second, size_t number_of_edges = 0)

template<typename source_t, typename T = typename source_t::element_t>
auto compute_resampling(const source_t &source, size_t samples_per_second, size_t samples_per_ascan, T clock_delay_samples = 0)

template<typename T>
xt::xtensor<std::complex<T>, 1> dispersion_phasor(size_t length, std::array<T, 2> coeff)

namespace vortex::engine::bind

Functions

template<typename block_t, typename T>
auto acquisition(std::shared_ptr<T> a, const base_t& = base_t())

template<typename block_t, typename T>
auto processor(std::shared_ptr<T> a, const base_t& = base_t())

template<typename block_t, typename T>
auto io(std::shared_ptr<T> a, const base_t& = base_t())

template<typename block_t, typename T>
auto formatter(std::shared_ptr<T> a, const base_t& = base_t())

template<typename block_t, typename T>
auto endpoint(std::shared_ptr<T> a, const base_t& = base_t())

namespace detail

namespace fft

namespace vortex::format

Typedefs

using format_action_t = std::variant<action::copy, action::resize, action::finish_segment, action::finish_volume, action::finish_scan, action::event>

using format_plan_t = std::vector<format_action_t>

namespace action

namespace vortex::format::detail

Functions

template<typename V>
auto trim_shape_and_stride(const viewable<V> &buffer_, size_t n)

namespace vortex::io

Typedefs

using default_channel_t = channel_t<channel::analog_voltage_input_t, channel::analog_voltage_output_t, channel::digital_input_t, channel::digital_output_t>

namespace channel

namespace detail

namespace marker

namespace detail

namespace vortex::motion

Functions

xt::xtensor<double, 2> plan(size_t dimension, double dt, const state_t<const double*> &start, const state_t<const double*> &end, const limits_t<double> *limits, const options_t &options = {})

template<size_t N, typename T>
auto plan(T dt, const state_t<const xt_point<T, N>&> &start, const state_t<const xt_point<T, N>&> &end, const limits_t<T> *limits, const options_t &options = {})

template<typename T>
auto plan(T dt, const state_t<xt::xtensor<T, 1>> &start, const state_t<xt::xtensor<T, 1>> &end, const limits_t<T> *limits, const options_t &options = {})

namespace process

namespace vortex::process::detail

Functions

void resample(const cuda::stream_t &stream, size_t samples_per_record, size_t records, size_t samples_per_ascan, const uint16_t *before_index, const uint16_t *after_index, const float *before_weight, const float *after_weight, const uint16_t *in, float *out)

void resample(const cuda::stream_t &stream, size_t samples_per_record, size_t records, size_t samples_per_ascan, const uint16_t *before_index, const uint16_t *after_index, const float *before_weight, const float *after_weight, const float *in, float *out)

size_t compute_average_internal_storage_size(size_t samples_per_record, const uint16_t *average_record_buffer, size_t average_record_count, float *average_record)

void compute_average(const cuda::stream_t &stream, const uint8_t *internal_storage, size_t samples_per_record, const uint16_t *average_record_buffer, size_t average_record_count, float *average_record)

void compute_average(const cuda::stream_t &stream, size_t samples_per_record, const uint16_t *average_record_buffer, size_t average_record_count, float *average_record)

void subtract_average(const cuda::stream_t &stream, size_t samples_per_record, size_t records, const uint16_t *average_record_buffer, size_t average_record_count, const float *average_record, const uint16_t *in, float *out)

void complex_filter(const cuda::stream_t &stream, size_t samples_per_ascan, size_t ascans, const uint16_t *in, const cuFloatComplex *filter, cuFloatComplex *out)

void complex_filter(const cuda::stream_t &stream, size_t samples_per_ascan, size_t ascans, const float *in, const cuFloatComplex *filter, cuFloatComplex *out)

void cast(const cuda::stream_t &stream, size_t samples_per_ascan, size_t ascans, const uint16_t *in, cuFloatComplex *out)

void cast(const cuda::stream_t &stream, size_t samples_per_ascan, size_t ascans, const float *in, cuFloatComplex *out)

void cast(const cuda::stream_t &stream, size_t samples_per_ascan, size_t ascans, const cuFloatComplex *in, cuFloatComplex *out)

_DECLARE(float, uint16_t, float)

_DECLARE(float, float, float)

_DECLARE(float, cuFloatComplex, float)

_DECLARE(float, uint16_t, int8_t)

_DECLARE(float, float, int8_t)

_DECLARE(float, cuFloatComplex, int8_t)

namespace scan

namespace vortex::scan::detail

Functions

template<typename It, typename S>
auto load_waypoints(const It &waypoints_begin, const It &waypoints_end, size_t index, bool reversed, S &segment)

namespace warp

namespace simple

namespace vortex::storage

Typedefs

template<typename config_t>
using marker_log_t = marker::marker_v0_t<config_t>

template<typename config_t>
using stream_dump_t = dump::stream_dump_v0_t<config_t>

Enums

enum broct_scan_t

Values:

enumerator rectangular

enumerator bscan

enumerator aiming

enumerator mscan

enumerator radial

enumerator ascan

enumerator speckle

enumerator mixed

enumerator xfast_yfast

enumerator xfast_yfast_speckle

enumerator spiral

enum hdf5_stack_header_t

Values:

enumerator none

enumerator matlab

enum simple_stream_header_t

Values:

enumerator none

enumerator raw

enum simple_stack_header_t

Values:

enumerator none

enumerator raw

enumerator numpy

enumerator matlab

namespace vortex::storage::broct

Variables

static constexpr int32_t meta = 70

static constexpr std::array<size_t, 3> header_axis_order = {1, 2, 0}

static constexpr std::array<size_t, 3> data_axis_order = {0, 2, 1}

namespace vortex::storage::detail

Functions

template<typename element_t>
void write_raw_header(std::ostream &out)

template<typename element_t, typename shape_t>
void write_raw_header(std::ostream &out, const shape_t &shape)

template<typename T>
inline void write_raw(std::ostream &s, const T &o)

template<>
inline void write_raw(std::ostream &s, const std::string &o)

template<typename T>
inline void write_through_raw(std::ostream &s, const T &o)

template<typename T>
inline void read_raw(std::istream &s, T &o)

template<typename T>
inline void write_raw(std::ostream &s, const T *o, size_t count)

template<typename T>
inline void write_through_raw(std::ostream &s, const T *o, size_t count)

template<typename T>
inline void read_raw(std::istream &s, T *o, size_t count)

template<typename T>
auto datatype()

namespace vortex::storage::detail::matlab

Functions

inline void write_preamble(std::ostream &out, uint16_t version, std::string text = default_text)

template<typename element_t, typename shape_t>
auto write_header(std::ostream &out, shape_t shape, std::string name = "data", std::string text = default_text, bool global = false, bool logical = false)

inline void write_final_padding(std::ofstream &out)

Variables

const uint32_t miINT8 = 1

const uint32_t miUINT8 = 2

const uint32_t miINT16 = 3

const uint32_t miUINT16 = 4

const uint32_t miINT32 = 5

const uint32_t miUINT32 = 6

const uint32_t miSINGLE = 7

const uint32_t miDOUBLE = 9

const uint32_t miINT64 = 12

const uint32_t miUINT64 = 13

const uint32_t miMATRIX = 14

const uint32_t miCOMPRESSED = 15

const uint32_t miUTF8 = 16

const uint32_t miUTF16 = 17

const uint32_t miUTF32 = 18

const uint8_t mxDOUBLE_CLASS = 6

const uint8_t mxSINGLE_CLASS = 7

const uint8_t mxINT8_CLASS = 8

const uint8_t mxUINT8_CLASS = 9

const uint8_t mxINT16_CLASS = 10

const uint8_t mxUINT16_CLASS = 11

const uint8_t mxINT32_CLASS = 12

const uint8_t mxUINT32_CLASS = 13

const uint8_t mxINT64_CLASS = 14

const uint8_t mxUINT64_CLASS = 15

const uint8_t complex_flag = 0b00001000

const uint8_t global_flag = 0b00000100

const uint8_t logical_flag = 0b00000010

const auto default_text = "MATLAB"

const auto text_length = 116

const uint16_t endian_indicator = 0x4d49

const auto alignment = 8

namespace vortex::storage::detail::numpy

Functions

template<typename element_t, typename shape_t>
auto write_header(std::ostream &out, const shape_t &shape, bool fortran_order = false, size_t padded_length = 256)

Variables

const auto magic = std::string("\x93NUMPY\x02\x00", 8)

const auto alignment = 64

namespace dump

namespace marker

namespace vortex::strategy

Variables

struct vortex::strategy::left_t left

struct vortex::strategy::right_t right

struct vortex::strategy::balance_t balance

namespace sync

namespace util

namespace variant

namespace detail

file acquire.hpp

file dso.hpp

file base.hpp

file base.hpp

file base.hpp

file config.hpp

file cuda.hpp

file cuda.hpp

file cuda.hpp

file cuda.hpp

file cuda.hpp

Defines

_DECLARE(factor_t, in_t, out_t)

file fft.hpp

file fft.hpp

file host.hpp

file file.hpp

file null.hpp

file null.hpp

file null.hpp

file core.cpp

file core.cpp

file core.hpp

file core.hpp

file board.cpp

Defines

_ACCESSOR_HELPER(name, parameter, display)

Functions

template<typename T>
static T _clip(T v, T lower, T upper)

static auto _trigger_level(float level)

_ACCESSOR_HELPER (samples_per_record, RECORD_LENGTH, "samples per record (record length)")

_ACCESSOR_HELPER (record_capture_count, GET_RECORDS_CAPTURED, "record capture count")

_ACCESSOR_HELPER (pending_buffer_count, GET_ASYNC_BUFFERS_PENDING, "pending count")

file board.hpp

file db.cpp

Defines

_LOOKUP_DEFINE(name, map, display, in_t, out_t)

Functions

_LOOKUP_DEFINE (lookup_board_kind, _board_kind_map, "board kind", U32, std::string)

_LOOKUP_DEFINE (lookup_sampling_rate, _sampling_rate_map, "sampling rate", size_t, U32)

_LOOKUP_DEFINE (lookup_supported_sampling_rate, _supported_sampling_rate_map, "supported sampling rates", std::string, std::vector< size_t >)

_LOOKUP_DEFINE (lookup_impedance_ohms, _impedance_ohms_map, "impedance (Ohms)", size_t, U32)

_LOOKUP_DEFINE (lookup_input_range_millivolts, _input_range_millivolts_map, "input range (mV)", size_t, U32)

_LOOKUP_DEFINE (lookup_supported_impedance_ohms_input_range_millivolts, _supported_impedance_ohms_input_range_millivolts_map, "supported impedance (Ohms)/input range (mV) combination", std::string, std::vector< impedance_input_range_t >)

_LOOKUP_DEFINE (lookup_trigger_range_volts, _trigger_range_volts_map, "trigger range (V)", size_t, U32)

_LOOKUP_DEFINE (lookup_alignment, _alignment_map, "alignment requirements", std::string, const alignment_info_t &)

Variables

static const std::unordered_map<U32, std::string> _board_kind_map

static std::unordered_map<size_t, U32> _sampling_rate_map

static std::unordered_map<std::string, std::vector<size_t>> _supported_sampling_rate_map = {{"ATS310", {10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000}}, {"ATS9120", {10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000}}, {"ATS330", {10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 25000000, 50000000}}, {"ATS9130", {10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 25000000, 50000000}}, {"ATS460", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000}}, {"ATS660", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000}}, {"ATS850", {10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 25000000, 50000000}}, {"ATS860", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 25000000, 50000000, 100000000, 125000000, 250000000}}, {"ATS9350", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000, 250000000, 500000000}}, {"ATS9351", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000, 250000000, 500000000}}, {"ATS9360", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 200000000, 500000000, 800000000, 1000000000, 1200000000, 1500000000, 1800000000}}, {"ATS9373", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 200000000, 500000000, 800000000, 1000000000}}, {"ATS9373", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 200000000, 500000000, 800000000, 1000000000, 1200000000, 1500000000, 2000000000, 2400000000, 3000000000, 3600000000, 4000000000}}, {"ATS9416", {1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000}}, {"ATS9440", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000}}, {"ATS9462", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000, 160000000, 180000000}}, {"ATS9625", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000, 250000000}}, {"ATS9626", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000, 250000000}}, {"ATS9870", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 250000000, 500000000, 1000000000}}, {"AXI9870", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 250000000, 500000000, 1000000000}},}

static std::unordered_map<size_t, U32> _impedance_ohms_map = {{1000000, IMPEDANCE_1M_OHM}, {50, IMPEDANCE_50_OHM}, {75, IMPEDANCE_75_OHM}, {300, IMPEDANCE_300_OHM},}

static std::unordered_map<size_t, U32> _input_range_millivolts_map = {{20, INPUT_RANGE_PM_20_MV}, {40, INPUT_RANGE_PM_40_MV}, {50, INPUT_RANGE_PM_50_MV}, {80, INPUT_RANGE_PM_80_MV}, {100, INPUT_RANGE_PM_100_MV}, {200, INPUT_RANGE_PM_200_MV}, {400, INPUT_RANGE_PM_400_MV}, {500, INPUT_RANGE_PM_500_MV}, {800, INPUT_RANGE_PM_800_MV}, {1000, INPUT_RANGE_PM_1_V}, {2000, INPUT_RANGE_PM_2_V}, {4000, INPUT_RANGE_PM_4_V}, {5000, INPUT_RANGE_PM_5_V}, {8000, INPUT_RANGE_PM_8_V}, {10000, INPUT_RANGE_PM_10_V}, {20000, INPUT_RANGE_PM_20_V}, {40000, INPUT_RANGE_PM_40_V}, {16000, INPUT_RANGE_PM_16_V}, {1250, INPUT_RANGE_PM_1_V_25}, {2500, INPUT_RANGE_PM_2_V_5}, {125, INPUT_RANGE_PM_125_MV}, {250, INPUT_RANGE_PM_250_MV},}

static std::unordered_map<std::string, std::vector<impedance_input_range_t>> _supported_impedance_ohms_input_range_millivolts_map

static std::unordered_map<size_t, U32> _packing_mode_map = {{16, PACK_DEFAULT}, {8, PACK_8_BITS_PER_SAMPLE}, {12, PACK_12_BITS_PER_SAMPLE},}

static std::unordered_map<size_t, U32> _trigger_range_volts_map = {{5000, ETR_5V}, {1000, ETR_1V}, {2500, ETR_2V5}, {0, ETR_TTL},}

static std::unordered_map<std::string, alignment_info_t> _alignment_map = {{"ATS310", {256, 4, 16}}, {"ATS330", {256, 4, 16}}, {"ATS460", {128, 16, 16}}, {"ATS660", {128, 16, 16}}, {"ATS850", {256, 4, 16}}, {"ATS860", {256, 32, 32}}, {"ATS9350", {256, 32, 32}}, {"ATS9351", {256, 32, 32}}, {"ATS9120", {256, 32, 32}}, {"ATS9130", {256, 32, 32}}, {"ATS9360", {256, 128, 128}}, {"ATS9370", {256, 128, 128}}, {"ATS9371", {256, 128, 128}}, {"ATS9373", {256, 128, 128}}, {"ATS9416", {256, 128, 128}}, {"ATS9440", {256, 32, 32}}, {"ATS9462", {256, 32, 32}}, {"ATS9625", {256, 32, 32}}, {"ATS9626", {256, 32, 32}}, {"ATS9870", {256, 64, 64}}, {"AXI9870", {256, 64, 64}},}

file db.hpp

Defines

_LOOKUP_DECLARE(name, in_t, out_t)

file copy.hpp

file copy.hpp

file copy.hpp

file runtime.cpp

file runtime.hpp

file types.hpp

file daqmx.cpp

Functions

template<typename ...Args>
static const void _handle_error(int32 error, const std::string &msg, Args... args)

file daqmx.hpp

file daqmx.hpp

file fftw.hpp

file motion.cpp

file motion.hpp

file common.hpp

file common.hpp

file common.hpp

file cpu.hpp

file cpu.hpp

file cpu.hpp

file storage.hpp

file storage.hpp

file adapter.hpp

file clock.hpp

file session.hpp

file dispersion.hpp

file engine.hpp

file engine.hpp

file engine.hpp

file scan.hpp

file scan.hpp

file source.hpp

file format.hpp

file broct.hpp

file broct.hpp

file plan.hpp

file position.hpp

file radial.hpp

file radial.hpp

file spiral.hpp

file spiral.hpp

file stack.hpp

file io.hpp

file flags.hpp

file marker.hpp

file marker.hpp

file marker.hpp

file memory.hpp

file alazar.hpp

file tensor.hpp

file view.hpp

Defines

VORTEX_VIEW_AS_IMPL(view_check, suffix)

file process.hpp

file freeform.hpp

file pattern.hpp

file raster.hpp

file segmented.hpp

file warp.hpp

file waypoints.hpp

file header.hpp

file raw.hpp

file hdf5.hpp

file simple.hpp

file stream.hpp

file stream.hpp

file cast.hpp

file platform.cpp

Defines

REALTIME_PRIORITY

file platform.hpp

file ring.hpp

file sync.cpp

file sync.hpp

file thread.hpp

file tuple.hpp

file variant.hpp

Defines

CALL(obj, function, ...)

CALL_CONST(obj, function, ...)

DISPATCH(function, ...)

DISPATCH_CONST(function, ...)

ACCESS(attribute)

ACCESS_CONST(attribute)

file vortex.hpp

dir src/vortex/acquire

dir src/vortex/acquire/dso/alazar

dir src/vortex/driver/alazar

dir src/vortex/driver/cuda

dir src/vortex/engine/detail

dir src/vortex/storage/detail

dir src/vortex/driver

dir src/vortex/acquire/dso

dir src/vortex/endpoint

dir src/vortex/engine

dir src/vortex/format

dir src/vortex/io

dir src/vortex/marker

dir src/vortex/memory

dir src/vortex/process

dir src/vortex/scan

dir src/vortex/simple

dir src

dir src/vortex/storage

dir src/vortex/util

dir src/vortex