AliPhysics  c7b8e89 (c7b8e89)
AliAnalysisTaskEA.cxx
Go to the documentation of this file.
1 #ifndef ALIANALYSISTASKSE_H
2 
3 #include <Riostream.h>
4 #include <TROOT.h>
5 #include <TFile.h>
6 #include <TChain.h>
7 #include <TTree.h>
8 #include <TKey.h>
9 #include <TProfile.h>
10 #include <TProfile2D.h>
11 #include <TH1.h>
12 #include <TH1F.h>
13 #include <TF1.h>
14 #include <TH2F.h>
15 #include <TH1D.h>
16 #include <TH1I.h>
17 #include <TArrayF.h>
18 #include <TArrayD.h>
19 #include <THnSparse.h>
20 #include <TCanvas.h>
21 #include <TList.h>
22 #include <TClonesArray.h>
23 #include <TObject.h>
24 #include <TMath.h>
25 #include <TSystem.h>
26 #include <TInterpreter.h>
27 #include "AliAnalysisTask.h"
28 #include "AliCentrality.h"
29 #include "AliStack.h"
30 #include "AliESDEvent.h"
31 #include "AliESDInputHandler.h"
32 #include "AliAODEvent.h"
33 #include "AliAODHandler.h"
34 #include "AliAnalysisManager.h"
35 #include "AliAnalysisTaskSE.h"
37 #include "AliParticleContainer.h"
38 #include "AliInputEventHandler.h"
39 #endif
40 
41 #include <time.h>
42 #include <TRandom3.h>
43 #include "AliGenEventHeader.h"
44 #include "AliGenPythiaEventHeader.h"
45 #include "AliGenHijingEventHeader.h"
46 #include "AliAODMCHeader.h"
47 #include "AliMCEvent.h"
48 #include "AliLog.h"
49 #include <AliEmcalJet.h>
50 #include <AliPicoTrack.h>
51 #include "AliVEventHandler.h"
52 #include "AliVParticle.h"
53 #include "AliAODMCParticle.h"
54 #include "AliAnalysisUtils.h"
55 #include "AliRhoParameter.h"
56 #include "TVector3.h"
57 #include "AliVVertex.h"
58 #include "AliExternalTrackParam.h"
59 
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <vector>
63 
64 #include "AliGenDPMjetEventHeader.h"
65 #include "AliJetContainer.h"
66 #include "AliAnalysisTaskEmcal.h"
68 #include "AliAnalysisTaskEA.h"
69 #include "AliHeader.h"
70 #include "AliRunLoader.h"
71 #include "AliVVZERO.h"
72 #include "AliAODZDC.h"
73 #include "AliVZDC.h"
74 #include "AliMultSelection.h"
75 
76 using namespace std;
77 
78 // ANALYSIS OF HIGH PT HADRON TRIGGER ASSOCIATED SPECTRUM OF RECOIL JETS IN P+PB
79 // Author Filip Krizek (7.Oct. 2015)
80 
81 ClassImp(AliAnalysisTaskEA)
82 //________________________________________________________________________________________
83 
86 fUseDefaultVertexCut(1),
87 fUsePileUpCut(1),
88 fMyTrackContainerName(""),
89 fMyParticleContainerName(""),
90 fMyJetContainerName(""),
91 fMyJetParticleContainerName(""),
92 fTrkContainerDetLevel(0x0),
93 fParticleContainerPartLevel(0x0),
94 fJetContainerDetLevel(0x0),
95 fJetContainerPartLevel(0x0),
96 fRhoTaskName(""),
97 fRhoTaskNameMC(""),
98 fCentralityTree(0x0),
99 fMultSelection(0x0),
100 fIsMinBiasTrig(1),
101 fIsEmcalTrig(0),
102 fCentralityV0A(-1),
103 fCentralityV0C(-1),
104 fCentralityCL1(-1),
105 fCentralityZNA(-1),
106 fCentralityZNC(-1),
107 fxVertex(-1),
108 fyVertex(-1),
109 fzVertex(-1),
110 fVertexer3d(1),
111 fNTracklets(-1),
112 fIsV0ATriggered(0),
113 fIsV0CTriggered(0),
114 fMultV0A(1),
115 fMultV0C(1),
116 fZEM1Energy(0),
117 fZEM2Energy(0),
118 fTrackEtaWindow(0.9),
119 fMinTrackPt(0.150),
120 fMC(0),
121 fHelperClass(0), fInitializedLocal(0),
122 fHistEvtSelection(0x0),
123 fhVertexZ(0x0),
124 fhTrackPhiIncl(0x0), fhTrackEtaIncl(0x0),
125 fhJetPhiIncl(0x0), fhJetEtaIncl(0x0),
126 fhRhoIncl(0x0),
127 fZVertexCut(10.0),
128 fnHadronTTBins(0),
129 fnJetChTTBins(0),
130 fFillTTree(0)
131 {
132  //default constructor
133 
134  for(Int_t i=0; i<2; i++) fNClusters[i] = 0;
135  for(Int_t i=0; i<8; i++) fRingMultV0[i] = 0;
136 
137  for(Int_t i=0; i<5; i++){
138  fZNCtower[i] = 0;
139  fZPCtower[i] = 0;
140  fZNAtower[i] = 0;
141  fZPAtower[i] = 0;
142  fZNCtowerLG[i] = 0;
143  fZPCtowerLG[i] = 0;
144  fZNAtowerLG[i] = 0;
145  fZPAtowerLG[i] = 0;
146  }
147 
148  for(Int_t i=0; i<fkTTbins; i++){
149  fHadronTT[i] = 0;
150  fJetChTT[i] = 0;
151 
152  fhMultTTHinMB[i] = 0x0;
153  fhMultTTJinMB[i] = 0x0;
154  }
155 
156  for(Int_t i=0; i<fkTTbins;i++){
157  fHadronTTLowPt[i]=-1;
158  fHadronTTHighPt[i]=-1;
159  fJetChTTLowPt[i]=-1;
160  fJetChTTHighPt[i]=-1;
161  }
162 
163  for(Int_t iv=0; iv<fkVtx;iv++){
164  fhVertex[iv]=0x0;
165  for(Int_t i=0; i<fkTTbins;i++){
166  fhVertexTTH[iv][i]=0x0;
167  }
168  }
169 
170  for(Int_t ic=0; ic<fkCE;ic++){
171  fhCentralityMB[ic] = 0x0;
172  fhSignalMB[ic] = 0x0;
173 
174  for(Int_t i=0; i<fkTTbins;i++){
175  fhCentralityTTH[ic][i] = 0x0;
176  fhCentralityTTJ[ic][i] = 0x0;
177 
178  fhSignalTTH[ic][i] = 0x0;
179  fhSignalTTJ[ic][i] = 0x0;
180  }
181  }
182 
183 
184  sprintf(fTrigClass,"%s","");
185 }
186 
187 //________________________________________________________________________
189 AliAnalysisTaskEmcalJet(name,kTRUE),
190 fUseDefaultVertexCut(1),
191 fUsePileUpCut(1),
192 fMyTrackContainerName(""),
193 fMyParticleContainerName(""),
194 fMyJetContainerName(""),
195 fMyJetParticleContainerName(""),
196 fTrkContainerDetLevel(0x0),
197 fParticleContainerPartLevel(0x0),
198 fJetContainerDetLevel(0x0),
199 fJetContainerPartLevel(0x0),
200 fRhoTaskName(""),
201 fRhoTaskNameMC(""),
202 fCentralityTree(0x0),
203 fMultSelection(0x0),
204 fIsMinBiasTrig(1),
205 fIsEmcalTrig(0),
206 fCentralityV0A(-1),
207 fCentralityV0C(-1),
208 fCentralityCL1(-1),
209 fCentralityZNA(-1),
210 fCentralityZNC(-1),
211 fxVertex(-1),
212 fyVertex(-1),
213 fzVertex(-1),
214 fVertexer3d(1),
215 fNTracklets(-1),
216 fIsV0ATriggered(0),
217 fIsV0CTriggered(0),
218 fMultV0A(1),
219 fMultV0C(1),
220 fZEM1Energy(0),
221 fZEM2Energy(0),
222 fTrackEtaWindow(0.9),
223 fMinTrackPt(0.150),
224 fMC(0),
225 fHelperClass(0), fInitializedLocal(0),
226 fHistEvtSelection(0x0),
227 fhVertexZ(0x0),
228 fhTrackPhiIncl(0x0), fhTrackEtaIncl(0x0),
229 fhJetPhiIncl(0x0), fhJetEtaIncl(0x0),
230 fhRhoIncl(0x0),
231 fZVertexCut(10.0),
232 fnHadronTTBins(0),
233 fnJetChTTBins(0),
234 fFillTTree(0)
235 {
236  //Constructor
237 
238  for(Int_t i=0; i<2; i++) fNClusters[i] = 0;
239  for(Int_t i=0; i<8; i++) fRingMultV0[i] = 0;
240 
241  for(Int_t i=0; i<5; i++){
242  fZNCtower[i] = 0;
243  fZPCtower[i] = 0;
244  fZNAtower[i] = 0;
245  fZPAtower[i] = 0;
246  fZNCtowerLG[i] = 0;
247  fZPCtowerLG[i] = 0;
248  fZNAtowerLG[i] = 0;
249  fZPAtowerLG[i] = 0;
250  }
251 
252  //arrays number of triggers
253  for(Int_t i=0; i<fkTTbins; i++){
254  fHadronTT[i] = 0;
255  fJetChTT[i] = 0;
256 
257  fhMultTTHinMB[i] = 0x0;
258  fhMultTTJinMB[i] = 0x0;
259  }
260 
261  for(Int_t i=0; i<fkTTbins;i++){
262  fHadronTTLowPt[i]=-1;
263  fHadronTTHighPt[i]=-1;
264  fJetChTTLowPt[i]=-1;
265  fJetChTTHighPt[i]=-1;
266  }
267 
268  for(Int_t iv=0; iv<fkVtx;iv++){
269  fhVertex[iv]=0x0;
270  for(Int_t i=0; i<fkTTbins;i++){
271  fhVertexTTH[iv][i]=0x0;
272  }
273  }
274 
275  for(Int_t ic=0; ic<fkCE;ic++){
276  fhCentralityMB[ic] = 0x0;
277  fhSignalMB[ic] = 0x0;
278 
279  for(Int_t i=0; i<fkTTbins;i++){
280  fhCentralityTTH[ic][i] = 0x0;
281  fhCentralityTTJ[ic][i] = 0x0;
282 
283  fhSignalTTH[ic][i] = 0x0;
284  fhSignalTTJ[ic][i] = 0x0;
285  }
286  }
287 
288 
289  sprintf(fTrigClass,"%s","");
290  //inclusive pT spectrum times the boost function
291 
292  DefineOutput(1, TList::Class());
293 }
294 
295 //_____________________________________________________________________________________
297 
298  TString trigger = fInputEvent->GetFiredTriggerClasses();
299  bool passedGammaTrigger = kFALSE;
300  //SELECT ALSO DCAL????PreSelection checks just EMCAL
301  if(trigger.Contains("EG1") || trigger.Contains("EG2") || trigger.Contains("DG1") || trigger.Contains("DG2")){
302  passedGammaTrigger = kTRUE;
303  }
304  return passedGammaTrigger;
305 
306 }
307 //_____________________________________________________________________________________
309 
310  TString trigger = fInputEvent->GetFiredTriggerClasses();
311  bool passedTrigger = kFALSE;
312  if(trigger.Contains("INT7")){
313  passedTrigger = kTRUE;
314  }
315  return passedTrigger;
316 
317 }
318 
319 //_____________________________________________________________________________________
321 
322  // Get rho from event using CMS approach
323  AliRhoParameter* rho = NULL;
324  TString rhoname = (!isMC) ? fRhoTaskName : fRhoTaskNameMC;
325  if(!rhoname.IsNull()){
326  rho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(rhoname.Data()));
327  if (!rho) {
328  //AliWarningF(MSGWARNING("%s: Could not retrieve rho with name %s!"), GetName(), rhoname.Data());
329  return 0.;
330  }
331  }else{
332  //AliWarningF(MSGWARNING("No %s Rho task name provided"), (!isMC ? "DATA" : "MC"));
333  return 0.;
334  }
335 
336  return rho->GetVal();
337 }
338 //________________________________________________________________________
339 
341  //EVENT SELECTION RECONSTRUCTED DATA
342 
343 
344  if(!event) return kFALSE;
345 
346  //___________________________________________________
347  //TEST PILE UP
348  if(fUsePileUpCut){
349  if(!fHelperClass || fHelperClass->IsPileUpEvent(event)){
350  fHistEvtSelection->Fill(1.5); //count events rejected by pileup
351  return kFALSE;
352  }
353  }
354  //___________________________________________________
355  //VERTEX CUT
356 
358  if(!fHelperClass || !fHelperClass->IsVertexSelected2013pA(event)){ //??? USE THIS OR SOMETHING ELSE
359  fHistEvtSelection->Fill(2.5); //count events rejected by vertex cut
360  return kFALSE;
361  }
362  }else{
363  if(TMath::Abs(event->GetPrimaryVertex()->GetZ()) > fZVertexCut){
364  fHistEvtSelection->Fill(2.5); //count events rejected by vertex cut
365  return kFALSE;
366  }
367  }
368  //___________________________________________________
369  //AFTER VERTEX CUT
370  fhVertexZ->Fill(event->GetPrimaryVertex()->GetZ());
371 
372 
373  return kTRUE;
374 }
375 
376 //________________________________________________________________________
378  // Check if the track pt and eta range
379  if(!track) return kFALSE;
380 
381  if(isGen){ //particle level MC: select charged physical primary tracks
382  //Apply only for kine level or MC containers
383  if(!track->Charge()) return kFALSE;
384  if(fMC == kPartLevel){
385  if(!(static_cast<AliAODMCParticle*>(track))->IsPhysicalPrimary()) return kFALSE;
386  }
387  }
388  if(TMath::Abs(track->Eta()) < fTrackEtaWindow){ //APPLY TRACK ETA CUT
389  if(track->Pt() > fMinTrackPt){ //APPLY TRACK PT CUT
390  return kTRUE;
391  }
392  }
393  return kFALSE;
394 }
395 //________________________________________________________________________
397  // Initialization of jet containers done in AliAnalysisTaskEmcalJet::ExecOnce()
398  //Read arrays of jets and tracks
399  fInitializedLocal = kTRUE;
400 
401  // Initialize helper class (for vertex selection & pile up correction)
402  fHelperClass = new AliAnalysisUtils();
403  fHelperClass->SetCutOnZVertexSPD(kFALSE); // kFALSE: no cut; kTRUE: |zvtx-SPD - zvtx-TPC|<0.5cm
404 
405 
406  return;
407 }
408 
409 //________________________________________________________________________
411  if(!cluster->IsEMCAL()) return kFALSE;
412  if(cluster->E()<0.7) return kFALSE;
413  return kTRUE;
414 }
415 
416 //________________________________________________________________________
418 /*
419  //General QA.
420  if(!cluster->IsEMCAL()) return kFALSE;
421 
422  if( cluster->GetNCells() < 2) return kFALSE;
423 
424  Int_t disToBad = cluster->GetDistanceToBadChannel();
425  if(disToBad<2) return kFALSE;
426 
427  Int_t disToBorder = GetMaxDistanceFromBorder(cluster);
428  if(disToBorder<1) return kFALSE;
429 
430  Double_t exoticity = GetExoticity(cluster);
431  if(exoticity>0.97) return kFALSE;
432 
433  Double_t time = cluster->GetTOF()*1000000000; //in ns
434  if(!fMC && std::abs(time)>30) return kFALSE;
435 */
436  return kTRUE;
437 }
438 
439 //________________________________________________________________________
441  // executed in each event
442  //called in AliAnalysisTaskEmcal::UserExec(Option_t *)
443  // Analyze the event and Fill histograms
444 
445  if(!InputEvent()){
446  AliError("??? Event pointer == 0 ???");
447  return kFALSE;
448  }
449 
450  //Execute only once: Get tracks, jets from arrays if not already given
452 
453 
454  //_________________________________________________________________
455  // EVENT SELECTION
456  fHistEvtSelection->Fill(0.5); //Count input event
457 
458  //Check Reconstructed event vertex and pileup
459  if(!IsEventInAcceptance(InputEvent())) return kFALSE; //post data is in UserExec
460 
461 
462  fIsMinBiasTrig = kFALSE; //Minimum bias event flag
463  if(PassedMinBiasTrigger()){
464  fIsMinBiasTrig = kTRUE;
465  fHistEvtSelection->Fill(3.5); //Count Accepted input event
466  }
467 
468  fIsEmcalTrig = kFALSE; //EMCAL triggered event flag
469  if(PassedGATrigger()){
470  fIsEmcalTrig = kTRUE;
471  fHistEvtSelection->Fill(4.5); //Count Accepted input event
472  }
473 
474 
475  if(!fIsEmcalTrig && !fIsMinBiasTrig) return kFALSE; //post data is in UserExec
476 
477 
478  // END EVENT SELECTION
479  //_________________________________________________________________
480  // EVENT PROPERTIES
481 
482  for(int ir=0; ir<8; ir++) fRingMultV0[ir]=0.;
483 
484  // ***** Trigger selection
485  TString triggerClass = InputEvent()->GetFiredTriggerClasses();
486  sprintf(fTrigClass,"%s",triggerClass.Data());
487 
488 
489  fMultSelection = (AliMultSelection*) InputEvent()->FindListObject("MultSelection");
490  if(fMultSelection){
491  fCentralityV0A = fMultSelection->GetMultiplicityPercentile("V0A");
492  fCentralityV0C = fMultSelection->GetMultiplicityPercentile("V0C");
493  fCentralityCL1 = fMultSelection->GetMultiplicityPercentile("CL1");
494  fCentralityZNA = fMultSelection->GetMultiplicityPercentile("ZNA");
495  fCentralityZNC = fMultSelection->GetMultiplicityPercentile("ZNC");
496  }else{
497  fCentralityV0A = -1;
498  fCentralityV0C = -1;
499  fCentralityCL1 = -1;
500  fCentralityZNA = -1;
501  fCentralityZNC = -1;
502  }
503 
504  const AliVVertex *vertex = InputEvent()->GetPrimaryVertexSPD();
505  if(vertex){
506  fxVertex = vertex->GetX();
507  fyVertex = vertex->GetY();
508  fzVertex = vertex->GetZ();
509  if(vertex->IsFromVertexer3D()) fVertexer3d = kTRUE;
510  else fVertexer3d = kFALSE;
511  }else{
512  fxVertex = 9999.;
513  fyVertex = 9999.;
514  fzVertex = 9999.;
515  fVertexer3d = kFALSE;
516  }
517 
518  const AliVMultiplicity *mult = InputEvent()->GetMultiplicity();
519  if(mult){
520  fNTracklets = mult->GetNumberOfTracklets();
521 
522  for(Int_t ilay=0; ilay<2; ilay++){
523  fNClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
524  }
525  }else{
526  fNTracklets = -9999;
527  for(Int_t ilay=0; ilay<2; ilay++){
528  fNClusters[ilay] = -9999;
529  }
530  }
531 
532 
533 
534  AliVVZERO *vzeroAOD = InputEvent()->GetVZEROData();
535  if(vzeroAOD){
536  fMultV0A = vzeroAOD->GetMTotV0A();
537  fMultV0C = vzeroAOD->GetMTotV0C();
538  fIsV0ATriggered = vzeroAOD->GetV0ADecision();
539  fIsV0CTriggered = vzeroAOD->GetV0CDecision();
540 
541  for(Int_t iRing = 0; iRing < 8; ++iRing){
542  for(Int_t i = 0; i < 8; ++i){
543  fRingMultV0[iRing] += vzeroAOD->GetMultiplicity(8*iRing+i);
544  }
545  }
546  }else{
547  fMultV0A = -1;
548  fMultV0C = -1;
549  fIsV0ATriggered = kFALSE;
550  fIsV0CTriggered = kFALSE;
551 
552  for(Int_t iRing = 0; iRing < 8; ++iRing){
553  for(Int_t i = 0; i < 8; ++i){
554  fRingMultV0[iRing] += 0;
555  }
556  }
557  }
558 
559 
560  AliAODZDC *aodZDC =dynamic_cast<AliAODZDC*> (InputEvent()->GetZDCData());
561  if(aodZDC){
562 
563  fZEM1Energy = (Float_t) (aodZDC->GetZEM1Energy());
564  fZEM2Energy = (Float_t) (aodZDC->GetZEM2Energy());
565 
566  const Double_t* towZNC = aodZDC->GetZNCTowerEnergy();
567  const Double_t* towZPC = aodZDC->GetZPCTowerEnergy();
568  const Double_t* towZNA = aodZDC->GetZNATowerEnergy();
569  const Double_t* towZPA = aodZDC->GetZPATowerEnergy();
570  //
571  const Double_t* towZNCLG = aodZDC->GetZNCTowerEnergyLR();
572  const Double_t* towZPCLG = aodZDC->GetZPCTowerEnergyLR();
573  const Double_t* towZNALG = aodZDC->GetZNATowerEnergyLR();
574  const Double_t* towZPALG = aodZDC->GetZPATowerEnergyLR();
575  //
576  for(Int_t it=0; it<5; it++){
577  fZNCtower[it] = (Float_t) (towZNC[it]);
578  fZPCtower[it] = (Float_t) (towZPC[it]);
579  fZNAtower[it] = (Float_t) (towZNA[it]);
580  fZPAtower[it] = (Float_t) (towZPA[it]);
581  fZNCtowerLG[it] = (Float_t) (towZNCLG[it]);
582  fZPCtowerLG[it] = (Float_t) (towZPCLG[it]);
583  fZNAtowerLG[it] = (Float_t) (towZNALG[it]);
584  fZPAtowerLG[it] = (Float_t) (towZPALG[it]);
585  }
586  }else{
587  fZEM1Energy = -1;
588  fZEM2Energy = -1;
589  for(Int_t it=0; it<5; it++){
590  fZNCtower[it] = -1;
591  fZPCtower[it] = -1;
592  fZNAtower[it] = -1;
593  fZPAtower[it] = -1;
594  fZNCtowerLG[it] = -1;
595  fZPCtowerLG[it] = -1;
596  fZNAtowerLG[it] = -1;
597  fZPAtowerLG[it] = -1;
598  }
599  }
600 
601 
602 
603 
604 
605 
606  //_________________________________________________________________
607  // JET+TRACK CONTAINERS
608 
609  AliEmcalJet *jet = NULL; //jet pointer real jet
610  AliEmcalJet *jetMC = NULL; //jet pointer real jet
611  AliVParticle *track = NULL; //jet constituent
612 
613  //_________________________________________________________
614  //READ TRACK AND JET CONTAINERS
615  //Container operations http://alidoc.cern.ch/AliPhysics/master/READMEcontainers.html#emcalContainerIterateTechniques
616 
617  fTrkContainerDetLevel = static_cast<AliTrackContainer*> (GetTrackContainer(fMyTrackContainerName.Data())); //reconstructed particle container
618  fJetContainerDetLevel = static_cast<AliJetContainer*> (GetJetContainer(fMyJetContainerName.Data())); //AKT jet
619 
620  if(fMC){
621  fParticleContainerPartLevel = GetParticleContainer(fMyParticleContainerName.Data()); //reconstructed particle container
622  fJetContainerPartLevel = GetJetContainer(fMyJetParticleContainerName.Data()); //reconstructed particle container
623  }
624 
625 //
626 // //EMCAL CLUSTERS
627 // AliClusterContainer* clusters = GetClusterContainer(0);
628 // if(!clusters) AliError(Form("Could not retrieve clusters!"));
629 //
630 // //Filling cluster and pion THnSparsesx
631 // for(auto cluster: clusters->accepted()){
632 // if(!PreSelection(cluster)) continue;
633 //
634 // Bool_t passed = FinalClusterCuts(cluster);
635 //
636 // //FillClusterHisto(cluster, h_Cluster);
637 // for(auto cluster2: clusters->accepted()){
638 // if(!PreSelection(cluster2)) continue;
639 // if(cluster==cluster2) continue;
640 // // FillPionHisto(cluster, cluster2, h_Pi0);
641 //
642 // // AVOID DOUBLE COUNTING !!!!!!!!!!!!!!!
643 // }
644 // }
645 //
646 
647  if(fIsMinBiasTrig){
648  fhVertex[0]->Fill(fxVertex);
649  fhVertex[1]->Fill(fyVertex);
650  fhVertex[2]->Fill(fzVertex);
651 
652 
653  fhCentralityMB[0]->Fill(fCentralityV0A);
654  fhCentralityMB[1]->Fill(fCentralityV0C);
655  fhCentralityMB[2]->Fill(fCentralityCL1);
656  fhCentralityMB[3]->Fill(fCentralityZNA);
657  fhCentralityMB[4]->Fill(fCentralityZNC);
658 
659  fhSignalMB[0]->Fill(fMultV0A);
660  fhSignalMB[1]->Fill(fMultV0C);
661  fhSignalMB[2]->Fill(fNTracklets);
662  fhSignalMB[3]->Fill(fZNAtower[0]);
663  fhSignalMB[4]->Fill(fZNCtower[0]);
664  }
665 
666 
667 
668 
669 
670 
671 
672  //_________________________________________________________
673  //LOOP OVER TRACKS DETECTOR LEVEL + SEARCH FOR HIGH PT HADRON TRIGGER
674 
675  for(Int_t i=0; i<fnHadronTTBins; i++){
676  fHadronTT[i] = 0;
677  }
678 
679 
680  for(auto trackIterator : fTrkContainerDetLevel->accepted_momentum() ){
681  // trackIterator is a std::map of AliTLorentzVector and AliVTrack
682  track = trackIterator.second; // Get the full track
683 
684  if(IsTrackInAcceptance(track, kDetLevel)){
685 
686 
687  if(fIsMinBiasTrig){
688  //fill some histograms for detector level tracks
689  fhTrackPhiIncl->Fill(track->Pt(), track->Phi());
690  fhTrackEtaIncl->Fill(track->Pt(), track->Eta());
691  }
692 
693  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
694  if(fHadronTTLowPt[itt] < track->Pt() && track->Pt() < fHadronTTHighPt[itt]){
695  fHadronTT[itt]++; // there was a high pt
696  }
697  }
698  }
699  }
700 
701 
702 
703 
704  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
705 
706  fhMultTTHinMB[itt]->Fill(fHadronTT[itt]);
707 
708  if(!fHadronTT[itt]) continue;
709  fhVertexTTH[0][itt]->Fill(fxVertex);
710  fhVertexTTH[1][itt]->Fill(fyVertex);
711  fhVertexTTH[2][itt]->Fill(fzVertex);
712 
713 
714  fhCentralityTTH[fkV0A][itt]->Fill(fCentralityV0A);
715  fhCentralityTTH[fkV0C][itt]->Fill(fCentralityV0C);
716  fhCentralityTTH[fkSPD][itt]->Fill(fCentralityCL1);
717  fhCentralityTTH[fkZNA][itt]->Fill(fCentralityZNA);
718  fhCentralityTTH[fkZNC][itt]->Fill(fCentralityZNC);
719 
720  fhSignalTTH[fkV0A][itt]->Fill(fMultV0A);
721  fhSignalTTH[fkV0C][itt]->Fill(fMultV0C);
722  fhSignalTTH[fkSPD][itt]->Fill(fNTracklets);
723  fhSignalTTH[fkZNA][itt]->Fill(fZNAtower[0]);
724  fhSignalTTH[fkZNC][itt]->Fill(fZNCtower[0]);
725 
726  }
727 
728  //_________________________________________________________
729  //LOOP OVER JETS DETECTOR LEVEL
730 
731  for(Int_t i=0; i<fnJetChTTBins; i++){
732  fJetChTT[i] = 0;
733  }
734 
735  Double_t rho = GetExternalRho(kDetLevel); //estimated backround pt density
736 
737  if(fIsMinBiasTrig){
738  fhRhoIncl->Fill(rho);
739  }
740 
741  for(auto jetIterator : fJetContainerDetLevel->accepted_momentum() ){
742  // trackIterator is a std::map of AliTLorentzVector and AliVTrack
743  jet = jetIterator.second; // Get the pointer to jet object
744  if(!jet) continue;
745 
746  if(fIsMinBiasTrig){
747  //fill some histograms for detector level jets
748  fhJetPhiIncl->Fill(jet->Pt(), jet->Phi());
749  fhJetEtaIncl->Fill(jet->Pt(), jet->Eta());
750  }
751 
752  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
753  if(fJetChTTLowPt[ijj] < jet->Pt() && jet->Pt() < fJetChTTHighPt[ijj]){
754  fJetChTT[ijj]++; // there was a high pt
755  }
756  }
757 
758  //loop over jet constituents
759  //for(Int_t iq=0; iq < jet->GetNumberOfTracks(); iq++) {
760  // track = (AliVParticle*) (jet->TrackAt(iq, fTrkContainerDetLevel->GetArray()));
761  //here one can e.g. analyze jet shapes
762 
763  //}
764 
765 
766  //you can also find the closest particle level jet to given detector level
767  //the mateching betwe particle and detector level jets is done in Tagger task
768  //if(fMC){
769  // jetMC = jet->ClosestJet();
770  //}
771  }
772 
773  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
774 
775  fhMultTTJinMB[ijj]->Fill(fJetChTT[ijj]);
776 
777  if(!fJetChTT[ijj]) continue;
778 
779  fhCentralityTTJ[fkV0A][ijj]->Fill(fCentralityV0A);
780  fhCentralityTTJ[fkV0C][ijj]->Fill(fCentralityV0C);
781  fhCentralityTTJ[fkSPD][ijj]->Fill(fCentralityCL1);
782  fhCentralityTTJ[fkZNA][ijj]->Fill(fCentralityZNA);
783  fhCentralityTTJ[fkZNC][ijj]->Fill(fCentralityZNC);
784 
785 
786  fhSignalTTJ[fkV0A][ijj]->Fill(fMultV0A);
787  fhSignalTTJ[fkV0C][ijj]->Fill(fMultV0C);
788  fhSignalTTJ[fkSPD][ijj]->Fill(fNTracklets);
789  fhSignalTTJ[fkZNA][ijj]->Fill(fZNAtower[0]);
790  fhSignalTTJ[fkZNC][ijj]->Fill(fZNCtower[0]);
791 
792  }
793 
794 
795 
796  //___________________________________________________________
797 //
798 // if(fMC){
799 //
800 // //_________________________________________________________
801 // //LOOP OVER PARTICLE LEVEL
802 //
803 // for(auto trackIterator : fParticleContainerPartLevel->accepted_momentum() ){
804 // // trackIterator is a std::map of AliTLorentzVector and AliVTrack
805 // track = trackIterator.second; // Get the full track
806 //
807 // if(IsTrackInAcceptance(track, kPartLevel)){
808 // //here fill some histograms for particle level particles
809 //
810 // }
811 // }
812 //
813 // //_________________________________________________________
814 // //LOOP OVER JETS PARTICLE LEVEL
815 //
816 //
817 // Double_t rhoMC = GetExternalRho(kPartLevel); //estimated backround pt density
818 //
819 // for(auto jetIterator : fJetContainerPartLevel->accepted_momentum() ){
820 // // trackIterator is a std::map of AliTLorentzVector and AliVTrack
821 // jet = jetIterator.second; // Get the pointer to jet object
822 //
823 // //fill some histograms for detector level jets
824 // fhJetPhiIncl->Fill(jet->Pt(), jet->Phi());
825 // fhJetEtaIncl->Fill(jet->Pt(), jet->Eta());
826 //
827 // //loop over jet constituents at particle level
828 // for(Int_t iq=0; iq < jet->GetNumberOfTracks(); iq++) {
829 // track = (AliVParticle*) (jet->TrackAt(iq, fParticleContainerPartLevel->GetArray()));
830 // //here one can e.g. analyze jet shapes
831 //
832 // }
833 //
834 // }
835 //
836 // }
837 
838  if(fFillTTree){
839  fCentralityTree->Fill();
840  }
841 
842 
843  return kTRUE;
844 }
845 
846 //________________________________________________________________________
848  //Treminate
849  PostData(1, fOutput);
850 
851  // Mandatory
852  fOutput = dynamic_cast<AliEmcalList*> (GetOutputData(1)); // '1' refers to the output slot
853  if(!fOutput) {
854  printf("ERROR: Output list not available\n");
855  return;
856  }
857 }
858 
859 //________________________________________________________________________
861  // Destructor. Clean-up the output list, but not the histograms that are put inside
862  // (the list is owner and will clean-up these histograms). Protect in PROOF case.
863  if(fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
864  delete fOutput;
865  }
866  delete fHelperClass;
867 
868 }
869 
870 //________________________________________________________________________
872  // called once to create user defined output objects like histograms, plots etc.
873  // and to put it on the output list.
874  // Note: Saving to file with e.g. OpenFile(0) is must be before creating other objects.
875  //fOutput TList defined in the mother class
877 
878  Bool_t oldStatus = TH1::AddDirectoryStatus();
879  TH1::AddDirectory(kFALSE);
880  TString name, object;
881 
882 
883  //__________________________________________________________
884  // Event statistics
885  fHistEvtSelection = new TH1I("fHistEvtSelection", "event selection", 5, 0, 5);
886  fHistEvtSelection->GetXaxis()->SetBinLabel(1,"events IN");
887  fHistEvtSelection->GetXaxis()->SetBinLabel(2,"pile up (rejected)");
888  fHistEvtSelection->GetXaxis()->SetBinLabel(3,"vertex cut (rejected)");
889  fHistEvtSelection->GetXaxis()->SetBinLabel(4,"MB");
890  fHistEvtSelection->GetXaxis()->SetBinLabel(5,"EMCAL");
891 
892 
894 
895 
896  //_______________________________________________________________________
897  //inclusive azimuthal and pseudorapidity histograms
898 
899  fhVertexZ = new TH1F("fhVertexZ","z vertex",40,-20,20);
900  fOutput->Add(fhVertexZ);
901 
902  //-------------------------
903 
904  fhTrackEtaIncl = new TH2F("fhTrackEtaIncl","Eta dist inclusive track vs pTjet", 50,0, 100, 40,-0.9,0.9);
905  fOutput->Add((TH2F*) fhTrackEtaIncl);
906 
907  fhTrackPhiIncl = new TH2F("fhTrackPhiIncl","Azim dist tracks vs pTjet", 50, 0, 100, 50,0,2*TMath::Pi());
908  fOutput->Add((TH2F*) fhTrackPhiIncl);
909 
910  fhJetEtaIncl = new TH2F("fhJetEtaIncl","Eta dist inclusive jets vs pTjet", 150, -20, 130, 40,-0.9,0.9);
911  fOutput->Add((TH2F*) fhJetEtaIncl);
912 
913  fhJetPhiIncl = new TH2F("fhJetPhiIncl","Azim dist jets vs pTjet", 50, 0, 100, 50,0,2*TMath::Pi());
914  fOutput->Add((TH2F*) fhJetPhiIncl);
915 
916  fhRhoIncl = new TH1F("hRho","Rho",1000,0,100);
917  fOutput->Add((TH1F*) fhRhoIncl);
918 
919 
920  for(Int_t iv=0; iv<fkVtx;iv++){
921  if(iv==0) fhVertex[iv] = new TH1D("hVertexX","VertexX",100,-1,1);
922  else if(iv==1) fhVertex[iv] = new TH1D("hVertexY","VertexY",100,-1,1);
923  else fhVertex[iv] = new TH1D("hVertexZ","VertexZ",400,-20,20);
924  fOutput->Add((TH1D*) fhVertex[iv]);
925  }
926 
927  for(Int_t iv=0; iv<fkVtx;iv++){
928  for(Int_t itt=0; itt<fnHadronTTBins;itt++){
929  name = Form("%s_TTH%d_%d", fhVertex[iv]->GetName(), fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
930  fhVertexTTH[iv][itt] = (TH1D*) fhVertex[iv]->Clone(name.Data());
931  fOutput->Add((TH1D*) fhVertexTTH[iv][itt]);
932  }
933  }
934 
935  TString cest[fkCE] = {"V0A", "V0C", "SPD", "ZNA", "ZNC"}; //centrality estimators
936 
937  for(Int_t ic=0; ic<fkCE;ic++){
938  name = Form("hCentralityMB_%s",cest[ic].Data());
939  fhCentralityMB[ic] = new TH1D(name.Data(), name.Data(),101,0,101);
940  fOutput->Add((TH1D*) fhCentralityMB[ic]);
941  }
942 
943  for(Int_t ic=0; ic<fkCE;ic++){
944  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
945  name = Form("hCentrality_%s_TTH%d_%d",cest[ic].Data(), fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
946  fhCentralityTTH[ic][itt] = new TH1D(name.Data(), name.Data(),101,0,101);
947  }
948  }
949 
950  for(Int_t ic=0; ic<fkCE;ic++){
951  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
952  name = Form("hCentrality_%s_TTJ%d_%d", cest[ic].Data(), fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
953  fhCentralityTTJ[ic][ijj] = new TH1D(name.Data(), name.Data(),101,0,101);
954  }
955  }
956 
957  TString signal[]={"multV0A", "multV0C", "nTracklets", "znatower0", "znctower0"};
958  Float_t signalL[]={0,0,0,0,0};
959  Float_t signalH[]={1000,1000,500,30000,30000};
960  Int_t signalN[]={100,100,100,100,100};
961 
962  for(Int_t ic=0; ic<fkCE;ic++){
963  name = Form("hSignalMB_%s", cest[ic].Data());
964  fhSignalMB[ic] = new TH1D(name.Data(), name.Data(), signalN[ic], signalL[ic], signalH[ic]);
965  fOutput->Add((TH1D*) fhSignalMB[ic]);
966  }
967 
968 
969  for(Int_t ic=0; ic<fkCE;ic++){
970  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
971  name = Form("hSignal_%s_TTH%d_%d", cest[ic].Data(), fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
972  fhSignalTTH[ic][itt] = new TH1D(name.Data(),name.Data(),signalN[ic], signalL[ic], signalH[ic]);
973  fOutput->Add((TH1D*) fhSignalTTH[ic][itt]);
974  }
975  }
976 
977  for(Int_t ic=0; ic<fkCE;ic++){
978  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
979  name = Form("hSignal_%s_TTJ%d_%d", cest[ic].Data(), fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
980  fhSignalTTJ[ic][ijj] = new TH1D(name.Data(),name.Data(),signalN[ic], signalL[ic], signalH[ic]);
981  fOutput->Add((TH1D*) fhSignalTTJ[ic][ijj]);
982  }
983  }
984 
985 
986  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
987  name = Form("hMultTTHinMB_TTH%d_%d", fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
988  fhMultTTHinMB[itt] = new TH1D(name.Data(),name.Data(),100,0,100);
989  fOutput->Add((TH1D*) fhMultTTHinMB[itt]);
990  }
991 
992  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
993  name = Form("hMultTTJinMB_TTJ%d_%d", fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
994  fhMultTTJinMB[ijj] = new TH1D(name.Data(),name.Data(),100,0,100);
995  fOutput->Add((TH1D*) fhMultTTJinMB[ijj]);
996  }
997 
998  // OUTPUT TREE
999  if(fFillTTree){
1000  fCentralityTree = new TTree("fCentralityTree", "Centrality vs. multiplicity tree");
1001  //
1002  fCentralityTree->Branch("trigClass",fTrigClass,"trigClass/C");
1003  fCentralityTree->Branch("xVertex", &fxVertex,"xVertex/D");
1004  fCentralityTree->Branch("yVertex", &fyVertex,"yVertex/D");
1005  fCentralityTree->Branch("zVertex", &fzVertex,"zVertex/D");
1006  fCentralityTree->Branch("vertexer3d", &fVertexer3d,"vertexer3d/O");
1007  fCentralityTree->Branch("nTracklets", &fNTracklets,"nTracklets/I");
1008  fCentralityTree->Branch("nClusters", fNClusters,"nClusters[2]/I");
1009  //
1010  fCentralityTree->Branch("isV0ATriggered", &fIsV0ATriggered,"isV0ATriggered/I");
1011  fCentralityTree->Branch("isV0CTriggered", &fIsV0CTriggered,"isV0CTriggered/I");
1012  fCentralityTree->Branch("multV0A", &fMultV0A,"multV0A/F");
1013  fCentralityTree->Branch("multV0C", &fMultV0C,"multV0C/F");
1014  fCentralityTree->Branch("ringmultV0", fRingMultV0,"ringmultV0[8]/F");
1015 
1016  fCentralityTree->Branch("znctower", fZNCtower, "znctower[5]/F");
1017  fCentralityTree->Branch("zpctower", fZPCtower, "zpctower[5]/F");
1018  fCentralityTree->Branch("znatower", fZNAtower, "znatower[5]/F");
1019  fCentralityTree->Branch("zpatower", fZPAtower, "zpatower[5]/F");
1020  fCentralityTree->Branch("znctowerLG", fZNCtowerLG, "znctowerLG[5]/F");
1021  fCentralityTree->Branch("zpctowerLG", fZPCtowerLG, "zpctowerLG[5]/F");
1022  fCentralityTree->Branch("znatowerLG", fZNAtowerLG, "znatowerLG[5]/F");
1023  fCentralityTree->Branch("zpatowerLG", fZPAtowerLG, "zpatowerLG[5]/F");
1024 
1025  //fCentralityTree->Branch("tdc", fTDCvalues, "tdc[32][4]/I");
1026  //fCentralityTree->Branch("tdcSum", &fTDCSum, "tdcSum/F");
1027  //fCentralityTree->Branch("tdcDiff", &fTDCDiff, "tdcDiff/F");
1028 
1029  fCentralityTree->Branch("centrV0Amult", &fCentralityV0A, "centrV0Amult/F");
1030  fCentralityTree->Branch("centrV0Cmult", &fCentralityV0C, "centrV0Cmult/F");
1031  fCentralityTree->Branch("centrSPDclu1", &fCentralityCL1, "centrSPDclu1/F");
1032  fCentralityTree->Branch("centrZNA", &fCentralityZNA, "centrZNA/F");
1033  fCentralityTree->Branch("centrZNC", &fCentralityZNC, "centrZNC/F");
1034 
1035  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
1036  name = Form("hadronTTbin_%d_%d",fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
1037  object = name;
1038  object.Append("/I"); //Number of tracks in given bin
1039 
1040  fCentralityTree->Branch(name.Data(), &(fHadronTT[itt]), object.Data());
1041  }
1042 
1043  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1044  name = Form("jetchTTbin_%d_%d",fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
1045  object = name;
1046  object.Append("/I"); //Number of jets in given bin
1047 
1048  fCentralityTree->Branch(name.Data(), &(fJetChTT[ijj]), object.Data());
1049  }
1050 
1051  fOutput->Add(fCentralityTree);
1052  }
1053 
1054 
1055 
1056  // =========== Switch on Sumw2 for all histos ===========
1057  for(Int_t i=0; i<fOutput->GetEntries(); i++){
1058  TH1 *h1 = dynamic_cast<TH1*>(fOutput->At(i));
1059  if(h1){
1060  h1->Sumw2();
1061  continue;
1062  }
1063  THnSparse *hn = dynamic_cast<THnSparse*>(fOutput->At(i));
1064  if(hn){
1065  hn->Sumw2();
1066  }
1067  }
1068  TH1::AddDirectory(oldStatus);
1069 
1070 
1071  PostData(1, fOutput);
1072 }
1073 //________________________________________________________________________
1075  //
1076  // retrieve event objects
1077  //
1078  if(!AliAnalysisTaskEmcalJet::RetrieveEventObjects()) return kFALSE;
1079 
1080  return kTRUE;
1081 }
1082 //________________________________________________________________________
1084 {
1085  // Run analysis code here, if needed. It will be executed before FillHistograms().
1086 
1087  return kTRUE;
1088 }
1089 
1090 //________________________________________________________________________
1091 
AliAnalysisUtils * fHelperClass
TH1D * fhMultTTHinMB[fkTTbins]
distributions of centrality estimators biased with ch jet TT
Bool_t FillHistograms()
Function filling histograms.
Float_t fCentralityZNC
Centrality from ZNA.
Bool_t fVertexer3d
Z vertex from ITS.
TH2F * fhTrackEtaIncl
minimum bias phi inclusive
Int_t fJetChTTHighPt[fkTTbins]
double Double_t
Definition: External.C:58
Definition: External.C:236
AliJetContainer * GetJetContainer(Int_t i=0) const
Double_t Eta() const
Definition: AliEmcalJet.h:121
Int_t fNClusters[2]
no. tracklets
Double_t Phi() const
Definition: AliEmcalJet.h:117
Float_t fZPCtowerLG[5]
ZNC 5 tower signals.
Float_t fCentralityV0C
Centrality from V0A.
Container with name, TClonesArray and cuts for particles.
TString fMyParticleContainerName
Float_t fZNCtower[5]
ZEM2 Energy.
Bool_t fIsEmcalTrig
triggered by Min Bias Trig
TH2F * fhTrackPhiIncl
gc vertexZ inclusive
TH1I * fHistEvtSelection
trigger if tracks/jets are loaded initiates calling ExecOnce
TH1F * fhVertexZ
gc event statistics
Bool_t PreSelection(AliVCluster *cluster)
TH1D * fhCentralityTTH[fkCE][fkTTbins]
estimated centrality based on mult V0, mult VC, tracklets, znatower0, znctower0
Float_t fMultV0A
V0C decision.
TH2F * fhJetEtaIncl
minimum bias phi inclusive
Int_t fJetChTT[fkTTbins]
array which stores the number of triggers in given event
Int_t fHadronTTHighPt[fkTTbins]
Float_t fZPAtower[5]
ZNA 5 tower signals.
Float_t fMultV0C
mult. V0A
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
Float_t fZPCtower[5]
ZNC 5 tower signals.
TH1D * fhSignalTTJ[fkCE][fkTTbins]
distributions of centrality estimators biased with hadron TT
const AliJetIterableMomentumContainer accepted_momentum() const
int Int_t
Definition: External.C:63
TH1D * fhMultTTJinMB[fkTTbins]
multiplicity of hadron TT in MB event
Definition: External.C:204
Bool_t fFillTTree
array which stores the number of jets in given event
Int_t fNTracklets
Is vertex from 3d vertexer?
float Float_t
Definition: External.C:68
TH1D * fhVertex[fkVtx]
minimum bias rho inclusive
AliParticleContainer * fParticleContainerPartLevel
detector level track container
Float_t fCentralityV0A
triggered by EMCAL
Double_t fxVertex
Centrality from ZNC.
Float_t fZPAtowerLG[5]
ZNA 5 tower signals.
Definition: External.C:212
Int_t fIsV0CTriggered
VOA decision.
Int_t fHadronTT[fkTTbins]
TString fMyJetParticleContainerName
Float_t fCentralityZNA
Centrality from Clusters in layer 1.
TH1D * fhSignalMB[fkCE]
estimated centrality in events biased with hadron TT
Bool_t fIsMinBiasTrig
fired trigger classes
char fTrigClass[1000]
object which handels centrality
Float_t fZNAtowerLG[5]
ZPC 5 tower signals.
Bool_t FinalClusterCuts(AliVCluster *cluster)
Float_t fZEM2Energy
ZEM1 Energy.
TH1D * fhCentralityMB[fkCE]
vertex distribution in events biased with hadron TT
Double_t fTrackEtaWindow
ZPA 5 tower signals.
Float_t fZEM1Energy
V0 ring mult.
Double_t fZVertexCut
multiplicity of charged jet TT in MB event
Bool_t RetrieveEventObjects()
Retrieve common objects from event.
TH2F * fhJetPhiIncl
minimum bias eta inclusive
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
TH1D * fhSignalTTH[fkCE][fkTTbins]
distributions of centrality estimators: mult V0, mult VC, tracklets, znatower0, znctower0 ...
Double_t Pt() const
Definition: AliEmcalJet.h:109
Enhanced TList-derived class that implements correct merging for pt_hard binned production.
Definition: AliEmcalList.h:25
Bool_t isMC
AliEmcalList * fOutput
!output list
void Terminate(Option_t *)
Double_t fyVertex
X vertex from ITS.
TH1D * fhVertexTTH[fkVtx][fkTTbins]
vertex distribution
TH1F * fhRhoIncl
minimum bias eta inclusive
AliTrackContainer * GetTrackContainer(Int_t i=0) const
Int_t fJetChTTLowPt[fkTTbins]
Float_t fZNAtower[5]
ZPC 5 tower signals.
Base task in the EMCAL jet framework.
Double_t fzVertex
Y vertex from ITS.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:51
AliJetContainer * fJetContainerPartLevel
detector level jet container
const AliTrackIterableMomentumContainer accepted_momentum() const
Float_t fCentralityCL1
Centrality from V0C.
AliJetContainer * fJetContainerDetLevel
particle level container with particles
Bool_t IsTrackInAcceptance(AliVParticle *track, Bool_t isGen=0)
const char Option_t
Definition: External.C:48
TH1D * fhCentralityTTJ[fkCE][fkTTbins]
estimated centrality in events biased with hadron TT
AliTrackContainer * fTrkContainerDetLevel
void UserCreateOutputObjects()
Main initialization function on the worker.
Bool_t Run()
Run function. This is the core function of the analysis and contains the user code. Therefore users have to implement this function.
bool Bool_t
Definition: External.C:53
Bool_t fInitializedLocal
Vertex selection helper.
TString fRhoTaskName
particle level jet container
Int_t fHadronTTLowPt[fkTTbins]
Bool_t IsEventInAcceptance(AliVEvent *event)
Int_t fIsV0ATriggered
no. clusters on SPD layers
Float_t fZNCtowerLG[5]
ZPA 5 tower signals.
Container for jet within the EMCAL jet framework.
Definition: External.C:196
Double_t GetExternalRho(Bool_t isMC)
Float_t fRingMultV0[8]
mult. V0C
AliMultSelection * fMultSelection
output tree