CbmTrdDigi.h

Go to the documentation of this file.

#ifndef CBMTRDDIGI_H
#define CBMTRDDIGI_H
 
#include <Rtypes.h>      // for ClassDef
#include <RtypesCore.h>  // for Int_t, Float_t, Double_t, Bool_t, ULong64_t
 
#include <string>  // for string
 
#include "CbmDefs.h"  // for kTrd
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
 
class CbmTrdDigi {
public:
  enum CbmTrdAsicType { kSPADIC = 0, kFASP, kNTypes };
  enum ECbmTrdTriggerType {
    kBeginTriggerTypes = 0,
    kSelf              = kBeginTriggerTypes,
    kNeighbor,
    kMulti,
    kTrg2,
    kNTrg
  };
  enum CbmTrdDigiDef {
    kFlag1 = 0  //<
    ,
    kFlag2  //< in case of FASP simulations define pileup
    ,
    kFlag3  //< in case of FASP simulations define masked
    ,
    kNflags
  };
  CbmTrdDigi();
  CbmTrdDigi(Int_t padChNr, Float_t chargeT, Float_t chargeR, ULong64_t time);
  CbmTrdDigi(Int_t padChNr,
             Int_t uniqueModuleId,
             Float_t charge,
             ULong64_t time,
             Int_t triggerType,
             Int_t errClass /*nrSamples*/);
 
  CbmTrdDigi(Int_t /*address*/,
             Double_t /*fullTime*/,
             Int_t /*triggerType*/,
             Int_t /*infoType*/,
             Int_t /*stopType*/,
             Int_t /*nrSamples*/,
             Float_t* /*samples*/)
    : fInfo(0), fCharge(0), fTime(0) {
    ;
  }
 
  void AddCharge(CbmTrdDigi* sd, Double_t f);
  void AddCharge(Double_t c, Double_t f = 1);
  static Float_t Clk(CbmTrdAsicType ty) {
    return (ty == kNTypes ? 0 : fgClk[ty]);
  }
  Int_t GetAddress() const { return (fInfo >> fgkRoOffset) & 0x7fffff; }
  Int_t GetAddressChannel() const;
  Int_t GetAddressModule() const;
  Double_t GetCharge() const;
  Double_t GetCharge(Double_t& tilt, Int_t& dt) const;
  Double_t GetChargeError() const;
  Int_t GetErrorClass() const { return (fInfo >> fgkErrOffset) & 0x7; }
 
  static ECbmModuleId GetSystem() { return ECbmModuleId::kTrd; }
 
 
  static const char* GetClassName() { return "CbmTrdDigi"; }
 
 
  Double_t GetTime() const {
    return (GetType() == kFASP) ? fTime * fgClk[GetType()] : fTime;
  }
  ULong64_t GetTimeDAQ() const {
    return (GetType() == kFASP) ? fTime : fTime / fgClk[GetType()];
  }
  Int_t GetTriggerType() const { return (fInfo >> fgkTrgOffset) & 0x3; }
  CbmTrdAsicType GetType() const {
    return ((fInfo >> fgkTypOffset) & 0x1) ? kFASP : kSPADIC;
  }
 
  Bool_t IsMasked() const { return (GetType() == kFASP) && IsFlagged(kFlag3); }
  Bool_t IsPileUp() const { return (GetType() == kFASP) && IsFlagged(kFlag2); }
  Bool_t IsFlagged(const Int_t iflag) const;
  Int_t Layer() const { return (fInfo >> fgkLyOffset) & 0xf; }
  Int_t Module() const { return (fInfo >> fgkModOffset) & 0x7f; }
 
  void SetAddress(const Int_t a);
  void SetAddressModule(const Int_t a) { SetAddress(a); }
 
  void SetAsic(CbmTrdAsicType ty = kSPADIC);
  void SetCharge(Float_t c);
  void SetCharge(Float_t cT, Float_t cR, Int_t dt = 0);
  void SetFlag(const Int_t iflag, Bool_t set = kTRUE);
  void SetMasked(Bool_t set = kTRUE) {
    if (GetType() == kFASP) SetFlag(kFlag3, set);
  }
  void SetPileUp(Bool_t set = kTRUE) {
    if (GetType() == kFASP) SetFlag(kFlag2, set);
  }
  void SetTime(Double_t t);
  void SetTimeDAQ(ULong64_t t) { fTime = t; }
  void SetTimeOffset(Char_t t);
  void SetTriggerType(const Int_t ttype);
  void SetErrorClass(const Int_t n) {
    fInfo &= ~(0x7 << fgkErrOffset);
    fInfo |= ((n & 0x7) << fgkErrOffset);
  }
  std::string ToString() const;
 
  // TEMPORARY ADDED WITHOUT PROVIDING FUNCTIONALITY ! TODO should be removed
  // keep backward compatible compilation of CbmTrdSPADIC
  void SetStopType(Int_t /*stopType*/) { ; }
  Int_t GetStopType() { return 0; }
  void SetPulseShape(Float_t /*pulse*/[45]) { ; }
  // keep backward compatible compilation of fles/reader/tasks [/tools]
  Double_t GetChargeTR() const { return 0.; }
  void SetInfoType(Int_t /*infoType*/) { ; }
  Int_t GetNrSamples() { return 0; }
  Float_t* GetSamples() { return nullptr; }
 
protected:
  void SetChannel(const Int_t a) {
    fInfo &= ~(0xfff << fgkRoOffset);
    fInfo |= (a & 0xfff) << fgkRoOffset;
  }
  void SetLayer(const Int_t a) {
    fInfo &= ~(0xf << fgkLyOffset);
    fInfo |= ((a & 0xf) << fgkLyOffset);
  }
  void SetModule(const Int_t a) {
    fInfo &= ~(0x7f << fgkModOffset);
    fInfo |= ((a & 0x7f) << fgkModOffset);
  }
 
  UInt_t fInfo;  //< pad address and extra information
  UInt_t
    fCharge;  //< measured charge. For SPADIC is Int_t(charge*1eN) where N is the precission while
    //< for FASP it contains the R and T charges each on 12bits and the time difference between R and T pads in CLK (8 bits).
  ULong64_t
    fTime;  //< global time of the digi: For SPADIC in ns, for FASP in ASIC clock
 
  static Double_t fgClk[kNTypes];        //< clock length in ns for acquisition
  static Float_t fgPrecission[kNTypes];  //< no. of digits stored for ASIC
 
private:
  static const Int_t fgkRoOffset  = 0;
  static const Int_t fgkModOffset = 12;
  static const Int_t fgkLyOffset  = 19;
  static const Int_t fgkErrOffset = 23;
  static const Int_t fgkFlgOffset = 26;
  static const Int_t fgkTrgOffset = 29;
  static const Int_t fgkTypOffset = 31;
 
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive& ar, const unsigned int /*version*/) {
    ar& fInfo;
    ar& fCharge;
    ar& fTime;
  }
 
  ClassDefNV(CbmTrdDigi, 3);  // Production ready TRD digit
};
 
#endif