DocMap¶

template<int N, typename T> struct icrar::detail::_fixed

Public Members

T _val

struct icrar::detail::_memory_amount

Public Members

std::size_t _val

struct icrar::detail::_microseconds_amount

Public Members

std::chrono::microseconds::rep _val

struct icrar::ArgumentsDTO

#include <Arguments.h>

Typed arguments of CLIArgumentsDTO.

Public Functions

ArgumentsDTO() = default

ArgumentsDTO(CLIArgumentsDTO &&args)

Public Members

boost::optional<InputType> inputType: MeasurementSet source type.

boost::optional<std::string> filePath: MeasurementSet filepath.

boost::optional<std::string> configFilePath: Optional config filepath.

boost::optional<StreamOutType> streamOutType

boost::optional<std::string> outputFilePath: Calibration output file, print to terminal if empty.

boost::optional<int> stations

boost::optional<unsigned int> referenceAntenna

boost::optional<std::vector<SphericalDirection>> directions

boost::optional<ComputeImplementation> computeImplementation

boost::optional<Slice> solutionInterval

boost::optional<double> minimumBaselineThreshold

boost::optional<bool> readAutocorrelations

boost::optional<bool> mwaSupport

boost::optional<icrar::log::Verbosity> verbosity

boost::optional<bool> useFileSystemCache: Whether to update a file cache for fast inverse matrix loading.

boost::optional<bool> useIntermediateBuffer: Whether to allocate intermediate buffers for reduced cpu->gpu copies.

boost::optional<bool> useCusolver: Whether to use cusolverDn for matrix inversion.

class icrar::ArgumentsValidated

#include <Arguments.h>

Validated set of command line arguments required to perform leap calibration

Public Functions

ArgumentsValidated(ArgumentsDTO &&cliArgs)

void ApplyArguments(ArgumentsDTO &&args)

Overwrites the stored set of arguments.

Parameters

args:

void Validate() const

boost::optional<std::string> GetOutputFilePath() const

std::unique_ptr<std::ostream> CreateOutputStream(double startEpoch = 0.0) const

StreamOutType GetStreamOutType() const

Gets the configuration for output stream type.

Return: StreamOutType

MeasurementSet &GetMeasurementSet()

Gets the user specifified measurement set.

Return: MeasurementSet&

const std::vector<SphericalDirection> &GetDirections() const

ComputeImplementation GetComputeImplementation() const

Slice GetSolutionInterval() const

boost::optional<unsigned int> GetReferenceAntenna() const

double GetMinimumBaselineThreshold() const

Gets the minimum baseline threshold in meteres. Baselines of length beneath the threshold are to be filtered/flagged.

Return: double baseline threshold length in meters

ComputeOptionsDTO GetComputeOptions() const

Gets configured options related to compute performance.

Return: ComputeOptionsDTO

icrar::log::Verbosity GetVerbosity() const

Gets the configured logging verbosity.

Return: icrar::log::Verbosity

Private Functions

ArgumentsDTO ParseConfig(const std::string &configFilepath)¶

Converts a JSON file to a config.

Return

Config

Parameters

configFilepath:

void ParseConfig(const std::string &configFilepath, ArgumentsDTO &args)¶

Converts a JSON file to a config.

Parameters

configFilepath:
args:

Private Members

InputType m_inputType¶: Constants

boost::optional<std::string> m_filePath¶: MeasurementSet filepath.

boost::optional<std::string> m_configFilePath¶: Config filepath.

StreamOutType m_streamOutType¶

boost::optional<std::string> m_outputFilePath¶: Calibration output filepath.

boost::optional<int> m_stations¶: Overriden number of stations (will be removed in a later release)

boost::optional<unsigned int> m_referenceAntenna¶: Index of the reference antenna.

std::vector<SphericalDirection> m_directions¶: Calibration directions.

ComputeImplementation m_computeImplementation¶: Specifies the implementation for calibration computation.

Slice m_solutionInterval¶: Specifies the interval to calculate solutions for.

double m_minimumBaselineThreshold¶: Minimum baseline length otherwise flagged at runtime.

bool m_readAutocorrelations¶: Adjusts the number of baselines calculation to include autocorrelations.

bool m_mwaSupport¶: Negates baselines when enabled.

icrar::log::Verbosity m_verbosity¶: Defines logging level for std::out.

ComputeOptionsDTO m_computeOptions¶: Defines options for compute performance tweaks.

std::unique_ptr<MeasurementSet> m_measurementSet¶: Resources

class band_data

Public Functions

band_data()

Private Members

size_t channelCount¶

double frequencyStep¶

std::unique_ptr<std::vector<double>> channelFrequencies¶

class icrar::cpu::BeamCalibration

#include <BeamCalibration.h>

Contains the results of leap calibration for a single direction.

Public Functions

BeamCalibration(SphericalDirection direction, Eigen::MatrixXd calibration)

Construct a new Direction Calibration object.

Parameters

direction: direciton of calibration
calibration: calibration of each antenna for the given direction

BeamCalibration(const std::pair<SphericalDirection, Eigen::MatrixXd> &beamCalibration)

bool IsApprox(const BeamCalibration &beamCalibration, double threshold)

const SphericalDirection &GetDirection() const

Gets the calibration direction.

Return: const SphericalDirection

const Eigen::MatrixXd &GetPhaseCalibration() const

Get the phase calibration Vector for the antenna array in the specified direction.

Return: const Eigen::MatrixXd

void Serialize(std::ostream &os, bool pretty = false) const

Serializes the beam calibration to JSON format.

Parameters

os: JSON output stream

template<typename Writer> void Write(Writer &writer) const

Public Static Functions

BeamCalibration Parse(const rapidjson::Value &doc)

Private Members

SphericalDirection m_direction¶

Eigen::MatrixXd m_calibration¶

class icrar::cpu::Calibration

#include <Calibration.h>

Contains a single calibration solution.

Public Functions

Calibration(double startEpoch, double endEpoch)

Creates an empty calibration.

Parameters

startEpoch:
endEpoch:

Calibration(double startEpoch, double endEpoch, std::vector<cpu::BeamCalibration> &&beamCalibrations)

double GetStartEpoch() const

double GetEndEpoch() const

bool IsApprox(const Calibration &calibration, double threshold)

const std::vector<BeamCalibration> &GetBeamCalibrations() const

std::vector<BeamCalibration> &GetBeamCalibrations()

void Serialize(std::ostream &os, bool pretty = false) const

template<typename Writer> void Write(Writer &writer) const

Public Static Functions

Calibration Parse(const std::string &json)

Calibration Parse(const rapidjson::Value &doc)

Private Members

double m_startEpoch¶

double m_endEpoch¶

std::vector<BeamCalibration> m_beamCalibrations¶

class icrar::cpu::CalibrationCollection

#include <CalibrationCollection.h>

Contains a collection of calibrations.

Public Functions

CalibrationCollection(std::vector<cpu::Calibration> &&calibrations)

const std::vector<cpu::Calibration> &GetCalibrations() const

void Serialize(std::ostream &os, bool pretty = false) const

void Write(rapidjson::PrettyWriter<rapidjson::StringBuffer> &writer) const

Private Members

std::vector<cpu::Calibration> m_calibrations¶

class channel_info

Public Functions

channel_info(double frequency, double width)

Private Members

double frequency¶

double width¶

struct icrar::CLIArgumentsDTO

#include <Arguments.h>

Raw arguments received via the command line interface using boost::program_options. Only raw types std::string, bool, int, uint, float and double are allowed here.

Public Members

boost::optional<std::string> inputType

boost::optional<std::string> filePath

boost::optional<std::string> configFilePath

boost::optional<std::string> streamOutType

boost::optional<std::string> outputFilePath

boost::optional<int> stations

boost::optional<unsigned int> referenceAntenna

boost::optional<std::string> directions

boost::optional<std::string> computeImplementation

boost::optional<std::string> solutionInterval

boost::optional<double> minimumBaselineThreshold

boost::optional<bool> mwaSupport

boost::optional<bool> readAutocorrelations

boost::optional<int> verbosity

boost::optional<bool> useFileSystemCache

boost::optional<bool> useIntermediateBuffer

boost::optional<bool> useCusolver

Public Static Functions

CLIArgumentsDTO GetDefaultArguments()

class icrar::cuda::ComputeDevice

Private Members

cublasHandle_t m_cublasContext¶

cublasLtHandle_t m_cublasLtContext¶

cusolverDnHandle_t m_cusolverDnContext¶

struct icrar::ComputeOptionsDTO

#include <ComputeOptionsDTO.h>

Options received from I/O that optimizes computation performance based on input data and hardware configuration. Can either be overriden by the user or intelligently determined at runtime if not set.

Public Functions

bool IsInitialized() const

Public Members

boost::optional<bool> isFileSystemCacheEnabled: Enables caching of expensive calculations to the filesystem.

boost::optional<bool> useIntermediateBuffer

boost::optional<bool> useCusolver

class icrar::cuda::ConstantBuffer

#include <DeviceMetaData.h>

Container class of uniform gpu buffers available to all cuda threads that are const/immutable per calibration.

Public Functions

