AliPhysics  dc874a1 (dc874a1)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalClustersRef.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2015, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 #include <array>
16 #include <bitset>
17 #include <iostream>
18 #include <map>
19 #include <vector>
20 
21 #include <TArrayD.h>
22 #include <TClonesArray.h>
23 #include <TGrid.h>
24 #include <THashList.h>
25 #include <THistManager.h>
26 #include <TLinearBinning.h>
27 #include <TLorentzVector.h>
28 #include <TObjArray.h>
29 #include <TParameter.h>
30 #include <TMath.h>
31 
32 #include "AliAnalysisManager.h"
33 #include "AliAnalysisUtils.h"
34 #include "AliClusterContainer.h"
36 #include "AliEMCALGeometry.h"
37 #include "AliEmcalList.h"
38 #include "AliEMCALTriggerPatchInfo.h"
40 #include "AliESDEvent.h"
41 #include "AliInputEventHandler.h"
42 #include "AliLog.h"
43 #include "AliMultSelection.h"
44 #include "AliMultEstimator.h"
45 #include "AliVCluster.h"
46 #include "AliVEvent.h"
47 #include "AliVEventHandler.h"
48 #include "AliVVertex.h"
49 
51 
55 
56 namespace EMCalTriggerPtAnalysis {
57 
58 AliAnalysisTaskEmcalClustersRef::AliAnalysisTaskEmcalClustersRef() :
60  fNameClusterContainer(""),
61  fCentralityRange(-999., 999.),
62  fRequestCentrality(false),
63  fEventCentrality(-1),
64  fEnergyDefinition(kDefaultEnergy)
65 {
66 }
67 
70  fNameClusterContainer(""),
71  fCentralityRange(-999., 999.),
72  fRequestCentrality(false),
73  fEventCentrality(-1),
74  fEnergyDefinition(kDefaultEnergy)
75 {
76 }
77 
79 }
80 
81 
83 
84  EnergyBinning energybinning;
85  TLinearBinning smbinning(21, -0.5, 20.5), etabinning(100, -0.7, 0.7);
86 
87  /*
88  * Exclusive classes are defined as triggered events
89  * in a class without lower threshold classes firing.
90  * This is needed to make the triggers statistically
91  * independent.
92  */
93  std::array<Double_t, 5> encuts = {1., 2., 5., 10., 20.};
94  Int_t sectorsWithEMCAL[10] = {4, 5, 6, 7, 8, 9, 13, 14, 15, 16};
95  for(auto trg : GetSupportedTriggers()){
96  fHistos->CreateTH1(Form("hEventCount%s", trg.Data()), Form("Event count for trigger class %s", trg.Data()), 1, 0.5, 1.5);
97  fHistos->CreateTH1(Form("hEventCentrality%s", trg.Data()), Form("Event centrality for trigger class %s", trg.Data()), 103, -2., 101.);
98  fHistos->CreateTH1(Form("hVertexZ%s", trg.Data()), Form("z-position of the primary vertex for trigger class %s", trg.Data()), 200, -40., 40.);
99  fHistos->CreateTH1(Form("hClusterEnergy%s", trg.Data()), Form("Cluster energy for trigger class %s", trg.Data()), energybinning);
100  fHistos->CreateTH1(Form("hClusterET%s", trg.Data()), Form("Cluster transverse energy for trigger class %s", trg.Data()), energybinning);
101  fHistos->CreateTH1(Form("hClusterEnergyFired%s", trg.Data()), Form("Cluster energy for trigger class %s, firing the trigger", trg.Data()), energybinning);
102  fHistos->CreateTH1(Form("hClusterETFired%s", trg.Data()), Form("Cluster transverse energy for trigger class %s, firing the trigger", trg.Data()), energybinning);
103  fHistos->CreateTH2(Form("hClusterEnergySM%s", trg.Data()), Form("Cluster energy versus supermodule for trigger class %s", trg.Data()), smbinning, energybinning);
104  fHistos->CreateTH2(Form("hClusterETSM%s", trg.Data()), Form("Cluster transverse energy versus supermodule for trigger class %s", trg.Data()), smbinning, energybinning);
105  fHistos->CreateTH2(Form("hClusterEnergyFiredSM%s", trg.Data()), Form("Cluster energy versus supermodule for trigger class %s, firing the trigger", trg.Data()), smbinning, energybinning);
106  fHistos->CreateTH2(Form("hClusterETFiredSM%s", trg.Data()), Form("Cluster transverse energy versus supermodule for trigger class %s, firing the trigger", trg.Data()), smbinning, energybinning);
107  fHistos->CreateTH2(Form("hEtaEnergy%s", trg.Data()), Form("Cluster energy vs. eta for trigger class %s", trg.Data()), etabinning, energybinning);
108  fHistos->CreateTH2(Form("hEtaET%s", trg.Data()), Form("Cluster transverse energy vs. eta for trigger class %s", trg.Data()), etabinning, energybinning);
109  fHistos->CreateTH2(Form("hEtaEnergyFired%s", trg.Data()), Form("Cluster energy vs. eta for trigger class %s, firing the trigger", trg.Data()), etabinning, energybinning);
110  fHistos->CreateTH2(Form("hEtaETFired%s", trg.Data()), Form("Cluster transverse energy vs. eta for trigger class %s, firing the trigger", trg.Data()), etabinning, energybinning);
111  for(int ism = 0; ism < 20; ism++){
112  fHistos->CreateTH2(Form("hEtaEnergySM%d%s", ism, trg.Data()), Form("Cluster energy vs. eta in Supermodule %d for trigger %s", ism, trg.Data()), etabinning, energybinning);
113  fHistos->CreateTH2(Form("hEtaETSM%d%s", ism, trg.Data()), Form("Cluster transverse energy vs. eta in Supermodule %d for trigger %s", ism, trg.Data()), etabinning, energybinning);
114  fHistos->CreateTH2(Form("hEtaEnergyFiredSM%d%s", ism, trg.Data()), Form("Cluster energy vs. eta in Supermodule %d for trigger %s, firing the trigger", ism, trg.Data()), etabinning, energybinning);
115  fHistos->CreateTH2(Form("hEtaETFiredSM%d%s", ism, trg.Data()), Form("Cluster transverse energy vs. eta in Supermodule %d for trigger %s, firing the trigger", ism, trg.Data()), etabinning, energybinning);
116  }
117  for(int isec = 0; isec < 10; isec++){
118  fHistos->CreateTH2(Form("hEtaEnergySec%d%s", sectorsWithEMCAL[isec], trg.Data()), Form("Cluster energy vs.eta in tracking sector %d for trigger %s", sectorsWithEMCAL[isec], trg.Data()), etabinning, energybinning);
119  fHistos->CreateTH2(Form("hEtaETSec%d%s", sectorsWithEMCAL[isec], trg.Data()), Form("Cluster transverse energy vs.eta in tracking sector %d for trigger %s", sectorsWithEMCAL[isec], trg.Data()), etabinning, energybinning);
120  fHistos->CreateTH2(Form("hEtaEnergyFiredSec%d%s", sectorsWithEMCAL[isec], trg.Data()), Form("Cluster energy vs.eta in tracking sector %d for trigger %s, firing the trigger", sectorsWithEMCAL[isec], trg.Data()), etabinning, energybinning);
121  fHistos->CreateTH2(Form("hEtaETFiredSec%d%s", sectorsWithEMCAL[isec], trg.Data()), Form("Cluster transverse energy vs.eta in tracking sector %d for trigger %s, firing the trigger", sectorsWithEMCAL[isec], trg.Data()), etabinning, energybinning);
122  }
123  for(auto ien : encuts){
124  fHistos->CreateTH2(Form("hEtaPhi%dG%s", static_cast<int>(ien), trg.Data()), Form("cluster #eta-#phi map for clusters with energy larger than %f GeV/c for trigger class %s", ien, trg.Data()), 100, -0.7, 0.7, 200, 0, 2*TMath::Pi());
125  fHistos->CreateTH2(Form("hEtaPhiFired%dG%s", static_cast<int>(ien), trg.Data()), Form("cluster #eta-#phi map for clusters fired the trigger with energy larger than %f GeV/c for trigger class %s", ien, trg.Data()), 200, -0.7, 0.7, 200, 0, 2*TMath::Pi());
126  }
127  }
128 }
129 
131  fEventCentrality = -1;
132  if(fRequestCentrality){
133  AliMultSelection *mult = dynamic_cast<AliMultSelection *>(InputEvent()->FindListObject("MultSelection"));
134  if(!mult){
135  AliErrorStream() << GetName() << ": Centrality selection enabled but no centrality estimator found" << std::endl;
136  return false;
137  }
138  if(mult->IsEventSelected()) return false;
139  fEventCentrality = mult->GetEstimator("V0M")->GetPercentile();
140  AliDebugStream(1) << GetName() << ": Centrality " << fEventCentrality << std::endl;
142  AliDebugStream(1) << GetName() << ": reject centrality: " << fEventCentrality << std::endl;
143  return false;
144  } else {
145  AliDebugStream(1) << GetName() << ": select centrality " << fEventCentrality << std::endl;
146  }
147  } else {
148  AliDebugStream(1) << GetName() << ": No centrality selection applied" << std::endl;
149  }
150  return true;
151 }
152 
154  AliDebugStream(1) << GetName() << ": UserExec start" << std::endl;
155 
156  TList ej1patches, dj1patches, ej2patches, dj2patches, eg1patches, dg1patches, eg2patches, dg2patches;
157  FindPatchesForTrigger("EJ2", fTriggerPatchInfo, ej2patches);
158  FindPatchesForTrigger("DJ2", fTriggerPatchInfo, dj2patches);
159  FindPatchesForTrigger("EJ1", fTriggerPatchInfo, ej1patches);
160  FindPatchesForTrigger("DJ1", fTriggerPatchInfo, dj1patches);
161  FindPatchesForTrigger("EG2", fTriggerPatchInfo, eg2patches);
162  FindPatchesForTrigger("DG2", fTriggerPatchInfo, dg2patches);
163  FindPatchesForTrigger("EG1", fTriggerPatchInfo, eg1patches);
164  FindPatchesForTrigger("DG1", fTriggerPatchInfo, dg1patches);
165 
166  Double_t energy, et, eta, phi;
167  TList *selpatches(nullptr);
168  for(auto clust : GetClusterContainer(fNameClusterContainer.Data())->all()){
169  //AliVCluster *clust = static_cast<AliVCluster *>(*clustIter);
170  if(!clust->IsEMCAL()) continue;
171  if(clust->GetIsExotic()) continue;
172 
173  // Distinguish energy definition
174  switch(fEnergyDefinition){
175  case kDefaultEnergy: energy = clust->E(); break;
176  case kNonLinCorrEnergy: energy = clust->GetNonLinCorrEnergy(); break;
177  case kHadCorrEnergy: energy = clust->GetHadCorrEnergy(); break;
178  };
179 
180  TLorentzVector posvec;
181  energy = clust->GetNonLinCorrEnergy();
182  clust->GetMomentum(posvec, fVertex);
183  posvec.SetE(energy); // use energy definition as selected in the task
184  et = posvec.Et();
185  eta = posvec.Eta();
186  phi = posvec.Phi();
187 
188  // fill histograms allEta
189  for(const auto & trg : fSelectedTriggers){
190  selpatches = nullptr;
191  if(trg.Contains("EJ2")) selpatches = &ej2patches;
192  if(trg.Contains("DJ2")) selpatches = &dj2patches;
193  if(trg.Contains("EJ1")) selpatches = &ej1patches;
194  if(trg.Contains("DJ1")) selpatches = &dj1patches;
195  if(trg.Contains("EG2")) selpatches = &eg2patches;
196  if(trg.Contains("DG2")) selpatches = &dg2patches;
197  if(trg.Contains("EG1")) selpatches = &eg1patches;
198  if(trg.Contains("DG1")) selpatches = &dg1patches;
199  FillClusterHistograms(trg.Data(), energy, et, eta, phi, nullptr);
200  }
201  }
202  return true;
203 }
204 
205 void AliAnalysisTaskEmcalClustersRef::FillClusterHistograms(const TString &triggerclass, double energy, double transverseenergy, double eta, double phi, TList *fTriggerPatches){
206  Bool_t hasTriggerPatch = fTriggerPatches ? CorrelateToTrigger(eta, phi, fTriggerPatches) : kFALSE;
207  Int_t supermoduleID = -1, sector = -1;
208  Double_t weight = GetTriggerWeight(triggerclass);
209  AliDebugStream(1) << GetName() << ": Using weight " << weight << " for trigger " << triggerclass << std::endl;
210 
211  fGeom->SuperModuleNumberFromEtaPhi(eta, phi, supermoduleID);
212  fHistos->FillTH1(Form("hClusterEnergy%s", triggerclass.Data()), energy, weight);
213  fHistos->FillTH1(Form("hClusterET%s", triggerclass.Data()), transverseenergy, weight);
214  fHistos->FillTH2(Form("hEtaEnergy%s", triggerclass.Data()), eta, energy, weight);
215  fHistos->FillTH2(Form("hEtaET%s", triggerclass.Data()), eta, transverseenergy, weight);
216  if(supermoduleID >= 0){
217  fHistos->FillTH2(Form("hClusterEnergySM%s", triggerclass.Data()), supermoduleID, energy, weight);
218  fHistos->FillTH2(Form("hClusterETSM%s", triggerclass.Data()), supermoduleID, transverseenergy, weight);
219  fHistos->FillTH2(Form("hEtaEnergySM%d%s", supermoduleID, triggerclass.Data()), eta, energy, weight);
220  fHistos->FillTH2(Form("hEtaETSM%d%s", supermoduleID, triggerclass.Data()), eta, transverseenergy, weight);
221  if(supermoduleID < 12)
222  sector = 4 + int(supermoduleID/2); // EMCAL
223  else
224  sector = 13 + int((supermoduleID-12)/2); // DCAL
225  fHistos->FillTH2(Form("hEtaEnergySec%d%s", sector, triggerclass.Data()), eta, energy, weight);
226  fHistos->FillTH2(Form("hEtaETSec%d%s", sector, triggerclass.Data()), eta, transverseenergy, weight);
227  }
228  if(hasTriggerPatch){
229  fHistos->FillTH1(Form("hClusterEnergyFired%s", triggerclass.Data()), energy, weight);
230  fHistos->FillTH1(Form("hClusterETFired%s", triggerclass.Data()), energy, weight);
231  fHistos->FillTH2(Form("hEtaEnergyFired%s", triggerclass.Data()), eta, energy, weight);
232  fHistos->FillTH2(Form("hEtaETFired%s", triggerclass.Data()), eta, energy, weight);
233  if(supermoduleID >= 0){
234  fHistos->FillTH2(Form("hClusterEnergyFiredSM%s", triggerclass.Data()), supermoduleID, energy, weight);
235  fHistos->FillTH2(Form("hClusterETFiredSM%s", triggerclass.Data()), supermoduleID, transverseenergy, weight);
236  fHistos->FillTH2(Form("hEtaEnergyFiredSM%d%s", supermoduleID, triggerclass.Data()), eta, energy,weight);
237  fHistos->FillTH2(Form("hEtaETFiredSM%d%s", supermoduleID, triggerclass.Data()), eta, transverseenergy, weight);
238  fHistos->FillTH2(Form("hEtaEnergyFiredSec%d%s", sector, triggerclass.Data()), eta, energy, weight);
239  fHistos->FillTH2(Form("hEtaETFiredSec%d%s", sector, triggerclass.Data()), eta, transverseenergy, weight);
240  }
241  }
242  Double_t encuts[5] = {1., 2., 5., 10., 20.};
243  for(int ien = 0; ien < 5; ien++){
244  if(energy > encuts[ien]){
245  fHistos->FillTH2(Form("hEtaPhi%dG%s", static_cast<int>(encuts[ien]), triggerclass.Data()), eta, phi, weight);
246  if(hasTriggerPatch){
247  fHistos->FillTH2(Form("hEtaPhiFired%dG%s", static_cast<int>(encuts[ien]), triggerclass.Data()), eta, phi, weight);
248  }
249  }
250  }
251 }
252 
254  for(const auto &t : fSelectedTriggers){
255  Double_t weight = GetTriggerWeight(t);
256  fHistos->FillTH1(Form("hEventCount%s", t.Data()), 1, weight);
257  fHistos->FillTH1(Form("hEventCentrality%s", t.Data()), fEventCentrality, weight);
258  fHistos->FillTH1(Form("hVertexZ%s", t.Data()), fVertex[2], weight);
259  }
260 }
261 
263  Bool_t hasfound = kFALSE;
264  for(TIter patchIter = TIter(fTriggerPatches).Begin(); patchIter != TIter::End(); ++patchIter){
265  Double_t boundaries[4];
266  GetPatchBoundaries(*patchIter, boundaries);
267  Double_t etamin = TMath::Min(boundaries[0], boundaries[1]),
268  etamax = TMath::Max(boundaries[0], boundaries[1]),
269  phimin = TMath::Min(boundaries[2], boundaries[3]),
270  phimax = TMath::Max(boundaries[2], boundaries[3]);
271  if(etaclust > etamin && etaclust < etamax && phiclust > phimin && phiclust < phimax){
272  hasfound = kTRUE;
273  break;
274  }
275  }
276  return hasfound;
277 }
278 
279 void AliAnalysisTaskEmcalClustersRef::FindPatchesForTrigger(TString triggerclass, const TClonesArray * fTriggerPatches, TList &foundtriggers) const {
280  foundtriggers.Clear();
281  if(!fTriggerPatches) return;
283  if(triggerclass == "EG1") myclass = AliEmcalTriggerOfflineSelection::kTrgEG1;
284  if(triggerclass == "EG2") myclass = AliEmcalTriggerOfflineSelection::kTrgEG2;
285  if(triggerclass == "EJ1") myclass = AliEmcalTriggerOfflineSelection::kTrgEJ1;
286  if(triggerclass == "EJ2") myclass = AliEmcalTriggerOfflineSelection::kTrgEJ2;
287  if(triggerclass == "DMC7") myclass = AliEmcalTriggerOfflineSelection::kTrgDL0;
288  if(triggerclass == "DG1") myclass = AliEmcalTriggerOfflineSelection::kTrgDG1;
289  if(triggerclass == "DG2") myclass = AliEmcalTriggerOfflineSelection::kTrgDG2;
290  if(triggerclass == "DJ1") myclass = AliEmcalTriggerOfflineSelection::kTrgDJ1;
291  if(triggerclass == "DJ2") myclass = AliEmcalTriggerOfflineSelection::kTrgDJ2;
292  for(TIter patchiter = TIter(fTriggerPatches).Begin(); patchiter != TIter::End(); ++patchiter){
293  if(!IsOfflineSimplePatch(*patchiter)) continue;
295  if(!SelectDCALPatch(*patchiter)) continue;
296  } else {
297  if(SelectDCALPatch(*patchiter)) continue;
298  }
300  if(!SelectSingleShowerPatch(*patchiter)) continue;
301  } else {
302  if(!SelectJetPatch(*patchiter)) continue;
303  }
304  double threshold = fTriggerSelection ? fTriggerSelection->GetThresholdForTrigger(myclass) : -1;
305  if(GetPatchEnergy(*patchiter) > threshold) foundtriggers.Add(*patchiter);
306  }
307 }
308 
310  AliEMCALTriggerPatchInfo *patch= dynamic_cast<AliEMCALTriggerPatchInfo *>(o);
311  boundaries[0] = patch->GetEtaMin();
312  boundaries[1] = patch->GetEtaMax();
313  boundaries[2] = patch->GetPhiMin();
314  boundaries[3] = patch->GetPhiMax();
315 }
316 
318  AliEMCALTriggerPatchInfo *patch = dynamic_cast<AliEMCALTriggerPatchInfo *>(o);
319  return patch->IsOfflineSimple();
320 }
321 
323  AliEMCALTriggerPatchInfo *patch = dynamic_cast<AliEMCALTriggerPatchInfo *>(o);
324  return patch->GetRowStart() >= 64;
325 }
326 
328  AliEMCALTriggerPatchInfo *patch = dynamic_cast<AliEMCALTriggerPatchInfo *>(o);
329  return patch->IsGammaLowSimple();
330 }
331 
333  AliEMCALTriggerPatchInfo *patch = dynamic_cast<AliEMCALTriggerPatchInfo *>(o);
334  if(!patch->IsOfflineSimple()) return false;
335  return patch->IsJetLowSimple();
336 }
337 
339  double energy = 0.;
340  AliEMCALTriggerPatchInfo *patch = dynamic_cast<AliEMCALTriggerPatchInfo *>(o);
341  energy = patch->GetPatchE();
342  return energy;
343 }
344 
346  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
347 
348  //-------------------------------------------------------
349  // Init the task and do settings
350  //-------------------------------------------------------
351 
352  TString clusName(nclusters == "usedefault" ? AliEmcalAnalysisFactory::ClusterContainerNameFactory(mgr->GetInputEventHandler()->InheritsFrom("AliAODInputHandler")) : nclusters);
353 
354  TString taskname = "emcalClusterQA_" + suffix;
355 
357  task->AddClusterContainer(clusName);
358  task->SetClusterContainer(clusName);
359  mgr->AddTask(task);
360 
361  TString outfile(mgr->GetCommonFileName());
362  outfile += ":ClusterQA_" + TString(suffix);
363  TString containername = "ClusterResults_" + TString(suffix);
364  printf("Outfile: %s, container: %s\n", outfile.Data(), containername.Data());
365 
366  task->ConnectInput(0, mgr->GetCommonInputContainer());
367  mgr->ConnectOutput(task, 1, mgr->CreateContainer(containername.Data(), TList::Class(), AliAnalysisManager::kOutputContainer, outfile.Data()));
368 
369  return task;
370 }
371 
373  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
374 
376  mgr->AddTask(task);
377 
378  // Adding cluster container
379  TString clusName(nClusters == "usedefault" ? AliEmcalAnalysisFactory::ClusterContainerNameFactory(mgr->GetInputEventHandler()->InheritsFrom("AliAODInputHandler")) : nClusters);
380  task->AddClusterContainer(clusName.Data());
381  task->SetClusterContainer(clusName);
382 
383  // Set Energy thresholds for additional patch selection:
384  // These are events with offline patches of a given type where the trigger reached already the plateau
385  // These numers are determined as:
386  // EMC7: 3.5 GeV
387  // EG1: 14 GeV
388  // EG2: 8 GeV
389  // EJ1: 22 GeV
390  // EJ2: 12 GeV
393  );
394 
395  TString outfile(mgr->GetCommonFileName());
396  outfile += ":ClusterQA";
397 
398  task->ConnectInput(0, mgr->GetCommonInputContainer());
399  mgr->ConnectOutput(task, 1, mgr->CreateContainer("ClusterResults", AliEmcalList::Class(), AliAnalysisManager::kOutputContainer, outfile.Data()));
400 
401  return task;
402 }
403 
404 
410 {
411  this->SetMinimum(0.);
412  this->AddStep(1, 0.05);
413  this->AddStep(2, 0.1);
414  this->AddStep(4, 0.2);
415  this->AddStep(7, 0.5);
416  this->AddStep(16, 1);
417  this->AddStep(32, 2);
418  this->AddStep(40, 4);
419  this->AddStep(50, 5);
420  this->AddStep(100, 10);
421  this->AddStep(200, 20);
422 }
423 
424 
425 } /* namespace EMCalTriggerPtAnalysis */
void GetPatchBoundaries(TObject *o, Double_t *boundaries) const
std::vector< TString > fSelectedTriggers
! Triggers selected for given event
double Double_t
Definition: External.C:58
Class creating a linear binning, used in the histogram manager.
Bool_t CorrelateToTrigger(Double_t etaclust, Double_t phiclust, TList *triggerpatches) const
static TString ClusterContainerNameFactory(Bool_t isAOD)
void FillTH2(const char *hname, double x, double y, double weight=1., Option_t *opt="")
Simple monitoring task for cluster-related quantities in EMCAL-triggered events.
AliEmcalTriggerOfflineSelection * fTriggerSelection
Offline trigger selection.
Bool_t fRequestCentrality
Switch on request for centrality range.
void AddStep(Double_t max, Double_t binwidth)
void SetOfflineTriggerSelection(AliEmcalTriggerOfflineSelection *sel)
AliClusterContainer * AddClusterContainer(const char *n)
void FillClusterHistograms(const TString &triggerclass, double energy, double transversenergy, double eta, double phi, TList *triggerpatches)
const Double_t etamin
TH2 * CreateTH2(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, Option_t *opt="")
int Int_t
Definition: External.C:63
TString fNameClusterContainer
Name of the cluster container in the event.
AliEMCALGeometry * fGeom
!emcal geometry
EmcalTriggerClass
Definition of the various supported trigger types.
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Helper class creating user defined custom binning.
static AliAnalysisTaskEmcalClustersRef * AddTaskEmcalClustersRef(const TString &nClusters="usedefault", const TString &suffix="")
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
energy
static AliAnalysisTaskEmcalClustersRef * AddTaskEmcalClustersRefDefault(const TString &nClusters="usedefault")
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Double_t fVertex[3]
!event vertex
AliCutValueRange< double > fCentralityRange
Selected centrality range.
const Double_t etamax
TClonesArray * fTriggerPatchInfo
!trigger patch info array
EnergyDefinition_t fEnergyDefinition
Energy definition used for a given cluster.
bool Bool_t
Definition: External.C:53
static AliEmcalTriggerOfflineSelection * TriggerSelectionFactory(Double_t el0, Double_t eg1, Double_t eg2, Double_t ej1, Double_t ej2)
const Double_t phimin
void FindPatchesForTrigger(TString triggerclass, const TClonesArray *triggerpatches, TList &foundpatches) const
void SetMinimum(Double_t min)