]>
Commit | Line | Data |
---|---|---|
765d44e7 | 1 | #ifndef ALICALORIMETERUTILS_H |
2 | #define ALICALORIMETERUTILS_H | |
3 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
4 | * See cxx source for full Copyright notice */ | |
765d44e7 | 5 | |
6 | //_________________________________________________________________________ | |
7 | // Class utility for Calorimeter specific selection methods /// | |
8 | // | |
9 | // | |
10 | // | |
11 | //-- Author: Gustavo Conesa (LPSC-Grenoble) | |
12 | ////////////////////////////////////////////////////////////////////////////// | |
13 | ||
14 | // --- ROOT system --- | |
de0b770d | 15 | #include <TObject.h> |
16 | #include <TString.h> | |
17 | #include <TObjArray.h> | |
765d44e7 | 18 | class TArrayF; |
de0b770d | 19 | #include <TH2I.h> |
20 | #include <TGeoMatrix.h> | |
765d44e7 | 21 | |
22 | //--- ANALYSIS system --- | |
23 | class AliVEvent; | |
d832b695 | 24 | class AliVTrack; |
765d44e7 | 25 | class AliAODPWG4Particle; |
3c1d9afb | 26 | class AliAODCaloCluster; |
c8fe2783 | 27 | class AliVCaloCells; |
c5693f62 | 28 | class AliPHOSGeoUtils; |
29 | class AliEMCALGeometry; | |
4eb65103 | 30 | class AliAODMCParticle; |
31 | class TParticle; | |
32 | ||
19db8f8c | 33 | #include "AliEMCALRecoUtils.h" |
765d44e7 | 34 | |
35 | class AliCalorimeterUtils : public TObject { | |
36 | ||
78219bac | 37 | public: |
765d44e7 | 38 | AliCalorimeterUtils() ; // ctor |
765d44e7 | 39 | virtual ~AliCalorimeterUtils() ;//virtual dtor |
765d44e7 | 40 | |
a5fb4114 | 41 | virtual void InitParameters(); |
42 | virtual void Print(const Option_t * opt) const ; | |
765d44e7 | 43 | |
a5fb4114 | 44 | virtual Int_t GetDebug() const { return fDebug ; } |
45 | virtual void SetDebug(Int_t d) { fDebug = d ; } | |
765d44e7 | 46 | |
47 | //virtual void Init(); | |
48 | ||
7db7dcb6 | 49 | // Cluster contents |
50 | ||
9dcf63c2 | 51 | Bool_t AreNeighbours(Int_t calo, Int_t absId1, Int_t absId2) const ; |
7db7dcb6 | 52 | |
e1d24b6a | 53 | Bool_t IsClusterSharedByTwoSuperModules(const AliEMCALGeometry * geom, |
54 | AliVCluster* cluster); | |
55 | ||
71e3889f | 56 | Int_t GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells) ; |
57 | ||
7db7dcb6 | 58 | Int_t GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells, |
59 | Int_t *absIdList, Float_t *maxEList) ; | |
60 | ||
61 | Float_t GetLocalMaximaCutE() const { return fLocMaxCutE ; } | |
62 | void SetLocalMaximaCutE(Float_t cut) { fLocMaxCutE = cut ; } | |
63 | ||
64 | Float_t GetLocalMaximaCutEDiff() const { return fLocMaxCutEDiff ; } | |
65 | void SetLocalMaximaCutEDiff(Float_t c) { fLocMaxCutEDiff = c ; } | |
66 | ||
c5693f62 | 67 | Int_t GetMaxEnergyCell(AliVCaloCells* cells, const AliVCluster* clu, Float_t & fraction) const ; |
13cd2872 | 68 | |
8a2dbbff | 69 | void SplitEnergy(Int_t absId1, Int_t absId2, AliVCluster *cluster, AliVCaloCells* cells, |
55d66f31 | 70 | //Float_t & e1, Float_t & e2, |
8a2dbbff | 71 | AliAODCaloCluster *cluster1, AliAODCaloCluster *cluster2, |
72 | Int_t nMax, Int_t eventNumber = 0);//, Int_t *absIdList, Float_t *maxEList, | |
3c1d9afb | 73 | |
74 | void SwitchOnClusterPlot() { fPlotCluster = kTRUE ; } | |
75 | void SwitchOffClusterPlot() { fPlotCluster = kFALSE ; } | |
76 | ||
e1d24b6a | 77 | Float_t GetMCECellClusFracCorrection(Float_t eCell, Float_t eCluster) const ; |
78 | void SetMCECellClusFracCorrectionParamters(Int_t i, Float_t param) { if(i<4) fMCECellClusFracCorrParam[i] = param; } | |
79 | ||
80 | Bool_t IsMCECellClusFracCorrectionOn() const { return fMCECellClusFracCorrOn ; } | |
81 | void SwitchOnMCECellClusFracCorrection() { fMCECellClusFracCorrOn = kTRUE ; } | |
82 | void SwitchOffMCECellClusFracCorrection() { fMCECellClusFracCorrOn = kFALSE ; } | |
83 | ||
84 | ||
765d44e7 | 85 | //Calorimeters Geometry Methods |
a5fb4114 | 86 | AliEMCALGeometry * GetEMCALGeometry() const { return fEMCALGeo ; } |
87 | TString EMCALGeometryName() const { return fEMCALGeoName ; } | |
88 | void SetEMCALGeometryName(TString name) { fEMCALGeoName = name ; } | |
55d66f31 | 89 | void InitEMCALGeometry(Int_t runnumber = 180000) ; |
a5fb4114 | 90 | Bool_t IsEMCALGeoMatrixSet() const { return fEMCALGeoMatrixSet ; } |
765d44e7 | 91 | |
a5fb4114 | 92 | AliPHOSGeoUtils * GetPHOSGeometry() const { return fPHOSGeo ; } |
93 | TString PHOSGeometryName() const { return fPHOSGeoName ; } | |
94 | void SetPHOSGeometryName(TString name) { fPHOSGeoName = name ; } | |
55d66f31 | 95 | void InitPHOSGeometry(Int_t runnumber = 180000) ; |
a5fb4114 | 96 | Bool_t IsPHOSGeoMatrixSet() const { return fPHOSGeoMatrixSet ; } |
765d44e7 | 97 | |
55d66f31 | 98 | void AccessGeometry(AliVEvent* inputEvent) ; |
765d44e7 | 99 | |
9e536695 | 100 | void SetImportGeometryFromFile(Bool_t import, |
101 | TString path = ""){ | |
102 | fImportGeometryFromFile = import ; | |
103 | fImportGeometryFilePath = path ; } // EMCAL | |
104 | ||
9dcf63c2 | 105 | Bool_t IsMCParticleInCalorimeterAcceptance(Int_t calo, TParticle* particle); |
106 | Bool_t IsMCParticleInCalorimeterAcceptance(Int_t calo, AliAODMCParticle* particle); | |
107 | Bool_t IsMCParticleInCalorimeterAcceptance(Int_t calo, Float_t eta, Float_t theta, Float_t phi, Int_t & absID); | |
4eb65103 | 108 | |
a5fb4114 | 109 | void SwitchOnLoadOwnEMCALGeometryMatrices() { fLoadEMCALMatrices = kTRUE ; } |
110 | void SwitchOffLoadOwnEMCALGeometryMatrices() { fLoadEMCALMatrices = kFALSE ; } | |
111 | void SetEMCALGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fEMCALMatrix[i] = m ; } | |
3b13c34c | 112 | |
a5fb4114 | 113 | void SwitchOnLoadOwnPHOSGeometryMatrices() { fLoadPHOSMatrices = kTRUE ; } |
114 | void SwitchOffLoadOwnPHOSGeometryMatrices() { fLoadPHOSMatrices = kFALSE ; } | |
115 | void SetPHOSGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fPHOSMatrix[i] = m ; } | |
3b13c34c | 116 | |
765d44e7 | 117 | // Bad channels |
a5fb4114 | 118 | Bool_t IsBadChannelsRemovalSwitchedOn() const { return fRemoveBadChannels ; } |
119 | void SwitchOnBadChannelsRemoval () { fRemoveBadChannels = kTRUE ; | |
120 | fEMCALRecoUtils->SwitchOnBadChannelsRemoval(); | |
121 | if(!fPHOSBadChannelMap) InitPHOSBadChannelStatusMap() ; } | |
122 | void SwitchOffBadChannelsRemoval() { fRemoveBadChannels = kFALSE ; | |
123 | fEMCALRecoUtils->SwitchOffBadChannelsRemoval() ; } | |
c0b85449 | 124 | |
a5fb4114 | 125 | Bool_t IsDistanceToBadChannelRecalculated() const { return IsDistanceToBadChannelRecalculated() ; } |
126 | void SwitchOnDistToBadChannelRecalculation () { fEMCALRecoUtils->SwitchOnDistToBadChannelRecalculation() ; } | |
127 | void SwitchOffDistToBadChannelRecalculation() { fEMCALRecoUtils->SwitchOffDistToBadChannelRecalculation(); } | |
c0b85449 | 128 | |
a5fb4114 | 129 | void InitPHOSBadChannelStatusMap () ; |
765d44e7 | 130 | |
a5fb4114 | 131 | Int_t GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const { |
132 | return fEMCALRecoUtils->GetEMCALChannelStatus(iSM,iCol,iRow); }//Channel is ok by default | |
765d44e7 | 133 | |
a5fb4114 | 134 | Int_t GetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow) const { |
8a2dbbff | 135 | if(fPHOSBadChannelMap) return (Int_t) ((TH2I*)fPHOSBadChannelMap->At(imod))->GetBinContent(iCol,iRow); |
a5fb4114 | 136 | else return 0 ; }//Channel is ok by default |
765d44e7 | 137 | |
a5fb4114 | 138 | void SetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { |
139 | fEMCALRecoUtils->SetEMCALChannelStatus(iSM,iCol,iRow,c) ; } | |
765d44e7 | 140 | |
a5fb4114 | 141 | void SetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow, Double_t c = 1) { |
142 | if(!fPHOSBadChannelMap) InitPHOSBadChannelStatusMap() ; | |
143 | ((TH2I*)fPHOSBadChannelMap->At(imod))->SetBinContent(iCol,iRow,c) ; } | |
765d44e7 | 144 | |
a5fb4114 | 145 | void SetEMCALChannelStatusMap(Int_t iSM , TH2I* h) { fEMCALRecoUtils->SetEMCALChannelStatusMap(iSM,h) ; } |
146 | void SetPHOSChannelStatusMap(Int_t imod , TH2I* h) { fPHOSBadChannelMap ->AddAt(h,imod) ; } | |
05b8f25a | 147 | |
a5fb4114 | 148 | TH2I * GetEMCALChannelStatusMap(Int_t iSM) const { return fEMCALRecoUtils->GetEMCALChannelStatusMap(iSM) ; } |
149 | TH2I * GetPHOSChannelStatusMap(Int_t imod) const { return (TH2I*)fPHOSBadChannelMap->At(imod) ; } | |
765d44e7 | 150 | |
a5fb4114 | 151 | void SetEMCALChannelStatusMap(TObjArray *map) { fEMCALRecoUtils->SetEMCALChannelStatusMap(map) ; } |
152 | void SetPHOSChannelStatusMap (TObjArray *map) { fPHOSBadChannelMap = map ; } | |
765d44e7 | 153 | |
9dcf63c2 | 154 | Bool_t ClusterContainsBadChannel(Int_t calo,UShort_t* cellList, Int_t nCells); |
765d44e7 | 155 | |
a5fb4114 | 156 | // Mask clusters in front of frame, EMCAL only |
157 | Int_t GetNMaskCellColumns() const { return fNMaskCellColumns;} | |
158 | void SetNMaskCellColumns(Int_t n) { | |
159 | if(n > fNMaskCellColumns) { delete [] fMaskCellColumns ; fMaskCellColumns = new Int_t[n] ; } | |
160 | fNMaskCellColumns = n ; } | |
161 | void SetMaskCellColumn(Int_t ipos, Int_t icol) { | |
162 | if(ipos < fNMaskCellColumns) fMaskCellColumns[ipos] = icol; | |
163 | else printf("Not set, position larger than allocated set size first") ; } | |
8a2dbbff | 164 | Bool_t MaskFrameCluster(Int_t iSM, Int_t ieta) const ; |
a5fb4114 | 165 | |
166 | ||
765d44e7 | 167 | //Calorimeter indexes information |
a5fb4114 | 168 | Int_t GetModuleNumber(AliAODPWG4Particle * particle, AliVEvent* inputEvent) const; |
169 | Int_t GetModuleNumber(AliVCluster * cluster) const; | |
9dcf63c2 | 170 | Int_t GetModuleNumberCellIndexes(Int_t absId, Int_t calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const ; |
765d44e7 | 171 | |
172 | //Modules fiducial region | |
6b28ddba | 173 | Bool_t CheckCellFiducialRegion(AliVCluster* cluster, AliVCaloCells* cells) const ; |
58007db9 | 174 | Bool_t CheckCellFiducialRegion(AliVCluster* cluster, AliVCaloCells* cells, AliVEvent* /**/, Int_t /**/) |
175 | { return CheckCellFiducialRegion(cluster, cells) ; } // Stupid thing to do but just to avoid compilation break in AliTrackComparisonESD while I find the authors | |
a5fb4114 | 176 | void SetNumberOfCellsFromPHOSBorder(Int_t n) { fNCellsFromPHOSBorder = n ; } |
177 | Int_t GetNumberOfCellsFromPHOSBorder() const { return fNCellsFromPHOSBorder ; } | |
178 | void SetNumberOfCellsFromEMCALBorder(Int_t n) { fEMCALRecoUtils->SetNumberOfCellsFromEMCALBorder(n) ; } | |
179 | Int_t GetNumberOfCellsFromEMCALBorder() const { return fEMCALRecoUtils->GetNumberOfCellsFromEMCALBorder(); } | |
180 | void SwitchOnNoFiducialBorderInEMCALEta0() { fEMCALRecoUtils->SwitchOnNoFiducialBorderInEMCALEta0() ; } | |
181 | void SwitchOffNoFiducialBorderInEMCALEta0() { fEMCALRecoUtils->SwitchOffNoFiducialBorderInEMCALEta0() ; } | |
182 | Bool_t IsEMCALNoBorderAtEta0() const { return fEMCALRecoUtils->IsEMCALNoBorderAtEta0() ; } | |
247abff4 | 183 | |
09e819c9 | 184 | // Recalibration |
a5fb4114 | 185 | Bool_t IsRecalibrationOn() const { return fRecalibration ; } |
186 | void SwitchOnRecalibration() { fRecalibration = kTRUE ; | |
187 | InitPHOSRecalibrationFactors(); fEMCALRecoUtils->SwitchOnRecalibration() ; } | |
188 | void SwitchOffRecalibration() { fRecalibration = kFALSE; | |
189 | fEMCALRecoUtils->SwitchOffRecalibration() ; } | |
09e819c9 | 190 | |
a5fb4114 | 191 | void InitPHOSRecalibrationFactors () ; |
09e819c9 | 192 | |
a5fb4114 | 193 | Float_t GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const { |
194 | return fEMCALRecoUtils->GetEMCALChannelRecalibrationFactor(iSM , iCol, iRow) ; } | |
78219bac | 195 | |
a5fb4114 | 196 | Float_t GetPHOSChannelRecalibrationFactor (Int_t imod, Int_t iCol, Int_t iRow) const { |
197 | if(fPHOSRecalibrationFactors) | |
198 | return (Float_t) ((TH2F*)fPHOSRecalibrationFactors->At(imod))->GetBinContent(iCol,iRow); | |
199 | else return 1 ; } | |
78219bac | 200 | |
a5fb4114 | 201 | void SetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { |
202 | fEMCALRecoUtils->SetEMCALChannelRecalibrationFactor(iSM,iCol,iRow,c) ; } | |
09e819c9 | 203 | |
a5fb4114 | 204 | void SetPHOSChannelRecalibrationFactor (Int_t imod, Int_t iCol, Int_t iRow, Double_t c = 1) { |
205 | if(!fPHOSRecalibrationFactors) InitPHOSRecalibrationFactors(); | |
206 | ((TH2F*)fPHOSRecalibrationFactors->At(imod))->SetBinContent(iCol,iRow,c) ; } | |
09e819c9 | 207 | |
a5fb4114 | 208 | void SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(iSM,h) ; } |
209 | void SetPHOSChannelRecalibrationFactors(Int_t imod , TH2F* h) { fPHOSRecalibrationFactors ->AddAt(h,imod) ; } | |
09e819c9 | 210 | |
a5fb4114 | 211 | TH2F * GetEMCALChannelRecalibrationFactors(Int_t iSM) const { return fEMCALRecoUtils->GetEMCALChannelRecalibrationFactors(iSM) ; } |
212 | TH2F * GetPHOSChannelRecalibrationFactors(Int_t imod) const { return (TH2F*)fPHOSRecalibrationFactors->At(imod) ; } | |
09e819c9 | 213 | |
a5fb4114 | 214 | void SetEMCALChannelRecalibrationFactors(TObjArray *map) { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(map) ; } |
215 | void SetPHOSChannelRecalibrationFactors (TObjArray *map) { fPHOSRecalibrationFactors = map;} | |
09e819c9 | 216 | |
9dcf63c2 | 217 | void RecalibrateCellTime (Double_t & time, Int_t calo, Int_t absId, Int_t bunchCrossNumber) const ; |
218 | void RecalibrateCellAmplitude(Float_t & amp, Int_t calo, Int_t absId) const ; | |
a5fb4114 | 219 | Float_t RecalibrateClusterEnergy(AliVCluster* cluster, AliVCaloCells * cells); |
e1d24b6a | 220 | Float_t RecalibrateClusterEnergyWeightCell(AliVCluster* cluster, AliVCaloCells * cells, Float_t energyOrg); |
765d44e7 | 221 | |
55d66f31 | 222 | // Run dependent energy calibrations (EMCAL) |
223 | ||
7bf608c9 | 224 | void SwitchOffRunDepCorrection() { fRunDependentCorrection = kFALSE ; } |
225 | void SwitchOnRunDepCorrection() { fRunDependentCorrection = kTRUE ; } | |
55d66f31 | 226 | |
227 | // Time Recalibration (EMCAL) | |
228 | ||
229 | Bool_t IsTimeRecalibrationOn() const { return fEMCALRecoUtils->IsTimeRecalibrationOn() ; } | |
230 | void SwitchOffTimeRecalibration() { fEMCALRecoUtils->SwitchOffTimeRecalibration() ; } | |
231 | void SwitchOnTimeRecalibration() { fEMCALRecoUtils->SwitchOnTimeRecalibration() ; } | |
232 | ||
8a2dbbff | 233 | Float_t GetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID) const |
eeeed2bc | 234 | { return fEMCALRecoUtils->GetEMCALChannelTimeRecalibrationFactor(bc, absID) ; } |
55d66f31 | 235 | |
8a2dbbff | 236 | void SetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID, Double_t c = 0) |
55d66f31 | 237 | { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactor(bc, absID, c) ; } |
238 | ||
8a2dbbff | 239 | TH1F * GetEMCALChannelTimeRecalibrationFactors(Int_t bc) const { return fEMCALRecoUtils-> GetEMCALChannelTimeRecalibrationFactors(bc) ; } |
240 | void SetEMCALChannelTimeRecalibrationFactors(TObjArray *map) { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(map) ; } | |
241 | void SetEMCALChannelTimeRecalibrationFactors(Int_t bc , TH1F* h) { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(bc , h) ; } | |
55d66f31 | 242 | |
f2ccb5b8 | 243 | //EMCAL specific utils for the moment |
a5fb4114 | 244 | void SetEMCALRecoUtils(AliEMCALRecoUtils * ru) { fEMCALRecoUtils = ru ; } |
245 | AliEMCALRecoUtils* GetEMCALRecoUtils() const { return fEMCALRecoUtils ; } | |
9584c261 | 246 | |
a5fb4114 | 247 | Bool_t IsCorrectionOfClusterEnergyOn() const { return fCorrectELinearity ; } |
248 | void SwitchOnCorrectClusterLinearity() { fCorrectELinearity = kTRUE ; } | |
249 | void SwitchOffCorrectClusterLinearity() { fCorrectELinearity = kFALSE ; } | |
250 | void CorrectClusterEnergy(AliVCluster *cl); | |
9584c261 | 251 | |
a5fb4114 | 252 | Bool_t IsRecalculationOfClusterPositionOn() const { return fRecalculatePosition ; } |
253 | void SwitchOnRecalculateClusterPosition() { fRecalculatePosition = kTRUE ; } | |
254 | void SwitchOffRecalculateClusterPosition() { fRecalculatePosition = kFALSE ; } | |
255 | void RecalculateClusterPosition(AliVCaloCells* cells, AliVCluster* clu); | |
256 | void RecalculateClusterShowerShapeParameters(AliVCaloCells* cells, AliVCluster* clu){ | |
257 | fEMCALRecoUtils->RecalculateClusterShowerShapeParameters((AliEMCALGeometry*)fEMCALGeo, cells, clu) ; } | |
3b13c34c | 258 | |
a5fb4114 | 259 | void RecalculateClusterDistanceToBadChannel(AliVCaloCells* cells, AliVCluster* clu){ |
260 | fEMCALRecoUtils->RecalculateClusterDistanceToBadChannel((AliEMCALGeometry*)fEMCALGeo, cells, clu) ; } | |
3b13c34c | 261 | |
a5fb4114 | 262 | void RecalculateClusterPID(AliVCluster* clu) { fEMCALRecoUtils->RecalculateClusterPID(clu) ; } |
9584c261 | 263 | |
d832b695 | 264 | // *** Track Matching *** |
265 | ||
8a2dbbff | 266 | AliVTrack * GetMatchedTrack(AliVCluster * cluster, AliVEvent * event, Int_t index = 0) const ; |
d832b695 | 267 | |
268 | // Recalculation | |
cb5780f4 | 269 | void RecalculateClusterTrackMatching(AliVEvent * event, TObjArray* clusterArray = 0x0) ; |
270 | ||
a5fb4114 | 271 | void GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ) { |
272 | if (fRecalculateMatching) fEMCALRecoUtils->GetMatchedResiduals(index,dR,dZ) ; } | |
9e8998b1 | 273 | |
f2ccb5b8 | 274 | //This could be used for PHOS ... |
a5fb4114 | 275 | void SwitchOnRecalculateClusterTrackMatching() { fRecalculateMatching = kTRUE ; } |
276 | void SwitchOffRecalculateClusterTrackMatching() { fRecalculateMatching = kFALSE ; } | |
277 | Bool_t IsRecalculationOfClusterTrackMatchingOn() const { return fRecalculateMatching ; } | |
f2ccb5b8 | 278 | |
9e8998b1 | 279 | Float_t GetCutZ() const { return fCutZ ; } // PHOS only |
280 | void SetCutZ(Float_t z) { fCutZ = z ; } // PHOS only | |
281 | ||
282 | ||
283 | Float_t GetCutR() const { return fCutR ; } // PHOS and EMCAL | |
284 | void SetCutR(Float_t r) { fCutR = r ; // PHOS and EMCA | |
285 | fEMCALRecoUtils->SetCutR(r) ; } | |
286 | ||
287 | Float_t GetCutEta() const { return fCutEta ; } // EMCAL only | |
288 | void SetCutEta(Float_t e) { fCutEta = e ; // EMCAL only | |
289 | fEMCALRecoUtils->SetCutEta(e) ; } | |
290 | ||
291 | Float_t GetCutPhi() const { return fCutPhi ; } // EMCAL only | |
292 | void SetCutPhi(Float_t p) { fCutPhi = p ; // EMCAL only | |
293 | fEMCALRecoUtils->SetCutPhi(p) ; } | |
55d66f31 | 294 | // OADB options settings |
295 | ||
296 | void AccessOADB(AliVEvent * event) ; | |
297 | ||
298 | TString GetPass() ; | |
299 | ||
300 | void SwitchOnEMCALOADB() { fOADBForEMCAL = kTRUE ; } | |
301 | void SwitchOffEMCALOADB() { fOADBForEMCAL = kFALSE ; } | |
302 | ||
303 | void SwitchOnPHOSOADB() { fOADBForPHOS = kTRUE ; } | |
304 | void SwitchOffPHOSOADB() { fOADBForPHOS = kFALSE ; } | |
305 | ||
306 | void SetEMCALOADBFilePath(TString path) { fOADBFilePathEMCAL = path ; } | |
307 | void SetPHOSOADBFilePath (TString path) { fOADBFilePathPHOS = path ; } | |
308 | ||
190f6f2d | 309 | void SetNumberOfSuperModulesUsed(Int_t nSM) { fNSuperModulesUsed = nSM ; } |
310 | Int_t GetNumberOfSuperModulesUsed() const { return fNSuperModulesUsed ; } | |
f2ccb5b8 | 311 | |
9dcf63c2 | 312 | enum detector { kEMCAL = 0, kPHOS = 1, kCTS = 2, kDCAL = 3, kDCALPHOS = 4 }; |
313 | ||
765d44e7 | 314 | private: |
315 | ||
09e819c9 | 316 | Int_t fDebug; // Debugging level |
317 | TString fEMCALGeoName; // Name of geometry to use for EMCAL. | |
318 | TString fPHOSGeoName; // Name of geometry to use for PHOS. | |
a38a48f2 | 319 | AliEMCALGeometry * fEMCALGeo ; //! EMCAL geometry pointer |
09e819c9 | 320 | AliPHOSGeoUtils * fPHOSGeo ; //! PHOS geometry pointer |
321 | Bool_t fEMCALGeoMatrixSet; // Check if the transformation matrix is set for EMCAL | |
322 | Bool_t fPHOSGeoMatrixSet ; // Check if the transformation matrix is set for PHOS | |
3b13c34c | 323 | Bool_t fLoadEMCALMatrices; // Matrices set from configuration, not get from geometry.root or from ESDs/AODs |
90e32961 | 324 | TGeoHMatrix * fEMCALMatrix[12]; // Geometry matrices with alignments |
3b13c34c | 325 | Bool_t fLoadPHOSMatrices; // Matrices set from configuration, not get from geometry.root or from ESDs/AODs |
326 | TGeoHMatrix * fPHOSMatrix[5]; // Geometry matrices with alignments | |
09e819c9 | 327 | Bool_t fRemoveBadChannels; // Check the channel status provided and remove clusters with bad channels |
2be3914b | 328 | TObjArray * fPHOSBadChannelMap; // Array of histograms with map of bad channels, PHOS |
09e819c9 | 329 | Int_t fNCellsFromPHOSBorder; // Number of cells from PHOS border the cell with maximum amplitude has to be. |
a5fb4114 | 330 | Int_t fNMaskCellColumns; // Number of masked columns |
331 | Int_t* fMaskCellColumns; //[fNMaskCellColumns] list of masked cell collumn | |
09e819c9 | 332 | Bool_t fRecalibration; // Switch on or off the recalibration |
7bf608c9 | 333 | Bool_t fRunDependentCorrection;// Switch on or off the recalibration dependent on T |
2be3914b | 334 | TObjArray * fPHOSRecalibrationFactors; // Array of histograms with map of recalibration factors, PHOS |
9584c261 | 335 | AliEMCALRecoUtils* fEMCALRecoUtils; // EMCAL utils for cluster rereconstruction |
3b13c34c | 336 | Bool_t fRecalculatePosition; // Recalculate cluster position |
337 | Bool_t fCorrectELinearity ; // Correct cluster energy linearity | |
338 | Bool_t fRecalculateMatching; // Recalculate cluster position | |
9e8998b1 | 339 | Float_t fCutR; // dR cut on matching (PHOS) |
340 | Float_t fCutZ; // dZ cut on matching (EMCAL/PHOS) | |
341 | Float_t fCutEta; // dEta cut on matching (EMCAL) | |
342 | Float_t fCutPhi; // dPhi cut on matching (EMCAL) | |
7db7dcb6 | 343 | Float_t fLocMaxCutE; // Local maxima cut must have more than this energy |
344 | Float_t fLocMaxCutEDiff; // Local maxima cut, when aggregating cells, next can be a bit higher | |
3c1d9afb | 345 | Bool_t fPlotCluster; // Plot cluster in splitting method |
55d66f31 | 346 | Bool_t fOADBSet ; // AODB parameters already set |
347 | Bool_t fOADBForEMCAL ; // Get calibration from OADB for EMCAL | |
348 | Bool_t fOADBForPHOS ; // Get calibration from OADB for PHOS | |
349 | TString fOADBFilePathEMCAL ; // Default path $ALICE_ROOT/OADB/EMCAL, if needed change | |
350 | TString fOADBFilePathPHOS ; // Default path $ALICE_ROOT/OADB/PHOS, if needed change | |
9e536695 | 351 | Bool_t fImportGeometryFromFile;// Import geometry settings in geometry.root file |
352 | TString fImportGeometryFilePath;// path fo geometry.root file | |
353 | ||
190f6f2d | 354 | Int_t fNSuperModulesUsed; // Number of supermodules to be used in analysis, can be different than the real geo, |
355 | // to be used at initialization of histograms | |
356 | ||
4eb65103 | 357 | Bool_t fMCECellClusFracCorrOn; // Correct or not the weight of cells in cluster |
e1d24b6a | 358 | Float_t fMCECellClusFracCorrParam[4]; // Parameters for the function correcting the weight of the cells in the cluster |
190f6f2d | 359 | |
90e32961 | 360 | AliCalorimeterUtils( const AliCalorimeterUtils & cu) ; // cpy ctor |
361 | AliCalorimeterUtils & operator = (const AliCalorimeterUtils & cu) ; // cpy assignment | |
c5693f62 | 362 | |
e1d24b6a | 363 | ClassDef(AliCalorimeterUtils,17) |
765d44e7 | 364 | } ; |
365 | ||
366 | ||
367 | #endif //ALICALORIMETERUTILS_H | |
368 | ||
369 | ||
370 |