3 // Analysis task for neutral pions (into two gammas).
5 // Author: C.Loizides, E.Braidot
7 #include "AliAnalysisTaskEMCALPi0PbPb.h"
10 #include <TClonesArray.h>
12 #include <TGeoGlobalMagField.h>
16 #include <TLorentzVector.h>
22 #include "AliAODEvent.h"
23 #include "AliAODMCParticle.h"
24 #include "AliAODVertex.h"
25 #include "AliAnalysisManager.h"
26 #include "AliAnalysisTaskEMCALClusterizeFast.h"
27 #include "AliCDBManager.h"
28 #include "AliCentrality.h"
29 #include "AliEMCALDigit.h"
30 #include "AliEMCALGeometry.h"
31 #include "AliEMCALRecPoint.h"
32 #include "AliEMCALRecoUtils.h"
33 #include "AliESDCaloTrigger.h"
34 #include "AliESDEvent.h"
35 #include "AliESDUtils.h"
36 #include "AliESDVertex.h"
37 #include "AliESDtrack.h"
38 #include "AliESDtrackCuts.h"
39 #include "AliEventplane.h"
40 #include "AliGeomManager.h"
41 #include "AliInputEventHandler.h"
43 #include "AliMCEvent.h"
44 #include "AliMCParticle.h"
46 #include "AliMultiplicity.h"
48 #include "AliTrackerBase.h"
49 #include "AliTriggerAnalysis.h"
55 ClassImp(AliAnalysisTaskEMCALPi0PbPb)
57 //________________________________________________________________________
58 AliAnalysisTaskEMCALPi0PbPb::AliAnalysisTaskEMCALPi0PbPb()
59 : AliAnalysisTaskSE(),
74 fGeoName("EMCAL_FIRSTYEARV1"),
120 fHTclsBeforeCuts(0x0),
121 fHTclsAfterCuts(0x0),
129 fHCellFreqNoCut(0x0),
130 fHCellFreqCut100M(0x0),
131 fHCellFreqCut300M(0x0),
134 fHClustEccentricity(0),
136 fHClustEnergyPt(0x0),
137 fHClustEnergySigma(0x0),
138 fHClustSigmaSigma(0x0),
139 fHClustNCellEnergyRatio(0x0),
140 fHClustEnergyNCell(0x0),
156 //________________________________________________________________________
157 AliAnalysisTaskEMCALPi0PbPb::AliAnalysisTaskEMCALPi0PbPb(const char *name)
158 : AliAnalysisTaskSE(name),
173 fGeoName("EMCAL_FIRSTYEARV1"),
219 fHTclsBeforeCuts(0x0),
220 fHTclsAfterCuts(0x0),
228 fHCellFreqNoCut(0x0),
229 fHCellFreqCut100M(0x0),
230 fHCellFreqCut300M(0x0),
233 fHClustEccentricity(0),
235 fHClustEnergyPt(0x0),
236 fHClustEnergySigma(0x0),
237 fHClustSigmaSigma(0x0),
238 fHClustNCellEnergyRatio(0x0),
239 fHClustEnergyNCell(0x0),
254 DefineOutput(1, TList::Class());
255 fBranchNames="ESD:AliESDRun.,AliESDHeader.,PrimaryVertex.,SPDVertex.,TPCVertex.,EMCALCells.,Tracks,EMCALTrigger.,SPDPileupVertices,TrkPileupVertices "
256 "AOD:header,vertices,emcalCells,tracks";
259 //________________________________________________________________________
260 AliAnalysisTaskEMCALPi0PbPb::~AliAnalysisTaskEMCALPi0PbPb()
264 if (!AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
265 delete fOutput; fOutput = 0;
267 delete fPtRanges; fPtRanges = 0;
268 fGeom = 0; // do not delete geometry when using instance
269 delete fReco; fReco = 0;
270 delete fTrClassNamesArr;
272 delete fSelPrimTracks;
274 delete [] fHColuRowE;
275 delete [] fHCellMult;
276 delete [] fHCellFreqNoCut;
277 delete [] fHCellFreqCut100M;
278 delete [] fHCellFreqCut300M;
281 //________________________________________________________________________
282 void AliAnalysisTaskEMCALPi0PbPb::UserCreateOutputObjects()
284 // Create user objects here.
286 cout << "AliAnalysisTaskEMCALPi0PbPb: Input settings" << endl;
287 cout << " fCentVar: " << fCentVar << endl;
288 cout << " fCentFrom: " << fCentFrom << endl;
289 cout << " fCentTo: " << fCentTo << endl;
290 cout << " fVtxZMin: " << fVtxZMin << endl;
291 cout << " fVtxZMax: " << fVtxZMax << endl;
292 cout << " fUseQualFlag: " << fUseQualFlag << endl;
293 cout << " fClusName: \"" << fClusName << "\"" << endl;
294 cout << " fDoNtuple: " << fDoNtuple << endl;
295 cout << " fDoAfterburner: " << fDoAfterburner << endl;
296 cout << " fAsymMax: " << fAsymMax << endl;
297 cout << " fNminCells: " << fNminCells << endl;
298 cout << " fMinE: " << fMinE << endl;
299 cout << " fMinErat: " << fMinErat << endl;
300 cout << " fMinEcc: " << fMinEcc << endl;
301 cout << " fGeoName: \"" << fGeoName << "\"" << endl;
302 cout << " fMinNClusPerTr: " << fMinNClusPerTr << endl;
303 cout << " fIsoDist: " << fIsoDist << endl;
304 cout << " fTrClassNames: \"" << fTrClassNames << "\"" << endl;
305 cout << " fTrCuts: " << fTrCuts << endl;
306 cout << " fPrimTrCuts: " << fPrimTrCuts << endl;
307 cout << " fDoTrMatGeom: " << fDoTrMatGeom << endl;
308 cout << " fTrainMode: " << fTrainMode << endl;
309 cout << " fMarkCells: " << fMarkCells << endl;
310 cout << " fMinL0Time: " << fMinL0Time << endl;
311 cout << " fMaxL0Time: " << fMaxL0Time << endl;
312 cout << " fMcMode: " << fMcMode << endl;
313 cout << " fEmbedMode: " << fEmbedMode << endl;
314 cout << " fGeom: " << fGeom << endl;
315 cout << " fReco: " << fReco << endl;
316 cout << " fTrigName: " << fTrigName << endl;
317 cout << " fDoPSel: " << fDoPSel << endl;
320 fGeom = AliEMCALGeometry::GetInstance(fGeoName);
322 if (fGeom->GetMatrixForSuperModule(0))
323 fIsGeoMatsSet = kTRUE;
326 fReco = new AliEMCALRecoUtils();
327 fTrClassNamesArr = fTrClassNames.Tokenize(" ");
328 fOutput = new TList();
329 fOutput->SetOwner(1);
330 fSelTracks = new TObjArray;
331 fSelPrimTracks = new TObjArray;
334 TFile *f = OpenFile(1);
335 TDirectory::TContext context(f);
337 f->SetCompressionLevel(2);
338 fNtuple = new TTree(Form("tree%.0fto%.0f",fCentFrom,fCentTo), "StandaloneTree");
339 fNtuple->SetDirectory(f);
341 fNtuple->SetAutoFlush(-2*1024*1024);
342 fNtuple->SetAutoSave(0);
344 fNtuple->SetAutoFlush(-32*1024*1024);
345 fNtuple->SetAutoSave(0);
348 fHeader = new AliStaHeader;
349 fNtuple->Branch("header", &fHeader, 16*1024, 99);
350 fPrimVert = new AliStaVertex;
351 fNtuple->Branch("primv", &fPrimVert, 16*1024, 99);
352 fSpdVert = new AliStaVertex;
353 fNtuple->Branch("spdv", &fSpdVert, 16*1024, 99);
354 fTpcVert = new AliStaVertex;
355 fNtuple->Branch("tpcv", &fTpcVert, 16*1024, 99);
356 if (TClass::GetClass("AliStaCluster"))
357 TClass::GetClass("AliStaCluster")->IgnoreTObjectStreamer();
358 fClusters = new TClonesArray("AliStaCluster");
359 fNtuple->Branch("clusters", &fClusters, 8*16*1024, 99);
360 if (TClass::GetClass("AliStaTrigger"))
361 TClass::GetClass("AliStaTrigger")->IgnoreTObjectStreamer();
362 fTriggers = new TClonesArray("AliStaTrigger");
363 fNtuple->Branch("l0prim", &fTriggers, 16*1024, 99);
364 if (fMcMode||fEmbedMode) {
365 if (TClass::GetClass("AliStaPart"))
366 TClass::GetClass("AliStaPart")->IgnoreTObjectStreamer();
367 fMcParts = new TClonesArray("AliStaPart");
368 fNtuple->Branch("mcparts", &fMcParts, 8*16*1024, 99);
373 AliEMCALEMCGeometry *emc = fGeom->GetEMCGeometry();
374 Double_t phimin = emc->GetArm1PhiMin()*TMath::DegToRad();
375 Double_t phimax = emc->GetArm1PhiMax()*TMath::DegToRad();
378 Bool_t th1 = TH1::GetDefaultSumw2();
379 TH1::SetDefaultSumw2(kTRUE);
380 Bool_t th2 = TH2::GetDefaultSumw2();
381 TH2::SetDefaultSumw2(kTRUE);
382 fHCuts = new TH1F("hEventCuts","",5,0.5,5.5);
383 fHCuts->GetXaxis()->SetBinLabel(1,"All");
384 fHCuts->GetXaxis()->SetBinLabel(2,"PS");
385 fHCuts->GetXaxis()->SetBinLabel(3,Form("%s: %.0f-%.0f",fCentVar.Data(),fCentFrom,fCentTo));
386 fHCuts->GetXaxis()->SetBinLabel(4,"QFlag");
387 fHCuts->GetXaxis()->SetBinLabel(5,Form("zvtx: %.0f-%.0f",fVtxZMin,fVtxZMax));
388 fOutput->Add(fHCuts);
389 fHVertexZ = new TH1F("hVertexZBeforeCut","",100,-25,25);
390 fHVertexZ->SetXTitle("z [cm]");
391 fOutput->Add(fHVertexZ);
392 fHVertexZ2 = new TH1F("hVertexZAfterCut","",100,-25,25);
393 fHVertexZ2->SetXTitle("z [cm]");
394 fOutput->Add(fHVertexZ2);
395 fHCent = new TH1F("hCentBeforeCut","",102,-1,101);
396 fHCent->SetXTitle(fCentVar.Data());
397 fOutput->Add(fHCent);
398 fHCentQual = new TH1F("hCentAfterCut","",102,-1,101);
399 fHCentQual->SetXTitle(fCentVar.Data());
400 fOutput->Add(fHCentQual);
401 fHTclsBeforeCuts = new TH1F("hTclsBeforeCuts","",fTrClassNamesArr->GetEntries(),0.5,0.5+fTrClassNamesArr->GetEntries());
402 fHTclsAfterCuts = new TH1F("hTclsAfterCuts","",fTrClassNamesArr->GetEntries(),0.5,0.5+fTrClassNamesArr->GetEntries());
403 for (Int_t i = 0; i<fTrClassNamesArr->GetEntries(); ++i) {
404 const char *name = fTrClassNamesArr->At(i)->GetName();
405 fHTclsBeforeCuts->GetXaxis()->SetBinLabel(1+i,name);
406 fHTclsAfterCuts->GetXaxis()->SetBinLabel(1+i,name);
408 fOutput->Add(fHTclsBeforeCuts);
409 fOutput->Add(fHTclsAfterCuts);
411 // histograms for cells
412 Int_t nsm = fGeom->GetEMCGeometry()->GetNumberOfSuperModules();
413 fHColuRow = new TH2*[nsm];
414 fHColuRowE = new TH2*[nsm];
415 fHCellMult = new TH1*[nsm];
416 for (Int_t i = 0; i<nsm; ++i) {
417 fHColuRow[i] = new TH2F(Form("hColRow_Mod%d",i),"",48,0,48,24,0.,24);
418 fHColuRow[i]->SetTitle(Form("Module %d: Occupancy", i));
419 fHColuRow[i]->SetXTitle("col (i#eta)");
420 fHColuRow[i]->SetYTitle("row (i#phi)");
421 fHColuRowE[i] = new TH2F(Form("hColRowE_Mod%d", i),"",48,0,48,24,0,24);
422 fHColuRowE[i]->SetTitle(Form("Module %d: Cell energy",i));
423 fHColuRowE[i]->SetXTitle("col (i#eta)");
424 fHColuRowE[i]->SetYTitle("row (i#phi)");
425 fHCellMult[i] = new TH1F(Form("hCellMult_Mod%d",i),"",1000,0,1000);
426 fHCellMult[i]->SetTitle(Form("Module %d: Cell multiplicity",i));
427 fHCellMult[i]->SetXTitle("# of cells");
428 fOutput->Add(fHColuRow[i]);
429 fOutput->Add(fHColuRowE[i]);
430 fOutput->Add(fHCellMult[i]);
432 fHCellE = new TH1F("hCellE","",250,0.,25.);
433 fHCellE->SetXTitle("E_{cell} [GeV]");
434 fOutput->Add(fHCellE);
435 fHCellH = new TH1F ("hCellHighestE","",250,0.,25.);
436 fHCellH->SetXTitle("E^{max}_{cell} [GeV]");
437 fOutput->Add(fHCellH);
438 fHCellM = new TH1F ("hCellMeanEperHitCell","",250,0.,2.5);
439 fHCellM->SetXTitle("#LT E_{cell}#GT [GeV]");
440 fOutput->Add(fHCellM);
441 fHCellM2 = new TH1F ("hCellMeanEperAllCells","",250,0.,1);
442 fHCellM2->SetXTitle("1/N_{cells} #Sigma E_{cell} [GeV]");
443 fOutput->Add(fHCellM2);
445 fHCellFreqNoCut = new TH1*[nsm];
446 fHCellFreqCut100M = new TH1*[nsm];
447 fHCellFreqCut300M = new TH1*[nsm];
448 fHCellFreqE = new TH1*[nsm];
449 for (Int_t i = 0; i<nsm; ++i){
450 Double_t lbin = i*24*48-0.5;
451 Double_t hbin = lbin+24*48;
452 fHCellFreqNoCut[i] = new TH1F(Form("hCellFreqNoCut_SM%d",i),
453 Form("Frequency SM%d (no cut);id;#",i), 1152, lbin, hbin);
454 fHCellFreqCut100M[i] = new TH1F(Form("hCellFreqCut100M_SM%d",i),
455 Form("Frequency SM%d (>0.1GeV);id;#",i), 1152, lbin, hbin);
456 fHCellFreqCut300M[i] = new TH1F(Form("hCellFreqCut300M_SM%d",i),
457 Form("Frequency SM%d (>0.3GeV);id;#",i), 1152, lbin, hbin);
458 fHCellFreqE[i] = new TH1F(Form("hCellFreqE_SM%d",i),
459 Form("Frequency SM%d (E weighted);id;#",i), 1152, lbin, hbin);
460 fOutput->Add(fHCellFreqNoCut[i]);
461 fOutput->Add(fHCellFreqCut100M[i]);
462 fOutput->Add(fHCellFreqCut300M[i]);
463 fOutput->Add(fHCellFreqE[i]);
465 if (!fMarkCells.IsNull()) {
466 fHCellCheckE = new TH1*[24*48*nsm];
467 memset(fHCellCheckE,0,24*48*nsm*sizeof(TH1*));
468 TObjArray *cells = fMarkCells.Tokenize(" ");
469 Int_t n = cells->GetEntries();
470 Int_t *tcs = new Int_t[n];
471 for (Int_t i=0;i<n;++i) {
472 TString name(cells->At(i)->GetName());
475 for (Int_t i = 0; i<n; ++i) {
478 fHCellCheckE[i] = new TH1F(Form("hCellE_id%d",c), Form("Cell %d;E [GeV/c];#",c), 1000, 0, 10);
479 fOutput->Add(fHCellCheckE[i]);
486 // histograms for clusters
488 fHClustEccentricity = new TH1F("hClustEccentricity","",100,-0.1,1.1);
489 fHClustEccentricity->SetXTitle("#epsilon_{C}");
490 fOutput->Add(fHClustEccentricity);
491 fHClustEtaPhi = new TH2F("hClustEtaPhi","",500,-0.8,0.8,100*nsm,phimin,phimax);
492 fHClustEtaPhi->SetXTitle("#eta");
493 fHClustEtaPhi->SetYTitle("#varphi");
494 fOutput->Add(fHClustEtaPhi);
495 fHClustEnergyPt = new TH2F("hClustEnergyPt","",250,0,50,250,0,50);
496 fHClustEnergyPt->SetXTitle("E [GeV]");
497 fHClustEnergyPt->SetYTitle("p_{T} [GeV/c]");
498 fOutput->Add(fHClustEnergyPt);
499 fHClustEnergySigma = new TH2F("hClustEnergySigma","",100,0,100,500,0,50);
500 fHClustEnergySigma->SetXTitle("E_{C} * #sigma_{max} [GeV*cm]");
501 fHClustEnergySigma->SetYTitle("E_{C} [GeV]");
502 fOutput->Add(fHClustEnergySigma);
503 fHClustSigmaSigma = new TH2F("hClustSigmaSigma","",500,0,50,500,0,50);
504 fHClustSigmaSigma->SetXTitle("#lambda_{0} [cm]");
505 fHClustSigmaSigma->SetYTitle("#sigma_{max} [cm]");
506 fOutput->Add(fHClustSigmaSigma);
507 fHClustNCellEnergyRatio = new TH2F("hClustNCellEnergyRatio","",27,-0.5,26.5,101,-0.05,1.05);
508 fHClustNCellEnergyRatio->SetXTitle("N_{cells}");
509 fHClustNCellEnergyRatio->SetYTitle("E^{max}_{cell}/E_{clus}");
510 fOutput->Add(fHClustNCellEnergyRatio);
511 fHClustEnergyNCell = new TH2F("hClustEnergyNCell","",200,0,100,50,0,50);
512 fHClustEnergyNCell->SetXTitle("E_{clus}");
513 fHClustEnergyNCell->SetYTitle("N_{cells}");
514 fOutput->Add(fHClustEnergyNCell);
517 // histograms for primary tracks
518 fHPrimTrackPt = new TH1F("hPrimTrackPt",";p_{T} [GeV/c]",500,0,50);
519 fOutput->Add(fHPrimTrackPt);
520 fHPrimTrackEta = new TH1F("hPrimTrackEta",";#eta",40,-2,2);
521 fOutput->Add(fHPrimTrackEta);
522 fHPrimTrackPhi = new TH1F("hPrimTrackPhi",";#varPhi [rad]",63,0,6.3);
523 fOutput->Add(fHPrimTrackPhi);
525 // histograms for track matching
527 fHMatchDr = new TH1F("hMatchDrDist",";dR [cm]",500,0,200);
528 fOutput->Add(fHMatchDr);
529 fHMatchDz = new TH1F("hMatchDzDist",";dZ [cm]",500,-100,100);
530 fOutput->Add(fHMatchDz);
531 fHMatchEp = new TH1F("hMatchEpDist",";E/p",100,0,10);
532 fOutput->Add(fHMatchEp);
535 // histograms for pion candidates
537 fHPionEtaPhi = new TH2F("hPionEtaPhi","",100,-0.8,0.8,100*nsm,phimin,phimax);
538 fHPionEtaPhi->SetXTitle("#eta_{#gamma#gamma}");
539 fHPionEtaPhi->SetYTitle("#varphi_{#gamma#gamma}");
540 fOutput->Add(fHPionEtaPhi);
541 fHPionMggPt = new TH2F("hPionMggPt","",1000,0,2,100,0,20.0);
542 fHPionMggPt->SetXTitle("M_{#gamma#gamma} [GeV/c^{2}]");
543 fHPionMggPt->SetYTitle("p_{T}^{#gamma#gamma} [GeV/c]");
544 fOutput->Add(fHPionMggPt);
545 fHPionMggAsym = new TH2F("hPionMggAsym","",1000,0,2,100,0,1);
546 fHPionMggAsym->SetXTitle("M_{#gamma#gamma} [GeV/c^{2}]");
547 fHPionMggAsym->SetYTitle("Z_{#gamma#gamma} [GeV]");
548 fOutput->Add(fHPionMggAsym);
549 fHPionMggDgg = new TH2F("hPionMggDgg","",1000,0,2,100,0,10);
550 fHPionMggDgg->SetXTitle("M_{#gamma#gamma} [GeV/c^{2}]");
551 fHPionMggDgg->SetYTitle("opening angle [grad]");
552 fOutput->Add(fHPionMggDgg);
553 const Int_t nbins = 20;
554 Double_t xbins[nbins] = {0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10,12.5,15,20,25,50};
555 fPtRanges = new TAxis(nbins-1,xbins);
556 for (Int_t i = 0; i<=nbins; ++i) {
557 fHPionInvMasses[i] = new TH1F(Form("hPionInvMass%d",i),"",1000,0,2);
558 fHPionInvMasses[i]->SetXTitle("M_{#gamma#gamma} [GeV/c^{2}]");
560 fHPionInvMasses[i]->SetTitle(Form("0 < p_{T}^{#gamma#gamma} <%.1f",xbins[0]));
562 fHPionInvMasses[i]->SetTitle(Form("p_{T}^{#gamma#gamma} > 50"));
564 fHPionInvMasses[i]->SetTitle(Form("%.1f < p_{T}^{#gamma#gamma} <%.1f",xbins[i-1],xbins[i]));
565 fOutput->Add(fHPionInvMasses[i]);
569 TH1::SetDefaultSumw2(th1);
570 TH2::SetDefaultSumw2(th2);
571 PostData(1, fOutput);
574 //________________________________________________________________________
575 void AliAnalysisTaskEMCALPi0PbPb::UserExec(Option_t *)
577 // Called for each event.
582 AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
583 fEsdEv = dynamic_cast<AliESDEvent*>(InputEvent());
584 UInt_t offtrigger = 0;
586 am->LoadBranch("AliESDRun.");
587 am->LoadBranch("AliESDHeader.");
588 UInt_t mask1 = fEsdEv->GetESDRun()->GetDetectorsInDAQ();
589 UInt_t mask2 = fEsdEv->GetESDRun()->GetDetectorsInReco();
590 Bool_t desc1 = (mask1 >> 18) & 0x1;
591 Bool_t desc2 = (mask2 >> 18) & 0x1;
592 if (desc1==0 || desc2==0) { //AliDAQ::OfflineModuleName(18)=="EMCAL"
593 AliError(Form("EMCAL not in DAQ/RECO: %u (%u)/%u (%u)",
594 mask1, fEsdEv->GetESDRun()->GetDetectorsInReco(),
595 mask2, fEsdEv->GetESDRun()->GetDetectorsInDAQ()));
598 offtrigger = ((AliInputEventHandler*)(am->GetInputEventHandler()))->IsEventSelected();
600 fAodEv = dynamic_cast<AliAODEvent*>(InputEvent());
602 AliFatal("Neither ESD nor AOD event found");
605 am->LoadBranch("header");
606 offtrigger = ((AliVAODHeader*)fAodEv->GetHeader())->GetOfflineTrigger();
608 if (!fMcMode && (offtrigger & AliVEvent::kFastOnly)) {
609 AliWarning(Form("EMCAL not in fast only partition"));
612 if (fDoTrMatGeom && !AliGeomManager::GetGeometry()) { // get geometry
613 AliWarning("Accessing geometry from OCDB, this is not very efficient!");
614 AliCDBManager *cdb = AliCDBManager::Instance();
615 if (!cdb->IsDefaultStorageSet())
616 cdb->SetDefaultStorage("raw://");
617 Int_t runno = InputEvent()->GetRunNumber();
618 if (runno != cdb->GetRun())
620 AliGeomManager::LoadGeometry();
623 if (!AliGeomManager::GetGeometry()&&!fIsGeoMatsSet) { // set misalignment matrices (stored in first event)
624 Int_t nsm = fGeom->GetEMCGeometry()->GetNumberOfSuperModules();
625 for (Int_t i=0; i<nsm; ++i) {
626 const TGeoHMatrix *geom = 0;
628 geom = fEsdEv->GetESDRun()->GetEMCALMatrix(i);
630 AliAODHeader * aodheader = dynamic_cast<AliAODHeader*>(fAodEv->GetHeader());
631 if(!aodheader) AliFatal("Not a standard AOD");
632 geom = aodheader->GetEMCALMatrix(i);
637 fGeom->SetMisalMatrix(geom,i);
639 fIsGeoMatsSet = kTRUE;
642 if (!TGeoGlobalMagField::Instance()->GetField()) { // construct field map
644 const AliESDRun *erun = fEsdEv->GetESDRun();
645 AliMagF *field = AliMagF::CreateFieldMap(erun->GetCurrentL3(),
646 erun->GetCurrentDip(),
649 erun->GetBeamEnergy(),
650 erun->GetBeamType());
651 TGeoGlobalMagField::Instance()->SetField(field);
653 Double_t pol = -1; //polarity
654 Double_t be = -1; //beam energy
655 AliMagF::BeamType_t btype = AliMagF::kBeamTypepp;
656 Int_t runno = fAodEv->GetRunNumber();
657 if (runno>=136851 && runno<138275) {
660 btype = AliMagF::kBeamTypeAA;
661 } else if (runno>=138275 && runno<=139517) {
664 btype = AliMagF::kBeamTypeAA;
666 AliError(Form("Do not know the bfield parameters for run %d! Using defaults!!!", runno));
668 TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", pol, pol, AliMagF::k5kG, btype, be));
676 AliESDHeader *h = dynamic_cast<AliESDHeader*>(InputEvent()->GetHeader());
678 trgclasses = fEsdEv->GetFiredTriggerClasses();
680 AliAODHeader *h2 = dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader());
682 trgclasses = h2->GetFiredTriggerClasses();
684 for (Int_t i = 0; i<fTrClassNamesArr->GetEntries(); ++i) {
685 const char *name = fTrClassNamesArr->At(i)->GetName();
686 TRegexp regexp(name);
687 if (trgclasses.Contains(regexp))
688 fHTclsBeforeCuts->Fill(1+i);
691 if (fDoPSel && offtrigger==0)
696 const AliCentrality *centP = InputEvent()->GetCentrality();
697 Double_t cent = centP->GetCentralityPercentileUnchecked(fCentVar);
699 if (cent<fCentFrom||cent>fCentTo)
705 if (centP->GetQuality()>0)
709 fHCentQual->Fill(cent);
713 am->LoadBranch("PrimaryVertex.");
714 am->LoadBranch("SPDVertex.");
715 am->LoadBranch("TPCVertex.");
717 fAodEv = dynamic_cast<AliAODEvent*>(InputEvent());
718 am->LoadBranch("vertices");
722 const AliVVertex *vertex = InputEvent()->GetPrimaryVertex();
726 fHVertexZ->Fill(vertex->GetZ());
728 if(vertex->GetZ()<fVtxZMin||vertex->GetZ()>fVtxZMax)
732 fHVertexZ2->Fill(vertex->GetZ());
734 // count number of accepted events
737 for (Int_t i = 0; i<fTrClassNamesArr->GetEntries(); ++i) {
738 const char *name = fTrClassNamesArr->At(i)->GetName();
739 TRegexp regexp(name);
740 if (trgclasses.Contains(regexp))
741 fHTclsAfterCuts->Fill(1+i);
744 fRecPoints = 0; // will be set if fClusName is given and AliAnalysisTaskEMCALClusterizeFast is used
745 fDigits = 0; // will be set if fClusName is given and AliAnalysisTaskEMCALClusterizeFast is used
746 fEsdClusters = 0; // will be set if ESD input used and if fRecPoints are not set or if clusters are attached
747 fEsdCells = 0; // will be set if ESD input used
748 fAodClusters = 0; // will be set if AOD input used and if fRecPoints are not set or if clusters are attached
749 // or if fClusName is given and AliAnalysisTaskEMCALClusterizeFast in AOD output mode
750 fAodCells = 0; // will be set if AOD input used
752 // deal with special output from AliAnalysisTaskEMCALClusterizeFast first
753 Bool_t overwrite = 0;
754 Bool_t clusattached = 0;
755 Bool_t recalibrated = 0;
756 if (1 && !fClusName.IsNull()) {
757 AliAnalysisTaskEMCALClusterizeFast *cltask = 0;
758 TObjArray *ts = am->GetTasks();
759 cltask = dynamic_cast<AliAnalysisTaskEMCALClusterizeFast*>(ts->FindObject(fClusName));
760 if (cltask && cltask->GetClusters()) {
761 fRecPoints = cltask->GetClusters();
762 fDigits = cltask->GetDigits();
763 clusattached = cltask->GetAttachClusters();
764 overwrite = cltask->GetOverwrite();
765 if (cltask->GetCalibData()!=0)
766 recalibrated = kTRUE;
769 if (1 && !fClusName.IsNull()) {
772 l = AODEvent()->GetList();
774 l = fAodEv->GetList();
776 fAodClusters = dynamic_cast<TClonesArray*>(l->FindObject(fClusName));
780 if (fEsdEv) { // ESD input mode
781 if (1 && (!fRecPoints||clusattached)) {
782 if (!clusattached && !overwrite)
783 am->LoadBranch("CaloClusters");
784 TList *l = fEsdEv->GetList();
786 fEsdClusters = dynamic_cast<TClonesArray*>(l->FindObject(fClusName));
788 fEsdClusters = dynamic_cast<TClonesArray*>(l->FindObject("CaloClusters"));
793 am->LoadBranch("EMCALCells.");
794 fEsdCells = fEsdEv->GetEMCALCells();
796 } else if (fAodEv) { // AOD input mode
797 if (1 && (!fAodClusters || clusattached)) {
799 am->LoadBranch("caloClusters");
800 TList *l = fAodEv->GetList();
802 fAodClusters = dynamic_cast<TClonesArray*>(l->FindObject("caloClusters"));
807 am->LoadBranch("emcalCells");
808 fAodCells = fAodEv->GetEMCALCells();
811 AliFatal("Impossible to not have either pointer to ESD or AOD event");
815 AliDebug(2,Form("fRecPoints set: %p", fRecPoints));
816 AliDebug(2,Form("fDigits set: %p", fDigits));
817 AliDebug(2,Form("fEsdClusters set: %p", fEsdClusters));
818 AliDebug(2,Form("fEsdCells set: %p", fEsdCells));
819 AliDebug(2,Form("fAodClusters set: %p", fAodClusters));
820 AliDebug(2,Form("fAodCells set: %p", fAodCells));
824 ClusterAfterburner();
843 fSelPrimTracks->Clear();
852 PostData(1, fOutput);
855 //________________________________________________________________________
856 void AliAnalysisTaskEMCALPi0PbPb::Terminate(Option_t *)
858 // Terminate called at the end of analysis.
861 TFile *f = OpenFile(1);
862 TDirectory::TContext context(f);
867 AliInfo(Form("%s: Accepted %lld events ", GetName(), fNEvs));
870 //________________________________________________________________________
871 void AliAnalysisTaskEMCALPi0PbPb::CalcCaloTriggers()
873 // Calculate triggers
876 return; // information not available in AOD
883 if (fTrigName.Length()<=0)
886 TClonesArray *arr = dynamic_cast<TClonesArray*>(fEsdEv->FindListObject(fTrigName));
888 AliError(Form("Could not get array with name %s", fTrigName.Data()));
892 Int_t nNumberOfCaloClusters = arr->GetEntries();
893 for(Int_t j = 0, ntrigs = 0; j < nNumberOfCaloClusters; ++j) {
894 AliVCluster *cl = dynamic_cast<AliVCluster*>(arr->At(j));
901 AliStaTrigger *trignew = static_cast<AliStaTrigger*>(fTriggers->New(ntrigs++));
902 Float_t pos[3] = {0,0,0};
903 cl->GetPosition(pos);
905 trignew->fE = cl->E();
906 trignew->fEta = vpos.Eta();
907 trignew->fPhi = vpos.Phi();
909 GetMaxCellEnergy(cl, id);
910 trignew->fIdMax = id;
914 //________________________________________________________________________
915 void AliAnalysisTaskEMCALPi0PbPb::CalcClusterProps()
917 // Calculate cluster properties
924 AliVCaloCells *cells = fEsdCells;
930 TObjArray *clusters = fEsdClusters;
932 clusters = fAodClusters;
936 const Int_t ncells = cells->GetNumberOfCells();
937 const Int_t nclus = clusters->GetEntries();
938 const Int_t ntrks = fSelTracks->GetEntries();
940 std::map<Short_t,Short_t> map;
941 for (Short_t pos=0; pos<ncells; ++pos) {
942 Short_t id = cells->GetCellNumber(pos);
943 if (id>24*48*fGeom->GetNumberOfSuperModules()) {
944 AliError(Form("Id of cell found to be too large: %d", id));
947 AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigits->At(pos));
948 if (digit->GetId() != id) {
949 AliError(Form("Ids should be equal: %d %d", id, digit->GetId()));
955 TObjArray filtMcParts;
957 Int_t nmc = fMcParts->GetEntries();
958 for (Int_t i=0; i<nmc; ++i) {
959 AliStaPart *pa = static_cast<AliStaPart*>(fMcParts->At(i));
965 Double_t vertex[3] = {0,0,0};
966 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
968 for(Int_t i=0, ncl=0; i<nclus; ++i) {
969 AliVCluster *clus = static_cast<AliVCluster*>(clusters->At(i));
973 if (!clus->IsEMCAL())
978 Float_t clsPos[3] = {0,0,0};
979 clus->GetPosition(clsPos);
980 TVector3 clsVec(clsPos);
981 TLorentzVector clusterVec;
982 clus->GetMomentum(clusterVec,vertex);
983 Double_t clsEta = clusterVec.Eta();
985 AliStaCluster *cl = static_cast<AliStaCluster*>(fClusters->New(ncl++));
987 cl->fR = clsVec.Perp();
988 cl->fEta = clsVec.Eta();
989 cl->fPhi = clsVec.Phi();
990 cl->fN = clus->GetNCells();
991 cl->fN1 = GetNCells(clus,0.100);
992 cl->fN3 = GetNCells(clus,0.300);
994 Double_t emax = GetMaxCellEnergy(clus, id);
996 cl->fSM = fGeom->GetSuperModuleNumber(id);
999 cl->fE2max = GetSecondMaxCellEnergy(clus,id2);
1000 cl->fTmax = cells->GetCellTime(id);
1001 if (clus->GetDistanceToBadChannel()<10000)
1002 cl->fDbc = clus->GetDistanceToBadChannel();
1003 if (!TMath::IsNaN(clus->GetDispersion()))
1004 cl->fDisp = clus->GetDispersion();
1005 if (!TMath::IsNaN(clus->GetM20()))
1006 cl->fM20 = clus->GetM20();
1007 if (!TMath::IsNaN(clus->GetM02()))
1008 cl->fM02 = clus->GetM02();
1009 Double_t maxAxis = -1, minAxis = -1;
1010 GetSigma(clus,maxAxis,minAxis);
1011 clus->SetTOF(maxAxis); // store sigma in TOF for later plotting
1013 Double_t sEtaEta = -1;
1014 Double_t sPhiPhi = -1;
1015 GetSigmaEtaEta(clus, sEtaEta, sPhiPhi);
1016 cl->fSigEtaEta = sEtaEta;
1017 cl->fSigPhiPhi = sPhiPhi;
1018 Double_t clusterEcc = -1;
1020 clusterEcc = TMath::Sqrt(1.0 - minAxis*minAxis/(maxAxis*maxAxis));
1021 clus->SetChi2(clusterEcc); // store ecc in chi2 for later plotting
1022 cl->fEcc = clusterEcc;
1023 cl->fTrIso = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist);
1024 cl->fTrIso1 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist, 1);
1025 cl->fTrIso2 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist, 2);
1026 cl->fTrIsoD1 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist-0.1);
1027 cl->fTrIso1D1 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist-0.1, 1);
1028 cl->fTrIso2D1 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist-0.1, 2);
1029 cl->fTrIsoD3 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist+0.1);
1030 cl->fTrIso1D3 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist+0.1, 1);
1031 cl->fTrIso2D3 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist+0.1, 2);
1032 cl->fTrIsoD4 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist+0.2);
1033 cl->fTrIso1D4 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist+0.2, 1);
1034 cl->fTrIso2D4 = GetTrackIsolation(clusterVec.Eta(),clusterVec.Phi(),fIsoDist+0.2, 2);
1035 cl->fTrIsoStrip = GetTrackIsoStrip(clusterVec.Eta(), clusterVec.Phi());
1036 cl->fCeCore = GetCellIsolation(clsVec.Eta(),clsVec.Phi(),0.05);
1037 cl->fCeIso = GetCellIsolation(clsVec.Eta(),clsVec.Phi(),fIsoDist);
1038 cl->fCeIso1 = GetCellIsolation(clsVec.Eta(),clsVec.Phi(),0.10);
1039 cl->fCeIso3 = GetCellIsolation(clsVec.Eta(),clsVec.Phi(),0.30);
1040 cl->fCeIso4 = GetCellIsolation(clsVec.Eta(),clsVec.Phi(),0.40);
1041 cl->fCeIso3x3 = GetCellIsoNxM(clsVec.Eta(),clsVec.Phi(), 3, 3);
1042 cl->fCeIso4x4 = GetCellIsoNxM(clsVec.Eta(),clsVec.Phi(), 4, 4);
1043 cl->fCeIso5x5 = GetCellIsoNxM(clsVec.Eta(),clsVec.Phi(), 5, 5);
1044 cl->fCeIso3x22 = GetCellIsoNxM(clsVec.Eta(),clsVec.Phi(), 3, 22);
1045 cl->fIsShared = IsShared(clus);
1050 Int_t ntrig = fTriggers->GetEntries();
1051 for (Int_t j = 0; j<ntrig; ++j) {
1052 AliStaTrigger *sta = static_cast<AliStaTrigger*>(fTriggers->At(j));
1055 Short_t idmax = sta->fIdMax;
1056 Bool_t inc = IsIdPartOfCluster(clus, idmax);
1059 cl->fTrigE = sta->fE;
1067 Double_t mind2 = 1e10;
1068 for(Int_t j = 0; j<ntrks; ++j) {
1069 AliVTrack *track = static_cast<AliVTrack*>(fSelTracks->At(j));
1072 if (TMath::Abs(clsEta-track->Eta())>0.5)
1074 TVector3 vec(clsPos);
1075 Float_t tmpEta=-1, tmpPhi=-1, tmpR2=1e10;
1078 AliESDtrack *esdTrack = static_cast<AliESDtrack*>(track);
1079 dedx = esdTrack->GetTPCsignal();
1081 if (TMath::Abs(clsEta-track->Eta())>fIsoDist)
1083 AliExternalTrackParam tParam;
1084 tParam.CopyFromVTrack(track);
1085 if (!fReco->ExtrapolateTrackToCluster(&tParam, clus, tmpEta, tmpPhi))
1087 tmpR2 = tmpEta*tmpEta + tmpPhi*tmpPhi;
1088 Double_t d2 = tmpR2;
1093 cl->fTrEp = clus->E()/track->P();
1098 if (cl->fIsTrackM) {
1099 fHMatchDr->Fill(cl->fTrDr);
1100 fHMatchDz->Fill(cl->fTrDz);
1101 fHMatchEp->Fill(cl->fTrEp);
1107 Int_t nmc = filtMcParts.GetEntries();
1108 Double_t diffR2 = 1e9;
1109 AliStaPart *msta = 0;
1110 for (Int_t j=0; j<nmc; ++j) {
1111 AliStaPart *pa = static_cast<AliStaPart*>(filtMcParts.At(j));
1112 Double_t t1=clsVec.Eta()-pa->fVEta;
1113 Double_t t2=TVector2::Phi_mpi_pi(clsVec.Phi()-pa->fVPhi);
1114 Double_t tmp = t1*t1+t2*t2;
1120 if (diffR2<10 && msta!=0) {
1121 cl->fMcLabel = msta->fLab;
1126 if (fDigits && fEmbedMode) {
1127 for(Int_t j=0; j<cl->fN; ++j) {
1128 Short_t cid = TMath::Abs(clus->GetCellAbsId(j));
1130 std::map<Short_t,Short_t>::iterator it = map.find(cid);
1135 AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigits->At(pos));
1138 if (digit->GetType()<-1) {
1139 cl->fEmbE += digit->GetChi2();
1146 //________________________________________________________________________
1147 void AliAnalysisTaskEMCALPi0PbPb::CalcPrimTracks()
1149 // Calculate track properties for primary tracks.
1151 fSelPrimTracks->Clear();
1153 AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
1154 TClonesArray *tracks = 0;
1155 Bool_t doConstrain = kFALSE;
1156 TString trkname(fPrimTracksName);
1158 if (trkname.IsNull()) {
1160 am->LoadBranch("Tracks");
1161 fSelPrimTracks->SetOwner(kTRUE);
1162 doConstrain = kTRUE;
1164 TList *l = fEsdEv->GetList();
1165 tracks = dynamic_cast<TClonesArray*>(l->FindObject(trkname));
1168 am->LoadBranch("tracks");
1169 TList *l = fAodEv->GetList();
1170 tracks = dynamic_cast<TClonesArray*>(l->FindObject("tracks"));
1174 AliError(Form("Pointer to tracks %s == 0", trkname.Data() ));
1178 AliEMCALEMCGeometry *emc = fGeom->GetEMCGeometry();
1179 Double_t phimin = emc->GetArm1PhiMin()*TMath::DegToRad()-fIsoDist*1.25;
1180 Double_t phimax = emc->GetArm1PhiMax()*TMath::DegToRad()+fIsoDist*1.25;
1183 am->LoadBranch("PrimaryVertex.");
1184 const AliESDVertex *vtx = fEsdEv->GetPrimaryVertexSPD();
1185 am->LoadBranch("SPDVertex.");
1186 const AliESDVertex *vtxSPD = fEsdEv->GetPrimaryVertexSPD();
1187 am->LoadBranch("Tracks");
1188 const Int_t Ntracks = tracks->GetEntries();
1189 for (Int_t iTracks = 0; iTracks < Ntracks; ++iTracks) {
1190 AliESDtrack *track = static_cast<AliESDtrack*>(tracks->At(iTracks));
1192 AliWarning(Form("Could not receive track %d\n", iTracks));
1195 if (fPrimTrCuts && !fPrimTrCuts->IsSelected(track))
1197 Double_t eta = track->Eta();
1200 if (track->Phi()<phimin||track->Phi()>phimax)
1203 fSelPrimTracks->Add(track);
1206 AliESDtrack copyt(*track);
1208 copyt.GetBxByBz(bfield);
1209 AliExternalTrackParam tParam;
1210 Bool_t relate = copyt.RelateToVertexBxByBz(vtxSPD,bfield,kVeryBig,&tParam);
1213 copyt.Set(tParam.GetX(),tParam.GetAlpha(),tParam.GetParameter(),tParam.GetCovariance());
1214 Double_t p[3] = { 0. };
1216 Double_t pos[3] = { 0. };
1218 Double_t covTr[21] = { 0. };
1219 copyt.GetCovarianceXYZPxPyPz(covTr);
1220 // Double_t pid[10] = { 0. };
1221 // copyt.GetESDpid(pid);
1222 AliAODTrack *aTrack = new AliAODTrack(copyt.GetID(),
1229 (Short_t)copyt.GetSign(),
1230 copyt.GetITSClusterMap(),
1232 0,/*fPrimaryVertex,*/
1233 kTRUE, // check if this is right
1234 vtx->UsesTrack(copyt.GetID()));
1235 aTrack->SetPIDForTracking(copyt.GetPIDForTracking());
1236 aTrack->SetTPCClusterMap(copyt.GetTPCClusterMap());
1237 aTrack->SetTPCSharedMap (copyt.GetTPCSharedMap());
1238 Float_t ndf = copyt.GetTPCNcls() + 1 - 5 ;
1240 aTrack->SetChi2perNDF(copyt.GetTPCchi2()/ndf);
1242 aTrack->SetChi2perNDF(-1);
1243 aTrack->SetFlags(copyt.GetStatus());
1244 aTrack->SetTPCPointsF(copyt.GetTPCNclsF());
1245 fSelPrimTracks->Add(aTrack);
1248 Int_t ntracks = tracks->GetEntries();
1249 for (Int_t i=0; i<ntracks; ++i) {
1250 AliAODTrack *track = static_cast<AliAODTrack*>(tracks->At(i));
1253 Double_t eta = track->Eta();
1256 if (track->Phi()<phimin||track->Phi()>phimax)
1258 if(track->GetTPCNcls()<fMinNClusPerTr)
1260 //todo: Learn how to set/filter AODs for prim/sec tracks
1261 fSelPrimTracks->Add(track);
1266 //________________________________________________________________________
1267 void AliAnalysisTaskEMCALPi0PbPb::CalcTracks()
1269 // Calculate track properties (including secondaries).
1271 fSelTracks->Clear();
1273 AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
1274 TClonesArray *tracks = 0;
1276 am->LoadBranch("Tracks");
1277 TList *l = fEsdEv->GetList();
1278 tracks = dynamic_cast<TClonesArray*>(l->FindObject("Tracks"));
1280 am->LoadBranch("tracks");
1281 TList *l = fAodEv->GetList();
1282 tracks = dynamic_cast<TClonesArray*>(l->FindObject("tracks"));
1289 const Int_t Ntracks = tracks->GetEntries();
1290 for (Int_t iTracks = 0; iTracks < Ntracks; ++iTracks) {
1291 AliESDtrack *track = static_cast<AliESDtrack*>(tracks->At(iTracks));
1293 AliWarning(Form("Could not receive track %d\n", iTracks));
1296 if (fTrCuts && !fTrCuts->IsSelected(track))
1298 Double_t eta = track->Eta();
1301 fSelTracks->Add(track);
1304 Int_t ntracks = tracks->GetEntries();
1305 for (Int_t i=0; i<ntracks; ++i) {
1306 AliAODTrack *track = static_cast<AliAODTrack*>(tracks->At(i));
1309 Double_t eta = track->Eta();
1312 if(track->GetTPCNcls()<fMinNClusPerTr)
1315 if (0 && (track->Pt()>=0.6) && (track->PxAtDCA()==-999)) { // compute position on EMCAL
1316 AliExternalTrackParam tParam;
1317 tParam.CopyFromVTrack(track);
1318 if (AliTrackerBase::PropagateTrackToBxByBz(&tParam, 430, 0.139, 1, kTRUE)) {
1320 tParam.GetXYZ(trkPos);
1321 track->SetPxPyPzAtDCA(trkPos[0],trkPos[1],trkPos[2]);
1324 fSelTracks->Add(track);
1329 //________________________________________________________________________
1330 void AliAnalysisTaskEMCALPi0PbPb::ClusterAfterburner()
1332 // Run custer reconstruction afterburner.
1334 AliVCaloCells *cells = fEsdCells;
1341 Int_t ncells = cells->GetNumberOfCells();
1345 Double_t cellMeanE = 0, cellSigE = 0;
1346 for (Int_t i = 0; i<ncells; ++i) {
1347 Double_t cellE = cells->GetAmplitude(i);
1349 cellSigE += cellE*cellE;
1351 cellMeanE /= ncells;
1353 cellSigE -= cellMeanE*cellMeanE;
1356 cellSigE = TMath::Sqrt(cellSigE / ncells);
1358 Double_t subE = cellMeanE - 7*cellSigE;
1362 for (Int_t i = 0; i<ncells; ++i) {
1365 Double_t amp=0,time=0, efrac = 0;
1366 if (!cells->GetCell(i, id, amp, time,mclabel,efrac))
1371 cells->SetCell(i, id, amp, time);
1374 TObjArray *clusters = fEsdClusters;
1376 clusters = fAodClusters;
1380 Int_t nclus = clusters->GetEntries();
1381 for (Int_t i = 0; i<nclus; ++i) {
1382 AliVCluster *clus = static_cast<AliVCluster*>(clusters->At(i));
1383 if (!clus->IsEMCAL())
1385 Int_t nc = clus->GetNCells();
1387 UShort_t ids[100] = {0};
1388 Double_t fra[100] = {0};
1389 for (Int_t j = 0; j<nc; ++j) {
1390 Short_t id = TMath::Abs(clus->GetCellAbsId(j));
1391 Double_t cen = cells->GetCellAmplitude(id);
1399 clusters->RemoveAt(i);
1403 for (Int_t j = 0; j<nc; ++j) {
1404 Short_t id = ids[j];
1405 Double_t cen = cells->GetCellAmplitude(id);
1409 AliAODCaloCluster *aodclus = dynamic_cast<AliAODCaloCluster*>(clus);
1412 aodclus->SetNCells(nc);
1413 aodclus->SetCellsAmplitudeFraction(fra);
1414 aodclus->SetCellsAbsId(ids);
1417 clusters->Compress();
1420 //________________________________________________________________________
1421 void AliAnalysisTaskEMCALPi0PbPb::FillCellHists()
1423 // Fill histograms related to cell properties.
1425 AliVCaloCells *cells = fEsdCells;
1432 Int_t cellModCount[12] = {0};
1433 Double_t cellMaxE = 0;
1434 Double_t cellMeanE = 0;
1435 Int_t ncells = cells->GetNumberOfCells();
1439 Int_t nsm = fGeom->GetEMCGeometry()->GetNumberOfSuperModules();
1441 for (Int_t i = 0; i<ncells; ++i) {
1442 Int_t absID = TMath::Abs(cells->GetCellNumber(i));
1443 Double_t cellE = cells->GetAmplitude(i);
1444 fHCellE->Fill(cellE);
1449 Int_t iSM=-1, iTower=-1, nIphi=-1, nIeta=-1;
1450 Bool_t ret = fGeom->GetCellIndex(absID, iSM, iTower, nIphi, nIeta);
1452 AliError(Form("Could not get cell index for %d", absID));
1455 ++cellModCount[iSM];
1456 Int_t iPhi=-1, iEta=-1;
1457 fGeom->GetCellPhiEtaIndexInSModule(iSM, iTower, nIphi, nIeta, iPhi, iEta);
1458 fHColuRow[iSM]->Fill(iEta,iPhi,1);
1459 fHColuRowE[iSM]->Fill(iEta,iPhi,cellE);
1460 fHCellFreqNoCut[iSM]->Fill(absID);
1461 if (cellE > 0.1) fHCellFreqCut100M[iSM]->Fill(absID);
1462 if (cellE > 0.3) fHCellFreqCut300M[iSM]->Fill(absID);
1463 if (fHCellCheckE && fHCellCheckE[absID])
1464 fHCellCheckE[absID]->Fill(cellE);
1465 fHCellFreqE[iSM]->Fill(absID, cellE);
1467 fHCellH->Fill(cellMaxE);
1468 cellMeanE /= ncells;
1469 fHCellM->Fill(cellMeanE);
1470 fHCellM2->Fill(cellMeanE*ncells/24/48/nsm);
1471 for (Int_t i=0; i<nsm; ++i)
1472 fHCellMult[i]->Fill(cellModCount[i]);
1475 //________________________________________________________________________
1476 void AliAnalysisTaskEMCALPi0PbPb::FillClusHists()
1478 // Fill histograms related to cluster properties.
1480 TObjArray *clusters = fEsdClusters;
1482 clusters = fAodClusters;
1486 Double_t vertex[3] = {0};
1487 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1489 Int_t nclus = clusters->GetEntries();
1490 for(Int_t i = 0; i<nclus; ++i) {
1491 AliVCluster *clus = static_cast<AliVCluster*>(clusters->At(i));
1494 if (!clus->IsEMCAL())
1496 TLorentzVector clusterVec;
1497 clus->GetMomentum(clusterVec,vertex);
1498 Double_t maxAxis = clus->GetTOF(); //sigma
1499 Double_t clusterEcc = clus->Chi2(); //eccentricity
1500 fHClustEccentricity->Fill(clusterEcc);
1501 fHClustEtaPhi->Fill(clusterVec.Eta(),clusterVec.Phi());
1502 fHClustEnergyPt->Fill(clusterVec.E(),clusterVec.Pt());
1503 fHClustEnergySigma->Fill(clus->E()*maxAxis,clus->E());
1504 fHClustSigmaSigma->Fill(max(clus->GetM02(),clus->GetM20()),clus->E()*maxAxis);
1505 fHClustNCellEnergyRatio->Fill(clus->GetNCells(),GetMaxCellEnergy(clus)/clus->E());
1506 fHClustEnergyNCell->Fill(clus->E(),clus->GetNCells());
1510 //________________________________________________________________________
1511 void AliAnalysisTaskEMCALPi0PbPb::CalcMcInfo()
1513 // Get Mc truth particle information.
1520 AliEMCALEMCGeometry *emc = fGeom->GetEMCGeometry();
1521 Double_t etamin = -0.7;
1522 Double_t etamax = +0.7;
1523 Double_t phimin = emc->GetArm1PhiMin()*TMath::DegToRad();
1524 Double_t phimax = emc->GetArm1PhiMax()*TMath::DegToRad();
1527 AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
1528 am->LoadBranch(AliAODMCParticle::StdBranchName());
1529 TClonesArray *tca = dynamic_cast<TClonesArray*>(fAodEv->FindListObject(AliAODMCParticle::StdBranchName()));
1533 Int_t nents = tca->GetEntries();
1534 for(int it=0; it<nents; ++it) {
1535 AliAODMCParticle *part = static_cast<AliAODMCParticle*>(tca->At(it));
1538 // pion or eta meson or direct photon
1539 if(part->GetPdgCode() == 111) {
1540 } else if(part->GetPdgCode() == 221) {
1541 } else if(part->GetPdgCode() == 22 ) {
1546 Double_t dR = TMath::Sqrt((part->Xv()*part->Xv())+(part->Yv()*part->Yv()));
1551 Double_t pt = part->Pt() ;
1554 Double_t eta = part->Eta();
1555 if (eta<etamin||eta>etamax)
1557 Double_t phi = part->Phi();
1558 if (phi<phimin||phi>phimax)
1561 ProcessDaughters(part, it, tca);
1566 AliMCEvent *mcEvent = MCEvent();
1570 const AliVVertex *evtVtx = mcEvent->GetPrimaryVertex();
1574 mcEvent->PreReadAll();
1576 Int_t nTracks = mcEvent->GetNumberOfPrimaries();
1577 for (Int_t iTrack = 0; iTrack<nTracks; ++iTrack) {
1578 AliMCParticle *mcP = static_cast<AliMCParticle*>(mcEvent->GetTrack(iTrack));
1582 // pion or eta meson or direct photon
1583 if(mcP->PdgCode() == 111) {
1584 } else if(mcP->PdgCode() == 221) {
1585 } else if(mcP->PdgCode() == 22 ) {
1590 Double_t dR = TMath::Sqrt((mcP->Xv()-evtVtx->GetX())*(mcP->Xv()-evtVtx->GetX()) +
1591 (mcP->Yv()-evtVtx->GetY())*(mcP->Yv()-evtVtx->GetY()));
1596 Double_t pt = mcP->Pt() ;
1599 Double_t eta = mcP->Eta();
1600 if (eta<etamin||eta>etamax)
1602 Double_t phi = mcP->Phi();
1603 if (phi<phimin||phi>phimax)
1606 ProcessDaughters(mcP, iTrack, mcEvent);
1610 //________________________________________________________________________
1611 void AliAnalysisTaskEMCALPi0PbPb::FillNtuple()
1618 AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
1620 AliAODHeader * aodheader = dynamic_cast<AliAODHeader*>(fAodEv->GetHeader());
1621 if(!aodheader) AliFatal("Not a standard AOD");
1623 fHeader->fRun = fAodEv->GetRunNumber();
1624 fHeader->fOrbit = aodheader->GetOrbitNumber();
1625 fHeader->fPeriod = aodheader->GetPeriodNumber();
1626 fHeader->fBx = aodheader->GetBunchCrossNumber();
1627 fHeader->fL0 = aodheader->GetL0TriggerInputs();
1628 fHeader->fL1 = aodheader->GetL1TriggerInputs();
1629 fHeader->fL2 = aodheader->GetL2TriggerInputs();
1630 fHeader->fTrClassMask = aodheader->GetTriggerMask();
1631 fHeader->fTrCluster = aodheader->GetTriggerCluster();
1632 fHeader->fOffTriggers = aodheader->GetOfflineTrigger();
1633 fHeader->fFiredTriggers = aodheader->GetFiredTriggerClasses();
1635 fHeader->fRun = fEsdEv->GetRunNumber();
1636 fHeader->fOrbit = fEsdEv->GetHeader()->GetOrbitNumber();
1637 fHeader->fPeriod = fEsdEv->GetESDRun()->GetPeriodNumber();
1638 fHeader->fBx = fEsdEv->GetHeader()->GetBunchCrossNumber();
1639 fHeader->fL0 = fEsdEv->GetHeader()->GetL0TriggerInputs();
1640 fHeader->fL1 = fEsdEv->GetHeader()->GetL1TriggerInputs();
1641 fHeader->fL2 = fEsdEv->GetHeader()->GetL2TriggerInputs();
1642 fHeader->fTrClassMask = fEsdEv->GetHeader()->GetTriggerMask();
1643 fHeader->fTrCluster = fEsdEv->GetHeader()->GetTriggerCluster();
1644 fHeader->fOffTriggers = ((AliInputEventHandler*)(am->GetInputEventHandler()))->IsEventSelected();
1645 fHeader->fFiredTriggers = fEsdEv->GetFiredTriggerClasses();
1646 Float_t v0CorrR = 0;
1647 fHeader->fV0 = AliESDUtils::GetCorrV0(fEsdEv,v0CorrR);
1648 const AliMultiplicity *mult = fEsdEv->GetMultiplicity();
1650 fHeader->fCl1 = mult->GetNumberOfITSClusters(1);
1651 fHeader->fTr = AliESDtrackCuts::GetReferenceMultiplicity(fEsdEv,1);
1652 AliTriggerAnalysis trAn; /// Trigger Analysis
1653 Bool_t v0B = trAn.IsOfflineTriggerFired(fEsdEv, AliTriggerAnalysis::kV0C);
1654 Bool_t v0A = trAn.IsOfflineTriggerFired(fEsdEv, AliTriggerAnalysis::kV0A);
1655 fHeader->fV0And = v0A && v0B;
1656 fHeader->fIsHT = (fHeader->fOffTriggers & AliVEvent::kEMC1) || (fHeader->fOffTriggers & AliVEvent::kEMC7);
1657 am->LoadBranch("SPDPileupVertices");
1658 am->LoadBranch("TrkPileupVertices");
1659 fHeader->fIsPileup = fEsdEv->IsPileupFromSPD(3,0.8);
1660 fHeader->fIsPileup2 = fEsdEv->IsPileupFromSPD(3,0.4);
1661 fHeader->fIsPileup4 = fEsdEv->IsPileupFromSPD(3,0.2);
1662 fHeader->fIsPileup8 = fEsdEv->IsPileupFromSPD(3,0.1);
1663 fHeader->fNSpdVertices = fEsdEv->GetNumberOfPileupVerticesSPD();
1664 fHeader->fNTpcVertices = fEsdEv->GetNumberOfPileupVerticesTracks();
1667 AliCentrality *cent = InputEvent()->GetCentrality();
1668 fHeader->fV0Cent = cent->GetCentralityPercentileUnchecked("V0M");
1669 fHeader->fCl1Cent = cent->GetCentralityPercentileUnchecked("CL1");
1670 fHeader->fTrCent = cent->GetCentralityPercentileUnchecked("TRK");
1671 fHeader->fCqual = cent->GetQuality();
1673 AliEventplane *ep = InputEvent()->GetEventplane();
1675 if (ep->GetQVector())
1676 fHeader->fPsi = ep->GetQVector()->Phi()/2. ;
1679 if (ep->GetQsub1()&&ep->GetQsub2())
1680 fHeader->fPsiRes = ep->GetQsub1()->Phi()/2.-ep->GetQsub2()->Phi()/2.;
1682 fHeader->fPsiRes = 0;
1686 TString trgclasses(fHeader->fFiredTriggers);
1687 for (Int_t j = 0; j<fTrClassNamesArr->GetEntries(); ++j) {
1688 const char *name = fTrClassNamesArr->At(j)->GetName();
1689 TRegexp regexp(name);
1690 if (trgclasses.Contains(regexp))
1691 val += TMath::Power(2,j);
1693 fHeader->fTcls = (UInt_t)val;
1695 fHeader->fNSelTr = fSelTracks->GetEntries();
1696 fHeader->fNSelPrimTr = fSelPrimTracks->GetEntries();
1697 fHeader->fNSelPrimTr1 = 0;
1698 fHeader->fNSelPrimTr2 = 0;
1699 for(int iTracks=0; iTracks < fSelPrimTracks->GetEntries(); iTracks++){
1700 AliESDtrack *track = static_cast<AliESDtrack*>(fSelPrimTracks->At(iTracks));
1702 ++fHeader->fNSelPrimTr1;
1704 ++fHeader->fNSelPrimTr2;
1707 fHeader->fNCells = 0;
1708 fHeader->fNCells0 = 0;
1709 fHeader->fNCells01 = 0;
1710 fHeader->fNCells03 = 0;
1711 fHeader->fNCells1 = 0;
1712 fHeader->fNCells2 = 0;
1713 fHeader->fNCells5 = 0;
1714 fHeader->fMaxCellE = 0;
1716 AliVCaloCells *cells = fEsdCells;
1721 Int_t ncells = cells->GetNumberOfCells();
1722 for(Int_t j=0; j<ncells; ++j) {
1723 Double_t cellen = cells->GetAmplitude(j);
1725 ++fHeader->fNCells0;
1727 ++fHeader->fNCells01;
1729 ++fHeader->fNCells03;
1731 ++fHeader->fNCells1;
1733 ++fHeader->fNCells2;
1735 ++fHeader->fNCells5;
1736 if (cellen>fHeader->fMaxCellE)
1737 fHeader->fMaxCellE = cellen;
1739 fHeader->fNCells = ncells;
1742 fHeader->fNClus = 0;
1743 fHeader->fNClus1 = 0;
1744 fHeader->fNClus2 = 0;
1745 fHeader->fNClus5 = 0;
1746 fHeader->fMaxClusE = 0;
1748 TObjArray *clusters = fEsdClusters;
1750 clusters = fAodClusters;
1753 Int_t nclus = clusters->GetEntries();
1754 for(Int_t j=0; j<nclus; ++j) {
1755 AliVCluster *clus = static_cast<AliVCluster*>(clusters->At(j));
1756 if (!clus->IsEMCAL())
1758 Double_t clusen = clus->E();
1765 if (clusen>fHeader->fMaxClusE)
1766 fHeader->fMaxClusE = clusen;
1768 fHeader->fNClus = nclus;
1771 fHeader->fMaxTrE = 0;
1773 Int_t ntrig = fTriggers->GetEntries();
1774 for (Int_t j = 0; j<ntrig; ++j) {
1775 AliStaTrigger *sta = static_cast<AliStaTrigger*>(fTriggers->At(j));
1778 if (sta->fE>fHeader->fMaxTrE)
1779 fHeader->fMaxTrE = sta->fE;
1783 // count cells above 100 MeV on super modules
1784 fHeader->fNcSM0 = GetNCells(0, 0.100);
1785 fHeader->fNcSM1 = GetNCells(1, 0.100);
1786 fHeader->fNcSM2 = GetNCells(2, 0.100);
1787 fHeader->fNcSM3 = GetNCells(3, 0.100);
1788 fHeader->fNcSM4 = GetNCells(4, 0.100);
1789 fHeader->fNcSM5 = GetNCells(5, 0.100);
1790 fHeader->fNcSM6 = GetNCells(6, 0.100);
1791 fHeader->fNcSM7 = GetNCells(7, 0.100);
1792 fHeader->fNcSM8 = GetNCells(8, 0.100);
1793 fHeader->fNcSM9 = GetNCells(9, 0.100);
1796 am->LoadBranch("vertices");
1797 AliAODVertex *pv = fAodEv->GetPrimaryVertex();
1798 FillVertex(fPrimVert, pv);
1799 AliAODVertex *sv = fAodEv->GetPrimaryVertexSPD();
1800 FillVertex(fSpdVert, sv);
1802 am->LoadBranch("PrimaryVertex.");
1803 const AliESDVertex *pv = fEsdEv->GetPrimaryVertexTracks();
1804 FillVertex(fPrimVert, pv);
1805 am->LoadBranch("SPDVertex.");
1806 const AliESDVertex *sv = fEsdEv->GetPrimaryVertexSPD();
1807 FillVertex(fSpdVert, sv);
1808 am->LoadBranch("TPCVertex.");
1809 const AliESDVertex *tv = fEsdEv->GetPrimaryVertexTPC();
1810 FillVertex(fTpcVert, tv);
1816 //________________________________________________________________________
1817 void AliAnalysisTaskEMCALPi0PbPb::FillPionHists()
1819 // Fill histograms related to pions.
1821 Double_t vertex[3] = {0};
1822 InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
1824 TObjArray *clusters = fEsdClusters;
1826 clusters = fAodClusters;
1829 TLorentzVector clusterVec1;
1830 TLorentzVector clusterVec2;
1831 TLorentzVector pionVec;
1833 Int_t nclus = clusters->GetEntries();
1834 for (Int_t i = 0; i<nclus; ++i) {
1835 AliVCluster *clus1 = static_cast<AliVCluster*>(clusters->At(i));
1838 if (!clus1->IsEMCAL())
1840 if (clus1->E()<fMinE)
1842 if (clus1->GetNCells()<fNminCells)
1844 if (GetMaxCellEnergy(clus1)/clus1->E()<fMinErat)
1846 if (clus1->Chi2()<fMinEcc) // eccentricity cut
1848 clus1->GetMomentum(clusterVec1,vertex);
1849 for (Int_t j = i+1; j<nclus; ++j) {
1850 AliVCluster *clus2 = static_cast<AliVCluster*>(clusters->At(j));
1853 if (!clus2->IsEMCAL())
1855 if (clus2->E()<fMinE)
1857 if (clus2->GetNCells()<fNminCells)
1859 if (GetMaxCellEnergy(clus2)/clus2->E()<fMinErat)
1861 if (clus2->Chi2()<fMinEcc) // eccentricity cut
1863 clus2->GetMomentum(clusterVec2,vertex);
1864 pionVec = clusterVec1 + clusterVec2;
1865 Double_t pionZgg = TMath::Abs(clusterVec1.E()-clusterVec2.E())/pionVec.E();
1866 Double_t pionOpeningAngle = clusterVec1.Angle(clusterVec2.Vect());
1867 if (pionZgg < fAsymMax) {
1868 fHPionEtaPhi->Fill(pionVec.Eta(),pionVec.Phi());
1869 fHPionMggPt->Fill(pionVec.M(),pionVec.Pt());
1870 fHPionMggAsym->Fill(pionVec.M(),pionZgg);
1871 fHPionMggDgg->Fill(pionVec.M(),pionOpeningAngle);
1872 Int_t bin = fPtRanges->FindBin(pionVec.Pt());
1873 fHPionInvMasses[bin]->Fill(pionVec.M());
1880 //________________________________________________________________________
1881 void AliAnalysisTaskEMCALPi0PbPb::FillMcHists()
1883 // Fill additional MC information histograms.
1888 // check if aod or esd mc mode and the fill histos
1891 //________________________________________________________________________
1892 void AliAnalysisTaskEMCALPi0PbPb::FillOtherHists()
1894 // Fill other histograms.
1896 for(int iTracks=0; iTracks < fSelPrimTracks->GetEntries(); ++iTracks){
1897 AliESDtrack *track = static_cast<AliESDtrack*>(fSelPrimTracks->At(iTracks));
1900 fHPrimTrackPt->Fill(track->Pt());
1901 fHPrimTrackEta->Fill(track->Eta());
1902 fHPrimTrackPhi->Fill(track->Phi());
1906 //________________________________________________________________________
1907 void AliAnalysisTaskEMCALPi0PbPb::FillTrackHists()
1909 // Fill track histograms.
1911 if (fSelPrimTracks) {
1912 for(int iTracks=0; iTracks < fSelPrimTracks->GetEntries(); iTracks++) {
1913 AliESDtrack *track = static_cast<AliESDtrack*>(fSelPrimTracks->At(iTracks));
1916 fHPrimTrackPt->Fill(track->Pt());
1917 fHPrimTrackEta->Fill(track->Eta());
1918 fHPrimTrackPhi->Fill(track->Phi());
1923 //__________________________________________________________________________________________________
1924 void AliAnalysisTaskEMCALPi0PbPb::FillVertex(AliStaVertex *v, const AliESDVertex *esdv)
1926 // Fill vertex from ESD vertex info.
1928 v->fVx = esdv->GetX();
1929 v->fVy = esdv->GetY();
1930 v->fVz = esdv->GetZ();
1931 v->fVc = esdv->GetNContributors();
1932 v->fDisp = esdv->GetDispersion();
1933 v->fZres = esdv->GetZRes();
1934 v->fChi2 = esdv->GetChi2();
1935 v->fSt = esdv->GetStatus();
1936 v->fIs3D = esdv->IsFromVertexer3D();
1937 v->fIsZ = esdv->IsFromVertexerZ();
1940 //__________________________________________________________________________________________________
1941 void AliAnalysisTaskEMCALPi0PbPb::FillVertex(AliStaVertex *v, const AliAODVertex *aodv)
1943 // Fill vertex from AOD vertex info.
1945 v->fVx = aodv->GetX();
1946 v->fVy = aodv->GetY();
1947 v->fVz = aodv->GetZ();
1948 v->fVc = aodv->GetNContributors();
1949 v->fChi2 = aodv->GetChi2();
1952 //________________________________________________________________________
1953 Double_t AliAnalysisTaskEMCALPi0PbPb::GetCellIsolation(Double_t cEta, Double_t cPhi, Double_t radius) const
1955 // Compute isolation based on cell content.
1957 AliVCaloCells *cells = fEsdCells;
1963 Double_t cellIsolation = 0;
1964 Double_t rad2 = radius*radius;
1965 Int_t ncells = cells->GetNumberOfCells();
1966 for (Int_t i = 0; i<ncells; ++i) {
1967 Int_t absID = TMath::Abs(cells->GetCellNumber(i));
1968 Float_t eta=-1, phi=-1;
1969 fGeom->EtaPhiFromIndex(absID,eta,phi);
1970 Double_t phidiff = TVector2::Phi_mpi_pi(phi-cPhi);
1971 Double_t dist = (eta-cEta)*(eta-cEta)+phidiff*phidiff;
1974 Double_t cellE = cells->GetAmplitude(i);
1975 Double_t theta = 2*TMath::ATan(TMath::Exp(-eta));
1976 Double_t cellEt = cellE*sin(theta);
1977 cellIsolation += cellEt;
1979 return cellIsolation;
1982 //________________________________________________________________________
1983 Double_t AliAnalysisTaskEMCALPi0PbPb::GetCellIsoNxM(Double_t cEta, Double_t cPhi, Int_t N, Int_t M) const
1985 // Compute isolation based on cell content, in a NxM rectangle.
1987 AliVCaloCells *cells = fEsdCells;
1993 Double_t cellIsolation = 0;
1994 Int_t ncells = cells->GetNumberOfCells();
1995 for (Int_t i = 0; i<ncells; ++i) {
1996 Int_t absID = TMath::Abs(cells->GetCellNumber(i));
1997 Float_t eta=-1, phi=-1;
1998 fGeom->EtaPhiFromIndex(absID,eta,phi);
1999 Double_t phidiff = TVector2::Phi_mpi_pi(phi-cPhi);
2000 Double_t etadiff = (eta-cEta)*(eta-cEta)+phidiff*phidiff;
2001 if(TMath::Abs(etadiff)/0.014>N)
2003 if(TMath::Abs(phidiff)/0.014>M)
2005 Double_t cellE = cells->GetAmplitude(i);
2006 Double_t theta = 2*TMath::ATan(TMath::Exp(-eta));
2007 Double_t cellEt = cellE*sin(theta);
2008 cellIsolation += cellEt;
2010 return cellIsolation;
2013 //________________________________________________________________________
2014 Double_t AliAnalysisTaskEMCALPi0PbPb::GetCellEnergy(const AliVCluster *cluster) const
2016 // Get maximum energy of attached cell.
2019 Int_t ncells = cluster->GetNCells();
2021 for (Int_t i=0; i<ncells; i++) {
2022 Double_t e = fEsdCells->GetCellAmplitude(TMath::Abs(cluster->GetCellAbsId(i)));
2026 for (Int_t i=0; i<ncells; i++) {
2027 Double_t e = fAodCells->GetCellAmplitude(TMath::Abs(cluster->GetCellAbsId(i)));
2034 //________________________________________________________________________
2035 Double_t AliAnalysisTaskEMCALPi0PbPb::GetMaxCellEnergy(const AliVCluster *cluster, Short_t &id) const
2037 // Get maximum energy of attached cell.
2041 Int_t ncells = cluster->GetNCells();
2043 for (Int_t i=0; i<ncells; i++) {
2044 Double_t e = fEsdCells->GetCellAmplitude(TMath::Abs(cluster->GetCellAbsId(i)));
2047 id = cluster->GetCellAbsId(i);
2051 for (Int_t i=0; i<ncells; i++) {
2052 Double_t e = fAodCells->GetCellAmplitude(TMath::Abs(cluster->GetCellAbsId(i)));
2055 id = cluster->GetCellAbsId(i);
2061 //________________________________________________________________________
2062 Double_t AliAnalysisTaskEMCALPi0PbPb::GetSecondMaxCellEnergy(AliVCluster *clus, Short_t &id) const
2064 // Get second maximum cell.
2066 AliVCaloCells *cells = fEsdCells;
2072 Double_t secondEmax=0, firstEmax=0;
2074 for(Int_t iCell=0;iCell<clus->GetNCells();iCell++){
2075 Int_t absId = clus->GetCellAbsId(iCell);
2076 cellen = cells->GetCellAmplitude(absId);
2077 if(cellen > firstEmax)
2080 for(Int_t iCell=0;iCell<clus->GetNCells();iCell++){
2081 Int_t absId = clus->GetCellAbsId(iCell);
2082 cellen = cells->GetCellAmplitude(absId);
2083 if(cellen < firstEmax && cellen > secondEmax) {
2084 secondEmax = cellen;
2091 //________________________________________________________________________
2092 void AliAnalysisTaskEMCALPi0PbPb::GetSigma(const AliVCluster *c, Double_t& sigmaMax, Double_t &sigmaMin) const
2094 // Calculate the (E) weighted variance along the longer (eigen) axis.
2096 sigmaMax = 0; // cluster variance along its longer axis
2097 sigmaMin = 0; // cluster variance along its shorter axis
2098 Double_t Ec = c->E(); // cluster energy
2101 Double_t Xc = 0 ; // cluster first moment along X
2102 Double_t Yc = 0 ; // cluster first moment along Y
2103 Double_t Sxx = 0 ; // cluster second central moment along X (variance_X^2)
2104 Double_t Sxy = 0 ; // cluster second central moment along Y (variance_Y^2)
2105 Double_t Syy = 0 ; // cluster covariance^2
2107 AliVCaloCells *cells = fEsdCells;
2114 Int_t ncells = c->GetNCells();
2118 for(Int_t j=0; j<ncells; ++j) {
2119 Int_t id = TMath::Abs(c->GetCellAbsId(j));
2120 Double_t cellen = cells->GetCellAmplitude(id);
2122 fGeom->GetGlobal(id,pos);
2123 Xc += cellen*pos.X();
2124 Yc += cellen*pos.Y();
2125 Sxx += cellen*pos.X()*pos.X();
2126 Syy += cellen*pos.Y()*pos.Y();
2127 Sxy += cellen*pos.X()*pos.Y();
2137 Sxx = TMath::Abs(Sxx);
2138 Syy = TMath::Abs(Syy);
2139 sigmaMax = (Sxx + Syy + TMath::Sqrt(TMath::Abs((Sxx-Syy)*(Sxx-Syy)+4.0*Sxy*Sxy)))/2.0;
2140 sigmaMax = TMath::Sqrt(TMath::Abs(sigmaMax));
2141 sigmaMin = TMath::Abs(Sxx + Syy - TMath::Sqrt(TMath::Abs((Sxx-Syy)*(Sxx-Syy)+4.0*Sxy*Sxy)))/2.0;
2142 sigmaMin = TMath::Sqrt(TMath::Abs(sigmaMin));
2145 //________________________________________________________________________
2146 void AliAnalysisTaskEMCALPi0PbPb::GetSigmaEtaEta(const AliVCluster *c, Double_t& sEtaEta, Double_t &sPhiPhi) const
2148 // Calculate the (E) weighted variance along the pseudorapidity.
2153 Double_t Ec = c->E(); // cluster energy
2157 const Int_t ncells = c->GetNCells();
2159 Double_t EtaC = 0; // cluster first moment along eta
2160 Double_t PhiC = 0; // cluster first moment along phi
2161 Double_t Setaeta = 0; // cluster second central moment along eta
2162 Double_t Sphiphi = 0; // cluster second central moment along phi
2163 Double_t w[ncells]; // weight max(0,4.5*log(E_i/Ec))
2167 AliVCaloCells *cells = fEsdCells;
2177 for(Int_t j=0; j<ncells; ++j) {
2178 id[j] = TMath::Abs(c->GetCellAbsId(j));
2179 Double_t cellen = cells->GetCellAmplitude(id[j]);
2180 w[j] = TMath::Max(0., 4.5+TMath::Log(cellen/Ec));
2182 fGeom->GetGlobal(id[j],pos);
2183 EtaC += w[j]*pos.Eta();
2184 PhiC += w[j]*pos.Phi();
2190 for(Int_t j=0; j<ncells; ++j) {
2192 fGeom->GetGlobal(id[j],pos);
2193 Setaeta = w[j]*(pos.Eta() - EtaC)*(pos.Eta() - EtaC);
2194 Sphiphi = w[j]*(pos.Phi() - PhiC)*(pos.Phi() - PhiC);
2197 sEtaEta = TMath::Sqrt(Setaeta);
2199 sPhiPhi = TMath::Sqrt(Sphiphi);
2202 //________________________________________________________________________
2203 Int_t AliAnalysisTaskEMCALPi0PbPb::GetNCells(const AliVCluster *c, Double_t emin) const
2205 // Calculate number of attached cells above emin.
2207 AliVCaloCells *cells = fEsdCells;
2214 Int_t ncells = c->GetNCells();
2215 for(Int_t j=0; j<ncells; ++j) {
2216 Int_t id = TMath::Abs(c->GetCellAbsId(j));
2217 Double_t cellen = cells->GetCellAmplitude(id);
2224 //________________________________________________________________________
2225 Int_t AliAnalysisTaskEMCALPi0PbPb::GetNCells(Int_t sm, Double_t emin) const
2227 // Calculate number of cells per SM above emin.
2229 AliVCaloCells *cells = fEsdCells;
2236 Int_t ncells = cells->GetNumberOfCells();
2237 for(Int_t j=0; j<ncells; ++j) {
2238 Int_t id = TMath::Abs(cells->GetCellNumber(j));
2239 Double_t cellen = cells->GetCellAmplitude(id);
2242 Int_t fsm = fGeom->GetSuperModuleNumber(id);
2250 //________________________________________________________________________
2251 Double_t AliAnalysisTaskEMCALPi0PbPb::GetTrackIsolation(Double_t cEta, Double_t cPhi, Double_t radius, Double_t pt) const
2253 // Compute isolation based on tracks.
2255 Double_t trkIsolation = 0;
2256 Double_t rad2 = radius*radius;
2257 Int_t ntrks = fSelPrimTracks->GetEntries();
2258 for(Int_t j = 0; j<ntrks; ++j) {
2259 AliVTrack *track = static_cast<AliVTrack*>(fSelPrimTracks->At(j));
2264 Float_t eta = track->Eta();
2265 Float_t phi = track->Phi();
2266 Double_t phidiff = TVector2::Phi_mpi_pi(phi-cPhi);
2267 Double_t dist = (eta-cEta)*(eta-cEta)+phidiff*phidiff;
2270 trkIsolation += track->Pt();
2272 return trkIsolation;
2275 //________________________________________________________________________
2276 Double_t AliAnalysisTaskEMCALPi0PbPb::GetTrackIsoStrip(Double_t cEta, Double_t cPhi, Double_t dEta, Double_t dPhi, Double_t pt) const
2278 // Compute isolation based on tracks.
2280 Double_t trkIsolation = 0;
2281 Int_t ntrks = fSelPrimTracks->GetEntries();
2282 for(Int_t j = 0; j<ntrks; ++j) {
2283 AliVTrack *track = static_cast<AliVTrack*>(fSelPrimTracks->At(j));
2288 Float_t eta = track->Eta();
2289 Float_t phi = track->Phi();
2290 Double_t phidiff = TVector2::Phi_mpi_pi(phi-cPhi);
2291 Double_t etadiff = (eta-cEta);
2292 if(TMath::Abs(etadiff)>dEta || TMath::Abs(phidiff)>dPhi)
2294 trkIsolation += track->Pt();
2296 return trkIsolation;
2299 //________________________________________________________________________
2300 Bool_t AliAnalysisTaskEMCALPi0PbPb::IsShared(const AliVCluster *c) const
2302 // Returns if cluster shared across super modules.
2308 Int_t ncells = c->GetNCells();
2309 for(Int_t j=0; j<ncells; ++j) {
2310 Int_t id = TMath::Abs(c->GetCellAbsId(j));
2311 Int_t got = id / (24*48);
2322 //________________________________________________________________________
2323 Bool_t AliAnalysisTaskEMCALPi0PbPb::IsIdPartOfCluster(const AliVCluster *c, Short_t id) const
2325 // Returns if id is part of cluster.
2327 AliVCaloCells *cells = fEsdCells;
2333 Int_t ncells = c->GetNCells();
2334 for(Int_t j=0; j<ncells; ++j) {
2335 Int_t cid = TMath::Abs(c->GetCellAbsId(j));
2342 //________________________________________________________________________
2343 void AliAnalysisTaskEMCALPi0PbPb::PrintDaughters(const AliVParticle *p, const TObjArray *arr, Int_t level) const
2345 // Print recursively daughter information.
2350 const AliAODMCParticle *amc = dynamic_cast<const AliAODMCParticle*>(p);
2353 for (Int_t i=0; i<level; ++i) printf(" ");
2356 Int_t n = amc->GetNDaughters();
2357 for (Int_t i=0; i<n; ++i) {
2358 Int_t d = amc->GetDaughter(i);
2359 const AliVParticle *dmc = static_cast<const AliVParticle*>(arr->At(d));
2360 PrintDaughters(dmc,arr,level+1);
2364 //________________________________________________________________________
2365 void AliAnalysisTaskEMCALPi0PbPb::PrintDaughters(const AliMCParticle *p, const AliMCEvent *arr, Int_t level) const
2367 // Print recursively daughter information.
2372 for (Int_t i=0; i<level; ++i) printf(" ");
2373 Int_t d1 = p->GetFirstDaughter();
2374 Int_t d2 = p->GetLastDaughter();
2375 printf("pid=%d: %.2f %.2f %.2f (%.2f %.2f %.2f); nd=%d,%d\n",
2376 p->PdgCode(),p->Px(),p->Py(),p->Pz(),p->Xv(),p->Yv(),p->Zv(),d1,d2);
2381 for (Int_t i=d1;i<=d2;++i) {
2382 const AliMCParticle *dmc = static_cast<const AliMCParticle *>(arr->GetTrack(i));
2383 PrintDaughters(dmc,arr,level+1);
2387 //________________________________________________________________________
2388 void AliAnalysisTaskEMCALPi0PbPb::PrintTrackRefs(AliMCParticle *p) const
2390 // Print track ref array.
2395 Int_t n = p->GetNumberOfTrackReferences();
2396 for (Int_t i=0; i<n; ++i) {
2397 AliTrackReference *ref = p->GetTrackReference(i);
2400 ref->SetUserId(ref->DetectorId());
2405 //________________________________________________________________________
2406 void AliAnalysisTaskEMCALPi0PbPb::ProcessDaughters(AliVParticle *p, Int_t index, const TObjArray *arr)
2408 // Process and create daughters.
2413 AliAODMCParticle *amc = dynamic_cast<AliAODMCParticle*>(p);
2419 Int_t nparts = arr->GetEntries();
2420 Int_t nents = fMcParts->GetEntries();
2422 AliStaPart *newp = static_cast<AliStaPart*>(fMcParts->New(nents));
2423 newp->fPt = amc->Pt();
2424 newp->fEta = amc->Eta();
2425 newp->fPhi = amc->Phi();
2426 if (amc->Xv() != 0 || amc->Yv() != 0 || amc->Zv() != 0) {
2427 TVector3 vec(amc->Xv(),amc->Yv(),amc->Zv());
2428 newp->fVR = vec.Perp();
2429 newp->fVEta = vec.Eta();
2430 newp->fVPhi = vec.Phi();
2432 newp->fPid = amc->PdgCode();
2434 Int_t moi = amc->GetMother();
2435 if (moi>=0&&moi<nparts) {
2436 const AliAODMCParticle *mmc = static_cast<const AliAODMCParticle*>(arr->At(moi));
2437 moi = mmc->GetUniqueID();
2440 p->SetUniqueID(nents);
2442 // TODO: Determine which detector was hit
2445 Int_t n = amc->GetNDaughters();
2446 for (Int_t i=0; i<n; ++i) {
2447 Int_t d = amc->GetDaughter(i);
2448 if (d<=index || d>=nparts)
2450 AliVParticle *dmc = static_cast<AliVParticle*>(arr->At(d));
2451 ProcessDaughters(dmc,d,arr);
2455 //________________________________________________________________________
2456 void AliAnalysisTaskEMCALPi0PbPb::ProcessDaughters(AliMCParticle *p, Int_t index, const AliMCEvent *arr)
2458 // Process and create daughters.
2463 Int_t d1 = p->GetFirstDaughter();
2464 Int_t d2 = p->GetLastDaughter();
2466 printf("%d pid=%d: %.3f %.3f %.3f (%.2f %.2f %.2f); nd=%d,%d, mo=%d\n",
2467 index,p->PdgCode(),p->Px(),p->Py(),p->Pz(),p->Xv(),p->Yv(),p->Zv(),d1,d2, p->GetMother());
2470 Int_t nents = fMcParts->GetEntries();
2472 AliStaPart *newp = static_cast<AliStaPart*>(fMcParts->New(nents));
2473 newp->fPt = p->Pt();
2474 newp->fEta = p->Eta();
2475 newp->fPhi = p->Phi();
2476 if (p->Xv() != 0 || p->Yv() != 0 || p->Zv() != 0) {
2477 TVector3 vec(p->Xv(),p->Yv(),p->Zv());
2478 newp->fVR = vec.Perp();
2479 newp->fVEta = vec.Eta();
2480 newp->fVPhi = vec.Phi();
2482 newp->fPid = p->PdgCode();
2484 Int_t moi = p->GetMother();
2486 const AliMCParticle *mmc = static_cast<const AliMCParticle *>(arr->GetTrack(moi));
2487 moi = mmc->GetUniqueID();
2490 p->SetUniqueID(nents);
2492 Int_t nref = p->GetNumberOfTrackReferences();
2494 AliTrackReference *ref = p->GetTrackReference(nref-1);
2496 newp->fDet = ref->DetectorId();
2504 for (Int_t i=d1;i<=d2;++i) {
2505 AliMCParticle *dmc = static_cast<AliMCParticle *>(arr->GetTrack(i));
2508 ProcessDaughters(dmc,i,arr);
2512 //__________________________________________________________________________________________________
2513 void AliStaCluster::GetMom(TLorentzVector& p, Double_t *vertex)
2515 // Calculate momentum.
2518 pos.SetPtEtaPhi(fR,fEta,fPhi);
2520 if(vertex){ //calculate direction relative to vertex
2524 Double_t r = pos.Mag();
2525 p.SetPxPyPzE(fE*pos.x()/r, fE*pos.y()/r, fE*pos.z()/r, fE);
2528 //__________________________________________________________________________________________________
2529 void AliStaCluster::GetMom(TLorentzVector& p, AliStaVertex *vertex)
2531 // Calculate momentum.
2533 Double_t v[3] = {0,0,0};