ConstantBuffer(const icrar::cpu::Constants &constants, device_matrix<double> &&A, device_vector<int> &&I, device_matrix<double> &&Ad, device_matrix<double> &&A1, device_vector<int> &&I1, device_matrix<double> &&Ad1)

Construct a new Constant Buffer object.

Parameters

constants:
A:
I:
Ad:
A1:
I1:
Ad1:

const icrar::cpu::Constants &GetConstants() const

const device_matrix<double> &GetA() const

const device_vector<int> &GetI() const

const device_matrix<double> &GetAd() const

const device_matrix<double> &GetA1() const

const device_vector<int> &GetI1() const

const device_matrix<double> &GetAd1() const

void ToHost(icrar::cpu::MetaData &host) const

void ToHostAsync(icrar::cpu::MetaData &host) const

Private Members

icrar::cpu::Constants m_constants¶

device_matrix<double> m_A¶

device_vector<int> m_I¶

device_matrix<double> m_Ad¶

device_matrix<double> m_A1¶

device_vector<int> m_I1¶

device_matrix<double> m_Ad1¶

struct icrar::cpu::Constants

#include <MetaData.h>

Container of variables that do not change throughout calibration.

Public Functions

__host__ __device__ double GetChannelWavelength(int i) const

bool operator==(const Constants &rhs) const

Public Members

uint32_t nbaselines

uint32_t referenceAntenna

uint32_t channels

uint32_t num_pols

uint32_t stations

uint32_t rows

double freq_start_hz

double freq_inc_hz

double phase_centre_ra_rad

double phase_centre_dec_rad

double dlm_ra

double dlm_dec

class icrar::CpuComputeOptions

Public Functions

CpuComputeOptions(const ComputeOptionsDTO &dto, const icrar::MeasurementSet &ms)

Determines ideal calibration compute options for a given MeasurementSet.

Parameters

computeOptions:
ms:

bool IsFileSystemCacheEnabled() const

Private Members

bool m_isFileSystemCacheEnabled¶: Enables caching of expensive calculations to the filesystem.

class icrar::cpu::CpuLeapCalibrator : public icrar::ILeapCalibrator

Public Functions

void Calibrate(std::function<void(const cpu::Calibration&)> outputCallback, const icrar::MeasurementSet &ms, const std::vector<SphericalDirection> &directions, const Slice &solutionInterval, double minimumBaselineThreshold, boost::optional<unsigned int> referenceAntenna, const ComputeOptionsDTO &computeOptions, ) override

Interface for Leap calibration implementations.

Calibrates by performing phase rotation for each direction in directions by splitting uvws into integration batches per timestep.

Public Static Functions

void PhaseRotate(MetaData &metadata, const SphericalDirection &direction, std::vector<Integration> &input, std::vector<BeamCalibration> &output_calibrations)

Performs rotation, summing and calibration for direction.

Parameters

metadata: metadata object containing data required for calibration
direction: the direction to calibrate for
input: batches of uvws and visibilities to process
output_calibrations: output calibration from summing a function of uvws and visibilities

void RotateVisibilities(Integration &integration, MetaData &metadata)

Performs averaging over each baseline, channel and polarization.

Parameters

integration: The input integration batch of uvws and visibilities
metadata: The metadata object where AverageData is written to

class icrar::CudaComputeOptions

#include <CudaComputeOptions.h>

Validates and determines the best compute features for calibration depending on measurement set data and hardware configuration.

Public Functions

CudaComputeOptions(const ComputeOptionsDTO &computeOptions, const icrar::MeasurementSet &ms, const Range &solutionRange)

Determines ideal calibration compute options for a given measurementSet.

Parameters

computeOptions:
ms:

Public Members

bool isFileSystemCacheEnabled: Enables caching of expensive calculations to the filesystem.

bool useIntermediateBuffer: enables an intermediate buffer containing unrotated visibilities to improve per direction performance

bool useCusolver: Uses cusolver for Ad calculation.

class icrar::cuda::CudaLeapCalibrator : public icrar::ILeapCalibrator

#include <CudaLeapCalibrator.h>

LEAP calibration object implemented using CUDA.

Public Functions

CudaLeapCalibrator()

~CudaLeapCalibrator() override

void Calibrate(std::function<void(const cpu::Calibration&)> outputCallback, const icrar::MeasurementSet &ms, const std::vector<SphericalDirection> &directions, const Slice &solutionInterval, double minimumBaselineThreshold, boost::optional<unsigned int> referenceAntenna, const ComputeOptionsDTO &computeOptions, ) override

Interface for Leap calibration implementations.

Calibrates by performing phase rotation for each direction in directions by splitting uvws and visibilities into integration batches per timestep.

void CalculateAd(const Eigen::MatrixXd &hostA, device_matrix<double> &deviceA, Eigen::MatrixXd &hostAd, device_matrix<double> &deviceAd, bool isFileSystemCacheEnabled, bool useCuda)

Calculates Ad into deviceAd, writes to cache if isFileSystemCacheEnabled is true.

Parameters

hostA: matrix to invert
deviceA: output device memory of A
hostAd: output host memory of Ad (optionally written to)
deviceAd: output device memory of Ad
isFileSystemCacheEnabled: whether to use file caching
useCuda: whether to use cuda solvers

void CalculateAd1(const Eigen::MatrixXd &hostA1, device_matrix<double> &deviceA1, Eigen::MatrixXd &hostAd1, device_matrix<double> &deviceAd1)

Calculates Ad1 into deviceAd1.

Parameters

hostA1: matrix to invert
deviceA1: output device memory of A1
hostAd1: output host memory of Ad1 (optionally written to)
deviceAd1: output device memory of Ad1

void PhaseRotate(const cpu::MetaData &hostMetadata, DeviceMetaData &deviceMetadata, const SphericalDirection &direction, cuda::DeviceIntegration &input, std::vector<cpu::BeamCalibration> &output_calibrations): Performs only visibilities rotation on the GPU

Private Members

cublasHandle_t m_cublasContext¶

cusolverDnHandle_t m_cusolverDnContext¶

template<typename T> class icrar::cuda::device_matrix : private noncopyable

#include <device_matrix.h>

A cuda device buffer object that represents a memory buffer on a cuda device. Matrix size is fixed at construction and can only be resized using move semantics.

Note

See https://www.quantstart.com/articles/Matrix-Matrix-Multiplication-on-the-GPU-with-Nvidia-CUDA/

Note

See https://forums.developer.nvidia.com/t/guide-cudamalloc3d-and-cudaarrays/23421

Template Parameters

T: numeric type

Public Functions

device_matrix(): Default constructor.

device_matrix(device_matrix &&other) noexcept

Move Constructor.

Parameters

other:

device_matrix &operator=(device_matrix &&other) noexcept

Move Assignment Operator.

Return

device_matrix&

Parameters

other:

device_matrix(size_t rows, size_t cols, const T *data = nullptr)

Construct a new device matrix object of fixed size and initialized asyncronously if data is provided.

Parameters

rows: number of rows
cols: number of columns
data: constigous column major data of size rows*cols*sizeof(T) to copy to device

device_matrix(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> &data)

template<int Rows, int Cols> device_matrix(const Eigen::Matrix<T, Rows, Cols> &data)

~device_matrix()

__host__ __device__ T *Get()

__host__ __device__ const T *Get() const

__host__ __device__ size_t GetRows() const

__host__ __device__ size_t GetCols() const

__host__ __device__ size_t GetCount() const

__host__ __device__ size_t GetSize() const

__host__ void SetZeroAsync()

__host__ void SetDataSync(const T *data)

Performs a synchronous copy of data into the device buffer.

Return

host

Parameters

data:

__host__ void SetDataAsync(const T *data)

Set the Data Async object.

Return

host

Parameters

data:

__host__ void ToHost(T *out) const

__host__ void ToHost(std::vector<T> &out) const

__host__ void ToHost(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> &out) const

template<int Rows, int Cols> __host__ void ToHost(Eigen::Matrix<T, Rows, Cols> &out) const

__host__ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> ToHost() const

__host__ void ToHostAsync(T *out) const

__host__ void ToHostAsync(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> &out) const

__host__ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> ToHostAsync() const

Private Members

size_t m_rows¶

size_t m_cols¶

T *m_buffer¶

template<typename T> class icrar::cuda::device_tensor3

#include <device_tensor.h>

A cuda device buffer object that represents a memory buffer on a cuda device.

Note

See https://www.quantstart.com/articles/Matrix-Matrix-Multiplication-on-the-GPU-with-Nvidia-CUDA/

Note

See https://forums.developer.nvidia.com/t/guide-cudamalloc3d-and-cudaarrays/23421

Template Parameters

T:

Public Functions

device_tensor3(size_t sizeDim0, size_t sizeDim1, size_t sizeDim2, const T *data = nullptr)

device_tensor3(const Eigen::Tensor<T, 3> &tensor)

device_tensor3(device_tensor3 &&other)

Copy Constructor.

Parameters

other:

device_tensor3 &operator=(device_tensor3 &&other) noexcept

~device_tensor3()

__host__ __device__ T *Get()

__host__ __device__ const T *Get() const

__host__ __device__ size_t GetDimensionSize(int dim) const

