CbmTrdDigi.h

Go to the documentation of this file.

/* Copyright (C) 2009-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Florian Uhlig [committer] */
 
#ifndef CBMTRDDIGI_H
#define CBMTRDDIGI_H
 
#include "CbmDefs.h"  // for kTrd
 
#ifndef NO_ROOT
#include <Rtypes.h>  // for CLRBIT, SETBIT, TESTBIT, ClassDef
#endif
 
#include <boost/serialization/access.hpp>
 
#include <cstdint>
#include <string>  // for string
#include <utility>  // for pair
 
class CbmTrdDigi {
public:
  enum class eCbmTrdAsicType : size_t
  {
    kSPADIC = 0,
    kFASP,
    kNTypes
  };
  enum class eTriggerType : int32_t
  {
    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(int32_t padChNr, float chargeT, float chargeR, uint64_t time);
  CbmTrdDigi(int32_t padChNr, int32_t uniqueModuleId, float charge, uint64_t time, eTriggerType triggerType,
             int32_t errClass /*nrSamples*/);
 
  CbmTrdDigi(int32_t /*address*/, double /*fullTime*/, int32_t /*triggerType*/, int32_t /*infoType*/,
             int32_t /*stopType*/, int32_t /*nrSamples*/, float* /*samples*/)
    : fInfo(0)
    , fCharge(0)
    , fTime(0)
  {
    ;
  }
 
  CbmTrdDigi(const CbmTrdDigi&);
 
  CbmTrdDigi& operator=(const CbmTrdDigi&) = default;
 
 
  void AddCharge(CbmTrdDigi* sd, double f);
  void AddCharge(double c, double f = 1);
  static float Clk(eCbmTrdAsicType ty) { return fgClk[static_cast<size_t>(ty)]; }
  int32_t GetAddress() const { return (fInfo >> fgkRoOffset) & 0x7fffff; }
  int32_t GetAddressChannel() const;
  int32_t GetAddressModule() const;
  double GetCharge() const;
  double GetCharge(double& tilt, int32_t& dt) const;
  double GetChargeError() const;
  int32_t GetErrorClass() const { return (fInfo >> fgkErrOffset) & 0x7; }
 
  static ECbmModuleId GetSystem() { return ECbmModuleId::kTrd; }
 
  static const char* GetClassName() { return "CbmTrdDigi"; }
 
  static const char* GetBranchName() { return "TrdDigi"; }
 
 
  double GetTime() const { return fTime; }
  uint64_t GetTimeDAQ() const { return fTime / fgClk[static_cast<size_t>(GetType())]; }
  int32_t GetTriggerType() const { return (fInfo >> fgkTrgOffset) & 0x3; }
 
  static std::pair<eTriggerType, bool> GetTriggerPair(const int32_t triggerValue);
 
  eCbmTrdAsicType GetType() const
  {
    return ((fInfo >> fgkTypOffset) & 0x1) ? eCbmTrdAsicType::kFASP : eCbmTrdAsicType::kSPADIC;
  }
 
  bool IsFASP() const { return GetType() == eCbmTrdAsicType::kFASP; }
 
  bool IsMasked() const { return (GetType() == eCbmTrdAsicType::kFASP) && IsFlagged(kFlag3); }
  bool IsPileUp() const { return (GetType() == eCbmTrdAsicType::kFASP) && IsFlagged(kFlag2); }
  bool IsFlagged(const int32_t iflag) const;
  int32_t Layer() const { return (fInfo >> fgkLyOffset) & 0xf; }
  int32_t Module() const { return (fInfo >> fgkModOffset) & 0x7f; }
 
  void SetAddress(const int32_t a);
  void SetAddressModule(const int32_t a) { SetAddress(a); }
 
  void SetAsic(eCbmTrdAsicType ty = eCbmTrdAsicType::kSPADIC);
  void SetCharge(float c);
  void SetCharge(float cT, float cR, int32_t dt = 0);
  void SetFlag(const int32_t iflag, bool set = true);
  void SetMasked(bool set = true)
  {
    if (GetType() == eCbmTrdAsicType::kFASP) SetFlag(kFlag3, set);
  }
  void SetPileUp(bool set = true)
  {
    if (GetType() == eCbmTrdAsicType::kFASP) SetFlag(kFlag2, set);
  }
  void SetTime(double t) { fTime = static_cast<uint64_t>(t); }
  void SetTimeOffset(int8_t t);
  void SetTriggerType(const eTriggerType triggerType);
  void SetTriggerType(const int32_t triggerValue);
  void SetErrorClass(const int32_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(int32_t /*stopType*/) { ; }
  int32_t GetStopType() { return 0; }
  void SetPulseShape(float /*pulse*/[45]) { ; }
  // keep backward compatible compilation of fles/reader/tasks [/tools]
  double GetChargeTR() const { return 0.; }
  void SetInfoType(int32_t /*infoType*/) { ; }
  int32_t GetNrSamples() { return 0; }
  float* GetSamples() { return nullptr; }
 
protected:
  void SetChannel(const int32_t a)
  {
    fInfo &= ~(0xfff << fgkRoOffset);
    fInfo |= (a & 0xfff) << fgkRoOffset;
  }
  void SetLayer(const int32_t a)
  {
    fInfo &= ~(0xf << fgkLyOffset);
    fInfo |= ((a & 0xf) << fgkLyOffset);
  }
  void SetModule(const int32_t a)
  {
    fInfo &= ~(0x7f << fgkModOffset);
    fInfo |= ((a & 0x7f) << fgkModOffset);
  }
 
  uint32_t fInfo   = 0;  //< pad address and extra information
  uint32_t fCharge = 0;  //< measured charge. For SPADIC is int32_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).
  uint64_t fTime = 0;  //< global time of the digi: For SPADIC & FASP in ns
 
  static const double fgClk[static_cast<size_t>(eCbmTrdAsicType::kNTypes) + 1];
 
  static const float fgPrecission[static_cast<size_t>(eCbmTrdAsicType::kNTypes) + 1];
 
 
private:
  static const int32_t fgkRoOffset  = 0;
  static const int32_t fgkModOffset = 12;
  static const int32_t fgkLyOffset  = 19;
  static const int32_t fgkErrOffset = 23;
  static const int32_t fgkFlgOffset = 26;
  static const int32_t fgkTrgOffset = 29;
  static const int32_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;
  }
 
#ifndef NO_ROOT
  ClassDefNV(CbmTrdDigi, 4);  // Production ready TRD digit
#endif
};
 
#endif