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 auto value = mxDOUBLE_CLASS
static constexpr auto name = "float64"
static constexpr auto flags = 0
template<>
struct vortex::storage::detail::matlab::array<float>

Public Static Attributes

static constexpr auto value = mxSINGLE_CLASS
static constexpr auto name = "float32"
static constexpr auto flags = 0
template<>
struct vortex::storage::detail::matlab::array<int16_t>

Public Static Attributes

static constexpr auto value = mxINT16_CLASS
static constexpr auto name = "int16"
static constexpr auto flags = 0
template<>
struct vortex::storage::detail::matlab::array<int32_t>

Public Static Attributes

static constexpr auto value = mxINT32_CLASS
static constexpr auto name = "int32"
static constexpr auto flags = 0
template<>
struct vortex::storage::detail::matlab::array<int64_t>

Public Static Attributes

static constexpr auto value = mxINT64_CLASS
static constexpr auto name = "int64"
static constexpr auto flags = 0
template<>
struct vortex::storage::detail::matlab::array<int8_t>

Public Static Attributes

static constexpr auto value = mxINT8_CLASS
static constexpr auto name = "int8"
static constexpr auto flags = 0
template<typename T>
struct vortex::storage::detail::matlab::array<std::complex<T>>

Public Static Attributes

static constexpr auto value = array<T>::value
static constexpr auto flags = complex_flag
template<>
struct vortex::storage::detail::matlab::array<uint16_t>

Public Static Attributes

static constexpr auto value = mxUINT16_CLASS
static constexpr auto name = "uint16"
static constexpr auto flags = 0
template<>
struct vortex::storage::detail::matlab::array<uint32_t>

Public Static Attributes

static constexpr auto value = mxUINT32_CLASS
static constexpr auto name = "uint32"
static constexpr auto flags = 0
template<>
struct vortex::storage::detail::matlab::array<uint64_t>

Public Static Attributes

static constexpr auto value = mxUINT64_CLASS
static constexpr auto name = "uint64"
static constexpr auto flags = 0
template<>
struct vortex::storage::detail::matlab::array<uint8_t>

Public Static Attributes

static constexpr auto value = mxUINT8_CLASS
static constexpr auto name = "uint8"
static constexpr 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 T>
struct ascan_position_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl<T, position_format_executor_t, detail::select_ascans_t, ascan_position_cuda_device_tensor<T>>
template<typename T>
struct ascan_radial_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_impl<T, radial_format_executor_t, detail::select_ascans_t, ascan_radial_cuda_device_tensor<T>>
template<typename T>
struct ascan_spiral_galvo_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl<T, spiral_format_executor_t, detail::select_ascans_t, ascan_spiral_galvo_cuda_device_tensor<T>>
template<typename T>
struct ascan_stack_cpu_tensor : public vortex::endpoint::detail::cpu_tensor<cpu_tensor_t<T>, stack_format_executor_t, detail::select_ascans_t>
template<typename T>
struct ascan_stack_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_impl<T, stack_format_executor_t, detail::select_ascans_t, ascan_stack_cuda_device_tensor<T>>
template<typename T>
struct ascan_stack_cuda_host_tensor : public vortex::endpoint::detail::cuda_host_tensor_impl<T, stack_format_executor_t, detail::select_ascans_t, ascan_stack_cuda_host_tensor<T>>
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 class stream_index_t : size_t

Values:

enumerator counter
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 counter_stream_t = sync::lockable<cpu_tensor_t<counter_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
counter_stream_t counter
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_overflow : public vortex::imaq::exception
class buffer_underflow : public vortex::daqmx::exception
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, typename source_selector_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 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)

Public Members

aggregate_segment_callback_t aggregate_segment_callback
update_callback_t update_callback

Protected Functions

template<typename block_t, typename V>
inline void _handle(const format::format_plan_t &plan, const block_t &block, const cuda::cuda_viewable<V> &source)
template<typename block_t, typename V>
inline void _handle(const format::format_plan_t &plan, const block_t &block, const cpu_viewable<V> &source_)
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>

Subclassed by vortex::sync::lockable< cpu_tensor_t< counter_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 source_selector_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, detail::select_ascans_t, ascan_position_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl< T, spiral_format_executor_t, detail::select_ascans_t, ascan_spiral_galvo_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl< T, position_format_executor_t, detail::select_spectra_t, spectra_position_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl< T, spiral_format_executor_t, detail::select_spectra_t, spectra_spiral_galvo_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl< T, executor_t, source_selector_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 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

template<typename block_t, typename V>
inline void _handle(const format::format_plan_t &plan, const block_t &block, const cpu_viewable<V> &source)
template<typename block_t, typename V>
inline void _handle(const format::format_plan_t &plan, const block_t &block, const cuda::cuda_viewable<V> &source_)
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 source_selector_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, source_selector_t, derived_t>

Public Functions

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