__host__ __device__ Eigen::DSizes<Eigen::DenseIndex, 3> GetDimensions() const

__host__ __device__ size_t GetCount() const

Gets the total number of elements in the tensor.

Return: host

__host__ __device__ size_t GetSize() const

Gets the total number of elements in the tensor.

Return: host

__host__ __device__ size_t GetByteSize() const

Gets the total number of bytes in the memory buffer.

Return: host

__host__ void SetDataSync(const T *data)

Performs a synchronous copy of data into the device buffer.

Return

host

Parameters

data:

__host__ void SetDataAsync(const T *data)

Set the Data asyncronously from host memory.

Return

host

Parameters

data:

__host__ void SetDataAsync(const device_tensor3<T> &data)

__host__ void ToHost(T *out) const

__host__ void ToHost(std::vector<T> &out) const

__host__ void ToHost(Eigen::Tensor<T, 3> &out) const

__host__ void ToHostAsync(T *out) const

Private Members

size_t m_sizeDim0¶

size_t m_sizeDim1¶

size_t m_sizeDim2¶

T *m_buffer = nullptr¶

template<typename T> class icrar::cuda::device_vector : private noncopyable

#include <device_vector.h>

A cuda device buffer object that represents a memory buffer on a cuda device.

Note

See https://www.quantstart.com/articles/Matrix-Matrix-Multiplication-on-the-GPU-with-Nvidia-CUDA/

Note

See https://forums.developer.nvidia.com/t/guide-cudamalloc3d-and-cudaarrays/23421

Template Parameters

T: numeric type

Public Functions

device_vector(): Default constructor.

__host__ device_vector(device_vector &&other) noexcept

__host__ device_vector &operator=(device_vector &&other) noexcept

__host__ device_vector(size_t count, const T *data = nullptr)

Construct a new device buffer object.

Parameters

size:
data:

__host__ device_vector(const std::vector<T> &data)

__host__ device_vector(const Eigen::Matrix<T, Eigen::Dynamic, 1> &data)

__host__ device_vector(const Eigen::Matrix<T, 1, Eigen::Dynamic> &data)

__host__ ~device_vector()

__host__ __device__ T *Get()

__host__ __device__ const T *Get() const

__host__ __device__ size_t GetCount() const: Gets the number of elements in the buffer.

__host__ __device__ size_t GetRows() const: Gets the number of rows in the column vector.

__host__ __device__ constexpr size_t GetCols() const

__host__ __device__ size_t GetSize() const: Gets the buffer size in bytes.

__host__ void SetZeroAsync()

__host__ void SetDataSync(const T *data)

Performs a synchronous copy of data into the device buffer.

Pre

data points to a buffer of byte size >= GetSize()

Parameters

data: data buffer for host to device copying

__host__ void SetDataAsync(const T *data)

Sets buffer data from pinned host memory.

Pre

Heap memory must be pinned using cudaHostRegister(…, cudaHostRegisterPortable)

Pre

data points to a buffer of byte size >= GetSize()

Parameters

data: data buffer for host to device copying

__host__ void ToHost(T *out) const

__host__ void ToHost(std::vector<T> &out) const

__host__ void ToHost(Eigen::Matrix<T, Eigen::Dynamic, 1> &out) const

__host__ void ToHostAsync(T *out) const

Sets buffer data from pinned host memory.

Pre

Heap memory must be pinned using cudaHostRegister(…, cudaHostRegisterPortable)

Pre

data points to a buffer of byte size >= GetSize()

Parameters

data: data buffer for device to host copying

__host__ void ToHostAsync(std::vector<T> &out) const

__host__ void ToHostAsync(Eigen::Matrix<T, Eigen::Dynamic, 1> &out) const

__host__ Eigen::Matrix<T, Eigen::Dynamic, 1> ToHostAsync() const

Private Members

size_t m_count¶

T *m_buffer = nullptr¶

class icrar::cuda::DeviceIntegration

#include <DeviceIntegration.h>

A Cuda memory buffer instance of visibility data for integration.

Public Functions

DeviceIntegration(int integrationNumber, Eigen::DSizes<Eigen::DenseIndex, 3> shape)

Construct a new Device Integration object where visibilities is a zero tensor of .

Parameters

shape:

DeviceIntegration(const icrar::cpu::Integration &integration)

Construct a new Device Integration object with a data syncronous copy.

Parameters

integration:

__host__ void Set(const icrar::cpu::Integration &integration)

Set the Data object.

Parameters

integration:

__host__ void Set(const icrar::cuda::DeviceIntegration &integration)

Set the Data object.

Parameters

integration:

int GetIntegrationNumber() const

size_t GetIndex() const

size_t GetChannels() const

size_t GetBaselines() const

const device_tensor3<std::complex<double>> &GetVis() const

device_tensor3<std::complex<double>> &GetVis()

__host__ void ToHost(cpu::Integration &host) const

Copies device data to a host object.

Parameters

host: object with data on cpu memory

Private Members

int m_integrationNumber¶

device_tensor3<std::complex<double>> m_visibilities¶

size_t index¶

size_t x¶

size_t channels¶

size_t baselines¶

class icrar::cuda::DeviceMetaData

#include <DeviceMetaData.h>

Represents the complete collection of MetaData that resides on the GPU for leap-calibration

Public Functions

DeviceMetaData(DeviceMetaData &&other) noexcept = default

DeviceMetaData &operator=(DeviceMetaData &&other) noexcept = default

DeviceMetaData(const icrar::cpu::MetaData &metadata)

Construct a new Device MetaData object from the equivalent object on CPU memory. This copies to all device buffers.

Parameters

metadata:

DeviceMetaData(std::shared_ptr<ConstantBuffer> constantBuffer, std::shared_ptr<SolutionIntervalBuffer> SolutionIntervalBuffer, std::shared_ptr<DirectionBuffer> directionBuffer)

Construct a new Device MetaData object from the equivalent object on CPU memory. This copies to all device buffers.

Parameters

constantBuffer:
SolutionIntervalBuffer:
directionBuffer:

const icrar::cpu::Constants &GetConstants() const

const device_vector<icrar::MVuvw> &GetUVW() const

const SphericalDirection &GetDirection() const

const Eigen::Matrix3d &GetDD() const

const ConstantBuffer &GetConstantBuffer() const

const device_matrix<std::complex<double>> &GetAvgData() const

device_matrix<std::complex<double>> &GetAvgData()

void SetAvgData(int v)

void ToHost(icrar::cpu::MetaData &host) const

icrar::cpu::MetaData ToHost() const

void ToHostAsync(icrar::cpu::MetaData &host) const

Private Members

std::shared_ptr<ConstantBuffer> m_constantBuffer¶

std::shared_ptr<SolutionIntervalBuffer> m_solutionIntervalBuffer¶

std::shared_ptr<DirectionBuffer> m_directionBuffer¶

class icrar::cuda::DirectionBuffer

#include <DeviceMetaData.h>

MetaData Variables allocated per direction.

Public Functions

DirectionBuffer(const SphericalDirection &direction, const Eigen::Matrix3d &dd, const Eigen::MatrixXcd &avgData)

Constructs a new Direction Buffer object initializing all memory.

Parameters

uvw:
direction:
dd:
avgData:

DirectionBuffer(int avgDataRows, int avgDataCols)

Constructs a new Direction Buffer object for late initialization.

Parameters

avgDataRows:
avgDataCols:

const SphericalDirection &GetDirection() const

const Eigen::Matrix3d &GetDD() const

device_matrix<std::complex<double>> &GetAvgData()

void SetDirection(const SphericalDirection &direction)

void SetDD(const Eigen::Matrix3d &dd)

Private Members

SphericalDirection m_direction¶

Eigen::Matrix3d m_dd¶

device_matrix<std::complex<double>> m_avgData¶

class icrar::exception : public exception

#include <exception.h>

Generic exception with source tracing.

Subclassed by icrar::file_exception, icrar::invalid_argument_exception, icrar::json_exception, icrar::not_implemented_exception

Public Functions

exception(const std::string &msg, const std::string &file, int line)

Constructs a new exception object.

Parameters

msg: exception reason
file: exception file location
line: exception line location

const char *what() const noexcept override

Private Members

std::string m_message¶

class icrar::file_exception : public icrar::exception

#include <exception.h>

Exception raised when a file system operation fails.

Public Functions

file_exception(const std::string &msg, const std::string &filename, const std::string &file, int line)

class icrar::cuda::HostIntegration : public icrar::cpu::Integration

#include <HostIntegration.h>

A cuda decorator for cpu::Integration. This class stores data on the host using pinned memory to allow for asyncronous read and write with cuda.

Public Functions

HostIntegration(int integrationNumber, const icrar::MeasurementSet &ms, unsigned int index, unsigned int channels, unsigned int baselines, unsigned int polarizations)

~HostIntegration()

class icrar::cuda::HostMetaData : public icrar::cpu::MetaData

#include <HostMetaData.h>

A cuda decorator for for cpu::Integration. This class stores data on the host using pinned memory to allow for asyncronous read and write with cuda.

Public Functions

HostMetaData(const icrar::MeasurementSet &ms, boost::optional<unsigned int> refAnt, double minimumBaselineThreshold, bool computeInverse, bool useCache)

