AARE
Data analysis library for PSI hybrid detectors
Loading...
Searching...
No Matches
Namespaces | Data Structures | Typedefs | Enumerations | Functions
aare Namespace Reference

Frame class to represent a single frame of data model class should be able to work with streams coming from files or network. More...

Namespaces

namespace  File
 
namespace  Frame
 
namespace  logger
 
namespace  network_io
 
namespace  NumpyHelpers
 

Data Structures

class  CircularFifo
 
class  ClusterFinder
 
class  DType
 
class  File
 RAII File class for reading and writing image files in various formats wrapper on a FileInterface to abstract the underlying file format. More...
 
struct  FileConfig
 FileConfig structure to store the configuration of a file dtype: data type of the file rows: number of rows in the file cols: number of columns in the file geometry: geometry of the file. More...
 
class  FileInterface
 FileInterface class to define the interface for file operations. More...
 
class  Frame
 
class  NDArray
 
class  NDView
 
class  NumpyFile
 NumpyFile class to read and write numpy files. More...
 
struct  NumpyHeader
 
class  RawFile
 RawFile class to read .raw and .json files. More...
 
struct  RawFileConfig
 
struct  sls_detector_header
 
class  SubFile
 Class to read a subfile from a RawFile. More...
 
struct  xy
 
struct  ZmqFrame
 ZmqFrame structure wrapper class to contain a ZmqHeader and a Frame. More...
 
struct  ZmqHeader
 
class  ZmqSocket
 
class  ZmqSocketReceiver
 
class  ZmqSocketSender
 

Typedefs

using dynamic_shape = std::vector< ssize_t >
 
using DataTypeVariants = std::variant< uint16_t, uint32_t >
 
template<ssize_t Ndim>
using Shape = std::array< ssize_t, Ndim >
 
using shape_t = std::vector< size_t >
 

Enumerations

enum class  DetectorType {
  Jungfrau , Eiger , Mythen3 , Moench ,
  ChipTestBoard
}
 
enum class  TimingMode { Auto , Trigger }
 
enum class  endian { little = __ORDER_LITTLE_ENDIAN__ , big = __ORDER_BIG_ENDIAN__ , native = __BYTE_ORDER__ }
 

Functions

template<class T >
StringTo (std::string sv)
 
template<class T >
std::string toString (T sv)
 
template<>
DetectorType StringTo (std::string)
 
template<>
std::string toString (DetectorType type)
 
template<>
TimingMode StringTo (std::string)
 
template<typename T , ssize_t Ndim>
void save (NDArray< T, Ndim > &img, std::string pathname)
 
template<typename T , ssize_t Ndim>
NDArray< T, Ndim > load (const std::string &pathname, std::array< ssize_t, Ndim > shape)
 
template<ssize_t Ndim>
Shape< Ndim > make_shape (const std::vector< size_t > &shape)
 
template<ssize_t Dim = 0, typename Strides >
ssize_t element_offset (const Strides &)
 
template<ssize_t Dim = 0, typename Strides , typename... Ix>
ssize_t element_offset (const Strides &strides, ssize_t i, Ix... index)
 
template<ssize_t Ndim>
std::array< ssize_t, Ndim > c_strides (const std::array< ssize_t, Ndim > &shape)
 
template<ssize_t Ndim>
std::array< ssize_t, Ndim > make_array (const std::vector< ssize_t > &vec)
 
template<>
std::string toString (DetectorType type)
 
template<>
DetectorType StringTo (std::string name)
 
template<>
TimingMode StringTo (std::string mode)
 

Detailed Description

Frame class to represent a single frame of data model class should be able to work with streams coming from files or network.

Typedef Documentation

◆ DataTypeVariants

using aare::DataTypeVariants = typedef std::variant<uint16_t, uint32_t>

◆ dynamic_shape

using aare::dynamic_shape = typedef std::vector<ssize_t>

◆ Shape

template<ssize_t Ndim>
using aare::Shape = typedef std::array<ssize_t, Ndim>

◆ shape_t

using aare::shape_t = typedef std::vector<size_t>

Enumeration Type Documentation

◆ DetectorType

enum class aare::DetectorType
strong
Enumerator
Jungfrau 
Eiger 
Mythen3 
Moench 
ChipTestBoard 

◆ endian

enum class aare::endian
strong
Enumerator
little 
big 
native 

◆ TimingMode

enum class aare::TimingMode
strong
Enumerator
Auto 
Trigger 

Function Documentation

◆ c_strides()

template<ssize_t Ndim>
std::array< ssize_t, Ndim > aare::c_strides ( const std::array< ssize_t, Ndim > &  shape)

◆ element_offset() [1/2]

template<ssize_t Dim = 0, typename Strides >
ssize_t aare::element_offset ( const Strides &  )

◆ element_offset() [2/2]

template<ssize_t Dim = 0, typename Strides , typename... Ix>
ssize_t aare::element_offset ( const Strides &  strides,
ssize_t  i,
Ix...  index 
)

◆ load()

template<typename T , ssize_t Ndim>
NDArray< T, Ndim > aare::load ( const std::string &  pathname,
std::array< ssize_t, Ndim >  shape 
)

◆ make_array()

template<ssize_t Ndim>
std::array< ssize_t, Ndim > aare::make_array ( const std::vector< ssize_t > &  vec)

◆ make_shape()

template<ssize_t Ndim>
Shape< Ndim > aare::make_shape ( const std::vector< size_t > &  shape)

◆ save()

template<typename T , ssize_t Ndim>
void aare::save ( NDArray< T, Ndim > &  img,
std::string  pathname 
)

◆ StringTo() [1/5]

template<>
TimingMode aare::StringTo ( std::string  mode)

◆ StringTo() [2/5]

template<>
DetectorType aare::StringTo ( std::string  name)

◆ StringTo() [3/5]

template<class T >
T aare::StringTo ( std::string  sv)

◆ StringTo() [4/5]

template<>
DetectorType aare::StringTo ( std::string  name)

◆ StringTo() [5/5]

template<>
TimingMode aare::StringTo ( std::string  name)

◆ toString() [1/3]

template<>
std::string aare::toString ( DetectorType  type)

◆ toString() [2/3]

template<>
std::string aare::toString ( DetectorType  type)

◆ toString() [3/3]

template<class T >
std::string aare::toString ( sv)