BaseProducts.h

Go to the documentation of this file.

#ifndef BASEPRODUCTS_H
#define BASEPRODUCTS_H

#include "DAQChannelMap/DAQChannelMap.h"
#include "DAQDataFormats/TriggerDefines.h"

#include <stdint.h>

namespace novaddt{

  // These are the definitions of the base
  // data types that are contained in all
  // DAQHit objects and used else where
  // as parameters for other data products 

  // The Time Stamp for the data
  // This is a 64bit time stamp 
  // which is constructed from two 32bit 
  // data words

  // The fractional member was added to provide
  // sub-tick precision derived from
  // multipoint fitting.
  struct TDC {
#ifndef __GCCXML__
    TDC() = default;
#endif
    TDC(uint64_t const a):val(a),frac(0){}
    TDC(uint64_t const a, uint8_t f):val(a),frac(f){}

    // use unsigned long long to ensure the same type on OSX and linux systems
    typedef unsigned long long value_type;
    typedef uint8_t fraction_type;
    value_type val;
    fraction_type frac;

    double fraction() const { return double(frac) / 100; }
  };
  

  // Note:
  //   fractional TDC values are not used in the operators
  //
  inline bool operator== (TDC lhs, TDC rhs) { return lhs.val == rhs.val; }
  inline bool operator< (TDC lhs, TDC rhs) { return lhs.val < rhs.val; }
  inline bool operator> (TDC lhs, TDC rhs) { return lhs.val > rhs.val; }
  inline TDC::value_type operator- (TDC lhs, TDC rhs) 
  { return lhs.val - rhs.val; }
  inline TDC::value_type operator+ (TDC lhs, TDC rhs) 
  { return lhs.val + rhs.val; }
  inline TDC::value_type operator* (TDC lhs, TDC rhs) 
  { return lhs.val * rhs.val; }
  inline TDC::value_type operator+= (TDC lhs, TDC rhs) 
  { return lhs.val += rhs.val; }


  // This is the ADC value which is 12bits
  // wide in the raw data
  struct ADC {
#ifndef __GCCXML__
    ADC() = default;
#endif
    ADC(uint16_t const a):val(a){}
    typedef uint16_t value_type;
    value_type val;
  };

  inline bool operator== (ADC lhs, ADC rhs) { return lhs.val == rhs.val; }
  inline bool operator<  (ADC lhs, ADC rhs) { return lhs.val < rhs.val; }
  inline bool operator>  (ADC lhs, ADC rhs) { return lhs.val > rhs.val; }
  inline ADC::value_type operator-  (ADC lhs, ADC rhs) 
  { return lhs.val - rhs.val; }
  inline ADC::value_type operator+  (ADC lhs, ADC rhs) 
  { return lhs.val + rhs.val; }

  // This is the Plane on which the hit registered
  // This ranges from 1 to 32*Nblocks (960ish)
  struct Plane {
#ifndef __GCCXML__
    Plane() = default;
#endif
    Plane(uint16_t const a):val(a){}
    typedef uint16_t value_type;
    value_type val;
  };

  inline bool operator== (Plane lhs, Plane rhs) { return lhs.val == rhs.val; }
  inline bool operator< (Plane lhs, Plane rhs) { return lhs.val < rhs.val; }
  inline bool operator> (Plane lhs, Plane rhs) { return lhs.val > rhs.val; }
  inline Plane::value_type operator- (Plane lhs, Plane rhs)
  { return lhs.val - rhs.val; }
  inline Plane::value_type operator+ (Plane lhs, Plane rhs) 
  { return lhs.val + rhs.val; }
  inline Plane::value_type operator* (Plane lhs, Plane rhs) 
  { return lhs.val * rhs.val; }
  inline Plane::value_type operator+= (Plane lhs, Plane rhs) 
  { return lhs.val += rhs.val; }


  // This is the cell number within the plane to
  // which the hit belonged.  This ranges from 1
  // to 384 (32*12)
  struct Cell {
#ifndef __GCCXML__
    Cell() = default;
#endif
    Cell(uint16_t const a):val(a){}
    typedef uint16_t value_type;
    value_type val;
  };

  inline bool operator== (Cell lhs, Cell rhs) { return lhs.val == rhs.val; }
  inline bool operator< (Cell lhs, Cell rhs) { return lhs.val < rhs.val; }
  inline bool operator> (Cell lhs, Cell rhs) { return lhs.val > rhs.val; }
  inline Cell::value_type operator- (Cell lhs, Cell rhs) 
  { return lhs.val - rhs.val; }
  inline Cell::value_type operator+ (Cell lhs, Cell rhs) 
  { return lhs.val + rhs.val; }
  inline Cell::value_type operator* (Cell lhs, Cell rhs) 
  { return lhs.val * rhs.val; }
  inline Cell::value_type operator+= (Cell lhs, Cell rhs) 
  { return lhs.val += rhs.val; }

  // This is the view to which the hit belonged
  // This is either an X or Y view

  /*
    MF (8/15/2013) 
    Chris G. recommended this form of the View struct so as to not confuse Root
    about the constructor.  For some reason, Root would add the View as a branch
    rather than as a member.  Let's see whether this will fix the problem.
  */
  struct View {
    typedef uint8_t value_type;
    View() : val(0) {}
    explicit View(value_type const a) : val(a) {}
    value_type val;
  };
//   struct View {
// #ifndef __GCCXML__
//     View() = default;
// #endif
//     View(uint8_t const a):val(a){}
//     typedef uint8_t value_type;
//     value_type val;
//   };

  // It is not clear whether we want a comparison operator for the view
  // and how to implement it, but here is an example based on the comparison 
  // operators above:

  inline bool operator== (View lhs, View rhs) { return lhs.val == rhs.val; }
  inline bool operator<  (View lhs, View rhs) { return lhs.val <  rhs.val; }
  inline bool operator>  (View lhs, View rhs) { return lhs.val >  rhs.val; }
  inline bool operator!= (View lhs, View rhs) { return lhs.val != rhs.val; }


  // This is the DCM to which the hit belonged
  // This is going to be used in partitioning by DCM boundaries
  struct DCM {
#ifndef __GCCXML__
    DCM() = default;
#endif
    DCM(daqchannelmap::dcm_id_t const a):val(a){}
    typedef daqchannelmap::dcm_id_t value_type;
    value_type val;
  };

  inline bool operator== (DCM lhs, DCM rhs) { return lhs.val == rhs.val; }
  inline bool operator< (DCM lhs, DCM rhs) { return lhs.val < rhs.val; }
  inline bool operator> (DCM lhs, DCM rhs) { return lhs.val > rhs.val; }

  
  //This is the triggger decision that has been issued
  struct TriggerMask {
#ifndef __GCCXML__
    TriggerMask() = default;
#endif
    TriggerMask(daqdataformats::trigID const a):val(a){}
    typedef daqdataformats::trigID value_type;
    value_type val;
  };


} /* End Namespace */
#endif /* BASEPRODUCTS_H */