~HostMetaData()

class icrar::ILeapCalibrator : private noncopyable

#include <ILeapCalibrator.h>

Interface for Leap calibration implementations.

Subclassed by icrar::cpu::CpuLeapCalibrator, icrar::cuda::CudaLeapCalibrator

Public Functions

~ILeapCalibrator() = default

void Calibrate(std::function<void(const cpu::Calibration&)> outputCallback, const icrar::MeasurementSet &ms, const std::vector<SphericalDirection> &directions, const Slice &solutionInterval, double minimumBaselineThreshold, boost::optional<unsigned int> referenceAntenna, const ComputeOptionsDTO &computeOptions, ) = 0

Performs Leap calibration for single or multiple solutions.

Return

CalibrationCollection the calibrationn result

Parameters

ms: the mesurement set containing all input measurements
directions: the directions to calibrate for
minimumBaselineThreshold: the minimum baseline length to use in calibrations
solutionInterval: the arbitrary interval to calculate solutions for
referenceAntenna: the reference antenna of metrix A1
isFileSystemCacheEnabled: enable to use the filesystem to cache data between calibration calls

class icrar::cpu::Integration

#include <Integration.h>

A container for storing a visibilities tensor for accumulation during phase rotating.

Subclassed by icrar::cuda::HostIntegration

Public Functions

Integration(int integrationNumber, const icrar::MeasurementSet &ms, uint32_t index, uint32_t channels, uint32_t baselines, uint32_t polarizations)

bool operator==(const Integration &rhs) const

int GetIntegrationNumber() const

size_t GetBaselines() const

Gets the number of baselines.

Return: int

const std::vector<icrar::MVuvw> &GetUVW() const

Gets the UVW list.

Return: const std::vector<icrar::MVuvw>&

std::vector<icrar::MVuvw> &GetUVW()

const Eigen::Tensor<std::complex<double>, 3> &GetVis() const

Get the Visibilities object of size (polarizations, baselines, channels)

Return: Eigen::Tensor<std::complex<double>, 3>&

Eigen::Tensor<std::complex<double>, 3> &GetVis()

Get the Visibilities object of size (polarizations, baselines, channels)

Return: Eigen::Tensor<std::complex<double>, 3>&

Protected Attributes

int m_integrationNumber

int64_t index

int64_t x

int64_t channels

int64_t baselines

std::vector<MVuvw> m_UVW

Eigen::Tensor<std::complex<double>, 3> m_visibilities

Friends

friend class icrar::cuda::DeviceIntegration

class icrar::invalid_argument_exception : public icrar::exception

#include <exception.h>

Exception raised when an invalid argument is passed into a function.

Public Functions

invalid_argument_exception(const std::string &msg, const std::string &arg, const std::string &file, int line)

class icrar::json_exception : public icrar::exception

#include <exception.h>

Exception raised when parsing invalid json.

Public Functions

json_exception(const std::string &msg, const std::string &file, int line)

class icrar::LeapCalibratorFactory

#include <LeapCalibratorFactory.h>

Factory class for creating a specialized LEAP calibrator.

Public Static Functions

std::unique_ptr<ILeapCalibrator> Create(ComputeImplementation impl)

Creates a calibrator object that performs leap calibration with specified implementation.

Return

std::unique_ptr<ILeapCalibrator>

Parameters

impl:

Private Functions

LeapCalibratorFactory() = delete¶

template<typename T> struct icrar::matrix_hash : public std::unary_function<T, size_t>

#include <eigen_cache.h>

Hash function for Eigen matrix and vector. The code is from hash_combine function of the Boost library. See http://www.boost.org/doc/libs/1_55_0/doc/html/hash/reference.html#boost.hash_combine .

Template Parameters

T: Eigen Dense Matrix type

Public Functions

std::size_t operator()(const T &matrix) const

class icrar::MeasurementSet

#include <MeasurementSet.h>

Provides an abstraction layer around a casacore MeasurementSet that provides all data required for leap calibration. This class additionally stores runtime user specificed variables and cached variabled calculated from the underlying measurement set.

Public Functions

MeasurementSet(const std::string &filepath, boost::optional<int> overrideNStations, bool readAutocorrelations)

boost::optional<std::string> GetFilepath() const

const casacore::MeasurementSet *GetMS() const

Gets a non-null pointer to a casacore::MeasurementSet.

Return: const casacore::MeasurementSet*

const casacore::MSMainColumns *GetMSMainColumns() const

Gets a non-null pointer to a casacore::MSMainColumns.

Return: const casacore::MSMainColumns*

const casacore::MSColumns *GetMSColumns() const

Gets a non-null pointer to a casacore::MSColumns.

Return: const casacore::MSColumns*

uint32_t GetTotalAntennas() const: Gets the total number of antennas including flagged antennas.

uint32_t GetNumStations() const

Gets the number of stations excluding flagged stations.

Return: uint32_t

uint32_t GetNumBaselines() const

Get the number of baselines in the measurement set using the current autocorrelations setting and including stations not recording rows.

Note: TODO: baselines should always be n*(n-1) / 2 and without autocorrelations
Return: uint32_t

uint32_t GetNumPols() const

Get the number of polarizations in the measurement set.

Return: uint32_t

uint32_t GetNumChannels() const

Gets the number of channels in the measurement set.

Return: uint32_t

uint32_t GetNumRows() const

Gets the number of rows in the measurement set (non-flagged baselines * timesteps).

Return: uint32_t

uint32_t GetNumTimesteps() const

Gets the total number of timesteps in the measurement set.

Return: uint32_t

std::vector<double> GetEpochs() const

Get the Epochs object.

Return: std::vector<double>

Eigen::VectorXb GetFlaggedBaselines() const

Gets a vector of size nBaselines with a true value at the index of flagged baselines. Checks for flagged data on the first channel and polarization.

Return: Eigen::VectorXb

uint32_t GetNumFlaggedBaselines() const

Get the number of baselines that are flagged by the measurement set.

Return: uint32_t

Eigen::VectorXb GetShortBaselines(double minimumBaselineThreshold = 0.0) const

Gets a flag vector of short baselines.

Return

Eigen::VectorXb

Parameters

minimumBaselineThreshold:

uint32_t GetNumShortBaselines(double minimumBaselineThreshold = 0.0) const

Get the number of baselines that below the minimumBaselineThreshold.

Return

uint32_t

Parameters

minimumBaselineThreshold:

Eigen::VectorXb GetFilteredBaselines(double minimumBaselineThreshold = 0.0) const

Gets flag vector of filtered baselines that are either flagged or short.

Return

Eigen::VectorXb

Parameters

minimumBaselineThreshold:

uint32_t GetNumFilteredBaselines(double minimumBaselineThreshold = 0.0) const

Gets the number of baselines that are flagged baselines or short baselines.

Return

uint32_t

Parameters

minimumBaselineThreshold:

Eigen::MatrixX3d GetCoords() const

Gets a flag vector of filtered stations.

Return

Eigen::VectorXb

Parameters

minimumBaselineThreshold:

Eigen::MatrixX3d GetCoords(uint32_t start_row, uint32_t nBaselines) const

Eigen::Tensor<std::complex<double>, 3> GetVis(std::uint32_t startBaseline, std::uint32_t startChannel, std::uint32_t nChannels, std::uint32_t nBaselines, std::uint32_t nPolarizations) const

Eigen::Tensor<std::complex<double>, 3> GetVis() const

std::set<int32_t> GetMissingAntennas() const

Gets the antennas that are not present in any baselines.

Return: std::set<int32_t>

std::set<int32_t> GetFlaggedAntennas() const

Gets the antenna indexes that are either not present in any baselines or are flagged in all of it’s baselines.

Indexes are out of the total antennas

Return: std::set<int32_t>

Private Functions

void Validate() const¶

uint32_t GetNumBaselines(bool useAutocorrelations) const¶

Get the number of baselines in the measurement set (e.g. (0,0), (1,1), (2,2))

Return: uint32_t

std::set<int32_t> CalculateUniqueAntennas() const¶

Calculates the set of unique antenna present in baselines.

Return: uint32_t

Private Members

std::unique_ptr<casacore::MeasurementSet> m_measurementSet¶

std::unique_ptr<casacore::MSMainColumns> m_msmc¶

std::unique_ptr<casacore::MSColumns> m_msc¶

boost::optional<std::string> m_filepath¶

std::set<std::int32_t> m_antennas¶

int m_stations¶

bool m_readAutocorrelations¶

class icrar::cpu::MetaData

#include <MetaData.h>

container of phaserotation constants and variables for calibrating a single beam. Can be mutated to calibrate for multiple directions.

Subclassed by icrar::cuda::HostMetaData

Public Functions

MetaData(const icrar::MeasurementSet &ms, boost::optional<unsigned int> refAnt = boost::none, double minimumBaselineThreshold = 0.0, bool computeInverse = true, bool useCache = true)

Construct a new MetaData object. SetUVW() and SetDirection() must be called after construction.

Parameters

ms:
minimumBaselineThreshold:
useCache:

