C++ ReferenceΒΆ

struct acquire_config

Public Members

bool preload
bool master
process_graph_t graph
struct acquire_plan

Public Members

processor_sets rotation
size_t output_index
struct acquisition : public vortex::engine::adapter<block_t>::detail::base

Public Types

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

Public Functions

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

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<stride_t()> output_stride
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
std::function<void(block_t&, spectra_stream_t&)> recycle
struct active_lines : public vortex::marker::detail::base

Public Functions

auto operator<=>(const active_lines&) const = default
inline base()
inline base(counter_t sample_)
template<typename block_t>
struct 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>
using stride_t = std::array<ptrdiff_t, 3>
template<typename T>
class 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 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)

Protected Functions

inline size_t _next(size_t id, const viewable<V> &buffer_)
inline void _next_async(size_t id, const viewable<V> &buffer_, callback_t &&callback)
template<typename config_t_, typename board_t_>
class 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 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)

Public Members

struct vortex::acquire::detail::alazar_config_t::device_t device
template<typename clock_t_, typename trigger_t_, typename option_t_>
struct 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 = {alazar::clock::internal_t{}}
trigger_t trigger = {alazar::trigger::single_external_t{}}
std::vector<alazar::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 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 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

Public Functions

inline virtual void prepare() override
template<typename clock_t, typename trigger_t, typename option_t>
struct 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 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)

Protected Functions

inline size_t _next(size_t id, const viewable<V> &buffer_)
inline void _next_async(size_t id, const viewable<V> &buffer_, callback_t &&callback)
template<typename clock_t, typename trigger_t, typename option_t>
struct 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
struct vortex::acquire::detail::alazar_config_t::device_t device
template<typename T>
class 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, typename S2>
inline alazar_view_t(T *data, const bounds_t<T> &bounds, const S1 &shape, const S2 &stride, const cuda::device_t &device, const HANDLE &handle)
template<typename O, typename S1, typename S2>
inline alazar_view_t(const O &other, T *data, const S1 &shape, const S2 &stride)
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 T>
class 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, typename S2>
inline alazar_view_t(T *data, const bounds_t<T> &bounds, const S1 &shape, const S2 &stride, const cuda::device_t &device, const HANDLE &handle)
template<typename O, typename S1, typename S2>
inline alazar_view_t(const O &other, T *data, const S1 &shape, const S2 &stride)
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 alignment_info_t

Public Members

U32 min_record_size
U32 pretrigger_alignment
U32 resolution
struct analog_input_t : public vortex::daqmx::detail::analog_t

Subclassed by vortex::daqmx::channel::analog_voltage_input_t

struct analog_output_t : public vortex::daqmx::detail::analog_t

Subclassed by vortex::daqmx::channel::analog_voltage_output_t

struct analog_t : public vortex::daqmx::detail::base_t

Subclassed by vortex::daqmx::detail::analog_input_t, vortex::daqmx::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 analog_voltage_input_t : public vortex::daqmx::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 analog_voltage_output_t : public vortex::daqmx::detail::analog_output_t

Public Functions

inline void apply(daqmx::daqmx_t &daqmx, std::shared_ptr<spdlog::logger> &log) const
struct 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 array<double>

Public Static Attributes

static auto value = mxDOUBLE_CLASS
static auto name = "float64"
static auto flags = 0
template<>
struct array<float>

Public Static Attributes

static auto value = mxSINGLE_CLASS
static auto name = "float32"
static auto flags = 0
template<>
struct array<int16_t>

Public Static Attributes

static auto value = mxINT16_CLASS
static auto name = "int16"
static auto flags = 0
template<>
struct array<int32_t>

Public Static Attributes

static auto value = mxINT32_CLASS
static auto name = "int32"
static auto flags = 0
template<>
struct array<int64_t>

Public Static Attributes

static auto value = mxINT64_CLASS
static auto name = "int64"
static auto flags = 0
template<>
struct array<int8_t>

Public Static Attributes

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

Public Static Attributes

static auto value = array<T>::value
static auto flags = complex_flag
template<>
struct array<uint16_t>

Public Static Attributes

static auto value = mxUINT16_CLASS
static auto name = "uint16"
static auto flags = 0
template<>
struct array<uint32_t>

Public Static Attributes

static auto value = mxUINT32_CLASS
static auto name = "uint32"
static auto flags = 0
template<>
struct array<uint64_t>

Public Static Attributes

static auto value = mxUINT64_CLASS
static auto name = "uint64"
static auto flags = 0
template<>
struct array<uint8_t>

Public Static Attributes

static auto value = mxUINT8_CLASS
static auto name = "uint8"
static auto flags = 0
struct ascan_buffer

Public Members

