AliConvEventCuts.h

Go to the documentation of this file.

#ifndef ALICONVEVENTCUTS_H
#define ALICONVEVENTCUTS_H

// Class handling all kinds of selection cuts for Gamma Conversion analysis
// Authors: Friederike Bock, Daniel Muehlheim

#include "AliAODTrack.h"
#include "AliESDtrack.h"
#include "AliVEvent.h"
#include "AliMCEvent.h"
#include "AliVTrack.h"
#include "AliAnalysisCuts.h"
#include "TH1F.h"
#include "TF1.h"
#include "TObjArray.h"
#include "AliAnalysisUtils.h"
#include "AliAnalysisManager.h"
#include "TRandom3.h"
#include "AliVCaloTrigger.h"

class AliESDEvent;
class AliAODEvent;
class TH1F;
class TH2F;
class TF1;
class AliAnalysisCuts;
class iostream;
class TList;
class AliAnalysisManager;
class AliAODMCParticle;
class AliEMCALTriggerPatchInfo;

class AliConvEventCuts : public AliAnalysisCuts {

    public:
      enum cutIds {
        kisHeavyIon,
        kCentralityMin,
        kCentralityMax,
        kSelectSpecialTriggerAlias,
        kSelectSubTriggerClass,
        kremovePileUp,
        kExtraSignals,
        kVertex,
        kNCuts
      };

      enum TriggerTypeEMCAL {
        kND       = -1,  //not defined
        kJ1       = 1,
        kJ2       = 2,
        kG1       = 3,
        kG2       = 4,
        kL0       = 5,
      };

      enum PeriodVar {
        // data periods
        kNoPeriod=0,  
        // 2010
        kLHC10bg,         
        kLHC10h,          
        // MC's corresponding to 2010 data
        kLHC10d1,         
        kLHC10d2,         
        kLHC10d4a,        
        kLHC10d4,         
        kLHC10e12,        
        kLHC10e13,        
        kLHC10f6a,        
        kLHC10f6,         
        kLHC10e20,        
        kLHC10e21,        
        kLHC14j4,         
        kLHC14b7,         
        kLHC13d2,         
        kLHC13d2b,        
        kLHC12a11a,       
        kLHC12a11b,       
        kLHC12a11c,       
        kLHC12a11d,       
        kLHC12a11e,       
        kLHC12a11f,       

        // 2011
        kLHC11a,          
        kLHC11b,          
        kLHC11cg,         
        kLHC11h,          
        // MC's corresponding to 2011 data
        kLHC12a15c,       
        kLHC12f1a,        
        kLHC12f1b,        
        kLHC12i3,         
        kLHC15g1a,        
        kLHC15g1b,        
        kLHC13e4,         
        kLHC13e5,         
        kLHC14k1a,        
        kLHC14k1b,        
        kLHC12a15f,       
        kLHC12a15g,       
        kLHC12f2a,        
        kLHC14a1a,        
        kLHC14a1b,        
        kLHC14a1c,        

        // 2012
        kLHC12,           
        // MC's corresponding to 2012 data
        kLHC14e2b,        
        kLHC15h1,         
        kLHC15h2,         
        kLHC12P2JJ,       