MetaData(const icrar::MeasurementSet &ms, const std::vector<icrar::MVuvw> &uvws, boost::optional<unsigned int> refAnt = boost::none, double minimumBaselineThreshold = 0.0, bool computeInverse = true, bool useCache = true)

Construct a new MetaData object. SetDirection() must be called after construction.

Parameters

ms: measurement set to read observations from
uvws: uvw coordinates of stations
refAnt: the reference antenna index, default is the last index
minimumBaselineThreshold: baseline lengths less that the minimum in meters are flagged
useCache: whether to load Ad matrix from cache

MetaData(const icrar::MeasurementSet &ms, const SphericalDirection &direction, const std::vector<icrar::MVuvw> &uvws, boost::optional<unsigned int> refAnt = boost::none, double minimumBaselineThreshold = 0.0, bool computeInverse = true, bool useCache = true)

Construct a new MetaData object.

Parameters

ms: measurement set to read observations from
direction: the direction of the beam to calibrate for
uvws: uvw coordinates of stations
refAnt: the reference antenna index, default is the last index
minimumBaselineThreshold: baseline lengths less that the minimum in meters are flagged
useCache: whether to load Ad matrix from cache

const Constants &GetConstants() const

const Eigen::MatrixXd &GetA() const: Matrix of baseline pairs of shape [baselines, stations].

const Eigen::VectorXi &GetI() const: Vector of indexes of the stations that are not flagged, shape [stations].

const Eigen::MatrixXd &GetAd() const: The pseudoinverse of A with shape [stations, baselines].

Eigen::MatrixXd &GetAd(): Gets a mutable reference to Ad. Host references may need to reregister after resize.

const Eigen::MatrixXd &GetA1() const: Matrix of baselines using the reference antenna of shape [stations+1, stations] the last row represents the reference antenna.

const Eigen::VectorXi &GetI1() const

const Eigen::MatrixXd &GetAd1() const

Eigen::MatrixXd &GetAd1(): Gets a mutable reference to Ad1. Host references may need to reregister after resize.

const std::vector<icrar::MVuvw> &GetUVW() const

const SphericalDirection &GetDirection() const

const Eigen::Matrix3d &GetDD() const

void SetDirection(const SphericalDirection &direction)

void SetUVW(const std::vector<icrar::MVuvw> &uvws)

void ComputeInverse(): Computes the A and A1 inverse matrices.

void ValidateInverse() const: Output logs on the validity of inverse matrices.

Eigen::Matrix3d GenerateDDMatrix(const SphericalDirection &direction) const

Utility method to generate a direction matrix using the configured zenith direction.

Return

Eigen::Matrix3d

Parameters

direction:

const Eigen::MatrixXcd &GetAvgData() const

Eigen::MatrixXcd &GetAvgData()

bool operator==(const MetaData &rhs) const

bool operator!=(const MetaData &rhs) const

Protected Attributes

Constants m_constants

double m_minimumBaselineThreshold

bool m_useCache

Eigen::MatrixXd m_A

Eigen::VectorXi m_I

Eigen::MatrixXd m_A1

Eigen::VectorXi m_I1

Eigen::MatrixXd m_Ad: The pseudo-inverse of m_A, late intitialized.

Eigen::MatrixXd m_Ad1

std::vector<icrar::MVuvw> m_UVW

SphericalDirection m_direction

Eigen::Matrix3d m_dd

Eigen::MatrixXcd m_avgData

Private Functions

MetaData() = default¶

Friends

friend class icrar::cuda::DeviceMetaData

friend class icrar::cuda::ConstantBuffer

class icrar::not_implemented_exception : public icrar::exception

Public Functions

not_implemented_exception(const std::string &file, int line)

class icrar::Range

#include <Range.h>

Represents a forwards linear sequence of indexes for some finite collection.

Public Functions

Range(int start, int interval, int end)

uint32_t GetStart() const

uint32_t GetInterval() const

uint32_t GetEnd() const

int GetSize() const

Gets the number of elements in the range.

Return: int

Private Members

std::uint32_t m_start¶

std::uint32_t m_interval¶

std::uint32_t m_end¶

struct icrar::profiling::ResourceUsage

#include <resource_usage.h>

A collection of resource-related statistics.

Public Members

usec_t utime: Time spent in user mode, in microseconds.

usec_t stime: Time spent in kernel mode, in microseconds.

usec_t wtime: Total walltime spent since program started.

std::size_t peak_rss: Maximum amount of memory used, in bytes.

class icrar::Slice

#include <Slice.h>

Represents a forwards linear sequence of indexes for some arbitrary collection.

Public Functions

Slice() = default

Slice(int interval)

Slice(int start, int end)

Slice(int start, int interval, int end)

int32_t GetStart() const: Gets the starting index of an arbitrary collection slice. -1 represents the end of the collection.

int32_t GetInterval() const: Gets the interval betweeen indices of an arbitrary collection slice. -1 represents the end of the collection.

int32_t GetEnd() const: Gets the end index of an arbitrary collection slice. -1 represents the end of the collection.

Range Evaluate(int collectionSize) const

Private Members

std::int32_t m_start¶

std::int32_t m_interval¶

std::int32_t m_end¶

class icrar::cuda::SolutionIntervalBuffer

#include <DeviceMetaData.h>

MetaData variables allocated per solution interval.

Public Functions

SolutionIntervalBuffer(const std::vector<icrar::MVuvw> &UVW)

SolutionIntervalBuffer(size_t baselines)

const device_vector<icrar::MVuvw> &GetUVW() const

void SetUVW(std::vector<icrar::MVuvw> UVW)

Private Members

device_vector<icrar::MVuvw> m_UVW¶

class icrar::profiling::timer

Public Types

using clock = std::chrono::high_resolution_clock

using duration = typename clock::duration

Public Functions

duration get() const

Private Members

clock::time_point m_start = {clock::now()}¶

class icrar::profiling::UsageReporter

#include <UsageReporter.h>

Reports high-level, process-wide resource usage values on destruction.

Public Functions

UsageReporter() = default

UsageReporter(UsageReporter&&) = default

UsageReporter(const UsageReporter&) = default

UsageReporter &operator=(const UsageReporter&) = default

UsageReporter &operator=(UsageReporter&&) = default

~UsageReporter() noexcept

struct icrar::visibility

Public Functions

std::ostream &operator<<(std::ostream &os, const visibility &vis)

Public Members

double frequency

double time

double u

double v

double w

double r

double i

double weight

int a1

int a2

int gcfinx

namespace Eigen¶

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Typedefs

using MatrixXb = Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic>

using VectorXb = Eigen::Vector<bool, Eigen::Dynamic>

namespace icrar¶

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 - 1307 USA

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Typedefs

using SphericalDirection = Eigen::Vector2d

using Tensor3X = Eigen::Tensor<T, 3>

using MVuvw = Eigen::Vector3d

Enums

enum ComputeImplementation

Specifier for the compute implementation of a LeapCalibrator.

Values:

enumerator cpu

enumerator cuda

enum InputType

Values:

enumerator file: Read from a casacore table file.

enumerator stream: Read from a spead2 stream (unsupported)

enum StreamOutType

A configurable enumaration type that can be used for specifying how calibrations are streamed to the output during computation.

Values:

enumerator collection: Calibrations are written to a collection in a single file.

enumerator singleFile: Calibrations are continously rewritten to a single file as computed.

enumerator multipleFiles: Calibrations are continously written to multiple files as computed.

Functions

template<class Matrix> void write_binary(const char *filepath, const Matrix &matrix)

Writes matrix to a file overwriting existing content (throws if fails)

Template Parameters

Matrix: Eigen Matrix type

Parameters

filepath: filepath to write to
matrix: matrix to write

template<class Matrix> void read_binary(const char *filepath, Matrix &matrix)

Reads matrix from a file by resizing and overwriting the existing matrix (throws if fails)

Template Parameters

Matrix: Eigen Matrix type

Parameters

filepath: filepath to read from
matrix: matrix to read

template<typename T> void read_hash(const char *filename, T &hash)

Reads a file containing a binary hash at filename and outputs to hash.

Template Parameters

T: the hash type

Parameters

filename: the hash file to read
hash: output parameter

template<typename T> void write_hash(const char *filename, T hash)

Writes a hash value to a specified file.

Template Parameters

T: the hash value

Parameters

filename: the hash file to write to
hash: the hash value

template<typename In, typename Out, typename Lambda> void ProcessCache(size_t hash, const In &in, Out &out, const std::string &hashFile, const std::string &cacheFile, Lambda transform)

Reads the hash file and writes to cache if the hash file is different, else reads the cache file if hash file is the same.

Template Parameters

In: Matrix type
Out: Matrix type
Lambda: lambda type of signature Out(const In&)

Parameters

in: The input matrix to hash and transform
out: The transformed output
transform: the transform lambda
cacheFile: the transformed out cache file
hashFile: the in hash file

template<typename RowVector> void pretty_row(const RowVector &row, std::stringstream &ss)

Prints a formatted displaying up to 6 elements.

Template Parameters

RowVector: Eigen RowVector type

Parameters

row: the row to print
ss: the stream to print to

template<typename Matrix> std::string pretty_matrix(const Eigen::MatrixBase<Matrix> &value)

