AliPhysics  cdeda5a (cdeda5a)
 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"
28 #include "AliEMCALGeometry.h"
29 #include "AliEMCALTriggerPatchInfo.h"
30 #include "AliEMCALTriggerMapping.h"
31 #include "AliESDEvent.h"
32 #include "AliInputEventHandler.h"
33 #include "AliLog.h"
34 #include "AliOADBContainer.h"
35 #include "AliVVertex.h"
36 
40 
41 namespace EMCalTriggerPtAnalysis {
42 
43 AliAnalysisTaskEmcalTriggerBase::AliAnalysisTaskEmcalTriggerBase():
45  fTriggerSelection(nullptr),
46  fUseTriggerBits(kTRUE),
47  fRequireBunchCrossing(kTRUE),
48  fHistos(nullptr),
49  fTriggerStringFromPatches(kFALSE),
50  fSelectedTriggers(),
51  fNameClusterContainer(""),
52  fRequireAnalysisUtils(kTRUE),
53  fVertexCut(-10., 10.),
54  fNameDownscaleOADB(""),
55  fDownscaleOADB(nullptr),
56  fDownscaleFactors(nullptr),
57  fNameMaskedFastorOADB(),
58  fMaskedFastorOADB(nullptr),
59  fMaskedFastors(),
60  fOnlineTriggerThresholds(),
61  fNameAcceptanceOADB(),
62  fSelectNoiseEvents(false),
63  fRejectNoiseEvents(false),
64  fEnableDCALTriggers(true)
65 {
66  SetNeedEmcalGeom(true);
68  SetCaloTriggerPatchInfoName("EmcalTriggers");
69 }
70 
72  AliAnalysisTaskEmcal(name, true),
73  fTriggerSelection(nullptr),
74  fUseTriggerBits(kTRUE),
75  fRequireBunchCrossing(kTRUE),
76  fHistos(nullptr),
77  fTriggerStringFromPatches(kFALSE),
78  fSelectedTriggers(),
79  fNameClusterContainer(""),
80  fRequireAnalysisUtils(kTRUE),
81  fVertexCut(-10., 10.),
82  fNameDownscaleOADB(""),
83  fDownscaleOADB(nullptr),
84  fDownscaleFactors(nullptr),
85  fNameMaskedFastorOADB(),
86  fMaskedFastorOADB(nullptr),
87  fMaskedFastors(),
88  fOnlineTriggerThresholds(),
89  fNameAcceptanceOADB(),
90  fSelectNoiseEvents(false),
91  fRejectNoiseEvents(false),
92  fEnableDCALTriggers(true)
93 {
94  SetNeedEmcalGeom(true);
96  SetCaloTriggerPatchInfoName("EmcalTriggers");
97 }
98 
101  if(fHistos) delete fHistos;
102  if(fDownscaleOADB) delete fDownscaleOADB;
103 }
104 
107  if(fRequireAnalysisUtils && !fAliAnalysisUtils) fAliAnalysisUtils = new AliAnalysisUtils;
108 
109  fHistos = new THistManager(Form("Histos_%s", GetName()));
110 
113 
114  for(auto h : *(fHistos->GetListOfHistograms())) fOutput->Add(h);
115 
116  PostData(1, fOutput);
117 }
118 
120  // Apply trigger selection
122  if(!fSelectedTriggers.size()) return false;
123 
125 
126  const AliVVertex *vtx = fInputEvent->GetPrimaryVertex();
127  //if(!fInputEvent->IsPileupFromSPD(3, 0.8, 3., 2., 5.)) return; // reject pileup event
128  if(vtx->GetNContributors() < 1) return false;
129 
131  if(fInputEvent->IsA() == AliESDEvent::Class() && fAliAnalysisUtils->IsFirstEventInChunk(fInputEvent)) return false;
132  if(fAliAnalysisUtils->IsPileUpEvent(fInputEvent)) return false; // Apply new vertex cut
133  if(!fAliAnalysisUtils->IsVertexSelected2013pA(fInputEvent))return false; // Apply new vertex cut
134  }
135 
136  if(!fVertexCut.IsInRange(fVertex[2])) return false;
137  if(!IsUserEventSelected()) return false;
138 
139  // Do MC outlier cut
140  if(fIsPythia){
141  if(!CheckMCOutliers()){
142  AliDebugStream(1) << GetName() << ": Reject MC outliers" << std::endl;
143  return false;
144  }
145  }
146 
148  return true;
149 }
150 
151 
153  fSelectedTriggers.clear();
154  Bool_t isMC = MCEvent() != nullptr;
155 
156  TString triggerstring = "";
159  } else {
160  triggerstring = fInputEvent->GetFiredTriggerClasses();
161  }
162 
163 
164  UInt_t selectionstatus = fInputHandler->IsEventSelected();
165  Bool_t isMinBias = selectionstatus & AliVEvent::kINT7,
167  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++) emcalTriggers[itrg] = true;
168  if(!isMC){
169  // In case of data select events as bunch-bunch (-B-) events.
170  // Cut not applied in simulations
171  if(fRequireBunchCrossing && ! triggerstring.Contains("-B-")) return;
172 
173  // In case of data use information from the physics selection and event record
174  // Further cleanup of trigger events can be performed depending on the presence
175  // of recalc patches (after masking hot fastors in the trigger maker) above
176  // threshold
177  if(fUseTriggerBits){
178  const std::array<ULong_t, AliEmcalTriggerOfflineSelection::kTrgn> kSelectTriggerBits = {
179  AliVEvent::kEMC7, AliVEvent::kEMCEGA, AliVEvent::kEMCEGA, AliVEvent::kEMCEJE, AliVEvent::kEMCEJE,
180  AliVEvent::kEMC7, AliVEvent::kEMCEGA, AliVEvent::kEMCEGA, AliVEvent::kEMCEJE, AliVEvent::kEMCEJE,
181  };
182  for(int iclass = 0; iclass < AliEmcalTriggerOfflineSelection::kTrgn; iclass++)
183  emcalTriggers[iclass] &= bool(selectionstatus & kSelectTriggerBits[iclass]);
184  }
185 
186  // Apply cut on the trigger string - this basically discriminates high- and low-threshold
187  // triggers
188  const std::array<TString, AliEmcalTriggerOfflineSelection::kTrgn> kSelectTriggerStrings = {
189  "CEMC7", "EG1", "EG2", "EJ1", "EJ2", "CDMC7", "DG1", "DG2", "DJ1", "DJ2"
190  };
191  if(triggerstring.Contains("EMC")) AliDebugStream(1) << GetName() << ": Trigger string " << triggerstring << std::endl;
192  for(int iclass = 0; iclass < AliEmcalTriggerOfflineSelection::kTrgn; iclass++){
193  emcalTriggers[iclass] &= triggerstring.Contains(kSelectTriggerStrings[iclass]);
194  if(emcalTriggers[iclass])
195  AliDebugStream(1) << GetName() << ": Event selected as trigger " << kSelectTriggerStrings[iclass] << std::endl;
196  }
197 
198  // Online selection / rejection
200  if(fRejectNoiseEvents){
201  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++){
202  if(emcalTriggers[itrg])
204  }
205  } else {
206  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++){
207  if(emcalTriggers[itrg])
209  }
210  }
211  }
212  }
213  // Apply offline trigger selection: In this case cuts are performed on the
214  // patch energy from EMCAL cells after calibration. This method is most relevant
215  // for simulations. It can have a special use case in data in case a stronger
216  // offline selection is applied in addition to the online selection.
218  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++)
220  }
221  if(isMinBias) fSelectedTriggers.push_back("MB");
222  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0]){
223  fSelectedTriggers.push_back("EMC7");
224  if(!isMinBias) fSelectedTriggers.push_back("EMC7excl");
225  }
226  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEJ2]){
227  fSelectedTriggers.push_back("EJ2");
228  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0])) fSelectedTriggers.push_back("EJ2excl");
229  }
230  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEJ1]){
231  fSelectedTriggers.push_back("EJ1");
232  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0] || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEJ2])) fSelectedTriggers.push_back("EJ1excl");
233  }
234  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEG2]){
235  fSelectedTriggers.push_back("EG2");
236  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0])) fSelectedTriggers.push_back("EG2excl");
237  }
238  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEG1]){
239  fSelectedTriggers.push_back("EG1");
240  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEL0] || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgEG2])) fSelectedTriggers.push_back("EG1excl");
241  }
242 
244  // Handle DCAL triggers only in case DCAL triggers are enabled,
245  // otherwise ignore results of the online/offline trigger selection
246  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0]){
247  fSelectedTriggers.push_back("DMC7");
248  if(!isMinBias) fSelectedTriggers.push_back("DMC7excl");
249  }
250  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDJ2]){
251  fSelectedTriggers.push_back("DJ2");
252  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0])) fSelectedTriggers.push_back("DJ2excl");
253  }
254  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDJ1]){
255  fSelectedTriggers.push_back("DJ1");
256  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0] || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDJ2])) fSelectedTriggers.push_back("DJ1excl");
257  }
258  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDG2]){
259  fSelectedTriggers.push_back("DG2");
260  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0])) fSelectedTriggers.push_back("DG2excl");
261  }
262  if(emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDG1]){
263  fSelectedTriggers.push_back("DG1");
264  if(!(isMinBias || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDL0] || emcalTriggers[AliEmcalTriggerOfflineSelection::kTrgDG2])) fSelectedTriggers.push_back("DG1excl");
265  }
266  }
267 }
268 
271 
272  if(!fLocalInitialized){
273  return;
274  }
275 
278  }
279 
280  // Handle OADB container with downscaling factors
281  if(fNameDownscaleOADB.Length()){
282  if(fNameDownscaleOADB.Contains("alien://") && ! gGrid) TGrid::Connect("alien://");
283  fDownscaleOADB = new AliOADBContainer("AliEmcalDownscaleFactors");
284  fDownscaleOADB->InitFromFile(fNameDownscaleOADB.Data(), "AliEmcalDownscaleFactors");
285  }
286  // Load OADB container with masked fastors (in case fastor masking is switched on)
288  if(fNameMaskedFastorOADB.Contains("alien://") && ! gGrid) TGrid::Connect("alien://");
289  fMaskedFastorOADB = new AliOADBContainer("AliEmcalMaskedFastors");
290  fMaskedFastorOADB->InitFromFile(fNameMaskedFastorOADB.Data(), "AliEmcalMaskedFastors");
291  }
292 
293  // Setting online threshold for trigger
295  if(fInputEvent->GetRunNumber() >= 15344 && fInputEvent->GetRunNumber() <= 197388){
300  SetOnlineTriggerThreshold("DG1", 0);
301  SetOnlineTriggerThreshold("DG2", 0);
302  SetOnlineTriggerThreshold("DJ1", 0);
303  SetOnlineTriggerThreshold("DJ2", 0);
304  SetOnlineTriggerThreshold("EMC7", 0);
305  SetOnlineTriggerThreshold("DMC7", 0);
306  }
307  }
308 
309  // Load acceptance OADB
310  if(fNameAcceptanceOADB.Length() && fTriggerSelection){
311  AliDebugStream(1) << GetName() << ": Loading acceptance map from OADB file " << fNameAcceptanceOADB << std::endl;
312  AliOADBContainer acceptanceCont("AliEmcalTriggerAcceptance");
313  acceptanceCont.InitFromFile(fNameAcceptanceOADB.Data(), "AliEmcalTriggerAcceptance");
314  TObjArray *acceptanceMaps = dynamic_cast<TObjArray *>(acceptanceCont.GetObject(fInputEvent->GetRunNumber()));
315  TH2 *map(nullptr);
316  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("EG1")))){
317  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger EG1" << std::endl;
318  map->SetDirectory(nullptr);
320  }
321  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("EG2")))){
322  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger EG2" << std::endl;
323  map->SetDirectory(nullptr);
325  }
326  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("DG1")))){
327  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger DG1" << std::endl;
328  map->SetDirectory(nullptr);
330  }
331  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("DG2")))){
332  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger DG2" << std::endl;
333  map->SetDirectory(nullptr);
335  }
336  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("EJ1")))){
337  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger EJ1" << std::endl;
338  map->SetDirectory(nullptr);
340  }
341  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("EJ2")))){
342  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger EJ2" << std::endl;
343  map->SetDirectory(nullptr);
345  }
346  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("DJ1")))){
347  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger DJ1" << std::endl;
348  map->SetDirectory(nullptr);
350  }
351  if((map = dynamic_cast<TH2 *>(acceptanceMaps->FindObject("DJ2")))){
352  AliDebugStream(1) << GetName() << ": Found acceptance map for trigger DJ2" << std::endl;
353  map->SetDirectory(nullptr);
355  }
356  }
357 }
358 
360  if(fDownscaleOADB){
361  fDownscaleFactors = static_cast<TObjArray *>(fDownscaleOADB->GetObject(runnumber));
362  }
363  if(fMaskedFastorOADB){
364  fMaskedFastors.clear();
365  TObjArray *ids = static_cast<TObjArray *>(fMaskedFastorOADB->GetObject(runnumber));
366  for(auto m : *ids){
367  TParameter<int> *id = static_cast<TParameter<int> *>(m);
368  fMaskedFastors.push_back(id->GetVal());
369  }
370  }
371 }
372 
374  // Exclusive means classes without lower trigger classes (which are downscaled) -
375  // in order to make samples statistically independent: MBExcl means MinBias && !EMCAL trigger
376  std::vector<TString> triggers = {
377  "MB", "EMC7", "EJ1", "EJ2", "EG1", "EG2", "EMC7excl", "EG2excl", "EJ2excl", "EJ1excl", "EG1excl"
378  };
379  std::vector<TString> dcaltriggers = {
380  "DMC7", "DJ1", "DJ2", "DG1", "DG2", "DMC7excl", "DG2excl", "DJ2excl", "DJ1excl", "DG1excl"
381  };
383  for(const auto &t : dcaltriggers) triggers.push_back(t);
384  }
385  return triggers;
386 }
387 
389  AliDebugStream(1) << "Using V1 online trigger selector" << std::endl;
391  int ngood(0);
392  for(auto p : *fTriggerPatchInfo){
393  AliEMCALTriggerPatchInfo *patch = static_cast<AliEMCALTriggerPatchInfo *>(p);
394  if((AliEmcalTriggerOfflineSelection::IsSingleShower(trigger) && patch->IsGammaLowRecalc()) ||
395  (!AliEmcalTriggerOfflineSelection::IsSingleShower(trigger) && patch->IsJetLowRecalc())){
396  if(patch->GetADCAmp() >= GetOnlineTriggerThresholdByIndex(trigger)) ngood++;
397  }
398  }
399  return ngood > 0;
400 }
401 
403  if(fDownscaleFactors){
404  TParameter<double> *result(nullptr);
405  // Downscaling only done on MB, L0 and the low threshold triggers
406  if(triggerclass.Contains("MB")) result = static_cast<TParameter<double> *>(fDownscaleFactors->FindObject("INT7"));
407  else if(triggerclass.Contains("EMC7")) result = static_cast<TParameter<double> *>(fDownscaleFactors->FindObject("EMC7"));
408  else if(triggerclass.Contains("EJ2")) result = static_cast<TParameter<double> *>(fDownscaleFactors->FindObject("EJ2"));
409  else if(triggerclass.Contains("EG2")) result = static_cast<TParameter<double> *>(fDownscaleFactors->FindObject("EG2"));
410  if(result) return 1./result->GetVal();
411  }
412  return 1.;
413 }
414 
416  TParameter<int> *threshpar(nullptr);
417  if((threshpar = static_cast<TParameter<int> *>(fOnlineTriggerThresholds.FindObject(triggerclass.Data())))){
418  threshpar->SetVal(threshold);
419  } else {
420  fOnlineTriggerThresholds.Add(new TParameter<int>(triggerclass.Data(), threshold));
421  }
422 }
423 
425  Int_t threshold(0);
426  TParameter<int> *val(nullptr);
427  if((val = static_cast<TParameter<int> *>(fOnlineTriggerThresholds.FindObject(name))))
428  threshold = val->GetVal();
429  return threshold;
430 }
431 
433  const TString triggernames[AliEmcalTriggerOfflineSelection::kTrgn] = {"EMC7", "EG1", "EG2", "EJ1", "EJ2", "DMC7",
434  "DG1", "DG2", "DJ1", "DJ2"};
435  return GetOnlineTriggerThresholdByName(triggernames[trigger]);
436 }
437 
439  const TString triggernames[AliEmcalTriggerOfflineSelection::kTrgn] = {"EMC7", "EG1", "EG2", "EJ1", "EJ2", "DMC7",
440  "DG1", "DG2", "DJ1", "DJ2"};
441  bool isInitialized = true;
442  for(int itrg = 0; itrg < AliEmcalTriggerOfflineSelection::kTrgn; itrg++){
443  if(!fOnlineTriggerThresholds.FindObject(triggernames[itrg].Data())) {
444  isInitialized = false;
445  break;
446  }
447  }
448  return isInitialized;
449 }
450 
452  return adc > GetOnlineTriggerThresholdByName(triggerclass);
453 }
454 
456  TString triggerstring = "";
457  Int_t nEJ1 = 0, nEJ2 = 0, nEG1 = 0, nEG2 = 0, nDJ1 = 0, nDJ2 = 0, nDG1 = 0, nDG2 = 0;
458  for(auto patchIter : *triggerpatches){
459  AliEMCALTriggerPatchInfo *patch = dynamic_cast<AliEMCALTriggerPatchInfo *>(patchIter);
460  if(!patch->IsRecalc()) continue;
461  if(patch->IsEMCal()){
462  if(patch->IsGammaLowRecalc() && SelectFiredPatch("EG1", patch->GetADCAmp())) nEG1++;
463  if(patch->IsGammaLowRecalc() && SelectFiredPatch("EG2", patch->GetADCAmp())) nEG2++;
464  if(patch->IsJetLowRecalc() && SelectFiredPatch("EJ1", patch->GetADCAmp())) nEJ1++;
465  if(patch->IsJetLowRecalc() && SelectFiredPatch("EJ2", patch->GetADCAmp())) nEJ2++;
466  } else {
467  if(patch->IsGammaLowRecalc() && SelectFiredPatch("DG1", patch->GetADCAmp())) nDG1++;
468  if(patch->IsGammaLowRecalc() && SelectFiredPatch("DG2", patch->GetADCAmp())) nDG2++;
469  if(patch->IsJetLowRecalc() && SelectFiredPatch("DJ1", patch->GetADCAmp())) nDJ1++;
470  if(patch->IsJetLowRecalc() && SelectFiredPatch("DJ2", patch->GetADCAmp())) nDJ2++;
471  }
472  }
473  if(nEJ1) triggerstring += "EJ1";
474  if(nEJ2){
475  if(triggerstring.Length()) triggerstring += ",";
476  triggerstring += "EJ2";
477  }
478  if(nEG1){
479  if(triggerstring.Length()) triggerstring += ",";
480  triggerstring += "EG1";
481  }
482  if(nEG2){
483  if(triggerstring.Length()) triggerstring += ",";
484  triggerstring += "EG2";
485  }
486  if(nDJ1){
487  if(triggerstring.Length()) triggerstring += ",";
488  triggerstring += "DJ2";
489  }
490  if(nDJ2){
491  if(triggerstring.Length()) triggerstring += ",";
492  triggerstring += "DJ2";
493  }
494  if(nDG1){
495  if(triggerstring.Length()) triggerstring += ",";
496  triggerstring += "DG1";
497  }
498  if(nDG2){
499  if(triggerstring.Length()) triggerstring += ",";
500  triggerstring += "DG2";
501  }
502  return triggerstring;
503 }
504 
505 } /* 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
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