template<typename block_t, typename V>
inline void _handle(const format::format_plan_t &plan, const block_t &block, const cpu_viewable<V> &source)
template<typename block_t, typename V>
inline void _handle(const format::format_plan_t &plan, const block_t &block, const cuda::cuda_viewable<V> &source_)

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 source_selector_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, detail::select_ascans_t, ascan_radial_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_impl< T, stack_format_executor_t, detail::select_ascans_t, ascan_stack_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_impl< T, radial_format_executor_t, detail::select_spectra_t, spectra_radial_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_device_tensor_impl< T, stack_format_executor_t, detail::select_spectra_t, spectra_stack_cuda_device_tensor< T > >, vortex::endpoint::detail::cuda_host_tensor_impl< T, stack_format_executor_t, detail::select_ascans_t, ascan_stack_cuda_host_tensor< T > >, vortex::endpoint::detail::cuda_host_tensor_impl< T, stack_format_executor_t, detail::select_spectra_t, spectra_stack_cuda_host_tensor< T > >, vortex::endpoint::detail::cuda_host_tensor_impl< T, stack_format_executor_t, detail::select_streams_t< index >, streams_stack_cuda_host_tensor< index, 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
template<size_t N>
inline auto to_strided() 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
class device_in_use : public vortex::imaq::exception
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 constexpr 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_ >, vortex::acquire::imaq_config_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 auto name = "float64"
template<>
struct vortex::storage::detail::numpy::dtype<float>

Public Static Attributes

static constexpr auto name = "float32"
template<>
struct vortex::storage::detail::numpy::dtype<int16_t>

Public Static Attributes

static constexpr auto name = "int16"
template<>
struct vortex::storage::detail::numpy::dtype<int32_t>

Public Static Attributes

static constexpr auto name = "int32"
template<>
struct vortex::storage::detail::numpy::dtype<int64_t>

Public Static Attributes

static constexpr auto name = "int64"
template<>
struct vortex::storage::detail::numpy::dtype<int8_t>

Public Static Attributes

static constexpr auto name = "int8"
template<>
struct vortex::storage::detail::numpy::dtype<std::complex<double>>

Public Static Attributes

static constexpr auto name = "complex128"
template<>
struct vortex::storage::detail::numpy::dtype<std::complex<float>>

Public Static Attributes

static constexpr auto name = "complex64"
template<>
struct vortex::storage::detail::numpy::dtype<uint16_t>

Public Static Attributes

static constexpr auto name = "uint16"
template<>
struct vortex::storage::detail::numpy::dtype<uint32_t>

Public Static Attributes

static constexpr auto name = "uint32"
template<>
struct vortex::storage::detail::numpy::dtype<uint64_t>

Public Static Attributes

static constexpr auto name = "uint64"
template<>
struct vortex::storage::detail::numpy::dtype<uint8_t>

Public Static Attributes

static constexpr 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
std::vector<strobe_t> strobes = {strobe::sample(0, 2), strobe::sample(1, 1000), strobe::sample(2, 1000, strobe::polarity_t::low), strobe::segment(3), strobe::volume(4)}

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_error() 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 _shutdown_exception
std::optional<session_t> _session
mutable std::mutex _mutex
template<typename stream_t>
struct vortex::detail::stream_element_is_same::evaluate

Public Types

using T = element_t
using U = typename std::decay_t<stream_t>::derived_t::element_t

Public Static Attributes

static constexpr auto value = std::is_same_v<T, U> || (std::is_integral_v<T> && std::is_integral_v<U> && std::is_signed_v<T> == std::is_signed_v<U> && sizeof(T) == sizeof(U))
struct vortex::engine::strobe::event : public vortex::engine::strobe::detail::physical, public vortex::engine::strobe::detail::flagged

Public Functions

inline event(size_t line_ = 0, polarity_t polarity_ = polarity_t::high, size_t duration_ = 10, size_t delay_ = 0, flags_t flags_ = flags_t::all())
auto operator<=>(const event&) const = default
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)
inline event(counter_t sample_, eid_t id_, flags_t flags_)
auto operator<=>(const event&) const = default

Public Members

eid_t id
flags_t flags
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

class exception : public std::runtime_error

Subclassed by vortex::imaq::buffer_overflow, vortex::imaq::device_in_use, vortex::imaq::incompatible_region, vortex::imaq::timeout

struct vortex::acquire::clock::external_t

Public Functions

