CbmTrdModuleRec2D.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 CBMTRDMODULEREC2D_H
#define CBMTRDMODULEREC2D_H
 
#include "CbmTrdModuleRec.h"
 
#include <list>
#include <map>
#include <vector>
#define NBINSCORRX 50  
#define NBINSCORRY 4   
#define NANODE 9
 
using std::list;
using std::map;
using std::vector;
class TGraphErrors;
class CbmTrdDigiRec;
class CbmTrdParFaspChannel;
class TF1;
class CbmTrdModuleRec2D : public CbmTrdModuleRec {
 public:
  enum ECbmTrdModuleRec2D
  {
    kVerbCluster = 0,  
    kVerbReco    = 1,  
    kDraw        = 2,  
    kHelpers     = 3   
  };
 
  CbmTrdModuleRec2D();
  CbmTrdModuleRec2D(Int_t mod, Int_t ly = -1, Int_t rot = 0);
  virtual ~CbmTrdModuleRec2D();
 
 
  virtual Bool_t AddDigi(const CbmTrdDigi* d, Int_t id);
  virtual void DrawHit(CbmTrdHit*) const { ; }
  virtual Int_t GetOverThreshold() const;
  virtual Bool_t PreProcessHits();
  virtual Bool_t PostProcessHits();
  virtual Int_t FindClusters(bool clr);
  virtual Bool_t MakeHits();
  virtual CbmTrdHit* MakeHit(Int_t cId, const CbmTrdCluster* c, std::vector<const CbmTrdDigi*>* digis);
  Int_t LoadDigis(vector<const CbmTrdDigi*>* din, Int_t cid);
  Int_t ProjectDigis(Int_t cid, Int_t cjd = -1);
  Int_t CheckMerge(Int_t cid, Int_t cjd);
  Bool_t MergeHits(CbmTrdHit* h, Int_t a0);
  Bool_t BuildHit(CbmTrdHit* h);
  UShort_t GetHitMap() const { return vyM; }
  Double_t GetXcorr(Double_t dx, Int_t typ, Int_t cls = 0) const;
  Double_t GetYcorr(Double_t dy, Int_t cls = 0) const;
  void RecenterXoffset(Double_t& dx);
  void RecenterYoffset(Double_t& dy);
  Int_t GetHitClass() const;
  Int_t GetHitRcClass(Int_t a0) const;
 
  void SetUseHelpers(bool use = true)
  {
    use ? SETBIT(fConfigMap, ECbmTrdModuleRec2D::kHelpers) : CLRBIT(fConfigMap, ECbmTrdModuleRec2D::kHelpers);
  }
  void SetHitTimeOffset(int dt) { fHitTimeOff = dt; }
 
 protected:
 private:
  CbmTrdModuleRec2D(const CbmTrdModuleRec2D& ref);
  const CbmTrdModuleRec2D& operator=(const CbmTrdModuleRec2D& ref);
 
  virtual inline void Config(Bool_t vcl, Bool_t vrc, Bool_t dw);
  Bool_t CDRAW() const { return TESTBIT(fConfigMap, ECbmTrdModuleRec2D::kDraw); }
  Bool_t CWRITE(int level) const
  {
    if (level)
      return TESTBIT(fConfigMap, ECbmTrdModuleRec2D::kVerbReco);
    else
      return TESTBIT(fConfigMap, ECbmTrdModuleRec2D::kVerbCluster);
  }
  Bool_t CHELPERS() const { return TESTBIT(fConfigMap, ECbmTrdModuleRec2D::kHelpers); }
 
  int AddClusterEdges(CbmTrdCluster* cl);
  Bool_t CheckConvolution(CbmTrdHit* h) const;
  Bool_t Deconvolute(CbmTrdHit* h);
  Double_t GetXoffset(Int_t n0 = 0) const;
  Double_t GetYoffset(Int_t n0 = 0) const;
  const CbmTrdParFaspChannel* GetFaspChCalibrator(uint16_t ch) const;
  Int_t LoadDigis(std::vector<const CbmTrdDigi*>* digis, std::vector<CbmTrdDigi*>* vdgM, std::vector<Bool_t>* vmask,
                  ULong64_t& t0, Int_t& cM);
  Int_t LoadDigisRC(vector<const CbmTrdDigi*>* digis, const Int_t r0, const Int_t a0,
                    /*vector<CbmTrdDigi*> *vdgM, */ ULong64_t& t0, Int_t& cM);
 
  Bool_t MergeDigis(std::vector<const CbmTrdDigi*>* digis, std::vector<CbmTrdDigi*>* vdgM, std::vector<Bool_t>* vmask);
 