Prints a formatted matrix to a string with a maximum of 6 rows and columns displayed.

Return

std::string the formatted string result

Template Parameters

Matrix: Eigen Matrix type

Parameters

value: the matrix to print

template<typename Matrix> void trace_matrix(const Matrix &value, const std::string &name)

Dumps a matrix to file name .txt.

Template Parameters

Matrix: Eigen Matrix type

Parameters

value: matrix to dump to file
name: name of the matrix to dump

template<typename T> std::underlying_type_t<T> to_underlying_type(T e)

Safely casts an enum to its underlying type.

Return

std::underlying_type_t<T> the cast value

Template Parameters

T: enum with underlying type

Parameters

e: enum value

Slice ParseSlice(const std::string &json)

Slice ParseSlice(const rapidjson::Value &doc)

std::vector<SphericalDirection> ParseDirections(const std::string &json)

Parses a json string to a collection of MVDirections.

Return

std::vector<SphericalDirection>

Parameters

json:

std::vector<SphericalDirection> ParseDirections(const rapidjson::Value &doc): Parses a json object to a collection of MVDirections.

template<typename T> bool isApprox(const Tensor3X<T> &lhs, const Tensor3X<T> &rhs, double tolerance)

std::string ComputeImplementationToString(ComputeImplementation value): Converts an enum value to a string.

ComputeImplementation ParseComputeImplementation(const std::string &value)

Parses string argument into an enum, throws an exception otherwise.

Return

ComputeImplementation

Parameters

value:

bool TryParseComputeImplementation(const std::string &value, ComputeImplementation &out)

Return: true if value was converted succesfully, false otherwise

std::string git_sha1()

Return: The git SHA1 value for the current source code commit.

bool git_has_local_changes()

Return: Whether the local clone of the repository has uncommitted changes.

InputType ParseInputType(const std::string &value)

Parses string argument into an enum, throws an exception otherwise.

Return

StreamOutType

Parameters

value:

bool TryParseInputType(const std::string &value, InputType &out)

Return: true if value was converted succesfully, false otherwise

template<int N, typename T> detail::_fixed<N, T> fixed(T v)

Sent to a stream object, this manipulator will print the given value with a precision of N decimal places.

Return

detail::_fixed<N, T>

Template Parameters

N:
T:

Parameters

v: The value to send to the stream

detail::_memory_amount memory_amount(std::size_t amount)

Sent to a stream object, this manipulator will print the given amount of memory using the correct suffix and 3 decimal places.

Return

detail::_memory_amount

Parameters

amount: The value to send to the stream

detail::_microseconds_amount us_time(std::chrono::microseconds::rep amount)

Sent to a stream object, this manipulator will print the given amount of nanoseconds using the correct suffix and 3 decimal places.

Return

detail::_microseconds_amount

Parameters

amount: The value to send to the stream

size_t GetTotalSystemVirtualMemory(): Gets the total amount system virtual memory. This includes the system’s dynamic RAM plus swap space.

size_t GetTotalUsedSystemVirtualMemory(): Gets the total amount of used system virtual memory.

size_t GetTotalAvailableSystemVirtualMemory(): Gets the currently available/free virtual system memory.

size_t GetTotalCudaPhysicalMemory(): Gets the total physical cuda memory on the current cuda device.

size_t GetAvailableCudaPhysicalMemory(): Gets the currently available/free physical cuda memory of the current cuda device. This excludes the memory used by the current process.

StreamOutType ParseStreamOutType(const std::string &value)

Parses string argument into an enum, throws an exception otherwise.

Return

StreamOutType

Parameters

value:

bool TryParseStreamOutType(const std::string &value, StreamOutType &out)

Return: true if value was converted succesfully, false otherwise

bool IsImmediateMode(StreamOutType streamOutType): True if solutions should be written to IO as soon as they are computed.

std::string version()

Returns the version of this library as a single string

Return: The version of this library

template<typename T> casacore::Matrix<T> Transpose(const casacore::Matrix<T> matrix)

template<typename T> icrar::MVuvw Dot(const icrar::MVuvw &left, const Eigen::Matrix<T, 3, 3> &right)

template<typename T> casacore::MVuvw Dot(const casacore::MVuvw &v1, const casacore::Matrix<T> &v2)

template<typename T> bool Equal(const boost::optional<casacore::Matrix<T>> &l, const boost::optional<casacore::Matrix<T>> &r)

template<typename T> bool Equal(const casacore::Array<T> &l, const casacore::Array<T> &r)

template<typename T, typename Op> casacore::Matrix<std::result_of_t<Op(const T&)>> casa_matrix_map(const casacore::Matrix<T> &matrix, Op lambda)¶

Performs a std::transform on a newly allocated casacore::Matrix.

Return

std::vector<R>

Template Parameters

T: The input vector template type
function: of signature R(const T&)

Parameters

vector:

template<typename T, typename Op> casacore::Vector<std::result_of_t<Op(const T&)>> casa_vector_map(const casacore::Vector<T> &vector, Op lambda)¶

Performs a std::transform on a newly allocated casacore::Vector.

Return

std::vector<R>

Template Parameters

T: The input vector template type
function: of signature R(const T&)

Parameters

vector:

template<typename T> void ArrayFill(casacore::Array<T> &value, T v)

template<typename T> T ArrayMax(const casacore::Array<T> &value)

Returns the largest value within the array.

Return

T

Template Parameters

T:

Parameters

value:

template<typename T> bool isApprox(const std::complex<T> &lhs, const std::complex<T> &rhs, T threshold)

returns true if the magnitude of the difference between two values are approximately equal (within the specified threshold)

Return

true if left value approximately equals right value

Return

false if left value does not approximately equals right value

Template Parameters

T:

Parameters

lhs: left value
rhs: right value
threshold:

template<typename T> Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> ToMatrix(const casacore::Matrix<T> &value): Converts a casacore matrix to the equivalent eigen3 matrix

template<typename T, int R, int C> Eigen::Matrix<T, R, C> ToFixedMatrix(const casacore::Matrix<T> &value)

template<typename T, int R, int C> casacore::Matrix<T> ConvertMatrix(const Eigen::Matrix<T, R, C> &value): Converts an Eigen3 matrix to the equivalent casacore matrix.

template<typename T> casacore::Matrix<T> ConvertMatrix(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> &value): Converts an Eigen3 matrix to the equivalent casacore matrix.

template<typename T> Eigen::Matrix<T, Eigen::Dynamic, 1> ToVector(casacore::Vector<T> value): Converts a casacore vector to the equivalent Eigen3 vector.

template<typename T> Eigen::Matrix<T, Eigen::Dynamic, 1> ToVector(const std::vector<T> &value): Converts a std vector to the equivalent Eigen3 vector.

template<typename T> casacore::Vector<T> ConvertVector(const Eigen::Matrix<T, Eigen::Dynamic, 1> &value)

Converts an Eigen3 column-vector into a casacore Array.

Return

casacore::Array<T>

Template Parameters

T:

Parameters

value:

icrar::MVuvw ToUVW(const casacore::MVuvw &value)

Converts a casacore UVW value to an icrar UVW value.

Return

icrar::MVuvw

Parameters

value:

std::vector<icrar::MVuvw> ToUVWVector(const std::vector<casacore::MVuvw> &value)

std::vector<icrar::MVuvw> ToUVWVector(const Eigen::MatrixXd &value): Converts a column-major matrix of size Nx3 into a vector of UVWs.

casacore::MVuvw ToCasaUVW(const icrar::MVuvw &value)

std::vector<casacore::MVuvw> ToCasaUVWVector(const std::vector<icrar::MVuvw> &value)

std::vector<casacore::MVuvw> ToCasaUVWVector(const Eigen::MatrixX3d &value)

SphericalDirection ToDirection(const casacore::MVDirection &value): Converts a casacore direction to an icrar sperical direction.

std::vector<SphericalDirection> ToDirectionVector(const std::vector<casacore::MVDirection> &value)

casacore::MVDirection ToCasaDirection(const SphericalDirection &value)

std::vector<casacore::MVDirection> ToCasaDirectionVector(const std::vector<SphericalDirection> &value)

template<typename IntType> std::vector<IntType> range(IntType start, IntType stop, IntType step)

returns a linear sequence of values from start at step sized intervals to the stop value inclusive

Return

std::vector<IntType>

Template Parameters

IntType:

Parameters

start:
stop:
step:

template<typename IntType> std::vector<IntType> range(IntType start, IntType stop)

Return

std::vector<IntType>

Template Parameters

IntType:

Parameters

start:
stop:

template<typename IntType> std::vector<IntType> range(IntType stop)

Return

std::vector<IntType>

Template Parameters

IntType:

Parameters

stop:

template<typename T> bool isApprox(const std::vector<T> &lhs, const std::vector<T> &rhs, T tolerance)

Returns true if all vector elements of.

Parameters

lhs: are within the tolerance threshold to
rhs:

Template Parameters

T: numeric type

Parameters

lhs: left hand side
rhs: right hand side
tolerance: tolerance threshold

template<typename T, typename Op> std::vector<std::result_of_t<Op(const T&)>> vector_map(const std::vector<T> &vector, Op lambda)¶

