Korrektion for
[u/mrichter/AliRoot.git] / PWG4 / UserTasks / EmcalTasks / AliAnalysisTaskEMCALClusterizeFast.cxx
CommitLineData
2f7259cf 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 **************************************************************************/
15
16/* $Id$ */
17
18// --- Root ---
19#include <TClonesArray.h>
20#include <TGeoManager.h>
21#include <TObjArray.h>
22#include <TString.h>
23#include <TTree.h>
7a7d5a64 24
25// --- AliRoot ---
2f7259cf 26#include "AliAODCaloCluster.h"
27#include "AliAODEvent.h"
28#include "AliAnalysisManager.h"
29#include "AliCDBEntry.h"
30#include "AliCDBManager.h"
31#include "AliCaloCalibPedestal.h"
32#include "AliEMCALAfterBurnerUF.h"
33#include "AliEMCALCalibData.h"
34#include "AliEMCALClusterizerNxN.h"
35#include "AliEMCALClusterizerv1.h"
3786256f 36#include "AliEMCALClusterizerv2.h"
7a7d5a64 37#include "AliEMCALClusterizerFixedWindow.h"
2f7259cf 38#include "AliEMCALDigit.h"
39#include "AliEMCALGeometry.h"
40#include "AliEMCALRecParam.h"
41#include "AliEMCALRecPoint.h"
42#include "AliEMCALRecoUtils.h"
43#include "AliESDEvent.h"
6b7ed7bd 44#include "AliInputEventHandler.h"
2f7259cf 45#include "AliLog.h"
46
47#include "AliAnalysisTaskEMCALClusterizeFast.h"
48
49ClassImp(AliAnalysisTaskEMCALClusterizeFast)
50
51//________________________________________________________________________
2431b20f 52AliAnalysisTaskEMCALClusterizeFast::AliAnalysisTaskEMCALClusterizeFast()
53 : AliAnalysisTaskSE(),
349bf69e 54 fRun(-1),
2431b20f 55 fDigitsArr(0),
56 fClusterArr(0),
57 fRecParam(0),
58 fClusterizer(0),
59 fUnfolder(0),
60 fJustUnfold(kFALSE),
61 fGeomName(),
62 fGeomMatrixSet(kFALSE),
63 fLoadGeomMatrices(kFALSE),
64 fOCDBpath(),
65 fCalibData(0),
66 fPedestalData(0),
67 fOutputAODBranch(0),
68 fOutputAODBrName(),
69 fRecoUtils(0),
70 fLoadCalib(0),
4cf9204b 71 fLoadPed(0),
e50a444f 72 fAttachClusters(1),
95f69c66 73 fRecalibOnly(0),
7a7d5a64 74 fSubBackground(0),
75 fCreatePattern(0),
e50a444f 76 fOverwrite(0),
7a7d5a64 77 fNewClusterArrayName("newCaloClusters"),
78 fNPhi(4),
79 fNEta(4),
3c56da8f 80 fShiftPhi(2),
81 fShiftEta(2),
82 fTRUShift(0),
e93ec1f7 83 fClusterizeFastORs(0)
2431b20f 84{
85 // Constructor
86}
87
88//________________________________________________________________________
2f7259cf 89AliAnalysisTaskEMCALClusterizeFast::AliAnalysisTaskEMCALClusterizeFast(const char *name)
90 : AliAnalysisTaskSE(name),
349bf69e 91 fRun(-1),
2f7259cf 92 fDigitsArr(0),
93 fClusterArr(0),
94 fRecParam(new AliEMCALRecParam),
95 fClusterizer(0),
96 fUnfolder(0),
97 fJustUnfold(kFALSE),
98 fGeomName("EMCAL_FIRSTYEARV1"),
99 fGeomMatrixSet(kFALSE),
100 fLoadGeomMatrices(kFALSE),
101 fOCDBpath(),
102 fCalibData(0),
103 fPedestalData(0),
104 fOutputAODBranch(0),
105 fOutputAODBrName(),
10d33986 106 fRecoUtils(0),
107 fLoadCalib(0),
4cf9204b 108 fLoadPed(0),
e50a444f 109 fAttachClusters(1),
95f69c66 110 fRecalibOnly(0),
7a7d5a64 111 fSubBackground(0),
112 fCreatePattern(0),
e50a444f 113 fOverwrite(0),
7a7d5a64 114 fNewClusterArrayName("newCaloClusters"),
115 fNPhi(4),
116 fNEta(4),
3c56da8f 117 fShiftPhi(2),
118 fShiftEta(2),
119 fTRUShift(0),
e93ec1f7 120 fClusterizeFastORs(0)
2f7259cf 121{
122 // Constructor
123
0a7eb283 124 fBranchNames = "ESD:AliESDHeader.,AliESDRun.,EMCALCells.,EMCALTrigger. AOD:header,emcalCells";
95f69c66 125 for(Int_t i = 0; i < 12; ++i)
2f7259cf 126 fGeomMatrix[i] = 0;
127}
128
129//________________________________________________________________________
130AliAnalysisTaskEMCALClusterizeFast::~AliAnalysisTaskEMCALClusterizeFast()
131{
132 // Destructor.
133
134 delete fDigitsArr;
135 delete fClusterizer;
136 delete fUnfolder;
137 delete fRecoUtils;
138}
139
140//-------------------------------------------------------------------
141void AliAnalysisTaskEMCALClusterizeFast::UserCreateOutputObjects()
142{
143 // Create output objects.
144
145 if (!fOutputAODBrName.IsNull()) {
146 fOutputAODBranch = new TClonesArray("AliAODCaloCluster", 0);
147 fOutputAODBranch->SetName(fOutputAODBrName);
148 AddAODBranch("TClonesArray", &fOutputAODBranch);
149 AliInfo(Form("Created Branch: %s",fOutputAODBrName.Data()));
150 }
151}
152
153//________________________________________________________________________
154void AliAnalysisTaskEMCALClusterizeFast::UserExec(Option_t *)
155{
156 // Main loop, called for each event
157
158 // remove the contents of output list set in the previous event
159 if (fOutputAODBranch)
160 fOutputAODBranch->Clear("C");
161
162 AliESDEvent *esdevent = dynamic_cast<AliESDEvent*>(InputEvent());
163 AliAODEvent *aodevent = dynamic_cast<AliAODEvent*>(InputEvent());
164
165 if (!esdevent&&!aodevent) {
166 Error("UserExec","Event not available");
167 return;
168 }
169
170 LoadBranches();
6b7ed7bd 171
172 UInt_t offtrigger = 0;
173 if (esdevent) {
9809ed8c 174 UInt_t mask1 = esdevent->GetESDRun()->GetDetectorsInDAQ();
175 UInt_t mask2 = esdevent->GetESDRun()->GetDetectorsInReco();
176 Bool_t desc1 = (mask1 >> 18) & 0x1;
177 Bool_t desc2 = (mask2 >> 18) & 0x1;
178 if (desc1==0 || desc2==0) { //AliDAQ::OfflineModuleName(180=="EMCAL"
179 AliError(Form("EMCAL not in DAQ/RECO: %u (%u)/%u (%u)",
180 mask1, esdevent->GetESDRun()->GetDetectorsInReco(),
181 mask2, esdevent->GetESDRun()->GetDetectorsInDAQ()));
6b7ed7bd 182 return;
183 }
184 AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
185 offtrigger = ((AliInputEventHandler*)(am->GetInputEventHandler()))->IsEventSelected();
186 } else if (aodevent) {
187 offtrigger = aodevent->GetHeader()->GetOfflineTrigger();
188 }
189 if (offtrigger & AliVEvent::kFastOnly) {
190 AliWarning(Form("EMCAL not in fast only partition"));
191 return;
192 }
2f7259cf 193
194 Init();
195
196 if (fJustUnfold) {
197 AliWarning("Unfolding not implemented");
84ccad86 198 return;
199 }
200
95f69c66 201 FillDigitsArray();
84ccad86 202
95f69c66 203 if (fRecalibOnly) {
204 UpdateCells();
205 return; // not requested to run clusterizer
84ccad86 206 }
7099ec08 207
95f69c66 208 Clusterize();
209 UpdateCells();
210 UpdateClusters();
2431b20f 211
95f69c66 212 if (fOutputAODBranch)
213 RecPoints2Clusters(fOutputAODBranch);
2431b20f 214}
215
216//________________________________________________________________________
95f69c66 217void AliAnalysisTaskEMCALClusterizeFast::Clusterize()
2431b20f 218{
95f69c66 219 // Clusterize
7099ec08 220
95f69c66 221 if (fSubBackground) {
222 fClusterizer->SetInputCalibrated(kTRUE);
223 fClusterizer->SetCalibrationParameters(0);
2f7259cf 224 }
d3b5a5ec 225
95f69c66 226 fClusterizer->Digits2Clusters("");
227 if (fSubBackground) {
4889ed8b 228 if (fCalibData) {
229 fClusterizer->SetInputCalibrated(kFALSE);
230 fClusterizer->SetCalibrationParameters(fCalibData);
231 }
4cf9204b 232 }
4cf9204b 233}
234
235//________________________________________________________________________
95f69c66 236void AliAnalysisTaskEMCALClusterizeFast::FillDigitsArray()
2f7259cf 237{
6265e793 238 // Fill digits array
239
240 fDigitsArr->Clear("C");
241
5133b922 242 if (fCreatePattern) { // Fill digits from a pattern
7a7d5a64 243 AliEMCALGeometry *fGeom = AliEMCALGeometry::GetInstance(fGeomName);
7a7d5a64 244 Int_t maxd = fGeom->GetNCells() / 4;
6265e793 245 for (Int_t idigit = 0; idigit < maxd; idigit++){
7a7d5a64 246 if (idigit % 24 == 12) idigit += 12;
247 AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigitsArr->New(idigit));
248 digit->SetId(idigit * 4);
249 digit->SetTime(600);
250 digit->SetTimeR(600);
251 digit->SetIndexInList(idigit);
252 digit->SetType(AliEMCALDigit::kHG);
253 digit->SetAmplitude(0.1);
b0e354fe 254 }
06ca320f 255
5133b922 256 } else if (fClusterizeFastORs) { // Fill digits from FastORs
6265e793 257
258 AliEMCALGeometry *fGeom = AliEMCALGeometry::GetInstance(fGeomName);
06ca320f 259
6265e793 260 AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
261 if (!esd){
262 AliError("Cannot get the ESD event");
263 return;
264 }
265
266 AliESDCaloTrigger *triggers = esd->GetCaloTrigger("EMCAL");
267
268 if (!triggers || !(triggers->GetEntries() > 0))
269 return;
270
271 Int_t idigit = 0;
272 triggers->Reset();
273
5133b922 274 while ((triggers->Next())) {
6265e793 275 Float_t triggerAmplitude = 0;
276 triggers->GetAmplitude(triggerAmplitude);
277 if (triggerAmplitude <= 0)
278 continue;
279
280 Int_t triggerTime = 0;
281 Int_t ntimes = 0;
282 triggers->GetNL0Times(ntimes);
5133b922 283 if (ntimes > 0) {
6265e793 284 Int_t trgtimes[25];
285 triggers->GetL0Times(trgtimes);
286 triggerTime = trgtimes[0];
287 }
288
289 Int_t triggerCol = 0, triggerRow = 0;
290 triggers->GetPosition(triggerCol, triggerRow);
291
292 Int_t find = -1;
293 fGeom->GetAbsFastORIndexFromPositionInEMCAL(triggerCol, triggerRow, find);
294
295 if (find<0)
296 continue;
297
298 Int_t cidx[4] = {-1};
299 Bool_t ret = fGeom->GetCellIndexFromFastORIndex(find, cidx);
300
301 if (!ret)
302 continue;
303
5133b922 304 for (Int_t idxpos = 0; idxpos < 4; idxpos++) {
6265e793 305 Int_t triggerNumber = cidx[idxpos];
306 AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigitsArr->New(idigit));
307 digit->SetId(triggerNumber);
308 digit->SetTime(triggerTime);
309 digit->SetTimeR(triggerTime);
310 digit->SetIndexInList(idigit);
311 digit->SetType(AliEMCALDigit::kHG);
312 digit->SetAmplitude(triggerAmplitude);
313 idigit++;
314 }
315 }
06ca320f 316
317 } else { // Fill digits from cells.
7a7d5a64 318
7a7d5a64 319 AliVCaloCells *cells = InputEvent()->GetEMCALCells();
320 Double_t avgE = 0; // for background subtraction
321 Int_t ncells = cells->GetNumberOfCells();
322 for (Int_t icell = 0, idigit = 0; icell < ncells; ++icell) {
323 Double_t cellAmplitude=0, cellTime=0;
324 Short_t cellNumber=0;
325 if (cells->GetCell(icell, cellNumber, cellAmplitude, cellTime) != kTRUE)
326 break;
327 AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigitsArr->New(idigit));
328 digit->SetId(cellNumber);
329 digit->SetTime(cellTime);
330 digit->SetTimeR(cellTime);
331 digit->SetIndexInList(idigit);
332 digit->SetType(AliEMCALDigit::kHG);
333 if (fRecalibOnly||fSubBackground) {
334 Float_t energy = cellAmplitude;
335 Float_t time = cellTime;
336 fClusterizer->Calibrate(energy,time,cellNumber);
95f69c66 337 digit->SetAmplitude(energy);
7a7d5a64 338 avgE += energy;
339 } else {
340 digit->SetAmplitude(cellAmplitude);
95f69c66 341 }
7a7d5a64 342 idigit++;
b0e354fe 343 }
7a7d5a64 344
345 if (fSubBackground) {
346 avgE /= AliEMCALGeometry::GetInstance(fGeomName)->GetNumberOfSuperModules()*48*24;
347 Int_t ndigis = fDigitsArr->GetEntries();
348 for (Int_t i = 0; i < ndigis; ++i) {
349 AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigitsArr->At(i));
350 Double_t energy = digit->GetAmplitude() - avgE;
351 if (energy<=0.001) {
352 digit->SetAmplitude(0);
353 } else {
354 digit->SetAmplitude(energy);
355 }
356 }
357 }
06ca320f 358 }
2f7259cf 359}
360
361//________________________________________________________________________________________
95f69c66 362void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
4cf9204b 363{
364 // Cluster energy, global position, cells and their amplitude fractions are restored.
365
95f69c66 366 Bool_t esdobjects = 0;
367 if (strcmp(clus->GetClass()->GetName(),"AliESDCaloCluster")==0)
368 esdobjects = 1;
369
b98487bc 370 AliVCaloCells *cells = InputEvent()->GetEMCALCells();
371 AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance(fGeomName);
372
e93ec1f7 373 AliDebug(1, Form("total no of clusters %d", fClusterArr->GetEntriesFast()));
374
4cf9204b 375 Int_t Ncls = fClusterArr->GetEntriesFast();
376 for(Int_t i=0, nout=clus->GetEntries(); i < Ncls; ++i) {
377 AliEMCALRecPoint *recpoint = static_cast<AliEMCALRecPoint*>(fClusterArr->At(i));
378 Int_t ncells_true = 0;
379 const Int_t ncells = recpoint->GetMultiplicity();
380 UShort_t absIds[ncells];
381 Double32_t ratios[ncells];
382 Int_t *dlist = recpoint->GetDigitsList();
383 Float_t *elist = recpoint->GetEnergiesList();
384 for (Int_t c = 0; c < ncells; ++c) {
385 AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigitsArr->At(dlist[c]));
386 absIds[ncells_true] = digit->GetId();
387 ratios[ncells_true] = elist[c]/digit->GetAmplitude();
84ccad86 388 ++ncells_true;
4cf9204b 389 }
390
391 if (ncells_true < 1) {
392 AliWarning("Skipping cluster with no cells");
393 continue;
394 }
395
396 // calculate new cluster position
397 TVector3 gpos;
4cf9204b 398 recpoint->GetGlobalPosition(gpos);
84ccad86 399 Float_t g[3];
4cf9204b 400 gpos.GetXYZ(g);
401
e93ec1f7 402 AliDebug(1, Form("energy %f", recpoint->GetEnergy()));
403
95f69c66 404 AliVCluster *c = static_cast<AliVCluster*>(clus->New(nout++));
4cf9204b 405 c->SetType(AliVCluster::kEMCALClusterv1);
406 c->SetE(recpoint->GetEnergy());
407 c->SetPosition(g);
408 c->SetNCells(ncells_true);
4cf9204b 409 c->SetDispersion(recpoint->GetDispersion());
84ccad86 410 c->SetEmcCpvDistance(-1); //not yet implemented
4cf9204b 411 c->SetChi2(-1); //not yet implemented
412 c->SetTOF(recpoint->GetTime()) ; //time-of-flight
413 c->SetNExMax(recpoint->GetNExMax()); //number of local maxima
414 Float_t elipAxis[2];
415 recpoint->GetElipsAxis(elipAxis);
e93ec1f7 416 c->SetM02(elipAxis[0]*elipAxis[0]);
417 c->SetM20(elipAxis[1]*elipAxis[1]);
418 if (fPedestalData) {
b98487bc 419 c->SetDistanceToBadChannel(recpoint->GetDistanceToBadTower());
e93ec1f7 420 }
421 else {
422 if (fRecoUtils && fRecoUtils->IsBadChannelsRemovalSwitchedOn()) {
423 fRecoUtils->RecalculateClusterDistanceToBadChannel(geom, cells, c);
424 }
b98487bc 425 }
e93ec1f7 426
95f69c66 427 if (esdobjects) {
428 AliESDCaloCluster *cesd = static_cast<AliESDCaloCluster*>(c);
429 cesd->SetCellsAbsId(absIds);
430 cesd->SetCellsAmplitudeFraction(ratios);
06ca320f 431 cesd->SetID(recpoint->GetUniqueID());
95f69c66 432 } else {
433 AliAODCaloCluster *caod = static_cast<AliAODCaloCluster*>(c);
434 caod->SetCellsAbsId(absIds);
435 caod->SetCellsAmplitudeFraction(ratios);
436 }
84ccad86 437 }
438
439 AliESDEvent *esdevent = dynamic_cast<AliESDEvent*>(InputEvent());
440 if (!esdevent)
441 return;
442 if (!fRecoUtils)
443 return;
444
95f69c66 445 AliAnalysisManager::GetAnalysisManager()->LoadBranch("Tracks");
84ccad86 446 fRecoUtils->FindMatches(esdevent,clus);
447
95f69c66 448 if (!esdobjects) {
449 Int_t Nclus = clus->GetEntries();
450 for(Int_t i=0; i < Nclus; ++i) {
451 AliAODCaloCluster *c = static_cast<AliAODCaloCluster*>(clus->At(i));
452 Int_t trackIndex = fRecoUtils->GetMatchedTrackIndex(i);
06ca320f 453 if (trackIndex >= 0) {
95f69c66 454 Float_t dR, dZ;
455 fRecoUtils->GetMatchedResiduals(i,dR, dZ);
e93ec1f7 456 c->AddTrackMatched(0x0); //esdevent->GetTrack(trackIndex));
95f69c66 457 c->SetTrackDistance(dR,dZ); // not implemented
458 c->SetEmcCpvDistance(dR);
459 c->SetChi2(dZ);
06ca320f 460 if (DebugLevel() > 1)
95f69c66 461 AliInfo(Form("Matched Track index %d to new cluster %d\n",trackIndex,i));
462 }
2f7259cf 463 }
95f69c66 464 } else {
84ccad86 465 Int_t Nclus = clus->GetEntries();
466 for(Int_t i=0; i < Nclus; ++i) {
467 AliESDCaloCluster *c = static_cast<AliESDCaloCluster*>(clus->At(i));
2f7259cf 468 Int_t trackIndex = fRecoUtils->GetMatchedTrackIndex(i);
06ca320f 469 if (trackIndex >= 0) {
84ccad86 470 Float_t dR, dZ;
471 fRecoUtils->GetMatchedResiduals(i,dR, dZ);
472 c->SetTrackDistance(dR,dZ);
473 c->SetEmcCpvDistance(dR); //to be consistent with AODs
474 c->SetChi2(dZ); //to be consistent with AODs
4cf9204b 475 TArrayI tm(1,&trackIndex);
476 c->AddTracksMatched(tm);
06ca320f 477 if (DebugLevel() > 1)
2f7259cf 478 AliInfo(Form("Matched Track index %d to new cluster %d\n",trackIndex,i));
479 }
480 }
481 }
482}
483
95f69c66 484//________________________________________________________________________
485void AliAnalysisTaskEMCALClusterizeFast::UpdateCells()
486{
487 // Update cells in case re-calibration was done.
488
489 if (!fCalibData&&!fSubBackground)
490 return;
491
492 AliVCaloCells *cells = InputEvent()->GetEMCALCells();
493 Int_t ncells = cells->GetNumberOfCells();
494 Int_t ndigis = fDigitsArr->GetEntries();
495
496 if (ncells!=ndigis) {
497 cells->DeleteContainer();
498 cells->CreateContainer(ndigis);
499 }
500 for (Int_t idigit = 0; idigit < ndigis; ++idigit) {
501 AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigitsArr->At(idigit));
502 Double_t cellAmplitude = digit->GetCalibAmp();
503 Short_t cellNumber = digit->GetId();
504 Double_t cellTime = digit->GetTime();
505 cells->SetCell(idigit, cellNumber, cellAmplitude, cellTime);
506 }
507}
508
509//________________________________________________________________________
510void AliAnalysisTaskEMCALClusterizeFast::UpdateClusters()
511{
512 // Update cells in case re-calibration was done.
7a7d5a64 513
95f69c66 514 if (!fAttachClusters)
515 return;
7a7d5a64 516
06ca320f 517 TClonesArray *clus = 0;
7a7d5a64 518
e50a444f 519 if (fOverwrite) {
7a7d5a64 520 clus = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject("caloClusters"));
521 if (!clus)
522 clus = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject("CaloClusters"));
06ca320f 523 if (!clus)
7a7d5a64 524 return;
525
526 Int_t nents = clus->GetEntries();
527 for (Int_t i=0;i<nents;++i) {
528 AliVCluster *c = static_cast<AliVCluster*>(clus->At(i));
529 if (!c)
530 continue;
531 if (c->IsEMCAL())
532 delete clus->RemoveAt(i);
533 }
06ca320f 534 } else {
7a7d5a64 535 clus = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fNewClusterArrayName));
06ca320f 536 if (!clus) {
7a7d5a64 537 clus = new TClonesArray("AliESDCaloCluster");
538 clus->SetName(fNewClusterArrayName);
539 InputEvent()->AddObject(clus);
06ca320f 540 } else {
0a7eb283 541 clus->Delete();
7a7d5a64 542 }
543 }
544
95f69c66 545 RecPoints2Clusters(clus);
546}
547
2f7259cf 548//________________________________________________________________________________________
549void AliAnalysisTaskEMCALClusterizeFast::Init()
550{
551 //Select clusterization/unfolding algorithm and set all the needed parameters
01bc1ce8 552
2f7259cf 553 AliVEvent * event = InputEvent();
554 if (!event) {
555 AliWarning("Event not available!!!");
556 return;
557 }
558
559 if (event->GetRunNumber()==fRun)
560 return;
561 fRun = event->GetRunNumber();
562
563 if (fJustUnfold){
564 // init the unfolding afterburner
565 delete fUnfolder;
566 fUnfolder = new AliEMCALAfterBurnerUF(fRecParam->GetW0(),fRecParam->GetLocMaxCut());
567 return;
568 }
569
2f7259cf 570 AliEMCALGeometry *geometry = AliEMCALGeometry::GetInstance(fGeomName);
571 if (!geometry) {
572 AliFatal("Geometry not available!!!");
573 return;
574 }
575
576 if (!fGeomMatrixSet) {
577 if (fLoadGeomMatrices) {
e51bc3f5 578 for(Int_t mod=0; mod < geometry->GetNumberOfSuperModules(); ++mod) {
06ca320f 579 if (fGeomMatrix[mod]){
580 if (DebugLevel() > 2)
2f7259cf 581 fGeomMatrix[mod]->Print();
582 geometry->SetMisalMatrix(fGeomMatrix[mod],mod);
583 }
584 }
29b496d5 585 } else { // get matrix from file (work around bug in aliroot)
2f7259cf 586 for(Int_t mod=0; mod < geometry->GetEMCGeometry()->GetNumberOfSuperModules(); ++mod) {
29b496d5 587 const TGeoHMatrix *gm = 0;
441c4d3c 588 AliESDEvent *esdevent = dynamic_cast<AliESDEvent*>(event);
29b496d5 589 if (esdevent) {
590 gm = esdevent->GetEMCALMatrix(mod);
591 } else {
592 AliAODHeader *aodheader = dynamic_cast<AliAODHeader*>(event->GetHeader());
593 if (aodheader) {
594 gm = aodheader->GetEMCALMatrix(mod);
595 }
596 }
597 if (gm) {
06ca320f 598 if (DebugLevel() > 2)
29b496d5 599 gm->Print();
600 geometry->SetMisalMatrix(gm,mod);
2f7259cf 601 }
602 }
603 }
604 fGeomMatrixSet=kTRUE;
605 }
606
607 // setup digit array if needed
608 if (!fDigitsArr) {
609 fDigitsArr = new TClonesArray("AliEMCALDigit", 1000);
610 fDigitsArr->SetOwner(1);
611 }
612
613 // then setup clusterizer
614 delete fClusterizer;
615 if (fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerv1)
616 fClusterizer = new AliEMCALClusterizerv1(geometry);
06ca320f 617 else if (fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerNxN) {
2f7259cf 618 AliEMCALClusterizerNxN *clusterizer = new AliEMCALClusterizerNxN(geometry);
3c56da8f 619 clusterizer->SetNRowDiff(fRecParam->GetNRowDiff());
620 clusterizer->SetNColDiff(fRecParam->GetNColDiff());
621 fClusterizer = clusterizer;
06ca320f 622 } else if (fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerv2)
3c56da8f 623 fClusterizer = new AliEMCALClusterizerv2(geometry);
06ca320f 624 else if (fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerFW){
7a7d5a64 625 AliEMCALClusterizerFixedWindow *clusterizer = new AliEMCALClusterizerFixedWindow(geometry);
0fda97fe 626 clusterizer->SetNphi(fNPhi);
627 clusterizer->SetNeta(fNEta);
628 clusterizer->SetShiftPhi(fShiftPhi);
629 clusterizer->SetShiftEta(fShiftEta);
3c56da8f 630 clusterizer->SetTRUshift(fTRUShift);
7a7d5a64 631 fClusterizer = clusterizer;
632 }
633 else{
2f7259cf 634 AliFatal(Form("Clusterizer < %d > not available", fRecParam->GetClusterizerFlag()));
635 }
636 fClusterizer->InitParameters(fRecParam);
01bc1ce8 637
638 if ((!fCalibData&&fLoadCalib) || (!fPedestalData&&fLoadPed)) {
639 AliCDBManager *cdb = AliCDBManager::Instance();
640 if (!cdb->IsDefaultStorageSet() && !fOCDBpath.IsNull())
641 cdb->SetDefaultStorage(fOCDBpath);
642 if (fRun!=cdb->GetRun())
643 cdb->SetRun(fRun);
644 }
349bf69e 645 if (!fCalibData&&fLoadCalib&&fRun>0) {
2f7259cf 646 AliCDBEntry *entry = static_cast<AliCDBEntry*>(AliCDBManager::Instance()->Get("EMCAL/Calib/Data"));
647 if (entry)
648 fCalibData = static_cast<AliEMCALCalibData*>(entry->GetObject());
649 if (!fCalibData)
650 AliFatal("Calibration parameters not found in CDB!");
651 }
349bf69e 652 if (!fPedestalData&&fLoadPed&&fRun>0) {
2f7259cf 653 AliCDBEntry *entry = static_cast<AliCDBEntry*>(AliCDBManager::Instance()->Get("EMCAL/Calib/Pedestals"));
654 if (entry)
655 fPedestalData = static_cast<AliCaloCalibPedestal*>(entry->GetObject());
656 }
10d33986 657 if (fCalibData) {
658 fClusterizer->SetInputCalibrated(kFALSE);
659 fClusterizer->SetCalibrationParameters(fCalibData);
10d33986 660 } else {
661 fClusterizer->SetInputCalibrated(kTRUE);
662 }
e93ec1f7 663 fClusterizer->SetCaloCalibPedestal(fPedestalData);
10d33986 664 fClusterizer->SetJustClusters(kTRUE);
2f7259cf 665 fClusterizer->SetDigitsArr(fDigitsArr);
666 fClusterizer->SetOutput(0);
667 fClusterArr = const_cast<TObjArray *>(fClusterizer->GetRecPoints());
668}