AliPhysics  b1f9b5e (b1f9b5e)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliCaloTrackReader.h
Go to the documentation of this file.
1 #ifndef ALICALOTRACKREADER_H
2 #define ALICALOTRACKREADER_H
3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  * See cxx source for full Copyright notice */
5 
6 //_________________________________________________________________________
23 //_________________________________________________________________________
24 
25 // --- ROOT system ---
26 #include <TObject.h>
27 #include <TString.h>
28 class TObjArray ;
29 class TTree ;
30 class TArrayI ;
31 #include <TRandom3.h>
32 
33 //--- ANALYSIS system ---
34 #include "AliVEvent.h"
35 class AliVCaloCells;
36 class AliStack;
37 class AliHeader;
38 class AliGenEventHeader;
39 class AliAODEvent;
40 class AliMCEvent;
41 class AliMixedEvent;
42 class AliAODMCHeader;
43 class AliCentrality;
44 class AliMultSelection;
45 class AliESDtrackCuts;
46 //class AliTriggerAnalysis;
47 class AliEventplane;
48 class AliVCluster;
49 
50 // --- CaloTrackCorr / EMCAL ---
51 #include "AliFiducialCut.h"
52 class AliCalorimeterUtils;
53 #include "AliAnaWeights.h"
54 
55 // Jets
56 class AliAODJetEventBackground;
57 
58 class AliCaloTrackReader : public TObject {
59 
60 public:
61 
62  AliCaloTrackReader() ; // ctor
63  virtual ~AliCaloTrackReader() ; // virtual dtor
64  void DeletePointers();
65 
66  //--------------------------------
67  // General methods
68  //--------------------------------
69 
70  virtual void Init();
71 
72  virtual void InitParameters();
73 
74  virtual void Print(const Option_t * opt) const;
75 
76  virtual void ResetLists();
77 
78  virtual Int_t GetDebug() const { return fDebug ; }
79  virtual void SetDebug(Int_t d) { fDebug = d ; }
80 
81  enum inputDataType {kESD, kAOD, kMC};
82  virtual Int_t GetDataType() const { return fDataType ; }
83  virtual void SetDataType(Int_t data ) { fDataType = data ; }
84 
85  virtual Int_t GetEventNumber() const { return fEventNumber ; }
86 
87  virtual TObjString * GetListOfParameters() ;
88 
89  TString GetTaskName() const { return fTaskName ; }
90  void SetTaskName(TString name) { fTaskName = name ; }
91 
92  //---------------------------------------
93  // Input/output event setters and getters
94  //---------------------------------------
95 
96  virtual void SetInputEvent(AliVEvent* input) ;
97  virtual void SetOutputEvent(AliAODEvent* aod) { fOutputEvent = aod ; }
98  virtual void SetMC(AliMCEvent* const mc) { fMC = mc ; }
99  virtual void SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) { ; }
100 
101  // Delta AODs
102 
103  virtual TList * GetAODBranchList() const { return fAODBranchList ; }
104  void SetDeltaAODFileName(TString name ) { fDeltaAODFileName = name ; }
105  TString GetDeltaAODFileName() const { return fDeltaAODFileName ; }
106  void SwitchOnWriteDeltaAOD() { fWriteOutputDeltaAOD = kTRUE ; }
107  void SwitchOffWriteDeltaAOD() { fWriteOutputDeltaAOD = kFALSE ; }
108  Bool_t WriteDeltaAODToFile() const { return fWriteOutputDeltaAOD ; }
109 
110  virtual TList * GetCreateControlHistograms() ;
111  void SetControlHistogramEnergyBinning(Int_t nBins, Float_t emin, Float_t emax)
112  { fEnergyHistogramNbins = nBins ; fEnergyHistogramLimit[0] = emin; fEnergyHistogramLimit[1] = emax ; }
113 
114  //------------------------------------------------------------
115  // Clusters/Tracks arrays filtering/filling methods and switchs
116  //------------------------------------------------------------
117 
118  // detector identificator enum, used here and in AliAnaCaloTrackBaseClass and derived classes
119  enum detector { kEMCAL = AliFiducialCut::kEMCAL, kPHOS = AliFiducialCut::kPHOS,
120  kCTS = AliFiducialCut::kCTS , kDCAL = AliFiducialCut::kDCAL,
121  kDCALPHOS = AliFiducialCut::kDCALPHOS } ;
122 
124  enum smearingFunction { kNoSmearing, kSmearingLandau, kSmearingLandauShift } ;
125 
126  // Minimum pt setters and getters
127 
128  Float_t GetEMCALPtMin() const { return fEMCALPtMin ; }
129  Float_t GetPHOSPtMin() const { return fPHOSPtMin ; }
130  Float_t GetCTSPtMin() const { return fCTSPtMin ; }
131  Float_t GetEMCALPtMax() const { return fEMCALPtMax ; }
132  Float_t GetPHOSPtMax() const { return fPHOSPtMax ; }
133  Float_t GetCTSPtMax() const { return fCTSPtMax ; }
134 
135  void SetEMCALPtMin(Float_t pt) { fEMCALPtMin = pt ; }
136  void SetPHOSPtMin (Float_t pt) { fPHOSPtMin = pt ; }
137  void SetCTSPtMin (Float_t pt) { fCTSPtMin = pt ; }
138  void SetEMCALPtMax(Float_t pt) { fEMCALPtMax = pt ; }
139  void SetPHOSPtMax (Float_t pt) { fPHOSPtMax = pt ; }
140  void SetCTSPtMax (Float_t pt) { fCTSPtMax = pt ; }
141 
142  Float_t GetEMCALEMin() const { return GetEMCALPtMin() ; }
143  Float_t GetPHOSEMin() const { return GetPHOSPtMin() ; }
144  Float_t GetEMCALEMax() const { return GetEMCALPtMax() ; }
145  Float_t GetPHOSEMax() const { return GetPHOSPtMax() ; }
146 
147  void SetEMCALEMin (Float_t en) { SetEMCALPtMin(en) ; }
148  void SetPHOSEMin (Float_t en) { SetPHOSPtMin (en) ; }
149  void SetEMCALEMax (Float_t en) { SetEMCALPtMax(en) ; }
150  void SetPHOSEMax (Float_t en) { SetPHOSPtMax (en) ; }
151 
152  virtual Int_t GetTrackID(AliVTrack* track) ;
153 
154  // Distance to bad channels cut
155 
156  Float_t GetEMCALBadChannelMinDist() const { return fEMCALBadChMinDist ; }
157  Float_t GetPHOSBadChannelMinDist() const { return fPHOSBadChMinDist ; }
158 
159  void SetEMCALBadChannelMinDist(Float_t di) { fEMCALBadChMinDist = di ; }
160  void SetPHOSBadChannelMinDist (Float_t di) { fPHOSBadChMinDist = di ; }
161 
162  // Number of cells in cluster cut
163 
164  Int_t GetEMCALNCellsCut() const { return fEMCALNCellsCut ; }
165  Int_t GetPHOSNCellsCut() const { return fPHOSNCellsCut ; }
166 
167  void SetEMCALNCellsCut(Int_t nc) { fEMCALNCellsCut = nc ; }
168  void SetPHOSNCellsCut (Int_t nc) { fPHOSNCellsCut = nc ; }
169 
170  // Track DCA cut
171 
172  Bool_t AcceptDCA(Float_t pt, Float_t dca);
173  Double_t GetTrackDCACut(Int_t i) const { if(i >= 0 && i < 3 ) return fTrackDCACut[i] ;
174  else return -999 ; }
175 
176  void SetTrackDCACut(Int_t i, Float_t cut) { if(i >= 0 && i < 3 )
177  fTrackDCACut[i] = cut ; }
178 
179  void SwitchOnUseTrackDCACut() { fUseTrackDCACut = kTRUE ; }
180  void SwitchOffUseTrackDCACut() { fUseTrackDCACut = kFALSE ; }
181  Bool_t IsDCACutOn() const { return fUseTrackDCACut ; }
182 
183  // Time cut
184 
185  Double_t GetTrackTimeCutMin() const { return fTrackTimeCutMin ; }
186  Double_t GetTrackTimeCutMax() const { return fTrackTimeCutMax ; }
187 
188  void SetTrackTimeCut(Double_t a, Double_t b) { fTrackTimeCutMin = a ;
189  fTrackTimeCutMax = b ; } // ns
190 
191  void SwitchOnUseTrackTimeCut() { fUseTrackTimeCut = kTRUE ; fAccessTrackTOF = kTRUE ; }
192  void SwitchOffUseTrackTimeCut() { fUseTrackTimeCut = kFALSE ; }
193 
194  void SwitchOnAccessTrackTimeCut() { fAccessTrackTOF = kTRUE ; }
195  void SwitchOffAccessTrackTimeCut() { fAccessTrackTOF = kFALSE ; }
196  Bool_t IsAccessToTrackTimeOn() const { return fAccessTrackTOF ; }
197 
198 
199  Double_t GetEMCALTimeCutMin() const { return fEMCALTimeCutMin ; }
200  Double_t GetEMCALTimeCutMax() const { return fEMCALTimeCutMax ; }
201 
202  Bool_t IsInTimeWindow(Double_t tof, Float_t energy) const ;
203 
204  void SetEMCALTimeCut(Double_t a, Double_t b) { fEMCALTimeCutMin = a ;
205  fEMCALTimeCutMax = b ; } // ns
206 
207  void SetEMCALParametrizedMinTimeCut(Int_t i, Float_t par) { fEMCALParamTimeCutMin[i] = par ; }
208  void SetEMCALParametrizedMaxTimeCut(Int_t i, Float_t par) { fEMCALParamTimeCutMax[i] = par ; }
209 
210  void SwitchOnUseEMCALTimeCut() { fUseEMCALTimeCut = kTRUE ; }
211  void SwitchOffUseEMCALTimeCut() { fUseEMCALTimeCut = kFALSE ; }
212 
213  void SwitchOnUseParametrizedTimeCut() { fUseParamTimeCut = kTRUE ; }
214  void SwitchOffUseParametrizedTimeCut() { fUseParamTimeCut = kFALSE ; }
215 
216  // Fidutial cuts
217 
218  virtual AliFiducialCut * GetFiducialCut() {
219  if(!fFiducialCut) fFiducialCut = new AliFiducialCut();
220  return fFiducialCut ; }
221  virtual void SetFiducialCut(AliFiducialCut * fc) { fFiducialCut = fc ; }
222  virtual Bool_t IsFiducialCutOn() const { return fCheckFidCut ; }
223  virtual void SwitchOnFiducialCut() { fCheckFidCut = kTRUE ;
224  fFiducialCut = new AliFiducialCut() ; }
225  virtual void SwitchOffFiducialCut() { fCheckFidCut = kFALSE ; }
226 
227  // Cluster/track/cells switchs
228 
229  Bool_t IsCTSSwitchedOn() const { return fFillCTS ; }
230  void SwitchOnCTS() { fFillCTS = kTRUE ; }
231  void SwitchOffCTS() { fFillCTS = kFALSE ; }
232 
233  Bool_t IsEMCALSwitchedOn() const { return fFillEMCAL ; }
234  void SwitchOnEMCAL() { fFillEMCAL = kTRUE ; }
235  void SwitchOffEMCAL() { fFillEMCAL = kFALSE ; }
236 
237  Bool_t IsDCALSwitchedOn() const { return fFillDCAL ; }
238  void SwitchOnDCAL() { fFillDCAL = kTRUE ; }
239  void SwitchOffDCAL() { fFillDCAL = kFALSE ; }
240 
241  Bool_t IsPHOSSwitchedOn() const { return fFillPHOS ; }
242  void SwitchOnPHOS() { fFillPHOS = kTRUE ; }
243  void SwitchOffPHOS() { fFillPHOS = kFALSE ; }
244 
245  Bool_t IsEMCALCellsSwitchedOn() const { return fFillEMCALCells ; }
246  void SwitchOnEMCALCells() { fFillEMCALCells = kTRUE ; }
247  void SwitchOffEMCALCells() { fFillEMCALCells = kFALSE ; }
248 
249  Bool_t IsPHOSCellsSwitchedOn() const { return fFillPHOSCells ; }
250  void SwitchOnPHOSCells() { fFillPHOSCells = kTRUE ; }
251  void SwitchOffPHOSCells() { fFillPHOSCells = kFALSE ; }
252 
253  Bool_t AreClustersRecalculated() const { return fRecalculateClusters ; }
254  void SwitchOnClusterRecalculation() { fRecalculateClusters = kTRUE ; }
255  void SwitchOffClusterRecalculation() { fRecalculateClusters = kFALSE ; }
256 
257  void SwitchOnClusterELinearityCorrection() { fCorrectELinearity = kTRUE ; }
258  void SwitchOffClusterELinearityCorrection() { fCorrectELinearity = kFALSE ; }
259 
260  Bool_t IsEmbeddedClusterSelectionOn() const { return fSelectEmbeddedClusters ; }
261  void SwitchOnEmbeddedClustersSelection() { fSelectEmbeddedClusters = kTRUE ; }
262  void SwitchOffEmbeddedClustersSelection() { fSelectEmbeddedClusters = kFALSE ; }
263 
264  // Shower shape smearing function
265 
266  void SetSmearingFunction(Int_t smfu) { fSmearingFunction = smfu ; }
267  Int_t GetSmearingFunction() const { return fSmearingFunction ; }
268 
269  Bool_t IsShowerShapeSmeared() const { return fSmearShowerShape ; }
270  void SwitchOnShowerShapeSmearing() { fSmearShowerShape = kTRUE ; }
271  void SwitchOffShowerShapeSmearing() { fSmearShowerShape = kFALSE ; }
272 
273  void SetShowerShapeSmearWidth(Float_t w ) { fSmearShowerShapeWidth = w ; }
274 
275  void SetSmearingNLMRange(Int_t mi, Int_t ma) { fSmearNLMMin = mi ; fSmearNLMMax = ma ; }
276 
277  // Filling/ filtering / detector information access methods
278 
279  virtual Bool_t FillInputEvent(Int_t iEntry, const char *currentFileName) ;
280  virtual void FillInputCTS() ;
281  virtual void FillInputEMCAL() ;
282  virtual void FillInputEMCALAlgorithm(AliVCluster * clus, Int_t iclus) ;
283  virtual void FillInputPHOS() ;
284  virtual void FillInputEMCALCells() ;
285  virtual void FillInputPHOSCells() ;
286  virtual void FillInputVZERO() ;
287 
288  Int_t GetV0Signal(Int_t i) const { return fV0ADC[i] ; }
289  Int_t GetV0Multiplicity(Int_t i) const { return fV0Mul[i] ; }
290 
291  void SetEMCALClusterListName(TString &name) { fEMCALClustersListName = name ; }
292  TString GetEMCALClusterListName() const { return fEMCALClustersListName ; }
293 
294  // Arrays with clusters/track/cells access method
295 
296  virtual TObjArray* GetCTSTracks() const { return fCTSTracks ; }
297  virtual TObjArray* GetEMCALClusters() const { return fEMCALClusters ; }
298  virtual TObjArray* GetDCALClusters() const { return fDCALClusters ; }
299  virtual TObjArray* GetPHOSClusters() const { return fPHOSClusters ; }
300  virtual AliVCaloCells* GetEMCALCells() const { return fEMCALCells ; }
301  virtual AliVCaloCells* GetPHOSCells() const { return fPHOSCells ; }
302 
303  //-------------------------------------
304  // Event/track selection methods
305  //-------------------------------------
306 
307  void AcceptFastClusterEvents() { fAcceptFastCluster = kTRUE ; }
308  void RejectFastClusterEvents() { fAcceptFastCluster = kFALSE ; }
309  Bool_t IsFastClusterAccepted() const { return fAcceptFastCluster ; }
310 
311  Bool_t AcceptEventWithTriggerBit();
312  Bool_t RejectEventWithTriggerBit();
313  void SetAcceptEventsWithBit(UInt_t bit) { Int_t n = fAcceptEventsWithBit.GetSize();
314  fAcceptEventsWithBit.Set(n+1);
315  fAcceptEventsWithBit.AddAt(bit,n) ; }
316 
317  void SetRejectEventsWithBit(UInt_t bit) { Int_t n = fRejectEventsWithBit.GetSize();
318  fRejectEventsWithBit.Set(n+1);
319  fRejectEventsWithBit.AddAt(bit,n) ; }
320 
321  void SwitchOnLEDEventsRemoval() { fRemoveLEDEvents = kTRUE ; }
322  void SwitchOffLEDEventsRemoval() { fRemoveLEDEvents = kFALSE ; }
323  Bool_t IsLEDEventRemoved() const { return fRemoveLEDEvents ; }
324  Bool_t RejectLEDEvents();
325 
326  void SetFiredTriggerClassName(TString name ) { fFiredTriggerClassName = name ; }
327  TString GetFiredTriggerClassName() const { return fFiredTriggerClassName ; }
328  TString GetFiredTriggerClasses() const { return GetInputEvent()->GetFiredTriggerClasses() ; }
329 
330 
331  // Event selection when mixed event is used
332 
333  UInt_t GetEventTriggerMask() const { return fEventTriggerMask ; }
334  void SetEventTriggerMask(UInt_t evtTrig = AliVEvent::kAny)
335  { fEventTriggerMask = evtTrig ; }
336  UInt_t GetMixEventTriggerMask() const { return fMixEventTriggerMask ; }
337  void SetMixEventTriggerMask(UInt_t evtTrig = AliVEvent::kAnyINT)
338  { fMixEventTriggerMask = evtTrig ; }
339  Bool_t IsEventTriggerAtSEOn() const { return fEventTriggerAtSE ; }
340  void SwitchOnEventTriggerAtSE() { fEventTriggerAtSE = kTRUE ; }
341  void SwitchOffEventTriggerAtSE() { fEventTriggerAtSE = kFALSE ; }
342 
343  // EMCal Triggered events selection, studies
344 
345  TArrayI GetTriggerPatches(Int_t tmin, Int_t tmax);
346  void MatchTriggerCluster(TArrayI patches);
347  void SetEMCALTriggerThresholds();
348 
349  Bool_t CheckEventTriggers();
350 
351  Bool_t IsExoticEvent() const { return fIsExoticEvent ; }
352  Bool_t IsBadCellTriggerEvent() const { return fIsBadCellEvent ; }
353  Bool_t IsBadMaxCellTriggerEvent() const { return fIsBadMaxCellEvent ; }
354  Bool_t IsTriggerMatched() const { return fIsTriggerMatch ; }
355  Bool_t IsTriggerMatchedOpenCuts(Int_t i) const { return fIsTriggerMatchOpenCut[i]; }
356 
357  Int_t GetTriggerClusterBC() const { return fTriggerClusterBC ; }
358  Int_t GetTriggerClusterIndex() const { return fTriggerClusterIndex ; }
359  Int_t GetTriggerClusterId() const { return fTriggerClusterId ; }
360 
361  Float_t GetEventTriggerL0Threshold() const { return fTriggerL0EventThreshold ; }
362  void SetEventTriggerL0Threshold(Float_t tr) { fTriggerL0EventThreshold = tr ; }
363  Float_t GetEventTriggerL1Threshold() const { return fTriggerL1EventThreshold ; }
364  void SetEventTriggerL1Threshold(Float_t tr) { fTriggerL1EventThreshold = tr ; fTriggerL1EventThresholdFix = kTRUE; }
365 
366  void SetEventTriggerL1Bit(Int_t ega, Int_t eje) { fBitEGA = ega ; fBitEJE = eje; }
367 
368  void SetTriggerPatchTimeWindow(Int_t min, Int_t max) { fTriggerPatchTimeWindow[0] = min ;
369  fTriggerPatchTimeWindow[1] = max ; }
370 
371  Bool_t AreBadTriggerEventsRemoved() const { return fRemoveBadTriggerEvents ; }
372  void SwitchOffBadTriggerEventsRemoval() { fRemoveBadTriggerEvents = kFALSE ; }
373  void SwitchOnBadTriggerEventsRemoval() { fRemoveBadTriggerEvents = kTRUE ; }
374 
375  Bool_t AreUnMatchedTriggerEventsRemoved()const { return fRemoveUnMatchedTriggers ; }
376  void SwitchOffUnMatchedTriggerEventsRemoval(){ fRemoveUnMatchedTriggers = kFALSE ; }
377  void SwitchOnUnMatchedTriggerEventsRemoval() { fRemoveUnMatchedTriggers = kTRUE ; }
378 
379  Bool_t IsTriggerPatchMatchedToCluster() const { return fTriggerPatchClusterMatch ; }
380  void SwitchOffTriggerPatchMatching() { fTriggerPatchClusterMatch = kFALSE ; }
381  void SwitchOnTriggerPatchMatching() { fTriggerPatchClusterMatch = kTRUE ; }
382 
383  Bool_t IsTriggerClusterTimeRecal() const { return fTriggerClusterTimeRecal ; }
384  void SwitchOnTriggerClusterTimeRecal () { fTriggerClusterTimeRecal = kTRUE ; }
385  void SwitchOffTriggerClusterTimeRecal() { fTriggerClusterTimeRecal = kFALSE ; }
386 
387  void SetEventTriggerBit();
388  Bool_t IsEventMinimumBias() const { return fEventTrigMinBias ; }
389  Bool_t IsEventCentral() const { return fEventTrigCentral ; }
390  Bool_t IsEventSemiCentral() const { return fEventTrigSemiCentral ; }
391  Bool_t IsEventEMCALL0() const { return fEventTrigEMCALL0 ; }
392  Bool_t IsEventEMCALL1Gamma1() const { return fEventTrigEMCALL1Gamma1 ; }
393  Bool_t IsEventEMCALL1Gamma2() const { return fEventTrigEMCALL1Gamma2 ; }
394  Bool_t IsEventEMCALL1Jet1() const { return fEventTrigEMCALL1Jet1 ; }
395  Bool_t IsEventEMCALL1Jet2() const { return fEventTrigEMCALL1Jet2 ; }
396  Bool_t IsEventEMCALL1Gamma() const { return (fEventTrigEMCALL1Gamma1 || fEventTrigEMCALL1Gamma2) ; }
397  Bool_t IsEventEMCALL1Jet() const { return (fEventTrigEMCALL1Jet1 || fEventTrigEMCALL1Jet2 ) ; }
398  Bool_t IsEventEMCALL1() const { return (IsEventEMCALL1Gamma() || IsEventEMCALL1Jet() ) ; }
399 
400  void SwitchOnEMCALEventRejectionWith2Thresholds() { fRejectEMCalTriggerEventsWith2Tresholds = kTRUE ; }
401  void SwitchOffEMCALEventRejectionWith2Thresholds() { fRejectEMCalTriggerEventsWith2Tresholds = kFALSE ; }
402 
403  // Other event rejections criteria
404 
405  void SwitchOnPileUpEventRejection() { fDoPileUpEventRejection= kTRUE ; }
406  void SwitchOffPileUpEventRejection() { fDoPileUpEventRejection= kFALSE ; }
407  Bool_t IsPileUpEventRejectionDone() const { return fDoPileUpEventRejection ; }
408 
409  void SwitchOnV0ANDSelection() { fDoV0ANDEventSelection = kTRUE ; }
410  void SwitchOffV0ANDSelection() { fDoV0ANDEventSelection = kFALSE ; }
411  Bool_t IsV0ANDEventSelectionDone() const { return fDoV0ANDEventSelection ; }
412 
413  void SwitchOnVertexBCEventSelection() { fDoVertexBCEventSelection = kTRUE ; }
414  void SwitchOffVertexBCEventSelection() { fDoVertexBCEventSelection = kFALSE ; }
415  Bool_t IsVertexBCEventSelectionDone() const { return fDoVertexBCEventSelection ; }
416 
417  void SwitchOnPrimaryVertexSelection() { fUseEventsWithPrimaryVertex = kTRUE ; }
418  void SwitchOffPrimaryVertexSelection() { fUseEventsWithPrimaryVertex = kFALSE ; }
419  Bool_t IsPrimaryVertexSelectionDone() const { return fUseEventsWithPrimaryVertex ; }
420 
421  void SwitchOnRejectNoTrackEvents() { fDoRejectNoTrackEvents = kTRUE ; }
422  void SwitchOffRejectNoTrackEvents() { fDoRejectNoTrackEvents = kFALSE ; }
423  Bool_t IsEventWithNoTrackRejectionDone() const { return fDoRejectNoTrackEvents ; }
424 
425  // Time Stamp
426 
427  Double_t GetRunTimeStampMin() const { return fTimeStampRunMin ; }
428  Double_t GetRunTimeStampMax() const { return fTimeStampRunMax ; }
429 
430  void SetRunTimeStamp(Double_t a, Double_t b) { fTimeStampRunMin = a ;
431  fTimeStampRunMax = b ; } // seconds
432 
433  Float_t GetEventTimeStampFractionMin() const { return fTimeStampEventFracMin ; }
434  Float_t GetEventTimeStampFractionMax() const { return fTimeStampEventFracMax ; }
435 
436  void SetEventTimeStampFraction(Float_t a, Float_t b) { fTimeStampEventFracMin = a ;
437  fTimeStampEventFracMax = b ; }
438 
439  void SwitchOnSelectEventTimeStamp() { fTimeStampEventSelect = kTRUE ; }
440  void SwitchOffSelectEventTimeStamp() { fTimeStampEventSelect = kFALSE ; }
441 
442  Bool_t IsSelectEventTimeStampOn() { return fTimeStampEventSelect ; }
443 
444  // Event tagging as pile-up
445 
446  Bool_t IsPileUpFromSPD() const ;
447  Bool_t IsPileUpFromEMCal() const ;
448  Bool_t IsPileUpFromSPDAndEMCal() const ;
449  Bool_t IsPileUpFromSPDOrEMCal() const ;
450  Bool_t IsPileUpFromSPDAndNotEMCal() const ;
451  Bool_t IsPileUpFromEMCalAndNotSPD() const ;
452  Bool_t IsPileUpFromNotSPDAndNotEMCal() const ;
453 
454  void SetPileUpParamForSPD (Int_t i, Double_t param)
455  { fPileUpParamSPD[i] = param ; }
456  void SetPileUpParamForEMCal(Int_t param) { fNPileUpClustersCut = param ; }
457 
458  Int_t GetNPileUpClusters() { return fNPileUpClusters ; }
459  Int_t GetNNonPileUpClusters() { return fNNonPileUpClusters ; }
460 
461  Int_t GetEMCalEventBC(Int_t bc) const { if(bc >=0 && bc < 19) return fEMCalBCEvent [bc] ; else return 0 ; }
462  Int_t GetTrackEventBC(Int_t bc) const { if(bc >=0 && bc < 19) return fTrackBCEvent [bc] ; else return 0 ; }
463  Int_t GetEMCalEventBCcut(Int_t bc) const { if(bc >=0 && bc < 19) return fEMCalBCEventCut[bc] ; else return 0 ; }
464  Int_t GetTrackEventBCcut(Int_t bc) const { if(bc >=0 && bc < 19) return fTrackBCEventCut[bc] ; else return 0 ; }
465 
466  void SetEMCalEventBC(Int_t bc) { if(bc >=0 && bc < 19) fEMCalBCEvent [bc] = 1 ; }
467  void SetTrackEventBC(Int_t bc) { if(bc >=0 && bc < 19) fTrackBCEvent [bc] = 1 ; }
468  void SetEMCalEventBCcut(Int_t bc) { if(bc >=0 && bc < 19) fEMCalBCEventCut[bc] = 1 ; }
469  void SetTrackEventBCcut(Int_t bc) { if(bc >=0 && bc < 19) fTrackBCEventCut[bc] = 1 ; }
470 
471  Int_t GetVertexBC(const AliVVertex * vtx);
472  Int_t GetVertexBC() const { return fVertexBC ; }
473  void SwitchOnRecalculateVertexBC() { fRecalculateVertexBC = kTRUE ; fAccessTrackTOF = kTRUE ; }
474  void SwitchOffRecalculateVertexBC() { fRecalculateVertexBC = kFALSE ; }
475 
476  // Track selection
477 
478  ULong_t GetTrackStatus() const { return fTrackStatus ; }
479  void SetTrackStatus(ULong_t bit) { fTrackStatus = bit ; }
480 
481  virtual Bool_t SelectTrack(AliVTrack* , Double_t*) { return kFALSE ; } // See AOD/ESD reader
482 
483  void SwitchOnTrackHitSPDSelection() { fSelectSPDHitTracks = kTRUE ; }
484  void SwitchOffTrackHitSPDSelection() { fSelectSPDHitTracks = kFALSE ; }
485 
486  Int_t GetTrackMultiplicity() const { return fTrackMult ; }
487  Float_t GetTrackMultiplicityEtaCut() const { return fTrackMultEtaCut ; }
488  void SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta ; }
489 
490  // Virtual for AliCaloTrackAODReader
491 
492  virtual ULong_t GetTrackFilterMask() const { return 0 ; }
493  virtual void SetTrackFilterMask(ULong_t) { ; }
494 
495  virtual ULong_t GetTrackFilterMaskComplementary() const { return 0 ; }
496  virtual void SetTrackFilterMaskComplementary(ULong_t) { ; }
497 
498  virtual void SwitchOnAODHybridTrackSelection() { ; }
499  virtual void SwitchOffAODHybridTrackSelection() { ; }
500 
501  virtual void SwitchOnAODPrimaryTrackSelection() { ; }
502  virtual void SwitchOffAODPrimaryTrackSelection() { ; }
503 
504  virtual void SwitchOnAODTrackSharedClusterSelection() { ; }
505  virtual void SwitchOffAODTrackSharedClusterSelection(){ ; }
506 
507  virtual void SetTPCSharedClusterFraction(Float_t) { ; }
508  virtual Float_t GetTPCSharedClusterFraction() const { return 0 ; }
509 
510  // Virtual for AliCaloTrackESDReader
511 
512  virtual AliESDtrackCuts* GetTrackCuts() const { return 0 ; }
513  virtual AliESDtrackCuts* GetTrackComplementaryCuts() const { return 0 ; }
514 
515  virtual void SetTrackCuts(AliESDtrackCuts *) { ; }
516  virtual void SetTrackComplementaryCuts(AliESDtrackCuts *) { ; }
517 
518  virtual void SwitchOnConstrainTrackToVertex() { ; }
519  virtual void SwitchOffConstrainTrackToVertex() { ; }
520 
521  // Events species selection
522 
523  void AnalyzeOnlyLEDEvents() { fEventType = 8 ; }
524  void AnalyzeOnlyPhysicsEvents() { fEventType = 7 ; }
525  void AnalyzeOnlyEventsOfType(Int_t specie) { fEventType = specie ; }
526 
527  //-------------------------------
528  // Vertex methods
529  //-------------------------------
530 
531  virtual void GetVertex(Double_t v[3]) const ;
532  virtual Double_t* GetVertex(Int_t evtIndex) const { return fVertex[evtIndex] ; }
533  virtual void GetVertex(Double_t vertex[3], const Int_t evtIndex) const ;
534  virtual void FillVertexArray();
535  virtual Bool_t CheckForPrimaryVertex() const { return kTRUE ; } // algorithm in ESD/AOD Readers
536  virtual Float_t GetZvertexCut() const { return fZvtxCut ; } // cut on vertex position
537  virtual void SetZvertexCut(Float_t zcut=10.) { fZvtxCut=zcut ; } // cut on vertex position
538 
539  //--------------------------
540  // Centrality / Event Plane
541  //--------------------------
542 
543  virtual AliCentrality* GetCentrality() const {
544  if(fDataType!=kMC) return fInputEvent->GetCentrality() ;
545  else return 0x0 ; }
546 
547  virtual AliMultSelection* GetMultSelCen() const {
548  if(fDataType!=kMC) return (AliMultSelection * ) fInputEvent->FindListObject("MultSelection") ;
549  else return 0x0 ; }
550 
551  virtual void SwitchOnAliCentrality () { fUseAliCentrality = kTRUE ; }
552  virtual void SwitchOffAliCentrality() { fUseAliCentrality = kFALSE ; }
553 
554  virtual void SetCentralityClass(TString name) { fCentralityClass = name ; }
555  virtual void SetCentralityOpt(Int_t opt) { fCentralityOpt = opt ; }
556  virtual TString GetCentralityClass() const { return fCentralityClass ; }
557  virtual Int_t GetCentralityOpt() const { return fCentralityOpt ; }
558  virtual Int_t GetEventCentrality() const ;
559  virtual void SetCentralityBin(Int_t min, Int_t max) //Set the centrality bin to select the event. If used, then need to get percentile
560  { fCentralityBin[0]=min; fCentralityBin[1]=max;
561  if(min>=0 && max > 0) fCentralityOpt = 100 ; }
562  virtual Float_t GetCentralityBin(Int_t i) const { if(i < 0 || i > 1) return 0 ;
563  else return fCentralityBin[i] ; }
564 
565  virtual AliEventplane* GetEventPlane() const { if(fDataType!=kMC) return fInputEvent->GetEventplane() ;
566  else return 0x0 ; }
567  virtual Double_t GetEventPlaneAngle() const ;
568  virtual void SetEventPlaneMethod(TString m) { fEventPlaneMethod = m ; }
569  virtual TString GetEventPlaneMethod() const { return fEventPlaneMethod ; }
570 
571  //--------------------
572  // Mixing
573  //--------------------
574 
575  Int_t GetLastCaloMixedEvent() const { return fLastMixedCaloEvent ; }
576  Int_t GetLastTracksMixedEvent () const { return fLastMixedTracksEvent ; }
577 
578  TList * GetListWithMixedEventsForCalo (Int_t bi) const { if(fListMixedCaloEvents) return fListMixedCaloEvents [bi] ; else return 0 ; }
579  TList * GetListWithMixedEventsForTracks(Int_t bi) const { if(fListMixedTracksEvents) return fListMixedTracksEvents[bi] ; else return 0 ; }
580 
581  Bool_t ListWithMixedEventsForCaloExists() const { if(fListMixedCaloEvents) return kTRUE ;
582  else return kFALSE ; }
583 
584  Bool_t ListWithMixedEventsForTracksExists() const { if(fListMixedTracksEvents) return kTRUE ;
585  else return kFALSE ; }
586 
587  void SetLastCaloMixedEvent (Int_t e) { fLastMixedCaloEvent = e ; }
588  void SetLastTracksMixedEvent(Int_t e) { fLastMixedTracksEvent = e ; }
589 
590  void SetListWithMixedEventsForCalo (TList ** l) {
591  if(fListMixedCaloEvents) printf("AliCaloTrackReader::SetListWithMixedEventsForCalo() - Track Mixing event list already set, nothing done\n");
592  else fListMixedCaloEvents = l ; }
593 
594  void SetListWithMixedEventsForTracks(TList ** l) {
595  if(fListMixedTracksEvents) printf("AliCaloTrackReader::SetListWithMixedEventsForTracks() - Calorimeter Mixing event list already set, nothing done\n");
596  else fListMixedTracksEvents = l ; }
597 
598  //-------------------------------------
599  // Other methods
600  //-------------------------------------
601 
602  AliCalorimeterUtils * GetCaloUtils() const { return fCaloUtils ; }
603  void SetCaloUtils(AliCalorimeterUtils * caloutils)
604  { fCaloUtils = caloutils ; }
605 
606  Double_t GetEventWeight() const { return fEventWeight ; }
607  AliAnaWeights * GetWeightUtils() { if ( !fWeightUtils ) fWeightUtils = new AliAnaWeights() ;
608  return fWeightUtils ; }
609 
610  virtual Double_t GetBField() const { return fInputEvent->GetMagneticField() ; }
611 
613  Float_t GetPhi (Float_t phi) const { if ( phi < 0 ) phi += TMath::TwoPi() ; return phi ; }
614 
615  Float_t DegToRad(Float_t deg) const { deg *= TMath::DegToRad(); return deg ; }
616 
617  Float_t RadToDeg(Float_t rad) const { rad *= TMath::RadToDeg(); return rad ; }
618 
619 
620  //------------------------------------------------
621  // MC analysis specific methods
622  //-------------------------------------------------
623 
624  // Kinematics and galice.root available
625 
626  virtual AliStack* GetStack() const ;
627  virtual AliHeader* GetHeader() const ;
628  virtual AliGenEventHeader* GetGenEventHeader() const ;
629 
630  // Filtered kinematics in AOD
631 
632  virtual TClonesArray* GetAODMCParticles() const ;
633  virtual AliAODMCHeader* GetAODMCHeader () const ;
634 
635  virtual AliVEvent* GetInputEvent() const { return fInputEvent ; }
636  virtual AliVEvent* GetOriginalInputEvent() const { return 0x0 ; }
637  virtual AliAODEvent* GetOutputEvent() const { return fOutputEvent ; }
638  virtual AliMCEvent* GetMC() const { return fMC ; }
639  virtual AliMixedEvent* GetMixedEvent() const { return fMixedEvent ; }
640  virtual Int_t GetNMixedEvent() const { return fNMixedEvent ; }
641 
642  void SwitchOnStack() { fReadStack = kTRUE ; }
643  void SwitchOffStack() { fReadStack = kFALSE ; }
644  void SwitchOnAODMCParticles() { fReadAODMCParticles = kTRUE ; }
645  void SwitchOffAODMCParticles() { fReadAODMCParticles = kFALSE ; }
646  Bool_t ReadStack() const { return fReadStack ; }
647  Bool_t ReadAODMCParticles() const { return fReadAODMCParticles ; }
648 
649  void RemapMCLabelForAODs(Int_t &label);
650 
651  // Select generated events, depending on comparison of pT hard and jets
652 
653  virtual Bool_t ComparePtHardAndJetPt() ;
654  virtual Bool_t IsPtHardAndJetPtComparisonSet() const { return fComparePtHardAndJetPt ; }
655  virtual void SetPtHardAndJetPtComparison(Bool_t compare) { fComparePtHardAndJetPt = compare ; }
656  virtual Float_t GetPtHardAndJetFactor() const { return fPtHardAndJetPtFactor ; }
657  virtual void SetPtHardAndJetPtFactor(Float_t factor) { fPtHardAndJetPtFactor = factor ; }
658 
659  virtual Bool_t ComparePtHardAndClusterPt() ;
660  virtual Bool_t IsPtHardAndClusterPtComparisonSet() const { return fComparePtHardAndClusterPt ; }
661  virtual void SetPtHardAndClusterPtComparison(Bool_t compare) { fComparePtHardAndClusterPt = compare ; }
662  virtual Float_t GetPtHardAndClusterFactor() const { return fPtHardAndClusterPtFactor ; }
663  virtual void SetPtHardAndClusterPtFactor(Float_t factor) { fPtHardAndClusterPtFactor = factor ; }
664 
665  // Select particles or clusters depending on generator
666  virtual void SetNumberOfMCGeneratorsToAccept(Int_t nGen)
667  { fNMCGenerToAccept = nGen ;
668  if ( nGen > 5 ) fNMCGenerToAccept = 5 ;
669  else if ( nGen < 0 ) fNMCGenerToAccept = 0 ; }
670  virtual Int_t GetNumberOfMCGeneratorsToAccept() const { return fNMCGenerToAccept ; }
671 
672  virtual void SetNameOfMCGeneratorsToAccept(Int_t ig, TString name)
673  { if ( ig < 5 || ig >= 0 ) fMCGenerToAccept[ig] = name ; }
674  virtual TString GetNameOfMCGeneratorsToAccept(Int_t ig) const { return fMCGenerToAccept[ig] ; }
675 
676  Bool_t AcceptParticleMCLabel(Int_t mcLabel) const ;
677 
678  virtual void SetNameOfMCEventHederGeneratorToAccept(TString name) { fMCGenerEventHeaderToAccept = name ; }
679  virtual TString GetNameOfMCEventHederGeneratorToAccept() const { return fMCGenerEventHeaderToAccept ; }
680 
681  // MC reader methods, declared there to allow compilation, they are only used in the MC reader
682 
683  virtual void AddNeutralParticlesArray(TArrayI & /*array*/) { ; }
684  virtual void AddChargedParticlesArray(TArrayI & /*array*/) { ; }
685  virtual void AddStatusArray(TArrayI & /*array*/) { ; }
686 
687  virtual void SwitchOnPi0Decay() { ; }
688  virtual void SwitchOffPi0Decay() { ; }
689  virtual void SwitchOnStatusSelection() { ; }
690  virtual void SwitchOffStatusSelection() { ; }
691  virtual void SwitchOnOverlapCheck() { ; }
692  virtual void SwitchOffOverlapCheck() { ; }
693  virtual void SwitchOnOnlyGeneratorParticles() { ; }
694  virtual void SwitchOffOnlyGeneratorParticles() { ; }
695 
696  virtual void SetEMCALOverlapAngle(Float_t /*angle*/) { ; }
697  virtual void SetPHOSOverlapAngle(Float_t /*angle*/) { ; }
698 
699  //-------------
700  // Jets
701  //-------------
702 
703  Bool_t IsNonStandardJetsSwitchedOn() const { return fFillInputNonStandardJetBranch ; }
704  void SwitchOnNonStandardJets() { fFillInputNonStandardJetBranch = kTRUE ; }
705  void SwitchOffNonStandardJets() { fFillInputNonStandardJetBranch = kFALSE ; }
706 
707  Bool_t IsBackgroundJetsSwitchedOn() const { return fFillInputBackgroundJetBranch ; }
708  void SwitchOnBackgroundJets() { fFillInputBackgroundJetBranch = kTRUE ; }
709  void SwitchOffBackgroundJets() { fFillInputBackgroundJetBranch = kFALSE ; }
710 
711  virtual void FillInputNonStandardJets() ;
712  virtual TClonesArray* GetNonStandardJets() const { return fNonStandardJets ; }
713  virtual void SetInputNonStandardJetBranchName(TString name) { fInputNonStandardJetBranchName = name ; }
714  virtual TString GetInputNonStandardJetBranchName() { return fInputNonStandardJetBranchName ; }
715 
716  virtual void FillInputBackgroundJets() ;
717  virtual AliAODJetEventBackground* GetBackgroundJets() const { return fBackgroundJets ; }
718  virtual void SetInputBackgroundJetBranchName(TString name) { fInputBackgroundJetBranchName = name ; }
719  virtual TString GetInputBackgroundJetBranchName() { return fInputBackgroundJetBranchName ; }
720 
721  protected:
722 
723  Int_t fEventNumber;
724  Int_t fDataType ;
725  Int_t fDebug;
726  AliFiducialCut * fFiducialCut;
727  Bool_t fCheckFidCut ;
728 
729  Bool_t fComparePtHardAndJetPt;
730  Float_t fPtHardAndJetPtFactor;
731 
732  Bool_t fComparePtHardAndClusterPt;
733  Float_t fPtHardAndClusterPtFactor;
734 
735  Float_t fCTSPtMin;
736  Float_t fEMCALPtMin;
737  Float_t fPHOSPtMin;
738  Float_t fCTSPtMax;
739  Float_t fEMCALPtMax;
740  Float_t fPHOSPtMax;
741 
742  Float_t fEMCALBadChMinDist ;
743  Float_t fPHOSBadChMinDist ;
744 
745  Int_t fEMCALNCellsCut ;
746  Int_t fPHOSNCellsCut ;
747 
748  Bool_t fUseEMCALTimeCut;
749  Bool_t fUseParamTimeCut;
750  Bool_t fUseTrackTimeCut;
751  Bool_t fAccessTrackTOF;
752  Double_t fEMCALTimeCutMin;
753  Double_t fEMCALTimeCutMax;
754  Float_t fEMCALParamTimeCutMin[4];
755  Double_t fEMCALParamTimeCutMax[4];
756  Double_t fTrackTimeCutMin;
757  Double_t fTrackTimeCutMax;
758 
759  Bool_t fUseTrackDCACut;
760  Double_t fTrackDCACut[3];
761 
763  TList * fAODBranchList ; //->
764 
766  TObjArray * fCTSTracks ; //->
767 
769  TObjArray * fEMCALClusters ; //->
770 
772  TObjArray * fDCALClusters ; //->
773 
775  TObjArray * fPHOSClusters ; //->
776 
777  AliVCaloCells * fEMCALCells ;
778  AliVCaloCells * fPHOSCells ;
779 
780  AliVEvent * fInputEvent;
781  AliAODEvent * fOutputEvent;
782  AliMCEvent * fMC;
783 
784  Bool_t fFillCTS;
785  Bool_t fFillEMCAL;
786  Bool_t fFillDCAL;
787  Bool_t fFillPHOS;
788  Bool_t fFillEMCALCells;
789  Bool_t fFillPHOSCells;
790  Bool_t fRecalculateClusters;
791  Bool_t fCorrectELinearity;
792  Bool_t fSelectEmbeddedClusters;
793 
794  Bool_t fSmearShowerShape;
795  Float_t fSmearShowerShapeWidth;
796  TRandom3 fRandom ;
797  Int_t fSmearingFunction;
798  Int_t fSmearNLMMin ;
799  Int_t fSmearNLMMax ;
800 
801  ULong_t fTrackStatus ;
802  Bool_t fSelectSPDHitTracks ;
803  Int_t fTrackMult ;
804  Float_t fTrackMultEtaCut ;
805 
806  Bool_t fReadStack ;
807  Bool_t fReadAODMCParticles ;
808 
809  TString fDeltaAODFileName ;
810  TString fFiredTriggerClassName;
811 
812  // Trigger bit
813  UInt_t fEventTriggerMask ;
814  UInt_t fMixEventTriggerMask ;
815  Bool_t fEventTriggerAtSE;
816 
817  Bool_t fEventTrigMinBias ;
818  Bool_t fEventTrigCentral ;
819  Bool_t fEventTrigSemiCentral ;
820  Bool_t fEventTrigEMCALL0 ;
821  Bool_t fEventTrigEMCALL1Gamma1 ;
822  Bool_t fEventTrigEMCALL1Gamma2 ;
823  Bool_t fEventTrigEMCALL1Jet1 ;
824  Bool_t fEventTrigEMCALL1Jet2 ;
825 
826  Int_t fBitEGA;
827  Int_t fBitEJE;
828 
829  Int_t fEventType;
830 
831  TString fTaskName;
832 
833  AliCalorimeterUtils * fCaloUtils ;
834 
835  AliAnaWeights * fWeightUtils ;
836  Double_t fEventWeight ;
837 
838  AliMixedEvent * fMixedEvent ;
839  Int_t fNMixedEvent ;
840  Double_t ** fVertex ;
841 
842  TList ** fListMixedTracksEvents;
843  TList ** fListMixedCaloEvents ;
844  Int_t fLastMixedTracksEvent ;
845  Int_t fLastMixedCaloEvent ;
846 
847  Bool_t fWriteOutputDeltaAOD;
848 
849  Int_t fV0ADC[2] ;
850  Int_t fV0Mul[2] ;
851 
852  TString fEMCALClustersListName;
853 
854  // Event selection
855 
856  Float_t fZvtxCut ;
857  Bool_t fAcceptFastCluster;
858  Bool_t fRemoveLEDEvents;
859 
860  Bool_t fRemoveBadTriggerEvents;
861  Bool_t fTriggerPatchClusterMatch;
862  Int_t fTriggerPatchTimeWindow[2];
863 
864  Float_t fTriggerL0EventThreshold;
865  Float_t fTriggerL1EventThreshold;
866  Bool_t fTriggerL1EventThresholdFix;
867 
868  Int_t fTriggerClusterBC;
869  Int_t fTriggerClusterIndex;
870  Int_t fTriggerClusterId;
871  Bool_t fIsExoticEvent;
872  Bool_t fIsBadCellEvent;
873  Bool_t fIsBadMaxCellEvent;
874  Bool_t fIsTriggerMatch;
875  Bool_t fIsTriggerMatchOpenCut[3];
876  Bool_t fTriggerClusterTimeRecal;
877  Bool_t fRemoveUnMatchedTriggers;
878 
879 
880  Bool_t fDoPileUpEventRejection;
881  Bool_t fDoV0ANDEventSelection;
882  Bool_t fDoVertexBCEventSelection;
883  Bool_t fDoRejectNoTrackEvents;
884  Bool_t fUseEventsWithPrimaryVertex ;
885 //AliTriggerAnalysis* fTriggerAnalysis; ///< Access to trigger selection algorithm for V0AND calculation.
886 
887  Bool_t fTimeStampEventSelect;
888  Float_t fTimeStampEventFracMin;
889  Float_t fTimeStampEventFracMax;
890  Double_t fTimeStampRunMin;
891  Double_t fTimeStampRunMax;
892 
895  Double_t fPileUpParamSPD[5];
896 
897  // Pile-up in EMCal
898 
899  Int_t fNPileUpClusters;
900  Int_t fNNonPileUpClusters;
901  Int_t fNPileUpClustersCut;
902  Int_t fEMCalBCEvent[19];
903  Int_t fEMCalBCEventCut[19];
904  Int_t fTrackBCEvent[19];
905  Int_t fTrackBCEventCut[19];
906  Int_t fVertexBC;
907  Bool_t fRecalculateVertexBC;
908 
909  // Centrality/Event plane
910  Bool_t fUseAliCentrality;
911  TString fCentralityClass;
912  Int_t fCentralityOpt;
913  Int_t fCentralityBin[2];
914  TString fEventPlaneMethod;
915 
916  // Jets
917  Bool_t fFillInputNonStandardJetBranch;
918  TClonesArray * fNonStandardJets;
919  TString fInputNonStandardJetBranchName;
920  Bool_t fFillInputBackgroundJetBranch;
921  AliAODJetEventBackground * fBackgroundJets;
922  TString fInputBackgroundJetBranchName;
923 
924  TArrayI fAcceptEventsWithBit;
925  TArrayI fRejectEventsWithBit;
926 
927  Bool_t fRejectEMCalTriggerEventsWith2Tresholds;
928 
929  TLorentzVector fMomentum;
930 
931  // cut control histograms
932 
933  TList * fOutputContainer;
934 
935  TH1F * fhEMCALClusterCutsE[8];
936  TH1F * fhPHOSClusterCutsE [7];
937  TH1F * fhCTSTrackCutsPt [6];
938 
939  Float_t fEnergyHistogramLimit[2];
940  Int_t fEnergyHistogramNbins ;
941 
942  TH1I * fhNEventsAfterCut;
943 
944  // MC labels to accept
945  Int_t fNMCGenerToAccept;
946  TString fMCGenerToAccept[5];
947 
948  TString fMCGenerEventHeaderToAccept;
949 
951  AliCaloTrackReader( const AliCaloTrackReader & r) ;
952 
954  AliCaloTrackReader & operator = (const AliCaloTrackReader & r) ;
955 
957  ClassDef(AliCaloTrackReader,76) ;
959 
960 } ;
961 
962 #endif //ALICALOTRACKREADER_H
963 
964 
965 
AliCaloTrackReader::IsPileUpFromSPD
Bool_t IsPileUpFromSPD() const
Definition: AliCaloTrackReader.cxx:1099
AliCaloTrackReader::GetDebug
virtual Int_t GetDebug() const
Definition: AliCaloTrackReader.h:78
AliCaloTrackReader::GetZvertexCut
virtual Float_t GetZvertexCut() const
Definition: AliCaloTrackReader.h:536
AliCaloTrackReader::IsBadMaxCellTriggerEvent
Bool_t IsBadMaxCellTriggerEvent() const
Definition: AliCaloTrackReader.h:353
AliCaloTrackReader::fEventWeight
Double_t fEventWeight
Weight assigned to the event when filling histograms.
Definition: AliCaloTrackReader.h:836
AliCaloTrackReader::fUseTrackDCACut
Bool_t fUseTrackDCACut
Do DCA selection.
Definition: AliCaloTrackReader.h:759
AliCaloTrackReader::SwitchOnAODTrackSharedClusterSelection
virtual void SwitchOnAODTrackSharedClusterSelection()
Definition: AliCaloTrackReader.h:504
AliCaloTrackReader::SetDebug
virtual void SetDebug(Int_t d)
Definition: AliCaloTrackReader.h:79
AliCaloTrackReader::GetTaskName
TString GetTaskName() const
Definition: AliCaloTrackReader.h:89
AliCaloTrackReader::SwitchOffConstrainTrackToVertex
virtual void SwitchOffConstrainTrackToVertex()
Definition: AliCaloTrackReader.h:519
AliCaloTrackReader::SetLastCaloMixedEvent
void SetLastCaloMixedEvent(Int_t e)
Definition: AliCaloTrackReader.h:587
AliAnaWeights.h
AliCaloTrackReader::GetTriggerPatches
TArrayI GetTriggerPatches(Int_t tmin, Int_t tmax)
Definition: AliCaloTrackReader.cxx:2381
AliCaloTrackReader::FillInputVZERO
virtual void FillInputVZERO()
Definition: AliCaloTrackReader.cxx:2281
AliCaloTrackReader::GetMC
virtual AliMCEvent * GetMC() const
Definition: AliCaloTrackReader.h:638
AliCaloTrackReader::fV0ADC
Int_t fV0ADC[2]
Integrated V0 signal.
Definition: AliCaloTrackReader.h:849
AliCaloTrackReader::fComparePtHardAndClusterPt
Bool_t fComparePtHardAndClusterPt
In MonteCarlo, jet events, reject events with too large cluster energy.
Definition: AliCaloTrackReader.h:732
AliCaloTrackReader::fWeightUtils
AliAnaWeights * fWeightUtils
Pointer to AliAnaWeights.
Definition: AliCaloTrackReader.h:835
AliCaloTrackReader::SetShowerShapeSmearWidth
void SetShowerShapeSmearWidth(Float_t w)
Definition: AliCaloTrackReader.h:273
AliCaloTrackReader::GetCaloUtils
AliCalorimeterUtils * GetCaloUtils() const
Definition: AliCaloTrackReader.h:602
AliCaloTrackReader::fTimeStampEventFracMin
Float_t fTimeStampEventFracMin
Minimum value of time stamp fraction event.
Definition: AliCaloTrackReader.h:888
AliCaloTrackReader::AnalyzeOnlyEventsOfType
void AnalyzeOnlyEventsOfType(Int_t specie)
Definition: AliCaloTrackReader.h:525
AliCaloTrackReader::fReadAODMCParticles
Bool_t fReadAODMCParticles
Access kine information from filtered AOD MC particles.
Definition: AliCaloTrackReader.h:807
Double_t
double Double_t
Definition: External.C:58
AliCaloTrackReader::FillInputNonStandardJets
virtual void FillInputNonStandardJets()
Definition: AliCaloTrackReader.cxx:2314
AliCaloTrackReader::fEMCALTimeCutMax
Double_t fEMCALTimeCutMax
Remove clusters/cells with time larger than this value, in ns.
Definition: AliCaloTrackReader.h:753
AliCaloTrackReader::SetInputBackgroundJetBranchName
virtual void SetInputBackgroundJetBranchName(TString name)
Definition: AliCaloTrackReader.h:718
AliCaloTrackReader::SetEMCALPtMax
void SetEMCALPtMax(Float_t pt)
Definition: AliCaloTrackReader.h:138
AliCaloTrackReader::fBitEJE
Int_t fBitEJE
Trigger bit on VCaloTrigger for EJE.
Definition: AliCaloTrackReader.h:827
AliCaloTrackReader::SwitchOffUnMatchedTriggerEventsRemoval
void SwitchOffUnMatchedTriggerEventsRemoval()
Definition: AliCaloTrackReader.h:376
AliCaloTrackReader::GetListWithMixedEventsForTracks
TList * GetListWithMixedEventsForTracks(Int_t bi) const
Definition: AliCaloTrackReader.h:579
AliCaloTrackReader::fMomentum
TLorentzVector fMomentum
! Temporal TLorentzVector container, avoid declaration of TLorentzVectors per event.
Definition: AliCaloTrackReader.h:929
AliCaloTrackReader::fTimeStampRunMin
Double_t fTimeStampRunMin
Minimum value of time stamp in run.
Definition: AliCaloTrackReader.h:890
AliCaloTrackReader::fDoPileUpEventRejection
Bool_t fDoPileUpEventRejection
Select pile-up events by SPD.
Definition: AliCaloTrackReader.h:880
AliCaloTrackReader::GetNonStandardJets
virtual TClonesArray * GetNonStandardJets() const
Definition: AliCaloTrackReader.h:712
AliCaloTrackReader::fPHOSClusters
TObjArray * fPHOSClusters
Temporal array with PHOS CaloClusters.
Definition: AliCaloTrackReader.h:775
AliCaloTrackReader::fTrackDCACut
Double_t fTrackDCACut[3]
Remove tracks with DCA larger than cut, parameters of function stored here.
Definition: AliCaloTrackReader.h:760
AliCaloTrackReader::SwitchOnStatusSelection
virtual void SwitchOnStatusSelection()
Definition: AliCaloTrackReader.h:689
AliCaloTrackReader::fUseEventsWithPrimaryVertex
Bool_t fUseEventsWithPrimaryVertex
Select events with primary vertex.
Definition: AliCaloTrackReader.h:884
AliCaloTrackReader::SwitchOnFiducialCut
virtual void SwitchOnFiducialCut()
Definition: AliCaloTrackReader.h:223
AliCaloTrackReader::GetPHOSCells
virtual AliVCaloCells * GetPHOSCells() const
Definition: AliCaloTrackReader.h:301
AliCaloTrackReader::fIsBadCellEvent
Bool_t fIsBadCellEvent
Bad cell triggered event flag, any cell in cluster is bad.
Definition: AliCaloTrackReader.h:872
AliCaloTrackReader::fEventTrigEMCALL1Gamma1
Bool_t fEventTrigEMCALL1Gamma1
Event is L1-Gamma, threshold 1 on its name, it should correspond kEMCEGA.
Definition: AliCaloTrackReader.h:821
AliCaloTrackReader::AddStatusArray
virtual void AddStatusArray(TArrayI &)
Definition: AliCaloTrackReader.h:685
AliCaloTrackReader::GetHeader
virtual AliHeader * GetHeader() const
Definition: AliCaloTrackReader.cxx:766
AliCaloTrackReader::SwitchOffPi0Decay
virtual void SwitchOffPi0Decay()
Definition: AliCaloTrackReader.h:688
AliCaloTrackReader::IsEventEMCALL1Jet1
Bool_t IsEventEMCALL1Jet1() const
Definition: AliCaloTrackReader.h:394
AliCaloTrackReader::SetTriggerPatchTimeWindow
void SetTriggerPatchTimeWindow(Int_t min, Int_t max)
Definition: AliCaloTrackReader.h:368
AliCaloTrackReader::SetPHOSPtMax
void SetPHOSPtMax(Float_t pt)
Definition: AliCaloTrackReader.h:139
AliCaloTrackReader::IsEventEMCALL1Gamma1
Bool_t IsEventEMCALL1Gamma1() const
Definition: AliCaloTrackReader.h:392
AliCaloTrackReader::SwitchOnAODHybridTrackSelection
virtual void SwitchOnAODHybridTrackSelection()
Definition: AliCaloTrackReader.h:498
AliCaloTrackReader::GetNumberOfMCGeneratorsToAccept
virtual Int_t GetNumberOfMCGeneratorsToAccept() const
Definition: AliCaloTrackReader.h:670
AliCaloTrackReader::SwitchOnEMCALEventRejectionWith2Thresholds
void SwitchOnEMCALEventRejectionWith2Thresholds()
Definition: AliCaloTrackReader.h:400
AliCaloTrackReader::SetCentralityBin
virtual void SetCentralityBin(Int_t min, Int_t max)
Definition: AliCaloTrackReader.h:559
AliCaloTrackReader::SetPHOSPtMin
void SetPHOSPtMin(Float_t pt)
Definition: AliCaloTrackReader.h:136
AliCaloTrackReader::AreBadTriggerEventsRemoved
Bool_t AreBadTriggerEventsRemoved() const
Definition: AliCaloTrackReader.h:371
AliCaloTrackReader::GetEventTimeStampFractionMax
Float_t GetEventTimeStampFractionMax() const
Definition: AliCaloTrackReader.h:434
AliCaloTrackReader::ReadAODMCParticles
Bool_t ReadAODMCParticles() const
Definition: AliCaloTrackReader.h:647
AliCaloTrackReader::fSmearNLMMin
Int_t fSmearNLMMin
Do smearing for clusters with at least this value.
Definition: AliCaloTrackReader.h:798
AliCaloTrackReader::SetEMCALParametrizedMinTimeCut
void SetEMCALParametrizedMinTimeCut(Int_t i, Float_t par)
Definition: AliCaloTrackReader.h:207
AliCaloTrackReader::GetBField
virtual Double_t GetBField() const
Definition: AliCaloTrackReader.h:610
AliCaloTrackReader::SetMC
virtual void SetMC(AliMCEvent *const mc)
Definition: AliCaloTrackReader.h:98
AliCaloTrackReader::SetPHOSOverlapAngle
virtual void SetPHOSOverlapAngle(Float_t)
Definition: AliCaloTrackReader.h:697
AliCaloTrackReader::fEventPlaneMethod
TString fEventPlaneMethod
Name of event plane method, by default "Q".
Definition: AliCaloTrackReader.h:914
AliCaloTrackReader::GetNameOfMCEventHederGeneratorToAccept
virtual TString GetNameOfMCEventHederGeneratorToAccept() const
Definition: AliCaloTrackReader.h:679
AliCaloTrackReader::fTrackBCEventCut
Int_t fTrackBCEventCut[19]
Fill one entry per event if there is a track in a given BC, depend on track pT, acceptance cut...
Definition: AliCaloTrackReader.h:905
AliCaloTrackReader::SwitchOffClusterELinearityCorrection
void SwitchOffClusterELinearityCorrection()
Definition: AliCaloTrackReader.h:258
AliCaloTrackReader::GetEMCALClusters
virtual TObjArray * GetEMCALClusters() const
Definition: AliCaloTrackReader.h:297
AliCaloTrackReader::SetCTSPtMax
void SetCTSPtMax(Float_t pt)
Definition: AliCaloTrackReader.h:140
AliCaloTrackReader::fDoVertexBCEventSelection
Bool_t fDoVertexBCEventSelection
Select events with vertex on BC=0 or -100.
Definition: AliCaloTrackReader.h:882
AliCaloTrackReader::GetCTSPtMax
Float_t GetCTSPtMax() const
Definition: AliCaloTrackReader.h:133
AliCaloTrackReader::SetInputOutputMCEvent
virtual void SetInputOutputMCEvent(AliVEvent *, AliAODEvent *, AliMCEvent *)
Definition: AliCaloTrackReader.h:99
AliCaloTrackReader::WriteDeltaAODToFile
Bool_t WriteDeltaAODToFile() const
Definition: AliCaloTrackReader.h:108
AliCaloTrackReader::SetListWithMixedEventsForTracks
void SetListWithMixedEventsForTracks(TList **l)
Definition: AliCaloTrackReader.h:594
AliCaloTrackReader::GetListWithMixedEventsForCalo
TList * GetListWithMixedEventsForCalo(Int_t bi) const
Definition: AliCaloTrackReader.h:578
AliCaloTrackReader::fMixedEvent
AliMixedEvent * fMixedEvent
! Mixed event object. This class is not the owner.
Definition: AliCaloTrackReader.h:838
AliCaloTrackReader::GetInputEvent
virtual AliVEvent * GetInputEvent() const
Definition: AliCaloTrackReader.h:635
AliCaloTrackReader::SwitchOnOnlyGeneratorParticles
virtual void SwitchOnOnlyGeneratorParticles()
Definition: AliCaloTrackReader.h:693
AliCaloTrackReader::SetSmearingFunction
void SetSmearingFunction(Int_t smfu)
Definition: AliCaloTrackReader.h:266
AliCaloTrackReader::IsPileUpFromSPDAndNotEMCal
Bool_t IsPileUpFromSPDAndNotEMCal() const
Check if event is from pile-up determined by SPD and not by EMCal.
Definition: AliCaloTrackReader.cxx:1136
AliCaloTrackReader::IsEventEMCALL1
Bool_t IsEventEMCALL1() const
Definition: AliCaloTrackReader.h:398
AliCaloTrackReader::IsTriggerPatchMatchedToCluster
Bool_t IsTriggerPatchMatchedToCluster() const
Definition: AliCaloTrackReader.h:379
AliCaloTrackReader::fPtHardAndClusterPtFactor
Float_t fPtHardAndClusterPtFactor
Factor between ptHard and cluster pT to reject/accept event.
Definition: AliCaloTrackReader.h:733
AliCaloTrackReader::fAcceptFastCluster
Bool_t fAcceptFastCluster
Accept events from fast cluster, exclude these events for LHC11a.
Definition: AliCaloTrackReader.h:857
AliCaloTrackReader::SetTrackComplementaryCuts
virtual void SetTrackComplementaryCuts(AliESDtrackCuts *)
Definition: AliCaloTrackReader.h:516
AliCaloTrackReader::fTrackTimeCutMin
Double_t fTrackTimeCutMin
Remove tracks with time smaller than this value, in ns.
Definition: AliCaloTrackReader.h:756
AliCaloTrackReader::IsPrimaryVertexSelectionDone
Bool_t IsPrimaryVertexSelectionDone() const
Definition: AliCaloTrackReader.h:419
AliCaloTrackReader::SetEMCALEMin
void SetEMCALEMin(Float_t en)
Definition: AliCaloTrackReader.h:147
AliCaloTrackReader::GetEMCALBadChannelMinDist
Float_t GetEMCALBadChannelMinDist() const
Definition: AliCaloTrackReader.h:156
AliCaloTrackReader::GetV0Signal
Int_t GetV0Signal(Int_t i) const
Definition: AliCaloTrackReader.h:288
AliCaloTrackReader::fSmearShowerShape
Bool_t fSmearShowerShape
Smear shower shape (use in MC).
Definition: AliCaloTrackReader.h:794
AliCaloTrackReader::SetTrackDCACut
void SetTrackDCACut(Int_t i, Float_t cut)
Definition: AliCaloTrackReader.h:176
AliCaloTrackReader::fInputEvent
AliVEvent * fInputEvent
! pointer to esd or aod input.
Definition: AliCaloTrackReader.h:780
AliCaloTrackReader::IsEventSemiCentral
Bool_t IsEventSemiCentral() const
Definition: AliCaloTrackReader.h:390
AliAnaWeights
Calculate the weight to the event to be applied when filling histograms.
Definition: AliAnaWeights.h:32
AliCaloTrackReader::SetInputEvent
virtual void SetInputEvent(AliVEvent *input)
Definition: AliCaloTrackReader.cxx:3199
AliCaloTrackReader::SetPileUpParamForEMCal
void SetPileUpParamForEMCal(Int_t param)
Definition: AliCaloTrackReader.h:456
AliCaloTrackReader::fTrackTimeCutMax
Double_t fTrackTimeCutMax
Remove tracks with time larger than this value, in ns.
Definition: AliCaloTrackReader.h:757
AliCaloTrackReader::AddNeutralParticlesArray
virtual void AddNeutralParticlesArray(TArrayI &)
Definition: AliCaloTrackReader.h:683
AliCaloTrackReader::fTriggerClusterBC
Int_t fTriggerClusterBC
Event triggered by a cluster in BC -5 0 to 5.
Definition: AliCaloTrackReader.h:868
AliCaloTrackReader::GetMultSelCen
virtual AliMultSelection * GetMultSelCen() const
Definition: AliCaloTrackReader.h:547
AliCaloTrackReader::fEMCALClustersListName
TString fEMCALClustersListName
Alternative list of clusters produced elsewhere and not from InputEvent.
Definition: AliCaloTrackReader.h:852
AliCaloTrackReader::GetTrackStatus
ULong_t GetTrackStatus() const
Definition: AliCaloTrackReader.h:478
AliCaloTrackReader::fPHOSBadChMinDist
Float_t fPHOSBadChMinDist
Minimal distance to bad channel to accept cluster in PHOS, cm.
Definition: AliCaloTrackReader.h:743
AliCaloTrackReader::GetRunTimeStampMin
Double_t GetRunTimeStampMin() const
Definition: AliCaloTrackReader.h:427
AliCaloTrackReader::fWriteOutputDeltaAOD
Bool_t fWriteOutputDeltaAOD
Write the created delta AOD objects into file.
Definition: AliCaloTrackReader.h:847
AliCaloTrackReader::SetNameOfMCEventHederGeneratorToAccept
virtual void SetNameOfMCEventHederGeneratorToAccept(TString name)
Definition: AliCaloTrackReader.h:678
AliCaloTrackReader::GetFiredTriggerClassName
TString GetFiredTriggerClassName() const
Definition: AliCaloTrackReader.h:327
AliCaloTrackReader::fV0Mul
Int_t fV0Mul[2]
Integrated V0 Multiplicity.
Definition: AliCaloTrackReader.h:850
AliCaloTrackReader::fEMCALPtMin
Float_t fEMCALPtMin
pT Threshold on emcal clusters.
Definition: AliCaloTrackReader.h:736
AliCaloTrackReader::fTriggerClusterTimeRecal
Bool_t fTriggerClusterTimeRecal
In case cluster already calibrated, do not try to recalibrate even if recalib on in AliEMCALRecoUtils...
Definition: AliCaloTrackReader.h:876
AliCaloTrackReader::fVertex
Double_t ** fVertex
! Vertex array 3 dim for each mixed event buffer.
Definition: AliCaloTrackReader.h:840
AliCaloTrackReader::fhCTSTrackCutsPt
TH1F * fhCTSTrackCutsPt[6]
! Control histogram on the different CTS tracks selection cuts, pT
Definition: AliCaloTrackReader.h:937
AliCaloTrackReader::IsEventWithNoTrackRejectionDone
Bool_t IsEventWithNoTrackRejectionDone() const
Definition: AliCaloTrackReader.h:423
AliFiducialCut.h
AliCaloTrackReader::fEventTriggerMask
UInt_t fEventTriggerMask
Select this triggerered event.
Definition: AliCaloTrackReader.h:813
AliCaloTrackReader::GetEventCentrality
virtual Int_t GetEventCentrality() const
Definition: AliCaloTrackReader.cxx:1402
AliCaloTrackReader::GetEMCALTimeCutMax
Double_t GetEMCALTimeCutMax() const
Definition: AliCaloTrackReader.h:200
AliCaloTrackReader::GetGenEventHeader
virtual AliGenEventHeader * GetGenEventHeader() const
Definition: AliCaloTrackReader.cxx:782
AliCaloTrackReader::GetSmearingFunction
Int_t GetSmearingFunction() const
Definition: AliCaloTrackReader.h:267
AliCaloTrackReader::SetTPCSharedClusterFraction
virtual void SetTPCSharedClusterFraction(Float_t)
Definition: AliCaloTrackReader.h:507
AliCaloTrackReader::GetCentrality
virtual AliCentrality * GetCentrality() const
Definition: AliCaloTrackReader.h:543
AliCaloTrackReader::fPHOSCells
AliVCaloCells * fPHOSCells
! Temporal array with PHOS AliVCaloCells.
Definition: AliCaloTrackReader.h:778
AliCaloTrackReader::fOutputContainer
TList * fOutputContainer
! Output container with cut control histograms.
Definition: AliCaloTrackReader.h:933
AliCaloTrackReader::IsEventEMCALL1Gamma2
Bool_t IsEventEMCALL1Gamma2() const
Definition: AliCaloTrackReader.h:393
AliCaloTrackReader::GetMixedEvent
virtual AliMixedEvent * GetMixedEvent() const
Definition: AliCaloTrackReader.h:639
AliCaloTrackReader::fEnergyHistogramNbins
Int_t fEnergyHistogramNbins
Binning of the control histograms, min and max window.
Definition: AliCaloTrackReader.h:940
AliCaloTrackReader::fFillInputBackgroundJetBranch
Bool_t fFillInputBackgroundJetBranch
Flag to use data from background jets.
Definition: AliCaloTrackReader.h:920
AliCaloTrackReader::SetTrackEventBC
void SetTrackEventBC(Int_t bc)
Definition: AliCaloTrackReader.h:467
AliCaloTrackReader::ComparePtHardAndClusterPt
virtual Bool_t ComparePtHardAndClusterPt()
Definition: AliCaloTrackReader.cxx:557
AliCaloTrackReader::fAODBranchList
TList * fAODBranchList
List with AOD branches created and needed in analysis.
Definition: AliCaloTrackReader.h:763
AliCaloTrackReader::SwitchOffStatusSelection
virtual void SwitchOffStatusSelection()
Definition: AliCaloTrackReader.h:690
AliCaloTrackReader::IsTriggerMatchedOpenCuts
Bool_t IsTriggerMatchedOpenCuts(Int_t i) const
Definition: AliCaloTrackReader.h:355
AliCaloTrackReader::RemapMCLabelForAODs
void RemapMCLabelForAODs(Int_t &label)
Definition: AliCaloTrackReader.cxx:2956
AliCaloTrackReader::GetEMCALEMin
Float_t GetEMCALEMin() const
Definition: AliCaloTrackReader.h:142
AliCaloTrackReader::fEventTrigSemiCentral
Bool_t fEventTrigSemiCentral
Event is AliVEvent::kSemiCentral on its name, it should correspond to PbPb.
Definition: AliCaloTrackReader.h:819
AliCaloTrackReader::fRandom
TRandom3 fRandom
! Random generator.
Definition: AliCaloTrackReader.h:796
AliCaloTrackReader::AcceptDCA
Bool_t AcceptDCA(Float_t pt, Float_t dca)
Definition: AliCaloTrackReader.cxx:236
AliCaloTrackReader::IsPileUpFromNotSPDAndNotEMCal
Bool_t IsPileUpFromNotSPDAndNotEMCal() const
Check if event not from pile-up determined neither by SPD nor by EMCal.
Definition: AliCaloTrackReader.cxx:1154
AliCaloTrackReader::GetPtHardAndJetFactor
virtual Float_t GetPtHardAndJetFactor() const
Definition: AliCaloTrackReader.h:656
AliCaloTrackReader::fFillCTS
Bool_t fFillCTS
Use data from CTS.
Definition: AliCaloTrackReader.h:784
AliCaloTrackReader::SetTrackFilterMaskComplementary
virtual void SetTrackFilterMaskComplementary(ULong_t)
Definition: AliCaloTrackReader.h:496
AliCaloTrackReader::InitParameters
virtual void InitParameters()
Initialize the parameters with default.
Definition: AliCaloTrackReader.cxx:946
AliCaloTrackReader::GetEMCALEMax
Float_t GetEMCALEMax() const
Definition: AliCaloTrackReader.h:144
AliCaloTrackReader::GetVertex
virtual void GetVertex(Double_t v[3]) const
Definition: AliCaloTrackReader.cxx:1481
AliCaloTrackReader::SetPtHardAndJetPtComparison
virtual void SetPtHardAndJetPtComparison(Bool_t compare)
Definition: AliCaloTrackReader.h:655
AliCaloTrackReader::SwitchOnEmbeddedClustersSelection
void SwitchOnEmbeddedClustersSelection()
Definition: AliCaloTrackReader.h:261
AliCaloTrackReader::IsTriggerClusterTimeRecal
Bool_t IsTriggerClusterTimeRecal() const
Definition: AliCaloTrackReader.h:383
AliCaloTrackReader::SwitchOffOverlapCheck
virtual void SwitchOffOverlapCheck()
Definition: AliCaloTrackReader.h:692
AliCaloTrackReader::FillInputEvent
virtual Bool_t FillInputEvent(Int_t iEntry, const char *currentFileName)
Definition: AliCaloTrackReader.cxx:1169
AliCaloTrackReader::SetSmearingNLMRange
void SetSmearingNLMRange(Int_t mi, Int_t ma)
Definition: AliCaloTrackReader.h:275
AliCaloTrackReader::IsBackgroundJetsSwitchedOn
Bool_t IsBackgroundJetsSwitchedOn() const
Definition: AliCaloTrackReader.h:707
AliCaloTrackReader::fPHOSPtMin
Float_t fPHOSPtMin
pT Threshold on phos clusters.
Definition: AliCaloTrackReader.h:737
AliCaloTrackReader::fSelectEmbeddedClusters
Bool_t fSelectEmbeddedClusters
Use only simulated clusters that come from embedding.
Definition: AliCaloTrackReader.h:792
AliCaloTrackReader::fEventTrigMinBias
Bool_t fEventTrigMinBias
Event is min bias on its name, it should correspond to AliVEvent::kMB, AliVEvent::kAnyInt.
Definition: AliCaloTrackReader.h:817
AliCaloTrackReader::fEMCALParamTimeCutMin
Float_t fEMCALParamTimeCutMin[4]
Remove clusters/cells with time smaller than parametrized value, in ns.
Definition: AliCaloTrackReader.h:754
AliCaloTrackReader::fEventNumber
Int_t fEventNumber
Event number.
Definition: AliCaloTrackReader.h:723
AliCaloTrackReader::fTaskName
TString fTaskName
Name of task that executes the analysis.
Definition: AliCaloTrackReader.h:831
AliCaloTrackReader::SetCTSPtMin
void SetCTSPtMin(Float_t pt)
Definition: AliCaloTrackReader.h:137
AliCaloTrackReader::fRemoveBadTriggerEvents
Bool_t fRemoveBadTriggerEvents
Remove triggered events because trigger was exotic, bad, or out of BC.
Definition: AliCaloTrackReader.h:860
AliCaloTrackReader::IsPileUpFromSPDOrEMCal
Bool_t IsPileUpFromSPDOrEMCal() const
Check if event is from pile-up determined by SPD or EMCal.
Definition: AliCaloTrackReader.cxx:1127
AliCaloTrackReader::IsPileUpFromEMCalAndNotSPD
Bool_t IsPileUpFromEMCalAndNotSPD() const
Check if event is from pile-up determined by EMCal, not by SPD.
Definition: AliCaloTrackReader.cxx:1145
AliCaloTrackReader::fEventTrigEMCALL1Gamma2
Bool_t fEventTrigEMCALL1Gamma2
Event is L1-Gamma, threshold 2 on its name, it should correspond kEMCEGA.
Definition: AliCaloTrackReader.h:822
AliCaloTrackReader::GetCentralityBin
virtual Float_t GetCentralityBin(Int_t i) const
Definition: AliCaloTrackReader.h:562
AliCaloTrackReader::SetEventTriggerMask
void SetEventTriggerMask(UInt_t evtTrig=AliVEvent::kAny)
Definition: AliCaloTrackReader.h:334
AliCaloTrackReader::GetRunTimeStampMax
Double_t GetRunTimeStampMax() const
Definition: AliCaloTrackReader.h:428
AliCaloTrackReader::fEventTrigEMCALL1Jet1
Bool_t fEventTrigEMCALL1Jet1
Event is L1-Gamma, threshold 1 on its name, it should correspond kEMCEGA.
Definition: AliCaloTrackReader.h:823
AliCaloTrackReader::SetEMCALParametrizedMaxTimeCut
void SetEMCALParametrizedMaxTimeCut(Int_t i, Float_t par)
Definition: AliCaloTrackReader.h:208
AliCaloTrackReader::GetEventNumber
virtual Int_t GetEventNumber() const
Definition: AliCaloTrackReader.h:85
AliCaloTrackReader::fFillEMCALCells
Bool_t fFillEMCALCells
Use data from EMCAL.
Definition: AliCaloTrackReader.h:788
AliCaloTrackReader::SwitchOffVertexBCEventSelection
void SwitchOffVertexBCEventSelection()
Definition: AliCaloTrackReader.h:414
AliCaloTrackReader::SetPtHardAndClusterPtFactor
virtual void SetPtHardAndClusterPtFactor(Float_t factor)
Definition: AliCaloTrackReader.h:663
AliCaloTrackReader::fEnergyHistogramLimit
Float_t fEnergyHistogramLimit[2]
Binning of the control histograms, number of bins.
Definition: AliCaloTrackReader.h:939
AliCaloTrackReader::fTriggerClusterId
Int_t fTriggerClusterId
Id of trigger cluster (cluster->GetID()).
Definition: AliCaloTrackReader.h:870
AliCaloTrackReader::fPHOSNCellsCut
Int_t fPHOSNCellsCut
Accept for the analysis PHOS clusters with more than fNCellsCut cells.
Definition: AliCaloTrackReader.h:746
AliCaloTrackReader::fCTSPtMax
Float_t fCTSPtMax
pT Threshold on charged particles.
Definition: AliCaloTrackReader.h:738
AliCaloTrackReader::SetTaskName
void SetTaskName(TString name)
Definition: AliCaloTrackReader.h:90
AliCaloTrackReader::fEMCALParamTimeCutMax
Double_t fEMCALParamTimeCutMax[4]
Remove clusters/cells with time larger than parametrized value, in ns.
Definition: AliCaloTrackReader.h:755
AliCaloTrackReader::FillInputEMCALCells
virtual void FillInputEMCALCells()
Connects the array with EMCAL cells and the pointer.
Definition: AliCaloTrackReader.cxx:2264
AliCaloTrackReader::fFillPHOSCells
Bool_t fFillPHOSCells
Use data from PHOS.
Definition: AliCaloTrackReader.h:789
AliCaloTrackReader::GetEMCALCells
virtual AliVCaloCells * GetEMCALCells() const
Definition: AliCaloTrackReader.h:300
AliCaloTrackReader::fRemoveLEDEvents
Bool_t fRemoveLEDEvents
Remove events where LED was wrongly firing - EMCAL LHC11a.
Definition: AliCaloTrackReader.h:858
AliCaloTrackReader::GetPHOSNCellsCut
Int_t GetPHOSNCellsCut() const
Definition: AliCaloTrackReader.h:165
AliCaloTrackReader::GetPtHardAndClusterFactor
virtual Float_t GetPtHardAndClusterFactor() const
Definition: AliCaloTrackReader.h:662
AliCaloTrackReader::GetTrackFilterMaskComplementary
virtual ULong_t GetTrackFilterMaskComplementary() const
Definition: AliCaloTrackReader.h:495
AliCaloTrackReader::IsDCACutOn
Bool_t IsDCACutOn() const
Definition: AliCaloTrackReader.h:181
AliCaloTrackReader::SetListWithMixedEventsForCalo
void SetListWithMixedEventsForCalo(TList **l)
Definition: AliCaloTrackReader.h:590
AliCaloTrackReader::GetFiducialCut
virtual AliFiducialCut * GetFiducialCut()
Definition: AliCaloTrackReader.h:218
AliCaloTrackReader::SetCentralityOpt
virtual void SetCentralityOpt(Int_t opt)
Definition: AliCaloTrackReader.h:555
AliCaloTrackReader::fIsBadMaxCellEvent
Bool_t fIsBadMaxCellEvent
Bad cell triggered event flag, only max energy cell is bad.
Definition: AliCaloTrackReader.h:873
Int_t
int Int_t
Definition: External.C:63
AliCaloTrackReader::fSelectSPDHitTracks
Bool_t fSelectSPDHitTracks
Ensure that track hits SPD layers.
Definition: AliCaloTrackReader.h:802
AliCaloTrackReader::GetEventTriggerL0Threshold
Float_t GetEventTriggerL0Threshold() const
Definition: AliCaloTrackReader.h:361
AliCaloTrackReader::fFiredTriggerClassName
TString fFiredTriggerClassName
Name of trigger event type used to do the analysis.
Definition: AliCaloTrackReader.h:810
AliCaloTrackReader::GetPHOSEMin
Float_t GetPHOSEMin() const
Definition: AliCaloTrackReader.h:143
AliCaloTrackReader::GetAODMCParticles
virtual TClonesArray * GetAODMCParticles() const
Definition: AliCaloTrackReader.cxx:842
TH1I
Definition: External.C:204
AliCaloTrackReader::GetFiredTriggerClasses
TString GetFiredTriggerClasses() const
Definition: AliCaloTrackReader.h:328
AliCaloTrackReader::ReadStack
Bool_t ReadStack() const
Definition: AliCaloTrackReader.h:646
AliCaloTrackReader::SwitchOffAODPrimaryTrackSelection
virtual void SwitchOffAODPrimaryTrackSelection()
Definition: AliCaloTrackReader.h:502
UInt_t
unsigned int UInt_t
Definition: External.C:33
AliCaloTrackReader::fEMCALClusters
TObjArray * fEMCALClusters
Temporal array with EMCAL CaloClusters.
Definition: AliCaloTrackReader.h:769
AliCaloTrackReader::GetPHOSBadChannelMinDist
Float_t GetPHOSBadChannelMinDist() const
Definition: AliCaloTrackReader.h:157
AliCaloTrackReader::IsEventEMCALL1Jet
Bool_t IsEventEMCALL1Jet() const
Definition: AliCaloTrackReader.h:397
AliCaloTrackReader::GetPHOSEMax
Float_t GetPHOSEMax() const
Definition: AliCaloTrackReader.h:145
AliCaloTrackReader::fPHOSPtMax
Float_t fPHOSPtMax
pT Threshold on phos clusters.
Definition: AliCaloTrackReader.h:740
AliCaloTrackReader::GetAODBranchList
virtual TList * GetAODBranchList() const
Definition: AliCaloTrackReader.h:103
AliCaloTrackReader::fAccessTrackTOF
Bool_t fAccessTrackTOF
Access the track TOF, in case of problems when accessing GetTOFBunchCrossing.
Definition: AliCaloTrackReader.h:751
Float_t
float Float_t
Definition: External.C:68
AliCaloTrackReader::GetInputNonStandardJetBranchName
virtual TString GetInputNonStandardJetBranchName()
Definition: AliCaloTrackReader.h:714
AliCaloTrackReader::SetTrackStatus
void SetTrackStatus(ULong_t bit)
Definition: AliCaloTrackReader.h:479
AliCaloTrackReader::IsTriggerMatched
Bool_t IsTriggerMatched() const
Definition: AliCaloTrackReader.h:354
AliCaloTrackReader::IsPileUpEventRejectionDone
Bool_t IsPileUpEventRejectionDone() const
Definition: AliCaloTrackReader.h:407
AliCaloTrackReader::CheckForPrimaryVertex
virtual Bool_t CheckForPrimaryVertex() const
Definition: AliCaloTrackReader.h:535
AliCaloTrackReader::fEMCalBCEvent
Int_t fEMCalBCEvent[19]
Fill one entry per event if there is a cluster in a given BC.
Definition: AliCaloTrackReader.h:902
AliCaloTrackReader::SetOutputEvent
virtual void SetOutputEvent(AliAODEvent *aod)
Definition: AliCaloTrackReader.h:97
AliCaloTrackReader::fInputBackgroundJetBranchName
TString fInputBackgroundJetBranchName
Name of background jet branch.
Definition: AliCaloTrackReader.h:922
AliCaloTrackReader::SetLastTracksMixedEvent
void SetLastTracksMixedEvent(Int_t e)
Definition: AliCaloTrackReader.h:588
AliCaloTrackReader::GetEventPlane
virtual AliEventplane * GetEventPlane() const
Definition: AliCaloTrackReader.h:565
AliCaloTrackReader::fEventTriggerAtSE
Bool_t fEventTriggerAtSE
Select triggered event at SE base task or here.
Definition: AliCaloTrackReader.h:815
AliCaloTrackReader::IsLEDEventRemoved
Bool_t IsLEDEventRemoved() const
Definition: AliCaloTrackReader.h:323
AliCaloTrackReader::fNMCGenerToAccept
Int_t fNMCGenerToAccept
Number of MC generators that should not be included in analysis.
Definition: AliCaloTrackReader.h:945
AliCaloTrackReader::SetControlHistogramEnergyBinning
void SetControlHistogramEnergyBinning(Int_t nBins, Float_t emin, Float_t emax)
Definition: AliCaloTrackReader.h:111
AliCaloTrackReader::fEMCALPtMax
Float_t fEMCALPtMax
pT Threshold on emcal clusters.
Definition: AliCaloTrackReader.h:739
AliCaloTrackReader::SetNumberOfMCGeneratorsToAccept
virtual void SetNumberOfMCGeneratorsToAccept(Int_t nGen)
Definition: AliCaloTrackReader.h:666
AliCaloTrackReader::fEventType
Int_t fEventType
Set the event species: 7 physics, 0 MC, 8 LED (not useful now)
Definition: AliCaloTrackReader.h:829
AliCaloTrackReader::ComparePtHardAndJetPt
virtual Bool_t ComparePtHardAndJetPt()
Definition: AliCaloTrackReader.cxx:515
AliCaloTrackReader::IsEventCentral
Bool_t IsEventCentral() const
Definition: AliCaloTrackReader.h:389
AliCaloTrackReader::SetEMCALBadChannelMinDist
void SetEMCALBadChannelMinDist(Float_t di)
Definition: AliCaloTrackReader.h:159
AliCaloTrackReader::GetCentralityOpt
virtual Int_t GetCentralityOpt() const
Definition: AliCaloTrackReader.h:557
AliCaloTrackReader::GetOutputEvent
virtual AliAODEvent * GetOutputEvent() const
Definition: AliCaloTrackReader.h:637
AliCaloTrackReader::fEventTrigCentral
Bool_t fEventTrigCentral
Event is AliVEvent::kCentral on its name, it should correspond to PbPb.
Definition: AliCaloTrackReader.h:818
AliCaloTrackReader::SwitchOnTriggerClusterTimeRecal
void SwitchOnTriggerClusterTimeRecal()
Definition: AliCaloTrackReader.h:384
AliCaloTrackReader::IsPHOSSwitchedOn
Bool_t IsPHOSSwitchedOn() const
Definition: AliCaloTrackReader.h:241
AliCaloTrackReader::GetListOfParameters
virtual TObjString * GetListOfParameters()
Save parameters used for analysis in a string.
Definition: AliCaloTrackReader.cxx:667
AliCaloTrackReader::fTrackMultEtaCut
Float_t fTrackMultEtaCut
Track multiplicity eta cut.
Definition: AliCaloTrackReader.h:804
AliCaloTrackReader::SetEMCALNCellsCut
void SetEMCALNCellsCut(Int_t nc)
Definition: AliCaloTrackReader.h:167
AliCaloTrackReader::SwitchOnUnMatchedTriggerEventsRemoval
void SwitchOnUnMatchedTriggerEventsRemoval()
Definition: AliCaloTrackReader.h:377
AliCaloTrackReader::fMCGenerToAccept
TString fMCGenerToAccept[5]
List with name of generators that should not be included.
Definition: AliCaloTrackReader.h:946
AliCaloTrackReader::SetPtHardAndClusterPtComparison
virtual void SetPtHardAndClusterPtComparison(Bool_t compare)
Definition: AliCaloTrackReader.h:661
AliCaloTrackReader::IsFastClusterAccepted
Bool_t IsFastClusterAccepted() const
Definition: AliCaloTrackReader.h:309
AliCaloTrackReader::SetPHOSNCellsCut
void SetPHOSNCellsCut(Int_t nc)
Definition: AliCaloTrackReader.h:168
AliCaloTrackReader::fCaloUtils
AliCalorimeterUtils * fCaloUtils
Pointer to AliCalorimeterUtils.
Definition: AliCaloTrackReader.h:833
AliCaloTrackReader::fCentralityBin
Int_t fCentralityBin[2]
Minimum and maximum value of the centrality for the analysis.
Definition: AliCaloTrackReader.h:913
AliCaloTrackReader::SwitchOffTriggerClusterTimeRecal
void SwitchOffTriggerClusterTimeRecal()
Definition: AliCaloTrackReader.h:385
AliCaloTrackReader::FillInputPHOSCells
virtual void FillInputPHOSCells()
Connects the array with PHOS cells and the pointer.
Definition: AliCaloTrackReader.cxx:2272
AliCaloTrackReader::SetAcceptEventsWithBit
void SetAcceptEventsWithBit(UInt_t bit)
Definition: AliCaloTrackReader.h:313
AliCaloTrackReader
Base class for event, clusters and tracks filtering and preparation for the analysis.
Definition: AliCaloTrackReader.h:58
AliCaloTrackReader::GetEMCALNCellsCut
Int_t GetEMCALNCellsCut() const
Definition: AliCaloTrackReader.h:164
AliCaloTrackReader::SwitchOffBadTriggerEventsRemoval
void SwitchOffBadTriggerEventsRemoval()
Definition: AliCaloTrackReader.h:372
AliCaloTrackReader::fDCALClusters
TObjArray * fDCALClusters
Temporal array with DCAL CaloClusters, not needed in the normal case, use just EMCal array with DCal ...
Definition: AliCaloTrackReader.h:772
AliCaloTrackReader::SetEMCALClusterListName
void SetEMCALClusterListName(TString &name)
Definition: AliCaloTrackReader.h:291
AliCaloTrackReader::GetTriggerClusterBC
Int_t GetTriggerClusterBC() const
Definition: AliCaloTrackReader.h:357
AliCaloTrackReader::fUseTrackTimeCut
Bool_t fUseTrackTimeCut
Do time cut selection.
Definition: AliCaloTrackReader.h:750
AliCaloTrackReader::operator=
AliCaloTrackReader & operator=(const AliCaloTrackReader &r)
Assignment operator not implemented.
AliCaloTrackReader::GetEventPlaneMethod
virtual TString GetEventPlaneMethod() const
Definition: AliCaloTrackReader.h:569
AliCaloTrackReader::GetTrackID
virtual Int_t GetTrackID(AliVTrack *track)
Definition: AliCaloTrackReader.cxx:920
AliCaloTrackReader::GetEventWeight
Double_t GetEventWeight() const
Definition: AliCaloTrackReader.h:606
AliCaloTrackReader::SetEventTriggerL1Threshold
void SetEventTriggerL1Threshold(Float_t tr)
Definition: AliCaloTrackReader.h:364
AliCaloTrackReader::GetEventTriggerMask
UInt_t GetEventTriggerMask() const
Definition: AliCaloTrackReader.h:333
AliCaloTrackReader::fAcceptEventsWithBit
TArrayI fAcceptEventsWithBit
Accept events if trigger bit is on.
Definition: AliCaloTrackReader.h:924
AliCaloTrackReader::SwitchOffAODTrackSharedClusterSelection
virtual void SwitchOffAODTrackSharedClusterSelection()
Definition: AliCaloTrackReader.h:505
AliCaloTrackReader::SetEventTriggerL1Bit
void SetEventTriggerL1Bit(Int_t ega, Int_t eje)
Definition: AliCaloTrackReader.h:366
AliCaloTrackReader::SetTrackMultiplicityEtaCut
void SetTrackMultiplicityEtaCut(Float_t eta)
Definition: AliCaloTrackReader.h:488
AliCaloTrackReader::fLastMixedTracksEvent
Int_t fLastMixedTracksEvent
Temporary container with the last event added to the mixing list for tracks.
Definition: AliCaloTrackReader.h:844
ULong_t
unsigned long ULong_t
Definition: External.C:38
AliCaloTrackReader::fhEMCALClusterCutsE
TH1F * fhEMCALClusterCutsE[8]
! Control histogram on the different EMCal cluster selection cuts, E
Definition: AliCaloTrackReader.h:935
AliCaloTrackReader::GetTPCSharedClusterFraction
virtual Float_t GetTPCSharedClusterFraction() const
Definition: AliCaloTrackReader.h:508
AliCaloTrackReader::GetLastTracksMixedEvent
Int_t GetLastTracksMixedEvent() const
Definition: AliCaloTrackReader.h:576
AliCaloTrackReader::Print
virtual void Print(const Option_t *opt) const
Print some relevant parameters set for the analysis.
Definition: AliCaloTrackReader.cxx:2875
AliCaloTrackReader::MatchTriggerCluster
void MatchTriggerCluster(TArrayI patches)
Definition: AliCaloTrackReader.cxx:2498
AliCaloTrackReader::fTimeStampEventSelect
Bool_t fTimeStampEventSelect
Select events within a fraction of data taking time.
Definition: AliCaloTrackReader.h:887
AliCaloTrackReader::fTimeStampRunMax
Double_t fTimeStampRunMax
Maximum value of time stamp in run.
Definition: AliCaloTrackReader.h:891
AliCaloTrackReader::fListMixedTracksEvents
TList ** fListMixedTracksEvents
! Container for tracks stored for different events, used in case of own mixing, set in analysis class...
Definition: AliCaloTrackReader.h:842
AliCaloTrackReader::fEMCALTimeCutMin
Double_t fEMCALTimeCutMin
Remove clusters/cells with time smaller than this value, in ns.
Definition: AliCaloTrackReader.h:752
AliCaloTrackReader::SetTrackFilterMask
virtual void SetTrackFilterMask(ULong_t)
Definition: AliCaloTrackReader.h:493
AliCaloTrackReader::fEventTrigEMCALL1Jet2
Bool_t fEventTrigEMCALL1Jet2
Event is L1-Gamma, threshold 2 on its name, it should correspond kEMCEGA.
Definition: AliCaloTrackReader.h:824
AliCaloTrackReader::SetEMCalEventBCcut
void SetEMCalEventBCcut(Int_t bc)
Definition: AliCaloTrackReader.h:468
AliCaloTrackReader::GetInputBackgroundJetBranchName
virtual TString GetInputBackgroundJetBranchName()
Definition: AliCaloTrackReader.h:719
AliCaloTrackReader::fNPileUpClustersCut
Int_t fNPileUpClustersCut
Cut to select event as pile-up.
Definition: AliCaloTrackReader.h:901
AliCaloTrackReader::IsPtHardAndClusterPtComparisonSet
virtual Bool_t IsPtHardAndClusterPtComparisonSet() const
Definition: AliCaloTrackReader.h:660
AliCaloTrackReader::fDebug
Int_t fDebug
Debugging level.
Definition: AliCaloTrackReader.h:725
AliCaloTrackReader::IsEMCALSwitchedOn
Bool_t IsEMCALSwitchedOn() const
Definition: AliCaloTrackReader.h:233
AliCaloTrackReader::fCheckFidCut
Bool_t fCheckFidCut
Do analysis for clusters in defined region.
Definition: AliCaloTrackReader.h:727
AliCaloTrackReader::~AliCaloTrackReader
virtual ~AliCaloTrackReader()
Destructor.
Definition: AliCaloTrackReader.cxx:151
AliCaloTrackReader::GetTrackTimeCutMin
Double_t GetTrackTimeCutMin() const
Definition: AliCaloTrackReader.h:185
AliCaloTrackReader::fEventTrigEMCALL0
Bool_t fEventTrigEMCALL0
Event is EMCal L0 on its name, it should correspond to AliVEvent::kEMC7, AliVEvent::kEMC1.
Definition: AliCaloTrackReader.h:820
AliCaloTrackReader::SwitchOnPi0Decay
virtual void SwitchOnPi0Decay()
Definition: AliCaloTrackReader.h:687
AliCaloTrackReader::GetV0Multiplicity
Int_t GetV0Multiplicity(Int_t i) const
Definition: AliCaloTrackReader.h:289
AliCaloTrackReader::fTrackBCEvent
Int_t fTrackBCEvent[19]
Fill one entry per event if there is a track in a given BC.
Definition: AliCaloTrackReader.h:904
AliCaloTrackReader::AreUnMatchedTriggerEventsRemoved
Bool_t AreUnMatchedTriggerEventsRemoved() const
Definition: AliCaloTrackReader.h:375
AliCaloTrackReader::SetZvertexCut
virtual void SetZvertexCut(Float_t zcut=10.)
Definition: AliCaloTrackReader.h:537
AliCaloTrackReader::GetPHOSClusters
virtual TObjArray * GetPHOSClusters() const
Definition: AliCaloTrackReader.h:299
AliCaloTrackReader::GetEMCalEventBC
Int_t GetEMCalEventBC(Int_t bc) const
Definition: AliCaloTrackReader.h:461
AliCaloTrackReader::FillInputEMCALAlgorithm
virtual void FillInputEMCALAlgorithm(AliVCluster *clus, Int_t iclus)
Definition: AliCaloTrackReader.cxx:1727
AliCaloTrackReader::fComparePtHardAndJetPt
Bool_t fComparePtHardAndJetPt
In MonteCarlo, jet events, reject fake events with wrong jet energy.
Definition: AliCaloTrackReader.h:729
AliCaloTrackReader::SetRunTimeStamp
void SetRunTimeStamp(Double_t a, Double_t b)
Definition: AliCaloTrackReader.h:430
AliCaloTrackReader::fNNonPileUpClusters
Int_t fNNonPileUpClusters
Number of clusters with time below 20 ns.
Definition: AliCaloTrackReader.h:900
AliCaloTrackReader::GetVertex
virtual Double_t * GetVertex(Int_t evtIndex) const
Definition: AliCaloTrackReader.h:532
AliCaloTrackReader::fNMixedEvent
Int_t fNMixedEvent
Number of events in mixed event buffer.
Definition: AliCaloTrackReader.h:839
AliCaloTrackReader::GetTriggerClusterIndex
Int_t GetTriggerClusterIndex() const
Definition: AliCaloTrackReader.h:358
AliCaloTrackReader::IsPHOSCellsSwitchedOn
Bool_t IsPHOSCellsSwitchedOn() const
Definition: AliCaloTrackReader.h:249
AliCaloTrackReader::fCentralityOpt
Int_t fCentralityOpt
Option for the returned value of the centrality, possible options 5, 10, 100.
Definition: AliCaloTrackReader.h:912
AliCaloTrackReader::fZvtxCut
Float_t fZvtxCut
Cut on vertex position.
Definition: AliCaloTrackReader.h:856
energy
energy
Definition: HFPtSpectrumRaa.C:55
AliCaloTrackReader::GetEMCALTimeCutMin
Double_t GetEMCALTimeCutMin() const
Definition: AliCaloTrackReader.h:199
AliCaloTrackReader::AliCaloTrackReader
AliCaloTrackReader()
Constructor. Initialize parameters.
Definition: AliCaloTrackReader.cxx:62
AliCaloTrackReader::SwitchOnAliCentrality
virtual void SwitchOnAliCentrality()
Definition: AliCaloTrackReader.h:551
AliCaloTrackReader::fTriggerPatchClusterMatch
Bool_t fTriggerPatchClusterMatch
Search for the trigger patch and check if associated cluster was the trigger.
Definition: AliCaloTrackReader.h:861
AliCaloTrackReader::SetEMCALOverlapAngle
virtual void SetEMCALOverlapAngle(Float_t)
Definition: AliCaloTrackReader.h:696
AliCaloTrackReader::fListMixedCaloEvents
TList ** fListMixedCaloEvents
! Container for photon stored for different events, used in case of own mixing, set in analysis class...
Definition: AliCaloTrackReader.h:843
AliCaloTrackReader::fUseParamTimeCut
Bool_t fUseParamTimeCut
Use simple or parametrized time cut.
Definition: AliCaloTrackReader.h:749
AliCaloTrackReader::SetPtHardAndJetPtFactor
virtual void SetPtHardAndJetPtFactor(Float_t factor)
Definition: AliCaloTrackReader.h:657
AliCaloTrackReader::fFiducialCut
AliFiducialCut * fFiducialCut
Acceptance cuts.
Definition: AliCaloTrackReader.h:726
AliCaloTrackReader::fRejectEMCalTriggerEventsWith2Tresholds
Bool_t fRejectEMCalTriggerEventsWith2Tresholds
Reject events EG2 also triggered by EG1 or EJ2 also triggered by EJ1.
Definition: AliCaloTrackReader.h:927
AliCaloTrackReader::SetCaloUtils
void SetCaloUtils(AliCalorimeterUtils *caloutils)
Definition: AliCaloTrackReader.h:603
AliCaloTrackReader::fhPHOSClusterCutsE
TH1F * fhPHOSClusterCutsE[7]
! Control histogram on the different PHOS cluster selection cuts, E
Definition: AliCaloTrackReader.h:936
AliCaloTrackReader::SetEventPlaneMethod
virtual void SetEventPlaneMethod(TString m)
Definition: AliCaloTrackReader.h:568
AliCaloTrackReader::SetPHOSEMin
void SetPHOSEMin(Float_t en)
Definition: AliCaloTrackReader.h:148
AliCaloTrackReader::IsAccessToTrackTimeOn
Bool_t IsAccessToTrackTimeOn() const
Definition: AliCaloTrackReader.h:196
AliCaloTrackReader::GetTrackComplementaryCuts
virtual AliESDtrackCuts * GetTrackComplementaryCuts() const
Definition: AliCaloTrackReader.h:513
AliCaloTrackReader::GetCentralityClass
virtual TString GetCentralityClass() const
Definition: AliCaloTrackReader.h:556
AliCaloTrackReader::AreClustersRecalculated
Bool_t AreClustersRecalculated() const
Definition: AliCaloTrackReader.h:253
AliCaloTrackReader::FillInputEMCAL
virtual void FillInputEMCAL()
Definition: AliCaloTrackReader.cxx:2008
AliCaloTrackReader::fFillEMCAL
Bool_t fFillEMCAL
Use data from EMCAL.
Definition: AliCaloTrackReader.h:785
AliCaloTrackReader::fFillPHOS
Bool_t fFillPHOS
Use data from PHOS.
Definition: AliCaloTrackReader.h:787
AliCaloTrackReader::fEMCALCells
AliVCaloCells * fEMCALCells
! Temporal array with EMCAL AliVCaloCells.
Definition: AliCaloTrackReader.h:777
AliCaloTrackReader::IsEmbeddedClusterSelectionOn
Bool_t IsEmbeddedClusterSelectionOn() const
Definition: AliCaloTrackReader.h:260
AliCaloTrackReader::GetAODMCHeader
virtual AliAODMCHeader * GetAODMCHeader() const
Definition: AliCaloTrackReader.cxx:853
AliCaloTrackReader::fEMCALNCellsCut
Int_t fEMCALNCellsCut
Accept for the analysis EMCAL clusters with more than fNCellsCut cells.
Definition: AliCaloTrackReader.h:745
AliCaloTrackReader::SetTrackCuts
virtual void SetTrackCuts(AliESDtrackCuts *)
Definition: AliCaloTrackReader.h:515
AliCaloTrackReader::GetPHOSPtMin
Float_t GetPHOSPtMin() const
Definition: AliCaloTrackReader.h:129
AliCaloTrackReader::GetLastCaloMixedEvent
Int_t GetLastCaloMixedEvent() const
Definition: AliCaloTrackReader.h:575
AliCaloTrackReader::fCTSPtMin
Float_t fCTSPtMin
pT Threshold on charged particles.
Definition: AliCaloTrackReader.h:735
AliCaloTrackReader::IsCTSSwitchedOn
Bool_t IsCTSSwitchedOn() const
Definition: AliCaloTrackReader.h:229
AliCaloTrackReader::GetStack
virtual AliStack * GetStack() const
Definition: AliCaloTrackReader.cxx:752
AliCaloTrackReader::GetMixEventTriggerMask
UInt_t GetMixEventTriggerMask() const
Definition: AliCaloTrackReader.h:336
AliCaloTrackReader::GetEMCALPtMin
Float_t GetEMCALPtMin() const
Definition: AliCaloTrackReader.h:128
AliCaloTrackReader::SetPileUpParamForSPD
void SetPileUpParamForSPD(Int_t i, Double_t param)
Definition: AliCaloTrackReader.h:454
AliCaloTrackReader::GetTrackCuts
virtual AliESDtrackCuts * GetTrackCuts() const
Definition: AliCaloTrackReader.h:512
AliCaloTrackReader::GetEventTriggerL1Threshold
Float_t GetEventTriggerL1Threshold() const
Definition: AliCaloTrackReader.h:363
AliCaloTrackReader::SwitchOffFiducialCut
virtual void SwitchOffFiducialCut()
Definition: AliCaloTrackReader.h:225
AliCaloTrackReader::fSmearNLMMax
Int_t fSmearNLMMax
Do smearing for clusters with at maximum this value.
Definition: AliCaloTrackReader.h:799
AliCaloTrackReader::GetBackgroundJets
virtual AliAODJetEventBackground * GetBackgroundJets() const
Definition: AliCaloTrackReader.h:717
AliCaloTrackReader::IsVertexBCEventSelectionDone
Bool_t IsVertexBCEventSelectionDone() const
Definition: AliCaloTrackReader.h:415
AliCaloTrackReader::SetCentralityClass
virtual void SetCentralityClass(TString name)
Definition: AliCaloTrackReader.h:554
AliCaloTrackReader::fTriggerL0EventThreshold
Float_t fTriggerL0EventThreshold
L0 Threshold to look for triggered events, set outside.
Definition: AliCaloTrackReader.h:864
AliCaloTrackReader::DegToRad
Float_t DegToRad(Float_t deg) const
Definition: AliCaloTrackReader.h:615
AliCaloTrackReader::fTimeStampEventFracMax
Float_t fTimeStampEventFracMax
Maximum value of time stamp fraction event.
Definition: AliCaloTrackReader.h:889
AliCaloTrackReader::SetEMCALPtMin
void SetEMCALPtMin(Float_t pt)
Definition: AliCaloTrackReader.h:135
AliCaloTrackReader::ResetLists
virtual void ResetLists()
Reset lists, called in AliAnaCaloTrackCorrMaker.
Definition: AliCaloTrackReader.cxx:2998
AliCaloTrackReader::fNPileUpClusters
Int_t fNPileUpClusters
Number of clusters with time avobe 20 ns.
Definition: AliCaloTrackReader.h:899
AliCaloTrackReader::SwitchOnBadTriggerEventsRemoval
void SwitchOnBadTriggerEventsRemoval()
Definition: AliCaloTrackReader.h:373
AliCaloTrackReader::IsNonStandardJetsSwitchedOn
Bool_t IsNonStandardJetsSwitchedOn() const
Definition: AliCaloTrackReader.h:703
AliCaloTrackReader::fTrackMult
Int_t fTrackMult
Track multiplicity.
Definition: AliCaloTrackReader.h:803
AliCaloTrackReader::fOutputEvent
AliAODEvent * fOutputEvent
! pointer to aod output.
Definition: AliCaloTrackReader.h:781
AliCaloTrackReader::SetPHOSBadChannelMinDist
void SetPHOSBadChannelMinDist(Float_t di)
Definition: AliCaloTrackReader.h:160
AliCaloTrackReader::SwitchOnClusterELinearityCorrection
void SwitchOnClusterELinearityCorrection()
Definition: AliCaloTrackReader.h:257
AliCaloTrackReader::IsExoticEvent
Bool_t IsExoticEvent() const
Definition: AliCaloTrackReader.h:351
AliCaloTrackReader::GetTrackFilterMask
virtual ULong_t GetTrackFilterMask() const
Definition: AliCaloTrackReader.h:492
AliCaloTrackReader::GetEMCALPtMax
Float_t GetEMCALPtMax() const
Definition: AliCaloTrackReader.h:131
AliCaloTrackReader::AddChargedParticlesArray
virtual void AddChargedParticlesArray(TArrayI &)
Definition: AliCaloTrackReader.h:684
AliCaloTrackReader::SetTrackTimeCut
void SetTrackTimeCut(Double_t a, Double_t b)
Definition: AliCaloTrackReader.h:188
AliCaloTrackReader::fRecalculateClusters
Bool_t fRecalculateClusters
Correct clusters, recalculate them if recalibration parameters is given.
Definition: AliCaloTrackReader.h:790
AliCaloTrackReader::SetEMCALTimeCut
void SetEMCALTimeCut(Double_t a, Double_t b)
Definition: AliCaloTrackReader.h:204
AliCaloTrackReader::IsEventMinimumBias
Bool_t IsEventMinimumBias() const
Definition: AliCaloTrackReader.h:388
AliCaloTrackReader::fDoRejectNoTrackEvents
Bool_t fDoRejectNoTrackEvents
Reject events with no selected tracks in event.
Definition: AliCaloTrackReader.h:883
AliCaloTrackReader::IsEventEMCALL1Jet2
Bool_t IsEventEMCALL1Jet2() const
Definition: AliCaloTrackReader.h:395
AliCaloTrackReader::smearingFunction
smearingFunction
Smearing function enum.
Definition: AliCaloTrackReader.h:124
AliCaloTrackReader::fEMCALBadChMinDist
Float_t fEMCALBadChMinDist
Minimal distance to bad channel to accept cluster in EMCal, cell units.
Definition: AliCaloTrackReader.h:742
AliCaloTrackReader::fReadStack
Bool_t fReadStack
Access kine information from stack.
Definition: AliCaloTrackReader.h:806
AliCaloTrackReader::fIsTriggerMatchOpenCut
Bool_t fIsTriggerMatchOpenCut[3]
Could not match the event to a trigger patch?, retry opening cuts.
Definition: AliCaloTrackReader.h:875
AliCaloTrackReader::ListWithMixedEventsForCaloExists
Bool_t ListWithMixedEventsForCaloExists() const
Definition: AliCaloTrackReader.h:581
AliCaloTrackReader::fMixEventTriggerMask
UInt_t fMixEventTriggerMask
Select this triggerered event for mixing, tipically kMB or kAnyINT.
Definition: AliCaloTrackReader.h:814
AliCaloTrackReader::RadToDeg
Float_t RadToDeg(Float_t rad) const
Definition: AliCaloTrackReader.h:617
AliCaloTrackReader::IsEventTriggerAtSEOn
Bool_t IsEventTriggerAtSEOn() const
Definition: AliCaloTrackReader.h:339
AliCaloTrackReader::ListWithMixedEventsForTracksExists
Bool_t ListWithMixedEventsForTracksExists() const
Definition: AliCaloTrackReader.h:584
AliCaloTrackReader::FillVertexArray
virtual void FillVertexArray()
Definition: AliCaloTrackReader.cxx:1502
AliCaloTrackReader::IsInTimeWindow
Bool_t IsInTimeWindow(Double_t tof, Float_t energy) const
Definition: AliCaloTrackReader.cxx:1078
AliCaloTrackReader::fRemoveUnMatchedTriggers
Bool_t fRemoveUnMatchedTriggers
Analyze events where trigger patch and cluster where found or not.
Definition: AliCaloTrackReader.h:877
AliCaloTrackReader::GetTrackMultiplicityEtaCut
Float_t GetTrackMultiplicityEtaCut() const
Definition: AliCaloTrackReader.h:487
AliCaloTrackReader::IsV0ANDEventSelectionDone
Bool_t IsV0ANDEventSelectionDone() const
Definition: AliCaloTrackReader.h:411
AliCaloTrackReader::GetEventPlaneAngle
virtual Double_t GetEventPlaneAngle() const
Definition: AliCaloTrackReader.cxx:1445
AliCaloTrackReader::SwitchOffEmbeddedClustersSelection
void SwitchOffEmbeddedClustersSelection()
Definition: AliCaloTrackReader.h:262
AliCaloTrackReader::SetRejectEventsWithBit
void SetRejectEventsWithBit(UInt_t bit)
Definition: AliCaloTrackReader.h:317
AliCaloTrackReader::fCTSTracks
TObjArray * fCTSTracks
Temporal array with tracks.
Definition: AliCaloTrackReader.h:766
AliCaloTrackReader::fTriggerPatchTimeWindow
Int_t fTriggerPatchTimeWindow[2]
Trigger patch selection window.
Definition: AliCaloTrackReader.h:862
AliCaloTrackReader::GetOriginalInputEvent
virtual AliVEvent * GetOriginalInputEvent() const
Definition: AliCaloTrackReader.h:636
AliCaloTrackReader::GetEventTimeStampFractionMin
Float_t GetEventTimeStampFractionMin() const
Definition: AliCaloTrackReader.h:433
AliCaloTrackReader::AcceptParticleMCLabel
Bool_t AcceptParticleMCLabel(Int_t mcLabel) const
Definition: AliCaloTrackReader.cxx:278
AliCaloTrackReader::fMC
AliMCEvent * fMC
! Monte Carlo Event Handler.
Definition: AliCaloTrackReader.h:782
AliCaloTrackReader::SwitchOnOverlapCheck
virtual void SwitchOnOverlapCheck()
Definition: AliCaloTrackReader.h:691
AliCaloTrackReader::fhNEventsAfterCut
TH1I * fhNEventsAfterCut
! Each bin represents number of events resulting after a given selection cut: vertex, trigger, ...
Definition: AliCaloTrackReader.h:942
AliCaloTrackReader::fPtHardAndJetPtFactor
Float_t fPtHardAndJetPtFactor
Factor between ptHard and jet pT to reject/accept event.
Definition: AliCaloTrackReader.h:730
AliCaloTrackReader::SetEMCALEMax
void SetEMCALEMax(Float_t en)
Definition: AliCaloTrackReader.h:149
AliCaloTrackReader::fMCGenerEventHeaderToAccept
TString fMCGenerEventHeaderToAccept
Accept events that contain at least this event header name.
Definition: AliCaloTrackReader.h:948
AliCaloTrackReader::SwitchOnAODPrimaryTrackSelection
virtual void SwitchOnAODPrimaryTrackSelection()
Definition: AliCaloTrackReader.h:501
AliCaloTrackReader::SetEventTriggerL0Threshold
void SetEventTriggerL0Threshold(Float_t tr)
Definition: AliCaloTrackReader.h:362
Option_t
const char Option_t
Definition: External.C:48
AliCaloTrackReader::IsPtHardAndJetPtComparisonSet
virtual Bool_t IsPtHardAndJetPtComparisonSet() const
Definition: AliCaloTrackReader.h:654
AliCaloTrackReader::GetTrackEventBC
Int_t GetTrackEventBC(Int_t bc) const
Definition: AliCaloTrackReader.h:462
AliCaloTrackReader::fDeltaAODFileName
TString fDeltaAODFileName
Delta AOD file name.
Definition: AliCaloTrackReader.h:809
AliCaloTrackReader::GetDataType
virtual Int_t GetDataType() const
Definition: AliCaloTrackReader.h:82
AliCaloTrackReader::SwitchOffEMCALEventRejectionWith2Thresholds
void SwitchOffEMCALEventRejectionWith2Thresholds()
Definition: AliCaloTrackReader.h:401
AliCaloTrackReader::GetEMCALClusterListName
TString GetEMCALClusterListName() const
Definition: AliCaloTrackReader.h:292
AliCaloTrackReader::GetVertexBC
Int_t GetVertexBC() const
Definition: AliCaloTrackReader.h:472
AliCaloTrackReader::GetDeltaAODFileName
TString GetDeltaAODFileName() const
Definition: AliCaloTrackReader.h:105
AliCaloTrackReader::IsPileUpFromEMCal
Bool_t IsPileUpFromEMCal() const
Check if event is from pile-up determined by EMCal.
Definition: AliCaloTrackReader.cxx:1109
AliCaloTrackReader::fFillInputNonStandardJetBranch
Bool_t fFillInputNonStandardJetBranch
Flag to use data from non standard jets.
Definition: AliCaloTrackReader.h:917
AliCaloTrackReader::fNonStandardJets
TClonesArray * fNonStandardJets
! Temporal array with jets.
Definition: AliCaloTrackReader.h:918
AliCaloTrackReader::SetFiredTriggerClassName
void SetFiredTriggerClassName(TString name)
Definition: AliCaloTrackReader.h:326
AliCaloTrackReader::fEMCalBCEventCut
Int_t fEMCalBCEventCut[19]
Fill one entry per event if there is a cluster in a given BC, depend on cluster E, acceptance cut.
Definition: AliCaloTrackReader.h:903
AliCaloTrackReader::fTriggerClusterIndex
Int_t fTriggerClusterIndex
Index in clusters array of trigger cluster.
Definition: AliCaloTrackReader.h:869
AliCaloTrackReader::IsDCALSwitchedOn
Bool_t IsDCALSwitchedOn() const
Definition: AliCaloTrackReader.h:237
AliCaloTrackReader::fTriggerL1EventThresholdFix
Bool_t fTriggerL1EventThresholdFix
L1 Threshold is fix and set outside.
Definition: AliCaloTrackReader.h:866
Bool_t
bool Bool_t
Definition: External.C:53
AliCaloTrackReader::fSmearShowerShapeWidth
Float_t fSmearShowerShapeWidth
Smear shower shape landau function "width" (use in MC).
Definition: AliCaloTrackReader.h:795
AliCaloTrackReader::SetPHOSEMax
void SetPHOSEMax(Float_t en)
Definition: AliCaloTrackReader.h:150
AliCalorimeterUtils
Class with utils specific to calorimeter clusters/cells.
Definition: AliCalorimeterUtils.h:42
AliCaloTrackReader::fBitEGA
Int_t fBitEGA
Trigger bit on VCaloTrigger for EGA.
Definition: AliCaloTrackReader.h:826
AliCaloTrackReader::IsEventEMCALL1Gamma
Bool_t IsEventEMCALL1Gamma() const
Definition: AliCaloTrackReader.h:396
AliCaloTrackReader::GetTrackTimeCutMax
Double_t GetTrackTimeCutMax() const
Definition: AliCaloTrackReader.h:186
AliCaloTrackReader::GetTrackDCACut
Double_t GetTrackDCACut(Int_t i) const
Definition: AliCaloTrackReader.h:173
AliCaloTrackReader::FillInputBackgroundJets
virtual void FillInputBackgroundJets()
Definition: AliCaloTrackReader.cxx:2346
AliCaloTrackReader::GetNameOfMCGeneratorsToAccept
virtual TString GetNameOfMCGeneratorsToAccept(Int_t ig) const
Definition: AliCaloTrackReader.h:674
AliCaloTrackReader::fDoV0ANDEventSelection
Bool_t fDoV0ANDEventSelection
Select events depending on V0AND.
Definition: AliCaloTrackReader.h:881
AliCaloTrackReader::GetTrackMultiplicity
Int_t GetTrackMultiplicity() const
Definition: AliCaloTrackReader.h:486
AliCaloTrackReader::GetNMixedEvent
virtual Int_t GetNMixedEvent() const
Definition: AliCaloTrackReader.h:640
AliCaloTrackReader::SwitchOnConstrainTrackToVertex
virtual void SwitchOnConstrainTrackToVertex()
Definition: AliCaloTrackReader.h:518
AliCaloTrackReader::SwitchOffAliCentrality
virtual void SwitchOffAliCentrality()
Definition: AliCaloTrackReader.h:552
AliCaloTrackReader::SetNameOfMCGeneratorsToAccept
virtual void SetNameOfMCGeneratorsToAccept(Int_t ig, TString name)
Definition: AliCaloTrackReader.h:672
AliCaloTrackReader::fBackgroundJets
AliAODJetEventBackground * fBackgroundJets
! Background jets.
Definition: AliCaloTrackReader.h:921
AliCaloTrackReader::fCorrectELinearity
Bool_t fCorrectELinearity
Correct cluster linearity, always on.
Definition: AliCaloTrackReader.h:791
AliCaloTrackReader::SetMixEventTriggerMask
void SetMixEventTriggerMask(UInt_t evtTrig=AliVEvent::kAnyINT)
Definition: AliCaloTrackReader.h:337
AliCaloTrackReader::GetCreateControlHistograms
virtual TList * GetCreateControlHistograms()
Definition: AliCaloTrackReader.cxx:587
AliCaloTrackReader::fVertexBC
Int_t fVertexBC
Vertex BC.
Definition: AliCaloTrackReader.h:906
AliCaloTrackReader::IsFiducialCutOn
virtual Bool_t IsFiducialCutOn() const
Definition: AliCaloTrackReader.h:222
AliCaloTrackReader::SwitchOffPrimaryVertexSelection
void SwitchOffPrimaryVertexSelection()
Definition: AliCaloTrackReader.h:418
AliCaloTrackReader::SwitchOffOnlyGeneratorParticles
virtual void SwitchOffOnlyGeneratorParticles()
Definition: AliCaloTrackReader.h:694
AliCaloTrackReader::GetDCALClusters
virtual TObjArray * GetDCALClusters() const
Definition: AliCaloTrackReader.h:298
AliCaloTrackReader::GetWeightUtils
AliAnaWeights * GetWeightUtils()
Definition: AliCaloTrackReader.h:607
AliCaloTrackReader::SetInputNonStandardJetBranchName
virtual void SetInputNonStandardJetBranchName(TString name)
Definition: AliCaloTrackReader.h:713
AliCaloTrackReader::SetEventTimeStampFraction
void SetEventTimeStampFraction(Float_t a, Float_t b)
Definition: AliCaloTrackReader.h:436
AliCaloTrackReader::fIsExoticEvent
Bool_t fIsExoticEvent
Exotic trigger event flag.
Definition: AliCaloTrackReader.h:871
AliCaloTrackReader::fInputNonStandardJetBranchName
TString fInputNonStandardJetBranchName
Name of non standard jet branch.
Definition: AliCaloTrackReader.h:919
AliCaloTrackReader::GetEMCalEventBCcut
Int_t GetEMCalEventBCcut(Int_t bc) const
Definition: AliCaloTrackReader.h:463
AliCaloTrackReader::fRejectEventsWithBit
TArrayI fRejectEventsWithBit
Reject events if trigger bit is on.
Definition: AliCaloTrackReader.h:925
AliCaloTrackReader::fUseEMCALTimeCut
Bool_t fUseEMCALTimeCut
Do time cut selection.
Definition: AliCaloTrackReader.h:748
AliCaloTrackReader::IsBadCellTriggerEvent
Bool_t IsBadCellTriggerEvent() const
Definition: AliCaloTrackReader.h:352
AliCaloTrackReader::GetPhi
Float_t GetPhi(Float_t phi) const
Shift phi angle in case of negative value 360 degrees. Example TLorenzVector::Phi defined in -pi to p...
Definition: AliCaloTrackReader.h:613
AliFiducialCut
Store the acceptance cuts for clusters and tracks or particle objects.
Definition: AliFiducialCut.h:27
AliCaloTrackReader::fDataType
Int_t fDataType
Select MC: Kinematics, Data: ESD/AOD, MCData: Both.
Definition: AliCaloTrackReader.h:724
AliCaloTrackReader::SelectTrack
virtual Bool_t SelectTrack(AliVTrack *, Double_t *)
Definition: AliCaloTrackReader.h:481
AliCaloTrackReader::SetFiducialCut
virtual void SetFiducialCut(AliFiducialCut *fc)
Definition: AliCaloTrackReader.h:221
AliCaloTrackReader::fFillDCAL
Bool_t fFillDCAL
Use data from DCAL, not needed in the normal case, use just EMCal array with DCal limits...
Definition: AliCaloTrackReader.h:786
AliCaloTrackReader::IsEMCALCellsSwitchedOn
Bool_t IsEMCALCellsSwitchedOn() const
Definition: AliCaloTrackReader.h:245
AliCaloTrackReader::SetTrackEventBCcut
void SetTrackEventBCcut(Int_t bc)
Definition: AliCaloTrackReader.h:469
AliCaloTrackReader::SwitchOffUseParametrizedTimeCut
void SwitchOffUseParametrizedTimeCut()
Definition: AliCaloTrackReader.h:214
AliCaloTrackReader::IsShowerShapeSmeared
Bool_t IsShowerShapeSmeared() const
Definition: AliCaloTrackReader.h:269
AliCaloTrackReader::SetDataType
virtual void SetDataType(Int_t data)
Definition: AliCaloTrackReader.h:83
AliCaloTrackReader::GetPHOSPtMax
Float_t GetPHOSPtMax() const
Definition: AliCaloTrackReader.h:132
AliCaloTrackReader::fIsTriggerMatch
Bool_t fIsTriggerMatch
Could match the event to a trigger patch?
Definition: AliCaloTrackReader.h:874
AliCaloTrackReader::fTriggerL1EventThreshold
Float_t fTriggerL1EventThreshold
L1 Threshold to look for triggered events, set in data.
Definition: AliCaloTrackReader.h:865
AliCaloTrackReader::fCentralityClass
TString fCentralityClass
Name of selected centrality class.
Definition: AliCaloTrackReader.h:911
AliCaloTrackReader::GetTrackEventBCcut
Int_t GetTrackEventBCcut(Int_t bc) const
Definition: AliCaloTrackReader.h:464
AliCaloTrackReader::fTrackStatus
ULong_t fTrackStatus
Track selection bit, select tracks refitted in TPC, ITS ...
Definition: AliCaloTrackReader.h:801
AliCaloTrackReader::IsPileUpFromSPDAndEMCal
Bool_t IsPileUpFromSPDAndEMCal() const
Check if event is from pile-up determined by SPD and EMCal.
Definition: AliCaloTrackReader.cxx:1118
AliCaloTrackReader::FillInputPHOS
virtual void FillInputPHOS()
Fill the array with PHOS filtered clusters.
Definition: AliCaloTrackReader.cxx:2145
AliCaloTrackReader::fLastMixedCaloEvent
Int_t fLastMixedCaloEvent
Temporary container with the last event added to the mixing list for photons.
Definition: AliCaloTrackReader.h:845
AliCaloTrackReader::fUseAliCentrality
Bool_t fUseAliCentrality
Select as centrality estimator AliCentrality (Run1) or AliMultSelection (Run1 and Run2) ...
Definition: AliCaloTrackReader.h:910
AliCaloTrackReader::GetCTSTracks
virtual TObjArray * GetCTSTracks() const
Definition: AliCaloTrackReader.h:296
AliCaloTrackReader::fSmearingFunction
Int_t fSmearingFunction
Choice of smearing function. 0 no smearing. 1 smearing from Gustavo (Landau center at 0)...
Definition: AliCaloTrackReader.h:797
AliCaloTrackReader::fRecalculateVertexBC
Bool_t fRecalculateVertexBC
Recalculate vertex BC from tracks pointing to vertex.
Definition: AliCaloTrackReader.h:907
AliCaloTrackReader::SetEMCalEventBC
void SetEMCalEventBC(Int_t bc)
Definition: AliCaloTrackReader.h:466
AliCaloTrackReader::GetTriggerClusterId
Int_t GetTriggerClusterId() const
Definition: AliCaloTrackReader.h:359
AliCaloTrackReader::SwitchOffAODHybridTrackSelection
virtual void SwitchOffAODHybridTrackSelection()
Definition: AliCaloTrackReader.h:499
AliCaloTrackReader::SetDeltaAODFileName
void SetDeltaAODFileName(TString name)
Definition: AliCaloTrackReader.h:104
AliCaloTrackReader::IsEventEMCALL0
Bool_t IsEventEMCALL0() const
Definition: AliCaloTrackReader.h:391
AliCaloTrackReader::GetCTSPtMin
Float_t GetCTSPtMin() const
Definition: AliCaloTrackReader.h:130