template<typename board_t>
inline void apply(board_t &board, alazar::channel_t channels, 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
struct vortex::alazar::board_t::info_t::features_t

Public Members

bool set_external_clock_level = false
std::optional<size_t> adc_calibration_sampling_rate
bool dual_port_memory = false
bool dual_edge_sampling = 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 Functions

inline virtual void validate()

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
struct vortex::scan::inactive_policy::fixed_linear_t

Public Functions

inline void set_samples(size_t n)
template<typename T>
inline bool compatible(const motion::state_t<xt::xtensor<T, 1>> &a, const motion::state_t<xt::xtensor<T, 1>> &b) const
template<typename T>
inline xt::xtensor<T, 2> generate(bool inter_segment, T dt, const motion::state_t<xt::xtensor<T, 1>> &start, const motion::state_t<xt::xtensor<T, 1>> &end, const std::vector<motion::limits_t<T>> &limits, const motion::options_t &options) const

Public Members

size_t inter_segment_samples = 100
size_t inter_volume_samples = 100
struct vortex::engine::strobe::detail::flagged

Subclassed by vortex::engine::strobe::event, vortex::engine::strobe::scan, vortex::engine::strobe::segment, vortex::engine::strobe::volume

Public Functions

inline flagged(size_t delay_ = 0, flags_t flags_ = flags_t::all())
auto operator<=>(const flagged&) const = default

Public Members

flags_t flags
size_t delay
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
struct vortex::acquire::frame_trigger_t

Public Functions

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

Public Members

uInt32 line = 0
imaq::polarity_t polarity = imaq::polarity_t::high
imaq::signal_t signal = imaq::signal_t::external
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
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 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
template<typename config_t_, typename input_ts>
class vortex::acquire::imaq_acquisition_t

Public Types

using config_t = config_t_
using output_element_t = uint16_t
using callback_t = std::function<void(size_t, std::exception_ptr)>

Public Functions

inline imaq_acquisition_t(std::shared_ptr<spdlog::logger> log = nullptr)
inline virtual ~imaq_acquisition_t()
inline const config_t &config() const
inline const imaq::imaq_t &imaq() const
inline virtual void initialize(config_t config)
inline virtual void prepare()
inline void start()
inline void stop()
inline bool running() const
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 Types

using ring_buffer_t = typename detail::to_ring_buffer<input_ts>::type
using job_t = std::function<void()>

Protected Functions

inline ring_dtype_t _validate_datatype()
template<typename V>
inline auto _wait_block(size_t id, const V &output_buffer, bool lock_is_held)
inline void _stop(bool lock_is_held)

Protected Attributes

std::shared_ptr<spdlog::logger> _log
std::vector<ring_buffer_t> _ring
imaq::imaq_t::roi_t _copy_roi
imaq::imaq_t _imaq
std::atomic_bool _abort = false
std::atomic<size_t> _frame_count
std::optional<util::worker_pool_t> _pool
std::mutex _mutex
config_t _config

Protected Static Functions

static inline auto _to_string(const ring_dtype_t &dtype)
struct vortex::acquire::imaq_config_t : public vortex::acquire::dso_config_t

Public Functions

inline auto &sample_offset()
inline const auto &sample_offset() const
inline auto &record_offset()
inline const auto &record_offset() const
inline void validate()

Public Members

std::string device_name = "img0"
std::array<size_t, 2> offset = {{0, 0}}
std::optional<line_trigger_t> line_trigger
std::optional<frame_trigger_t> frame_trigger
std::vector<trigger_output_t> trigger_output = {trigger_output_t{}}
size_t ring_size = 10
std::chrono::milliseconds acquire_timeout = std::chrono::seconds(1)
bool stop_on_error = true
bool bypass_region_check = false
template<typename ...Ts>
struct imaq_input_ts
class vortex::imaq::imaq_t

Public Types

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

Public Functions

imaq_t()
imaq_t(std::string interface_name)
imaq_t(const imaq_t&) = delete
imaq_t &operator=(const imaq_t&) = delete
imaq_t(imaq_t &&other)
imaq_t &operator=(imaq_t &&other)
virtual ~imaq_t()
template<typename T>
inline void configure_ring(const std::vector<T*> &buffers)
void configure_ring(std::vector<void*> &buffers, uInt32 skip = 0)
locked_frame_t lock_frame(uInt32 index = current_frame, bool requested_only = true) const
uInt32 required_buffer_size() const
roi_t fit_region(const roi_t &roi)
void configure_region(const roi_t &roi)
roi_t query_region() const
void configure_line_trigger(uInt32 line, uInt32 skip = 0, polarity_t polarity = polarity_t::high, signal_t signal = signal_t::external)
void configure_frame_trigger(uInt32 line, polarity_t polarity = polarity_t::high, signal_t signal = signal_t::external)
void configure_frame_trigger(uInt32 line, const std::chrono::milliseconds &timeout, polarity_t polarity = polarity_t::high, signal_t signal = signal_t::external)
void configure_trigger_output(uInt32 line, source_t source, polarity_t polarity = polarity_t::high, signal_t signal = signal_t::external)
void configure_frame_timeout(const std::chrono::milliseconds &timeout)
void start_capture()
void start_capture(callback_t &&callback)
void stop_capture()
inline const info_t &info() const
bool valid() const
const std::string &name() const
INTERFACE_ID handle() const
bool running() const

Protected Functions

void _destroy()

Protected Attributes

INTERFACE_ID _interface = 0
SESSION_ID _session = 0
std::string _name
info_t _info
bool _started = false

Protected Static Functions

static uInt32 _callback_wrapper(SESSION_ID session, IMG_ERR error, uInt32 signal, void *data)
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_region : public vortex::imaq::exception
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<channel_t> supported_channels
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
features_t features
std::vector<dsp_t> dsp
struct vortex::imaq::imaq_t::info_t

Public Members

uInt32 device
uInt32 serial
std::optional<std::chrono::utc_clock::time_point> calibration
resolution_t resolution
roi_t acquisition_window
bool line_scan
uInt32 bits_per_pixel
uInt32 bytes_per_pixel
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, alazar::channel_t channels, 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
template<typename>
struct is_tuple : public std::false_type
template<typename ...T>
struct is_tuple<std::tuple<T...>> : public std::true_type
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
struct vortex::acquire::line_trigger_t

Public Functions

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

Public Members

uInt32 line = 0
uInt32 skip = 0
imaq::polarity_t polarity = imaq::polarity_t::high
imaq::signal_t signal = imaq::signal_t::external
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
struct vortex::imaq::imaq_t::locked_frame_t

Public Functions

locked_frame_t(const locked_frame_t&) = delete
locked_frame_t &operator=(const locked_frame_t&) = delete
locked_frame_t(locked_frame_t &&other)
locked_frame_t &operator=(locked_frame_t &&other)
locked_frame_t(const imaq_t &imaq_)
~locked_frame_t()

Public Members

uInt32 target_index
uInt32 actual_index
void *ptr

Protected Attributes

const imaq_t *imaq = nullptr
template<size_t N>
struct longlong
template<>
struct vortex::cuda::detail::longlong<2>

Public Types

using type = longlong2
template<>
struct vortex::cuda::detail::longlong<3>

Public Types

using type = longlong3
template<>
struct vortex::cuda::detail::longlong<4>

Public Types

using type = longlong4
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 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::cuda::matrix_t

Public Functions

inline std::array<size_t, 2> shape() const
inline auto count() const

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, detail::select_ascans_t >, vortex::endpoint::detail::cpu_tensor< cpu_tensor_t< T >, stack_format_executor_t, detail::select_spectra_t >, vortex::endpoint::detail::cpu_tensor< cpu_tensor_t< T >, stack_format_executor_t, detail::select_streams_t< index > >, vortex::endpoint::detail::stack_storage< stack_format_executor_t, simple_stack_t< element_t >, detail::select_ascans_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_spectra_t >, vortex::endpoint::detail::stack_storage< stack_format_executor_t, simple_stack_t< element_t >, detail::select_streams_t< index > >, vortex::endpoint::cuda_tensor< derived_t_ >, vortex::endpoint::detail::cpu_tensor< tensor_t, executor_t, source_selector_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
inline virtual void validate()

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
inline auto to_strided() 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
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
std::optional<size_t> fixed_samples
template<class ...Ts>
struct overloaded : public vortex::Ts
template<typename T, typename inactive_policy_t, typename waypoints_t, typename pattern_t>
struct vortex::scan::detail::patterned_config_factory_t : public vortex::scan::detail::segmented_config_t<T, inactive_policy_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
struct vortex::engine::strobe::detail::physical

Subclassed by vortex::engine::strobe::event, vortex::engine::strobe::sample, vortex::engine::strobe::scan, vortex::engine::strobe::segment, vortex::engine::strobe::volume

Public Functions

inline physical(size_t line_ = 0, polarity_t polarity_ = polarity_t::high, size_t duration_ = 1)
auto operator<=>(const physical&) const = default

Public Members

size_t line
polarity_t polarity
size_t duration
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
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_order

Public Members

flags_t flags = flags_t::all()
struct vortex::scan::repeated_pattern_t::repeat_pack

Public Members

flags_t flags = flags_t::all()
template<typename marker_t, typename flags_t>
struct vortex::scan::repeated_pattern_t

Public Types

using repeat_strategy_t = std::variant<repeat_order, 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

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 vortex::imaq::imaq_t::info_t::resolution_t

Public Members

uInt32 horizontal
uInt32 vertical
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::acquire::imaq_acquisition_t::ring_dtype_t

Public Members

bool compatible
size_t bits
std::string name
std::function<void*(const imaq::imaq_t&, ring_buffer_t&, std::array<size_t, 3>)> allocator
struct vortex::imaq::imaq_t::roi_t

Public Members

uInt32 top
uInt32 left
uInt32 height
uInt32 width
uInt32 pixels_per_row = 0
struct vortex::engine::strobe::sample : public vortex::engine::strobe::detail::physical

Public Functions

inline sample(size_t line_ = 0, size_t divisor_ = 2, polarity_t polarity_ = polarity_t::high, size_t duration_ = 1, size_t phase_ = 0)
auto operator<=>(const sample&) const = default

Public Members

size_t divisor
size_t phase
struct vortex::engine::strobe::scan : public vortex::engine::strobe::detail::physical, public vortex::engine::strobe::detail::flagged

Public Functions

inline scan(size_t line_ = 0, polarity_t polarity_ = polarity_t::high, size_t duration_ = 10, size_t delay_ = 0, flags_t flags_ = flags_t::all())
auto operator<=>(const scan&) const = default
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, inactive_policy_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 class 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::engine::strobe::segment : public vortex::engine::strobe::detail::physical, public vortex::engine::strobe::detail::flagged

Public Functions

inline segment(size_t line_ = 0, polarity_t polarity_ = polarity_t::high, size_t duration_ = 10, size_t delay_ = 0, flags_t flags_ = flags_t::all())
auto operator<=>(const segment&) const = default
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, typename inactive_policy_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, inactive_policy_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
inactive_policy_t inactive_policy
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 streams_t, typename spectra_stream_t, typename ascan_stream_t>
static inline const auto &select(const streams_t &streams, const spectra_stream_t &spectra, const ascan_stream_t &ascans)
struct vortex::endpoint::detail::select_spectra_t

Public Static Functions

template<typename streams_t, typename spectra_stream_t, typename ascan_stream_t>
static inline const auto &select(const streams_t &streams, const spectra_stream_t &spectra, const ascan_stream_t &ascans)
template<size_t index>
struct vortex::endpoint::detail::select_streams_t

Public Static Functions

template<typename ...T, typename spectra_stream_t, typename ascan_stream_t>
static inline const auto &select(const std::tuple<T...> &streams, const spectra_stream_t &spectra, const ascan_stream_t &ascans)
template<typename streams_t, typename spectra_stream_t, typename ascan_stream_t, typename = std::enable_if_t<!is_tuple<std::decay_t<streams_t>>::value>>
static inline const auto &select(const streams_t &streams, const spectra_stream_t &spectra, const ascan_stream_t &ascans)
template<typename marker_t, typename flags_t>
struct vortex::scan::sequential_pattern_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 &shutdown_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 quit(bool interrupt = false)
inline auto status() const

Protected Functions

inline void _quit(bool interrupt, const std::exception_ptr &error)
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()
template<typename object_map_t, typename deferred_map_t>
inline void _dispatch(const object_map_t &objects, const job_t &job, bool preload, deferred_map_t &deferred, size_t &task_idx)
inline void _dispatch(const typename config_t::adapter::acquisition &a, const typename config_t::acquire_config &config, const job_t &job, size_t task_index)
inline void _dispatch(const typename config_t::adapter::io &io, const typename config_t::io_config &config, const job_t &job, size_t task_index)
template<typename object_map_t, typename deferred_map_t>
inline void _start(const object_map_t &objects, bool master, deferred_map_t &deferred)
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)
template<typename R, typename S>
inline void _delay_signals_with_ring(size_t lead, size_t ref_lead, size_t total_records, R &rings, S &signals)
inline auto _strobe_idle() const
template<typename marker_t, typename buffer_t, typename strobe_t>
inline void _generate_flagged_strobe(block_t &block, const std::set<typename block_t::marker_t> &markers, buffer_t &buf, const strobe_t &s)
inline void _generate_strobes(block_t &block, typename block_t::digital_element_t idle, size_t ref_lead)
inline auto _number_of_acquire_tasks() const
inline auto _number_of_format_tasks() const
inline void _emit() const
inline void _emit(const std::exception_ptr &error) const
inline void _emit(event_t event, const std::exception_ptr &error = {}) const
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 &_shutdown_exception
std::shared_ptr<spdlog::logger> _log
std::atomic_bool _interrupt = false
std::atomic_bool _shutdown = false
sync::event_t _dispatch_complete
sync::event_t _session_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
std::set<typename block_t::marker_t> _ongoing_strobe_markers
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::ascan_stack_cuda_device_tensor<processor_t::output_element_t>> _stack_tensor_endpoint
std::shared_ptr<endpoint::ascan_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_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
T imaging_depth_meters = 0.01
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 T>
struct spectra_position_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl<T, position_format_executor_t, detail::select_spectra_t, spectra_position_cuda_device_tensor<T>>
template<typename T>
struct spectra_radial_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_impl<T, radial_format_executor_t, detail::select_spectra_t, spectra_radial_cuda_device_tensor<T>>
template<typename T>
struct spectra_spiral_galvo_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_with_galvo_impl<T, spiral_format_executor_t, detail::select_spectra_t, spectra_spiral_galvo_cuda_device_tensor<T>>
template<typename T>
struct spectra_stack_cpu_tensor : public vortex::endpoint::detail::cpu_tensor<cpu_tensor_t<T>, stack_format_executor_t, detail::select_spectra_t>
template<typename T>
struct spectra_stack_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_impl<T, stack_format_executor_t, detail::select_spectra_t, spectra_stack_cuda_device_tensor<T>>
template<typename T>
struct spectra_stack_cuda_host_tensor : public vortex::endpoint::detail::cuda_host_tensor_impl<T, stack_format_executor_t, detail::select_spectra_t, spectra_stack_cuda_host_tensor<T>>
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>
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, 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 auto &inner_radius()
inline const auto &inner_radius() const
inline auto &outer_radius()
inline const auto &outer_radius() const
inline auto radial_pitch() const
inline spiral_waypoints_t()
inline void set_isotropic(size_t samples_per_second)
inline void set_hybrid(size_t samples_per_second)
inline auto to_waypoints() const
inline range_t<T> &volume_extent()
inline const range_t<T> &volume_extent() 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