        // 2013
        kLHC13bc,         
        kLHC13de,         
        kLHC13f,          
        kLHC13g,          
        // MC's corresponding to 2013 data
        kLHC13b2_efix,    
        kLHC13e7,         
        kLHC14b2,         
        kLHC13b4_fix,     
        kLHC13b4_plus,    
        kLHC16c3a,        
        kLHC16c3b,        
        kLHC16c3c,        
        kLHC15g2,         
        kLHC15a3a,        
        kLHC15a3a_plus,   
        kLHC15a3b,        
        kLHC15d3a,        
        kLHC15d3b,        
        // 2015
        kLHC15fm,         
        kLHC15n,          
        kLHC15o,          
        // MC's corresponding to 2015 data
        kLHC15g3a3,       
        kLHC15g3a,        
        kLHC15g3c2,       
        kLHC15g3c3,       
        kLHC15g3,         
        kLHC16a2a,        
        kLHC16a2b,        
        kLHC16a2c,        
        kLHC15P2EPos,     
        kLHC15P2Pyt8,     
        kLHC15l1a2,       
        kLHC15l1b2,       
        kLHC15k1a1,       
        kLHC15k1a2,       
        kLHC15k1a3,       
        kLHC16j7,         
        kLHC16g1,         
        kLHC16g1a,        
        kLHC16g1b,        
        kLHC16g1c,        
        kLHC16g2,         
        kLHC16g3,         
        kLHC16h4,         
        kLHC16i1a,        
        kLHC16i1b,        
        kLHC16i1c,        
        kLHC16i2a,        
        kLHC16i2b,        
        kLHC16i2c,        
        kLHC16i3a,        
        kLHC16i3b,        
        kLHC16i3c,        
        kLHC16h2a,        
        kLHC16h2b,        
        kLHC16h2c,        
        kLHC16h3,         
        kLHC16h8a,        
        kLHC16h8b,        
        kLHC16k3a,        
        kLHC16k3b,        
        kLHC16k3a2,       
        kLHC16k3b2,       
        kLHC16k5a,        
        kLHC16k5b,        
        kLHC17e2,         
        kLHC15k5a,        
        kLHC15k5b,        
        kLHC15k5c,        

        // MC upgrade
        kLHC13d19,        

        // 2016
        kLHC16NomB,         
        kLHC16LowB,         
        kLHC16qt,           
        kLHC16r,            
        kLHC16s,            
        // MC's corresponding to 2016 data
        kLHC16P1Pyt8,       
        kLHC16P1Pyt8LowB,   
        kLHC16P1EPOS,       
        kLHC16P1PHO,        
        kLHC16P1JJ,         
        kLHC16P1JJLowB,     
        kLHC17h8a,             
        kLHC17h8b,             
        kLHC17h8c,             
        kLHC17c3b1,            
        kLHC17c3a1,            
        kLHC17c3b2,            
        kLHC17c3a2,            

        //General purpose- pPb
        kLHC17a3a,            
        kLHC17a3b,            
        kLHC17a4a,            
        kLHC17a4b,            
        kLHC17f2a,            
        kLHC17f2b,            
        kLHC17g8a,            
        kLHC17f3a,            
        kLHC17f3b,            
        kLHC17f4a,            
        kLHC17f4b,            
        kLHC16rP1JJ,          
        kLHC16sP1JJ,          

        //heavy flavour MC pPb k17d2a_fast,
        kLHC17d2a,          
        kLHC17d2b,          

        // 2017
        kLHC17NomB,           
        kLHC17LowB,           
        kLHC17n,              
        kLHC17pq,             
        kLHC17j7,             
        kLHC17XeXeHi,         
        kLHC17l3b,            
        kLHC17l4b,            
        kLHC18b8,             
        kLHC17P1PHO,          
        //13 TeV LHC2017
        kLHC17k1,               
        kLHC17k4,               
        kLHC17h11,              
        kLHC17h7b,              
        kLHC17h7a,              
        kLHC17j5a,              
        kLHC17j5b,              
        kLHC17j5c,              
        kLHC17h1,               
        kLHC17h3,               
        kLHC17l5,               
        //13 TeV LHC2017 JJ
        kLHC17P1JJ,              
        kLHC17P1JJLowB,          
        kUnknownPeriod
      };

      enum EnergyVar {
        kUnset        = 0,   
        k900GeV       = 1,   
        k2760GeV      = 2,   
        k5TeV         = 3,   
        k7TeV         = 4,   
        k8TeV         = 5,   
        k13TeV        = 6,   
        k13TeVLowB    = 7,   
        kpPb5TeV      = 8,   
        kpPb8TeV      = 9,   
        kPbPb2760GeV  = 10,  
        kPbPb5TeV     = 11,  
        kXeXe5440GeV  = 12,  
        kpPb5TeVR2    = 13   

      };


      AliConvEventCuts(const char *name="EventCuts", const char * title="Event Cuts");
      AliConvEventCuts(const AliConvEventCuts&);
      AliConvEventCuts& operator=(const AliConvEventCuts&);

