AliPhysics  a3be53f (a3be53f)
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 #include "AliEMCALGeometry.h"
40 #include "AliEMCALGeoParams.h"
41 #endif
42 
43 #include <time.h>
44 #include <TRandom3.h>
45 #include "AliGenEventHeader.h"
46 #include "AliGenPythiaEventHeader.h"
47 #include "AliGenHijingEventHeader.h"
48 #include "AliAODMCHeader.h"
49 #include "AliMCEvent.h"
50 #include "AliLog.h"
51 #include <AliEmcalJet.h>
52 #include <AliPicoTrack.h>
53 #include "AliVEventHandler.h"
54 #include "AliVParticle.h"
55 #include "AliAODMCParticle.h"
56 #include "AliAnalysisUtils.h"
57 #include "AliRhoParameter.h"
58 #include "TVector3.h"
59 #include "AliVVertex.h"
60 #include "AliExternalTrackParam.h"
61 
62 #include <stdio.h>
63 #include <stdlib.h>
64 #include <vector>
65 
66 #include "AliGenDPMjetEventHeader.h"
67 #include "AliJetContainer.h"
68 #include "AliAnalysisTaskEmcal.h"
70 #include "AliAnalysisTaskEA.h"
71 #include "AliHeader.h"
72 #include "AliRunLoader.h"
73 #include "AliVVZERO.h"
74 #include "AliAODZDC.h"
75 #include "AliVZDC.h"
76 #include "AliMultSelection.h"
77 
78 using namespace std;
79 
80 // ANALYSIS OF HIGH PT HADRON TRIGGER ASSOCIATED SPECTRUM OF RECOIL JETS IN P+PB
81 // Author Filip Krizek (7.Oct. 2015)
82 
83 ClassImp(AliAnalysisTaskEA)
84 //________________________________________________________________________________________
85 
88 fUseDefaultVertexCut(1),
89 fUsePileUpCut(1),
90 fMyTrackContainerName(""),
91 fMyParticleContainerName(""),
92 fMyJetContainerName(""),
93 fMyJetParticleContainerName(""),
94 fMyClusterContainerName(""),
95 fTrkContainerDetLevel(0x0),
96 fParticleContainerPartLevel(0x0),
97 fJetContainerDetLevel(0x0),
98 fJetContainerPartLevel(0x0),
99 fClusterContainerDetLevel(0x0),
100 fRhoTaskName(""),
101 fRhoTaskNameMC(""),
102 fCentralityTree(0x0),
103 fMultSelection(0x0),
104 fIsMinBiasTrig(1),
105 fIsEmcalTrig(0),
106 fCentralityV0A(-1),
107 fCentralityV0C(-1),
108 fCentralityCL1(-1),
109 fCentralityZNA(-1),
110 fCentralityZNC(-1),
111 fxVertex(-1),
112 fyVertex(-1),
113 fzVertex(-1),
114 fVertexer3d(1),
115 fNTracklets(-1),
116 fIsV0ATriggered(0),
117 fIsV0CTriggered(0),
118 fMultV0A(1),
119 fMultV0C(1),
120 fZEM1Energy(0),
121 fZEM2Energy(0),
122 fTrackEtaWindow(0.9),
123 fMinTrackPt(0.150),
124 fMC(0),
125 fHelperClass(0), fInitializedLocal(0),
126 fHistEvtSelection(0x0),
127 fhVertexZ(0x0),
128 fhTrackPhiIncl(0x0), fhTrackEtaIncl(0x0),
129 fhJetPhiIncl(0x0), fhJetEtaIncl(0x0),
130 fhClusterPhiInclMB(0x0), fhClusterEtaInclMB(0x0),
131 fhClusterPhiInclGA(0x0), fhClusterEtaInclGA(0x0),
132 fhRhoIncl(0x0),
133 fhV0AvsV0C(0x0),
134 fhV0AvsSPD(0x0),
135 fhV0CvsSPD(0x0),
136 fZVertexCut(10.0),
137 fnHadronTTBins(0),
138 fnJetChTTBins(0),
139 fnClusterTTBins(0),
140 fFillTTree(0),
141 fSystem(AliAnalysisTaskEA::kpPb),
142 fFiducialCellCut(0x0)
143 {
144  //default constructor
145 
146  for(Int_t i=0; i<2; i++) fNClusters[i] = 0;
147  for(Int_t i=0; i<8; i++) fRingMultV0[i] = 0;
148 
149  for(Int_t i=0; i<5; i++){
150  fZNCtower[i] = 0;
151  fZPCtower[i] = 0;
152  fZNAtower[i] = 0;
153  fZPAtower[i] = 0;
154  fZNCtowerLG[i] = 0;
155  fZPCtowerLG[i] = 0;
156  fZNAtowerLG[i] = 0;
157  fZPAtowerLG[i] = 0;
158  }
159 
160  for(Int_t i=0; i<fkTTbins; i++){
161  fHadronTT[i] = 0;
162  fJetChTT[i] = 0;
163  fClusterTT[i] = 0;
164 
165  fhMultTTHinMB[i] = 0x0;
166  fhMultTTJinMB[i] = 0x0;
167  fhMultTTCinMB[i] = 0x0;
168  fhMultTTCinGA[i] = 0x0;
169  }
170 
171  for(Int_t i=0; i<fkTTbins;i++){
172  fHadronTTLowPt[i]=-1;
173  fHadronTTHighPt[i]=-1;
174  fJetChTTLowPt[i]=-1;
175  fJetChTTHighPt[i]=-1;
176  fClusterTTLowPt[i]=-1;
177  fClusterTTHighPt[i]=-1;
178 
179  fhV0AvsV0CTTH[i] = 0x0;
180  fhV0AvsV0CTTJ[i] = 0x0;
181  fhV0AvsV0CTTCinMB[i] = 0x0;
182  fhV0AvsV0CTTCinGA[i] = 0x0;
183  }
184 
185  for(Int_t iv=0; iv<fkVtx;iv++){
186  fhVertex[iv]=0x0;
187  for(Int_t i=0; i<fkTTbins;i++){
188  fhVertexTTH[iv][i]=0x0;
189  }
190  }
191 
192  for(Int_t ic=0; ic<fkCE;ic++){
193  fhCentralityMB[ic] = 0x0;
194  fhSignalMB[ic] = 0x0;
195 
196  for(Int_t i=0; i<fkTTbins;i++){
197  fhCentralityTTH[ic][i] = 0x0;
198  fhCentralityTTJ[ic][i] = 0x0;
199  fhCentralityTTCinMB[ic][i] = 0x0;
200  fhCentralityTTCinGA[ic][i] = 0x0;
201 
202  fhSignalTTH[ic][i] = 0x0;
203  fhSignalTTJ[ic][i] = 0x0;
204  fhSignalTTCinMB[ic][i] = 0x0;
205  fhSignalTTCinGA[ic][i] = 0x0;
206  }
207  }
208 
209 
210 
211  fFiducialCellCut = new AliEMCALRecoUtils();
212 
213  sprintf(fTrigClass,"%s","");
214 }
215 
216 //________________________________________________________________________
218 AliAnalysisTaskEmcalJet(name,kTRUE),
219 fUseDefaultVertexCut(1),
220 fUsePileUpCut(1),
221 fMyTrackContainerName(""),
222 fMyParticleContainerName(""),
223 fMyJetContainerName(""),
224 fMyJetParticleContainerName(""),
225 fMyClusterContainerName(""),
226 fTrkContainerDetLevel(0x0),
227 fParticleContainerPartLevel(0x0),
228 fJetContainerDetLevel(0x0),
229 fJetContainerPartLevel(0x0),
230 fClusterContainerDetLevel(0x0),
231 fRhoTaskName(""),
232 fRhoTaskNameMC(""),
233 fCentralityTree(0x0),
234 fMultSelection(0x0),
235 fIsMinBiasTrig(1),
236 fIsEmcalTrig(0),
237 fCentralityV0A(-1),
238 fCentralityV0C(-1),
239 fCentralityCL1(-1),
240 fCentralityZNA(-1),
241 fCentralityZNC(-1),
242 fxVertex(-1),
243 fyVertex(-1),
244 fzVertex(-1),
245 fVertexer3d(1),
246 fNTracklets(-1),
247 fIsV0ATriggered(0),
248 fIsV0CTriggered(0),
249 fMultV0A(1),
250 fMultV0C(1),
251 fZEM1Energy(0),
252 fZEM2Energy(0),
253 fTrackEtaWindow(0.9),
254 fMinTrackPt(0.150),
255 fMC(0),
256 fHelperClass(0), fInitializedLocal(0),
257 fHistEvtSelection(0x0),
258 fhVertexZ(0x0),
259 fhTrackPhiIncl(0x0), fhTrackEtaIncl(0x0),
260 fhJetPhiIncl(0x0), fhJetEtaIncl(0x0),
261 fhClusterPhiInclMB(0x0), fhClusterEtaInclMB(0x0),
262 fhClusterPhiInclGA(0x0), fhClusterEtaInclGA(0x0),
263 fhRhoIncl(0x0),
264 fhV0AvsV0C(0x0),
265 fhV0AvsSPD(0x0),
266 fhV0CvsSPD(0x0),
267 fZVertexCut(10.0),
268 fnHadronTTBins(0),
269 fnJetChTTBins(0),
270 fnClusterTTBins(0),
271 fFillTTree(0),
272 fSystem(AliAnalysisTaskEA::kpPb),
273 fFiducialCellCut(0x0)
274 {
275  //Constructor
276 
277  for(Int_t i=0; i<2; i++) fNClusters[i] = 0;
278  for(Int_t i=0; i<8; i++) fRingMultV0[i] = 0;
279 
280  for(Int_t i=0; i<5; i++){
281  fZNCtower[i] = 0;
282  fZPCtower[i] = 0;
283  fZNAtower[i] = 0;
284  fZPAtower[i] = 0;
285  fZNCtowerLG[i] = 0;
286  fZPCtowerLG[i] = 0;
287  fZNAtowerLG[i] = 0;
288  fZPAtowerLG[i] = 0;
289  }
290 
291  //arrays number of triggers
292  for(Int_t i=0; i<fkTTbins; i++){
293  fHadronTT[i] = 0;
294  fJetChTT[i] = 0;
295  fClusterTT[i] = 0;
296 
297  fhMultTTHinMB[i] = 0x0;
298  fhMultTTJinMB[i] = 0x0;
299  fhMultTTCinMB[i] = 0x0;
300  fhMultTTCinGA[i] = 0x0;
301  }
302 
303  for(Int_t i=0; i<fkTTbins;i++){
304  fHadronTTLowPt[i]=-1;
305  fHadronTTHighPt[i]=-1;
306  fJetChTTLowPt[i]=-1;
307  fJetChTTHighPt[i]=-1;
308  fClusterTTLowPt[i]=-1;
309  fClusterTTHighPt[i]=-1;
310 
311  fhV0AvsV0CTTH[i] = 0x0;
312  fhV0AvsV0CTTJ[i] = 0x0;
313  fhV0AvsV0CTTCinMB[i] = 0x0;
314  fhV0AvsV0CTTCinGA[i] = 0x0;
315 
316  }
317 
318  for(Int_t iv=0; iv<fkVtx;iv++){
319  fhVertex[iv]=0x0;
320  for(Int_t i=0; i<fkTTbins;i++){
321  fhVertexTTH[iv][i]=0x0;
322  }
323  }
324 
325  for(Int_t ic=0; ic<fkCE;ic++){
326  fhCentralityMB[ic] = 0x0;
327  fhSignalMB[ic] = 0x0;
328 
329  for(Int_t i=0; i<fkTTbins;i++){
330  fhCentralityTTH[ic][i] = 0x0;
331  fhCentralityTTJ[ic][i] = 0x0;
332  fhCentralityTTCinMB[ic][i] = 0x0;
333  fhCentralityTTCinGA[ic][i] = 0x0;
334 
335  fhSignalTTH[ic][i] = 0x0;
336  fhSignalTTJ[ic][i] = 0x0;
337  fhSignalTTCinMB[ic][i] = 0x0;
338  fhSignalTTCinGA[ic][i] = 0x0;
339  }
340  }
341 
342 
343  sprintf(fTrigClass,"%s","");
344  //inclusive pT spectrum times the boost function
345 
347 
348  DefineOutput(1, TList::Class());
349 }
350 
357 //_____________________________________________________________________________________
359  Int_t system,
360  const char* jetarrayname,
361  const char* jetarraynameMC,
362  const char* trackarrayname,
363  const char* mcpariclearrayname,
364  const char* clusterarrayname,
365  const char* rhoname,
366  const char* mcrhoname,
367  Double_t jetRadius,
368  UInt_t trigger,
369  Int_t isMC,
370  Double_t trackEtaWindow,
371  Bool_t useVertexCut,
372  Bool_t usePileUpCut,
373  Double_t acut,
374  Double_t emcaltofcut,
375  const char* suffix
376 ){
377  // Get the pointer to the existing analysis manager via the static access method.
378  //==============================================================================
379 
380  Double_t jetEtaRange = TMath::Abs(trackEtaWindow - jetRadius);
381 
382 
383  // #### DEFINE MANAGER AND DATA CONTAINER NAMES
384  AliAnalysisManager *manager = AliAnalysisManager::GetAnalysisManager();
385  if(!manager){
386  ::Error("AliAnalysisTaskEA.cxx", "No analysis manager to connect to.");
387  return NULL;
388  }
389 
390  //__________________________________________________________________________________
391  // #### DEFINE MY ANALYSIS TASK
392 
393  TString myContName("");
394  myContName = Form("JetAnalysisR%02d", TMath::Nint(jetRadius*10));
395  myContName.Append(suffix);
396 
397 
398  AliAnalysisTaskEA *task = new AliAnalysisTaskEA(myContName.Data());
399 
400  if(isMC){ //for PYTHIA
401  task->SetIsPythia(kTRUE); //NECESSARY IN ORDER TO FILL XSEC AND TRIALS
402  task->SetMakeGeneralHistograms(kTRUE); //NECESSARY IN ORDER TO FILL XSEC AND TRIALS
403  }
404 
405  //inspired by AliAnalysisTaskEmcalQGTagging
406  //_____________________________________________
407  //TRACK/PARTICLE CONTAINTERS
408  AliTrackContainer *trackCont = 0x0; //detector level track container
409  AliParticleContainer *trackContTrue = 0x0; //mc particle container
410  AliClusterContainer *clusterCont = 0x0; //detector level track container
411 
412  trackCont = task->AddTrackContainer(trackarrayname); //detector level tracks
413  trackCont->SetMinPt(0.15);
414  trackCont->SetEtaLimits(-trackEtaWindow, trackEtaWindow);
415 
416  if(isMC){
417  trackContTrue = task->AddMCParticleContainer(mcpariclearrayname); //particle level MC particles
418  trackContTrue->SetClassName("AliAODMCParticle");
419  trackContTrue->SetMinPt(0.15);
420  trackContTrue->SetEtaLimits(-trackEtaWindow,trackEtaWindow);
421  }
422 
423  clusterCont = task->AddClusterContainer(clusterarrayname); //detector level tracks
424  clusterCont->SetMinPt(0.3);
425  clusterCont->SetExoticCut(1);
426  clusterCont->SetClusTimeCut(0, emcaltofcut);
427 
428  // clusterCont->SetEtaLimits(-trackEtaWindow, trackEtaWindow);
429 
430  //_____________________________________________
431  //JET CONTAINERS
432  AliJetContainer *jetContRec = 0x0; //jet container with detector level tracks
433  AliJetContainer *jetContTrue = 0x0; //jet container with mc particles
434 
435  jetContRec = task->AddJetContainer(jetarrayname,"TPC",jetRadius);
436 
437  if(jetContRec) { //DETECTOR LEVEL JET
438  jetContRec->ConnectParticleContainer(trackCont);
439  jetContRec->SetPercAreaCut(acut);
440  jetContRec->SetMinPt(0.150);
441  jetContRec->SetMaxTrackPt(1000);
443  jetContRec->SetJetEtaLimits(-jetEtaRange,jetEtaRange);
444  }
445 
446  if(isMC){
447  //AKT JETS PARTICLE LEVEL
448  jetContTrue = task->AddJetContainer(jetarraynameMC,"TPC",jetRadius);
449  if(jetContTrue){
450  jetContTrue->ConnectParticleContainer(trackContTrue);
451  jetContTrue->SetPercAreaCut(acut);
452  jetContTrue->SetMinPt(0.15);
453  jetContTrue->SetMaxTrackPt(1000);
455  jetContTrue->SetJetEtaLimits(-jetEtaRange,jetEtaRange);
456  }
457  }
458 
459  // #### Task configuration
460  task->SetMC(isMC);
461  task->SetUsePileUpCut(usePileUpCut);
462  task->SetUseDefaultVertexCut(useVertexCut);
463  task->SetAcceptanceWindows(trackEtaWindow);
464  task->SelectCollisionCandidates(trigger);
465  task->SetExternalRhoTaskName(rhoname);
466  task->SetExternalRhoTaskNameMC(mcrhoname);
467  task->SetTrackContainerName(trackarrayname);
468  task->SetSystem(system);
469 
470 
471  task->SetMCParticleContainerName(mcpariclearrayname);
472  task->SetClusterContainerName(clusterarrayname);
473  task->SetJetContainerName(jetarrayname);
474  task->SetMCJetContainerName(jetarraynameMC);
475  if(system!=AliAnalysisTaskEA::kpp){
476  task->SetUseNewCentralityEstimation(kTRUE); //CENTRALITY
477  }else{
478  task->SetUseNewCentralityEstimation(kFALSE); //CENTRALITY
479  }
480 
481  task->SetDebugLevel(0); //No debug messages 0
482 
483  // output container
484  AliAnalysisDataContainer *contHistos = manager->CreateContainer(myContName.Data(), TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:ChJetSpectra%s", AliAnalysisManager::GetCommonFileName(), myContName.Data()));
485 
486 
487  // #### ADD ANALYSIS TASK
488  manager->AddTask(task);
489  manager->ConnectInput(task, 0, manager->GetCommonInputContainer());
490  manager->ConnectOutput(task, 1, contHistos);
491 
492  return task;
493 }
494 //_____________________________________________________________________________________
496 
497  TString trigger = fInputEvent->GetFiredTriggerClasses();
498  bool passedGammaTrigger = kFALSE;
499 
500  if(trigger.Contains("EG1") || trigger.Contains("EG2") || trigger.Contains("DG1") || trigger.Contains("DG2")){
501  passedGammaTrigger = kTRUE;
502  }
503  return passedGammaTrigger;
504 
505 }
506 //_____________________________________________________________________________________
508 
509  TString trigger = fInputEvent->GetFiredTriggerClasses();
510  bool passedTrigger = kFALSE;
511  if(trigger.Contains("INT7")){
512  passedTrigger = kTRUE;
513  }
514  return passedTrigger;
515 
516 }
517 
518 //_____________________________________________________________________________________
520 
521  // Get rho from event using CMS approach
522  AliRhoParameter* rho = NULL;
523  TString rhoname = (!isMC) ? fRhoTaskName : fRhoTaskNameMC;
524  if(!rhoname.IsNull()){
525  rho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(rhoname.Data()));
526  if (!rho) {
527  //AliWarningF(MSGWARNING("%s: Could not retrieve rho with name %s!"), GetName(), rhoname.Data());
528  return 0.;
529  }
530  }else{
531  //AliWarningF(MSGWARNING("No %s Rho task name provided"), (!isMC ? "DATA" : "MC"));
532  return 0.;
533  }
534 
535  return rho->GetVal();
536 }
537 //________________________________________________________________________
538 
540  //EVENT SELECTION RECONSTRUCTED DATA
541 
542 
543  if(!event) return kFALSE;
544 
545  //___________________________________________________
546  //TEST PILE UP
547  if(fUsePileUpCut){
548  if(!fHelperClass || fHelperClass->IsPileUpEvent(event)){
549  fHistEvtSelection->Fill(1.5); //count events rejected by pileup
550  return kFALSE;
551  }
552  }
553  //___________________________________________________
554  //VERTEX CUT
555 
557  if(!fHelperClass || !fHelperClass->IsVertexSelected2013pA(event)){ //??? USE THIS OR SOMETHING ELSE
558  fHistEvtSelection->Fill(2.5); //count events rejected by vertex cut
559  return kFALSE;
560  }
561  }else{
562  if(TMath::Abs(event->GetPrimaryVertex()->GetZ()) > fZVertexCut){
563  fHistEvtSelection->Fill(2.5); //count events rejected by vertex cut
564  return kFALSE;
565  }
566  }
567  //___________________________________________________
568  //AFTER VERTEX CUT
569  fhVertexZ->Fill(event->GetPrimaryVertex()->GetZ());
570 
571 
572  return kTRUE;
573 }
574 
575 //________________________________________________________________________
577  // Check if the track pt and eta range
578  if(!track) return kFALSE;
579 
580  if(isGen){ //particle level MC: select charged physical primary tracks
581  //Apply only for kine level or MC containers
582  if(!track->Charge()) return kFALSE;
583  if(fMC == kPartLevel){
584  if(!(static_cast<AliAODMCParticle*>(track))->IsPhysicalPrimary()) return kFALSE;
585  }
586  }
587  if(TMath::Abs(track->Eta()) < fTrackEtaWindow){ //APPLY TRACK ETA CUT
588  if(track->Pt() > fMinTrackPt){ //APPLY TRACK PT CUT
589  return kTRUE;
590  }
591  }
592  return kFALSE;
593 }
594 //________________________________________________________________________
596  // Initialization of jet containers done in AliAnalysisTaskEmcalJet::ExecOnce()
597  //Read arrays of jets and tracks
598  fInitializedLocal = kTRUE;
599 
600  // Initialize helper class (for vertex selection & pile up correction)
601  fHelperClass = new AliAnalysisUtils();
602  fHelperClass->SetCutOnZVertexSPD(kFALSE); // kFALSE: no cut; kTRUE: |zvtx-SPD - zvtx-TPC|<0.5cm
603 
604 
605  return;
606 }
607 
608 //________________________________________________________________________
610  //Distance o
611  Int_t max = 0;
612 
613  for(Int_t n=0; n<6; n++){
616  max = n;
617  }else{
618  break;
619  }
620  }
621 
622  return max;
623 }
624 
625 
626 //________________________________________________________________________
628 
629  //General QA.
630  if( cluster->GetNCells() < 1) return kFALSE;
631 
632  Int_t disToBad = cluster->GetDistanceToBadChannel();
633  if(-1<disToBad && disToBad<2) return kFALSE;
634 
635  Int_t disToBorder = GetMaxDistanceFromBorder(cluster);
636  if(-1<disToBorder && disToBorder<1) return kFALSE;
637 
638  Double_t lambda0 = cluster->GetM02(); //avoid merged clusters
639  if(lambda0 > 0.4) return kFALSE;
640 
641  return kTRUE;
642 }
643 
644 //________________________________________________________________________
646  // executed in each event
647  //called in AliAnalysisTaskEmcal::UserExec(Option_t *)
648  // Analyze the event and Fill histograms
649 
650  if(!InputEvent()){
651  AliError("??? Event pointer == 0 ???");
652  return kFALSE;
653  }
654 
655  //Execute only once: Get tracks, jets from arrays if not already given
657 
658 
659  //_________________________________________________________________
660  // EVENT SELECTION
661  fHistEvtSelection->Fill(0.5); //Count input event
662 
663  //Check Reconstructed event vertex and pileup
664  if(!IsEventInAcceptance(InputEvent())) return kFALSE; //post data is in UserExec
665 
666 
667  fIsMinBiasTrig = kFALSE; //Minimum bias event flag
668  if(PassedMinBiasTrigger()){
669  fIsMinBiasTrig = kTRUE;
670  fHistEvtSelection->Fill(3.5); //Count Accepted input event
671  }
672 
673  fIsEmcalTrig = kFALSE; //EMCAL triggered event flag
674  if(PassedGATrigger()){
675  fIsEmcalTrig = kTRUE;
676  fHistEvtSelection->Fill(4.5); //Count Accepted input event
677  }
678 
679 
680  if(!fIsEmcalTrig && !fIsMinBiasTrig) return kFALSE; //post data is in UserExec
681 
682 
683  // END EVENT SELECTION
684  //_________________________________________________________________
685  // EVENT PROPERTIES
686 
687  for(int ir=0; ir<8; ir++) fRingMultV0[ir]=0.;
688 
689  // ***** Trigger selection
690  TString triggerClass = InputEvent()->GetFiredTriggerClasses();
691  sprintf(fTrigClass,"%s",triggerClass.Data());
692 
693 
695  fMultSelection = (AliMultSelection*) InputEvent()->FindListObject("MultSelection");
696  if(fMultSelection){
697  fCentralityV0A = fMultSelection->GetMultiplicityPercentile("V0A");
698  fCentralityV0C = fMultSelection->GetMultiplicityPercentile("V0C");
699  fCentralityCL1 = fMultSelection->GetMultiplicityPercentile("CL1");
700  fCentralityZNA = fMultSelection->GetMultiplicityPercentile("ZNA");
701  fCentralityZNC = fMultSelection->GetMultiplicityPercentile("ZNC");
702  }else{
703  fCentralityV0A = -1;
704  fCentralityV0C = -1;
705  fCentralityCL1 = -1;
706  fCentralityZNA = -1;
707  fCentralityZNC = -1;
708  }
709  }
710 
711  const AliVVertex *vertex = InputEvent()->GetPrimaryVertexSPD();
712  if(vertex){
713  fxVertex = vertex->GetX();
714  fyVertex = vertex->GetY();
715  fzVertex = vertex->GetZ();
716  if(vertex->IsFromVertexer3D()) fVertexer3d = kTRUE;
717  else fVertexer3d = kFALSE;
718  }else{
719  fxVertex = 9999.;
720  fyVertex = 9999.;
721  fzVertex = 9999.;
722  fVertexer3d = kFALSE;
723  }
724 
725  const AliVMultiplicity *mult = InputEvent()->GetMultiplicity();
726  if(mult){
727  fNTracklets = mult->GetNumberOfTracklets();
728 
729  for(Int_t ilay=0; ilay<2; ilay++){
730  fNClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
731  }
732  }else{
733  fNTracklets = -9999;
734  for(Int_t ilay=0; ilay<2; ilay++){
735  fNClusters[ilay] = -9999;
736  }
737  }
738 
739 
740 
741  AliVVZERO *vzeroAOD = InputEvent()->GetVZEROData();
742  if(vzeroAOD){
743  fMultV0A = vzeroAOD->GetMTotV0A();
744  fMultV0C = vzeroAOD->GetMTotV0C();
745  fIsV0ATriggered = vzeroAOD->GetV0ADecision();
746  fIsV0CTriggered = vzeroAOD->GetV0CDecision();
747 
748  for(Int_t iRing = 0; iRing < 8; ++iRing){
749  for(Int_t i = 0; i < 8; ++i){
750  fRingMultV0[iRing] += vzeroAOD->GetMultiplicity(8*iRing+i);
751  }
752  }
753  }else{
754  fMultV0A = -1;
755  fMultV0C = -1;
756  fIsV0ATriggered = kFALSE;
757  fIsV0CTriggered = kFALSE;
758 
759  for(Int_t iRing = 0; iRing < 8; ++iRing){
760  for(Int_t i = 0; i < 8; ++i){
761  fRingMultV0[iRing] += 0;
762  }
763  }
764  }
765 
766 
767  AliAODZDC *aodZDC =dynamic_cast<AliAODZDC*> (InputEvent()->GetZDCData());
768  if(aodZDC){
769 
770  fZEM1Energy = (Float_t) (aodZDC->GetZEM1Energy());
771  fZEM2Energy = (Float_t) (aodZDC->GetZEM2Energy());
772 
773  const Double_t* towZNC = aodZDC->GetZNCTowerEnergy();
774  const Double_t* towZPC = aodZDC->GetZPCTowerEnergy();
775  const Double_t* towZNA = aodZDC->GetZNATowerEnergy();
776  const Double_t* towZPA = aodZDC->GetZPATowerEnergy();
777  //
778  const Double_t* towZNCLG = aodZDC->GetZNCTowerEnergyLR();
779  const Double_t* towZPCLG = aodZDC->GetZPCTowerEnergyLR();
780  const Double_t* towZNALG = aodZDC->GetZNATowerEnergyLR();
781  const Double_t* towZPALG = aodZDC->GetZPATowerEnergyLR();
782  //
783  for(Int_t it=0; it<5; it++){
784  fZNCtower[it] = (Float_t) (towZNC[it]);
785  fZPCtower[it] = (Float_t) (towZPC[it]);
786  fZNAtower[it] = (Float_t) (towZNA[it]);
787  fZPAtower[it] = (Float_t) (towZPA[it]);
788  fZNCtowerLG[it] = (Float_t) (towZNCLG[it]);
789  fZPCtowerLG[it] = (Float_t) (towZPCLG[it]);
790  fZNAtowerLG[it] = (Float_t) (towZNALG[it]);
791  fZPAtowerLG[it] = (Float_t) (towZPALG[it]);
792  }
793  }else{
794  fZEM1Energy = -1;
795  fZEM2Energy = -1;
796  for(Int_t it=0; it<5; it++){
797  fZNCtower[it] = -1;
798  fZPCtower[it] = -1;
799  fZNAtower[it] = -1;
800  fZPAtower[it] = -1;
801  fZNCtowerLG[it] = -1;
802  fZPCtowerLG[it] = -1;
803  fZNAtowerLG[it] = -1;
804  fZPAtowerLG[it] = -1;
805  }
806  }
807 
808 
809 
810 
811  Double_t rho = GetExternalRho(kDetLevel); //estimated backround pt density
812 
813  //_________________________________________________________________
814  // JET+TRACK CONTAINERS
815 
816  AliEmcalJet *jet = NULL; //jet pointer real jet
817  AliEmcalJet *jetMC = NULL; //jet pointer real jet
818  AliVParticle *track = NULL; //jet constituent
819 
820  //_________________________________________________________
821  //READ TRACK AND JET CONTAINERS
822  //Container operations http://alidoc.cern.ch/AliPhysics/master/READMEcontainers.html#emcalContainerIterateTechniques
823 
824  fTrkContainerDetLevel = static_cast<AliTrackContainer*> (GetTrackContainer(fMyTrackContainerName.Data())); //reconstructed particle container
825  fJetContainerDetLevel = static_cast<AliJetContainer*> (GetJetContainer(fMyJetContainerName.Data())); //AKT jet
826 
827 
828 
829  if(fMC){
830  fParticleContainerPartLevel = GetParticleContainer(fMyParticleContainerName.Data()); //reconstructed particle container
831  fJetContainerPartLevel = GetJetContainer(fMyJetParticleContainerName.Data()); //reconstructed particle container
832  }
833 
834  if(fIsMinBiasTrig){
835  fhVertex[0]->Fill(fxVertex);
836  fhVertex[1]->Fill(fyVertex);
837  fhVertex[2]->Fill(fzVertex);
838 
839  fhRhoIncl->Fill(rho);
840 
847  }
848 
849  fhSignalMB[fkV0A]->Fill(fMultV0A);
850  fhSignalMB[fkV0C]->Fill(fMultV0C);
851  fhSignalMB[fkSPD]->Fill(fNTracklets);
852  fhSignalMB[fkZNA]->Fill(fZNAtower[0]);
853  fhSignalMB[fkZNC]->Fill(fZNCtower[0]);
854 
855  fhV0AvsV0C->Fill(fMultV0C, fMultV0A);
858 
859  }
860 
861 
862 
863  //_________________________________________________________
864  //LOOP OVER EMCAL CLUSTERS
865  TLorentzVector ph;
866  for(Int_t i=0; i<fnClusterTTBins; i++){
867  fClusterTT[i] = 0;
868  }
869 
870  if(fMyClusterContainerName.Data()){
872 
873 
874  for(auto cluster: fClusterContainerDetLevel->accepted()){
875 
877 
878  if(!FinalClusterCuts(cluster)) continue;
879 
880  if(fIsMinBiasTrig){
881  //fill some histograms for detector level tracks
882  fhClusterPhiInclMB->Fill(ph.Pt(), ph.Phi());
883  fhClusterEtaInclMB->Fill(ph.Pt(), ph.Eta());
884  }else if(fIsEmcalTrig){
885  fhClusterPhiInclGA->Fill(ph.Pt(), ph.Phi());
886  fhClusterEtaInclGA->Fill(ph.Pt(), ph.Eta());
887  }
888 
889  for(Int_t igg=0; igg<fnClusterTTBins; igg++){
890  if(fClusterTTLowPt[igg] < ph.Pt() && ph.Pt() < fClusterTTHighPt[igg]){
891  fClusterTT[igg]++; // there was a high pt
892  }
893  }
894  }
895 
896  if(fIsMinBiasTrig){
897  for(Int_t igg=0; igg<fnClusterTTBins; igg++){
898 
899  fhMultTTCinMB[igg]->Fill(fClusterTT[igg]);
900 
901  if(!fClusterTT[igg]) continue;
902 
903  fhRhoTTCinMB[igg]->Fill(rho);
904 
911  }
912 
913  fhSignalTTCinMB[fkV0A][igg]->Fill(fMultV0A);
914  fhSignalTTCinMB[fkV0C][igg]->Fill(fMultV0C);
915  fhSignalTTCinMB[fkSPD][igg]->Fill(fNTracklets);
916  fhSignalTTCinMB[fkZNA][igg]->Fill(fZNAtower[0]);
917  fhSignalTTCinMB[fkZNC][igg]->Fill(fZNCtower[0]);
918 
919 
920  fhV0AvsV0CTTCinMB[igg]->Fill(fMultV0C, fMultV0A);
921  }
922  }else if(fIsEmcalTrig){
923 
924  for(Int_t igg=0; igg<fnClusterTTBins; igg++){
925 
926  fhMultTTCinGA[igg]->Fill(fClusterTT[igg]);
927 
928  if(!fClusterTT[igg]) continue;
929 
930  fhRhoTTCinGA[igg]->Fill(rho);
931 
938  }
939 
940  fhSignalTTCinGA[fkV0A][igg]->Fill(fMultV0A);
941  fhSignalTTCinGA[fkV0C][igg]->Fill(fMultV0C);
942  fhSignalTTCinGA[fkSPD][igg]->Fill(fNTracklets);
943  fhSignalTTCinGA[fkZNA][igg]->Fill(fZNAtower[0]);
944  fhSignalTTCinGA[fkZNC][igg]->Fill(fZNCtower[0]);
945 
946  fhV0AvsV0CTTCinGA[igg]->Fill(fMultV0C, fMultV0A);
947  }
948  }
949 
950  }
951 
952 
953 
954 
955 
956  //_________________________________________________________
957  //LOOP OVER TRACKS DETECTOR LEVEL + SEARCH FOR HIGH PT HADRON TRIGGER
958 
959  for(Int_t i=0; i<fnHadronTTBins; i++){
960  fHadronTT[i] = 0;
961  }
962 
963 
964  for(auto trackIterator : fTrkContainerDetLevel->accepted_momentum() ){
965  // trackIterator is a std::map of AliTLorentzVector and AliVTrack
966  track = trackIterator.second; // Get the full track
967 
968  if(IsTrackInAcceptance(track, kDetLevel)){
969 
970 
971  if(fIsMinBiasTrig){
972  //fill some histograms for detector level tracks
973  fhTrackPhiIncl->Fill(track->Pt(), track->Phi());
974  fhTrackEtaIncl->Fill(track->Pt(), track->Eta());
975  }
976 
977  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
978  if(fHadronTTLowPt[itt] < track->Pt() && track->Pt() < fHadronTTHighPt[itt]){
979  fHadronTT[itt]++; // there was a high pt
980  }
981  }
982  }
983  }
984 
985  if(fIsMinBiasTrig){
986  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
987 
988  fhMultTTHinMB[itt]->Fill(fHadronTT[itt]);
989 
990  if(!fHadronTT[itt]) continue;
991  fhVertexTTH[0][itt]->Fill(fxVertex);
992  fhVertexTTH[1][itt]->Fill(fyVertex);
993  fhVertexTTH[2][itt]->Fill(fzVertex);
994 
995  fhRhoTTH[itt]->Fill(rho);
996 
998  fhCentralityTTH[fkV0A][itt]->Fill(fCentralityV0A);
999  fhCentralityTTH[fkV0C][itt]->Fill(fCentralityV0C);
1000  fhCentralityTTH[fkSPD][itt]->Fill(fCentralityCL1);
1001  fhCentralityTTH[fkZNA][itt]->Fill(fCentralityZNA);
1002  fhCentralityTTH[fkZNC][itt]->Fill(fCentralityZNC);
1003  }
1004 
1005  fhSignalTTH[fkV0A][itt]->Fill(fMultV0A);
1006  fhSignalTTH[fkV0C][itt]->Fill(fMultV0C);
1007  fhSignalTTH[fkSPD][itt]->Fill(fNTracklets);
1008  fhSignalTTH[fkZNA][itt]->Fill(fZNAtower[0]);
1009  fhSignalTTH[fkZNC][itt]->Fill(fZNCtower[0]);
1010 
1011  fhV0AvsV0CTTH[itt]->Fill(fMultV0C, fMultV0A);
1012  }
1013  }
1014 
1015  //_________________________________________________________
1016  //LOOP OVER JETS DETECTOR LEVEL
1017 
1018  for(Int_t i=0; i<fnJetChTTBins; i++){
1019  fJetChTT[i] = 0;
1020  }
1021 
1022 
1023  Double_t jetPtcorr;
1024  for(auto jetIterator : fJetContainerDetLevel->accepted_momentum() ){
1025  // trackIterator is a std::map of AliTLorentzVector and AliVTrack
1026  jet = jetIterator.second; // Get the pointer to jet object
1027  if(!jet) continue;
1028 
1029  jetPtcorr = jet->Pt() - rho*jet->Area();
1030  if(fIsMinBiasTrig){
1031  //fill some histograms for detector level jets
1032  fhJetPhiIncl->Fill(jetPtcorr, jet->Phi());
1033  fhJetEtaIncl->Fill(jetPtcorr, jet->Eta());
1034  }
1035 
1036  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1037  if(fJetChTTLowPt[ijj] < jetPtcorr && jetPtcorr < fJetChTTHighPt[ijj]){
1038  fJetChTT[ijj]++; // there was a high pt
1039  }
1040  }
1041 
1042  //loop over jet constituents
1043  //for(Int_t iq=0; iq < jet->GetNumberOfTracks(); iq++) {
1044  // track = (AliVParticle*) (jet->TrackAt(iq, fTrkContainerDetLevel->GetArray()));
1045  //here one can e.g. analyze jet shapes
1046 
1047  //}
1048 
1049 
1050  //you can also find the closest particle level jet to given detector level
1051  //the mateching betwe particle and detector level jets is done in Tagger task
1052  //if(fMC){
1053  // jetMC = jet->ClosestJet();
1054  //}
1055  }
1056 
1057  if(fIsMinBiasTrig){
1058  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1059 
1060  fhMultTTJinMB[ijj]->Fill(fJetChTT[ijj]);
1061 
1062  if(!fJetChTT[ijj]) continue;
1063 
1064  fhRhoTTJ[ijj]->Fill(rho);
1065 
1067  fhCentralityTTJ[fkV0A][ijj]->Fill(fCentralityV0A);
1068  fhCentralityTTJ[fkV0C][ijj]->Fill(fCentralityV0C);
1069  fhCentralityTTJ[fkSPD][ijj]->Fill(fCentralityCL1);
1070  fhCentralityTTJ[fkZNA][ijj]->Fill(fCentralityZNA);
1071  fhCentralityTTJ[fkZNC][ijj]->Fill(fCentralityZNC);
1072  }
1073 
1074  fhSignalTTJ[fkV0A][ijj]->Fill(fMultV0A);
1075  fhSignalTTJ[fkV0C][ijj]->Fill(fMultV0C);
1076  fhSignalTTJ[fkSPD][ijj]->Fill(fNTracklets);
1077  fhSignalTTJ[fkZNA][ijj]->Fill(fZNAtower[0]);
1078  fhSignalTTJ[fkZNC][ijj]->Fill(fZNCtower[0]);
1079 
1080  fhV0AvsV0CTTJ[ijj]->Fill(fMultV0C, fMultV0A);
1081  }
1082  }
1083 
1084 
1085  //___________________________________________________________
1086 //
1087 // if(fMC){
1088 //
1089 // //_________________________________________________________
1090 // //LOOP OVER PARTICLE LEVEL
1091 //
1092 // for(auto trackIterator : fParticleContainerPartLevel->accepted_momentum() ){
1093 // // trackIterator is a std::map of AliTLorentzVector and AliVTrack
1094 // track = trackIterator.second; // Get the full track
1095 //
1096 // if(IsTrackInAcceptance(track, kPartLevel)){
1097 // //here fill some histograms for particle level particles
1098 //
1099 // }
1100 // }
1101 //
1102 // //_________________________________________________________
1103 // //LOOP OVER JETS PARTICLE LEVEL
1104 //
1105 //
1106 // Double_t rhoMC = GetExternalRho(kPartLevel); //estimated backround pt density
1107 //
1108 // for(auto jetIterator : fJetContainerPartLevel->accepted_momentum() ){
1109 // // trackIterator is a std::map of AliTLorentzVector and AliVTrack
1110 // jet = jetIterator.second; // Get the pointer to jet object
1111 //
1112 // //fill some histograms for detector level jets
1113 // fhJetPhiIncl->Fill(jet->Pt(), jet->Phi());
1114 // fhJetEtaIncl->Fill(jet->Pt(), jet->Eta());
1115 //
1116 // //loop over jet constituents at particle level
1117 // for(Int_t iq=0; iq < jet->GetNumberOfTracks(); iq++) {
1118 // track = (AliVParticle*) (jet->TrackAt(iq, fParticleContainerPartLevel->GetArray()));
1119 // //here one can e.g. analyze jet shapes
1120 //
1121 // }
1122 //
1123 // }
1124 //
1125 // }
1126 
1127  if(fFillTTree){
1128  fCentralityTree->Fill();
1129  }
1130 
1131 
1132  return kTRUE;
1133 }
1134 
1135 //________________________________________________________________________
1137  //Treminate
1138  PostData(1, fOutput);
1139 
1140  // Mandatory
1141  fOutput = dynamic_cast<AliEmcalList*> (GetOutputData(1)); // '1' refers to the output slot
1142  if(!fOutput) {
1143  printf("ERROR: Output list not available\n");
1144  return;
1145  }
1146 }
1147 
1148 //________________________________________________________________________
1150  // Destructor. Clean-up the output list, but not the histograms that are put inside
1151  // (the list is owner and will clean-up these histograms). Protect in PROOF case.
1152  if(fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
1153  delete fOutput;
1154  }
1155  delete fHelperClass;
1156 
1157 }
1158 //________________________________________________________________________
1160  // called once to create user defined output objects like histograms, plots etc.
1161  // and to put it on the output list.
1162  // Note: Saving to file with e.g. OpenFile(0) is must be before creating other objects.
1163  //fOutput TList defined in the mother class
1165 
1166  Bool_t oldStatus = TH1::AddDirectoryStatus();
1167  TH1::AddDirectory(kFALSE);
1168  TString name, object;
1169 
1170 
1171  //__________________________________________________________
1172  // Event statistics
1173  fHistEvtSelection = new TH1I("fHistEvtSelection", "event selection", 5, 0, 5);
1174  fHistEvtSelection->GetXaxis()->SetBinLabel(1,"events IN");
1175  fHistEvtSelection->GetXaxis()->SetBinLabel(2,"pile up (rejected)");
1176  fHistEvtSelection->GetXaxis()->SetBinLabel(3,"vertex cut (rejected)");
1177  fHistEvtSelection->GetXaxis()->SetBinLabel(4,"MB");
1178  fHistEvtSelection->GetXaxis()->SetBinLabel(5,"EMCAL");
1179 
1180 
1181  fOutput->Add(fHistEvtSelection);
1182 
1183 
1184  //_______________________________________________________________________
1185  //inclusive azimuthal and pseudorapidity histograms
1186 
1187  fhVertexZ = new TH1F("fhVertexZ","z vertex",40,-20,20);
1188  fOutput->Add(fhVertexZ);
1189 
1190  //-------------------------
1191 
1192  fhTrackEtaIncl = new TH2F("fhTrackEtaIncl","Eta dist inclusive track vs pT", 50,0, 100, 40,-0.9,0.9);
1193  fOutput->Add((TH2F*) fhTrackEtaIncl);
1194 
1195  fhTrackPhiIncl = new TH2F("fhTrackPhiIncl","Azim dist tracks vs pT", 50, 0, 100, 50,0,2*TMath::Pi());
1196  fOutput->Add((TH2F*) fhTrackPhiIncl);
1197 
1198  fhJetEtaIncl = new TH2F("fhJetEtaIncl","Eta dist inclusive jets vs pTjet", 150, -20, 130, 40,-0.9,0.9);
1199  fOutput->Add((TH2F*) fhJetEtaIncl);
1200 
1201  fhJetPhiIncl = new TH2F("fhJetPhiIncl","Azim dist jets vs pTjet", 60, -20, 100, 50,0,2*TMath::Pi());
1202  fOutput->Add((TH2F*) fhJetPhiIncl);
1203 
1204  fhClusterEtaInclMB = new TH2F("fhClusterEtaInclMB","Eta dist inclusive clusters vs pT", 100, 0, 100, 40,-0.9,0.9);
1205  fOutput->Add((TH2F*) fhClusterEtaInclMB);
1206 
1207  fhClusterPhiInclMB = new TH2F("fhClusterPhiInclMB","Azim dist clusters vs pT", 50, 0, 100, 50,0,2*TMath::Pi());
1208  fOutput->Add((TH2F*) fhClusterPhiInclMB);
1209 
1210  fhClusterEtaInclGA = new TH2F("fhClusterEtaInclGA","Eta dist inclusive clusters vs pT", 100, 0, 100, 40,-0.9,0.9);
1211  fOutput->Add((TH2F*) fhClusterEtaInclGA);
1212 
1213  fhClusterPhiInclGA = new TH2F("fhClusterPhiInclGA","Azim dist clusters vs pT", 50, 0, 100, 50,0,2*TMath::Pi());
1214  fOutput->Add((TH2F*) fhClusterPhiInclGA);
1215 
1216 
1217  //RHO
1218  fhRhoIncl = new TH1F("hRho","Rho",1000,0,100);
1219  fOutput->Add((TH1F*) fhRhoIncl);
1220 
1221  for(Int_t itt=0; itt<fnHadronTTBins;itt++){
1222  name = Form("%s_TTH%d_%d", fhRhoIncl->GetName(), fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
1223  fhRhoTTH[itt] = (TH1F*) fhRhoIncl->Clone(name.Data());
1224  fOutput->Add((TH1F*) fhRhoTTH[itt]);
1225  }
1226  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1227  name = Form("%s_TTJ%d_%d", fhRhoIncl->GetName(), fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
1228  fhRhoTTJ[ijj] = (TH1F*) fhRhoIncl->Clone(name.Data());
1229  fOutput->Add((TH1F*) fhRhoTTJ[ijj]);
1230  }
1231  for(Int_t igg=0; igg<fnClusterTTBins; igg++){
1232  name = Form("%s_MB_TTC%d_%d", fhRhoIncl->GetName(), fClusterTTLowPt[igg],fClusterTTHighPt[igg]);
1233  fhRhoTTCinMB[igg] = (TH1F*) fhRhoIncl->Clone(name.Data());
1234  fOutput->Add((TH1F*) fhRhoTTCinMB[igg]);
1235  }
1236  for(Int_t igg=0; igg<fnClusterTTBins; igg++){
1237  name = Form("%s_GA_TTC%d_%d", fhRhoIncl->GetName(), fClusterTTLowPt[igg],fClusterTTHighPt[igg]);
1238  fhRhoTTCinGA[igg] = (TH1F*) fhRhoIncl->Clone(name.Data());
1239  fOutput->Add((TH1F*) fhRhoTTCinGA[igg]);
1240  }
1241 
1242 
1243 
1244  //VERTEX
1245  for(Int_t iv=0; iv<fkVtx;iv++){
1246  if(iv==0) fhVertex[iv] = new TH1D("hVertexX","VertexX",100,-1,1);
1247  else if(iv==1) fhVertex[iv] = new TH1D("hVertexY","VertexY",100,-1,1);
1248  else fhVertex[iv] = new TH1D("hVertexZ","VertexZ",400,-20,20);
1249  fOutput->Add((TH1D*) fhVertex[iv]);
1250  }
1251 
1252  for(Int_t iv=0; iv<fkVtx;iv++){
1253  for(Int_t itt=0; itt<fnHadronTTBins;itt++){
1254  name = Form("%s_TTH%d_%d", fhVertex[iv]->GetName(), fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
1255  fhVertexTTH[iv][itt] = (TH1D*) fhVertex[iv]->Clone(name.Data());
1256  fOutput->Add((TH1D*) fhVertexTTH[iv][itt]);
1257  }
1258  }
1259 
1260 
1261  TString cest[fkCE] = {"V0A", "V0C", "SPD", "ZNA", "ZNC"}; //centrality estimators
1262 
1263  if(fSystem!=AliAnalysisTaskEA::kpp){ //not pp
1264  for(Int_t ic=0; ic<fkCE;ic++){
1265  name = Form("hCentrality_MB_%s",cest[ic].Data());
1266  fhCentralityMB[ic] = new TH1D(name.Data(), name.Data(),101,0,101);
1267  fOutput->Add((TH1D*) fhCentralityMB[ic]);
1268  }
1269 
1270  for(Int_t ic=0; ic<fkCE;ic++){
1271  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
1272  name = Form("hCentrality_MB_%s_TTH%d_%d",cest[ic].Data(), fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
1273  fhCentralityTTH[ic][itt] = new TH1D(name.Data(), name.Data(),101,0,101);
1274  fOutput->Add((TH1D*) fhCentralityTTH[ic][itt]);
1275  }
1276  }
1277 
1278  for(Int_t ic=0; ic<fkCE;ic++){
1279  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1280  name = Form("hCentrality_MB_%s_TTJ%d_%d", cest[ic].Data(), fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
1281  fhCentralityTTJ[ic][ijj] = new TH1D(name.Data(), name.Data(),101,0,101);
1282  fOutput->Add((TH1D*) fhCentralityTTJ[ic][ijj]);
1283  }
1284  }
1285 
1286  for(Int_t ic=0; ic<fkCE;ic++){
1287  for(Int_t ijj=0; ijj<fnClusterTTBins; ijj++){
1288  name = Form("hCentrality_MB_%s_TTC%d_%d", cest[ic].Data(), fClusterTTLowPt[ijj],fClusterTTHighPt[ijj]);
1289  fhCentralityTTCinMB[ic][ijj] = new TH1D(name.Data(), name.Data(),101,0,101);
1290  fOutput->Add((TH1D*) fhCentralityTTCinMB[ic][ijj]);
1291  }
1292  }
1293 
1294  for(Int_t ic=0; ic<fkCE;ic++){
1295  for(Int_t ijj=0; ijj<fnClusterTTBins; ijj++){
1296  name = Form("hCentrality_GA_%s_TTC%d_%d", cest[ic].Data(), fClusterTTLowPt[ijj],fClusterTTHighPt[ijj]);
1297  fhCentralityTTCinGA[ic][ijj] = new TH1D(name.Data(), name.Data(),101,0,101);
1298  fOutput->Add((TH1D*) fhCentralityTTCinGA[ic][ijj]);
1299  }
1300  }
1301  }//not pp
1302 
1303  TString signal[]={"multV0A", "multV0C", "nTracklets", "znatower0", "znctower0"};
1304  Float_t signalL[]={0,0,0,0,0};
1305  Float_t signalH[]={1000,1000,500,30000,30000};
1306  Int_t signalN[]={1000,1000,500,100,100};
1307 
1308  for(Int_t ic=0; ic<fkCE;ic++){
1309  name = Form("hSignal_MB_%s", cest[ic].Data());
1310  fhSignalMB[ic] = new TH1D(name.Data(), name.Data(), signalN[ic], signalL[ic], signalH[ic]);
1311  fOutput->Add((TH1D*) fhSignalMB[ic]);
1312  }
1313 
1314 
1315  for(Int_t ic=0; ic<fkCE;ic++){
1316  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
1317  name = Form("hSignal_MB_%s_TTH%d_%d", cest[ic].Data(), fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
1318  fhSignalTTH[ic][itt] = new TH1D(name.Data(),name.Data(),signalN[ic], signalL[ic], signalH[ic]);
1319  fOutput->Add((TH1D*) fhSignalTTH[ic][itt]);
1320  }
1321  }
1322 
1323  for(Int_t ic=0; ic<fkCE;ic++){
1324  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1325  name = Form("hSignal_MB_%s_TTJ%d_%d", cest[ic].Data(), fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
1326  fhSignalTTJ[ic][ijj] = new TH1D(name.Data(),name.Data(),signalN[ic], signalL[ic], signalH[ic]);
1327  fOutput->Add((TH1D*) fhSignalTTJ[ic][ijj]);
1328  }
1329  }
1330 
1331  for(Int_t ic=0; ic<fkCE;ic++){
1332  for(Int_t ijj=0; ijj<fnClusterTTBins; ijj++){
1333  name = Form("hSignal_MB_%s_TTC%d_%d", cest[ic].Data(), fClusterTTLowPt[ijj],fClusterTTHighPt[ijj]);
1334  fhSignalTTCinMB[ic][ijj] = new TH1D(name.Data(),name.Data(),signalN[ic], signalL[ic], signalH[ic]);
1335  fOutput->Add((TH1D*) fhSignalTTCinMB[ic][ijj]);
1336  }
1337  }
1338 
1339  for(Int_t ic=0; ic<fkCE;ic++){
1340  for(Int_t ijj=0; ijj<fnClusterTTBins; ijj++){
1341  name = Form("hSignal_GA_%s_TTC%d_%d", cest[ic].Data(), fClusterTTLowPt[ijj],fClusterTTHighPt[ijj]);
1342  fhSignalTTCinGA[ic][ijj] = new TH1D(name.Data(),name.Data(),signalN[ic], signalL[ic], signalH[ic]);
1343  fOutput->Add((TH1D*) fhSignalTTCinGA[ic][ijj]);
1344  }
1345  }
1346 
1347  name = Form("fhV0AvsV0C_MB");
1348  fhV0AvsV0C = new TH2F(name.Data(),name.Data(),100,0,1000, 100,0,1000);
1349  fOutput->Add((TH2F*) fhV0AvsV0C);
1350 
1351  name = Form("fhV0AvsSPD_MB");
1352  fhV0AvsSPD = new TH2F(name.Data(),name.Data(),100,0,500, 100,0,500);
1353  fOutput->Add((TH2F*) fhV0AvsSPD);
1354 
1355  name = Form("fhV0CvsSPD_MB");
1356  fhV0CvsSPD = new TH2F(name.Data(),name.Data(),100,0,500, 100,0,500);
1357  fOutput->Add((TH2F*) fhV0CvsSPD);
1358 
1359 
1360  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
1361  name = Form("fhV0AvsV0C_MB_TTH%d_%d", fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
1362  fhV0AvsV0CTTH[itt] = (TH2F*) fhV0AvsV0C->Clone(name.Data());
1363  fhV0AvsV0CTTH[itt]->SetTitle(name.Data());
1364  fOutput->Add((TH2F*) fhV0AvsV0CTTH[itt]);
1365  }
1366  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1367  name = Form("fhV0AvsV0C_MB_TTJ%d_%d", fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
1368  fhV0AvsV0CTTJ[ijj] = (TH2F*) fhV0AvsV0C->Clone(name.Data());
1369  fhV0AvsV0CTTJ[ijj]->SetTitle(name.Data());
1370  fOutput->Add((TH2F*) fhV0AvsV0CTTJ[ijj]);
1371  }
1372  for(Int_t ijj=0; ijj<fnClusterTTBins; ijj++){
1373  name = Form("fhV0AvsV0C_MB_TTC%d_%d", fClusterTTLowPt[ijj],fClusterTTHighPt[ijj]);
1374  fhV0AvsV0CTTCinMB[ijj] = (TH2F*) fhV0AvsV0C->Clone(name.Data());
1375  fhV0AvsV0CTTCinMB[ijj]->SetTitle(name.Data());
1376  fOutput->Add((TH2F*) fhV0AvsV0CTTCinMB[ijj]);
1377  }
1378  for(Int_t ijj=0; ijj<fnClusterTTBins; ijj++){
1379  name = Form("fhV0AvsV0C_GA_TTC%d_%d", fClusterTTLowPt[ijj],fClusterTTHighPt[ijj]);
1380  fhV0AvsV0CTTCinGA[ijj] = (TH2F*) fhV0AvsV0C->Clone(name.Data());
1381  fhV0AvsV0CTTCinGA[ijj]->SetTitle(name.Data());
1382  fOutput->Add((TH2F*) fhV0AvsV0CTTCinGA[ijj]);
1383  }
1384 
1385 
1386  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
1387  name = Form("hMultTTHinMB_TTH%d_%d", fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
1388  fhMultTTHinMB[itt] = new TH1D(name.Data(),name.Data(),100,0,100);
1389  fOutput->Add((TH1D*) fhMultTTHinMB[itt]);
1390  }
1391 
1392  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1393  name = Form("hMultTTJinMB_TTJ%d_%d", fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
1394  fhMultTTJinMB[ijj] = new TH1D(name.Data(),name.Data(),100,0,100);
1395  fOutput->Add((TH1D*) fhMultTTJinMB[ijj]);
1396  }
1397 
1398  for(Int_t ijj=0; ijj<fnClusterTTBins; ijj++){
1399  name = Form("hMultTTCinMB_TTC%d_%d", fClusterTTLowPt[ijj],fClusterTTHighPt[ijj]);
1400  fhMultTTCinMB[ijj] = new TH1D(name.Data(),name.Data(),100,0,100);
1401  fOutput->Add((TH1D*) fhMultTTCinMB[ijj]);
1402  }
1403 
1404  for(Int_t ijj=0; ijj<fnClusterTTBins; ijj++){
1405  name = Form("hMultTTCinGA_TTC%d_%d", fClusterTTLowPt[ijj],fClusterTTHighPt[ijj]);
1406  fhMultTTCinGA[ijj] = new TH1D(name.Data(),name.Data(),100,0,100);
1407  fOutput->Add((TH1D*) fhMultTTCinGA[ijj]);
1408  }
1409 
1410 
1411 
1412  // OUTPUT TREE
1413  if(fFillTTree){
1414  fCentralityTree = new TTree("fCentralityTree", "Centrality vs. multiplicity tree");
1415  //
1416  fCentralityTree->Branch("trigClass",fTrigClass,"trigClass/C");
1417  fCentralityTree->Branch("xVertex", &fxVertex,"xVertex/D");
1418  fCentralityTree->Branch("yVertex", &fyVertex,"yVertex/D");
1419  fCentralityTree->Branch("zVertex", &fzVertex,"zVertex/D");
1420  fCentralityTree->Branch("vertexer3d", &fVertexer3d,"vertexer3d/O");
1421  fCentralityTree->Branch("nTracklets", &fNTracklets,"nTracklets/I");
1422  fCentralityTree->Branch("nClusters", fNClusters,"nClusters[2]/I");
1423  //
1424  fCentralityTree->Branch("isV0ATriggered", &fIsV0ATriggered,"isV0ATriggered/I");
1425  fCentralityTree->Branch("isV0CTriggered", &fIsV0CTriggered,"isV0CTriggered/I");
1426  fCentralityTree->Branch("multV0A", &fMultV0A,"multV0A/F");
1427  fCentralityTree->Branch("multV0C", &fMultV0C,"multV0C/F");
1428  fCentralityTree->Branch("ringmultV0", fRingMultV0,"ringmultV0[8]/F");
1429 
1430  fCentralityTree->Branch("znctower", fZNCtower, "znctower[5]/F");
1431  fCentralityTree->Branch("zpctower", fZPCtower, "zpctower[5]/F");
1432  fCentralityTree->Branch("znatower", fZNAtower, "znatower[5]/F");
1433  fCentralityTree->Branch("zpatower", fZPAtower, "zpatower[5]/F");
1434  fCentralityTree->Branch("znctowerLG", fZNCtowerLG, "znctowerLG[5]/F");
1435  fCentralityTree->Branch("zpctowerLG", fZPCtowerLG, "zpctowerLG[5]/F");
1436  fCentralityTree->Branch("znatowerLG", fZNAtowerLG, "znatowerLG[5]/F");
1437  fCentralityTree->Branch("zpatowerLG", fZPAtowerLG, "zpatowerLG[5]/F");
1438 
1439  //fCentralityTree->Branch("tdc", fTDCvalues, "tdc[32][4]/I");
1440  //fCentralityTree->Branch("tdcSum", &fTDCSum, "tdcSum/F");
1441  //fCentralityTree->Branch("tdcDiff", &fTDCDiff, "tdcDiff/F");
1442 
1444  fCentralityTree->Branch("centrV0Amult", &fCentralityV0A, "centrV0Amult/F");
1445  fCentralityTree->Branch("centrV0Cmult", &fCentralityV0C, "centrV0Cmult/F");
1446  fCentralityTree->Branch("centrSPDclu1", &fCentralityCL1, "centrSPDclu1/F");
1447  fCentralityTree->Branch("centrZNA", &fCentralityZNA, "centrZNA/F");
1448  fCentralityTree->Branch("centrZNC", &fCentralityZNC, "centrZNC/F");
1449  }
1450 
1451  for(Int_t itt=0; itt<fnHadronTTBins; itt++){
1452  name = Form("hadronTTbin_%d_%d",fHadronTTLowPt[itt],fHadronTTHighPt[itt]);
1453  object = name;
1454  object.Append("/I"); //Number of tracks in given bin
1455 
1456  fCentralityTree->Branch(name.Data(), &(fHadronTT[itt]), object.Data());
1457  }
1458 
1459  for(Int_t ijj=0; ijj<fnJetChTTBins; ijj++){
1460  name = Form("jetchTTbin_%d_%d",fJetChTTLowPt[ijj],fJetChTTHighPt[ijj]);
1461  object = name;
1462  object.Append("/I"); //Number of jets in given bin
1463 
1464  fCentralityTree->Branch(name.Data(), &(fJetChTT[ijj]), object.Data());
1465  }
1466 
1467  fOutput->Add(fCentralityTree);
1468  }
1469 
1470 
1471 
1472  // =========== Switch on Sumw2 for all histos ===========
1473  for(Int_t i=0; i<fOutput->GetEntries(); i++){
1474  TH1 *h1 = dynamic_cast<TH1*>(fOutput->At(i));
1475  if(h1){
1476  h1->Sumw2();
1477  continue;
1478  }
1479  THnSparse *hn = dynamic_cast<THnSparse*>(fOutput->At(i));
1480  if(hn){
1481  hn->Sumw2();
1482  }
1483  }
1484  TH1::AddDirectory(oldStatus);
1485 
1486 
1487  PostData(1, fOutput);
1488 }
1489 //________________________________________________________________________
1491  //
1492  // retrieve event objects
1493  //
1494  if(!AliAnalysisTaskEmcalJet::RetrieveEventObjects()) return kFALSE;
1495 
1496  return kTRUE;
1497 }
1498 //________________________________________________________________________
1500  // Run analysis code here, if needed. It will be executed before FillHistograms().
1501 
1502  if(!fCaloCells){
1503  if(fCaloCellsName.IsNull()){
1504  fCaloCells = InputEvent()->GetEMCALCells();
1505  }else{
1506  fCaloCells = dynamic_cast<AliVCaloCells*>(InputEvent()->FindListObject(fCaloCellsName));
1507  if(!fCaloCells) AliError(Form("%s: Could not retrieve cells %s!", GetName(), fCaloCellsName.Data()));
1508  }
1509  cout<<"load calo cells"<<endl;
1510  }
1511 
1512 
1513 
1514  return kTRUE;
1515 }
1516 
1517 //________________________________________________________________________
1518 
AliAnalysisUtils * fHelperClass
AliClusterContainer * fClusterContainerDetLevel
particle level jet container
TH1D * fhMultTTHinMB[fkTTbins]
V0A vs V0C biased with cluster TT in Gamma trigger.
Bool_t FillHistograms()
Function filling histograms.
Float_t fCentralityZNC
Centrality from ZNA.
Bool_t fVertexer3d
Z vertex from ITS.
TH2F * fhClusterEtaInclMB
minimum bias phi inclusive cluster
TH1F * fhRhoTTCinGA[fkTTbins]
in events MB with cluster TT
Double_t Area() const
Definition: AliEmcalJet.h:130
TH2F * fhTrackEtaIncl
minimum bias phi inclusive ch hadron
Int_t fJetChTTHighPt[fkTTbins]
double Double_t
Definition: External.C:58
Bool_t CheckCellFiducialRegion(const AliEMCALGeometry *geom, const AliVCluster *cluster, AliVCaloCells *cells)
Definition: External.C:236
AliJetContainer * GetJetContainer(Int_t i=0) const
void SetNumberOfCellsFromEMCALBorder(Int_t n)
Double_t Eta() const
Definition: AliEmcalJet.h:121
void SetMCParticleContainerName(const char *name)
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.
void SetExternalRhoTaskNameMC(const char *name)
TString fMyParticleContainerName
Float_t fZNCtower[5]
ZEM2 Energy.
Bool_t fIsEmcalTrig
triggered by Min Bias Trig
TH2F * fhTrackPhiIncl
gc vertexZ inclusive
void SetExternalRhoTaskName(const char *name)
TH2F * fhV0AvsV0CTTJ[fkTTbins]
V0A vs V0C biased with hadron TT.
TH1I * fHistEvtSelection
trigger if tracks/jets are loaded initiates calling ExecOnce
void SetUseNewCentralityEstimation(Bool_t b)
void SetAcceptanceWindows(Double_t trackEta)
TH1F * fhVertexZ
gc event statistics
TH1D * fhCentralityTTH[fkCE][fkTTbins]
estimated centrality based on mult V0, mult VC, tracklets, znatower0, znctower0
Full acceptance, i.e. no acceptance cut applied – left to user.
Definition: AliEmcalJet.h:77
TH2F * fhV0AvsV0CTTH[fkTTbins]
V0C vs SPD in MB.
AliJetContainer * AddJetContainer(const char *n, TString defaultCutType, Float_t jetRadius=0.4)
void SetPercAreaCut(Float_t p)
TH1D * fhMultTTCinGA[fkTTbins]
multiplicity of cluster TT in MB event
Float_t fMultV0A
V0C decision.
TH2F * fhJetEtaIncl
minimum bias phi inclusive ch jet
TH2F * fhV0AvsV0C
distributions of centrality estimators biased with cluster TT in Gamma trigger
Int_t fJetChTT[fkTTbins]
array which stores the number of triggers in given event
AliClusterContainer * AddClusterContainer(const char *n)
Create new cluster container and attach it to the task.
Some utilities for cluster and cell treatment.
Int_t fHadronTTHighPt[fkTTbins]
Container for particles within the EMCAL framework.
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.
void SetSystem(Int_t sys)
Int_t fClusterTTHighPt[fkTTbins]
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
Int_t GetMaxDistanceFromBorder(AliVCluster *cluster)
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
unsigned int UInt_t
Definition: External.C:33
Int_t fNTracklets
Is vertex from 3d vertexer?
float Float_t
Definition: External.C:68
AliEMCALGeometry * fGeom
!emcal geometry
TH1D * fhVertex[fkVtx]
in events GA with cluster TT
AliParticleContainer * fParticleContainerPartLevel
detector level track container
void SetUsePileUpCut(Bool_t val)
TH2F * fhClusterPhiInclGA
minimum bias eta inclusive
Float_t fCentralityV0A
triggered by EMCAL
TH1D * fhSignalTTCinGA[fkCE][fkTTbins]
distributions of centrality estimators biased with cluster TT in min bias
Double_t fxVertex
Centrality from ZNC.
Float_t fZPAtowerLG[5]
ZNA 5 tower signals.
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Get cluster container attached to this task.
Definition: External.C:212
Int_t fIsV0CTriggered
VOA decision.
Int_t fHadronTT[fkTTbins]
TString fMyJetParticleContainerName
void SetClusterContainerName(const char *name)
Float_t fCentralityZNA
Centrality from Clusters in layer 1.
TH1F * fhRhoTTJ[fkTTbins]
in events MB with hadron TT
const AliClusterIterableContainer accepted() const
TH2F * fhV0AvsV0CTTCinGA[fkTTbins]
V0A vs V0C biased with cluster TT in min bias.
TH1D * fhSignalMB[fkCE]
estimated centrality in GA events biased with cluster TT
Bool_t fIsMinBiasTrig
fired trigger classes
TString fCaloCellsName
name of calo cell collection
void SetJetContainerName(const char *name)
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
Int_t fClusterTTLowPt[fkTTbins]
Double_t fTrackEtaWindow
ZPA 5 tower signals.
Float_t fZEM1Energy
V0 ring mult.
AliMCParticleContainer * AddMCParticleContainer(const char *n)
Create new container for MC particles and attach it to the task.
Double_t fZVertexCut
multiplicity of cluster TT in Gamma trigger event
void SetTrackContainerName(const char *name)
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)
TH2F * fhClusterEtaInclGA
minimum bias phi inclusive cluster
TH1D * fhCentralityTTCinGA[fkCE][fkTTbins]
estimated centrality in MB events biased with cluster TT
TH1D * fhSignalTTH[fkCE][fkTTbins]
distributions of centrality estimators: mult V0, mult VC, tracklets, znatower0, znctower0 ...
AliVCaloCells * fCaloCells
!cells
void ConnectParticleContainer(AliParticleContainer *c)
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
void SetMC(Int_t bMC)
AliEmcalList * fOutput
!output list
TH1F * fhRhoTTCinMB[fkTTbins]
in events MB with jet TT
void Terminate(Option_t *)
Double_t fyVertex
X vertex from ITS.
TH1D * fhVertexTTH[fkVtx][fkTTbins]
vertex distribution
AliEMCALRecoUtils * fFiducialCellCut
!
TH1F * fhRhoIncl
minimum bias eta inclusive
AliTrackContainer * AddTrackContainer(const char *n)
Create new track container and attach it to the task.
Int_t fClusterTT[fkTTbins]
array which stores the number of jets in given event
AliTrackContainer * GetTrackContainer(Int_t i=0) const
Int_t fJetChTTLowPt[fkTTbins]
void SetMakeGeneralHistograms(Bool_t g)
Float_t fZNAtower[5]
ZPC 5 tower signals.
TH2F * fhClusterPhiInclMB
minimum bias eta inclusive
Bool_t GetMomentum(TLorentzVector &mom, const AliVCluster *vc, Double_t mass) const
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
TH2F * fhV0CvsSPD
V0A vs SPD in MB.
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.
void SetJetAcceptanceType(UInt_t type)
TH2F * fhV0AvsV0CTTCinMB[fkTTbins]
V0A vs V0C biased with ch jet TT.
bool Bool_t
Definition: External.C:53
Bool_t fInitializedLocal
Vertex selection helper.
TH1D * fhSignalTTCinMB[fkCE][fkTTbins]
distributions of centrality estimators biased with ch jet TT
void SetMaxTrackPt(Float_t b)
TString fRhoTaskName
detector level EMCAL cluster container
void SetClusTimeCut(Double_t min, Double_t max)
TH1D * fhMultTTCinMB[fkTTbins]
multiplicity of charged jet TT in MB event
void SetJetEtaLimits(Float_t min, Float_t max)
Int_t fHadronTTLowPt[fkTTbins]
Bool_t IsEventInAcceptance(AliVEvent *event)
static AliAnalysisTaskEA * AddTaskEA(Int_t system=AliAnalysisTaskEA::kpPb, const char *jetarrayname="Jet_AKTChargedR040_tracks_pT0150_pt_scheme", const char *jetarraynameMC="Jet_AKTChargedR040_mcparticles_pT0150_pt_scheme", const char *trackarrayname="tracks", const char *mcpariclearrayname="mcparticles", const char *clusterarrayname="caloClusters", const char *rhoname="", const char *mcrhoname="", Double_t jetRadius=0.4, UInt_t trigger=AliVEvent::kAny, Int_t isMC=0, Double_t trackEtaWindow=0.9, Bool_t useVertexCut=kTRUE, Bool_t usePileUpCut=kTRUE, Double_t acut=0.6, Double_t emcaltofcut=30e-9, const char *suffix="")
Container structure for EMCAL clusters.
TH1D * fhCentralityTTCinMB[fkCE][fkTTbins]
estimated centrality in events biased with ch jet TT
Int_t fIsV0ATriggered
no. clusters on SPD layers
Float_t fZNCtowerLG[5]
ZPA 5 tower signals.
void SetExoticCut(Bool_t e)
Container for jet within the EMCAL jet framework.
Definition: External.C:196
Double_t GetExternalRho(Bool_t isMC)
Float_t fRingMultV0[8]
mult. V0C
TH1F * fhRhoTTH[fkTTbins]
minimum bias rho inclusive
void SetMCJetContainerName(const char *name)
AliMultSelection * fMultSelection
output tree
TH2F * fhV0AvsSPD
V0A vs V0C in MB.
void SetUseDefaultVertexCut(Bool_t val)