Public Members

T angular_velocity = 10
T linear_velocity = 0
T acceleration_limit = 0
size_t rings_per_spiral = 10

Protected Functions

inline auto _cav_duration(T radius) const
inline auto _cav_spiral(const auto &t) const
inline auto _clv_duration(T radius) const
inline auto _clv_spiral(const auto &t) const
inline auto _clv_time_scale_setup() const
inline auto _clv_forward_time_scale(T t) const
template<typename E>
inline auto _clv_forward_time_scale(xt::xexpression<E> &t_in) const
inline auto _clv_inverse_time_scale(T s) const
template<typename E>
inline auto _clv_inverse_time_scale(xt::xexpression<E> &s_in) const
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
template<size_t index, typename T>
struct streams_stack_cpu_tensor : public vortex::endpoint::detail::cpu_tensor<cpu_tensor_t<T>, stack_format_executor_t, detail::select_streams_t<index>>
template<size_t index, typename T>
struct streams_stack_cuda_host_tensor : public vortex::endpoint::detail::cuda_host_tensor_impl<T, stack_format_executor_t, detail::select_streams_t<index>, streams_stack_cuda_host_tensor<index, T>>
template<size_t index, typename element_t>
struct streams_stack_storage : public vortex::endpoint::detail::stack_storage<stack_format_executor_t, simple_stack_t<element_t>, detail::select_streams_t<index>>
template<typename T, size_t N>
struct vortex::cuda::strided_t