      virtual ~AliConvEventCuts();                            //virtual destructor

  //    static AliConvEventCuts * GetStandardCuts2010PbPb();
  //    static AliConvEventCuts * GetStandardCuts2010pp();

      Int_t     fCuts[kNCuts];
      Bool_t    UpdateCutString();
      static const char * fgkCutNames[kNCuts];

      // Setters
      Bool_t    SetCutIds (TString cutString);
      Bool_t    SetCut (cutIds cutID, Int_t cut);
      Bool_t    SetIsHeavyIon (Int_t isHeavyIon);
      Bool_t    SetCentralityMax (Int_t centralityBin);
      Bool_t    SetCentralityMin (Int_t centralityBin);
      Bool_t    SetRemovePileUp (Int_t removePileUp);
      Bool_t    SetMultiplicityMethod (Int_t multiplicityMethod);
      Bool_t    SetSelectSpecialTrigger (Int_t selectSpecialTrigger);
      Bool_t    SetSelectSubTriggerClass (Int_t selectSpecialSubTriggerClass);
      Bool_t    SetRejectExtraSignalsCut (Int_t extraSignal);
      Bool_t    SetVertexCut(Int_t vertexCut);
      void    SetPeriodEnum (TString periodName);
      void    SetPeriodEnumExplicit ( PeriodVar periodEnum )                        { fPeriodEnum = periodEnum                                  ; }
      void    SetCorrectionTaskSetting(TString setting)                             { fCorrTaskSetting = setting                                ; }
      void    SetTriggerMimicking(Bool_t value)                                     { fMimicTrigger = value                                     ;
                                                                                      if(value)AliInfo("enabled trigger mimicking")             ; }
      void    SetTriggerOverlapRejecion (Bool_t value)                              { fRejectTriggerOverlap = value                             ;
                                                                                      if(value)AliInfo("enabled trigger overlap rejection")     ; }

      void    SetV0ReaderName (TString name)                                        { fV0ReaderName = name                                      ; }

      void    SetAddedSignalPDGCode (Int_t addedSignalPDGcode)                      { fAddedSignalPDGCode = addedSignalPDGcode                  ; }
      void    SetPreSelectionCutFlag (Bool_t preSelFlag)                            { fPreSelCut = preSelFlag                                   ; }
      void    SetCaloTriggerPatchInfoName(const char *n)                            { fCaloTriggerPatchInfoName = n                             ; }
      void    SetCaloTriggersName(const char *n)                                    { fCaloTriggersName  = n                                    ; }
      void    SetAcceptedHeader(TList *HeaderList)                                  { fHeaderList = HeaderList                                  ; }
      void    SetFillCutHistograms( TString name="",
                                    Bool_t preCut = kTRUE)                          { if(!fHistograms){ InitCutHistograms(name,preCut);}        ; }
      void    SetEtaShift(Double_t etaShift)                                        { fEtaShift = etaShift                                      ; } // Eta shift Setting
      void    SetEtaShift(TString pPbOrPbp)                                         { Double_t etaShift = 0.0                                   ;
                                                                                      if(!pPbOrPbp.CompareTo("pPb"))      etaShift = -0.465     ;
                                                                                      else if(!pPbOrPbp.CompareTo("Pbp")) etaShift =  0.465     ;
                                                                                      fEtaShift = etaShift                                      ; }
  //    void GetHistoCentralityFlattening
      void    SetUseWeightFlatCentralityFromFile( Int_t doFlattening = 1,
                              TString pathC="$ALICE_PHYSICS/PWGGA/GammaConv/InterpValuesAndFlattening.root",
                              TString histoCentNotFlat="")
                                                                                    {
                                                                                      AliInfo(Form("enabled centrality flattening with weights from file: %s",pathC.Data()));
                                                                                      fDoCentralityFlat = doFlattening                          ;
                                                                                      fPathWeightsFlatCent=pathC                                ;
                                                                                      fNameHistoNotFlatCentrality = histoCentNotFlat            ;
                                                                                    }
      void    SetUseReweightingWithHistogramFromFile( Bool_t pi0reweight=kTRUE,
                                Bool_t etareweight=kFALSE,
                                Bool_t k0sreweight=kFALSE,
                                                              TString path="$ALICE_PHYSICS/PWGGA/GammaConv/MCSpectraInput.root",
                                TString histoNamePi0 = "",
                                TString histoNameEta = "",
                                TString histoNameK0s = "",
                                TString fitNamePi0 = "",
                                TString fitNameEta = "",
                                TString fitNameK0s ="" )
                                                                                    {
                                                                                      AliInfo(Form("enabled reweighting for: pi0 : %i, eta: %i, K0s: %i",pi0reweight, etareweight, k0sreweight));
                                                                                      fDoReweightHistoMCPi0 = pi0reweight                       ;
                                                                                      fDoReweightHistoMCEta = etareweight                       ;
                                                                                      fDoReweightHistoMCK0s = k0sreweight                       ;
                                                                                      fPathTrFReweighting=path                                  ;
                                                                                      fNameHistoReweightingPi0 =histoNamePi0                    ;
                                                                                      fNameHistoReweightingEta =histoNameEta                    ;
                                                                                      fNameHistoReweightingK0s =histoNameK0s                    ;
                                                                                      fNameFitDataPi0 =fitNamePi0                               ;
                                                                                      fNameFitDataEta =fitNameEta                               ;
                                                                                      fNameFitDataK0s =fitNameK0s                               ;
                                                                                    }
      void    SetUseWeightMultiplicityFromFile( Int_t doWeighting = 0,
                                                TString pathC="$ALICE_PHYSICS/PWGGA/GammaConv/MultiplicityInput.root",
                                                TString nameHistoMultData="",
                                                TString nameHistoMultMC=""
                                              )
                                                                                    {
                                                                                      AliInfo(Form("enabled multiplicity weights from file: %s",pathC.Data()));
                                                                                      fDoMultiplicityWeighting = doWeighting                    ;
                                                                                      fPathReweightingMult=pathC                                ;
                                                                                      fNameHistoReweightingMultData = nameHistoMultData         ;
                                                                                      fNameHistoReweightingMultMC = nameHistoMultMC             ;
                                                                                    }