Performs a std::transform on a newly allocated std::vector.

Return

std::vector<R>

Template Parameters

T: The input vector template type
function: of signature R(const T&)

Parameters

vector:

Eigen::Matrix<double, Eigen::Dynamic, 3> ToMatrix(const std::vector<MVuvw> &uvws)

template<typename T> void ms_read_coords(const casacore::MeasurementSet &ms, uint32_t start_row, uint32_t num_baselines, T *uu, T *vv, T *ww)

template<typename T> void ms_read_vis(const casacore::MeasurementSet &ms, unsigned int start_baseline, unsigned int start_channel, unsigned int num_channels, unsigned int num_baselines, unsigned int num_pols, const char *column, T *vis)

cpu::CalibrationCollection GetEachTimestepMWACalibration()

cpu::CalibrationCollection GetAllTimestepsMWACalibration()

Gets the expected calibration output averaging over all timesteps. From LEAP-Cal:ported.

Return: a vector of direction and antenna calibration pairs

cpu::CalibrationCollection GetFirstTimestepMWACalibration()

Gets the expected calibration output averaging over the first timestep.

Return: std::vector<std::pair<SphericalDirection, std::vector<double>>>

template<typename T> ::testing::AssertionResult AttributeEquals(MyObject const &obj, T value)

namespace icrar::constants¶

Variables

constexpr double speed_of_light = 299792458.0: Speed of light in meters per second.

namespace icrar::cpu¶

Functions

std::pair<Eigen::MatrixXd, Eigen::VectorXi> PhaseMatrixFunction(const Eigen::VectorXi &a1, const Eigen::VectorXi &a2, const Eigen::VectorXb &fg, uint32_t refAnt, bool allBaselines)

Form Phase Matrix Given the antenna lists from MS and (optionally) RefAnt & Map: If non-negative RefAnt is provided it only forms the matrix for baselines with that antenna. If True Map is provided it returns the index map for the matrix (only useful if RefAnt set).

This function generates and returns the linear matrix for the phase calibration (only)

Return

std::pair<Matrixd, Matrixi> for refAnt = none: first matrix is of size [baselines,stations] and seconds of size[baselines,1] for 0 <= refAnt < stations: first matrix is of size [stations,stations] and seconds of size[stations,1]

Parameters

a1: indexes of 1st antenna of each baselines
a2: indexes of 2nd antenna of each baselines
refAnt: the reference antenna (0, 1), -1
fg: a flag map of flagged stations to ignore when true

template<typename Matrix, typename Scalar> Eigen::IndexedView<Matrix, Eigen::Vector<Scalar, Eigen::Dynamic>, Eigen::internal::AllRange<-1>> WrappedRowSelect(Eigen::MatrixBase<Matrix> &matrix, const Eigen::Vector<Scalar, Eigen::Dynamic> &rowIndices)

Selects a range of elements from matrix row indices. Negative indexes select from the bottom of the matrix with -1 representing the bottom row.

Template Parameters

T:

Parameters

matrix: the referenced matrix to select from
rowIndices: a range of row indices to select
column: a valid column index

template<typename T> double standard_deviation(const Eigen::MatrixBase<T> &matrix)

Computes the element-wise standard deviation.

Return

double

Template Parameters

T:

Parameters

matrix:

Eigen::MatrixXd arg(const Eigen::Ref<const Eigen::MatrixXcd> &a)

Returns the component-wise arguments of a matrix.

Return

Eigen::MatrixXd

Parameters

a:

bool near(const Eigen::Ref<const Eigen::MatrixXd> &left, const Eigen::Ref<const Eigen::MatrixXd> &right, double tolerance)

Performs an elementwise comparison between matrices and returns false if the absolute difference exceeds the tolerance.

Parameters

left:
right:
tolerance:

template<typename T> constexpr T ceil_div(T x, T y)

Performs integer division but rounds up if there is a remainder.

Template Parameters

T: integer type

Parameters

x: numerator
y: denominator

template<typename Matrix_T> Matrix_T SVDPseudoInverse(const Matrix_T &a, double epsilon = std::numeric_limits<typename Matrix_T::Scalar>::epsilon())

Calculates the pseudo_inverse matrix of size N * M for a given M * N matrix. Satisfies the equation A = A * Ah * A.

Return

Matrix_T

Parameters

A:
epsilon:

template<typename T> Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> pseudo_inverse(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> &a)

Invert as a function If non-negative RefAnt is provided it only forms the matrix for baselines with that antenna.

This function generates and returns the inverse of the linear matrix to solve for the phase calibration (only) given a MS. The MS is used to fill the columns of the matrix, based on the baselines in the MS (and RefAnt if given)

The output will be the inverse matrix to cross with the observation vector.

Parameters

A:

namespace icrar::cuda¶

cuda

Enums

enum JobType

Corresponds to job types of CusolverDn API (e.g. cusolverDnDgesvd)

Values:

enumerator A: All - Entire dense matrix is used.

enumerator S: Slim/Thin - Minimal matrix dimensions.

enum MatrixOp

Values:

enumerator normal

enumerator transpose

enumerator hermitian

enumerator conjugate

Functions

__host__ void CalcDeltaPhase(const device_matrix<double> &A, const device_vector<double> &cal1, const device_matrix<std::complex<double>> &avgData, device_matrix<double> &deltaPhase)

Computes the phase delta vector for the first polarization of avgData.

Parameters

A: Antenna matrix
cal1: cal1 matrix
avgData: averaged visibilities
deltaPhase: output deltaPhase vector

__host__ void GenerateDeltaPhaseColumn(const device_matrix<double> &deltaPhase, device_vector<double> &deltaPhaseColumn)

Copies the first column of deltaPhase into deltaPhaseColumn.

Parameters

deltaPhase: The delta phase matrix
deltaPhaseColumn: The output delta phase vector/column

__host__ void Empty(): An empty kernel for testing cuda configurations.

__host__ void AvgDataToPhaseAngles(const device_vector<int> &I1, const device_matrix<std::complex<double>> &avgData, device_vector<double> &phaseAnglesI1)

Copies the argument of the 1st column/polarization in avgData to phaseAnglesI1.

Parameters

I1: the index vector for unflagged antennas
avgData: the averaged data matrix
phaseAnglesI1: the output phaseAngles vector

__host__ void RotateVisibilities(DeviceIntegration &integration, DeviceMetaData &metadata)

Calculates avgData in metadata.

Parameters

integration: the input visibilities to integrate
metadata: the metadata container

Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> pseudo_inverse(cusolverDnHandle_t cusolverHandle, cublasHandle_t cublasHandle, const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> &a, const JobType jobtype = JobType::S)

Computes the moore penrose pseudo inverse where A’A = I (left inverse)

Return

Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>

Parameters

cusolverHandle:
cublasHandle:
a:
jobtype: SVD matrix dimension type

std::tuple<device_matrix<double>, device_vector<double>, device_matrix<double>> svd(cusolverDnHandle_t cusolverHandle, const device_matrix<double> &deviceA, const JobType jobType)

Computes the U, S and Vt values of matrix singular value decomposition.

Return

std::tuple<device_matrix<double>, device_vector<double>, device_matrix<double>>

Parameters

cusolverHandle:
deviceA:
jobType:

device_matrix<double> pseudo_inverse(cusolverDnHandle_t cusolverHandle, cublasHandle_t cublasHandle, const device_matrix<double> &matrix, const JobType jobType = JobType::S)

Performs matrix inversion using cusolver and cublas.

Return

device_matrix<double>

Parameters

cusolverHandle:
cublasHandle:
matrix:
jobType:

cublasOperation_t ToCublasOp(MatrixOp op)

Converts a matrix operation to a cublas operation.

Return

cublasOperation_t

Parameters

op:

namespace icrar::detail¶

Functions

template<typename T, int N, typename VT> std::basic_ostream<T> &operator<<(std::basic_ostream<T> &os, detail::_fixed<N, VT> v)

template<typename T> std::basic_ostream<T> &operator<<(std::basic_ostream<T> &os, const detail::_memory_amount &m)

template<typename T> std::basic_ostream<T> &operator<<(std::basic_ostream<T> &os, const detail::_microseconds_amount &t)

namespace icrar::log¶

log

Enums

enum Verbosity

Selects the reporting level filter for log messages.

Values:

enumerator fatal: brief Unexpected execution path, report issue to repo owner

enumerator error: Knwon execution error, address exception message before reporting.

enumerator warn: Automatically resolved user exception.

enumerator info: Regular execution reporting.

enumerator debug: Debug mode reporting.

enumerator trace: Developer targeted reporting.

Functions

void Initialize(Verbosity verbosity = DEFAULT_VERBOSITY)

Initializes logging singletons.

Parameters

verbosity: The verbosity to initialize the library with, higher values yield more verbose output.

Verbosity ParseVerbosity(const std::string &value)

Parses string argument into an enum, throws an exception otherwise.

Return

ComputeImplementation

Parameters

value:

bool TryParseVerbosity(const std::string &value, Verbosity &out)

Return: true if value was converted succesfully, false otherwise.

Variables

constexpr Verbosity DEFAULT_VERBOSITY = Verbosity::info: The default verbosity level with which the logging system is initialized.