Public Types

using shape_t = typename detail::ulonglong<N>::type
using stride_t = typename detail::longlong<N>::type

Public Functions

inline auto &operator[](size_t idx) const
inline strided_t(T *ptr_, shape_t &&shape_, stride_t &&stride_)
inline strided_t(T *ptr_, const std::array<size_t, N> &shape_, const std::array<ptrdiff_t, N> &stride_)

Public Members

T *ptr
shape_t shape
stride_t stride
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::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
class timeout : public vortex::imaq::exception
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 to_ring_buffer
template<typename ...Ts>
struct vortex::acquire::detail::to_ring_buffer<imaq_input_ts<Ts...>>

Public Types

using type = std::variant<cpu_tensor_t<Ts>...>
template<typename ...Ts>
struct to_tuple
template<typename ...Ts>
struct vortex::acquire::detail::to_tuple<imaq_input_ts<Ts...>>

Public Types

using type = std::tuple<Ts...>
struct vortex::acquire::trigger_output_t

Public Functions

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

Public Members

uInt32 line = 0
imaq::source_t source = imaq::source_t::hsync
imaq::polarity_t polarity = imaq::polarity_t::high
imaq::signal_t signal = imaq::signal_t::external
struct vortex::alazar::board_t::info_t::type_t

Public Members