  Bool_t HasLeftSgn() const { return TESTBIT(vyM, 3); }
  Bool_t HasOvf() const { return TESTBIT(vyM, 12); }
  Bool_t IsBiasX() const { return TESTBIT(vyM, 4); }
  Bool_t IsBiasXleft() const { return TESTBIT(vyM, 5); }
  Bool_t IsBiasXmid() const { return TESTBIT(vyM, 6); }
  Bool_t IsBiasXright() const { return TESTBIT(vyM, 7); }
  Bool_t IsBiasY() const { return TESTBIT(vyM, 8); }
  Bool_t IsBiasYleft() const { return TESTBIT(vyM, 9); }
  Bool_t IsLeftHit() const { return TESTBIT(vyM, 2); }
  Bool_t IsMaxTilt() const { return TESTBIT(vyM, 0); }
  Bool_t IsOpenLeft() const { return (viM % 2 && !IsMaxTilt()) || (!(viM % 2) && IsMaxTilt()); }
  inline Bool_t IsOpenRight() const;
  Bool_t IsSymmHit() const { return TESTBIT(vyM, 1); }
  void SetBiasX(Bool_t set = 1) { set ? SETBIT(vyM, 4) : CLRBIT(vyM, 4); }
  void SetBiasXleft(Bool_t set = 1) { set ? SETBIT(vyM, 5) : CLRBIT(vyM, 5); }
  void SetBiasXmid(Bool_t set = 1) { set ? SETBIT(vyM, 6) : CLRBIT(vyM, 6); }
  void SetBiasXright(Bool_t set = 1) { set ? SETBIT(vyM, 7) : CLRBIT(vyM, 7); }
  void SetBiasY(Bool_t set = 1) { set ? SETBIT(vyM, 8) : CLRBIT(vyM, 8); }
  void SetBiasYleft(Bool_t set = 1) { set ? SETBIT(vyM, 9) : CLRBIT(vyM, 9); }
  void SetBiasYmid(Bool_t set = 1) { set ? SETBIT(vyM, 10) : CLRBIT(vyM, 10); }
  void SetBiasYright(Bool_t set = 1) { set ? SETBIT(vyM, 11) : CLRBIT(vyM, 11); }
  void SetLeftSgn(Bool_t set = 1) { set ? SETBIT(vyM, 3) : CLRBIT(vyM, 3); }
  void SetLeftHit(Bool_t set = 1) { set ? SETBIT(vyM, 2) : CLRBIT(vyM, 2); }
  void SetSymmHit(Bool_t set = 1) { set ? SETBIT(vyM, 1) : CLRBIT(vyM, 1); }
  void SetMaxTilt(Bool_t set = 1) { set ? SETBIT(vyM, 0) : CLRBIT(vyM, 0); }
  void SetOvf(Bool_t set = 1) { set ? SETBIT(vyM, 12) : CLRBIT(vyM, 12); }
 
  UChar_t fConfigMap  = 0;                             
  ULong64_t fT0       = 0;                             
  UInt_t fTimeLast    = 0;                             
  UInt_t fTimeWinKeep = 11;                            
  std::map<Int_t, std::list<CbmTrdCluster*>> fBuffer;  //row-wise organized clusters
  std::map<Int_t, vector<CbmTrdDigiRec*>> fDigis;      
  // working representation of a hit on which the reconstruction is performed
  ULong64_t vt0   = 0;        
  UChar_t vcM     = 0;        
  UChar_t vrM     = 0;        
  UChar_t viM     = 0;        
  UShort_t vyM    = 0;        
  int fHitTimeOff = 0;        
  std::vector<Double_t> vs;   
  std::vector<Double_t> vse;  
  std::vector<Char_t> vt;     
  std::vector<Double_t> vx;   
  std::vector<Double_t> vxe;  
 
  static Float_t fgCorrXdx;                         
  static Float_t fgCorrXval[3][NBINSCORRX];         
  static Float_t fgCorrYval[NBINSCORRY][2];         
  static Float_t fgCorrRcXval[2][NBINSCORRX];       
  static Float_t fgCorrRcXbiasXval[3][NBINSCORRX];  
  static Double_t fgDT[3];                          
  static TGraphErrors* fgEdep;                      
  static TF1* fgPRF;                                
  static TGraphErrors* fgT;                         
 
  ClassDef(CbmTrdModuleRec2D,
           2)  // Triangular pad module; Cluster finding and hit reconstruction algorithms
};
 
void CbmTrdModuleRec2D::Config(Bool_t vcl, Bool_t vrc, Bool_t dw)
{
  if (vcl)
    SETBIT(fConfigMap, ECbmTrdModuleRec2D::kVerbCluster);
  else
    CLRBIT(fConfigMap, ECbmTrdModuleRec2D::kVerbCluster);
  printf("CbmTrdModuleRec2D::kVerbCluster[%c]\n", CWRITE(0) ? 'y' : 'n');
  if (vrc)
    SETBIT(fConfigMap, ECbmTrdModuleRec2D::kVerbReco);
  else
    CLRBIT(fConfigMap, ECbmTrdModuleRec2D::kVerbReco);
  printf("CbmTrdModuleRec2D::kVerbReco[%c]\n", CWRITE(1) ? 'y' : 'n');
  if (dw)
    SETBIT(fConfigMap, ECbmTrdModuleRec2D::kDraw);
  else
    CLRBIT(fConfigMap, ECbmTrdModuleRec2D::kDraw);
  printf("CbmTrdModuleRec2D::Draw[%c]\n", CDRAW() ? 'y' : 'n');
}
 
Bool_t CbmTrdModuleRec2D::IsOpenRight() const
{
  Int_t nR = vs.size() - 1 - viM;
  return (nR % 2 && IsMaxTilt()) || (!(nR % 2) && !IsMaxTilt());
}
#endif