Coverity fix for the PID
[u/mrichter/AliRoot.git] / PWG / CaloTrackCorrBase / AliCalorimeterUtils.cxx
CommitLineData
765d44e7 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
765d44e7 15
16//_________________________________________________________________________
17// Class utility for Calorimeter specific selection methods ///
18//
19//
20//
21//-- Author: Gustavo Conesa (LPSC-Grenoble)
22//////////////////////////////////////////////////////////////////////////////
23
24
25// --- ROOT system ---
26#include "TGeoManager.h"
27
c5693f62 28// --- ANALYSIS system ---
765d44e7 29#include "AliCalorimeterUtils.h"
4b892846 30#include "AliESDEvent.h"
46a3cde6 31#include "AliMCEvent.h"
32#include "AliStack.h"
765d44e7 33#include "AliAODPWG4Particle.h"
c8fe2783 34#include "AliVCluster.h"
35#include "AliVCaloCells.h"
36#include "AliMixedEvent.h"
765d44e7 37
c5693f62 38// --- Detector ---
39#include "AliEMCALGeometry.h"
40#include "AliPHOSGeoUtils.h"
41
765d44e7 42ClassImp(AliCalorimeterUtils)
43
44
cb5780f4 45//____________________________________________
765d44e7 46 AliCalorimeterUtils::AliCalorimeterUtils() :
47 TObject(), fDebug(0),
90e32961 48 fEMCALGeoName("EMCAL_COMPLETE12SMV1"),
49 fPHOSGeoName ("PHOSgeo"),
9e8998b1 50 fEMCALGeo(0x0), fPHOSGeo(0x0),
51 fEMCALGeoMatrixSet(kFALSE), fPHOSGeoMatrixSet(kFALSE),
52 fLoadEMCALMatrices(kFALSE), fLoadPHOSMatrices(kFALSE),
53 fRemoveBadChannels(kFALSE), fPHOSBadChannelMap(0x0),
a5fb4114 54 fNCellsFromPHOSBorder(0),
9e8998b1 55 fNMaskCellColumns(0), fMaskCellColumns(0x0),
56 fRecalibration(kFALSE), fPHOSRecalibrationFactors(),
247abff4 57 fEMCALRecoUtils(new AliEMCALRecoUtils),
9e8998b1 58 fRecalculatePosition(kFALSE), fCorrectELinearity(kFALSE),
59 fRecalculateMatching(kFALSE),
60 fCutR(20), fCutZ(20),
7db7dcb6 61 fCutEta(20), fCutPhi(20),
62 fLocMaxCutE(0), fLocMaxCutEDiff(0)
765d44e7 63{
64 //Ctor
65
66 //Initialize parameters
67 InitParameters();
90e32961 68 for(Int_t i = 0; i < 12; i++) fEMCALMatrix[i] = 0 ;
69 for(Int_t i = 0; i < 5 ; i++) fPHOSMatrix [i] = 0 ;
7cc7d3f8 70
765d44e7 71}
765d44e7 72
cb5780f4 73//_________________________________________
74AliCalorimeterUtils::~AliCalorimeterUtils()
75{
765d44e7 76 //Dtor
77
4df35693 78 //if(fPHOSGeo) delete fPHOSGeo ;
765d44e7 79 if(fEMCALGeo) delete fEMCALGeo ;
7cc7d3f8 80
765d44e7 81 if(fPHOSBadChannelMap) {
82 fPHOSBadChannelMap->Clear();
83 delete fPHOSBadChannelMap;
84 }
85
09e819c9 86 if(fPHOSRecalibrationFactors) {
78219bac 87 fPHOSRecalibrationFactors->Clear();
88 delete fPHOSRecalibrationFactors;
09e819c9 89 }
90
a5fb4114 91 if(fEMCALRecoUtils) delete fEMCALRecoUtils ;
92 if(fNMaskCellColumns) delete [] fMaskCellColumns;
9584c261 93
765d44e7 94}
95
7db7dcb6 96//______________________________________________________________________________________
97Bool_t AliCalorimeterUtils::AreNeighbours(const TString calo,
98 const Int_t absId1, const Int_t absId2 ) const
99{
100 // Tells if (true) or not (false) two cells are neighbours
101 // A neighbour is defined as being two cells which share a side or corner
102
103 Bool_t areNeighbours = kFALSE ;
104
105 Int_t iRCU1 = -1, irow1 = -1, icol1 = -1;
106 Int_t iRCU2 = -1, irow2 = -1, icol2 = -1;
107
108 Int_t rowdiff = 0, coldiff = 0;
109
9369a2b1 110 Int_t nSupMod1 = GetModuleNumberCellIndexes(absId1, calo, icol1, irow1, iRCU1);
111 Int_t nSupMod2 = GetModuleNumberCellIndexes(absId2, calo, icol2, irow2, iRCU2);
7db7dcb6 112
113 if(calo=="EMCAL" && nSupMod1!=nSupMod2)
114 {
115 // In case of a shared cluster, index of SM in C side, columns start at 48 and ends at 48*2-1
116 // C Side impair SM, nSupMod%2=1; A side pair SM nSupMod%2=0
117 if(nSupMod1%2) icol1+=AliEMCALGeoParams::fgkEMCALCols;
9369a2b1 118 else icol2+=AliEMCALGeoParams::fgkEMCALCols;
7db7dcb6 119 }
120
121 rowdiff = TMath::Abs( irow1 - irow2 ) ;
122 coldiff = TMath::Abs( icol1 - icol2 ) ;
123
124 if (( coldiff <= 1 ) && ( rowdiff <= 1 ) && (coldiff + rowdiff > 0))
125 areNeighbours = kTRUE ;
126
127 return areNeighbours;
128
129}
130
131
cb5780f4 132//_____________________________________________________________________________________
133Bool_t AliCalorimeterUtils::CheckCellFiducialRegion(AliVCluster* cluster,
134 AliVCaloCells* cells,
135 AliVEvent * event, Int_t iev) const
136{
7cc7d3f8 137
765d44e7 138 // Given the list of AbsId of the cluster, get the maximum cell and
139 // check if there are fNCellsFromBorder from the calorimeter border
140
7cc7d3f8 141 //If the distance to the border is 0 or negative just exit accept all clusters
247abff4 142 if(cells->GetType()==AliVCaloCells::kEMCALCell && fEMCALRecoUtils->GetNumberOfCellsFromEMCALBorder() <= 0 ) return kTRUE;
c8fe2783 143 if(cells->GetType()==AliVCaloCells::kPHOSCell && fNCellsFromPHOSBorder <= 0 ) return kTRUE;
7cc7d3f8 144
c8fe2783 145 Int_t absIdMax = -1;
765d44e7 146 Float_t ampMax = -1;
c8fe2783 147
148 AliMixedEvent * mixEvent = dynamic_cast<AliMixedEvent*> (event);
149 Int_t nMixedEvents = 0 ;
150 Int_t * cellsCumul = NULL ;
151 Int_t numberOfCells = 0 ;
152 if (mixEvent){
153 nMixedEvents = mixEvent->GetNumberOfEvents() ;
154 if (cells->GetType()==AliVCaloCells::kEMCALCell) {
155 cellsCumul = mixEvent->GetEMCALCellsCumul() ;
156 numberOfCells = mixEvent->GetNumberOfEMCALCells() ;
157 }
7cc7d3f8 158
c8fe2783 159 else if (cells->GetType()==AliVCaloCells::kPHOSCell) {
160 cellsCumul = mixEvent->GetPHOSCellsCumul() ;
161 numberOfCells = mixEvent->GetNumberOfPHOSCells() ;
162 }
898c9d44 163
164 if(cellsCumul){
165
166 Int_t startCell = cellsCumul[iev] ;
167 Int_t endCell = (iev+1 < nMixedEvents)?cellsCumul[iev+1]:numberOfCells;
c8fe2783 168 //Find cells with maximum amplitude
898c9d44 169 for(Int_t i = 0; i < cluster->GetNCells() ; i++){
170 Int_t absId = cluster->GetCellAbsId(i) ;
171 for (Int_t j = startCell; j < endCell ; j++) {
172 Short_t cellNumber;
173 Double_t amp ;
174 Double_t time;
175 cells->GetCell(j, cellNumber, amp, time) ;
176 if (absId == cellNumber) {
177 if(amp > ampMax){
178 ampMax = amp;
179 absIdMax = absId;
180 }
181 }
c8fe2783 182 }
898c9d44 183 }//loop on cluster cells
184 }// cells cumul available
185 else {
186 printf("AliCalorimeterUtils::CheckCellFiducialRegion() - CellsCumul is NULL!!!\n");
187 abort();
c8fe2783 188 }
898c9d44 189 } else {//Normal SE Events
c8fe2783 190 for(Int_t i = 0; i < cluster->GetNCells() ; i++){
191 Int_t absId = cluster->GetCellAbsId(i) ;
192 Float_t amp = cells->GetCellAmplitude(absId);
193 if(amp > ampMax){
194 ampMax = amp;
195 absIdMax = absId;
196 }
197 }
198 }
765d44e7 199
200 if(fDebug > 1)
280e6766 201 printf("AliCalorimeterUtils::CheckCellFiducialRegion() - Cluster Max AbsId %d, Cell Energy %2.2f, Cluster Energy %2.2f\n",
7cc7d3f8 202 absIdMax, ampMax, cluster->E());
765d44e7 203
204 if(absIdMax==-1) return kFALSE;
205
206 //Check if the cell is close to the borders:
207 Bool_t okrow = kFALSE;
208 Bool_t okcol = kFALSE;
7cc7d3f8 209
c8fe2783 210 if(cells->GetType()==AliVCaloCells::kEMCALCell){
7cc7d3f8 211
765d44e7 212 Int_t iTower = -1, iIphi = -1, iIeta = -1, iphi = -1, ieta = -1, iSM = -1;
213 fEMCALGeo->GetCellIndex(absIdMax,iSM,iTower,iIphi,iIeta);
214 fEMCALGeo->GetCellPhiEtaIndexInSModule(iSM,iTower,iIphi, iIeta,iphi,ieta);
280e6766 215 if(iSM < 0 || iphi < 0 || ieta < 0 ) {
216 Fatal("CheckCellFidutialRegion","Negative value for super module: %d, or cell ieta: %d, or cell iphi: %d, check EMCAL geometry name\n",iSM,ieta,iphi);
217 }
7cc7d3f8 218
765d44e7 219 //Check rows/phi
247abff4 220 Int_t nborder = fEMCALRecoUtils->GetNumberOfCellsFromEMCALBorder();
765d44e7 221 if(iSM < 10){
247abff4 222 if(iphi >= nborder && iphi < 24-nborder) okrow =kTRUE;
7cc7d3f8 223 }
765d44e7 224 else{
247abff4 225 if(iphi >= nborder && iphi < 12-nborder) okrow =kTRUE;
765d44e7 226 }
227
247abff4 228 //Check columns/eta
229 if(!fEMCALRecoUtils->IsEMCALNoBorderAtEta0()){
230 if(ieta > nborder && ieta < 48-nborder) okcol =kTRUE;
765d44e7 231 }
232 else{
233 if(iSM%2==0){
247abff4 234 if(ieta >= nborder) okcol = kTRUE;
765d44e7 235 }
236 else {
247abff4 237 if(ieta < 48-nborder) okcol = kTRUE;
765d44e7 238 }
239 }//eta 0 not checked
240 if(fDebug > 1)
241 {
280e6766 242 printf("AliCalorimeterUtils::CheckCellFiducialRegion() - EMCAL Cluster in %d cells fiducial volume: ieta %d, iphi %d, SM %d ?",
7cc7d3f8 243 nborder, ieta, iphi, iSM);
765d44e7 244 if (okcol && okrow ) printf(" YES \n");
245 else printf(" NO: column ok? %d, row ok? %d \n",okcol,okrow);
246 }
247 }//EMCAL
c8fe2783 248 else if(cells->GetType()==AliVCaloCells::kPHOSCell){
765d44e7 249 Int_t relId[4];
250 Int_t irow = -1, icol = -1;
251 fPHOSGeo->AbsToRelNumbering(absIdMax,relId);
252 irow = relId[2];
253 icol = relId[3];
254 //imod = relId[0]-1;
255 if(irow >= fNCellsFromPHOSBorder && irow < 64-fNCellsFromPHOSBorder) okrow =kTRUE;
256 if(icol >= fNCellsFromPHOSBorder && icol < 56-fNCellsFromPHOSBorder) okcol =kTRUE;
257 if(fDebug > 1)
258 {
280e6766 259 printf("AliCalorimeterUtils::CheckCellFiducialRegion() - PHOS Cluster in %d cells fiducial volume: icol %d, irow %d, Module %d?",
7cc7d3f8 260 fNCellsFromPHOSBorder, icol, irow, relId[0]-1);
765d44e7 261 if (okcol && okrow ) printf(" YES \n");
262 else printf(" NO: column ok? %d, row ok? %d \n",okcol,okrow);
263 }
264 }//PHOS
265
266 if (okcol && okrow) return kTRUE;
267 else return kFALSE;
268
269}
270
765d44e7 271//_________________________________________________________________________________________________________
cb5780f4 272Bool_t AliCalorimeterUtils::ClusterContainsBadChannel(TString calorimeter,UShort_t* cellList, Int_t nCells)
273{
765d44e7 274 // Check that in the cluster cells, there is no bad channel of those stored
275 // in fEMCALBadChannelMap or fPHOSBadChannelMap
276
277 if (!fRemoveBadChannels) return kFALSE;
36037088 278 //printf("fEMCALBadChannelMap %p, fPHOSBadChannelMap %p \n",fEMCALBadChannelMap,fPHOSBadChannelMap);
247abff4 279 if(calorimeter == "EMCAL" && !fEMCALRecoUtils->GetEMCALChannelStatusMap(0)) return kFALSE;
78219bac 280 if(calorimeter == "PHOS" && !fPHOSBadChannelMap) return kFALSE;
7cc7d3f8 281
765d44e7 282 Int_t icol = -1;
283 Int_t irow = -1;
284 Int_t imod = -1;
285 for(Int_t iCell = 0; iCell<nCells; iCell++){
7cc7d3f8 286
765d44e7 287 //Get the column and row
288 if(calorimeter == "EMCAL"){
247abff4 289 return fEMCALRecoUtils->ClusterContainsBadChannel((AliEMCALGeometry*)fEMCALGeo,cellList,nCells);
765d44e7 290 }
291 else if(calorimeter=="PHOS"){
292 Int_t relId[4];
293 fPHOSGeo->AbsToRelNumbering(cellList[iCell],relId);
294 irow = relId[2];
295 icol = relId[3];
296 imod = relId[0]-1;
297 if(fPHOSBadChannelMap->GetEntries() <= imod)continue;
c5693f62 298 //printf("PHOS bad channels imod %d, icol %d, irow %d\n",imod, irow, icol);
299 if(GetPHOSChannelStatus(imod, irow, icol)) return kTRUE;
765d44e7 300 }
301 else return kFALSE;
302
303 }// cell cluster loop
7cc7d3f8 304
765d44e7 305 return kFALSE;
7cc7d3f8 306
765d44e7 307}
308
cb5780f4 309//_______________________________________________________________
310void AliCalorimeterUtils::CorrectClusterEnergy(AliVCluster *clus)
311{
9584c261 312 // Correct cluster energy non linearity
13cd2872 313
9584c261 314 clus->SetE(fEMCALRecoUtils->CorrectClusterEnergyLinearity(clus));
13cd2872 315
316}
317
c5693f62 318//________________________________________________________________________________________
319Int_t AliCalorimeterUtils::GetMaxEnergyCell(AliVCaloCells* cells, const AliVCluster* clu,
320 Float_t & clusterFraction) const
cb5780f4 321{
13cd2872 322
323 //For a given CaloCluster gets the absId of the cell
324 //with maximum energy deposit.
325
326 if( !clu || !cells ){
327 AliInfo("Cluster or cells pointer is null!");
328 return -1;
329 }
330
331 Double_t eMax =-1.;
332 Double_t eTot = 0.;
333 Double_t eCell =-1.;
334 Float_t fraction = 1.;
335 Float_t recalFactor = 1.;
336 Int_t cellAbsId =-1 , absId =-1 ;
337 Int_t iSupMod =-1 , ieta =-1 , iphi = -1, iRCU = -1;
338
339 TString calo = "EMCAL";
340 if(clu->IsPHOS()) calo = "PHOS";
341
342 for (Int_t iDig=0; iDig< clu->GetNCells(); iDig++) {
343
344 cellAbsId = clu->GetCellAbsId(iDig);
345
346 fraction = clu->GetCellAmplitudeFraction(iDig);
347 if(fraction < 1e-4) fraction = 1.; // in case unfolding is off
348
b08dd6d5 349 iSupMod = GetModuleNumberCellIndexes(cellAbsId, calo, ieta, iphi, iRCU);
13cd2872 350
351 if(IsRecalibrationOn()) {
352 if(calo=="EMCAL") recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
c5693f62 353 else recalFactor = GetPHOSChannelRecalibrationFactor (iSupMod,iphi,ieta);
13cd2872 354 }
355
356 eCell = cells->GetCellAmplitude(cellAbsId)*fraction*recalFactor;
357
358 if(eCell > eMax) {
359 eMax = eCell;
360 absId = cellAbsId;
361 }
362
363 eTot+=eCell;
364
365 }// cell loop
366
367 clusterFraction = (eTot-eMax)/eTot; //Do not use cluster energy in case it was corrected for non linearity.
368
369 return absId;
370
9584c261 371}
372
d832b695 373//__________________________________________________________________________
374AliVTrack * AliCalorimeterUtils::GetMatchedTrack(const AliVCluster* cluster,
375 const AliVEvent* event,
376 const Int_t index) const
377{
378 // Get the matched track given its index, usually just the first match
379 // Since it is different for ESDs and AODs here it is a wrap method to do it
380
381 AliVTrack *track = 0;
382
383 // EMCAL case only when matching is recalculated
384 if(cluster->IsEMCAL() && IsRecalculationOfClusterTrackMatchingOn())
385 {
386 Int_t trackIndex = fEMCALRecoUtils->GetMatchedTrackIndex(cluster->GetID());
387 //printf("track index %d, cluster ID %d \n ",trackIndex,cluster->GetID());
388
389 if(trackIndex < 0 )
390 {
391 printf("AliCalorimeterUtils::GetMatchedTrack() - Wrong track index %d, from recalculation\n", trackIndex);
392 }
393 else
394 {
395 track = dynamic_cast<AliVTrack*> (event->GetTrack(trackIndex));
396 }
397
398 return track ;
399
400 }
401
402 // Normal case, get info from ESD or AOD
403 // ESDs
404 if(!strcmp("AliESDCaloCluster",Form("%s",cluster->ClassName())))
405 {
406 Int_t iESDtrack = cluster->GetTrackMatchedIndex();
407
408 if(iESDtrack < 0 )
409 {
410 printf("AliCalorimeterUtils::GetMatchedTrack() - Wrong track index %d\n", index);
411 return 0x0;
412 }
413
414 track = dynamic_cast<AliVTrack*> (event->GetTrack(iESDtrack));
415
416 }
417 else // AODs
418 {
419 if(cluster->GetNTracksMatched() > 0 )
420 track = dynamic_cast<AliVTrack*>(cluster->GetTrackMatched(index));
421 }
422
423 return track ;
424
425}
426
cb5780f4 427//_____________________________________________________________________________________________________
765d44e7 428Int_t AliCalorimeterUtils::GetModuleNumber(AliAODPWG4Particle * particle, AliVEvent * inputEvent) const
429{
430 //Get the EMCAL/PHOS module number that corresponds to this particle
431
432 Int_t absId = -1;
433 if(particle->GetDetector()=="EMCAL"){
434 fEMCALGeo->GetAbsCellIdFromEtaPhi(particle->Eta(),particle->Phi(), absId);
435 if(fDebug > 2)
436 printf("AliCalorimeterUtils::GetModuleNumber(PWG4AOD) - EMCAL: cluster eta %f, phi %f, absid %d, SuperModule %d\n",
7cc7d3f8 437 particle->Eta(), particle->Phi()*TMath::RadToDeg(),absId, fEMCALGeo->GetSuperModuleNumber(absId));
765d44e7 438 return fEMCALGeo->GetSuperModuleNumber(absId) ;
439 }//EMCAL
440 else if(particle->GetDetector()=="PHOS"){
46a3cde6 441 // In case we use the MC reader, the input are TParticles,
442 // in this case use the corresponing method in PHOS Geometry to get the particle.
443 if(strcmp(inputEvent->ClassName(), "AliMCEvent") == 0 )
444 {
445 Int_t mod =-1;
446 Double_t z = 0., x=0.;
447 TParticle* primary = 0x0;
448 AliStack * stack = ((AliMCEvent*)inputEvent)->Stack();
449 if(stack) {
450 primary = stack->Particle(particle->GetCaloLabel(0));
451 }
452 else {
280e6766 453 Fatal("GetModuleNumber(PWG4AOD)", "Stack not available, stop!");
46a3cde6 454 }
898c9d44 455
456 if(primary){
457 fPHOSGeo->ImpactOnEmc(primary,mod,z,x) ;
458 }
459 else{
460 Fatal("GetModuleNumber(PWG4AOD)", "Primary not available, stop!");
461 }
46a3cde6 462 return mod;
463 }
464 // Input are ESDs or AODs, get the PHOS module number like this.
465 else{
2206e918 466 //FIXME
467 //AliVCluster *cluster = inputEvent->GetCaloCluster(particle->GetCaloLabel(0));
468 //return GetModuleNumber(cluster);
469 //MEFIX
470 return -1;
46a3cde6 471 }
765d44e7 472 }//PHOS
473
474 return -1;
475}
476
cb5780f4 477//_____________________________________________________________________
c8fe2783 478Int_t AliCalorimeterUtils::GetModuleNumber(AliVCluster * cluster) const
765d44e7 479{
280e6766 480 //Get the EMCAL/PHOS module number that corresponds to this cluster
765d44e7 481 TLorentzVector lv;
482 Double_t v[]={0.,0.,0.}; //not necessary to pass the real vertex.
9cbbc28b 483 if(!cluster){
484 if(fDebug > 1) printf("AliCalorimeterUtils::GetModuleNumber() - NUL Cluster, please check!!!");
485 return -1;
486 }
765d44e7 487 cluster->GetMomentum(lv,v);
488 Float_t phi = lv.Phi();
489 if(phi < 0) phi+=TMath::TwoPi();
490 Int_t absId = -1;
c8fe2783 491 if(cluster->IsEMCAL()){
765d44e7 492 fEMCALGeo->GetAbsCellIdFromEtaPhi(lv.Eta(),phi, absId);
493 if(fDebug > 2)
280e6766 494 printf("AliCalorimeterUtils::GetModuleNumber() - EMCAL: cluster eta %f, phi %f, absid %d, SuperModule %d\n",
7cc7d3f8 495 lv.Eta(), phi*TMath::RadToDeg(),absId, fEMCALGeo->GetSuperModuleNumber(absId));
765d44e7 496 return fEMCALGeo->GetSuperModuleNumber(absId) ;
497 }//EMCAL
c8fe2783 498 else if(cluster->IsPHOS()) {
765d44e7 499 Int_t relId[4];
500 if ( cluster->GetNCells() > 0) {
501 absId = cluster->GetCellAbsId(0);
502 if(fDebug > 2)
280e6766 503 printf("AliCalorimeterUtils::GetModuleNumber() - PHOS: cluster eta %f, phi %f, e %f, absId %d\n",
7cc7d3f8 504 lv.Eta(), phi*TMath::RadToDeg(), lv.E(), absId);
765d44e7 505 }
506 else return -1;
507
508 if ( absId >= 0) {
509 fPHOSGeo->AbsToRelNumbering(absId,relId);
510 if(fDebug > 2)
280e6766 511 printf("AliCalorimeterUtils::GetModuleNumber() - PHOS: Module %d\n",relId[0]-1);
765d44e7 512 return relId[0]-1;
513 }
514 else return -1;
515 }//PHOS
516
517 return -1;
518}
519
cb5780f4 520//___________________________________________________________________________________________________
521Int_t AliCalorimeterUtils::GetModuleNumberCellIndexes(const Int_t absId, const TString calo,
522 Int_t & icol, Int_t & irow, Int_t & iRCU) const
765d44e7 523{
524 //Get the EMCAL/PHOS module, columns, row and RCU number that corresponds to this absId
525 Int_t imod = -1;
526 if ( absId >= 0) {
527 if(calo=="EMCAL"){
528 Int_t iTower = -1, iIphi = -1, iIeta = -1;
529 fEMCALGeo->GetCellIndex(absId,imod,iTower,iIphi,iIeta);
530 fEMCALGeo->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,irow,icol);
280e6766 531 if(imod < 0 || irow < 0 || icol < 0 ) {
532 Fatal("GetModuleNumberCellIndexes()","Negative value for super module: %d, or cell icol: %d, or cell irow: %d, check EMCAL geometry name\n",imod,icol,irow);
533 }
534
765d44e7 535 //RCU0
536 if (0<=irow&&irow<8) iRCU=0; // first cable row
537 else if (8<=irow&&irow<16 && 0<=icol&&icol<24) iRCU=0; // first half;
538 //second cable row
539 //RCU1
540 else if(8<=irow&&irow<16 && 24<=icol&&icol<48) iRCU=1; // second half;
541 //second cable row
542 else if(16<=irow&&irow<24) iRCU=1; // third cable row
543
544 if (imod%2==1) iRCU = 1 - iRCU; // swap for odd=C side, to allow us to cable both sides the same
545 if (iRCU<0) {
280e6766 546 Fatal("GetModuleNumberCellIndexes()","Wrong EMCAL RCU number = %d\n", iRCU);
765d44e7 547 }
548
549 return imod ;
550 }//EMCAL
551 else{//PHOS
552 Int_t relId[4];
553 fPHOSGeo->AbsToRelNumbering(absId,relId);
554 irow = relId[2];
555 icol = relId[3];
556 imod = relId[0]-1;
557 iRCU= (Int_t)(relId[2]-1)/16 ;
558 //Int_t iBranch= (Int_t)(relid[3]-1)/28 ; //0 to 1
559 if (iRCU >= 4) {
280e6766 560 Fatal("GetModuleNumberCellIndexes()","Wrong PHOS RCU number = %d\n", iRCU);
765d44e7 561 }
562 return imod;
563 }//PHOS
564 }
565
566 return -1;
567}
568
7db7dcb6 569//___________________________________________________________________________________________
71e3889f 570Int_t AliCalorimeterUtils::GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells)
571{
572 // Find local maxima in cluster
573
574 const Int_t nc = cluster->GetNCells();
575 Int_t *absIdList = new Int_t [nc];
576 Float_t *maxEList = new Float_t[nc];
577
578 Int_t nMax = GetNumberOfLocalMaxima(cluster, cells, absIdList, maxEList);
579
580 delete [] absIdList;
581 delete [] maxEList;
582
583 return nMax;
584
585}
586
587//___________________________________________________________________________________________
7db7dcb6 588Int_t AliCalorimeterUtils::GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells,
589 Int_t *absIdList, Float_t *maxEList)
590{
591 // Find local maxima in cluster
9369a2b1 592
7db7dcb6 593 Int_t iDigitN = 0 ;
594 Int_t iDigit = 0 ;
595 Int_t absId1 = -1 ;
596 Int_t absId2 = -1 ;
597 const Int_t nCells = cluster->GetNCells();
598
599 TString calorimeter = "EMCAL";
600 if(!cluster->IsEMCAL()) calorimeter = "PHOS";
601
602 //printf("cluster : ncells %d \n",nCells);
9369a2b1 603 for(iDigit = 0; iDigit < nCells ; iDigit++)
604 {
7db7dcb6 605 absIdList[iDigit] = cluster->GetCellsAbsId()[iDigit] ;
9369a2b1 606 //Float_t en = cells->GetCellAmplitude(absIdList[iDigit]);
607 //RecalibrateCellAmplitude(en,calorimeter,absIdList[iDigit]);
608 //Int_t icol = -1, irow = -1, iRCU = -1;
609 //Int_t sm = GetModuleNumberCellIndexes(absIdList[iDigit], calorimeter, icol, irow, iRCU) ;
610 //printf("\t cell %d, id %d, sm %d, col %d, row %d, e %f\n", iDigit, absIdList[iDigit], sm, icol, irow, en );
7db7dcb6 611 }
612
9369a2b1 613 for(iDigit = 0 ; iDigit < nCells; iDigit++)
614 {
615 if(absIdList[iDigit]>=0)
616 {
617 absId1 = cluster->GetCellsAbsId()[iDigit];
7db7dcb6 618
619 Float_t en1 = cells->GetCellAmplitude(absId1);
620 RecalibrateCellAmplitude(en1,calorimeter,absId1);
9369a2b1 621
622 //printf("%d : absIDi %d, E %f\n",iDigit, absId1,en1);
7db7dcb6 623
9369a2b1 624 for(iDigitN = 0; iDigitN < nCells; iDigitN++)
625 {
626 absId2 = cluster->GetCellsAbsId()[iDigitN] ;
7db7dcb6 627
9369a2b1 628 if(absId2==-1 || absId2==absId1) continue;
7db7dcb6 629
9369a2b1 630 //printf("\t %d : absIDj %d\n",iDigitN, absId2);
7db7dcb6 631
632 Float_t en2 = cells->GetCellAmplitude(absId2);
633 RecalibrateCellAmplitude(en2,calorimeter,absId2);
9369a2b1 634
635 //printf("\t %d : absIDj %d, E %f\n",iDigitN, absId2,en2);
7db7dcb6 636
9369a2b1 637 if ( AreNeighbours(calorimeter, absId1, absId2) )
638 {
639 // printf("\t \t Neighbours \n");
640 if (en1 > en2 )
641 {
7db7dcb6 642 absIdList[iDigitN] = -1 ;
643 //printf("\t \t indexN %d not local max\n",iDigitN);
644 // but may be digit too is not local max ?
645 if(en1 < en2 + fLocMaxCutEDiff) {
9369a2b1 646 //printf("\t \t index %d not local max cause locMaxCutEDiff\n",iDigit);
7db7dcb6 647 absIdList[iDigit] = -1 ;
648 }
649 }
9369a2b1 650 else
651 {
7db7dcb6 652 absIdList[iDigit] = -1 ;
653 //printf("\t \t index %d not local max\n",iDigitN);
654 // but may be digitN too is not local max ?
655 if(en1 > en2 - fLocMaxCutEDiff)
656 {
657 absIdList[iDigitN] = -1 ;
9369a2b1 658 //printf("\t \t indexN %d not local max cause locMaxCutEDiff\n",iDigit);
7db7dcb6 659 }
660 }
9369a2b1 661 } // if Are neighbours
662 //else printf("\t \t NOT Neighbours \n");
7db7dcb6 663 } // while digitN
664 } // slot not empty
665 } // while digit
666
667 iDigitN = 0 ;
9369a2b1 668 for(iDigit = 0; iDigit < nCells; iDigit++)
669 {
670 if(absIdList[iDigit]>=0 )
671 {
7db7dcb6 672 absIdList[iDigitN] = absIdList[iDigit] ;
673 Float_t en = cells->GetCellAmplitude(absIdList[iDigit]);
674 RecalibrateCellAmplitude(en,calorimeter,absIdList[iDigit]);
675 if(en < fLocMaxCutE) continue; // Maxima only with seed energy at least
676 maxEList[iDigitN] = en ;
677 //printf("Local max %d, id %d, en %f\n", iDigit,absIdList[iDigitN],en);
678 iDigitN++ ;
679 }
680 }
681
9369a2b1 682 //printf("**********N maxima %d \n",iDigitN);
7db7dcb6 683 //for(Int_t imax = 0; imax < iDigitN; imax++) printf("imax %d, absId %d, Ecell %f\n",imax,absIdList[imax],maxEList[imax]);
684
685 return iDigitN ;
686
687}
688
cb5780f4 689//________________________________________
765d44e7 690void AliCalorimeterUtils::InitParameters()
691{
692 //Initialize the parameters of the analysis.
7db7dcb6 693
7cc7d3f8 694 fEMCALGeoName = "EMCAL_COMPLETEV1";
695 fPHOSGeoName = "PHOSgeo";
7db7dcb6 696
7cc7d3f8 697 fEMCALGeoMatrixSet = kFALSE;
698 fPHOSGeoMatrixSet = kFALSE;
7db7dcb6 699
7cc7d3f8 700 fRemoveBadChannels = kFALSE;
7db7dcb6 701
7cc7d3f8 702 fNCellsFromPHOSBorder = 0;
a5fb4114 703
7db7dcb6 704 fLocMaxCutE = 0.1 ;
705 fLocMaxCutEDiff = 0.0 ;
706
7cc7d3f8 707 // fMaskCellColumns = new Int_t[fNMaskCellColumns];
708 // fMaskCellColumns[0] = 6 ; fMaskCellColumns[1] = 7 ; fMaskCellColumns[2] = 8 ;
709 // fMaskCellColumns[3] = 35; fMaskCellColumns[4] = 36; fMaskCellColumns[5] = 37;
710 // fMaskCellColumns[6] = 12+AliEMCALGeoParams::fgkEMCALCols; fMaskCellColumns[7] = 13+AliEMCALGeoParams::fgkEMCALCols;
711 // fMaskCellColumns[8] = 40+AliEMCALGeoParams::fgkEMCALCols; fMaskCellColumns[9] = 41+AliEMCALGeoParams::fgkEMCALCols;
712 // fMaskCellColumns[10]= 42+AliEMCALGeoParams::fgkEMCALCols;
a5fb4114 713
765d44e7 714}
715
765d44e7 716
cb5780f4 717//_____________________________________________________
718void AliCalorimeterUtils::InitPHOSBadChannelStatusMap()
719{
765d44e7 720 //Init PHOS bad channels map
721 if(fDebug > 0 )printf("AliCalorimeterUtils::InitPHOSBadChannelStatusMap()\n");
722 //In order to avoid rewriting the same histograms
723 Bool_t oldStatus = TH1::AddDirectoryStatus();
724 TH1::AddDirectory(kFALSE);
7cc7d3f8 725
78219bac 726 fPHOSBadChannelMap = new TObjArray(5);
c5693f62 727 for (int i = 0; i < 5; i++)fPHOSBadChannelMap->Add(new TH2I(Form("PHOS_BadMap_mod%d",i),Form("PHOS_BadMap_mod%d",i), 64, 0, 64, 56, 0, 56));
7cc7d3f8 728
765d44e7 729 fPHOSBadChannelMap->SetOwner(kTRUE);
730 fPHOSBadChannelMap->Compress();
731
732 //In order to avoid rewriting the same histograms
733 TH1::AddDirectory(oldStatus);
734}
735
cb5780f4 736//______________________________________________________
737void AliCalorimeterUtils::InitPHOSRecalibrationFactors()
738{
09e819c9 739 //Init EMCAL recalibration factors
740 if(fDebug > 0 )printf("AliCalorimeterUtils::InitPHOSRecalibrationFactors()\n");
741 //In order to avoid rewriting the same histograms
742 Bool_t oldStatus = TH1::AddDirectoryStatus();
743 TH1::AddDirectory(kFALSE);
7cc7d3f8 744
78219bac 745 fPHOSRecalibrationFactors = new TObjArray(5);
c5693f62 746 for (int i = 0; i < 5; i++)fPHOSRecalibrationFactors->Add(new TH2F(Form("PHOSRecalFactors_Mod%d",i),Form("PHOSRecalFactors_Mod%d",i), 64, 0, 64, 56, 0, 56));
09e819c9 747 //Init the histograms with 1
748 for (Int_t m = 0; m < 5; m++) {
749 for (Int_t i = 0; i < 56; i++) {
750 for (Int_t j = 0; j < 64; j++) {
c5693f62 751 SetPHOSChannelRecalibrationFactor(m,j,i,1.);
09e819c9 752 }
753 }
754 }
755 fPHOSRecalibrationFactors->SetOwner(kTRUE);
756 fPHOSRecalibrationFactors->Compress();
757
758 //In order to avoid rewriting the same histograms
759 TH1::AddDirectory(oldStatus);
760}
761
762
cb5780f4 763//___________________________________________
765d44e7 764void AliCalorimeterUtils::InitEMCALGeometry()
765{
766 //Initialize EMCAL geometry if it did not exist previously
767 if (!fEMCALGeo){
a38a48f2 768 fEMCALGeo = AliEMCALGeometry::GetInstance(fEMCALGeoName);
765d44e7 769 if(fDebug > 0){
770 printf("AliCalorimeterUtils::InitEMCALGeometry()");
771 if (!gGeoManager) printf(" - Careful!, gGeoManager not loaded, load misalign matrices");
772 printf("\n");
773 }
774 }
775}
776
cb5780f4 777//__________________________________________
765d44e7 778void AliCalorimeterUtils::InitPHOSGeometry()
779{
780 //Initialize PHOS geometry if it did not exist previously
781 if (!fPHOSGeo){
782 fPHOSGeo = new AliPHOSGeoUtils(fPHOSGeoName);
783 if(fDebug > 0){
784 printf("AliCalorimeterUtils::InitPHOSGeometry()");
785 if (!gGeoManager) printf(" - Careful!, gGeoManager not loaded, load misalign matrices");
786 printf("\n");
787 }
788 }
789}
790
cb5780f4 791//_________________________________________________________
765d44e7 792void AliCalorimeterUtils::Print(const Option_t * opt) const
793{
7cc7d3f8 794
765d44e7 795 //Print some relevant parameters set for the analysis
796 if(! opt)
797 return;
7cc7d3f8 798
765d44e7 799 printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
800 printf("Remove Clusters with bad channels? %d\n",fRemoveBadChannels);
801 printf("Remove Clusters with max cell at less than %d cells from EMCAL border and %d cells from PHOS border\n",
7cc7d3f8 802 fEMCALRecoUtils->GetNumberOfCellsFromEMCALBorder(), fNCellsFromPHOSBorder);
247abff4 803 if(fEMCALRecoUtils->IsEMCALNoBorderAtEta0()) printf("Do not remove EMCAL clusters at Eta = 0\n");
09e819c9 804 printf("Recalibrate Clusters? %d\n",fRecalibration);
9584c261 805 printf("Recalculate Clusters Position? %d\n",fRecalculatePosition);
806 printf("Recalculate Clusters Energy? %d\n",fCorrectELinearity);
f2ccb5b8 807 printf("Matching criteria: dR < %2.2f[cm], dZ < %2.2f[cm]\n",fCutR,fCutZ);
7cc7d3f8 808
7db7dcb6 809 printf("Loc. Max. E > %2.2f\n", fLocMaxCutE);
810 printf("Loc. Max. E Diff > %2.2f\n", fLocMaxCutEDiff);
811
765d44e7 812 printf(" \n") ;
813}
814
cb5780f4 815//__________________________________________________________________
816Bool_t AliCalorimeterUtils::MaskFrameCluster(const Int_t iSM,
817 const Int_t ieta) const
818{
a5fb4114 819 //Check if cell is in one of the regions where we have significant amount
820 //of material in front. Only EMCAL
821
822 Int_t icol = ieta;
823 if(iSM%2) icol+=48; // Impair SM, shift index [0-47] to [48-96]
824
825 if (fNMaskCellColumns && fMaskCellColumns) {
826 for (Int_t imask = 0; imask < fNMaskCellColumns; imask++) {
827 if(icol==fMaskCellColumns[imask]) return kTRUE;
828 }
829 }
830
831 return kFALSE;
832
833}
834
9369a2b1 835//__________________________________________________________________________________________
7db7dcb6 836void AliCalorimeterUtils::RecalibrateCellAmplitude(Float_t & amp,
9369a2b1 837 const TString calo, const Int_t id) const
7db7dcb6 838{
839 //Recaculate cell energy if recalibration factor
840
841 Int_t icol = -1; Int_t irow = -1; Int_t iRCU = -1;
842 Int_t nModule = GetModuleNumberCellIndexes(id,calo, icol, irow, iRCU);
843
844 if (IsRecalibrationOn())
845 {
846 if(calo == "PHOS")
847 {
848 amp *= GetPHOSChannelRecalibrationFactor(nModule,icol,irow);
849 }
850 else
851 {
852 amp *= GetEMCALChannelRecalibrationFactor(nModule,icol,irow);
853 }
854 }
855}
856
9369a2b1 857//_________________________________________________________________________________
7db7dcb6 858void AliCalorimeterUtils::RecalibrateCellTime(Double_t & time,
859 const TString calo,
9369a2b1 860 const Int_t id, const Int_t bc) const
7db7dcb6 861{
862 // Recalculate time if time recalibration available for EMCAL
863 // not ready for PHOS
864
865 if(calo == "EMCAL" && GetEMCALRecoUtils()->IsTimeRecalibrationOn())
866 {
867 GetEMCALRecoUtils()->RecalibrateCellTime(id,bc,time);
868 }
869
870}
871
a5fb4114 872
cb5780f4 873//__________________________________________________________________________
874Float_t AliCalorimeterUtils::RecalibrateClusterEnergy(AliVCluster * cluster,
875 AliVCaloCells * cells)
876{
09e819c9 877 // Recalibrate the cluster energy, considering the recalibration map and the energy of the cells that compose the cluster.
7cc7d3f8 878
898c9d44 879 //Initialize some used variables
7db7dcb6 880 Float_t frac = 0., energy = 0.;
898c9d44 881
7db7dcb6 882 if(cells)
883 {
7cc7d3f8 884 //Get the cluster number of cells and list of absId, check what kind of cluster do we have.
7db7dcb6 885
7cc7d3f8 886 UShort_t * index = cluster->GetCellsAbsId() ;
887 Double_t * fraction = cluster->GetCellsAmplitudeFraction() ;
7db7dcb6 888
7cc7d3f8 889 Int_t ncells = cluster->GetNCells();
7db7dcb6 890
7cc7d3f8 891 TString calo = "EMCAL";
7db7dcb6 892 if(cluster->IsPHOS())
893 calo = "PHOS";
7cc7d3f8 894
895 //Loop on the cells, get the cell amplitude and recalibration factor, multiply and and to the new energy
896 for(Int_t icell = 0; icell < ncells; icell++){
7db7dcb6 897
898 Int_t absId = index[icell];
899
7cc7d3f8 900 frac = fraction[icell];
901 if(frac < 1e-3) frac = 1; //in case of EMCAL, this is set as 0, not used.
7db7dcb6 902
903 Float_t amp = cells->GetCellAmplitude(absId);
904 RecalibrateCellAmplitude(amp,calo, absId);
905
7cc7d3f8 906 if(fDebug>2)
7db7dcb6 907 printf("AliCalorimeterUtils::RecalibrateClusterEnergy() - recalibrate cell: %s, cell fraction %f, cell energy %f\n",
908 calo.Data(),frac,cells->GetCellAmplitude(absId));
7cc7d3f8 909
7db7dcb6 910 energy += amp*frac;
7cc7d3f8 911 }
912
913 if(fDebug>1)
914 printf("AliCalorimeterUtils::RecalibrateClusterEnergy() - Energy before %f, after %f\n",cluster->E(),energy);
898c9d44 915
916 }// cells available
7db7dcb6 917 else
918 {
898c9d44 919 Fatal("RecalibrateClusterEnergy()","Cells pointer does not exist!");
920 }
921
09e819c9 922 return energy;
09e819c9 923}
924
cb5780f4 925//________________________________________________________________________________
765d44e7 926void AliCalorimeterUtils::SetGeometryTransformationMatrices(AliVEvent* inputEvent)
927{
928 //Set the calorimeters transformation matrices
7cc7d3f8 929
765d44e7 930 //Get the EMCAL transformation geometry matrices from ESD
3b13c34c 931 if(!fEMCALGeoMatrixSet && fEMCALGeo){
932 if(fLoadEMCALMatrices){
c5693f62 933 printf("AliCalorimeterUtils::SetGeometryTransformationMatrices() - Load user defined EMCAL geometry matrices\n");
3b13c34c 934 for(Int_t mod=0; mod < (fEMCALGeo->GetEMCGeometry())->GetNumberOfSuperModules(); mod++){
935 if(fEMCALMatrix[mod]){
936 if(fDebug > 1)
937 fEMCALMatrix[mod]->Print();
938 fEMCALGeo->SetMisalMatrix(fEMCALMatrix[mod],mod) ;
939 }
940 }//SM loop
941 fEMCALGeoMatrixSet = kTRUE;//At least one, so good
942
943 }//Load matrices
944 else if (!gGeoManager) {
7cc7d3f8 945
3b13c34c 946 if(fDebug > 1)
947 printf(" AliCalorimeterUtils::SetGeometryTransformationMatrices() - Load EMCAL misalignment matrices. \n");
948 if(!strcmp(inputEvent->GetName(),"AliESDEvent")) {
949 for(Int_t mod=0; mod < (fEMCALGeo->GetEMCGeometry())->GetNumberOfSuperModules(); mod++){
7cc7d3f8 950 //printf("Load ESD matrix %d, %p\n",mod,((AliESDEvent*)inputEvent)->GetEMCALMatrix(mod));
4b892846 951 if(((AliESDEvent*)inputEvent)->GetEMCALMatrix(mod)) {
952 fEMCALGeo->SetMisalMatrix(((AliESDEvent*)inputEvent)->GetEMCALMatrix(mod),mod) ;
3b13c34c 953 }
954 }// loop over super modules
c5693f62 955
3b13c34c 956 fEMCALGeoMatrixSet = kTRUE;//At least one, so good
957
958 }//ESD as input
959 else {
960 if(fDebug > 1)
961 printf("AliCalorimeterUtils::SetGeometryTransformationMatrices() - Setting of EMCAL transformation matrixes for AODs not implemented yet. \n Import geometry.root file\n");
962 }//AOD as input
963 }//Get matrix from data
04131edb 964 else if(gGeoManager){
965 fEMCALGeoMatrixSet = kTRUE;
966 }
765d44e7 967 }//EMCAL geo && no geoManager
c5693f62 968
765d44e7 969 //Get the PHOS transformation geometry matrices from ESD
3b13c34c 970 if(!fPHOSGeoMatrixSet && fPHOSGeo){
c5693f62 971
3b13c34c 972 if(fLoadPHOSMatrices){
c5693f62 973 printf("AliCalorimeterUtils::SetGeometryTransformationMatrices() - Load user defined PHOS geometry matrices\n");
974 for(Int_t mod = 0 ; mod < 5 ; mod++){
3b13c34c 975 if(fPHOSMatrix[mod]){
c5693f62 976 if(fDebug > 1 )
3b13c34c 977 fPHOSMatrix[mod]->Print();
dbf54f1e 978 fPHOSGeo->SetMisalMatrix(fPHOSMatrix[mod],mod) ;
3b13c34c 979 }
980 }//SM loop
981 fPHOSGeoMatrixSet = kTRUE;//At least one, so good
c5693f62 982
3b13c34c 983 }//Load matrices
984 else if (!gGeoManager) {
985 if(fDebug > 1)
986 printf(" AliCalorimeterUtils::SetGeometryTransformationMatrices() - Load PHOS misalignment matrices. \n");
765d44e7 987 if(!strcmp(inputEvent->GetName(),"AliESDEvent")) {
dbf54f1e 988 for(Int_t mod = 0; mod < 5; mod++){
4b892846 989 if( ((AliESDEvent*)inputEvent)->GetPHOSMatrix(mod)) {
765d44e7 990 //printf("PHOS: mod %d, matrix %p\n",mod, ((AliESDEvent*)inputEvent)->GetPHOSMatrix(mod));
4b892846 991 fPHOSGeo->SetMisalMatrix( ((AliESDEvent*)inputEvent)->GetPHOSMatrix(mod),mod) ;
765d44e7 992 }
3b13c34c 993 }// loop over modules
994 fPHOSGeoMatrixSet = kTRUE; //At least one so good
765d44e7 995 }//ESD as input
996 else {
997 if(fDebug > 1)
998 printf("AliCalorimeterUtils::SetGeometryTransformationMatrices() - Setting of EMCAL transformation matrixes for AODs not implemented yet. \n Import geometry.root file\n");
3b13c34c 999 }//AOD as input
1000 }// get matrix from data
04131edb 1001 else if(gGeoManager){
1002 fPHOSGeoMatrixSet = kTRUE;
1003 }
765d44e7 1004 }//PHOS geo and geoManager was not set
c5693f62 1005
765d44e7 1006}
1007
cb5780f4 1008//__________________________________________________________________________________________
1009void AliCalorimeterUtils::RecalculateClusterPosition(AliVCaloCells* cells, AliVCluster* clu)
1010{
9584c261 1011
1012 //Recalculate EMCAL cluster position
1013
19db8f8c 1014 fEMCALRecoUtils->RecalculateClusterPosition((AliEMCALGeometry*)fEMCALGeo, cells,clu);
7cc7d3f8 1015
9584c261 1016}
cb5780f4 1017
1018//________________________________________________________________________________
1019void AliCalorimeterUtils::RecalculateClusterTrackMatching(AliVEvent * event,
1020 TObjArray* clusterArray)
1021{
1022 //Recalculate track matching
1023
1024 if (fRecalculateMatching) {
1025 fEMCALRecoUtils->FindMatches(event,clusterArray,fEMCALGeo) ;
1026 //AliESDEvent* esdevent = dynamic_cast<AliESDEvent*> (event);
1027 //if(esdevent){
1028 // fEMCALRecoUtils->SetClusterMatchedToTrack(esdevent) ;
1029 // fEMCALRecoUtils->SetTracksMatchedToCluster(esdevent) ;
1030 //}
1031 }
1032}