AliPhysics  b0b429f (b0b429f)
 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"
35 #include "AliEmcalAnalysisFactory.h"
36 #include "AliEMCALGeometry.h"
37 #include "AliEmcalList.h"
38 #include "AliEMCALTriggerPatchInfo.h"
39 #include "AliEmcalTriggerOfflineSelection.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 
50 #include "AliAnalysisTaskEmcalClustersRef.h"
51 
53 ClassImp(EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef)
55 
56 namespace EMCalTriggerPtAnalysis {
57 
58 AliAnalysisTaskEmcalClustersRef::AliAnalysisTaskEmcalClustersRef() :
59  AliAnalysisTaskEmcalTriggerBase(),
60  fCentralityRange(-999., 999.),
61  fRequestCentrality(false),
62  fEventCentrality(-1),
63  fCentralityEstimator("V0M"),
64  fEnergyDefinition(kDefaultEnergy),
65  fEnableSumw2(false),
66  fClusterTimeRange(-50e-6, 50e-6)
67 {
68 }
69 
70 AliAnalysisTaskEmcalClustersRef::AliAnalysisTaskEmcalClustersRef(const char *name) :
71  AliAnalysisTaskEmcalTriggerBase(name),
72  fCentralityRange(-999., 999.),
73  fRequestCentrality(false),
74  fEventCentrality(-1),
75  fCentralityEstimator("V0M"),
76  fEnergyDefinition(kDefaultEnergy),
77  fEnableSumw2(false),
78  fClusterTimeRange(-50e-6, 50e-6)
79 {
80 }
81 
82 AliAnalysisTaskEmcalClustersRef::~AliAnalysisTaskEmcalClustersRef() {
83 }
84 
85 
86 void AliAnalysisTaskEmcalClustersRef::CreateUserHistos(){
87 
88  EnergyBinning energybinning;
89  TLinearBinning smbinning(21, -0.5, 20.5), etabinning(100, -0.7, 0.7), timebinning(100, -500e-9, 500e-9);
90  TString optionstring = fEnableSumw2 ? "s" : "";
91 
92  /*
93  * Exclusive classes are defined as triggered events
94  * in a class without lower threshold classes firing.
95  * This is needed to make the triggers statistically
96  * independent.
97  */
98  std::array<Double_t, 5> encuts = {1., 2., 5., 10., 20.};
99  Int_t sectorsWithEMCAL[10] = {4, 5, 6, 7, 8, 9, 13, 14, 15, 16};
100  for(auto trg : GetSupportedTriggers()){
101  fHistos->CreateTH1(Form("hEventCount%s", trg.Data()), Form("Event count for trigger class %s", trg.Data()), 1, 0.5, 1.5, optionstring);
102  fHistos->CreateTH1(Form("hEventCentrality%s", trg.Data()), Form("Event centrality for trigger class %s", trg.Data()), 103, -2., 101., optionstring);
103  fHistos->CreateTH1(Form("hVertexZ%s", trg.Data()), Form("z-position of the primary vertex for trigger class %s", trg.Data()), 200, -40., 40., optionstring);
104  fHistos->CreateTH1(Form("hClusterEnergy%s", trg.Data()), Form("Cluster energy for trigger class %s", trg.Data()), energybinning, optionstring);
105  fHistos->CreateTH1(Form("hClusterET%s", trg.Data()), Form("Cluster transverse energy for trigger class %s", trg.Data()), energybinning, optionstring);
106  fHistos->CreateTH1(Form("hClusterEnergyFired%s", trg.Data()), Form("Cluster energy for trigger class %s, firing the trigger", trg.Data()), energybinning, optionstring);
107  fHistos->CreateTH1(Form("hClusterETFired%s", trg.Data()), Form("Cluster transverse energy for trigger class %s, firing the trigger", trg.Data()), energybinning, optionstring);
108  fHistos->CreateTH2(Form("hClusterEnergySM%s", trg.Data()), Form("Cluster energy versus supermodule for trigger class %s", trg.Data()), smbinning, energybinning, optionstring);
109  fHistos->CreateTH2(Form("hClusterETSM%s", trg.Data()), Form("Cluster transverse energy versus supermodule for trigger class %s", trg.Data()), smbinning, energybinning, optionstring);
110  fHistos->CreateTH2(Form("hClusterEnergyFiredSM%s", trg.Data()), Form("Cluster energy versus supermodule for trigger class %s, firing the trigger", trg.Data()), smbinning, energybinning, optionstring);
111  fHistos->CreateTH2(Form("hClusterETFiredSM%s", trg.Data()), Form("Cluster transverse energy versus supermodule for trigger class %s, firing the trigger", trg.Data()), smbinning, energybinning, optionstring);
112  fHistos->CreateTH2(Form("hEtaEnergy%s", trg.Data()), Form("Cluster energy vs. eta for trigger class %s", trg.Data()), etabinning, energybinning, optionstring);
113  fHistos->CreateTH2(Form("hEtaET%s", trg.Data()), Form("Cluster transverse energy vs. eta for trigger class %s", trg.Data()), etabinning, energybinning, optionstring);
114  fHistos->CreateTH2(Form("hTimeEnergy%s", trg.Data()), Form("Cluster time vs. energy for trigger class %s", trg.Data()), timebinning, energybinning, optionstring);
115  fHistos->CreateTH2(Form("hEtaEnergyFired%s", trg.Data()), Form("Cluster energy vs. eta for trigger class %s, firing the trigger", trg.Data()), etabinning, energybinning, optionstring);
116  fHistos->CreateTH2(Form("hEtaETFired%s", trg.Data()), Form("Cluster transverse energy vs. eta for trigger class %s, firing the trigger", trg.Data()), etabinning, energybinning, optionstring);
117  for(int ism = 0; ism < 20; ism++){
118  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, optionstring);
119  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, optionstring);
120  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, optionstring);
121  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, optionstring);
122  }
123  for(int isec = 0; isec < 10; isec++){
124  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, optionstring);
125  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, optionstring);
126  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, optionstring);
127  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, optionstring);
128  }
129  for(auto ien : encuts){
130  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(), optionstring);
131  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(), optionstring);
132  }
133  }
134 }
135 
136 bool AliAnalysisTaskEmcalClustersRef::IsUserEventSelected(){
137  fEventCentrality = -1;
138  if(fRequestCentrality){
139  AliMultSelection *mult = dynamic_cast<AliMultSelection *>(InputEvent()->FindListObject("MultSelection"));
140  if(!mult){
141  AliErrorStream() << GetName() << ": Centrality selection enabled but no centrality estimator found" << std::endl;
142  return false;
143  }
144  if(mult->IsEventSelected()) return false;
145  fEventCentrality = mult->GetEstimator(fCentralityEstimator)->GetPercentile();
146  AliDebugStream(1) << GetName() << ": Centrality " << fEventCentrality << std::endl;
147  if(!fCentralityRange.IsInRange(fEventCentrality)){
148  AliDebugStream(1) << GetName() << ": reject centrality: " << fEventCentrality << std::endl;
149  return false;
150  } else {
151  AliDebugStream(1) << GetName() << ": select centrality " << fEventCentrality << std::endl;
152  }
153  } else {
154  AliDebugStream(1) << GetName() << ": No centrality selection applied" << std::endl;
155  }
156  return true;
157 }
158 
159 bool AliAnalysisTaskEmcalClustersRef::Run(){
160  AliDebugStream(1) << GetName() << ": UserExec start" << std::endl;
161 
162  TList ej1patches, dj1patches, ej2patches, dj2patches, eg1patches, dg1patches, eg2patches, dg2patches;
163  FindPatchesForTrigger("EJ2", fTriggerPatchInfo, ej2patches);
164  FindPatchesForTrigger("DJ2", fTriggerPatchInfo, dj2patches);
165  FindPatchesForTrigger("EJ1", fTriggerPatchInfo, ej1patches);
166  FindPatchesForTrigger("DJ1", fTriggerPatchInfo, dj1patches);
167  FindPatchesForTrigger("EG2", fTriggerPatchInfo, eg2patches);
168  FindPatchesForTrigger("DG2", fTriggerPatchInfo, dg2patches);
169  FindPatchesForTrigger("EG1", fTriggerPatchInfo, eg1patches);
170  FindPatchesForTrigger("DG1", fTriggerPatchInfo, dg1patches);
171 
172  Double_t energy, et, eta, phi;
173  TList *selpatches(nullptr);
174  for(auto clust : GetClusterContainer(fNameClusterContainer.Data())->all()){
175  //AliVCluster *clust = static_cast<AliVCluster *>(*clustIter);
176  if(!clust->IsEMCAL()) continue;
177  if(clust->GetIsExotic()) continue;
178  if(!fClusterTimeRange.IsInRange(clust->GetTOF())) continue;
179 
180  // Distinguish energy definition
181  switch(fEnergyDefinition){
182  case kDefaultEnergy:
183  AliDebugStream(2) << GetName() << ": Using cluster energy definition: default" << std::endl;
184  energy = clust->E();
185  break;
186  case kNonLinCorrEnergy:
187  AliDebugStream(2) << GetName() << ": Using cluster energy definition: corrected for non-linearity" << std::endl;
188  energy = clust->GetNonLinCorrEnergy();
189  break;
190  case kHadCorrEnergy:
191  AliDebugStream(2) << GetName() << ": Using cluster energy definition: corrected for hadronic contribution" << std::endl;
192  energy = clust->GetHadCorrEnergy();
193  break;
194  };
195 
196  AliDebugStream(2) << GetName() << ": Using energy " << energy << " (def: " << clust->E()
197  << " | NL: " << clust->GetNonLinCorrEnergy()
198  << " | HD: " << clust->GetHadCorrEnergy()
199  << ")" << std::endl;
200 
201  TLorentzVector posvec;
202  clust->GetMomentum(posvec, fVertex);
203  posvec.SetE(energy); // use energy definition as selected in the task
204  et = posvec.Et();
205  eta = posvec.Eta();
206  phi = posvec.Phi();
207 
208  // fill histograms allEta
209  for(const auto & trg : fSelectedTriggers){
210  selpatches = nullptr;
211  if(trg.Contains("EJ2")) selpatches = &ej2patches;
212  if(trg.Contains("DJ2")) selpatches = &dj2patches;
213  if(trg.Contains("EJ1")) selpatches = &ej1patches;
214  if(trg.Contains("DJ1")) selpatches = &dj1patches;
215  if(trg.Contains("EG2")) selpatches = &eg2patches;
216  if(trg.Contains("DG2")) selpatches = &dg2patches;
217  if(trg.Contains("EG1")) selpatches = &eg1patches;
218  if(trg.Contains("DG1")) selpatches = &dg1patches;
219  FillClusterHistograms(trg.Data(), energy, et, eta, phi, clust->GetTOF(), nullptr);
220  }
221  }
222  return true;
223 }
224 
225 void AliAnalysisTaskEmcalClustersRef::FillClusterHistograms(const TString &triggerclass, double energy, double transverseenergy, double eta, double phi, double clustertime, TList *fTriggerPatches){
226  Bool_t hasTriggerPatch = fTriggerPatches ? CorrelateToTrigger(eta, phi, fTriggerPatches) : kFALSE;
227  Int_t supermoduleID = -1, sector = -1;
228  Double_t weight = GetTriggerWeight(triggerclass);
229  AliDebugStream(1) << GetName() << ": Using weight " << weight << " for trigger " << triggerclass << std::endl;
230 
231  fGeom->SuperModuleNumberFromEtaPhi(eta, phi, supermoduleID);
232  fHistos->FillTH1(Form("hClusterEnergy%s", triggerclass.Data()), energy, weight);
233  fHistos->FillTH1(Form("hClusterET%s", triggerclass.Data()), transverseenergy, weight);
234  fHistos->FillTH2(Form("hEtaEnergy%s", triggerclass.Data()), eta, energy, weight);
235  fHistos->FillTH2(Form("hEtaET%s", triggerclass.Data()), eta, transverseenergy, weight);
236  fHistos->FillTH2(Form("hTimeEnergy%s", triggerclass.Data()), clustertime, energy, weight);
237  if(supermoduleID >= 0){
238  fHistos->FillTH2(Form("hClusterEnergySM%s", triggerclass.Data()), supermoduleID, energy, weight);
239  fHistos->FillTH2(Form("hClusterETSM%s", triggerclass.Data()), supermoduleID, transverseenergy, weight);
240  fHistos->FillTH2(Form("hEtaEnergySM%d%s", supermoduleID, triggerclass.Data()), eta, energy, weight);
241  fHistos->FillTH2(Form("hEtaETSM%d%s", supermoduleID, triggerclass.Data()), eta, transverseenergy, weight);
242  if(supermoduleID < 12)
243  sector = 4 + int(supermoduleID/2); // EMCAL
244  else
245  sector = 13 + int((supermoduleID-12)/2); // DCAL
246  fHistos->FillTH2(Form("hEtaEnergySec%d%s", sector, triggerclass.Data()), eta, energy, weight);
247  fHistos->FillTH2(Form("hEtaETSec%d%s", sector, triggerclass.Data()), eta, transverseenergy, weight);
248  }
249  if(hasTriggerPatch){
250  fHistos->FillTH1(Form("hClusterEnergyFired%s", triggerclass.Data()), energy, weight);
251  fHistos->FillTH1(Form("hClusterETFired%s", triggerclass.Data()), energy, weight);
252  fHistos->FillTH2(Form("hEtaEnergyFired%s", triggerclass.Data()), eta, energy, weight);
253  fHistos->FillTH2(Form("hEtaETFired%s", triggerclass.Data()), eta, energy, weight);
254  if(supermoduleID >= 0){
255  fHistos->FillTH2(Form("hClusterEnergyFiredSM%s", triggerclass.Data()), supermoduleID, energy, weight);
256  fHistos->FillTH2(Form("hClusterETFiredSM%s", triggerclass.Data()), supermoduleID, transverseenergy, weight);
257  fHistos->FillTH2(Form("hEtaEnergyFiredSM%d%s", supermoduleID, triggerclass.Data()), eta, energy,weight);
258  fHistos->FillTH2(Form("hEtaETFiredSM%d%s", supermoduleID, triggerclass.Data()), eta, transverseenergy, weight);
259  fHistos->FillTH2(Form("hEtaEnergyFiredSec%d%s", sector, triggerclass.Data()), eta, energy, weight);
260  fHistos->FillTH2(Form("hEtaETFiredSec%d%s", sector, triggerclass.Data()), eta, transverseenergy, weight);
261  }
262  }
263  Double_t encuts[5] = {1., 2., 5., 10., 20.};
264  for(int ien = 0; ien < 5; ien++){
265  if(energy > encuts[ien]){
266  fHistos->FillTH2(Form("hEtaPhi%dG%s", static_cast<int>(encuts[ien]), triggerclass.Data()), eta, phi, weight);
267  if(hasTriggerPatch){
268  fHistos->FillTH2(Form("hEtaPhiFired%dG%s", static_cast<int>(encuts[ien]), triggerclass.Data()), eta, phi, weight);
269  }
270  }
271  }
272 }
273 
274 void AliAnalysisTaskEmcalClustersRef::UserFillHistosAfterEventSelection(){
275  for(const auto &t : fSelectedTriggers){
276  Double_t weight = GetTriggerWeight(t);
277  fHistos->FillTH1(Form("hEventCount%s", t.Data()), 1, weight);
278  fHistos->FillTH1(Form("hEventCentrality%s", t.Data()), fEventCentrality, weight);
279  fHistos->FillTH1(Form("hVertexZ%s", t.Data()), fVertex[2], weight);
280  }
281 }
282 
283 Bool_t AliAnalysisTaskEmcalClustersRef::CorrelateToTrigger(Double_t etaclust, Double_t phiclust, TList *fTriggerPatches) const {
284  Bool_t hasfound = kFALSE;
285  for(TIter patchIter = TIter(fTriggerPatches).Begin(); patchIter != TIter::End(); ++patchIter){
286  Double_t boundaries[4];
287  GetPatchBoundaries(*patchIter, boundaries);
288  Double_t etamin = TMath::Min(boundaries[0], boundaries[1]),
289  etamax = TMath::Max(boundaries[0], boundaries[1]),
290  phimin = TMath::Min(boundaries[2], boundaries[3]),
291  phimax = TMath::Max(boundaries[2], boundaries[3]);
292  if(etaclust > etamin && etaclust < etamax && phiclust > phimin && phiclust < phimax){
293  hasfound = kTRUE;
294  break;
295  }
296  }
297  return hasfound;
298 }
299 
300 void AliAnalysisTaskEmcalClustersRef::FindPatchesForTrigger(TString triggerclass, const TClonesArray * triggerPatches, TList &foundtriggers) const {
301  foundtriggers.Clear();
302  if(!triggerPatches) return;
303  AliEmcalTriggerOfflineSelection::EmcalTriggerClass myclass = AliEmcalTriggerOfflineSelection::kTrgEL0;
304  if(triggerclass == "EG1") myclass = AliEmcalTriggerOfflineSelection::kTrgEG1;
305  if(triggerclass == "EG2") myclass = AliEmcalTriggerOfflineSelection::kTrgEG2;
306  if(triggerclass == "EJ1") myclass = AliEmcalTriggerOfflineSelection::kTrgEJ1;
307  if(triggerclass == "EJ2") myclass = AliEmcalTriggerOfflineSelection::kTrgEJ2;
308  if(triggerclass == "DMC7") myclass = AliEmcalTriggerOfflineSelection::kTrgDL0;
309  if(triggerclass == "DG1") myclass = AliEmcalTriggerOfflineSelection::kTrgDG1;
310  if(triggerclass == "DG2") myclass = AliEmcalTriggerOfflineSelection::kTrgDG2;
311  if(triggerclass == "DJ1") myclass = AliEmcalTriggerOfflineSelection::kTrgDJ1;
312  if(triggerclass == "DJ2") myclass = AliEmcalTriggerOfflineSelection::kTrgDJ2;
313  for(auto patchiter : *triggerPatches){
314  AliEMCALTriggerPatchInfo *mypatch = static_cast<AliEMCALTriggerPatchInfo *>(patchiter);
315  if(!mypatch->IsOfflineSimple()) continue;
316  if(AliEmcalTriggerOfflineSelection::IsDCAL(myclass)){
317  if(!mypatch->IsDCalPHOS()) continue;
318  } else {
319  if(mypatch->IsDCalPHOS()) continue;
320  }
321  if(AliEmcalTriggerOfflineSelection::IsSingleShower(myclass)){
322  if(!mypatch->IsGammaLowSimple()) continue;
323  } else {
324  if(!mypatch->IsJetLowSimple()) continue;
325  }
326  double threshold = fTriggerSelection ? fTriggerSelection->GetThresholdForTrigger(myclass) : -1;
327  if(mypatch->GetPatchE() > threshold) foundtriggers.Add(patchiter);
328  }
329 }
330 
331 void AliAnalysisTaskEmcalClustersRef::GetPatchBoundaries(TObject *o, Double_t *boundaries) const {
332  AliEMCALTriggerPatchInfo *patch= dynamic_cast<AliEMCALTriggerPatchInfo *>(o);
333  boundaries[0] = patch->GetEtaMin();
334  boundaries[1] = patch->GetEtaMax();
335  boundaries[2] = patch->GetPhiMin();
336  boundaries[3] = patch->GetPhiMax();
337 }
338 
339 AliAnalysisTaskEmcalClustersRef *AliAnalysisTaskEmcalClustersRef::AddTaskEmcalClustersRef(const TString &nclusters, const TString &suffix){
340  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
341 
342  //-------------------------------------------------------
343  // Init the task and do settings
344  //-------------------------------------------------------
345 
346  TString clusName(nclusters == "usedefault" ? AliEmcalAnalysisFactory::ClusterContainerNameFactory(mgr->GetInputEventHandler()->InheritsFrom("AliAODInputHandler")) : nclusters);
347 
348  TString taskname = "emcalClusterQA_" + suffix;
349 
350  EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef *task = new EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef(taskname.Data());
351  task->AddClusterContainer(clusName);
352  task->SetClusterContainer(clusName);
353  mgr->AddTask(task);
354 
355  TString outfile(mgr->GetCommonFileName());
356  outfile += ":ClusterQA_" + TString(suffix);
357  TString containername = "ClusterResults_" + TString(suffix);
358  printf("Outfile: %s, container: %s\n", outfile.Data(), containername.Data());
359 
360  task->ConnectInput(0, mgr->GetCommonInputContainer());
361  mgr->ConnectOutput(task, 1, mgr->CreateContainer(containername.Data(), TList::Class(), AliAnalysisManager::kOutputContainer, outfile.Data()));
362 
363  return task;
364 }
365 
366 AliAnalysisTaskEmcalClustersRef *AliAnalysisTaskEmcalClustersRef::AddTaskEmcalClustersRefDefault(const TString &nClusters){
367  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
368 
369  EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef *task = new EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef("emcalClusterQA");
370  mgr->AddTask(task);
371 
372  // Adding cluster container
373  TString clusName(nClusters == "usedefault" ? AliEmcalAnalysisFactory::ClusterContainerNameFactory(mgr->GetInputEventHandler()->InheritsFrom("AliAODInputHandler")) : nClusters);
374  task->AddClusterContainer(clusName.Data());
375  task->SetClusterContainer(clusName);
376 
377  // Set Energy thresholds for additional patch selection:
378  // These are events with offline patches of a given type where the trigger reached already the plateau
379  // These numers are determined as:
380  // EMC7: 3.5 GeV
381  // EG1: 14 GeV
382  // EG2: 8 GeV
383  // EJ1: 22 GeV
384  // EJ2: 12 GeV
385  task->SetOfflineTriggerSelection(
386  EMCalTriggerPtAnalysis::AliEmcalAnalysisFactory::TriggerSelectionFactory(5, 14, 8, 22, 12)
387  );
388 
389  TString outfile(mgr->GetCommonFileName());
390  outfile += ":ClusterQA";
391 
392  task->ConnectInput(0, mgr->GetCommonInputContainer());
393  mgr->ConnectOutput(task, 1, mgr->CreateContainer("ClusterResults", AliEmcalList::Class(), AliAnalysisManager::kOutputContainer, outfile.Data()));
394 
395  return task;
396 }
397 
398 
402 AliAnalysisTaskEmcalClustersRef::EnergyBinning::EnergyBinning():
403  TCustomBinning()
404 {
405  this->SetMinimum(0.);
406  this->AddStep(1, 0.05);
407  this->AddStep(2, 0.1);
408  this->AddStep(4, 0.2);
409  this->AddStep(7, 0.5);
410  this->AddStep(16, 1);
411  this->AddStep(32, 2);
412  this->AddStep(40, 4);
413  this->AddStep(50, 5);
414  this->AddStep(100, 10);
415  this->AddStep(200, 20);
416 }
417 
418 
419 } /* namespace EMCalTriggerPtAnalysis */
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::fClusterTimeRange
AliCutValueRange< double > fClusterTimeRange
Selected range on cluster time.
Definition: AliAnalysisTaskEmcalClustersRef.h:183
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::GetPatchBoundaries
void GetPatchBoundaries(TObject *o, Double_t *boundaries) const
Definition: AliAnalysisTaskEmcalClustersRef.cxx:331
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalTriggerBase::fSelectedTriggers
std::vector< TString > fSelectedTriggers
! Triggers selected for given event
Definition: AliAnalysisTaskEmcalTriggerBase.h:337
Double_t
double Double_t
Definition: External.C:58
TLinearBinning
Class creating a linear binning, used in the histogram manager.
Definition: TLinearBinning.h:47
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::CorrelateToTrigger
Bool_t CorrelateToTrigger(Double_t etaclust, Double_t phiclust, TList *triggerpatches) const
Definition: AliAnalysisTaskEmcalClustersRef.cxx:283
AliEmcalTriggerOfflineSelection.h
THistManager.h
AliEmcalList.h
EMCalTriggerPtAnalysis::AliEmcalAnalysisFactory::ClusterContainerNameFactory
static TString ClusterContainerNameFactory(Bool_t isAOD)
THistManager::FillTH2
void FillTH2(const char *hname, double x, double y, double weight=1., Option_t *opt="")
Definition: THistManager.cxx:425
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef
Simple monitoring task for cluster-related quantities in EMCAL-triggered events.
Definition: AliAnalysisTaskEmcalClustersRef.h:32
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalTriggerBase::fTriggerSelection
AliEmcalTriggerOfflineSelection * fTriggerSelection
Offline trigger selection.
Definition: AliAnalysisTaskEmcalTriggerBase.h:335
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::fRequestCentrality
Bool_t fRequestCentrality
Switch on request for centrality range.
Definition: AliAnalysisTaskEmcalClustersRef.h:177
EMCalTriggerPtAnalysis::AliEmcalAnalysisFactory::TriggerSelectionFactory
static AliEmcalTriggerOfflineSelection * TriggerSelectionFactory(Double_t el0, Double_t eg1, Double_t eg2, Double_t ej1, Double_t ej2, AliEmcalTriggerOfflineSelection::EmcalEnergyDefinition_t endef=AliEmcalTriggerOfflineSelection::kFEEEnergy)
TCustomBinning::AddStep
void AddStep(Double_t max, Double_t binwidth)
Definition: TCustomBinning.cxx:32
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalTriggerBase::SetOfflineTriggerSelection
void SetOfflineTriggerSelection(AliEmcalTriggerOfflineSelection *sel)
Definition: AliAnalysisTaskEmcalTriggerBase.h:127
AliEmcalAnalysisFactory.h
AliAnalysisTaskEmcal::AddClusterContainer
AliClusterContainer * AddClusterContainer(const char *n)
Definition: AliAnalysisTaskEmcal.cxx:1565
etamin
const Double_t etamin
Definition: AddTaskCFDStar.C:40
TLinearBinning.h
THistManager::CreateTH2
TH2 * CreateTH2(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, Option_t *opt="")
Definition: THistManager.cxx:141
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalTriggerBase::fNameClusterContainer
TString fNameClusterContainer
Name of the cluster container in the event.
Definition: AliAnalysisTaskEmcalTriggerBase.h:338
Int_t
int Int_t
Definition: External.C:63
AliAnalysisTaskEmcal::fGeom
AliEMCALGeometry * fGeom
!emcal geometry
Definition: AliAnalysisTaskEmcal.h:325
EMCalTriggerPtAnalysis::AliEmcalTriggerOfflineSelection::EmcalTriggerClass
EmcalTriggerClass
Definition of the various supported trigger types.
Definition: AliEmcalTriggerOfflineSelection.h:53
THistManager::CreateTH1
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
Definition: THistManager.cxx:80
AliAnalysisTaskEmcal::GetClusterContainer
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Definition: AliAnalysisTaskEmcal.cxx:1593
TCustomBinning
Helper class creating user defined custom binning.
Definition: TCustomBinning.h:52
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::AddTaskEmcalClustersRef
static AliAnalysisTaskEmcalClustersRef * AddTaskEmcalClustersRef(const TString &nClusters="usedefault", const TString &suffix="")
Definition: AliAnalysisTaskEmcalClustersRef.cxx:339
THistManager::FillTH1
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
Definition: THistManager.cxx:378
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::fCentralityEstimator
TString fCentralityEstimator
Centrality estimator (default: V0M for PbPb)
Definition: AliAnalysisTaskEmcalClustersRef.h:179
energy
energy
Definition: HFPtSpectrumRaa.C:55
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::FillClusterHistograms
void FillClusterHistograms(const TString &triggerclass, double energy, double transversenergy, double eta, double phi, double clustertime, TList *triggerpatches)
Definition: AliAnalysisTaskEmcalClustersRef.cxx:225
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::AddTaskEmcalClustersRefDefault
static AliAnalysisTaskEmcalClustersRef * AddTaskEmcalClustersRefDefault(const TString &nClusters="usedefault")
Definition: AliAnalysisTaskEmcalClustersRef.cxx:366
ClassImp
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Definition: AliAnalysisTaskCRC.cxx:44
AliAnalysisTaskEmcal::fVertex
Double_t fVertex[3]
!event vertex
Definition: AliAnalysisTaskEmcal.h:336
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::fCentralityRange
AliCutValueRange< double > fCentralityRange
Selected centrality range.
Definition: AliAnalysisTaskEmcalClustersRef.h:176
etamax
const Double_t etamax
Definition: AddTaskCFDStar.C:41
AliAnalysisTaskEmcalClustersRef.h
AliAnalysisTaskEmcal::fTriggerPatchInfo
TClonesArray * fTriggerPatchInfo
!trigger patch info array
Definition: AliAnalysisTaskEmcal.h:330
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::fEnergyDefinition
EnergyDefinition_t fEnergyDefinition
Energy definition used for a given cluster.
Definition: AliAnalysisTaskEmcalClustersRef.h:181
Bool_t
bool Bool_t
Definition: External.C:53
suffix
TString suffix
Definition: ComputeEfficiencyFromCombinHF.C:24
AliClusterContainer.h
phimin
const Double_t phimin
Definition: AddTaskCFDStar.C:32
EMCalTriggerPtAnalysis::AliAnalysisTaskEmcalClustersRef::FindPatchesForTrigger
void FindPatchesForTrigger(TString triggerclass, const TClonesArray *triggerpatches, TList &foundpatches) const
Definition: AliAnalysisTaskEmcalClustersRef.cxx:300
TCustomBinning::SetMinimum
void SetMinimum(Double_t min)
Definition: TCustomBinning.h:107