AliPhysics  6bc8652 (6bc8652)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalTriggerBase.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2016, 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 <functional>
17 #include <iostream>
18 
19 #include <TClonesArray.h>
20 #include <TGrid.h>
21 #include <THistManager.h>
22 #include <TParameter.h>
23 
25 #include "AliAnalysisUtils.h"
26 #include "AliAODEvent.h"
27 #include "AliAODInputHandler.h"
29 #include "AliEMCALGeometry.h"
30 #include "AliEMCALTriggerPatchInfo.h"
31 #include "AliEMCALTriggerMapping.h"
32 #include "AliESDEvent.h"
33 #include "AliInputEventHandler.h"
34 #include "AliLog.h"
35 #include "AliOADBContainer.h"
36 #include "AliVVertex.h"
37 
41 
42 namespace EMCalTriggerPtAnalysis {
43 
44 AliAnalysisTaskEmcalTriggerBase::AliAnalysisTaskEmcalTriggerBase():
46  fTriggerSelection(nullptr),
47  fUseTriggerBits(kTRUE),
48  fRequireBunchCrossing(kTRUE),
49  fHistos(nullptr),
50  fTriggerStringFromPatches(kFALSE),
51  fSelectedTriggers(),
52  fNameClusterContainer(""),
53  fRequireAnalysisUtils(kTRUE),
54  fVertexCut(-10., 10.),
55  fNameDownscaleOADB(""),
56  fDownscaleOADB(nullptr),
57  fDownscaleFactors(nullptr),
58  fNameMaskedFastorOADB(),
59  fMaskedFastorOADB(nullptr),
60  fMaskedFastors(),
61  fOnlineTriggerThresholds(),
62  fNameAcceptanceOADB(),
63  fSelectNoiseEvents(false),
64  fRejectNoiseEvents(false),
65  fEnableDCALTriggers(true)
66 {
67  SetNeedEmcalGeom(true);
69  SetCaloTriggerPatchInfoName("EmcalTriggers");
70 }
71 
73  AliAnalysisTaskEmcal(name, true),
74  fTriggerSelection(nullptr),
75  fUseTriggerBits(kTRUE),
76  fRequireBunchCrossing(kTRUE),
77  fHistos(nullptr),
78  fTriggerStringFromPatches(kFALSE),
79  fSelectedTriggers(),
80  fNameClusterContainer(""),
81  fRequireAnalysisUtils(kTRUE),
82  fVertexCut(-10., 10.),
83  fNameDownscaleOADB(""),
84  fDownscaleOADB(nullptr),
85  fDownscaleFactors(nullptr),
86  fNameMaskedFastorOADB(),
87  fMaskedFastorOADB(nullptr),
88  fMaskedFastors(),
89  fOnlineTriggerThresholds(),
90  fNameAcceptanceOADB(),
91  fSelectNoiseEvents(false),
92  fRejectNoiseEvents(false),
93  fEnableDCALTriggers(true)
94 {
95  SetNeedEmcalGeom(true);
97  SetCaloTriggerPatchInfoName("EmcalTriggers");
98 }
99 
102  if(fHistos) delete fHistos;
103  if(fDownscaleOADB) delete fDownscaleOADB;
104 }
105 
108  if(fRequireAnalysisUtils && !fAliAnalysisUtils) fAliAnalysisUtils = new AliAnalysisUtils;
109 
110  if(!fNameClusterContainer.Length()) fNameClusterContainer = AliEmcalAnalysisFactory::ClusterContainerNameFactory(fInputHandler->IsA() == AliAODInputHandler::Class());
113  }
114 
115  fHistos = new THistManager(Form("Histos_%s", GetName()));
116 
119 
120  for(auto h : *(fHistos->GetListOfHistograms())) fOutput->Add(h);
121 
122  PostData(1, fOutput);
123 }
124 
126  // Apply trigger selection
128  if(!fSelectedTriggers.size()) return false;
129 
131 
132  const AliVVertex *vtx = fInputEvent->GetPrimaryVertex();
133  //if(!fInputEvent->IsPileupFromSPD(3, 0.8, 3., 2., 5.)) return; // reject pileup event
134  if(vtx->GetNContributors() < 1) return false;
135 
137  if(fInputEvent->IsA() == AliESDEvent::Class() && fAliAnalysisUtils->IsFirstEventInChunk(fInputEvent)) return false;
138  if(fAliAnalysisUtils->IsPileUpEvent(fInputEvent)) return false; // Apply new vertex cut
139  if(!fAliAnalysisUtils->IsVertexSelected2013pA(fInputEvent))return false; // Apply new vertex cut
140  }
141 
142  if(!fVertexCut.IsInRange(fVertex[2])) return false;
143  if(!IsUserEventSelected()) return false;
144 
145  // Do MC outlier cut
146  if(fIsPythia){
147  if(!CheckMCOutliers()){
148  AliDebugStream(1) << GetName() << ": Reject MC outliers" << std::endl;
149  return false;
150  }
151  }
152 
154  return true;
155 }
156 
157 
159  fSelectedTriggers.clear();
160  Bool_t isMC = MCEvent() != nullptr;
161 
162  TString triggerstring = "";
165  } else {
166  triggerstring = fInputEvent->GetFiredTriggerClasses();
167  }
168 
169 
170  UInt_t selectionstatus = fInputHandler->IsEventSelected();
171  Bool_t isMinBias = selectionstatus & AliVEvent::kINT7,
173  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++) emcalTriggers[itrg] = true;
174  if(!isMC){
175  // In case of data select events as bunch-bunch (-B-) events.
176  // Cut not applied in simulations
177  if(fRequireBunchCrossing && ! triggerstring.Contains("-B-")) return;
178 
179  // In case of data use information from the physics selection and event record
180  // Further cleanup of trigger events can be performed depending on the presence
181  // of recalc patches (after masking hot fastors in the trigger maker) above
182  // threshold
183  if(fUseTriggerBits){
184  const std::array<ULong_t, AliEmcalTriggerOfflineSelection::kTrgn> kSelectTriggerBits = {
185  AliVEvent::kEMC7, AliVEvent::kEMCEGA, AliVEvent::kEMCEGA, AliVEvent::kEMCEJE, AliVEvent::kEMCEJE,
186  AliVEvent::kEMC7, AliVEvent::kEMCEGA, AliVEvent::kEMCEGA, AliVEvent::kEMCEJE, AliVEvent::kEMCEJE,
187  };
188  for(int iclass = 0; iclass < AliEmcalTriggerOfflineSelection::kTrgn; iclass++)
189  emcalTriggers[iclass] &= bool(selectionstatus & kSelectTriggerBits[iclass]);
190  }
191 
192  // Apply cut on the trigger string - this basically discriminates high- and low-threshold
193  // triggers
194  const std::array<TString, AliEmcalTriggerOfflineSelection::kTrgn> kSelectTriggerStrings = {
195  "CEMC7", "EG1", "EG2", "EJ1", "EJ2", "CDMC7", "DG1", "DG2", "DJ1", "DJ2"
196  };
197  if(triggerstring.Contains("EMC")) AliDebugStream(1) << GetName() << ": Trigger string " << triggerstring << std::endl;
198  for(int iclass = 0; iclass < AliEmcalTriggerOfflineSelection::kTrgn; iclass++){
199  emcalTriggers[iclass] &= triggerstring.Contains(kSelectTriggerStrings[iclass]);
200  if(emcalTriggers[iclass])
201  AliDebugStream(1) << GetName() << ": Event selected as trigger " << kSelectTriggerStrings[iclass] << std::endl;
202  }
203 
204  // Online selection / rejection
206  if(fRejectNoiseEvents){
207  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++){
208  if(emcalTriggers[itrg])
210  }
211  } else {
212  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++){
213  if(emcalTriggers[itrg])
215  }
216  }
217  }
218  }
219  // Apply offline trigger selection: In this case cuts are performed on the
220  // patch energy from EMCAL cells after calibration. This method is most relevant
221  // for simulations. It can have a special use case in data in case a stronger
222  // offline selection is applied in addition to the online selection.
224  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++)
226  }
227  if(isMinBias) fSelectedTriggers.push_back("MB");
228  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0]){
229  fSelectedTriggers.push_back("EMC7");
230  if(!isMinBias) fSelectedTriggers.push_back("EMC7excl");
231  }
232  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEJ2]){
233  fSelectedTriggers.push_back("EJ2");
234  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0])) fSelectedTriggers.push_back("EJ2excl");
235  }
236  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEJ1]){
237  fSelectedTriggers.push_back("EJ1");
238  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0] || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEJ2])) fSelectedTriggers.push_back("EJ1excl");
239  }
240  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEG2]){
241  fSelectedTriggers.push_back("EG2");
242  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0])) fSelectedTriggers.push_back("EG2excl");
243  }
244  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEG1]){
245  fSelectedTriggers.push_back("EG1");
246  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0] || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEG2])) fSelectedTriggers.push_back("EG1excl");
247  }
248 
250  // Handle DCAL triggers only in case DCAL triggers are enabled,
251  // otherwise ignore results of the online/offline trigger selection
252  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0]){
253  fSelectedTriggers.push_back("DMC7");
254  if(!isMinBias) fSelectedTriggers.push_back("DMC7excl");
255  }
256  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDJ2]){
257  fSelectedTriggers.push_back("DJ2");
258  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0])) fSelectedTriggers.push_back("DJ2excl");
259  }
260  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDJ1]){
261  fSelectedTriggers.push_back("DJ1");
262  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0] || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDJ2])) fSelectedTriggers.push_back("DJ1excl");
263  }
264  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDG2]){
265  fSelectedTriggers.push_back("DG2");
266  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0])) fSelectedTriggers.push_back("DG2excl");
267  }
268  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDG1]){
269  fSelectedTriggers.push_back("DG1");
270  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0] || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDG2])) fSelectedTriggers.push_back("DG1excl");
271  }
272  }
273 }
274 
277 
278  if(!fLocalInitialized){
279  return;
280  }
281 
282  // Handle OADB container with downscaling factors
283  if(fNameDownscaleOADB.Length()){
284  if(fNameDownscaleOADB.Contains("alien://") && ! gGrid) TGrid::Connect("alien://");
285  fDownscaleOADB = new AliOADBContainer("AliEmcalDownscaleFactors");
286  fDownscaleOADB->InitFromFile(fNameDownscaleOADB.Data(), "AliEmcalDownscaleFactors");
287  }
288  // Load OADB container with masked fastors (in case fastor masking is switched on)
290  if(fNameMaskedFastorOADB.Contains("alien://") && ! gGrid) TGrid::Connect("alien://");
291  fMaskedFastorOADB = new AliOADBContainer("AliEmcalMaskedFastors");
292  fMaskedFastorOADB->InitFromFile(fNameMaskedFastorOADB.Data(), "AliEmcalMaskedFastors");
293  }
294 
295  // Setting online threshold for trigger
297  if(fInputEvent->GetRunNumber() >= 15344 && fInputEvent->GetRunNumber() <= 197388){
302  SetOnlineTriggerThreshold("DG1", 0);
303  SetOnlineTriggerThreshold("DG2", 0);
304  SetOnlineTriggerThreshold("DJ1", 0);
305  SetOnlineTriggerThreshold("DJ2", 0);
306  SetOnlineTriggerThreshold("EMC7", 0);
307  SetOnlineTriggerThreshold("DMC7", 0);
308  }
309  }
310 
311  // Load acceptance OADB
312  if(fNameAcceptanceOADB.Length() && fTriggerSelection){
313  AliDebugStream(1) << GetName() << ": Loading acceptance map from OADB file " << fNameAcceptanceOADB << std::endl;
314  AliOADBContainer acceptanceCont("AliEmcalTriggerAcceptance");
315  acceptanceCont.InitFromFile(fNameAcceptanceOADB.Data(), "AliEmcalTriggerAcceptance");
316  TObjArray *acceptanceMaps = dynamic_cast<TObjArray *>(acceptanceCont.GetObject(fInputEvent->GetRunNumber()));
317  TH2 *map(nullptr);
318  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("EG1")))){
319  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger EG1" << std::endl;
320  map->SetDirectory(nullptr);
322  }
323  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("EG2")))){
324  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger EG2" << std::endl;
325  map->SetDirectory(nullptr);
327  }
328  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("DG1")))){
329  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger DG1" << std::endl;
330  map->SetDirectory(nullptr);
332  }
333  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("DG2")))){
334  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger DG2" << std::endl;
335  map->SetDirectory(nullptr);
337  }
338  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("EJ1")))){
339  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger EJ1" << std::endl;
340  map->SetDirectory(nullptr);
342  }
343  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("EJ2")))){
344  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger EJ2" << std::endl;
345  map->SetDirectory(nullptr);
347  }
348  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("DJ1")))){
349  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger DJ1" << std::endl;
350  map->SetDirectory(nullptr);
352  }
353  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("DJ2")))){
354  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger DJ2" << std::endl;
355  map->SetDirectory(nullptr);
357  }
358  }
359 }
360 
362  if(fDownscaleOADB){
363  fDownscaleFactors = static_cast<TObjArray *>(fDownscaleOADB->GetObject(runnumber));
364  }
365  if(fMaskedFastorOADB){
366  fMaskedFastors.clear();
367  TObjArray *ids = static_cast<TObjArray *>(fMaskedFastorOADB->GetObject(runnumber));
368  for(auto m : *ids){
369  TParameter<int> *id = static_cast<TParameter<int> *>(m);
370  fMaskedFastors.push_back(id->GetVal());
371  }
372  }
373 }
374 
376  // Exclusive means classes without lower trigger classes (which are downscaled) -
377  // in order to make samples statistically independent: MBExcl means MinBias && !EMCAL trigger
378  std::vector<TString> triggers = {
379  "MB", "EMC7", "EJ1", "EJ2", "EG1", "EG2", "EMC7excl", "EG2excl", "EJ2excl", "EJ1excl", "EG1excl"
380  };
381  std::vector<TString> dcaltriggers = {
382  "DMC7", "DJ1", "DJ2", "DG1", "DG2", "DMC7excl", "DG2excl", "DJ2excl", "DJ1excl", "DG1excl"
383  };
385  for(const auto &t : dcaltriggers) triggers.push_back(t);
386  }
387  return triggers;
388 }
389 
391  AliDebugStream(1) << "Using V1 online trigger selector" << std::endl;
393  int ngood(0);
394  for(auto p : *fTriggerPatchInfo){
395  AliEMCALTriggerPatchInfo *patch = static_cast<AliEMCALTriggerPatchInfo *>(p);
396  if((AliEmcalTriggerOfflineSelection::IsSingleShower(trigger) && patch->IsGammaLowRecalc()) ||
397  (!AliEmcalTriggerOfflineSelection::IsSingleShower(trigger) && patch->IsJetLowRecalc())){
398  if(patch->GetADCAmp() >= GetOnlineTriggerThresholdByIndex(trigger)) ngood++;
399  }
400  }
401  return ngood > 0;
402 }
403 
405  if(fDownscaleFactors){
406  TParameter<double> *result(nullptr);
407  // Downscaling only done on MB, L0 and the low threshold triggers
408  if(triggerclass.Contains("MB")) result = static_cast<TParameter<double> *>(fDownscaleFactors->FindObject("INT7"));
409  else if(triggerclass.Contains("EMC7")) result = static_cast<TParameter<double> *>(fDownscaleFactors->FindObject("EMC7"));
410  else if(triggerclass.Contains("EJ2")) result = static_cast<TParameter<double> *>(fDownscaleFactors->FindObject("EJ2"));
411  else if(triggerclass.Contains("EG2")) result = static_cast<TParameter<double> *>(fDownscaleFactors->FindObject("EG2"));
412  if(result) return 1./result->GetVal();
413  }
414  return 1.;
415 }
416 
418  TParameter<int> *threshpar(nullptr);
419  if((threshpar = static_cast<TParameter<int> *>(fOnlineTriggerThresholds.FindObject(triggerclass.Data())))){
420  threshpar->SetVal(threshold);
421  } else {
422  fOnlineTriggerThresholds.Add(new TParameter<int>(triggerclass.Data(), threshold));
423  }
424 }
425 
427  Int_t threshold(0);
428  TParameter<int> *val(nullptr);
429  if((val = static_cast<TParameter<int> *>(fOnlineTriggerThresholds.FindObject(name))))
430  threshold = val->GetVal();
431  return threshold;
432 }
433 
435  const TString triggernames[AliEmcalTriggerOfflineSelection::kTrgn] = {"EMC7", "EG1", "EG2", "EJ1", "EJ2", "DMC7",
436  "DG1", "DG2", "DJ1", "DJ2"};
437  return GetOnlineTriggerThresholdByName(triggernames[trigger]);
438 }
439 
441  const TString triggernames[AliEmcalTriggerOfflineSelection::kTrgn] = {"EMC7", "EG1", "EG2", "EJ1", "EJ2", "DMC7",
442  "DG1", "DG2", "DJ1", "DJ2"};
443  bool isInitialized = true;
444  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++){
445  if(!fOnlineTriggerThresholds.FindObject(triggernames[itrg].Data())) {
446  isInitialized = false;
447  break;
448  }
449  }
450  return isInitialized;
451 }
452 
454  return adc > GetOnlineTriggerThresholdByName(triggerclass);
455 }
456 
458  TString triggerstring = "";
459  Int_t nEJ1 = 0, nEJ2 = 0, nEG1 = 0, nEG2 = 0, nDJ1 = 0, nDJ2 = 0, nDG1 = 0, nDG2 = 0;
460  for(auto patchIter : *triggerpatches){
461  AliEMCALTriggerPatchInfo *patch = dynamic_cast<AliEMCALTriggerPatchInfo *>(patchIter);
462  if(!patch->IsRecalc()) continue;
463  if(patch->IsEMCal()){
464  if(patch->IsGammaLowRecalc() && SelectFiredPatch("EG1", patch->GetADCAmp())) nEG1++;
465  if(patch->IsGammaLowRecalc() && SelectFiredPatch("EG2", patch->GetADCAmp())) nEG2++;
466  if(patch->IsJetLowRecalc() && SelectFiredPatch("EJ1", patch->GetADCAmp())) nEJ1++;
467  if(patch->IsJetLowRecalc() && SelectFiredPatch("EJ2", patch->GetADCAmp())) nEJ2++;
468  } else {
469  if(patch->IsGammaLowRecalc() && SelectFiredPatch("DG1", patch->GetADCAmp())) nDG1++;
470  if(patch->IsGammaLowRecalc() && SelectFiredPatch("DG2", patch->GetADCAmp())) nDG2++;
471  if(patch->IsJetLowRecalc() && SelectFiredPatch("DJ1", patch->GetADCAmp())) nDJ1++;
472  if(patch->IsJetLowRecalc() && SelectFiredPatch("DJ2", patch->GetADCAmp())) nDJ2++;
473  }
474  }
475  if(nEJ1) triggerstring += "EJ1";
476  if(nEJ2){
477  if(triggerstring.Length()) triggerstring += ",";
478  triggerstring += "EJ2";
479  }
480  if(nEG1){
481  if(triggerstring.Length()) triggerstring += ",";
482  triggerstring += "EG1";
483  }
484  if(nEG2){
485  if(triggerstring.Length()) triggerstring += ",";
486  triggerstring += "EG2";
487  }
488  if(nDJ1){
489  if(triggerstring.Length()) triggerstring += ",";
490  triggerstring += "DJ2";
491  }
492  if(nDJ2){
493  if(triggerstring.Length()) triggerstring += ",";
494  triggerstring += "DJ2";
495  }
496  if(nDG1){
497  if(triggerstring.Length()) triggerstring += ",";
498  triggerstring += "DG1";
499  }
500  if(nDG2){
501  if(triggerstring.Length()) triggerstring += ",";
502  triggerstring += "DG2";
503  }
504  return triggerstring;
505 }
506 
507 } /* namespace EMCalTriggerPtAnalysis */
std::vector< TString > fSelectedTriggers
! Triggers selected for given event
Bool_t IsOfflineSelected(EmcalTriggerClass trgcls, const AliVEvent *const data) const
Bool_t fIsPythia
trigger, if it is a PYTHIA production
double Double_t
Definition: External.C:58
Int_t GetOnlineTriggerThresholdByIndex(AliEmcalTriggerOfflineSelection::EmcalTriggerClass trg) const
Bool_t fRejectNoiseEvents
Reject events triggered by noisy fastors.
Base task in the EMCAL framework.
void SetOnlineTriggerThreshold(const TString &triggerclass, Int_t threshold)
Bool_t fLocalInitialized
whether or not the task has been already initialized
TString GetFiredTriggerClassesFromPatches(const TClonesArray *triggerpatches) const
static TString ClusterContainerNameFactory(Bool_t isAOD)
AliEmcalTriggerOfflineSelection * fTriggerSelection
Offline trigger selection.
TObjArray fOnlineTriggerThresholds
Trigger thresholds applied at online level.
Bool_t fEnableDCALTriggers
Enable / Disable event selection for DCAL trigger classes.
void SetCaloTriggerPatchInfoName(const char *n)
TString fNameMaskedFastorOADB
Name of the masked fastor OADB container.
Bool_t fRequireAnalysisUtils
Switch whether to require event selection in AliAnalysisUtils.
bool SelectOnlineTrigger(AliEmcalTriggerOfflineSelection::EmcalTriggerClass trigger) const
Bool_t fRequireBunchCrossing
Require bunch-bunch events (tag -B- in trigger string)
void SetAcceptanceMap(EmcalTriggerClass trgcls, const TH2 *accmap)
int Int_t
Definition: External.C:63
TString fNameClusterContainer
Name of the cluster container in the event.
unsigned int UInt_t
Definition: External.C:33
THashList * GetListOfHistograms() const
Definition: THistManager.h:504
EmcalTriggerClass
Definition of the various supported trigger types.
AliAnalysisUtils * fAliAnalysisUtils
!vertex selection (optional)
TString fNameDownscaleOADB
Name of the downscale OADB container.
TString fNameAcceptanceOADB
Name of the OADB container with the trigger acceptance.
AliOADBContainer * fMaskedFastorOADB
! Container with masked fastors
Bool_t fSelectNoiseEvents
Explicitly select events triggered only by noisy fastors.
Bool_t fUseTriggerBits
Switch whether using trigger bits (relies on physics selection)
Bool_t fTriggerStringFromPatches
Do rebuild the trigger string from trigger patches.
Bool_t isMC
AliEmcalList * fOutput
!output list
Definition: External.C:220
AliOADBContainer * fDownscaleOADB
! Container with downscale factors for different triggers
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Double_t fVertex[3]
!event vertex
void SetMakeGeneralHistograms(Bool_t g)
TClonesArray * fTriggerPatchInfo
!trigger patch info array
void SetNeedEmcalGeom(Bool_t n)
Container class for histograms.
Definition: THistManager.h:43
AliCutValueRange< double > fVertexCut
Cut on the z-position of the primary vertex.
bool Bool_t
Definition: External.C:53
Bool_t SelectFiredPatch(const TString &triggerclass, Int_t adc) const