]>
Commit | Line | Data |
---|---|---|
1c5acb87 | 1 | #ifndef ALICALOPID_H |
2 | #define ALICALOPID_H | |
3 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
4 | * See cxx source for full Copyright notice */ | |
1c5acb87 | 5 | |
6 | //_________________________________________________________________________ | |
bdd2a262 | 7 | // Class for PID selection with calorimeters |
49b5c49b | 8 | // The Output of the main method GetIdentifiedParticleType is a PDG number identifying the cluster, |
bdd2a262 | 9 | // being kPhoton, kElectron, kPi0 ... as defined in the header file |
3c1d9afb | 10 | // - GetIdentifiedParticleType(const AliVCluster * cluster) |
49b5c49b | 11 | // Assignes a PID tag to the cluster, right now there is the possibility to : use bayesian weights from reco, |
12 | // recalculate them (EMCAL) or use other procedures not used in reco. | |
bdd2a262 | 13 | // In order to recalculate Bayesian, it is necessary to load the EMCALUtils library |
14 | // and do SwitchOnBayesianRecalculation(). | |
15 | // To change the PID parameters from Low to High like the ones by default, use the constructor | |
16 | // AliCaloPID(flux) | |
17 | // where flux is AliCaloPID::kLow or AliCaloPID::kHigh | |
18 | // If it is necessary to change the parameters use the constructor | |
19 | // AliCaloPID(AliEMCALPIDUtils *utils) and set the parameters before. | |
49b5c49b | 20 | |
3c1d9afb | 21 | // - GetGetIdentifiedParticleTypeFromBayesian(const Double_t * pid, const Float_t energy) |
49b5c49b | 22 | // Reads the PID weights array of the ESDs and depending on its magnitude identifies the particle, |
3c1d9afb | 23 | // executed when bayesian is ON by GetIdentifiedParticleType(const AliVCluster * cluster) |
9a6fa057 | 24 | // - SetPIDBits: Simple PID, depending on the thresholds fLOCut fTOFCut and even the |
bdd2a262 | 25 | // result of the PID bayesian a different PID bit is set. |
26 | // | |
1c5acb87 | 27 | // |
28 | //*-- Author: Gustavo Conesa (INFN-LNF) | |
29 | ||
30 | // --- ROOT system --- | |
31 | #include <TObject.h> | |
32 | class TString ; | |
33 | class TLorentzVector ; | |
a5fb4114 | 34 | #include <TFormula.h> |
f21fc003 | 35 | class TList; |
d39cba7e | 36 | class TH2F ; |
1c5acb87 | 37 | |
38 | //--- AliRoot system --- | |
0ae57829 | 39 | class AliVCluster; |
3c1d9afb | 40 | class AliVCaloCells; |
1c5acb87 | 41 | class AliAODPWG4Particle; |
c5693f62 | 42 | class AliEMCALPIDUtils; |
f2ccb5b8 | 43 | class AliCalorimeterUtils; |
49b5c49b | 44 | class AliVEvent; |
1c5acb87 | 45 | |
46 | class AliCaloPID : public TObject { | |
47 | ||
477d6cee | 48 | public: |
49 | ||
50 | AliCaloPID() ; // ctor | |
8a2dbbff | 51 | AliCaloPID(Int_t particleFlux) ; // ctor, to be used when recalculating bayesian PID |
f21fc003 | 52 | AliCaloPID(const TNamed * emcalpid) ; // ctor, to be used when recalculating bayesian PID and need different parameters |
477d6cee | 53 | virtual ~AliCaloPID() ;//virtual dtor |
c5693f62 | 54 | |
3c1d9afb | 55 | enum PidType |
56 | { | |
a5fb4114 | 57 | kPhoton = 22, |
58 | kPi0 = 111, | |
59 | kEta = 221, | |
60 | kElectron = 11, | |
61 | kEleCon =-11, | |
62 | kNeutralHadron = 2112, | |
63 | kChargedHadron = 211, | |
477d6cee | 64 | kNeutralUnknown = 130, |
a5fb4114 | 65 | kChargedUnknown = 321 |
477d6cee | 66 | }; |
67 | ||
68 | enum TagType {kPi0Decay, kEtaDecay, kOtherDecay, kConversion, kNoTag = -1}; | |
69 | ||
49b5c49b | 70 | // Main methods |
71 | ||
a5fb4114 | 72 | TList * GetCreateOutputObjects(); |
d39cba7e | 73 | |
a5fb4114 | 74 | void InitParameters(); |
9a6fa057 | 75 | |
8a2dbbff | 76 | Bool_t IsInPi0SplitAsymmetryRange(Float_t energy, Float_t asy, Int_t nlm) const; |
995c6150 | 77 | |
8a2dbbff | 78 | Bool_t IsInPi0SplitMassRange (Float_t energy, Float_t mass, Int_t nlm) const; |
995c6150 | 79 | |
8a2dbbff | 80 | Bool_t IsInM02Range (Float_t m02) const; |
81 | Bool_t IsInPi0M02Range (Float_t energy, Float_t m02, Int_t nlm) const; | |
82 | Bool_t IsInEtaM02Range (Float_t energy, Float_t m02, Int_t nlm) const; | |
83 | Bool_t IsInConM02Range (Float_t energy, Float_t m02, Int_t nlm) const; | |
5a72d9af | 84 | |
5a72d9af | 85 | |
8a2dbbff | 86 | Int_t GetIdentifiedParticleTypeFromBayesWeights(Bool_t isEMCAL, Double_t * pid, Float_t energy) ; |
3c1d9afb | 87 | |
88 | Int_t GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster * cluster, AliVCaloCells* cells, | |
89 | AliCalorimeterUtils * caloutils, | |
90 | Double_t vertex[3], | |
bfdcf7fb | 91 | Int_t & nLocMax, Double_t & mass, Double_t & angle, |
cfdf2b91 | 92 | TLorentzVector & l1 , TLorentzVector & l2, |
4914e781 | 93 | Int_t & absId1, Int_t & absId2, |
94 | Float_t & distbad1, Float_t & distbad2, | |
8a2dbbff | 95 | Bool_t & fidcut1, Bool_t & fidcut2 ) const; |
477d6cee | 96 | |
8a2dbbff | 97 | Int_t GetIdentifiedParticleType(AliVCluster * cluster) ; |
477d6cee | 98 | |
9a6fa057 | 99 | TString GetPIDParametersList(); |
477d6cee | 100 | |
49b5c49b | 101 | Bool_t IsTrackMatched(AliVCluster * cluster, AliCalorimeterUtils* cu, AliVEvent* event) const ; |
102 | ||
3c1d9afb | 103 | void SetPIDBits(AliVCluster * cluster, AliAODPWG4Particle *aodph, |
49b5c49b | 104 | AliCalorimeterUtils* cu, AliVEvent* event); |
477d6cee | 105 | |
a5fb4114 | 106 | void Print(const Option_t * opt)const; |
107 | ||
3c1d9afb | 108 | void PrintClusterPIDWeights(const Double_t * pid) const; |
109 | ||
49b5c49b | 110 | //Check if cluster photon-like. Uses photon cluster parameterization in real pp data |
111 | //Returns distance in sigmas. Recommended cut 2.5 | |
8a2dbbff | 112 | Float_t TestPHOSDispersion(Double_t pt, Double_t m20, Double_t m02) const ; |
49b5c49b | 113 | //Checks distance to the closest track. Takes into account |
114 | //non-perpendicular incidence of tracks. | |
8a2dbbff | 115 | Float_t TestPHOSChargedVeto(Double_t dx, Double_t dz, Double_t ptTrack, |
116 | Int_t chargeTrack, Double_t mf) const ; | |
49b5c49b | 117 | |
118 | // Setters, getters | |
119 | ||
120 | void SetDebug(Int_t deb) { fDebug = deb ; } | |
121 | Int_t GetDebug() const { return fDebug ; } | |
122 | ||
123 | enum eventType{kLow,kHigh}; | |
124 | void SetLowParticleFlux() { fParticleFlux = kLow ; } | |
125 | void SetHighParticleFlux() { fParticleFlux = kHigh ; } | |
126 | // not really used, only for bayesian recalculation in EMCAL, but could be useful in future | |
127 | ||
128 | // Bayesian | |
129 | ||
130 | void SwitchOnBayesian() { fUseBayesianWeights = kTRUE ; } | |
131 | void SwitchOffBayesian() { fUseBayesianWeights = kFALSE; } | |
132 | void SwitchOnBayesianRecalculation() { fRecalculateBayesian = kTRUE ; fUseBayesianWeights = kTRUE ;} // EMCAL | |
133 | void SwitchOffBayesianRecalculation() { fRecalculateBayesian = kFALSE; } // EMCAL | |
134 | ||
c5693f62 | 135 | AliEMCALPIDUtils * GetEMCALPIDUtils() ; |
477d6cee | 136 | |
137 | //Weight getters | |
49b5c49b | 138 | Float_t GetEMCALPhotonWeight() const { return fEMCALPhotonWeight ; } |
139 | Float_t GetEMCALPi0Weight() const { return fEMCALPi0Weight ; } | |
140 | Float_t GetEMCALElectronWeight() const { return fEMCALElectronWeight ; } | |
141 | Float_t GetEMCALChargeWeight() const { return fEMCALChargeWeight ; } | |
142 | Float_t GetEMCALNeutralWeight() const { return fEMCALNeutralWeight ; } | |
143 | Float_t GetPHOSPhotonWeight() const { return fPHOSPhotonWeight ; } | |
144 | Float_t GetPHOSPi0Weight() const { return fPHOSPi0Weight ; } | |
145 | Float_t GetPHOSElectronWeight() const { return fPHOSElectronWeight ; } | |
146 | Float_t GetPHOSChargeWeight() const { return fPHOSChargeWeight ; } | |
147 | Float_t GetPHOSNeutralWeight() const { return fPHOSNeutralWeight ; } | |
148 | ||
149 | Bool_t IsPHOSPIDWeightFormulaOn() const { return fPHOSWeightFormula ; } | |
150 | ||
151 | TFormula * GetPHOSPhotonWeightFormula() { | |
a5fb4114 | 152 | if(!fPHOSPhotonWeightFormula) |
153 | fPHOSPhotonWeightFormula = new TFormula("phos_photon_weight", | |
154 | fPHOSPhotonWeightFormulaExpression); | |
49b5c49b | 155 | return fPHOSPhotonWeightFormula ; } |
477d6cee | 156 | |
49b5c49b | 157 | TFormula * GetPHOSPi0WeightFormula() { |
a5fb4114 | 158 | if(!fPHOSPi0WeightFormula) |
159 | fPHOSPi0WeightFormula = new TFormula("phos_pi0_weight", | |
160 | fPHOSPi0WeightFormulaExpression); | |
49b5c49b | 161 | return fPHOSPi0WeightFormula ; } |
5ae09196 | 162 | |
49b5c49b | 163 | TString GetPHOSPhotonWeightFormulaExpression() const { return fPHOSPhotonWeightFormulaExpression ; } |
164 | TString GetPHOSPi0WeightFormulaExpression() const { return fPHOSPi0WeightFormulaExpression ; } | |
5ae09196 | 165 | |
a5fb4114 | 166 | //Weight setters |
49b5c49b | 167 | void SetEMCALPhotonWeight (Float_t w) { fEMCALPhotonWeight = w ; } |
168 | void SetEMCALPi0Weight (Float_t w) { fEMCALPi0Weight = w ; } | |
169 | void SetEMCALElectronWeight(Float_t w) { fEMCALElectronWeight = w ; } | |
170 | void SetEMCALChargeWeight (Float_t w) { fEMCALChargeWeight = w ; } | |
171 | void SetEMCALNeutralWeight (Float_t w) { fEMCALNeutralWeight = w ; } | |
172 | void SetPHOSPhotonWeight (Float_t w) { fPHOSPhotonWeight = w ; } | |
173 | void SetPHOSPi0Weight (Float_t w) { fPHOSPi0Weight = w ; } | |
174 | void SetPHOSElectronWeight (Float_t w) { fPHOSElectronWeight = w ; } | |
175 | void SetPHOSChargeWeight (Float_t w) { fPHOSChargeWeight = w ; } | |
176 | void SetPHOSNeutralWeight (Float_t w) { fPHOSNeutralWeight = w ; } | |
177 | ||
178 | void UsePHOSPIDWeightFormula (Bool_t ok ) { fPHOSWeightFormula = ok ; } | |
179 | void SetPHOSPhotonWeightFormulaExpression(TString ph) { fPHOSPhotonWeightFormulaExpression = ph ; } | |
180 | void SetPHOSPi0WeightFormulaExpression (TString pi) { fPHOSPi0WeightFormulaExpression = pi ; } | |
d39cba7e | 181 | |
49b5c49b | 182 | //PID cuts |
d39cba7e | 183 | |
49b5c49b | 184 | void SetEMCALLambda0CutMax(Float_t lcut ) { fEMCALL0CutMax = lcut ; } |
185 | Float_t GetEMCALLambda0CutMax() const { return fEMCALL0CutMax ; } | |
186 | ||
187 | void SetEMCALLambda0CutMin(Float_t lcut ) { fEMCALL0CutMin = lcut ; } | |
188 | Float_t GetEMCALLambda0CutMin() const { return fEMCALL0CutMin ; } | |
189 | ||
190 | void SetEMCALDEtaCut(Float_t dcut ) { fEMCALDEtaCut = dcut ; } | |
191 | Float_t GetEMCALDEtaCut() const { return fEMCALDEtaCut ; } | |
192 | ||
193 | void SetEMCALDPhiCut(Float_t dcut ) { fEMCALDPhiCut = dcut ; } | |
194 | Float_t GetEMCALDPhiCut() const { return fEMCALDPhiCut ; } | |
195 | ||
196 | void SetTOFCut(Float_t tcut ) { fTOFCut = tcut ; } | |
197 | Float_t GetTOFCut() const { return fTOFCut ; } | |
198 | ||
199 | void SetPHOSRCut(Float_t rcut ) { fPHOSRCut = rcut ; } | |
200 | Float_t GetPHOSRCut() const { return fPHOSRCut ; } | |
a5fb4114 | 201 | |
49b5c49b | 202 | void SetPHOSDispersionCut(Float_t dcut ) { fPHOSDispersionCut = dcut ; } |
203 | Float_t GetPHOSDispersionCut() const { return fPHOSDispersionCut ; } | |
204 | ||
3c1d9afb | 205 | // Cluster splitting analysis |
206 | ||
207 | void SwitchOnClusterSplittingPID() { fDoClusterSplitting = kTRUE ; } | |
208 | void SwitchOffClusterplittingPID() { fDoClusterSplitting = kFALSE ; } | |
5a72d9af | 209 | |
210 | void SwitchOnSimpleSplitMassCut() { fUseSimpleMassCut = kTRUE ; } | |
211 | void SwitchOffSimpleSplitMassCut() { fUseSimpleMassCut = kFALSE ; } | |
3c1d9afb | 212 | |
5a72d9af | 213 | void SwitchOnSimpleSplitM02Cut() { fUseSimpleM02Cut = kTRUE ; } |
214 | void SwitchOffSimpleSplitM02Cut() { fUseSimpleM02Cut = kFALSE ; } | |
215 | ||
667432ef | 216 | void SwitchOnSplitAsymmetryCut() { fUseSplitAsyCut = kTRUE ; } |
217 | void SwitchOffSplitAsymmetryCut() { fUseSplitAsyCut = kFALSE ; } | |
40cc0ed9 | 218 | Bool_t IsSplitAsymmetryCutOn() { return fUseSplitAsyCut ; } |
219 | ||
035e250e | 220 | void SwitchOnSplitShowerShapeCut() { fUseSplitSSCut = kTRUE ; } |
221 | void SwitchOffSplitShowerShapeCut() { fUseSplitSSCut = kFALSE ; } | |
40cc0ed9 | 222 | Bool_t IsSplitShowerShapeCutOn() { return fUseSplitSSCut ; } |
035e250e | 223 | |
3c1d9afb | 224 | void SetClusterSplittingM02Cut(Float_t min=0, Float_t max=100) |
225 | { fSplitM02MinCut = min ; fSplitM02MaxCut = max ; } | |
226 | ||
eb4ccbd1 | 227 | void SetClusterSplittingMinNCells(Int_t c) { fSplitMinNCells = c ; } |
228 | Int_t GetClusterSplittingMinNCells() const { return fSplitMinNCells ; } | |
667432ef | 229 | |
2c36e041 | 230 | void SetSplitEnergyFractionMinimum(Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSplitEFracMin[i] = min ; } |
231 | Float_t GetSplitEnergyFractionMinimum(Int_t i) const { if( i < 3 && i >=0 ) return fSplitEFracMin[i] ; else return 0 ; } | |
232 | ||
233 | void SetSubClusterEnergyMinimum (Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSubClusterEMin[i] = min ; } | |
234 | Float_t GetSubClusterEnergyMinimum (Int_t i) const { if( i < 3 && i >=0 ) return fSubClusterEMin[i]; else return 0 ; } | |
3c1d9afb | 235 | |
5a72d9af | 236 | Float_t GetPi0MinMass() const { return fMassPi0Min ; } // Simple cut case |
237 | Float_t GetEtaMinMass() const { return fMassEtaMin ; } // Simple cut case | |
3c1d9afb | 238 | Float_t GetPhotonMinMass() const { return fMassPhoMin ; } |
239 | Float_t GetPi0MaxMass() const { return fMassPi0Max ; } | |
240 | Float_t GetEtaMaxMass() const { return fMassEtaMax ; } | |
241 | Float_t GetPhotonMaxMass() const { return fMassPhoMax ; } | |
242 | ||
5a72d9af | 243 | void SetSplitWidthSigma(Float_t s) { fSplitWidthSigma = s ; } |
ac207ee4 | 244 | |
245 | void SetPi0MassShiftHighECell(Float_t s) { s = fMassShiftHighECell ; } | |
1be44524 | 246 | |
247 | void SetPi0MassSelectionParameters (Int_t inlm, Int_t iparam, Float_t param) | |
248 | { if(iparam < 6 ) fMassPi0Param[inlm][iparam] = param ; } | |
249 | ||
250 | void SetPi0WidthSelectionParameters (Int_t inlm, Int_t iparam, Float_t param) | |
251 | { if(iparam < 6 ) fWidthPi0Param[inlm][iparam] = param ; } | |
252 | ||
5b4c2f5b | 253 | void SetM02MaximumSelectionParameters (Int_t inlm, Int_t iparam, Float_t param) |
1be44524 | 254 | { if(iparam < 5 && inlm < 2) fM02MaxParam[inlm][iparam] = param ; } |
255 | ||
256 | void SetM02MaximumShiftForNLMN(Int_t shift) { fM02MaxParamShiftNLMN = shift ; } | |
257 | ||
a5a3f703 | 258 | void SetM02MinimumSelectionParameters (Int_t inlm, Int_t iparam, Float_t param) |
1be44524 | 259 | { if(iparam < 5 && inlm < 2) fM02MinParam[inlm][iparam] = param ; } |
260 | ||
afc83530 | 261 | void SetAsymmetryMinimumSelectionParameters(Int_t inlm, Int_t iparam, Float_t param) |
ac207ee4 | 262 | { if(iparam < 4 && inlm < 2) fAsyMinParam[inlm][iparam] = param ; } |
5a72d9af | 263 | |
264 | void SetPi0MassRange(Float_t min, Float_t max) { fMassPi0Min = min ; fMassPi0Max = max ; } // Simple case | |
265 | void SetEtaMassRange(Float_t min, Float_t max) { fMassEtaMin = min ; fMassEtaMax = max ; } | |
266 | void SetPhotonMassRange(Float_t min, Float_t max) { fMassPhoMin = min ; fMassPhoMax = max ; } | |
667432ef | 267 | |
f2ccb5b8 | 268 | private: |
477d6cee | 269 | |
49b5c49b | 270 | Int_t fDebug; // Debug level |
271 | Int_t fParticleFlux; // Particle flux for setting PID parameters | |
272 | ||
273 | // Bayesian | |
274 | AliEMCALPIDUtils * fEMCALPIDUtils; // Pointer to EMCALPID to redo the PID Bayesian calculation | |
275 | Bool_t fUseBayesianWeights; // Select clusters based on weights calculated in reconstruction | |
276 | Bool_t fRecalculateBayesian; // Recalculate PID bayesian or use simple PID? | |
277 | ||
278 | Float_t fEMCALPhotonWeight; // Bayesian PID weight for photons in EMCAL | |
279 | Float_t fEMCALPi0Weight; // Bayesian PID weight for pi0 in EMCAL | |
280 | Float_t fEMCALElectronWeight; // Bayesian PID weight for electrons in EMCAL | |
281 | Float_t fEMCALChargeWeight; // Bayesian PID weight for charged hadrons in EMCAL | |
282 | Float_t fEMCALNeutralWeight; // Bayesian PID weight for neutral hadrons in EMCAL | |
283 | Float_t fPHOSPhotonWeight; // Bayesian PID weight for photons in PHOS | |
284 | Float_t fPHOSPi0Weight; // Bayesian PID weight for pi0 in PHOS | |
285 | Float_t fPHOSElectronWeight; // Bayesian PID weight for electrons in PHOS | |
286 | Float_t fPHOSChargeWeight; // Bayesian PID weight for charged hadrons in PHOS | |
287 | Float_t fPHOSNeutralWeight; // Bayesian PID weight for neutral hadrons in PHOS | |
a5fb4114 | 288 | |
9a6fa057 | 289 | Bool_t fPHOSWeightFormula ; // Use parametrized weight threshold, function of energy |
290 | TFormula *fPHOSPhotonWeightFormula ; // Formula for photon weight | |
291 | TFormula *fPHOSPi0WeightFormula ; // Formula for pi0 weight | |
a5fb4114 | 292 | TString fPHOSPhotonWeightFormulaExpression; // Photon weight formula in string |
293 | TString fPHOSPi0WeightFormulaExpression; // Pi0 weight formula in string | |
294 | ||
49b5c49b | 295 | // PID calculation |
296 | Float_t fEMCALL0CutMax; // Max Cut on shower shape lambda0, used in PID evaluation, only EMCAL | |
297 | Float_t fEMCALL0CutMin; // Min Cut on shower shape lambda0, used in PID evaluation, only EMCAL | |
298 | Float_t fEMCALDEtaCut; // Track matching cut on Dz | |
299 | Float_t fEMCALDPhiCut; // Track matching cut on Dx | |
ae182e60 | 300 | |
49b5c49b | 301 | Float_t fTOFCut; // Cut on TOF, used in PID evaluation |
302 | ||
303 | Float_t fPHOSDispersionCut; // Shower shape elipse radious cut | |
304 | Float_t fPHOSRCut; // Track-Cluster distance cut for track matching in PHOS | |
49b5c49b | 305 | |
3c1d9afb | 306 | // Cluster splitting mass ranges |
307 | Bool_t fDoClusterSplitting; // Cluster splitting analysis | |
5a72d9af | 308 | Bool_t fUseSimpleMassCut; // Use simple min-max pi0 mass cut |
309 | Bool_t fUseSimpleM02Cut; // Use simple min-max M02 cut | |
035e250e | 310 | Bool_t fUseSplitAsyCut ; // Remove splitted clusters with too large asymmetry |
311 | Bool_t fUseSplitSSCut ; // Remove splitted clusters out of shower shape band | |
667432ef | 312 | Float_t fSplitM02MaxCut ; // Study clusters with l0 smaller than cut |
5a72d9af | 313 | Float_t fSplitM02MinCut ; // Study clusters with l0 larger than cut // simple case |
3c1d9afb | 314 | Int_t fSplitMinNCells ; // Study clusters with ncells larger than cut |
315 | Float_t fMassEtaMin ; // Min Eta mass | |
316 | Float_t fMassEtaMax ; // Max Eta mass | |
5a72d9af | 317 | Float_t fMassPi0Min ; // Min Pi0 mass // simple cut case |
318 | Float_t fMassPi0Max ; // Min Pi0 mass // simple cut case | |
3c1d9afb | 319 | Float_t fMassPhoMin ; // Min Photon mass |
320 | Float_t fMassPhoMax ; // Min Photon mass | |
1be44524 | 321 | Float_t fMassPi0Param [2][6] ; // mean mass param, 2 regions in energy |
322 | Float_t fWidthPi0Param[2][6] ; // width param, 2 regions in energy | |
323 | Float_t fM02MinParam[2][5] ; // 5 param for expo + pol fit on M02 minimum for pi0 selection (maximum for conversions) | |
324 | Float_t fM02MaxParam[2][5] ; // 5 param for expo + pol fit on M02 maximum for pi0 selection | |
325 | Float_t fM02MaxParamShiftNLMN; // shift of max M02 for NLM>2 | |
326 | Float_t fAsyMinParam[2][4] ; // 3 param for fit on asymmetry minimum, for 2 cases, NLM=1 and NLM>=2 | |
4d97a954 | 327 | Float_t fSplitEFracMin[3] ; // Do not use clusters with too large energy in cluster compared |
328 | // to energy in splitted clusters, depeding on NLM | |
2c36e041 | 329 | Float_t fSubClusterEMin[3] ; // Do not use sub-clusters with too low energy depeding on NLM |
5a72d9af | 330 | Float_t fSplitWidthSigma; // Cut on mass+-width*fSplitWidthSigma |
ac207ee4 | 331 | Float_t fMassShiftHighECell; // Shift cuts 5 MeV for Ecell > 150 MeV, default Ecell > 50 MeV |
5a72d9af | 332 | |
5a72d9af | 333 | AliCaloPID & operator = (const AliCaloPID & cpid) ; // cpy assignment |
334 | AliCaloPID( const AliCaloPID & cpid) ; // cpy ctor | |
c5693f62 | 335 | |
2c36e041 | 336 | ClassDef(AliCaloPID,21) |
3c1d9afb | 337 | |
e5dbdaf0 | 338 | } ; |
1c5acb87 | 339 | |
340 | ||
341 | #endif //ALICALOPID_H | |
342 | ||
343 | ||
344 |