CbmTrdClusterFinder.h

Go to the documentation of this file.

#ifndef CBMTRDCLUSTERFINDER_H
#define CBMTRDCLUSTERFINDER_H
 
#include "FairTask.h"
 
#include <map>
#include <set>
#include <vector>
 
class CbmTrdCluster;
class CbmTrdDigi;
class CbmTrdParSetAsic;
class CbmTrdParSetGas;
class CbmTrdParSetGeo;
class CbmTrdParSetDigi;
class CbmTrdParSetGain;
class CbmTrdModuleRec;
class TClonesArray;
class TGeoPhysicalNode;
 
class CbmTrdClusterFinder : public FairTask {
  friend class CbmTrdModuleRecR;
  friend class CbmTrdModuleRecT;
 
public:
  enum CbmTrdRecDef {
    kTime = 0,      
    kMultiHit,      
    kRowMerger,     
    kNeighbourCol,  
    kNeighbourRow,  
    kDumpClusters,  
    kFASP           
  };
 
  CbmTrdClusterFinder();
 
  ~CbmTrdClusterFinder();
 
  static Float_t GetMinimumChargeTH() { return fgMinimumChargeTH; }
  static Bool_t HasDumpClusters() { return TESTBIT(fgConfig, kDumpClusters); }
  static Bool_t HasMultiHit() { return TESTBIT(fgConfig, kMultiHit); }
  static Bool_t HasNeighbourCol() { return TESTBIT(fgConfig, kNeighbourCol); }
  static Bool_t HasNeighbourRow() { return TESTBIT(fgConfig, kNeighbourRow); }
  static Bool_t HasRowMerger() { return TESTBIT(fgConfig, kRowMerger); }
  static Bool_t IsTimeBased() { return TESTBIT(fgConfig, kTime); }
 
  //virtual InitStatus ReInit();
  virtual InitStatus Init();
  virtual void SetParContainers();
 
  virtual void Exec(Option_t* option);
 
  virtual void Finish();
 
 
  static void SetDumpClusters(Bool_t set = kTRUE) {
    set ? SETBIT(fgConfig, kDumpClusters) : CLRBIT(fgConfig, kDumpClusters);
  }
  static void SetRowMerger(Bool_t set = kTRUE) {
    set ? SETBIT(fgConfig, kRowMerger) : CLRBIT(fgConfig, kRowMerger);
  }
  static void SetMultiHit(Bool_t set = kTRUE) {
    set ? SETBIT(fgConfig, kMultiHit) : CLRBIT(fgConfig, kMultiHit);
  }
  static void SetNeighbourEnable(Bool_t col = kTRUE, Bool_t row = kFALSE) {
    col ? SETBIT(fgConfig, kNeighbourCol) : CLRBIT(fgConfig, kNeighbourCol);
    row ? SETBIT(fgConfig, kNeighbourRow) : CLRBIT(fgConfig, kNeighbourRow);
  }
  static void SetMinimumChargeTH(Float_t th) { fgMinimumChargeTH = th; }
  static void SetTimeBased(Bool_t set = kTRUE) {
    set ? SETBIT(fgConfig, kTime) : CLRBIT(fgConfig, kTime);
  }
 
protected:
  Bool_t AddCluster(CbmTrdCluster* c);
 
private:
  CbmTrdClusterFinder(const CbmTrdClusterFinder&);
  CbmTrdClusterFinder& operator=(const CbmTrdClusterFinder&);
 
  Int_t AddClusters(TClonesArray* clusters, Bool_t moveOwner = kTRUE);
  CbmTrdModuleRec* AddModule(const CbmTrdDigi* d);
 
  static Int_t
    fgConfig;  
  static Float_t fgMinimumChargeTH;  
 
 
  TClonesArray* fClusters; 
  std::map<Int_t, std::set<Int_t>> fDigiMap;    
  std::map<Int_t, std::set<Int_t>> fModuleMap;  
 
  std::set<Int_t> fNeighbours;
  std::map<Int_t, std::set<Int_t>>
    fModDigiMap;  //std::map<Int_t ModuleID, std::vector<Int_t DigiID> >
 
  std::map<Int_t, Int_t> fDigiRow;
  std::map<Int_t, Int_t> fDigiCol;
  std::map<Int_t, Double_t> fDigiCharge;
 
  std::vector<std::set<Int_t>> fClusterBuffer;
  std::map<Int_t, std::vector<std::set<Int_t>>> fModClusterDigiMap;
 
  //==================================================================
  std::map<Int_t, CbmTrdModuleRec*>
    fModules;                  
  CbmTrdParSetAsic* fAsicPar;  
  CbmTrdParSetGas* fGasPar;    
  CbmTrdParSetDigi* fDigiPar;  
  CbmTrdParSetGain* fGainPar;  
  CbmTrdParSetGeo* fGeoPar;    
 
  ClassDef(CbmTrdClusterFinder, 1);
};
#endif