U32 id
std::string model
template<size_t N>
struct ulonglong
template<>
struct vortex::cuda::detail::ulonglong<2>

Public Types

using type = ulonglong2
template<>
struct vortex::cuda::detail::ulonglong<3>

Public Types

using type = ulonglong3
template<>
struct vortex::cuda::detail::ulonglong<4>

Public Types

using type = ulonglong4
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< cpu_view_t< T > >, vortex::cpu_viewable< of_dimension< N > >, 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::engine::strobe::volume : public vortex::engine::strobe::detail::physical, public vortex::engine::strobe::detail::flagged

Public Functions

inline volume(size_t line_ = 0, polarity_t polarity_ = polarity_t::high, size_t duration_ = 10, size_t delay_ = 0, flags_t flags_ = flags_t::all())
auto operator<=>(const volume&) const = default
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
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 = std::variant<marker::scan_boundary, marker::volume_boundary, marker::segment_boundary, marker::active_lines, marker::inactive_lines, marker::event>
using default_marker_flags_t = vortex::marker::detail::base::flags_t
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 default_warp_t = std::variant<scan::warp::none_t, scan::warp::angular_t, scan::warp::telecentric_t>
using default_inactive_policy_t = std::variant<scan::inactive_policy::fixed_linear_t>
using freeform_scan_config_t = scan::freeform_config_t<double, default_inactive_policy_t, default_marker_t>
using freeform_scan_t = scan::freeform_scan_t<double, default_marker_t, freeform_scan_config_t>
using raster_scan_config_t = scan::raster_config_t<double, default_inactive_policy_t, default_warp_t, default_marker_t, default_marker_flags_t>
using raster_scan_t = scan::raster_scan_t<double, default_marker_t, raster_scan_config_t>
using repeated_raster_scan_config_t = scan::repeated_raster_config_t<double, default_inactive_policy_t, default_warp_t, default_marker_t, default_marker_flags_t>
using repeated_raster_scan_t = scan::raster_scan_t<double, default_marker_t, repeated_raster_scan_config_t>
using radial_scan_config_t = scan::radial_config_t<double, default_inactive_policy_t, default_warp_t, default_marker_t, default_marker_flags_t>
using radial_scan_t = scan::radial_scan_t<double, default_marker_t, radial_scan_config_t>
using repeated_radial_scan_config_t = scan::repeated_radial_config_t<double, default_inactive_policy_t, default_warp_t, default_marker_t, default_marker_flags_t>
using repeated_radial_scan_t = scan::radial_scan_t<double, default_marker_t, repeated_radial_scan_config_t>
using spiral_scan_config_t = scan::spiral_config_t<double, default_inactive_policy_t, default_warp_t, default_marker_t, default_marker_flags_t>
using spiral_scan_t = scan::spiral_scan_t<double, default_marker_t, spiral_scan_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)
std::string to_string(const std::exception &e, size_t level = 0)
std::string to_string(const std::exception_ptr &error)
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 = {})
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)
inline IMG_SIGNAL_TYPE cast(const imaq::signal_t &o)
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>>>
constexpr std::underlying_type_t<T> cast(const T &v)
bool check_keyboard_interrupt()
void setup_keyboard_interrupt()
void setup_keyboard_interrupt(interrupt_callback_t &&callback)
void setup_realtime()
void setup_tcp_low_latency()
void set_thread_name(const std::string &name)
std::string error_message_with_number()
std::string error_message_with_number(unsigned long error)
std::string error_message()
std::string error_message(unsigned long error)
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 volatile sig_atomic_t _keyboard_interrupt = 0
static std::function<void()> _keyboard_callback
namespace vortex::acquire

