scTDC_types.h

Go to the documentation of this file.

#pragma once

#ifndef ssize_t
#ifdef __linux__
  #include <sys/types.h>
#elif _WIN32
  #ifdef _MSC_VER
    #include <BaseTsd.h>
    typedef SSIZE_T ssize_t;
  #elif __MINGW32__
    #include <sys/types.h>
  #endif
#endif
#endif

#define SEPARATORS_TO_FLOW 0x01

#define STATISTICS_TO_FLOW 0x02

#define MILLISECONDS_TO_FLOW 0x04

#define FLIM_BOTH_WAY_SCAN 0x01

#define FLIM_XY_SWAP 0x02


struct sc3d_t
{
  int x; 
  int y; 
  long long time; 
};

struct sc3du_t
{
  unsigned int x; 
  unsigned int y; 
  unsigned long long time; 
};

struct roi_t
{
  struct sc3d_t offset; 
  struct sc3du_t size; 
};

struct statistics_t
{
  unsigned int counts_read[4][16];
  unsigned int counts_received[4][16];
  unsigned int events_found[4];
  unsigned int events_in_roi[4];
  unsigned int events_received[4];
  unsigned int counters[4][16];
  unsigned int reserved[52];
};

struct sc_tdc_channel_statistics_t
{
  unsigned long long counts_read;
  unsigned long long counts_received;
  unsigned long long counter;
  unsigned long long reserved[5];
};

struct sc_dld_device_statistics_t
{
  unsigned long long events_found;
  unsigned long long events_in_roi;
  unsigned long long events_received;
  unsigned long long reserved[5];
};

enum bitsize_t
{
  BS8 = 0, 
  BS16 = 1, 
  BS32 = 2, 
  BS64= 3, 
  F32 = 4, 
  F64 = 5 
};

struct sc_tdc_format
{
  unsigned char total_bits_length; 
  unsigned char channel_offset; 
  unsigned char channel_length; 
  unsigned char time_data_offset; 
  unsigned char time_data_length; 
  unsigned char time_tag_offset;
  unsigned char time_tag_length;
  unsigned char start_counter_offset; 
  unsigned char start_counter_length; 
  unsigned char dif1_offset; 
  unsigned char dif1_length; 
  unsigned char dif2_offset; 
  unsigned char dif2_length; 
  unsigned char sum_offset; 
  unsigned char sum_length; 
  unsigned char sign_counter_offset;
  unsigned char sign_counter_length;
  unsigned char reserved[14]; 
  unsigned char flow_control_flags; 
};

enum sc_pipe_type_t
{
  TDC_HISTO = 0, 
  DLD_IMAGE_XY = 1, 
  DLD_IMAGE_XT = 2, 
  DLD_IMAGE_YT = 3, 
  DLD_IMAGE_3D = 4, 
  DLD_SUM_HISTO = 5, 
  STATISTICS = 6, 
  TMSTAMP_TDC_HISTO = 7,
  TDC_STATISTICS = 8,
  DLD_STATISTICS = 9,
  USER_CALLBACKS = 10,
  DLD_IMAGE_XY_EXT = 11
};

struct sc_pipe_dld_image_xy_params_t
{
  enum bitsize_t depth; 
  int channel; 
  unsigned long long modulo; 
  struct sc3du_t binning; 
  struct roi_t roi; 
  unsigned int accumulation_ms; 
  void *allocator_owner; 
  int (*allocator_cb)(void *, void **);
};

struct sc_pipe_dld_image_xt_params_t
{
  enum bitsize_t depth; 
  int channel; 
  unsigned long long modulo;
  struct sc3du_t binning;
  struct roi_t roi;
  unsigned int accumulation_ms;
  void *allocator_owner;
  int (*allocator_cb)(void *, void **);
};

struct sc_pipe_dld_image_yt_params_t
{
  enum bitsize_t depth;
  int channel;
  unsigned long long modulo;
  struct sc3du_t binning;
  struct roi_t roi;
  unsigned int accumulation_ms;
  void *allocator_owner;
  int (*allocator_cb)(void *, void **);
};

struct sc_pipe_dld_image_3d_params_t
{
  enum bitsize_t depth;
  int channel;
  unsigned long long modulo;
  struct sc3du_t binning;
  struct roi_t roi;
  unsigned int accumulation_ms;
  void *allocator_owner;
  int (*allocator_cb)(void *, void **);
};