ascan_stream_factory_t factory
std::optional<cuda::device_t> device
shape_t shape
stride_t stride
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_cuda_device_tensor : public vortex::endpoint::detail::cuda_device_tensor_impl<T, spiral_format_executor_t, detail::select_ascans_t, ascan_radial_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 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 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 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 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 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

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

Public Functions

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

Public Members

size_t stream = 0
size_t channel = 0
struct base_t
template<typename T, typename shape_t, typename stride_t>
class 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 &bounds() 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, const bounds_t<T> &bounds)

Protected Attributes

T *_data
bounds_t<T> _bounds
shape_t _shape
stride_t _stride
template<typename acquire_element_t_, typename process_element_t_, typename analog_element_t_, typename digital_element_t_>
struct 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<teledyne::teledyne_cpu_view_t<acquire_element_t>>, sync::lockable<teledyne::teledyne_cuda_view_t<acquire_element_t>>, 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 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}
class board_t

Public Functions

board_t(unsigned int board_index = 0)
~board_t()
const info_t &info() const
void *handle() const
void configure_sampling_clock(double sampling_frequency, double reference_frequency, ADQClockGenerator clock_generator, ADQReferenceClockSource reference_source, double delay_adjustment, int32_t low_jitter_mode_enabled)
void configure_trigger_source(ADQEventSource trigger_source, double periodic_trigger_frequency, int64_t horizontal_offset_samples, int32_t trigger_skip_factor)
void configure_trigger_sync(bool enable)
void configure_resampling(double relative_phase_increment, uint32_t record_length, uint32_t channel_mapping)
void configure_capture(uint32_t channel_mask, int64_t samples_per_record, int32_t records_per_buffer, int64_t records_per_acquisition, bool test_pattern_signal, int64_t sample_skip_factor)
void commit_configuration()
void start_capture()
void stop_capture()
size_t wait_and_copy_buffer(void *ptr, size_t index, const std::chrono::milliseconds &timeout)
size_t wait_and_lock_buffer(void **ptr, size_t index, const std::chrono::milliseconds &timeout)
void unlock_buffer(size_t buffer_index) const
bool valid() const
bool running() const

Protected Functions

size_t _wait_and_lock_buffer(void **ptr, size_t index, const std::chrono::milliseconds &timeout)
void _wait_for_buffer(size_t buffer_index, const std::chrono::milliseconds &timeout)
uint32_t _first_active_channel()

Protected Attributes

bool _started = false
void *_handle = nullptr
ADQParameters _adq
std::vector<size_t> _channels
std::mutex _mutex
info_t _info
template<typename T>
struct bounds_t : public vortex::range_t<T*>

Public Functions

inline operator bounds_t<const T>() const
template<typename config_t>
class 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

Public Members

config_t _config
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 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 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 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_overflow : public vortex::teledyne::exception
class buffer_underflow : public vortex::daqmx::exception
struct clock_t

Public Members

size_t sampling_frequency = 2'500'000'000
size_t reference_frequency = 10'000'000
clock_generator_t clock_generator = clock_generator_t::internal_pll
clock_reference_source_t reference_source = clock_reference_source_t::internal
size_t delay_adjustment = 0
bool low_jitter_mode_enabled = true
template<typename ...Args>
class 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 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 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()
inline const 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
size_t _channels_per_sample = 1
template<typename input_element_t_, typename output_element_t_, typename config_t_>
class 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 void _next_async(size_t id, const cpu_viewable<V1> &input_buffer_, const cpu_viewable<V2> &output_buffer_, callback_t &&callback)
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 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 T>
struct cpu_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

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 cpu_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 cpu_processor_t(std::shared_ptr<spdlog::logger> log = nullptr)
inline virtual ~cpu_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 cpu_viewable<V1> &input_buffer, const cpu_viewable<V2> &output_buffer, bool append_history = true)
template<typename V1, typename V2>
inline void next(size_t id, const cpu_viewable<V1> &input_buffer, const cpu_viewable<V2> &output_buffer, bool append_history = true)
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)
template<typename V1, typename V2>
inline void next_async(const cpu_viewable<V1> &input_buffer, const cpu_viewable<V2> &output_buffer, bool append_history, 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, bool append_history, callback_t &&callback)

Protected Types

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

Protected Functions

template<typename V1, typename V2>
inline void _next_async(size_t id, const cpu_viewable<V1> &input_buffer_, const cpu_viewable<V2> &output_buffer_, bool append_history, callback_t &&callback)
inline void _recalculate()
inline auto &_next_slot()
template<typename V1, typename V2>
inline void _process(slot_t &slot, size_t id, const cpu_viewable<V1> &input_buffer_, const cpu_viewable<V2> &output_buffer_, bool append_history)