Typedefs

using default_clock_t = std::variant<clock::internal_t, clock::external_t>
using default_trigger_t = std::variant<trigger::single_external_t, trigger::dual_external_t>
using default_option_t = std::variant<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 class channel_t : U32

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 class coupling_t : U32

Values:

enumerator DC
enumerator AC
enum class clock_edge_t : U32

Values:

enumerator rising
enumerator falling
enum class trigger_slope_t : U32

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::string to_string(const clock_edge_t &v)
std::string to_string(const trigger_slope_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 std::array<channel_t, 16> all_channels = {{channel_t::A, channel_t::B, channel_t::C, channel_t::D, channel_t::E, channel_t::F, channel_t::G, channel_t::H, channel_t::I, channel_t::J, channel_t::K, channel_t::L, channel_t::M, channel_t::N, channel_t::P}}
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, const std::string&)
_LOOKUP_DECLARE(lookup_sampling_rate, size_t, U32)
_LOOKUP_DECLARE(lookup_supported_sampling_rate, const std::string&, const 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, const std::string&, const 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&)
_LOOKUP_DECLARE(lookup_features, std::string, const board_t::info_t::features_t&)
_LOOKUP_DECLARE(lookup_error_message, RETURN_CODE, const char*)
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)
inline ulonglong1 to_vec(const std::array<size_t, 1> &src)
inline ulonglong2 to_vec(const std::array<size_t, 2> &src)
inline ulonglong3 to_vec(const std::array<size_t, 3> &src)
inline ulonglong4 to_vec(const std::array<size_t, 4> &src)
inline longlong1 to_vec(const std::array<intmax_t, 1> &src)
inline longlong2 to_vec(const std::array<intmax_t, 2> &src)
inline longlong3 to_vec(const std::array<intmax_t, 3> &src)
inline longlong4 to_vec(const std::array<intmax_t, 4> &src)
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 class edge_t : int32

Values:

enumerator rising
enumerator falling
enum class terminal_t : int32

Values:

enumerator referenced
enumerator unreferenced
enumerator differential
enumerator pseudodifferential
enum class sample_mode_t : int32

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 class 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)>
using strobe_t = std::variant<strobe::sample, strobe::segment, strobe::volume, strobe::scan, strobe::event>

Enums

enum class 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 vortex::engine::strobe

Typedefs

using flags_t = vortex::default_marker_flags_t

Enums

enum class polarity_t

Values:

enumerator low
enumerator high
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::imaq

Enums

enum class signal_t

Values:

enumerator none
enumerator external
enumerator rtsi
enumerator iso_in
enumerator iso_out
enumerator status
enumerator scaled_encoder
enumerator software_trigger
enum class polarity_t : uInt32

Values:

enumerator low
enumerator high
enum class source_t : uInt32

Values:

enumerator disabled
enumerator acquisition_in_progress
enumerator acquisition_done
enumerator pixel_clock
enumerator unasserted
enumerator asserted
enumerator hsync
enumerator vsync
enumerator frame_start
enumerator frame_done
enumerator scaled_encoder

Functions

std::string to_string(const signal_t &v)
std::string to_string(const polarity_t &v)
std::string to_string(const source_t &v)
std::vector<std::string> enumerate()
std::string to_string(IMG_ERR error)

Variables

constexpr uInt32 current_frame = IMG_CURRENT_BUFFER
constexpr uInt32 infinite_timeout = IMG_TIMEOUT_INFINITE
namespace vortex::io
namespace channel
namespace detail
namespace marker
namespace detail
namespace motion
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 vortex::scan

Typedefs