      void    SetMaxFacPtHard(Float_t value)                                        { fMaxFacPtHard = value                                     ;
                                                                                      AliInfo(Form("maximum factor between pt hard and jet put to: %2.2f",fMaxFacPtHard));
                                                                                    }
      void    SetDebugLevel( Int_t value)                                           { fDebugLevel = value                                       ; }

      // Geters
      TString   GetCutNumber();
      TString*  GetFoundHeader()                                                    { return fGeneratorNames                                    ; }
      Int_t     GetEventQuality()                                                   { return fEventQuality                                      ; }
      Bool_t    GetIsFromPileup()                                                   { return fRemovePileUp                                      ; }
      Int_t     GetPastFutureLowBC()                                                { return fPastFutureRejectionLow                            ; }
      Int_t     GetPastFutureHighBC()                                               { return fPastFutureRejectionHigh                           ; }
      Bool_t    GetDoPileUpRejectV0MTPCout()                                        { return fDoPileUpRejectV0MTPCout                           ; }
      void      GetCentralityRange(Double_t range[2])                               { range[0]=10*fCentralityMin                                ;
                                                                                      range[1]=10*fCentralityMax                                ; }
      TList*    GetCutHistograms()                                                  { return fHistograms                                        ; }
      Int_t     GetMultiplicityMethod()                                             { return fMultiplicityMethod                                ; }
      Int_t     GetSignalRejection()                                                { return fRejectExtraSignals                                ; }
      Int_t     GetNAcceptedHeaders()                                               { return fnHeaders                                          ; }
      TString * GetAcceptedHeaderNames()                                            { return fGeneratorNames                                    ; }
      Int_t *   GetAcceptedHeaderStart()                                            { return fNotRejectedStart                                  ; }
      Int_t *   GetAcceptedHeaderEnd()                                              { return fNotRejectedEnd                                    ; }
      Int_t     GetAcceptedHeaderStart(Int_t headernumber)                          { if (headernumber < fnHeaders)
                                                                                        return fNotRejectedStart[headernumber]                  ;
                                                                                      else
                                                                                        return -1                                               ;
                                                                                    }
      Int_t     GetAcceptedHeaderEnd(Int_t headernumber)                            { if (headernumber < fnHeaders)
                                                                                        return fNotRejectedEnd[headernumber]                    ;
                                                                                      else
                                                                                        return -1                                               ;
                                                                                    }
      TList*    GetAcceptedHeader()                                                 { return fHeaderList                                        ; }
      Int_t     GetNumberOfContributorsVtx(AliVEvent *event);
      Double_t  GetEtaShift()                                                       { return fEtaShift                                          ; }
      Bool_t    GetDoEtaShift()                                                     { return fDoEtaShift                                        ; }
      TString   GetSpecialTriggerName()                                             { return fSpecialTriggerName                                ; }
      AliEMCALTriggerPatchInfo   *GetMainTriggerPatch();
      ULong_t   GetTriggerList();
      Float_t   GetWeightForCentralityFlattening(AliVEvent *event = 0x0);
      Float_t   GetWeightForMultiplicity(Int_t mult);
      Float_t   GetWeightForMeson( Int_t index, AliMCEvent *mcEvent, AliVEvent *event = 0x0);
      Float_t   GetCentrality(AliVEvent *event);
      Bool_t    GetUseNewMultiplicityFramework();
      void      GetCorrectEtaShiftFromPeriod();
      void      GetNotRejectedParticles(Int_t rejection, TList *HeaderList, AliVEvent *event);
      TClonesArray*     GetArrayFromEvent(AliVEvent* event, const char *name, const char *clname=0);