Protected Attributes

std::shared_ptr<spdlog::logger> _log
std::optional<util::completion_worker_pool_t<std::exception_ptr>> _pool
std::mutex _mutex
sync::event_t _update_complete
size_t _next_slot_index = 0
std::vector<slot_t> _slots
xt::xtensor<float_element_t, 1> _resample_before_weight
xt::xtensor<float_element_t, 1> _resample_after_weight
xt::xtensor<index_element_t, 1> _resample_before_index
xt::xtensor<index_element_t, 1> _resample_after_index
cpu_tensor_t<input_element_t> _average_record_buffer
cpu_tensor_t<float_element_t> _average_record
size_t _average_record_index
size_t _average_record_count
config_t_ _config
template<typename tensor_t, typename executor_t, typename source_selector_t>
struct 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 cpu_tensor_t : public vortex::detail::tensor_impl_t<T>

Subclassed by vortex::sync::lockable< cpu_tensor_t< counter_t > >, vortex::sync::lockable< cpu_tensor_t< digital_element_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 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, typename S2>
inline cpu_view_t(const O &other, T *data, const S1 &shape, const S2 &stride)
template<typename V>
inline cpu_view_t(const cpu_viewable<V> &other)
inline auto to_xt()
inline auto to_xt() const
template<typename T>
class 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, typename S2>
inline cpu_view_t(const O &other, T *data, const S1 &shape, const S2 &stride)
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>

Subclassed by vortex::teledyne::teledyne_cpu_viewable< derived_t >

template<typename T>
struct cuda_complex_t
template<>
struct cuda_complex_t<double>

Public Types

using type = cuDoubleComplex
template<>
struct cuda_complex_t<float>

Public Types

using type = cuFloatComplex
template<typename T, typename executor_t, typename source_selector_t, typename derived_t>
struct 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, 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_)

Protected Attributes

std::shared_ptr<executor_t> _executor
std::shared_ptr<sync::lockable<cuda::cuda_device_tensor_t<T>>> _tensor
std::optional<std::vector<size_t>> _shape
std::shared_ptr<spdlog::logger> _log
template<typename T>
class 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
template<size_t N, typename U = T, typename = std::enable_if_t<std::is_same_v<T, U> || std::is_same_v<std::add_const_t<T>, U>>>
inline auto to_strided() const
template<size_t N, typename U, typename = std::enable_if_t<std::is_same_v<T, U> || std::is_same_v<std::add_const_t<T>, U>>>
inline operator const cuda::strided_t<U, N>() const

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 cuda_device_tensor_with_galvo_impl : public vortex::endpoint::detail::cuda_device_tensor_impl<T, executor_t, source_selector_t, derived_t>

Public Types