struct sc_pipe_dld_sum_histo_params_t
{
  enum bitsize_t depth; 
  int channel; 
  unsigned long long modulo; 
  struct sc3du_t binning; 
  struct roi_t roi; 
  unsigned int accumulation_ms; 
  void *allocator_owner; 
  int (*allocator_cb)(void *, void **);
};

struct sc_pipe_tdc_histo_params_t
{
  enum bitsize_t depth; 
  unsigned int channel; 
  unsigned long long modulo; 
  unsigned int binning; 
  unsigned long long offset; 
  unsigned int size; 
  unsigned int accumulation_ms; 
  void *allocator_owner; 
  int (*allocator_cb)(void *, void **);
};

struct sc_pipe_statistics_params_t
{
  void *allocator_owner;
  int (*allocator_cb)(void *, void **);
};

struct sc_pipe_tdc_stat_params_t
{
  void *allocator_owner;
  int (*allocator_cb) (void *, void **);
  int channel_number;
};

struct sc_pipe_dld_stat_params_t
{
  void *allocator_owner;
  int (*allocator_cb) (void *, void **);
  int device_number;
};

enum sc_pipe_param_extension_type
{
  SC_PIPE_PARAM_EXTENSION_TYPE_IMAGE_SOURCE
};

struct sc_pipe_image_source
{
  enum sc_pipe_param_extension_type type;
  void *extension;
  enum sc_ImageSource {
    EVENTS,
    RAMDATA,
    BOTH
  } source;
};

struct sc_pipe_dld_image_xy_ext_params_t
{
  struct sc_pipe_dld_image_xy_params_t base;
  void *extension;
};

struct sc_TdcEvent
{
  unsigned subdevice; 
  unsigned channel; 
  unsigned long long start_counter; 
  unsigned long long time_tag; 
  unsigned long long time_data; 
  unsigned long long sign_counter;
};

struct sc_DldEvent
{
  unsigned long long start_counter; 
  unsigned long long time_tag; 
  unsigned subdevice; 
  unsigned channel;
  unsigned long long sum; 
  unsigned short dif1; 
  unsigned short dif2; 
  unsigned master_rst_counter;
  unsigned short adc;
  unsigned short signal1bit;
};

struct sc_pipe_callbacks
{
  void *priv;
  void (*start_of_measure) (void *priv);
  void (*end_of_measure) (void *priv);
  void (*millisecond_countup) (void *priv);
  void (*statistics) (void *priv, const struct statistics_t *stat);
  void (*tdc_event)
    (void *priv, const struct sc_TdcEvent *const event_array, size_t event_array_len);
  void (*dld_event)
    (void *priv, const struct sc_DldEvent *const event_array, size_t event_array_len);
};

struct sc_pipe_callback_params_t
{
  struct sc_pipe_callbacks *callbacks;
};


const unsigned long long sc_mask64[] = {
  0x0000000000000000ULL,
  0x0000000000000001ULL,
  0x0000000000000003ULL,
  0x0000000000000007ULL,
  0x000000000000000FULL,
  0x000000000000001FULL,
  0x000000000000003FULL,
  0x000000000000007FULL,
  0x00000000000000FFULL,
  0x00000000000001FFULL,
  0x00000000000003FFULL,
  0x00000000000007FFULL,
  0x0000000000000FFFULL,
  0x0000000000001FFFULL,
  0x0000000000003FFFULL,
  0x0000000000007FFFULL,
  0x000000000000FFFFULL,
  0x000000000001FFFFULL,
  0x000000000003FFFFULL,
  0x000000000007FFFFULL,
  0x00000000000FFFFFULL,
  0x00000000001FFFFFULL,
  0x00000000003FFFFFULL,
  0x00000000007FFFFFULL,
  0x0000000000FFFFFFULL,
  0x0000000001FFFFFFULL,
  0x0000000003FFFFFFULL,
  0x0000000007FFFFFFULL,
  0x000000000FFFFFFFULL,
  0x000000001FFFFFFFULL,
  0x000000003FFFFFFFULL,
  0x000000007FFFFFFFULL,
  0x00000000FFFFFFFFULL,
  0x00000001FFFFFFFFULL,
  0x00000003FFFFFFFFULL,
  0x00000007FFFFFFFFULL,
  0x0000000FFFFFFFFFULL,
  0x0000001FFFFFFFFFULL,
  0x0000003FFFFFFFFFULL,
  0x0000007FFFFFFFFFULL,
  0x000000FFFFFFFFFFULL,
  0x000001FFFFFFFFFFULL,
  0x000003FFFFFFFFFFULL,
  0x000007FFFFFFFFFFULL,
  0x00000FFFFFFFFFFFULL,
  0x00001FFFFFFFFFFFULL,
  0x00003FFFFFFFFFFFULL,
  0x00007FFFFFFFFFFFULL,
  0x0000FFFFFFFFFFFFULL,
  0x0001FFFFFFFFFFFFULL,
  0x0003FFFFFFFFFFFFULL,
  0x0007FFFFFFFFFFFFULL,
  0x000FFFFFFFFFFFFFULL,
  0x001FFFFFFFFFFFFFULL,
  0x003FFFFFFFFFFFFFULL,
  0x007FFFFFFFFFFFFFULL,
  0x00FFFFFFFFFFFFFFULL,
  0x01FFFFFFFFFFFFFFULL,
  0x03FFFFFFFFFFFFFFULL,
  0x07FFFFFFFFFFFFFFULL,
  0x0FFFFFFFFFFFFFFFULL,
  0x1FFFFFFFFFFFFFFFULL,
  0x3FFFFFFFFFFFFFFFULL,
  0x7FFFFFFFFFFFFFFFULL,
  0xFFFFFFFFFFFFFFFFULL,
};

