AliPhysics  9b6b435 (9b6b435)
AliAnalysisTaskEmcal.h
Go to the documentation of this file.
1 /************************************************************************************
2  * Copyright (C) 2017, Copyright Holders of the ALICE Collaboration *
3  * All rights reserved. *
4  * *
5  * Redistribution and use in source and binary forms, with or without *
6  * modification, are permitted provided that the following conditions are met: *
7  * * Redistributions of source code must retain the above copyright *
8  * notice, this list of conditions and the following disclaimer. *
9  * * Redistributions in binary form must reproduce the above copyright *
10  * notice, this list of conditions and the following disclaimer in the *
11  * documentation and/or other materials provided with the distribution. *
12  * * Neither the name of the <organization> nor the *
13  * names of its contributors may be used to endorse or promote products *
14  * derived from this software without specific prior written permission. *
15  * *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND *
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED *
18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
19  * DISCLAIMED. IN NO EVENT SHALL ALICE COLLABORATION BE LIABLE FOR ANY *
20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES *
21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; *
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND *
23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
26  ************************************************************************************/
27 #ifndef ALIANALYSISTASKEMCAL_H
28 #define ALIANALYSISTASKEMCAL_H
29 
30 class TClonesArray;
31 class TString;
32 class AliMCParticle;
33 class AliVCluster;
34 class AliVTrack;
35 class AliVParticle;
36 class AliVCaloCells;
37 class TH1;
38 class TProfile;
39 class AliEMCALGeometry;
40 class AliGenPythiaEventHeader;
41 class AliGenHerwigEventHeader;
42 class AliVCaloTrigger;
43 class AliAnalysisUtils;
44 class AliEMCALTriggerPatchInfo;
45 class AliAODTrack;
46 class AliEmcalPythiaInfo;
47 class AliAODInputHandler;
48 class AliESDInputHandler;
49 
50 #include "Rtypes.h"
51 #include "TArrayI.h"
52 
53 #include "AliParticleContainer.h"
54 #include "AliMCParticleContainer.h"
55 #include "AliTrackContainer.h"
56 #include "AliClusterContainer.h"
57 #include "AliEmcalList.h"
58 #include "AliEventCuts.h"
59 
60 #include "AliAnalysisTaskSE.h"
228  public:
229 
234  enum EDataType_t {
238  };
239 
244  enum BeamType {
245  kNA = -1,
246  kpp = 0,
247  kAA = 1,
248  kpA = 2
249  };
250 
255  enum TriggerType {
256  kND = -1,
257  kJ1 = 0,
258  kJ2 = 1,
259  kG1 = 2,
260  kG2 = 3,
261  kL0 = 4
262  };
263 
274  };
275 
283  };
284 
289 
300  AliAnalysisTaskEmcal(const char *name, Bool_t histo=kFALSE);
301 
305  virtual ~AliAnalysisTaskEmcal();
306 
316 
325  AliTrackContainer *AddTrackContainer(const char *n);
326 
336 
346 
351 
358 
364  AliParticleContainer *GetParticleContainer(const char* name) const;
365 
372 
378  AliClusterContainer *GetClusterContainer(const char* name) const;
380  AliMCParticleContainer *GetMCParticleContainer(const char* name) const { return dynamic_cast<AliMCParticleContainer*>(GetParticleContainer(name)); }
382  AliTrackContainer *GetTrackContainer(const char* name) const { return dynamic_cast<AliTrackContainer*>(GetParticleContainer(name)) ; }
383  AliEventCuts &GetEventCuts() { return fAliEventCuts; }
384  void RemoveParticleContainer(Int_t i=0) { fParticleCollArray.RemoveAt(i) ; }
385  void RemoveClusterContainer(Int_t i=0) { fClusterCollArray.RemoveAt(i) ; }
386  void SetCaloCellsName(const char *n) { fCaloCellsName = n ; }
388  void SetCaloTriggersName(const char *n) { fCaloTriggersName = n ; }
389  void SetCentRange(Double_t min, Double_t max) { fMinCent = min ; fMaxCent = max ; }
390  void SetCentralityEstimator(const char *c) { fCentEst = c ; }
391 
398  void SetClusPtCut(Double_t cut, Int_t c=0);
399 
407  void SetClusTimeCut(Double_t min, Double_t max, Int_t c=0);
408 
411  void SetHistoBins(Int_t nbins, Double_t min, Double_t max) { fNbins = nbins; fMinBinPt = min; fMaxBinPt = max ; }
413  void SetIsEmbedded(Bool_t i) { fIsEmbedded = i ; }
414 
424  void SetIsPythia(Bool_t i) { fIsPythia = i ; }
425 
435  void SetIsHerwig(Bool_t i) { fIsHerwig = i ; }
436 
446 
457 
463 
473  void SetUserPtHardBinning(const TArrayI &binning) { fPtHardBinning = binning; }
474 
476  void SetMinMCLabel(Int_t s) { fMinMCLabel = s ; }
477  void SetMinNTrack(Int_t min) { fMinNTrack = min ; }
480  virtual void SetNCentBins(Int_t n) { fNcentBins = n ; }
483  void SetOffTrigger(UInt_t t) { fOffTrigger = t ; }
484 
492  void SetTrackEtaLimits(Double_t min, Double_t max, Int_t c=0);
493 
501  void SetTrackPhiLimits(Double_t min, Double_t max, Int_t c=0);
502 
509  void SetTrackPtCut(Double_t cut, Int_t c=0);
510 
511  void SetTrigClass(const char *n) { fTrigClass = n ; }
512  void SetMinBiasTriggerClassName(const char *n) { fMinBiasRefTrigger = n ; }
514  void SetUseAliAnaUtils(Bool_t b, Bool_t bRejPilup = kTRUE) { fUseAliAnaUtils = b ; fRejectPileup = bRejPilup ; }
515 
523 
529 
540  void SetVzRange(Double_t min, Double_t max) { fMinVz = min ; fMaxVz = max ; }
546  void SetPythiaInfoName(const char *n) { fPythiaInfoName = n ; }
547  const TString& GetPythiaInfoName() const { return fPythiaInfoName ; }
548  const AliEmcalPythiaInfo *GetPythiaInfo() const { return fPythiaInfo ; }
549 
564 
575  void SetMCFilter() { fMCRejectFilter = kTRUE ; }
576 
580  void ResetMCFilter() { fMCRejectFilter = kFALSE ; }
581 
589 
595 
603 
609 
617 
623 
624  // Static Utilities
629  static AliAODInputHandler* AddAODHandler();
630 
635  static AliESDInputHandler* AddESDHandler();
636 
637  protected:
642  void LoadPythiaInfo(AliVEvent *event);
643 
644  void SetRejectionReasonLabels(TAxis* axis);
645 
657  Bool_t AcceptCluster(AliVCluster *clus, Int_t c = 0) const;
658 
668  Bool_t AcceptTrack(AliVParticle *track, Int_t c = 0) const;
669 
675  void AddObjectToEvent(TObject *obj, Bool_t attempt = kFALSE);
676 
684  AliVParticle *GetAcceptParticleFromArray(Int_t p, Int_t c=0) const;
685 
693  AliVCluster *GetAcceptClusterFromArray(Int_t cl, Int_t c=0) const;
694 
695 
705  TClonesArray *GetArrayFromEvent(const char *name, const char *clname=0);
706 
714  BeamType GetBeamType() const;
715 
721  TClonesArray *GetParticleArray(Int_t i=0) const;
722 
728  TClonesArray *GetClusterArray(Int_t i=0) const;
729 
735  Int_t GetNParticles(Int_t i=0) const;
736 
743  Int_t GetNClusters(Int_t i=0) const;
744 
756  AliEMCALTriggerPatchInfo *GetMainTriggerPatch(TriggerCategory triggersel = kTriggerLevel1Jet, Bool_t doSimpleOffline = kFALSE);
757 
766  Bool_t HasTriggerType(TriggerType triggersel);
767 
776 
790  Bool_t PythiaInfoFromFile(const char* currFile, Float_t &fXsec, Float_t &fTrials, Int_t &pthard);
800  Bool_t IsTrackInEmcalAcceptance(AliVParticle* part, Double_t edges=0.9) const;
801 
806  void GeneratePythiaInfoObject(AliMCEvent* mcEvent);
807 
814  virtual Bool_t CheckMCOutliers();
815 
856 
884  void UserExec(Option_t *option);
885 
896  Bool_t UserNotify();
897 
918 
930  virtual void ExecOnce();
931 
946  virtual Bool_t FillGeneralHistograms();
947 
963  virtual Bool_t IsEventSelected();
964 
976  virtual Bool_t IsTriggerSelected();
977 
1001  virtual Bool_t RetrieveEventObjects();
1002 
1010  virtual void RunChanged(Int_t /*newrun*/) {}
1011 
1019  virtual void UserExecOnce() {}
1020 
1026  virtual void UserFileChanged() {}
1027 
1035  virtual Bool_t FillHistograms() { return kTRUE ; }
1036 
1044  virtual Bool_t Run() { return kTRUE ; }
1045 
1046  // Static utilities
1056  static void GetEtaPhiDiff(const AliVTrack *t, const AliVCluster *v, Double_t &phidiff, Double_t &etadiff);
1057 
1063  static Byte_t GetTrackType(const AliVTrack *t);
1064 
1076  static Byte_t GetTrackType(const AliAODTrack *aodTrack, UInt_t filterBit1, UInt_t filterBit2);
1077 
1086  static Double_t DeltaPhi(Double_t phia, Double_t phib, Double_t rMin = -TMath::Pi()/2, Double_t rMax = 3*TMath::Pi()/2);
1087 
1097  static Double_t* GenerateFixedBinArray(Int_t n, Double_t min, Double_t max);
1098 
1108  static void GenerateFixedBinArray(Int_t n, Double_t min, Double_t max, Double_t* array);
1109 
1134 
1141  static Double_t GetParallelFraction(AliVParticle* part1, AliVParticle* part2);
1142 
1149  static Double_t GetParallelFraction(const TVector3& vect1, AliVParticle* part2);
1150 
1152 
1153  // Task configuration
1210 
1211  // Service fields
1213  AliEventCuts fAliEventCuts;
1214  AliAnalysisUtils *fAliAnalysisUtils;
1216  AliEMCALGeometry *fGeom;
1217  TClonesArray *fTracks;
1218  TClonesArray *fCaloClusters;
1219  AliVCaloCells *fCaloCells;
1220  AliVCaloTrigger *fCaloTriggers;
1221  TClonesArray *fTriggerPatchInfo;
1232  AliGenPythiaEventHeader *fPythiaHeader;
1233  AliGenHerwigEventHeader *fHerwigHeader;
1243 
1244  // Output
1252  TProfile *fHistXsection;
1263 
1264  private:
1265  AliAnalysisTaskEmcal(const AliAnalysisTaskEmcal&); // not implemented
1266  AliAnalysisTaskEmcal &operator=(const AliAnalysisTaskEmcal&); // not implemented
1267 
1269  ClassDef(AliAnalysisTaskEmcal, 19) // EMCAL base analysis task
1271 };
1272 
1274 {
1275  Double_t dphi = -999;
1276  const Double_t tpi = TMath::TwoPi();
1277 
1278  if (phia < 0) phia += tpi;
1279  else if (phia > tpi) phia -= tpi;
1280  if (phib < 0) phib += tpi;
1281  else if (phib > tpi) phib -= tpi;
1282  dphi = phib - phia;
1283  if (dphi < rangeMin) dphi += tpi;
1284  else if (dphi > rangeMax) dphi -= tpi;
1285 
1286  return dphi;
1287 }
1288 
1290 {
1291  Double_t binWidth = (max-min)/n;
1292  array[0] = min;
1293  for (Int_t i = 1; i <= n; i++) {
1294  array[i] = array[i-1]+binWidth;
1295  }
1296 }
1297 
1299 {
1300  Double_t *array = new Double_t[n+1];
1301  GenerateFixedBinArray(n, min, max, array);
1302  return array;
1303 }
1304 
1305 #endif
void SetJetPtFactor(Float_t f)
Set the jet pt factor for the outlier rejection.
void SetCentRange(Double_t min, Double_t max)
void SetRecycleUnusedEmbeddedEventsMode(Bool_t b)
virtual Bool_t Run()
Run function. This is the core function of the analysis and contains the user code. Therefore users have to implement this function.
void SetPythiaInfoName(const char *n)
void SetTrackPtFactor(Float_t f)
Set the track pt factor for the outlier rejection.
Bool_t fGeneratePythiaInfoObject
Generate Pythia info object.
TObjArray fClusterCollArray
cluster collection array
Int_t fNVertSPDCont
!event SPD vertex number of contributors
AliMCParticleContainer * GetMCParticleContainer(const char *name) const
Bool_t fIsPythia
trigger, if it is a PYTHIA production
double Double_t
Definition: External.C:58
void SetUseInternalEventSelection(Bool_t doUse)
Use internal (old) event selection.
TH2 * fHistPtHardBinCorr
!Correlation between global and local (per-event) -hard bin
void SetMCFilter()
Switch on MC outlier rejection.
TH1 * fHistTrials
!trials from pyxsec.root
Bool_t fPtHardInitialized
!flag whether the -hard bin was initialized, purely for internal processing
static Double_t DeltaPhi(Double_t phia, Double_t phib, Double_t rMin=-TMath::Pi()/2, Double_t rMax=3 *TMath::Pi()/2)
EMCAL Level1 gamma trigger, low threshold.
AliEmcalPythiaInfo * fPythiaInfo
!event parton info
Bool_t AcceptTrack(AliVParticle *track, Int_t c=0) const
ULong_t GetTriggerList()
Get list of selected triggers of the given event.
Int_t fPtHardBinGlobal
!event -hard bin, detected from filename
EMCAL Level1 jet trigger, low threshold.
Bool_t HasTriggerType(TriggerType triggersel)
Check if event has a given trigger type.
void SetUserPtHardBinning(const TArrayI &binning)
Set a non-standard -hard binning.
Int_t fNTrials
!event trials
void SetMinNTrack(Int_t min)
UInt_t fOffTrigger
offline trigger for event selection
void AdoptParticleContainer(AliParticleContainer *cont)
Double_t fVertexSPD[3]
!event Svertex
Double_t fMinCent
min centrality for event selection
Double_t fTrackPtCut
cut on track pt in event selection
virtual void UserFileChanged()
Virtual method for user code to be executed when a file changed.
Bool_t fRecycleUnusedEmbeddedEventsMode
Allows the recycling of embedded events which fail internal event selection. See the embedding helper...
No special treatment for EMCal triggers.
Recalculated jet trigger patch; does not need to be above trigger threshold.
Base task in the EMCAL framework.
void SetMinVertexContrib(Int_t min)
Bool_t fLocalInitialized
whether or not the task has been already initialized
Bool_t fUsePtHardBinScaling
Use -hard bin scaling in merging.
TH2 * fHistPtHardCorrGlobal
!Correlation between -hard value and global bin
Container with name, TClonesArray and cuts for particles.
void SetUseAliAnaUtils(Bool_t b, Bool_t bRejPilup=kTRUE)
Bool_t fUseXsecFromHeader
! Use cross section from header instead of pyxsec.root (purely transient)
void SetUseSPDTrackletVsClusterBG(Bool_t b)
void SetTrackPtCut(Double_t cut, Int_t c=0)
Apply cut on the transverse momentum of all tracks in the track container with index c...
static void GetEtaPhiDiff(const AliVTrack *t, const AliVCluster *v, Double_t &phidiff, Double_t &etadiff)
Calculate and difference between a track (t) and a cluster (c).
Double_t fMinBinPt
min pt in histograms
Double_t fEPV0
!event plane V0
void SetUseNewCentralityEstimation(Bool_t b)
void SetCountDownscaleCorrectedEvents(Bool_t d)
Int_t fNPtHardBins
Number of -hard bins in the dataset.
Bool_t fGeneralHistograms
whether or not it should fill some general histograms
Bool_t AcceptCluster(AliVCluster *clus, Int_t c=0) const
Cluster selection.
TCanvas * c
Definition: TestFitELoss.C:172
AliAnalysisTaskEmcal & operator=(const AliAnalysisTaskEmcal &)
virtual void UserExecOnce()
Task initializations handled in user tasks.
void SetGetPtHardBinFromPath(Bool_t docheck)
Switch on/off getting bin from the file path.
Int_t fCentBin
!event centrality bin
virtual Bool_t IsTriggerSelected()
Selection of a hardware trigger.
TH1 * fHistEventsAfterSel
!total number of events per pt hard bin after selection
Int_t fMinVertexContrib
Min. number of vertex contributors.
void SetTriggerTypeSel(TriggerType t)
Float_t fPtHardAndClusterPtFactor
Factor between ptHard and cluster pT to reject/accept event.
Double_t fMinPtTrackInEmcal
min pt track in emcal
void SetVzRange(Double_t min, Double_t max)
Set pre-configured event cut object.
TH1 * fHistEventPlane
!event plane distribution
Bool_t fUseBuiltinEventSelection
Use builtin event selection of the AliAnalysisTaskEmcal instead of AliEventCuts.
AliTrackContainer * GetTrackContainer(const char *name) const
TH1 * fHistEvents
!total number of events per pt hard bin
void SetClusPtCut(Double_t cut, Int_t c=0)
Apply cut on for all clusters in container with index c.
AliClusterContainer * AddClusterContainer(const char *n)
Create new cluster container and attach it to the task.
Double_t fEPV0C
!event plane V0C
TH1 * fHistCentrality
!event centrality distribution
void SetCaloTriggerPatchInfoName(const char *n)
Container for particles within the EMCAL framework.
void SetIsPythia(Bool_t i)
Define production as pythia pt-hard production.
Bool_t fIsEmbedded
trigger, embedded signal
AliEventCuts & GetEventCuts()
void AdoptClusterContainer(AliClusterContainer *cont)
TObjArray fParticleCollArray
particle/track collection array
BeamType
Switch for the beam type.
void SetTrackEtaLimits(Double_t min, Double_t max, Int_t c=0)
Apply cut on the pseudorapidity of the all tracks in the track container with index c...
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
void SetEMCalTriggerMode(EMCalTriggerMode_t m)
TProfile * fHistXsectionAfterSel
!x section from pythia header
TriggerType
Switch for EMCAL trigger types.
virtual Bool_t CheckMCOutliers()
Filter the mc tails in pt-hard distributions.
EMCalTriggerMode_t fEMCalTriggerMode
EMCal trigger selection mode.
virtual Bool_t FillHistograms()
Function filling histograms.
void SetForceBeamType(BeamType f)
Int_t GetNParticles(Int_t i=0) const
Get number of particles in container attached to this task with index i.
TClonesArray * fCaloClusters
!clusters
Bool_t fUseNewCentralityEstimation
Use new centrality estimation (for 2015 data)
Bool_t IsTrackInEmcalAcceptance(AliVParticle *part, Double_t edges=0.9) const
Determines if a track is inside the EMCal acceptance.
int Int_t
Definition: External.C:63
Float_t ClusterPtFactor()
Get the cluster pt factor for the outlier rejection.
TH1 * fHistTriggerClasses
!number of events in each trigger class
Bool_t fCountDownscaleCorrectedEvents
Count event number corrected for downscaling.
unsigned int UInt_t
Definition: External.C:33
float Float_t
Definition: External.C:68
Double_t fMaxVz
max vertex for event selection
void GeneratePythiaInfoObject(AliMCEvent *mcEvent)
Copy some information about the Pythia event in a PythaInfo object.
AliEMCALGeometry * fGeom
!emcal geometry
The overlap between low and high threshold trigger is assigned to the lower threshold only...
kRecalculated gamma trigger patch; does not need to be above trigger threshold
TString fCaloTriggerPatchInfoName
trigger patch info array name
TString fCaloTriggersName
name of calo triggers collection
TH1 * fHistTriggerClassesCorr
!corrected number of events in each trigger class
Bool_t fIsHerwig
trigger, if it is a HERWIG production
AliGenPythiaEventHeader * fPythiaHeader
!event Pythia header
void SetTrackPhiLimits(Double_t min, Double_t max, Int_t c=0)
Apply cut on azimuthal angle of the all tracks in the track container with index c...
AliParticleContainer * AddParticleContainer(const char *n)
Create new particle container and attach it to the task.
AliAnalysisUtils * fAliAnalysisUtils
!vertex selection (optional)
BeamType fForceBeamType
forced beam type
Int_t fNcentBins
how many centrality bins
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Get cluster container attached to this task.
TriggerType fTriggerTypeSel
trigger type to select based on trigger patches
virtual Bool_t FillGeneralHistograms()
Filling general histograms.
TString fTrigClass
trigger class name for event selection
Float_t fPtHardAndJetPtFactor
Factor between ptHard and jet pT to reject/accept event.
TClonesArray * GetParticleArray(Int_t i=0) const
Get TClonesArray with particles.
BeamType GetBeamType() const
Get beam type.
void SetUsePtHardBinScaling(Bool_t b)
Switch on pt-hard bin scaling.
Double_t fMinVz
min vertex for event selection
BeamType fBeamType
!event beam type
Float_t fPtHardAndTrackPtFactor
Factor between ptHard and track pT to reject/accept event.
Double_t fCent
!event centrality
Double_t fMinEventPlane
minimum event plane value
TString fCaloCellsName
name of calo cell collection
Float_t TrackPtFactor()
Get the track pt factor for the outlier rejection.
Int_t fMCLabelShift
if MC label > fMCLabelShift, MC label -= fMCLabelShift
Int_t GetNClusters(Int_t i=0) const
Get number of clusters in the cluster container attached to this task with index i.
Int_t fNVertCont
!event vertex number of contributors
Bool_t fMCRejectFilter
enable the filtering of events by tail rejection
Bool_t fGetPtHardBinFromName
Obtain pt-hard bin from file path.
unsigned long ULong_t
Definition: External.C:38
void RemoveClusterContainer(Int_t i=0)
Double_t fZvertexDiff
upper limit for distance between primary and SPD vertex
AliEMCALTriggerPatchInfo * GetMainTriggerPatch(TriggerCategory triggersel=kTriggerLevel1Jet, Bool_t doSimpleOffline=kFALSE)
Get main trigger match.
EMCAL Level0 trigger.
EMCAL Level1 jet trigger, high threshold.
void AdoptMCParticleContainer(AliMCParticleContainer *cont)
Int_t fSelectPtHardBin
select one pt hard bin for analysis
AliMCParticleContainer * AddMCParticleContainer(const char *n)
Create new container for MC particles and attach it to the task.
static Double_t GetParallelFraction(AliVParticle *part1, AliVParticle *part2)
Calculates the fraction of momentum z of part 1 w.r.t. part 2 in the direction of part 2...
void ResetMCFilter()
Switch off MC outlier rejection.
virtual Bool_t RetrieveEventObjects()
Retrieve common objects from event.
Bool_t fRejectPileup
Reject pilup using function AliAnalysisUtils::IsPileUpEvent()
void RemoveParticleContainer(Int_t i=0)
TProfile * fHistXsection
!x section from pyxsec.root
Bool_t PythiaInfoFromFile(const char *currFile, Float_t &fXsec, Float_t &fTrials, Int_t &pthard)
Loading PYTHIA information from external cross section file into the task.
void UserExec(Option_t *option)
Event loop, called for each event.
Int_t fMinMCLabel
minimum MC label value for the tracks/clusters being considered MC particles
virtual void SetNCentBins(Int_t n)
AliVCaloCells * fCaloCells
!cells
void SetTrigClass(const char *n)
TClonesArray * GetArrayFromEvent(const char *name, const char *clname=0)
Read a TClonesArray from event.
Enhanced TList-derived class that implements correct merging for pt_hard binned production.
Definition: AliEmcalList.h:25
Double_t fEventPlaneVsEmcal
select events which have a certain event plane wrt the emcal
Bool_t IsEventSelectedInternal()
Perform event selection (old method)
virtual Bool_t IsEventSelected()
Performing event selection.
Float_t fPtHard
!event -hard
TH1 * fHistPtHard
! -hard distribution
static Double_t * GenerateFixedBinArray(Int_t n, Double_t min, Double_t max)
AliEventCuts fAliEventCuts
Event cuts (run2 defaults)
AliEmcalList * fOutput
!output list
void SetZvertexDiffValue(Double_t cut)
Double_t fMaxBinPt
max pt in histograms
Int_t fPtHardBin
!event -hard bin
void SetHistoBins(Int_t nbins, Double_t min, Double_t max)
AliMCParticleContainer * GetMCParticleContainer(Int_t i=0) const
virtual void RunChanged(Int_t)
Process tasks relevant when a file with a different run number is processed.
TClonesArray * fTracks
!tracks
TH1 * fHistTrialsAfterSel
!total number of trials per pt hard bin after selection
AliGenHerwigEventHeader * fHerwigHeader
!event Herwig header
Definition: External.C:220
void LoadPythiaInfo(AliVEvent *event)
Load parton info.
Bool_t fIsEsd
!whether it&#39;s an ESD analysis
static AliAODInputHandler * AddAODHandler()
Add an AOD handler to the analysis manager.
void SetIsHerwig(Bool_t i)
Define production as herwig (6) pt-hard production.
Double_t fVertex[3]
!event vertex
AliTrackContainer * AddTrackContainer(const char *n)
Create new track container and attach it to the task.
AliTrackContainer * GetTrackContainer(Int_t i=0) const
void SetMinBiasTriggerClassName(const char *n)
EMCalTriggerMode_t
Handling of the EMCAL trigger thresholds.
Bool_t fCreateHisto
whether or not create histograms
void SetNumberOfPtHardBins(Int_t nbins)
Set the number of -hard bins.
Bool_t UserNotify()
Notifying the user that the input data file has changed and performing steps needed to be done...
Store some informaion about a Pythia eventThis class is used to store some information about a Pythia...
TH1 * fHistEventRejection
!book keep reasons for rejecting event
void SetMakeGeneralHistograms(Bool_t g)
Enable general histograms.
TClonesArray * fTriggerPatchInfo
!trigger patch info array
TClonesArray * GetClusterArray(Int_t i=0) const
Get TClonesArray with EMCAL clusters.
void SetNeedEmcalGeom(Bool_t n)
Bool_t FileChanged()
Steps to be executed when a few file is loaded into the input handler.
Double_t fEPV0A
!event plane V0A
void SetEventPlaneVsEmcal(Double_t ep)
void SetCaloTriggersName(const char *n)
const AliEmcalPythiaInfo * GetPythiaInfo() const
virtual void ExecOnce()
Perform steps needed to initialize the analysis.
TString fCentEst
name of V0 centrality estimator
TString fPythiaInfoName
name of pythia info object
const char Option_t
Definition: External.C:48
Int_t fRunNumber
!run number (triggering RunChanged())
EMCAL Level1 gamma trigger, high threshold.
void AddObjectToEvent(TObject *obj, Bool_t attempt=kFALSE)
Add object to event.
void SetUseBuiltinEventSelection(Bool_t doUse)
Use internal (old) event selection.
AliVCaloTrigger * fCaloTriggers
!calo triggers
void SetRejectionReasonLabels(TAxis *axis)
void UserCreateOutputObjects()
Main initialization function on the worker.
Bool_t fFileChanged
! Signal triggered when the file has changed
TH1 * fHistZVertex
!z vertex position
Int_t fMinNTrack
minimum nr of tracks in event with pT>fTrackPtCut
static Byte_t GetTrackType(const AliVTrack *t)
Get track type encoded from bits 20 and 21.
void SetGeneratePythiaInfoObject(Bool_t b)
const Int_t nbins
Bool_t fUseAliAnaUtils
used for LHC13* data: z-vtx, Ncontributors, z-vtx resolution cuts
void SetClusTimeCut(Double_t min, Double_t max, Int_t c=0)
Apply cut on cluster time for clusters in container with index c.
bool Bool_t
Definition: External.C:53
Float_t JetPtFactor()
Get the jet pt factor for the outlier rejection.
ULong_t fTriggers
list of fired triggers
static AliESDInputHandler * AddESDHandler()
Add a ESD handler to the analysis manager.
Double_t fMaxEventPlane
maximum event plane value
Float_t fXsection
!x-section from pythia header
EDataType_t
Switch for the data type.
void SetCaloCellsName(const char *n)
void SetCentralityEstimator(const char *c)
TH1 * fHistEventCount
!incoming and selected events
Double_t fMaxCent
max centrality for event selection
void SetMinPtTrackInEmcal(Double_t min)
TriggerCategory
Online trigger categories.
AliVParticle * GetAcceptParticleFromArray(Int_t p, Int_t c=0) const
Get particle p if accepted from container with index c If particle not accepted return 0...
Container structure for EMCAL clusters.
TString fMinBiasRefTrigger
Name of the minmum bias reference trigger, used in the calculation of downscale-corrected event numbe...
Container for MC-true particles within the EMCAL framework.
Bool_t fNeedEmcalGeom
whether or not the task needs the emcal geometry
AliVCluster * GetAcceptClusterFromArray(Int_t cl, Int_t c=0) const
Get cluster cl if accepted from container c If particle not accepted return 0.
void SetClusterPtFactor(Float_t f)
Set the cluster pt factor for the outlier rejection.
const TString & GetPythiaInfoName() const
void AdoptTrackContainer(AliTrackContainer *cont)
Definition: External.C:196
Int_t fNbins
no. of pt bins
Bool_t fTklVsClusSPDCut
Apply tracklet-vs-cluster SPD cut to reject background events in pp.
AliAnalysisTaskEmcal()
Default constructor.
TH2 * fHistPtHardCorr
!Correlation between -hard value and bin
TArrayI fPtHardBinning
-hard binning
virtual ~AliAnalysisTaskEmcal()
Destructor.
static Double_t fgkEMCalDCalPhiDivide
phi value used to distinguish between DCal and EMCal