      Bool_t    InitializeCutsFromCutString(const TString analysisCutSelection);
      void      SelectCollisionCandidates(UInt_t offlineTriggerMask = AliVEvent::kAny) {
                                                                                      fOfflineTriggerMask = offlineTriggerMask                  ;
                                                                                      fTriggerSelectedManually = kTRUE                          ;
                                                                                    }
      void    SelectSpecialTrigger( UInt_t offlineTriggerMask = AliVEvent::kAny,
                                    TString TriggerClassName = "AliVEvent::kAny" ) {
                                                                                      fOfflineTriggerMask = offlineTriggerMask                  ;
                                                                                      fSpecialTriggerName = TriggerClassName                    ;
                                                                                      AliInfo(fSpecialTriggerName)                              ;

                                                                                    }

      PeriodVar GetPeriodEnum ()                                                    { return fPeriodEnum                                        ; }
      EnergyVar GetEnergyEnum ()                                                    { return fEnergyEnum                                        ; }
      virtual   Bool_t IsSelected(TObject* /*obj*/)                                 { return kTRUE                                              ; }
      virtual   Bool_t IsSelected(TList* /*list*/)                                  { return kTRUE                                              ; }


      // Cut Selection
      Bool_t    EventIsSelected(AliVEvent *fInputEvent,
                                AliMCEvent *fMCEvent);
      Int_t     IsEventAcceptedByCut( AliConvEventCuts *ReaderCuts,
                                      AliVEvent *event,
                                      AliMCEvent *mcEvent,
                                      Int_t isHeavyIon,
                                      Bool_t isEMCALAnalysis);

      void    PrintCuts();
      void    PrintCutsWithValues();
      void    InitCutHistograms(  TString name="",
                                  Bool_t preCut = kTRUE);
      void    SetLightOutput( Bool_t flag ){fDoLightOutput = flag; return;}

      Int_t   IsParticleFromBGEvent(  Int_t index,
                                      AliMCEvent *mcEvent,
                                      AliVEvent *event = 0x0,
                                      Int_t debug = 0
                                   );

      void    LoadWeightingFlatCentralityFromFile ();
      void    LoadWeightingMultiplicityFromFile ();
      void    LoadReweightingHistosMCFromFile ();

