CbmTrdFASP.h

Go to the documentation of this file.

/* Copyright (C) 2018-2020 Horia Hulubei National Institute of Physics and Nuclear Engineering, Bucharest
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Alexandru Bercuci [committer] */
 
#ifndef CBMTRDFASP_H
#define CBMTRDFASP_H
 
#include "CbmTrdParFasp.h"
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Int_t, Float_t, ULong64_t, UInt_t, Bool_t
#include <TObject.h>     // for TObject
 
#include <map>      // for map
#include <tuple>    // for tuple
#include <utility>  // for pair
 
class CbmMatch;
class CbmTrdDigi;
class CbmTrdParFaspChannel;
class TCanvas;
class TGraph;
class TLine;
 
#define FASP_WINDOW 200
#define SHAPER_LUT 80
#define NGRAPH (NFASPMOD * NFASPCH + 1)
 
class CbmTrdFASP : public TObject {
public:
  CbmTrdFASP(UInt_t uslice = 1000);
  virtual ~CbmTrdFASP();
  virtual void Clear(Option_t* opt = "");
  virtual void Draw(Option_t* opt = "");
  virtual ULong64_t GetEndTime() const { return fStartTime + fProcTime; }
  virtual ULong64_t GetStartTime() const { return fStartTime; }
  static Float_t GetBaselineCorr() { return 4095. * fgBaseline / fgOutGain; }
  virtual Bool_t Go(ULong64_t time);
  virtual void InitChannel(int id, const CbmTrdParFaspChannel* par, int asicId = -1, int chId = -1);
  virtual void PhysToRaw(std::vector<std::pair<CbmTrdDigi*, CbmMatch*>>* digi);
  virtual void Print(Option_t* opt = "") const;
  static void SetLGminLength(Int_t nclk) { fgNclkLG = nclk; }
  static void SetNeighbourTrigger(Bool_t nb = kTRUE) { fgNeighbour = nb; }
  static void SetNeighbourThr(Float_t thr = 0.1) { fgNeighbourThr = thr; }
  static void SetShaperThr(Float_t thr = 0.2) { fgShaperThr = thr; }
  void SetProcTime(ULong64_t t = 0);
  void SetStartTime(ULong64_t t) { fStartTime = t; }
 
protected:
  int AddGraph(char typ = 'T');
  void GetShaperSignal(Double_t charge);
  Double_t MakeOut(Int_t t);
  Int_t ProcessShaper(Char_t typ = 'T');
  void ScanDigi(std::vector<std::pair<CbmTrdDigi*, CbmMatch*>>* digi);
  void ScanDigiNE(std::vector<std::pair<CbmTrdDigi*, CbmMatch*>>* digi);
  void WriteDigi();
 
  ULong64_t fStartTime = 0;   
  UInt_t fProcTime     = 0;   
  int fPad             = -1;  
  Int_t fNphys[2];       
  Int_t fNraw                                           = 0;        
  std::vector<std::pair<CbmTrdDigi*, CbmMatch*>>* fDigi = nullptr;  
 
  // analog support
  std::vector<bool> fHitThPrev     = {0};   
  std::vector<Float_t> fShaper     = {0.};  
  std::vector<Float_t> fShaperNext = {0.};  
  std::vector<std::tuple<UInt_t, UInt_t, UInt_t, Bool_t>> fDigiProc =
    {};  
  Float_t fSignal[FASP_WINDOW] = {
    0.};  
 
  // FASP channel characteristics
  const CbmTrdParFaspChannel* fPar[2] = {nullptr};  
  Int_t fTimeLG                       = -1;         
  Int_t fTimeFT                       = -1;         
  Int_t fTimeDY                       = -1;         
  Float_t fFT                         = 0.;         
 
  // FASP graphic support
  int fNgraph               = 1;         
  int fAsicId[2]            = {-1, -1};  
  int fChId[2]              = {-1, -1};  
  std::vector<Float_t> fOut = {0.};      
  std::map<int, std::array<int, NFASPCH>>
    fGraphMap;                             
  TGraph* fGraph[NGRAPH]     = {nullptr};  
  TGraph* fGraphShp[NGRAPH]  = {nullptr};  
  TGraph* fGraphPhys[NGRAPH] = {nullptr};  
  TLine* fGthr               = nullptr;    
  TCanvas* fMonitor          = nullptr;    
 
  // CADENCE parameters
  static const Int_t fgkNDB = 53;                       
  static const Float_t fgkCharge[fgkNDB];               
  static const Float_t fgkShaper[fgkNDB][FASP_WINDOW];  
  static const Float_t fgkShaperPar[4];                 
  static const Float_t fgkShaperLUT[SHAPER_LUT];        
  static const Float_t fgkDecayLUT[SHAPER_LUT];         
 
  // FASP configuration parameters
  static const Int_t fgkNclkFT;   
  static Int_t fgNclkLG;          
  static Bool_t fgNeighbour;      
  static Float_t fgNeighbourThr;  
  static Float_t fgShaperThr;     
  static Float_t fgBaseline;      
  static Float_t fgOutGain;       
 
  // FASP simulator configuration
  static const Int_t fgkBufferKeep;  
 
  ClassDef(CbmTrdFASP, 1)  // FASP ASIC simulator
};
 
#endif