const unsigned int sc_mask32[] = {
  0x00000000,
  0x00000001,
  0x00000003,
  0x00000007,
  0x0000000F,
  0x0000001F,
  0x0000003F,
  0x0000007F,
  0x000000FF,
  0x000001FF,
  0x000003FF,
  0x000007FF,
  0x00000FFF,
  0x00001FFF,
  0x00003FFF,
  0x00007FFF,
  0x0000FFFF,
  0x0001FFFF,
  0x0003FFFF,
  0x0007FFFF,
  0x000FFFFF,
  0x001FFFFF,
  0x003FFFFF,
  0x007FFFFF,
  0x00FFFFFF,
  0x01FFFFFF,
  0x03FFFFFF,
  0x07FFFFFF,
  0x0FFFFFFF,
  0x1FFFFFFF,
  0x3FFFFFFF,
  0x7FFFFFFF,
  0xFFFFFFFF,
};


enum sc_event_type_index {
  SC_TDC_SIGN_START = 0, 
  SC_TDC_SIGN_MILLISEC = 1, 
  SC_TDC_SIGN_STAT = 2 
};

enum sc_LoggerFacility {UNUSED}; //TODO: Remove

struct sc_Logger
{
  void *private_data; 
  void (*do_log)(void *pd, const char *sender, const char *msg);
};

struct sc_PipeCbf
{
  void (*cb)(void *);
  void *private_data;
};

struct sc_ConfigLine
{
  const char *section;
  const char *key;
  const char *value;
};

struct sc_DeviceProperties1
{
  struct sc3du_t detector_size; 
  double pixel_size_x; 
  double pixel_size_y; 
  double pixel_size_t; 
};

struct sc_DeviceProperties2
{
  int tdc_channel_number; 
};

struct sc_DeviceProperties3
{
  size_t dld_event_size; 
  size_t tdc_event_size; 
  size_t user_callback_size; 
};

struct sc_CmosSmootherParameters
{
  enum sc_ShutterMode {
    FULLY_EXTERNAL,
    IMMEDIATE_START_INTERNAL_TIMER,
    IMMEDIATE_START_INTERNAL_TIMER_MULTIPLE_SLOPES,
    EXTERNAL_START_INTERNAL_TIMER,
    EXTERNAL_START_INTERNAL_TIMER_MULTIPLE_SLOPES,
    IMMEDIATE_START_EXTERNAL_FINISH
  } shutter_mode;
  unsigned int single_slope_us;
  unsigned int dual_slope_us;
  unsigned int triple_slope_us;
  unsigned int frame_count;
  unsigned int analog_gain;
  double digital_gain;
  unsigned int black_offset;
  int black_cal_offset;
  unsigned int smoother_shift1;
  unsigned char smoother_pixel_mask1 [8][8];
  unsigned int smoother_shift2;
  unsigned char smoother_pixel_mask2 [8][8];
};

struct sc_BlobParameters
{
  unsigned int unbinning;
  unsigned int dif_min_top;
  unsigned int dif_min_bottom;
  double z_scale_factor;
};