      // Event Cuts
      Bool_t    IsCentralitySelected(AliVEvent *event, AliMCEvent *mcEvent);
      Bool_t    IsOutOfBunchPileupPastFuture(AliVEvent *event);
      Bool_t    IsPileUpV0MTPCout(AliVEvent *event);
      Bool_t    VertexZCut(AliVEvent *event);
      Bool_t    IsJetJetMCEventAccepted(AliMCEvent *mcEvent, Double_t& weight, AliVEvent* event = 0x0);
      Float_t   GetPtHard(AliMCEvent *mcEvent, AliVEvent* event = 0x0);
      void      GetXSectionAndNTrials(AliMCEvent *mcEvent, Float_t &XSection, Float_t &NTrials, AliVEvent* event = 0x0 );
      Float_t   GetMaxPtJet()                                                       { return fMaxPtJetMC                                        ; }
      Bool_t    MimicTrigger( AliVEvent *event,
                              Bool_t isMC );
      Bool_t    IsTriggerSelected(  AliVEvent *event,
                                    Bool_t isMC);
      Bool_t    HasV0AND()                                                          { return fHasV0AND                                          ; }
      Bool_t    IsSDDFired()                                                        { return fIsSDDFired                                        ; }
      Int_t     IsSpecialTrigger()                                                  { return fSpecialTrigger                                    ; }
      Int_t     IsSpecialSubTrigger()                                               { return fSpecialSubTrigger                                 ; }
      void      InitializeEMCALTrigger( AliVEvent *event);
      Bool_t    HasTriggerType(TriggerTypeEMCAL t);

      // Request Flags
      Int_t     IsHeavyIon()                                                        { return fIsHeavyIon                                        ; }
      void      DoEtaShift(Bool_t doEtaShift)                                       { fDoEtaShift = doEtaShift                                  ; }

      //MC particle flags - determine whether particle is primary or secondary
      Bool_t    IsConversionPrimaryESD( AliMCEvent *mcEvent,
                                        Long_t eventpos,
                                        Double_t prodVtxX,
                                        Double_t prodVtxY,
                                        Double_t prodVtxZ);
      Bool_t    IsConversionPrimaryAOD( AliVEvent *event,
                                        AliAODMCParticle* AODMCParticle,
                                        Double_t prodVtxX,
                                        Double_t prodVtxY,
                                        Double_t prodVtxZ);

      Int_t     SecondaryClassificationPhoton(  TParticle *particle,
                                                AliMCEvent *mcEvent,
                                                Bool_t isConversion );
      Int_t     SecondaryClassificationPhotonAOD( AliAODMCParticle *particle,
                                                  TClonesArray *aodmcArray,
                                                  Bool_t isConversion );

    protected:
      TList*                      fHistograms;                            
      TList*                      fHeaderList;                            

      Bool_t                      fDoLightOutput;                         
      Int_t                       fEventQuality;                          
      //cuts
      Int_t                       fIsHeavyIon;                            
      Int_t                       fDetectorCentrality;                    
      Int_t                       fModCentralityClass;                    
      Bool_t                      fEnableVertexCut;                       
      Double_t                    fMaxVertexZ;                            
      Int_t                       fCentralityMin;                         
      Int_t                       fCentralityMax;                         
      Int_t                       fMultiplicityMethod;                    
      Int_t                       fSpecialTrigger;                        
      Int_t                       fSpecialSubTrigger;                     
      Bool_t                      fRemovePileUp;                          
      Int_t                       fPastFutureRejectionLow;                
      Int_t                       fPastFutureRejectionHigh;               
      Int_t                       fDoPileUpRejectV0MTPCout;               
      TF1 *                       fFPileUpRejectV0MTPCout;                
      Int_t                       fRejectExtraSignals;                    
      UInt_t                      fOfflineTriggerMask;                    
      Bool_t                      fHasV0AND;                              
      Bool_t                      fIsSDDFired;                            
      TRandom3                    fRandom;                                
      Int_t                       fnHeaders;                              
      Int_t*                      fNotRejectedStart;                      //[fnHeaders]
      Int_t*                      fNotRejectedEnd;                        //[fnHeaders]
      TString*                    fGeneratorNames;                        //[fnHeaders]
      PeriodVar                   fPeriodEnum;                            
      EnergyVar                   fEnergyEnum;                            

