Line data Source code
1 : #ifndef ALIEMCALCLUSTERIZER_H
2 : #define ALIEMCALCLUSTERIZER_H
3 : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 : * See cxx source for full Copyright notice */
5 :
6 : //_________________________________________________________________________
7 : // Base class for the clusterization algorithm (pure abstract)
8 : //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (SUBATECH & Kurchatov Institute)
9 : //
10 : // Clusterization mother class. Contains common methods/data members of different
11 : // clusterizers. GCB 2010
12 : //_________________________________________________________________________
13 :
14 : // --- ROOT system ---
15 : #include <TObject.h>
16 : #include <TClonesArray.h>
17 : class TTree;
18 :
19 : // --- AliRoot header files ---
20 : #include "AliLog.h"
21 : class AliEMCALGeometry;
22 : class AliEMCALCalibData;
23 : class AliEMCALCalibTime;
24 : class AliCaloCalibPedestal;
25 : class AliEMCALRecParam;
26 : #include "AliEMCALUnfolding.h"
27 :
28 : class AliEMCALClusterizer : public TObject {
29 :
30 : public:
31 :
32 : AliEMCALClusterizer();
33 : AliEMCALClusterizer(AliEMCALGeometry *geometry);
34 : AliEMCALClusterizer(AliEMCALGeometry *geometry, AliEMCALCalibData *calib,
35 : AliEMCALCalibTime * calibt, AliCaloCalibPedestal *pedestal);
36 : virtual ~AliEMCALClusterizer();
37 :
38 : // main methods
39 :
40 : virtual void DeleteDigits();
41 : virtual void DeleteRecPoints();
42 :
43 : virtual void Digits2Clusters(Option_t *option) = 0;
44 :
45 : virtual void Calibrate(Float_t & amp, Float_t & time, const Int_t cellId);
46 : virtual void Init();
47 : virtual void InitParameters();
48 : virtual void InitParameters(const AliEMCALRecParam* recParam);
49 :
50 : virtual void Print (Option_t *option) const ;
51 : virtual void PrintRecPoints(Option_t *option);
52 : virtual void PrintRecoInfo();
53 :
54 0 : virtual const char *Version() const { Warning("Version", "Not Defined");
55 0 : return 0 ; }
56 :
57 : //Getters-Setters
58 :
59 : virtual void SetInput (TTree *digitsTree );
60 : virtual void SetOutput(TTree *clustersTree);
61 :
62 : virtual void GetCalibrationParameters(void);
63 : virtual void GetCaloCalibPedestal(void);
64 0 : virtual void SetCalibrationParameters(AliEMCALCalibData *calib) { fCalibData = calib; }
65 0 : virtual void SetTimeCalibrationParameters(AliEMCALCalibTime *calib) { fCalibTime = calib; }
66 0 : virtual void SetCaloCalibPedestal(AliCaloCalibPedestal *caped) { fCaloPed = caped; }
67 :
68 0 : virtual Float_t GetTimeMin() const { return fTimeMin; }
69 0 : virtual Float_t GetTimeMax() const { return fTimeMax; }
70 0 : virtual Float_t GetTimeCut() const { return fTimeCut; }
71 0 : virtual Float_t IsTimeCalibrationOn() const { return fTimeCalibration; }
72 0 : virtual Float_t GetECAClusteringThreshold() const { return fECAClusteringThreshold; }
73 0 : virtual Float_t GetECALocalMaxCut() const { return fECALocMaxCut; }
74 0 : virtual Float_t GetECALogWeight() const { return fECAW0; }
75 0 : virtual Float_t GetMinECut() const { return fMinECut; }
76 0 : virtual Bool_t GetRejectBelowThreshold() const { return fRejectBelowThreshold; }
77 :
78 0 : virtual void SetTimeMin(Float_t t) { fTimeMin = t; }
79 0 : virtual void SetTimeMax(Float_t t) { fTimeMax = t; }
80 0 : virtual void SetTimeCut(Float_t t) { fTimeCut = t; }
81 0 : virtual void SetTimeCalibration(Bool_t t) { fTimeCalibration = t; }
82 0 : virtual void SetECAClusteringThreshold(Float_t th) { fECAClusteringThreshold = th; }
83 0 : virtual void SetMinECut(Float_t mine) { fMinECut = mine; }
84 0 : virtual void SetECALocalMaxCut(Float_t cut) { fECALocMaxCut = cut; }
85 0 : virtual void SetECALogWeight(Float_t w) { fECAW0 = w; }
86 0 : virtual void SetRejectBelowThreshold(Bool_t reject) { fRejectBelowThreshold = reject; }
87 :
88 : //Unfolding
89 :
90 0 : virtual void SetUnfolding(Bool_t toUnfold = kTRUE ) { fToUnfold = toUnfold; }
91 0 : virtual void SetSSPars (Int_t ipar, Double_t par) { fSSPars[ipar] = par; }
92 0 : virtual void SetPar5 (Int_t ipar, Double_t par) { fPar5 [ipar] = par; }
93 0 : virtual void SetPar6 (Int_t ipar, Double_t par) { fPar6 [ipar] = par; }
94 : virtual void InitClusterUnfolding() {
95 0 : fClusterUnfolding=new AliEMCALUnfolding(fGeom,fECALocMaxCut,fSSPars,fPar5,fPar6);
96 0 : fClusterUnfolding->SetThreshold(fMinECut);
97 0 : fClusterUnfolding->SetRejectBelowThreshold(fRejectBelowThreshold); }
98 :
99 : //NxN (only used in NxN clusterizer)
100 :
101 16 : virtual void SetNRowDiff(Int_t ) { ; }
102 16 : virtual void SetNColDiff(Int_t ) { ; }
103 0 : virtual void SetEnergyGrad(Bool_t ) { ; }
104 :
105 0 : virtual Int_t GetNRowDiff() const { return -1 ; }
106 0 : virtual Int_t GetNColDiff() const { return -1 ; }
107 0 : virtual Bool_t GetEnergyGrad() const { return -1 ; }
108 :
109 : // add for clusterizing task
110 :
111 0 : virtual void SetDigitsArr(TClonesArray *arr) { fDigitsArr = arr ; }
112 0 : virtual TClonesArray *GetDigits() { if (!fDigitsArr)
113 0 : fDigitsArr = new TClonesArray("AliEMCALDigit",12000);
114 0 : return fDigitsArr ; }
115 0 : virtual const TObjArray *GetRecPoints() const { return fRecPoints ; }
116 : void SetInputCalibrated(Bool_t val);
117 : void SetJustClusters (Bool_t val);
118 :
119 :
120 : protected:
121 :
122 : virtual void MakeClusters() = 0;
123 :
124 : Bool_t fIsInputCalibrated; // to enable reclusterization from ESD cells
125 : Bool_t fJustClusters; // false for standard reco
126 : TClonesArray *fDigitsArr; // array with EMCAL digits
127 : TTree *fTreeR; // tree with output clusters
128 : TObjArray *fRecPoints; // array with EMCAL clusters
129 :
130 : AliEMCALGeometry *fGeom; //! pointer to geometry for utilities
131 : AliEMCALCalibData *fCalibData; //! energy calibration database if aval
132 : AliEMCALCalibTime *fCalibTime; //! time calibration database if aval
133 : AliCaloCalibPedestal *fCaloPed; //! tower status map if aval
134 :
135 : Float_t fADCchannelECA; // width of one ADC channel for EC section (GeV)
136 : Float_t fADCpedestalECA; // pedestal of ADC for EC section (GeV)
137 : Float_t fTimeECA; // calibration parameter for channels time
138 :
139 : Float_t fTimeMin; // minimum time of physical signal in a cell/digit
140 : Float_t fTimeMax; // maximum time of physical signal in a cell/digit
141 : Float_t fTimeCut; // maximum time difference between the digits inside EMC cluster
142 : Bool_t fTimeCalibration; // recover time shifts from OCDB?
143 :
144 : Bool_t fDefaultInit; //!says if the task was created by defaut ctor (only parameters are initialized)
145 : Bool_t fToUnfold; // says if unfolding should be performed
146 : Int_t fNumberOfECAClusters; // number of clusters found in EC section
147 :
148 : Float_t fECAClusteringThreshold; // minimum energy to seed a EC digit in a cluster
149 : Float_t fECALocMaxCut; // minimum energy difference to distinguish local maxima in a cluster
150 : Float_t fECAW0; // logarithmic weight for the cluster center of gravity calculation
151 : Float_t fMinECut; // minimum energy for a digit to be a member of a cluster
152 : Bool_t fRejectBelowThreshold; // split (false-default) or reject (true) cell energy below threshold after UF
153 :
154 : AliEMCALUnfolding *fClusterUnfolding; //!pointer to unfolding object
155 : Double_t fSSPars[8]; // shower shape parameters
156 : Double_t fPar5[3]; // shower shape parameter 5
157 : Double_t fPar6[3]; // shower shape parameter 6
158 :
159 : private:
160 : AliEMCALClusterizer( const AliEMCALClusterizer &);
161 : AliEMCALClusterizer & operator = (const AliEMCALClusterizer &);
162 :
163 46 : ClassDef(AliEMCALClusterizer,10) // Clusterization algorithm class
164 :
165 : };
166 : #endif // AliEMCALCLUSTERIZER_H
|