extern ::boost::log::trivial::severity_level logging_level: The logging level set on the application.

namespace icrar::profiling¶

Typedefs

using usec_t = std::uint64_t

Functions

template<typename CharT> std::basic_ostream<CharT> &operator<<(std::basic_ostream<CharT> &os, const ResourceUsage &ru): Stream output operator for instances of ResourceUsage.

ResourceUsage get_resource_usage(): Returns the maximum Resident Storage Size of this process.

template<typename CharT, typename Traits> std::basic_ostream<CharT, Traits> &operator<<(std::basic_ostream<CharT, Traits> &os, const timer &timer)

file ComputeOptionsDTO.h

file CpuComputeOptions.h

file CpuLeapCalibrator.h

file PhaseMatrixFunction.h

file CudaComputeOptions.h

file CudaLeapCalibrator.h

file ComputePhaseDeltaKernel.h

file CopyPhaseDeltaKernel.h

file EmptyKernel.h

file PolarizationsToPhaseAnglesKernel.h

file RotateVisibilitiesKernel.h

file ILeapCalibrator.h

file LeapCalibratorFactory.h

file Arguments.h

file constants.h

file eigen_cache.h

file eigen_stringutils.h

Variables

constexpr int pretty_width = 12

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

file enumutils.h

file Range.h

file Slice.h

file SphericalDirection.h

file stream_extensions.h

Functions

template<typename T> std::ostream &operator<<(std::ostream &os, const std::set<T> &v)

Prints a set of streamable values.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Return

std::ostream&

Template Parameters

T: streamable type

Parameters

os: output stream
v: set

template<typename T, typename S> std::ostream &operator<<(std::ostream &os, const std::map<T, S> &m)

file Tensor3X.h

file compute_implementation.h

file git_revision.h

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 - 1307 USA

Stores the version information of leap-accelerate

file InputType.h

file logging.h

file Verbosity.h

file ioutils.h

file system_memory.h

file resource_usage.h

file timer.h

file UsageReporter.h

file stream_out_type.h

file version.h

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 - 1307 USA

Stores the version information of leap-accelerate

file compute_device.h

file cuda_info.h

Functions

int GetCudaDeviceCount()

Gets the number of available Cuda Devices.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Return: int

void printCudaVersion(): Prints running cuda device info to the output log.

file device_matrix.h

file device_tensor.h

file device_vector.h

file exception.h

file casacore_helper.h

file complex_extensions.h

file eigen_extensions.h

file math.h

file matrix_invert.h

file matrix_invert.h

file matrix.h

file matrix_add.h

file matrix_multiply.h

Typedefs

cublasLtHandle_t = int #endif namespace icrar { namespace cuda { __host__ void mat_mul(cublasHandle_t handle, MatrixOp transa, MatrixOp transb, const size_t m, const size_t n, const size_t k, const double *a, const double *b, double *out)

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Functions

__host__ void mat_mul(cublasHandle_t handle, MatrixOp transa, MatrixOp transb, const size_t m, const size_t n, const size_t k, const float *a, const float *b, float *out)

__host__ void mat_mul(cublasHandle_t handle, MatrixOp transa, MatrixOp transb, const size_t m, const size_t n, const size_t k, const int *a, const int *b, int *out)

__host__ void mat_mul(cublasLtHandle_t handle, MatrixOp transa, MatrixOp transb, const size_t m, const size_t n, const size_t k, const double *a, const double *b, double *out)

__host__ void mat_mul(cublasLtHandle_t handle, MatrixOp transa, MatrixOp transb, const size_t m, const size_t n, const size_t k, const float *a, const float *b, float *out)

__host__ void mat_mul(cublasLtHandle_t handle, MatrixOp transa, MatrixOp transb, const size_t m, const size_t n, const size_t k, const int *a, const int *b, int *out)

template<typename T> __host__ void multiply(cublasHandle_t handle, const device_matrix<T> &a, const device_vector<T> &b, device_vector<T> &c, MatrixOp transa = MatrixOp::normal, MatrixOp transb = MatrixOp::normal)

Performs matrix-vector multiplication where C = A * B. The transpose and hermetian of A and B can be used instead.

Return

host

Template Parameters

T:

Parameters

handle:
a:
b:
c:
transa:
transb:

template<typename T> __host__ void multiply(cublasHandle_t handle, const device_matrix<T> &a, const device_matrix<T> &b, device_matrix<T> &c, MatrixOp transa = MatrixOp::normal, MatrixOp transb = MatrixOp::normal)

template<typename T> __host__ void multiply(cublasLtHandle_t handle, const device_matrix<T> &a, const device_vector<T> &b, device_vector<T> &c, MatrixOp transa = MatrixOp::normal, MatrixOp transb = MatrixOp::normal)

template<typename T> __host__ void multiply(cublasLtHandle_t handle, const device_matrix<T> &a, const device_matrix<T> &b, device_matrix<T> &c, MatrixOp transa = MatrixOp::normal, MatrixOp transb = MatrixOp::normal)

__host__ void mat_mul_add(cublasHandle_t handle, const size_t m, const size_t n, const size_t k, const double *a, const double *b, double *c)

__host__ void mat_mul_add(cublasHandle_t handle, const size_t m, const size_t n, const size_t k, const float *a, const float *b, float *c)

__host__ void mat_mul_add(cublasHandle_t handle, const size_t m, const size_t n, const size_t k, const int *a, const int *b, int *c)

__host__ void mat_mul_add(cublasLtHandle_t handle, const size_t m, const size_t n, const size_t k, const double *a, const double *b, const double *c, double *d)

__host__ void mat_mul_add(cublasLtHandle_t handle, const size_t m, const size_t n, const size_t k, const float *a, const float *b, const float *c, float *d)

__host__ void mat_mul_add(cublasLtHandle_t handle, const size_t m, const size_t n, const size_t k, const int *a, const int *b, const int *c, int *d)

template<typename T> __host__ void multiply_add(cublasLtHandle_t handle, const device_matrix<T> &a, const device_vector<T> &b, const device_vector<T> &c, device_vector<T> &d)

template<typename T> __host__ void multiply_add(cublasHandle_t handle, const device_matrix<T> &a, const device_matrix<T> &b, device_matrix<T> &c)

template<typename T> __host__ void multiply_add(cublasHandle_t handle, const device_matrix<T> &a, const device_vector<T> &b, device_vector<T> &c)

template<typename T> __host__ void multiply_add(cublasLtHandle_t handle, const device_matrix<T> &a, const device_matrix<T> &b, const device_matrix<T> &c, device_matrix<T> &d)

file matrix_op.h

file matrix_transpose.h

file math_conversion.h

file vector_extensions.h

Functions

template<typename T> std::ostream &operator<<(std::ostream &os, const std::vector<T> &v)

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 - 1307 USA

file band_data.h

file BeamCalibration.h

file Calibration.h

file CalibrationCollection.h

file Integration.h

file MetaData.h

file MVuvw.h

file DeviceIntegration.h

file DeviceMetaData.h

file HostIntegration.h

file HostMetaData.h

file visibility.h

file MeasurementSet.h

file utils.h

file PhaseRotateTestCaseData.h

file gtest_helper.h

file model_helper.h

file eigen_helper.h

Functions

void assert_near_cd(const std::complex<double> &expected, const std::complex<double> &actual, double tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 - 1307 USA

void assert_near_matrix_i(const Eigen::MatrixXi &expected, const Eigen::MatrixXi &actual, int tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

void assert_near_matrix_d(const Eigen::MatrixXd &expected, const Eigen::MatrixXd &actual, double tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

void assert_near_matrix3_d(const Eigen::Matrix3d &expected, const Eigen::Matrix3d &actual, double tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

void assert_near_matrix_cd(const Eigen::MatrixXcd &expected, const Eigen::MatrixXcd &actual, double tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

void assert_near_vector_i(const Eigen::VectorXi &expected, const Eigen::VectorXi &actual, double tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

void assert_near_vector_d(const Eigen::VectorXd &expected, const Eigen::VectorXd &actual, double tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

void assert_near_vector_d(const std::vector<double> &expected, const std::vector<double> &actual, double tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

template<typename T> void assert_near_tensor(const Eigen::Tensor<T, 3> &expected, const Eigen::Tensor<T, 3> &actual, T tolerance, const std::string &ln, const std::string &rn, const std::string &file, int line)

file test_helper.h

Functions

void assert_near_metadata(const icrar::cpu::MetaData &expected, const icrar::cpu::MetaData &actual, const std::string &ln, const std::string &rn, const std::string &file, int line)

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 - 1307 USA

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/algorithm

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/tests/algorithm

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/model/cpu/calibration

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/common

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/common/config

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/core

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/math/cpu

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/algorithm/cpu

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/model/cpu

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/math/cuda

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/model/cuda

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/algorithm/cuda

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/cuda

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/exception

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/tests/helper

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/algorithm/cuda/kernel

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/core/log

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/tests/math

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/math

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/core/memory

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/model

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/ms

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/core/profiling

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src

dir /home/docs/checkouts/readthedocs.org/user_builds/ska-telescope-icrar-leap-accelerate/checkouts/stable/src/icrar/leap-accelerate/tests