      TObjString*                 fCutString;                             
      TString                     fCutStringRead;                         
      AliAnalysisUtils*           fUtils;                                 
      Double_t                    fEtaShift;                              
      Bool_t                      fDoEtaShift;                            
      Int_t                       fDoCentralityFlat;                      
      TString                     fPathWeightsFlatCent;                   
      TString                     fNameHistoNotFlatCentrality;            
      Bool_t                      fDoReweightHistoMCPi0;                  
      Bool_t                      fDoReweightHistoMCEta;                  
      Bool_t                      fDoReweightHistoMCK0s;                  
      TString                     fPathTrFReweighting;                    
      TString                     fNameHistoReweightingPi0;               
      TString                     fNameHistoReweightingEta;               
      TString                     fNameHistoReweightingK0s;               
      TString                     fNameFitDataPi0;                        
      TString                     fNameFitDataEta;                        
      TString                     fNameFitDataK0s;                        
      // Histograms
      TH1F*                       fHistoEventCuts;                        
      TH1F*                       fHistoPastFutureBits;                   
      TH1F*                       hCentrality;                            
      TH1D*                       hCentralityNotFlat;                     
      //TH2F*                      hCentralityVsNumberOfPrimaryTracks;    ///< centrality distribution for selected events
      TH1F*                       hVertexZ;                               
      TH1F*                       hNPileupVertices;                       
      TH1F*                       hPileupVertexToPrimZ;                   
      TH1F*                       hPileupVertexToPrimZSPDPileup;          
      TH1F*                       hPileupVertexToPrimZTrackletvsHits;     
      TH1F*                       hEventPlaneAngle;                       
      Double_t                    fEventPlaneAngle;                       
      TH1F*                       hTriggerClass;                          
      TH1F*                       hTriggerClassSelected;                  
      TH1F*                       hTriggerClassesCorrelated;              
      TH1D*                       hReweightMCHistPi0;                     
      TH1D*                       hReweightMCHistEta;                     
      TH1D*                       hReweightMCHistK0s;                     
      TF1*                        fFitDataPi0;                            
      TF1*                        fFitDataEta;                            
      TF1*                        fFitDataK0s;                            
      Int_t                       fAddedSignalPDGCode;
      Bool_t                      fPreSelCut;                             // Flag for preselection cut used in V0Reader
      Bool_t                      fTriggerSelectedManually;               // Flag for manual trigger selection
      TString                     fSpecialTriggerName;                    // Name of the Special Triggers
      TString                     fSpecialSubTriggerName;                 // Name of the Special Triggers
      Int_t                       fNSpecialSubTriggerOptions;
      TH2F*                       hSPDClusterTrackletBackgroundBefore;    
      TH2F*                       hSPDClusterTrackletBackground;          
      // trigger information
      TString                     fV0ReaderName;                          
      TString                     fCorrTaskSetting;                       
      AliVCaloTrigger*            fCaloTriggers;                          
      TClonesArray*               fTriggerPatchInfo;                      
      AliEMCALTriggerPatchInfo *  fMainTriggerPatchEMCAL;                 
      TString                     fCaloTriggersName;                      
      TString                     fCaloTriggerPatchInfoName;              
      ULong_t                     fTriggersEMCAL;                         
      ULong_t                     fTriggersEMCALSelected;                 
      Bool_t                      fEMCALTrigInitialized;                  
      // Primary secondary distinction
      Double_t                    fSecProdBoundary;                       
      Float_t                     fMaxPtJetMC;                            
      Float_t                     fMaxFacPtHard;                          
      Float_t                     fMaxFacPtHardSingleParticle;            
      Bool_t                      fMimicTrigger;                          
      Bool_t                      fRejectTriggerOverlap;                  
      //
      Bool_t                      fDoMultiplicityWeighting;               
      TString                     fPathReweightingMult;                   
      TString                     fNameHistoReweightingMultData;          
      TString                     fNameHistoReweightingMultMC;            
      TH1D*                       hReweightMultData;                      
      TH1D*                       hReweightMultMC;                        
      Int_t                       fDebugLevel;                            
  private:

      ClassDef(AliConvEventCuts,49)
};


#endif