template<typename T, typename inactive_policy_t, typename marker_t>
using freeform_config_t = detail::patterned_config_factory_t<T, inactive_policy_t, null_waypoints_t<T>, manual_pattern_t<T, marker_t>>
template<typename T, typename marker_t, typename config_t>
using freeform_scan_t = detail::patterned_scan_factory_t<T, marker_t, config_t>
template<typename T, typename inactive_policy_t, typename warp_t, typename marker_t, typename flags_t>
using radial_config_t = detail::patterned_config_factory_t<T, inactive_policy_t, radial_waypoints_t<T, warp_t>, sequential_pattern_t<marker_t, flags_t>>
template<typename T, typename inactive_policy_t, typename warp_t, typename marker_t, typename flags_t>
using repeated_radial_config_t = detail::patterned_config_factory_t<T, inactive_policy_t, radial_waypoints_t<T, warp_t>, repeated_pattern_t<marker_t, flags_t>>
template<typename T, typename marker_t, typename config_t>
using radial_scan_t = detail::patterned_scan_factory_t<T, marker_t, config_t>
template<typename T, typename inactive_policy_t, typename warp_t, typename marker_t, typename flags_t>
using raster_config_t = detail::patterned_config_factory_t<T, inactive_policy_t, raster_waypoints_t<T, warp_t>, sequential_pattern_t<marker_t, flags_t>>
template<typename T, typename inactive_policy_t, typename warp_t, typename marker_t, typename flags_t>
using repeated_raster_config_t = detail::patterned_config_factory_t<T, inactive_policy_t, raster_waypoints_t<T, warp_t>, repeated_pattern_t<marker_t, flags_t>>
template<typename T, typename marker_t, typename config_t>
using raster_scan_t = detail::patterned_scan_factory_t<T, marker_t, config_t>
template<typename T, typename inactive_policy_t, typename warp_t, typename marker_t, typename flags_t>
using spiral_config_t = detail::patterned_config_factory_t<T, inactive_policy_t, spiral_waypoints_t<T, warp_t>, sequential_pattern_t<marker_t, flags_t>>
template<typename T, typename marker_t, typename config_t>
using spiral_scan_t = detail::patterned_scan_factory_t<T, marker_t, config_t>
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 inactive_policy
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 class broct_scan_t : int32_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 class hdf5_stack_header_t

Values:

enumerator none
enumerator matlab
enum class simple_stream_header_t

Values:

enumerator none
enumerator raw
enum class 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

Defines

_DECLARE(factor_t, in_t, out_t)
file fft.hpp
file fft.hpp
file host.hpp
file file.hpp
file imaq.hpp
file imaq.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, const 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", const std::string &, const 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", const std::string &, const 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 &)
_LOOKUP_DEFINE (lookup_features, _features_map, "features requirements", std::string, const board_t::info_t::features_t &)
_LOOKUP_DEFINE (lookup_error_message, _error_message_map, "error message", RETURN_CODE, const char *)

Variables

static const std::unordered_map<U32, std::string> _board_kind_map
static const std::unordered_map<size_t, U32> _sampling_rate_map
static const 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}}, {"ATS9146", {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}}, {"ATS9371", {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}}, {"ATS9628", {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}}, {"ATS9872", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 250000000, 500000000, 1000000000}}, {"ATS9352", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000, 250000000, 500000000}}, {"ATS9353", {1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 125000000, 250000000, 500000000}},}
static const 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 const 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 const std::unordered_map<std::string, std::vector<impedance_input_range_t>> _supported_impedance_ohms_input_range_millivolts_map
static const 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 const std::unordered_map<size_t, U32> _trigger_range_volts_map = {{5000, ETR_5V}, {1000, ETR_1V}, {2500, ETR_2V5}, {0, ETR_TTL},}
static const 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}}, {"ATS9146", {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}}, {"ATS9352", {256, 32, 32}}, {"ATS9353", {256, 32, 32}}, {"ATS9872", {256, 32, 32}}, {"ATS9628", {256, 32, 32}},}
static const std::unordered_map<std::string, board_t::info_t::features_t> _features_map = {{"ATS460", {true, {}}}, {"ATS660", {true, {}}}, {"ATS860", {true, {}}}, {"ATS9350", {true, {}}}, {"ATS9351", {true, {}}}, {"ATS9352", {true, {}}}, {"ATS9353", {true, {}}}, {"ATS9360", {false, {50000000}}}, {"ATS9371", {false, {50000000}}}, {"ATS9373", {false, {50000000}}}, {"ATS9440", {true, {}}}, {"ATS9462", {true, {}}}, {"ATS9625", {true, {}}}, {"ATS9626", {true, {}}}, {"ATS9870", {true, {}}}, {"ATS9872", {true, {}}},}
static const std::unordered_map<RETURN_CODE, const char*> _error_message_map
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 imaq.cpp

Defines

IMAQ_MIN_BUFFER_LENGTH

Functions

template<typename ...Args>
static const void _handle_error(IMG_ERR error, const std::string &msg, Args... args)

Variables

static std::shared_mutex _callback_mutex
static std::unordered_map<SESSION_ID, imaq_t::callback_t> _callback_map
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
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/acquire/frame_grabber
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