using base_t = 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
std::shared_ptr<executor_t> _executor
std::shared_ptr<sync::lockable<cuda::cuda_device_tensor_t<T>>> _tensor
std::optional<std::vector<size_t>> _shape
std::shared_ptr<spdlog::logger> _log
template<typename T, typename executor_t, typename source_selector_t, typename derived_t>
struct 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
std::shared_ptr<executor_t> _executor
std::shared_ptr<sync::lockable<cuda::cuda_host_tensor_t<T>>> _tensor
std::optional<std::vector<size_t>> _shape
std::shared_ptr<spdlog::logger> _log
template<typename T>
class 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 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
std::optional<size_t> clock_channel
bool interpret_as_signed = false
template<typename input_element_t_, typename output_element_t_, typename float_element_t_, typename index_element_t_, typename config_t_>
class 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)
inline auto _dispatch_block(slot_t &slot, size_t id, const cuda::fixed_cuda_view_t<const input_element_t, 2> &input_buffer_, const cuda::fixed_cuda_view_t<const input_element_t, 2> &clock_buffer_, const cuda::fixed_cuda_view_t<output_element_t, 2> &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, size_t N>
inline void _sync_with_device(const xt::xtensor<T, N> &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<index_element_t> _record_keys
cuda::cuda_device_tensor_t<index_element_t> _unused_counts
cuda::cuda_device_tensor_t<index_element_t> _sample_keys
cuda::cuda_device_tensor_t<float_element_t> _average_record_buffer
size_t _average_record_index
size_t _average_record_count
cuda::cuda_device_tensor_t<cuda::complex<float_element_t>> _complex_filter
config_t_ _config
template<typename derived_t_>
struct 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 cuda_tensor_impl : public vortex::endpoint::cuda_tensor<derived_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 cuda_type_t

Public Types

using type = T
template<>
struct cuda_type_t<std::complex<double>>

Public Types

using type = cuda_complex_t<double>::type
using type = std::complex<double>
template<>
struct cuda_type_t<std::complex<float>>

Public Types

using type = cuda_complex_t<float>::type
using type = std::complex<float>
template<typename T>
class 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, typename S2>
inline cuda_view_t(T *data, const bounds_t<T> bounds, const S1 &shape, const S2 &stride, const cuda::device_t &device)
template<typename O, typename S1, typename S2>
inline cuda_view_t(const O &other, T *data, const S1 &shape, const S2 &stride)
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, typename U = T, typename = std::enable_if_t<std::is_same_v<T, U> || std::is_same_v<std::add_const_t<T>, U>>>
inline auto to_strided() const
template<size_t N, typename U, typename = std::enable_if_t<std::is_same_v<T, U> || std::is_same_v<std::add_const_t<T>, U>>>
inline operator const cuda::strided_t<U, N>() const

Protected Attributes

cuda::device_t _device
template<typename T>
class 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, typename S2>
inline cuda_view_t(T *data, const bounds_t<T> bounds, const S1 &shape, const S2 &stride, const cuda::device_t &device)
template<typename O, typename S1, typename S2>
inline cuda_view_t(const O &other, T *data, const S1 &shape, const S2 &stride)
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, typename U = T, typename = std::enable_if_t<std::is_same_v<T, U> || std::is_same_v<std::add_const_t<T>, U>>>
inline auto to_strided() const
template<size_t N, typename U, typename = std::enable_if_t<std::is_same_v<T, U> || std::is_same_v<std::add_const_t<T>, U>>>
inline operator const cuda::strided_t<U, N>() 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< derived_t >, vortex::teledyne::teledyne_cuda_viewable< derived_t >

struct cycle_t

Public Members

std::vector<node> subgraph
template<typename channel_t_>
struct 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 clock
size_t blocks_to_buffer = 1
seconds readwrite_timeout = seconds(1)
std::vector<channel_t> channels
bool persistent_task = true
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 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

inline void _prepare_task()
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 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 datatype_helper<double>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<float>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<int16_t>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<int32_t>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<int64_t>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<int8_t>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<uint16_t>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<uint32_t>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<uint64_t>

Public Static Functions

static inline auto value()
template<>
struct datatype_helper<uint8_t>

Public Static Functions

static inline auto value()
struct 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 device_t

Public Members

U32 system_index = 1
U32 board_index = 1
struct digital_input_t : public vortex::daqmx::detail::digital_t

Public Functions

inline void apply(daqmx::daqmx_t &daqmx, std::shared_ptr<spdlog::logger> &log) const
struct digital_output_t : public vortex::daqmx::detail::digital_t

Public Functions

inline void apply(daqmx::daqmx_t &daqmx, std::shared_ptr<spdlog::logger> &log) const
struct digital_t : public vortex::daqmx::detail::base_t

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

Public Functions

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

Public Members

std::string line_name

Public Static Attributes

static size_t max_bits = 32
struct divide_t

Public Members

std::vector<node> subgraph
struct 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, vortex::acquire::teledyne_config_t

Public Functions

inline virtual ~dso_config_t()
inline virtual std::array<size_t, 3> shape() const
inline virtual std::array<ptrdiff_t, 3> stride() 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 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 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 dtype<double>

Public Static Attributes

static auto name = "float64"
template<>
struct dtype<float>

Public Static Attributes

static auto name = "float32"
template<>
struct dtype<int16_t>

Public Static Attributes

static auto name = "int16"
template<>
struct dtype<int32_t>

Public Static Attributes

static auto name = "int32"
template<>
struct dtype<int64_t>

Public Static Attributes

static auto name = "int64"
template<>
struct dtype<int8_t>

Public Static Attributes

static auto name = "int8"
template<>
struct dtype<std::complex<double>>

Public Static Attributes

static auto name = "complex128"
template<>
struct dtype<std::complex<float>>

Public Static Attributes

static auto name = "complex64"
template<>
struct dtype<uint16_t>

Public Static Attributes

static auto name = "uint16"
template<>
struct dtype<uint32_t>

Public Static Attributes

static auto name = "uint32"
template<>
struct dtype<uint64_t>

Public Static Attributes

static auto name = "uint64"
template<>
struct dtype<uint8_t>

Public Static Attributes

static auto name = "uint8"
struct 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
trigger_slope_t initial_slope = trigger_slope_t::positive
coupling_t coupling = coupling_t::DC
template<typename T, typename static_t_, typename dynamic_t>
class 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, typename S2>
inline dynamic_view_t(T *data, const bounds_t<T> &bounds, const S1 &shape, const S2 &stride)
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 index_right(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
inline auto &bounds() const
inline const auto &shape() const
inline auto shape(size_t idx) const
inline const auto &stride() const
inline auto stride</