Line data Source code
1 : #ifndef ALIEMCALRECPARAM_H
2 : #define ALIEMCALRECPARAM_H
3 : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 : * See cxx source for full Copyright notice */
5 :
6 : //-----------------------------------------------------------------------------
7 : ///
8 : /// \class AliEMCALRecParam
9 : /// \brief Container of reconstruction parameters
10 : ///
11 : /// Container of EMCAL reconstruction parameters
12 : /// The purpose of this object is to store it to OCDB
13 : /// and retrieve it in AliEMCALClusterizer, AliEMCALPID,
14 : /// AliEMCALTracker and use it to configure AliEMCALRawUtils
15 : ///
16 : /// \author: Yuri Kharlov, IHEP, first implementation
17 : /// \author: Gustavo Conesa Balbastre <Gustavo.Conesa.Balbastre@cern.ch>, LPSC-IN2P3-CNRS
18 : /// \author: Adam Matyja, clusterization with unfolding
19 : /// \author: Marie Germain, SUBATECH, PID
20 : /// \author: Jenn Klay, CalPoly, Raw fitting
21 : /// \author: Alberto Pulvirenti, INFN Catania, Track matching
22 : /// \author: Rong Rong Ma, Yale, Track matching
23 : ///
24 : //-----------------------------------------------------------------------------
25 :
26 : // --- ROOT system ---
27 :
28 : #include "AliDetectorRecoParam.h"
29 : #include "AliLog.h"
30 :
31 : class AliEMCALRecParam : public AliDetectorRecoParam
32 : {
33 : public:
34 :
35 : enum AliEMCALClusterizerFlag
36 : {
37 : kClusterizerv1 = 0,
38 : kClusterizerNxN = 1,
39 : kClusterizerv2 = 2,
40 : kClusterizerFW = 3
41 : };
42 :
43 : AliEMCALRecParam() ;
44 : AliEMCALRecParam(const AliEMCALRecParam& recParam);
45 : AliEMCALRecParam& operator = (const AliEMCALRecParam& recParam);
46 60 : virtual ~AliEMCALRecParam() {}
47 :
48 : //Clustering (Unfolding : Cynthia)
49 16 : Float_t GetClusteringThreshold() const {return fClusteringThreshold ;}
50 16 : Float_t GetW0 () const {return fW0 ;}
51 16 : Float_t GetMinECut () const {return fMinECut ;}
52 16 : Float_t GetLocMaxCut () const {return fLocMaxCut ;}
53 16 : Float_t GetTimeCut () const {return fTimeCut ;}
54 16 : Float_t GetTimeMin () const {return fTimeMin ;}
55 16 : Float_t GetTimeMax () const {return fTimeMax ;}
56 16 : Bool_t IsTimeCalibrationOn () const {return fTimeCalibration ;}
57 210 : Bool_t GetUnfold () const {return fUnfold ;}
58 16 : Int_t GetNRowDiff () const {return fNRowDiff ;}
59 16 : Int_t GetNColDiff () const {return fNColDiff ;}
60 :
61 0 : void SetClusteringThreshold(Float_t thrsh) {fClusteringThreshold = thrsh;}
62 0 : void SetW0 (Float_t w0) {fW0 = w0 ;}
63 0 : void SetMinECut (Float_t ecut) {fMinECut = ecut ;}
64 0 : void SetLocMaxCut (Float_t locMaxCut) {fLocMaxCut = locMaxCut ;}
65 0 : void SetTimeCut (Float_t t) {fTimeCut = t ;}
66 0 : void SetTimeMin (Float_t t) {fTimeMin = t ;}
67 0 : void SetTimeMax (Float_t t) {fTimeMax = t ;}
68 0 : void SetTimeCalibration (Bool_t yn) {fTimeCalibration = yn ;}
69 0 : void SetUnfold (Bool_t unfold) {fUnfold = unfold ;}
70 0 : void SetNxM(Int_t rdiff, Int_t cdiff) {fNRowDiff=rdiff; fNColDiff = cdiff; }
71 :
72 : // PID (Guenole)
73 : void InitPIDParametersForHighFlux();
74 :
75 576 : Double_t GetGamma(Int_t i, Int_t j) const {return fGamma[i][j];}
76 96 : Double_t GetGammaEnergyProb(Int_t i) const {return fGammaEnergyProb[i];}
77 576 : Double_t GetGamma1to10(Int_t i, Int_t j) const {return fGamma1to10[i][j];} // not used
78 576 : Double_t GetHadron(Int_t i, Int_t j) const {return fHadron[i][j];}
79 576 : Double_t GetHadron1to10(Int_t i, Int_t j) const {return fHadron1to10[i][j];} // not used
80 96 : Double_t GetHadronEnergyProb(Int_t i) const {return fHadronEnergyProb[i];}
81 576 : Double_t GetPiZero(Int_t i, Int_t j) const {return fPiZero[i][j];}
82 96 : Double_t GetPiZeroEnergyProb(Int_t i) const {return fPiZeroEnergyProb[i];}
83 :
84 0 : void SetGamma(Int_t i, Int_t j,Double_t param ) {fGamma[i][j]=param;}
85 0 : void SetGammaEnergyProb(Int_t i, Double_t param ) {fGammaEnergyProb[i]=param;}
86 0 : void SetGamma1to10(Int_t i, Int_t j,Double_t param ) {fGamma1to10[i][j]=param;}
87 0 : void SetHadron(Int_t i, Int_t j,Double_t param ) {fHadron[i][j]=param;}
88 0 : void SetHadron1to10(Int_t i, Int_t j,Double_t param ) {fHadron1to10[i][j]=param;}
89 0 : void SetHadronEnergyProb(Int_t i,Double_t param ) {fHadronEnergyProb[i]=param;}
90 0 : void SetPiZero(Int_t i, Int_t j,Double_t param) {fPiZero[i][j]=param;}
91 0 : void SetPiZeroEnergyProb(Int_t i,Double_t param) {fPiZeroEnergyProb[i]=param;}
92 :
93 : //Track Matching (Alberto; Revised by Rongrong)
94 : /* track matching cut setters */
95 0 : void SetMthCutEta(Double_t value) {fMthCutEta = value;}
96 0 : void SetMthCutPhi(Double_t value) {fMthCutPhi = value;}
97 0 : void SetExtrapolateStep(Double_t value) {fStep = value;}
98 0 : void SetTrkCutPt(Double_t value) {fTrkCutPt = value;}
99 0 : void SetTrkCutNITS(Double_t value) {fTrkCutNITS = value;}
100 0 : void SetTrkCutNTPC(Double_t value) {fTrkCutNTPC = value;}
101 0 : void SetTrkInITS(Bool_t value) {fTrkInITS = value;}
102 :
103 : /* track matching cut getters */
104 4 : Double_t GetMthCutEta() const {return fMthCutEta;}
105 4 : Double_t GetMthCutPhi() const {return fMthCutPhi;}
106 40 : Double_t GetExtrapolateStep() const {return fStep;}
107 4 : Double_t GetTrkCutPt() const {return fTrkCutPt;}
108 4 : Double_t GetTrkCutNITS() const {return fTrkCutNITS;}
109 4 : Double_t GetTrkCutNTPC() const {return fTrkCutNTPC;}
110 4 : Bool_t GetTrkInITS() const {return fTrkInITS;}
111 :
112 : //Raw signal fitting (Jenn)
113 : /* raw signal setters */
114 0 : void SetHighLowGainFactor(Double_t value) {fHighLowGainFactor = value;}
115 0 : void SetOrderParameter(Int_t value) {fOrderParameter = value;}
116 0 : void SetTau(Double_t value) {fTau = value;}
117 0 : void SetNoiseThreshold(Int_t value) {fNoiseThreshold = value;}
118 0 : void SetNPedSamples(Int_t value) {fNPedSamples = value;}
119 0 : void SetRemoveBadChannels(Bool_t val) {fRemoveBadChannels=val; }
120 0 : void SetFittingAlgorithm(Int_t val) {fFittingAlgorithm=val; }
121 0 : void SetFALTROUsage(Bool_t val) {fUseFALTRO=val; }
122 0 : void SetLEDFit(Bool_t val) {fFitLEDEvents=val; }
123 0 : void SetL1PhaseUse(Bool_t val) {fUseL1Phase=val; }
124 :
125 :
126 : /* raw signal getters */
127 0 : Double_t GetHighLowGainFactor() const {return fHighLowGainFactor;}
128 0 : Int_t GetOrderParameter() const {return fOrderParameter;}
129 0 : Double_t GetTau() const {return fTau;}
130 8 : Int_t GetNoiseThreshold() const {return fNoiseThreshold;}
131 8 : Int_t GetNPedSamples() const {return fNPedSamples;}
132 8 : Bool_t GetRemoveBadChannels() const {return fRemoveBadChannels;}
133 8 : Int_t GetFittingAlgorithm() const {return fFittingAlgorithm; }
134 8 : Bool_t UseFALTRO() const {return fUseFALTRO; }
135 8 : Bool_t FitLEDEvents() const {return fFitLEDEvents; }
136 8 : Bool_t UseL1Phase() const {return fUseL1Phase;}
137 :
138 : //Unfolding (Adam)
139 : void InitUnfoldingParameters();
140 0 : Double_t GetSSPars(Int_t i) const { return fSSPars[i] ; }
141 0 : Double_t GetPar5 (Int_t i) const { return fPar5 [i] ; }
142 0 : Double_t GetPar6 (Int_t i) const { return fPar6 [i] ; }
143 0 : void SetSSPars(Int_t i, Double_t param ) { fSSPars[i] = param ; }
144 0 : void SetPar5 (Int_t i, Double_t param ) { fPar5 [i] = param ; }
145 0 : void SetPar6 (Int_t i, Double_t param ) { fPar6 [i] = param ; }
146 :
147 16 : Bool_t GetRejectBelowThreshold() const { return fRejectBelowThreshold; }
148 0 : void SetRejectBelowThreshold(Bool_t reject) { fRejectBelowThreshold = reject; }
149 :
150 : virtual void Print(Option_t * option="") const;
151 :
152 : static AliEMCALRecParam* GetDefaultParameters();
153 : static AliEMCALRecParam* GetLowFluxParam();
154 : static AliEMCALRecParam* GetHighFluxParam();
155 : static AliEMCALRecParam* GetCalibParam();
156 : static AliEMCALRecParam* GetCosmicParam();
157 :
158 : static const TObjArray* GetMappings();
159 :
160 0 : void SetClusterizerFlag(Short_t val) { fClusterizerFlag = val; }
161 16 : Short_t GetClusterizerFlag() const { return fClusterizerFlag; }
162 :
163 : private:
164 : // Clustering
165 : Float_t fClusteringThreshold ; ///< Minimum energy to seed a EC digit in a cluster
166 : Float_t fW0 ; ///< Logarithmic weight for the cluster center of gravity calculation
167 : Float_t fMinECut; ///< Minimum energy for a digit to be a member of a cluster
168 : Bool_t fUnfold; ///< Flag to perform cluster unfolding
169 : Float_t fLocMaxCut; ///< Minimum energy difference to consider local maxima in a cluster
170 : Float_t fTimeCut ; ///< Maximum time of digits with respect to EMC cluster max.
171 : Float_t fTimeMin ; ///< Minimum time of digits
172 : Float_t fTimeMax ; ///< Maximum time of digits
173 : Bool_t fTimeCalibration; ///< Activate time calibration
174 : Short_t fClusterizerFlag ; ///< Choice of the clusterizer; Default selection (v1) is zero
175 : Int_t fNRowDiff; ///< NxN: How many neighbors to consider along row (phi)
176 : Int_t fNColDiff; ///< NxN: How many neighbors to consider along col (eta)
177 :
178 : // PID (Guenole)
179 : Double_t fGamma[6][6]; ///< Parameter to Compute PID for photons
180 : Double_t fGamma1to10[6][6]; ///< Parameter to Compute PID not used
181 : Double_t fHadron[6][6]; ///< Parameter to Compute PID for hadrons
182 : Double_t fHadron1to10[6][6]; ///< Parameter to Compute PID for hadrons between 1 and 10 GeV
183 : Double_t fHadronEnergyProb[6]; ///< Parameter to Compute PID for energy ponderation for hadrons
184 : Double_t fPiZeroEnergyProb[6]; ///< Parameter to Compute PID for energy ponderation for Pi0
185 : Double_t fGammaEnergyProb[6]; ///< Parameter to Compute PID for energy ponderation for gamma
186 : Double_t fPiZero[6][6]; ///< Parameter to Compute PID for pi0
187 :
188 : // Track-Matching (Alberto; Revised by Rongrong)
189 : Double_t fMthCutEta; ///< eta-difference cut for track matching
190 : Double_t fMthCutPhi; ///< phi-difference cut for track matching
191 : Double_t fStep; ///< Extrapolate length of each step
192 : Double_t fTrkCutPt; ///< Minimum pT cut on tracks. Needed for Pb-Pb runs
193 : Double_t fTrkCutNITS; ///< Number of ITS hits for track matching
194 : Double_t fTrkCutNTPC; ///< Number of TPC hits for track matching
195 :
196 : // Raw signal fitting parameters (Jenn)
197 : Double_t fHighLowGainFactor; ///< Gain factor to convert between high and low gain
198 : Int_t fOrderParameter; ///< Order parameter for raw signal fit
199 : Double_t fTau; ///< Decay constant for raw signal fit
200 : Int_t fNoiseThreshold; ///< Threshold to consider signal or noise
201 : Int_t fNPedSamples; ///< Number of time samples to use in pedestal calculation
202 : Bool_t fRemoveBadChannels; ///< Select if bad channels are removed before fitting
203 : Int_t fFittingAlgorithm; ///< Select the fitting algorithm
204 : Bool_t fUseFALTRO; ///< Get FALTRO (trigger) and put it on trigger digits.
205 : Bool_t fFitLEDEvents; ///< Fit LED events or not
206 : Bool_t fUseL1Phase; ///< Shift time bin depending on L1 phase
207 :
208 : // Shower shape parameters (Adam)
209 : Bool_t fRejectBelowThreshold; ///< split (false-default) or reject (true) cell energy below threshold after UF
210 : Double_t fSSPars[8]; ///< Unfolding shower shape parameters
211 : Double_t fPar5[3]; ///< UF SSPar nr 5
212 : Double_t fPar6[3]; ///< UF SSPar nr 6
213 :
214 : static TObjArray* fgkMaps; ///< ALTRO mappings for RCU0..RCUX
215 :
216 : Bool_t fTrkInITS; ///< Select tracks with AliVTrack::kITSout
217 :
218 : /// \cond CLASSIMP
219 66 : ClassDef(AliEMCALRecParam,20) ;
220 : /// \endcond
221 :
222 : };
223 :
224 : #endif // ALIEMCALRECPARAM_H
225 :
|
