AliAnalysisTaskGammaCalo.h

Go to the documentation of this file.

#ifndef ALIANLYSISTASKGAMMACALO_cxx
#define ALIANLYSISTASKGAMMACALO_cxx

#include "AliAnalysisTaskSE.h"
#include "AliESDtrack.h"
#include "AliV0ReaderV1.h"
#include "AliKFConversionPhoton.h"
#include "AliGammaConversionAODBGHandler.h"
#include "AliConversionAODBGHandlerRP.h"
#include "AliCaloPhotonCuts.h"
#include "AliConvEventCuts.h"
#include "AliConversionPhotonCuts.h"
#include "AliConversionMesonCuts.h"
#include "AliAnalysisManager.h"
#include "TProfile2D.h"
#include "TH3.h"
#include "TH3F.h"
#include <vector>
#include <map>

class AliAnalysisTaskGammaCalo : public AliAnalysisTaskSE {
  public:

    AliAnalysisTaskGammaCalo();
    AliAnalysisTaskGammaCalo(const char *name);
    virtual ~AliAnalysisTaskGammaCalo();

    virtual void   UserCreateOutputObjects();
    virtual Bool_t Notify();
    virtual void   UserExec(Option_t *);
    virtual void   Terminate(const Option_t*);
    void InitBack();

    void SetV0ReaderName(TString name){fV0ReaderName=name; return;}
    void SetIsHeavyIon(Int_t flag){
      fIsHeavyIon = flag;
    }

    // base functions for selecting photon and meson candidates in reconstructed data
    void ProcessClusters();
    void CalculatePi0Candidates();

    // MC functions
    void SetIsMC(Int_t isMC){fIsMC=isMC;}
    void ProcessMCParticles();
    void ProcessAODMCParticles();
    void ProcessTrueClusterCandidates( AliAODConversionPhoton* TruePhotonCandidate, AliVCluster* clus);
    void ProcessTrueClusterCandidatesAOD( AliAODConversionPhoton* TruePhotonCandidate, AliVCluster* clus);
    void ProcessTrueMesonCandidates( AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);
    void ProcessTrueMesonCandidatesAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);

    // switches for additional analysis streams or outputs
    void SetLightOutput(Bool_t flag){fDoLightOutput = flag;}
    void SetDoMesonAnalysis(Bool_t flag){fDoMesonAnalysis = flag;}
    void SetDoMesonQA(Int_t flag){fDoMesonQA = flag;}
    void SetDoClusterQA(Int_t flag){fDoClusterQA = flag;}
    void SetDoTHnSparse(Bool_t flag){fDoTHnSparse = flag;}
    void SetPlotHistsExtQA(Bool_t flag){fSetPlotHistsExtQA = flag;}
    void SetAllowOverlapHeaders( Bool_t allowOverlapHeader ) {fAllowOverlapHeaders = allowOverlapHeader;}

    void SetInOutTimingCluster(Double_t min, Double_t max){
      fDoInOutTimingCluster = kTRUE; fMinTimingCluster = min; fMaxTimingCluster = max;
      return;
    }

      // Setting the cut lists for the conversion photons
    void SetEventCutList(Int_t nCuts, TList *CutArray){
      fnCuts = nCuts;
      fEventCutArray = CutArray;
    }

      // Setting the cut lists for the calo photons
    void SetCaloCutList(Int_t nCuts, TList *CutArray){
      fnCuts = nCuts;
      fClusterCutArray = CutArray;
    }

    // Setting the cut lists for the meson
    void SetMesonCutList(Int_t nCuts, TList *CutArray){
      fnCuts = nCuts;
      fMesonCutArray = CutArray;
    }

    // BG HandlerSettings
    void CalculateBackground();
    void CalculateBackgroundRP();
    void RotateParticle(AliAODConversionPhoton *gamma);
    void RotateParticleAccordingToEP(AliAODConversionPhoton *gamma, Double_t previousEventEP, Double_t thisEventEP);
    void FillPhotonBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode);
    void FillPhotonPlusConversionBackgroundHist(AliAODConversionPhoton *TruePhotonCandidate, Int_t pdgCode);
    void FillPhotonBackgroundM02Hist(AliAODConversionPhoton *TruePhotonCandidate, AliVCluster* clus, Int_t pdgCode);
    void FillPhotonPlusConversionBackgroundM02Hist(AliAODConversionPhoton *TruePhotonCandidate, AliVCluster* clus, Int_t pdgCode);
    void UpdateEventByEventData();

    // Additional functions for convenience
    void SetLogBinningXTH2(TH2* histoRebin);
    Int_t GetSourceClassification(Int_t daughter, Int_t pdgCode);

    Bool_t CheckVectorForDoubleCount(vector<Int_t> &vec, Int_t tobechecked);
    void FillMultipleCountMap(map<Int_t,Int_t> &ma, Int_t tobechecked);
    void FillMultipleCountHistoAndClear(map<Int_t,Int_t> &ma, TH1F* hist);

    // set method to enable EOverP tree
    void SetProduceTreeEOverP(Bool_t b){fProduceTreeEOverP = b;}

    // Function to enable MC label sorting
    void SetEnableSortingOfMCClusLabels(Bool_t enableSort)  { fEnableSortForClusMC   = enableSort; }

    // Function to enable local debugging mode
    void SetLocalDebugFlag(Int_t iF) {fLocalDebugFlag = iF;}

    void EventDebugMethod();
    void DebugMethod(AliAODConversionMother *pi0cand, AliAODConversionPhoton *gamma0, AliAODConversionPhoton *gamma1);
    void DebugMethodPrint1(AliAODConversionMother *pi0cand, AliAODConversionPhoton *gamma0, AliAODConversionPhoton *gamma1);

  protected:
    AliV0ReaderV1*        fV0Reader;                                            // basic photon Selection Task
    TString               fV0ReaderName;
    AliGammaConversionAODBGHandler**  fBGHandler;                               // BG handler for Conversion
    AliVEvent*            fInputEvent;                                          // current event
    AliMCEvent*           fMCEvent;                                             // corresponding MC event
    TList**               fCutFolder;                                           // Array of lists for containers belonging to cut
    TList**               fESDList;                                             // Array of lists with histograms with reconstructed properties
    TList**               fBackList;                                            // Array of lists with BG THnSparseF
    TList**               fMotherList;                                          // Array of lists with Signal THnSparseF
    TList**               fTrueList;                                            // Array of lists with histograms with MC validated reconstructed properties
    TList**               fMCList;                                              // Array of lists with histograms with pure MC information
    TList**               fTreeList;                                            // Array of lists with tree for validated MC
    TList**               fClusterTreeList;                                     // Array of lists with tree for EoverP
    TList*                fOutputContainer;                                     // Output container
    TList*                fClusterCandidates;                                   
    TList*                fEventCutArray;                                       // List with Event Cuts
    AliConvEventCuts*     fEventCuts;                                           // EventCutObject
    TList*                fClusterCutArray;                                     // List with Cluster Cuts
    AliCaloPhotonCuts*    fCaloPhotonCuts;                                      // CaloPhotonCutObject
    TList*                fMesonCutArray;                                       // List with Meson Cuts
    AliConversionMesonCuts*   fMesonCuts;                                       // MesonCutObject

    //histograms for mesons reconstructed quantities
    TH2F**                fHistoMotherInvMassPt;                                
    THnSparseF**          fSparseMotherInvMassPtZM;                             
    TH2F**                fHistoMotherBackInvMassPt;                            
    THnSparseF**          fSparseMotherBackInvMassPtZM;                         
    TH2F**                fHistoMotherInvMassPtAlpha;                           
    TH2F**                fHistoMotherBackInvMassPtAlpha;                       
    TH2F**                fHistoMotherPi0PtY;                                   
    TH2F**                fHistoMotherEtaPtY;                                   
    TH2F**                fHistoMotherPi0PtAlpha;                               
    TH2F**                fHistoMotherEtaPtAlpha;                               
    TH2F**                fHistoMotherPi0PtOpenAngle;                           
    TH2F**                fHistoMotherEtaPtOpenAngle;                           
    TH2F**                fHistoMotherPi0NGoodESDTracksPt;                 
    TH2F**                fHistoMotherEtaNGoodESDTracksPt;                 

    // histograms for rec photon clusters
    TH1F**                fHistoClusGammaPt;                                    
    TH1F**                fHistoClusGammaE;                                     
    TH1F**                fHistoClusOverlapHeadersGammaPt;                      
    TH1F**                fHistoClusAllHeadersGammaPt;                          
    TH1F**                fHistoClusRejectedHeadersGammaPt;                     
    TH2F**                fHistoClusGammaPtM02;                                 
    //histograms for pure MC quantities
    TH1I**                fHistoMCHeaders;                                      
    TH1F**                fHistoMCAllGammaPt;                                   
    TH2F**                fHistoMCAllSecondaryGammaPt;                          
    TH1F**                fHistoMCDecayGammaPi0Pt;                              
    TH1F**                fHistoMCDecayGammaRhoPt;                              
    TH1F**                fHistoMCDecayGammaEtaPt;                              
    TH1F**                fHistoMCDecayGammaOmegaPt;                            
    TH1F**                fHistoMCDecayGammaEtapPt;                             
    TH1F**                fHistoMCDecayGammaPhiPt;                              
    TH1F**                fHistoMCDecayGammaSigmaPt;                            
    TH1F**                fHistoMCPi0Pt;                                        
    TH1F**                fHistoMCPi0WOWeightPt;                                
    TH1F**                fHistoMCPi0WOEvtWeightPt;                             
    TH1F**                fHistoMCEtaPt;                                        
    TH1F**                fHistoMCEtaWOWeightPt;                                
    TH1F**                fHistoMCEtaWOEvtWeightPt;                             
    TH1F**                fHistoMCPi0InAccPt;                                   
    TH1F**                fHistoMCEtaInAccPt;                                   
    TH1F**                fHistoMCPi0WOEvtWeightInAccPt;                        
    TH1F**                fHistoMCEtaWOEvtWeightInAccPt;                        
    TH2F**                fHistoMCPi0PtY;                                       
    TH2F**                fHistoMCEtaPtY;                                       
    TH2F**                fHistoMCPi0PtAlpha;                                   
    TH2F**                fHistoMCEtaPtAlpha;                                   
    TH2F**                fHistoMCPrimaryPtvsSource;                            
    TH2F**                fHistoMCSecPi0PtvsSource;                             
    TH1F**                fHistoMCSecPi0Source;                                 
    TH2F**                fHistoMCSecPi0InAccPtvsSource;                        
    TH1F**                fHistoMCSecEtaPt;                                     
    TH1F**                fHistoMCSecEtaSource;                                 
    TH2F**                fHistoMCPi0PtJetPt;                                   
    TH2F**                fHistoMCEtaPtJetPt;                                   

    // MC validated reconstructed quantities mesons
    TH2F**                fHistoTruePi0InvMassPt;                               
    TH2F**                fHistoTrueEtaInvMassPt;                               
    TH2F**                fHistoTruePi0CaloPhotonInvMassPt;                     
    TH2F**                fHistoTrueEtaCaloPhotonInvMassPt;                     
    TH2F**                fHistoTruePi0CaloConvertedPhotonInvMassPt;            
    TH2F**                fHistoTrueEtaCaloConvertedPhotonInvMassPt;            
    TH2F**                fHistoTruePi0CaloMixedPhotonConvPhotonInvMassPt;      
    TH2F**                fHistoTrueEtaCaloMixedPhotonConvPhotonInvMassPt;      
    TH2F**                fHistoTruePi0CaloElectronInvMassPt;                   
    TH2F**                fHistoTrueEtaCaloElectronInvMassPt;                   
    TH2F**                fHistoTruePi0CaloMergedClusterInvMassPt;              
    TH2F**                fHistoTrueEtaCaloMergedClusterInvMassPt;              
    TH2F**                fHistoTruePi0CaloMergedClusterPartConvInvMassPt;      
    TH2F**                fHistoTrueEtaCaloMergedClusterPartConvInvMassPt;      
    TH2F**                fHistoTruePi0NonMergedElectronPhotonInvMassPt;        
    TH2F**                fHistoTruePi0NonMergedElectronMergedPhotonInvMassPt;  
    TH2F**                fHistoTruePi0Category1;                               
    TH2F**                fHistoTrueEtaCategory1;                               
    TH2F**                fHistoTruePi0Category2;                               
    TH2F**                fHistoTrueEtaCategory2;                               
    TH2F**                fHistoTruePi0Category3;                               
    TH2F**                fHistoTrueEtaCategory3;                               
    TH2F**                fHistoTruePi0Category4_6;                             
    TH2F**                fHistoTrueEtaCategory4_6;                             
    TH2F**                fHistoTruePi0Category5;                               
    TH2F**                fHistoTrueEtaCategory5;                               
    TH2F**                fHistoTruePi0Category7;                               
    TH2F**                fHistoTrueEtaCategory7;                               
    TH2F**                fHistoTruePi0Category8;                               
    TH2F**                fHistoTrueEtaCategory8;                               
    TH2F**                fHistoTruePrimaryPi0InvMassPt;                        
    TH2F**                fHistoTruePrimaryEtaInvMassPt;                        
    TH2F**                fHistoTruePrimaryPi0W0WeightingInvMassPt;             
    TH2F**                fHistoTruePrimaryEtaW0WeightingInvMassPt;             
    TProfile2D**          fProfileTruePrimaryPi0WeightsInvMassPt;               
    TProfile2D**          fProfileTruePrimaryEtaWeightsInvMassPt;               
    TH2F**                fHistoTruePrimaryPi0MCPtResolPt;                      
    TH2F**                fHistoTruePrimaryEtaMCPtResolPt;                      
    TH2F**                fHistoTrueSecondaryPi0InvMassPt;                      
    TH2F**                fHistoTrueSecondaryPi0FromK0sInvMassPt;               
    TH1F**                fHistoTrueK0sWithPi0DaughterMCPt;                     
    TH2F**                fHistoTrueSecondaryPi0FromK0lInvMassPt;               
    TH1F**                fHistoTrueK0lWithPi0DaughterMCPt;                     
    TH2F**                fHistoTrueSecondaryPi0FromEtaInvMassPt;               
    TH1F**                fHistoTrueEtaWithPi0DaughterMCPt;                     
    TH2F**                fHistoTrueSecondaryPi0FromLambdaInvMassPt;            
    TH1F**                fHistoTrueLambdaWithPi0DaughterMCPt;                  
    TH2F**                fHistoTrueBckGGInvMassPt;                             
    TH2F**                fHistoTrueBckFullMesonContainedInOneClusterInvMassPt; 
    TH2F**                fHistoTrueBckAsymEClustersInvMassPt;                  
    TH2F**                fHistoTrueBckContInvMassPt;                           
    TH2F**                fHistoTruePi0PtY;                                     
    TH2F**                fHistoTrueEtaPtY;                                     
    TH2F**                fHistoTruePi0PtAlpha;                                 
    TH2F**                fHistoTrueEtaPtAlpha;                                 
    TH2F**                fHistoTruePi0PtOpenAngle;                             
    TH2F**                fHistoTrueEtaPtOpenAngle;                             
    // MC validated reconstructed quantities photons
    TH2F**                fHistoClusPhotonBGPt;                                 
    TH2F**                fHistoClusPhotonPlusConvBGPt;                         
    TH2F**                fHistoClustPhotonElectronBGPtM02;                     
    TH2F**                fHistoClustPhotonPionBGPtM02;                         
    TH2F**                fHistoClustPhotonKaonBGPtM02;                         
    TH2F**                fHistoClustPhotonK0lBGPtM02;                          
    TH2F**                fHistoClustPhotonNeutronBGPtM02;                      
    TH2F**                fHistoClustPhotonRestBGPtM02;                         
    TH2F**                fHistoClustPhotonPlusConvElectronBGPtM02;             
    TH2F**                fHistoClustPhotonPlusConvPionBGPtM02;                 
    TH2F**                fHistoClustPhotonPlusConvKaonBGPtM02;                 
    TH2F**                fHistoClustPhotonPlusConvK0lBGPtM02;                  
    TH2F**                fHistoClustPhotonPlusConvNeutronBGPtM02;              
    TH2F**                fHistoClustPhotonPlusConvRestBGPtM02;                 
    TH1F**                fHistoTrueClusGammaPt;                                
    TH1F**                fHistoTrueClusUnConvGammaPt;                          
    TH1F**                fHistoTrueClusUnConvGammaMCPt;                        
    TH2F**                fHistoTrueClusGammaPtM02;                             
    TH2F**                fHistoTrueClusUnConvGammaPtM02;                       
    TH1F**                fHistoTrueClusElectronPt;                             
    TH1F**                fHistoTrueClusConvGammaPt;                            
    TH1F**                fHistoTrueClusConvGammaMCPt;                          
    TH1F**                fHistoTrueClusConvGammaFullyPt;                       
    TH1F**                fHistoTrueClusMergedGammaPt;                          
    TH1F**                fHistoTrueClusMergedPartConvGammaPt;                  
    TH1F**                fHistoTrueClusDalitzPt;                               
    TH1F**                fHistoTrueClusDalitzMergedPt;                         
    TH1F**                fHistoTrueClusPhotonFromElecMotherPt;                 
    TH1F**                fHistoTrueClusShowerPt;                               
    TH1F**                fHistoTrueClusSubLeadingPt;                           
    TH1F**                fHistoTrueClusNParticles;                             
    TH1F**                fHistoTrueClusEMNonLeadingPt;                         
    TH1F**                fHistoTrueNLabelsInClus;                              
    TH1F**                fHistoTruePrimaryClusGammaPt;                         
    TH2F**                fHistoTruePrimaryClusGammaESDPtMCPt;                  
    TH1F**                fHistoTruePrimaryClusConvGammaPt;                     
    TH2F**                fHistoTruePrimaryClusConvGammaESDPtMCPt;              
    TH2F**                fHistoTrueSecondaryClusGammaPt;                       
    TH2F**                fHistoTrueSecondaryClusConvGammaPt;                   
    TH2F**                fHistoTrueSecondaryClusGammaMCPt;                     
    TH2F**                fHistoTrueSecondaryClusConvGammaMCPt;                 
    TH2F**                fHistoTrueSecondaryClusGammaFromXFromK0sMCPtESDPt;        
    TH2F**                fHistoTrueSecondaryClusConvGammaFromXFromK0sMCPtESDPt;    
    TH2F**                fHistoTrueSecondaryClusGammaFromXFromK0lMCPtESDPt;        
    TH2F**                fHistoTrueSecondaryClusConvGammaFromXFromK0lMCPtESDPt;    
    TH2F**                fHistoTrueSecondaryClusGammaFromXFromLambdaMCPtESDPt;     
    TH2F**                fHistoTrueSecondaryClusConvGammaFromXFromLambdaMCPtESDPt; 
    TH2F**                fHistoDoubleCountTruePi0InvMassPt;                    
    TH2F**                fHistoDoubleCountTrueEtaInvMassPt;                    
    TH2F**                fHistoDoubleCountTrueClusterGammaPt;                  
    vector<Int_t>         fVectorDoubleCountTruePi0s;                           
    vector<Int_t>         fVectorDoubleCountTrueEtas;                           
    vector<Int_t>         fVectorDoubleCountTrueClusterGammas;                  
    TH1F**                fHistoMultipleCountTrueClusterGamma;                  
    map<Int_t,Int_t>      fMapMultipleCountTrueClusterGammas;                   
    TH2F**                fHistoTruePi0InvMassPtAlpha;                          
    TH2F**                fHistoTruePi0PureGammaInvMassPtAlpha;                 
    TH2F**                fHistCellIDvsClusterEnergy;                           
    TH2F**                fHistCellIDvsClusterEnergyMax;                        

    // event histograms
    TH1F**                fHistoNEvents;                                        
    TH1F**                fHistoNEventsWOWeight;                                
    TH1F**                fHistoNGoodESDTracks;                                 
    TH1F**                fHistoVertexZ;                                        
    TH1F**                fHistoNGammaCandidates;                               
    TH2F**                fHistoNGoodESDTracksVsNGammaCandidates;               
    TH2F**                fHistoSPDClusterTrackletBackground;                   
    TH1F**                fHistoNV0Tracks;                                      
    TProfile**            fProfileEtaShift;                                     
    TProfile**            fProfileJetJetXSection;                               
    TH1F**                fHistoJetJetNTrials;                                  

    // tree for identified particle properties
    TTree**               tTrueInvMassROpenABPtFlag;                            
    Float_t               fInvMass;                                             
    Float_t               fRconv;                                               
    Float_t               fOpenRPrim;                                           
    Float_t               fInvMassRTOF;                                         
    Float_t               fPt;                                                  
    UChar_t               iFlag;                                                

    // tree for alpha/opening angle studies
    TTree**               tSigInvMassPtAlphaTheta;                              
    TTree**               tBckInvMassPtAlphaTheta;                              
    Float_t               fInvMassTreeInvMass;
    Float_t               fInvMassTreePt;
    Float_t               fInvMassTreeAlpha;
    Float_t               fInvMassTreeTheta;
    Int_t                 fInvMassTreeMixPool;
    Float_t               fInvMassTreeZVertex;
    Float_t               fInvMassTreeEta;

    // tree for E/p studies
    TTree**               tClusterEOverP;                                       
    Float_t               fClusterE;                                            
    Float_t               fClusterM02;                                          
    Float_t               fClusterM20;                                          
    Float_t               fClusterEP;                                           
    Int_t                 fClusterLeadCellID;                                   
    Int_t                 fClusterClassification;                               
    Float_t               fDeltaEta;                                            
    Float_t               fDeltaPhi;                                            
    Float_t               fTrackPt;                                             
    Int_t                 fTrackPID_e;                                          
    Int_t                 fTrackPID_Pi;                                         
    Int_t                 fTrackPID_K;                                          
    Int_t                 fTrackPID_P;                                          
    Float_t               fClusterIsoSumClusterEt;                              
    Float_t               fClusterIsoSumTrackEt;                                

    // hists for nonlineartiy calibration
//    TH2F**                fHistoTruePi0NonLinearity;                            //! E_truth/E_rec vs E_rec for TruePi0s
//    TH2F**                fHistoTrueEtaNonLinearity;                            //! E_truth/E_rec vs E_rec for TrueEtas

    // additional variables
    Double_t              fEventPlaneAngle;                                     // EventPlaneAngle
    TRandom3              fRandom;                                              // random
    Int_t                 fnCuts;                                               // number of cuts to be analysed in parallel
    Int_t                 fiCut;                                                // current cut
    Int_t                 fIsHeavyIon;                                          // switch for pp = 0, PbPb = 1, pPb = 2
    Bool_t                fDoLightOutput;                                       // switch for running light output, kFALSE -> normal mode, kTRUE -> light mode
    Bool_t                fDoMesonAnalysis;                                     // flag for meson analysis
    Int_t                 fDoMesonQA;                                           // flag for meson QA
    Int_t                 fDoClusterQA;                                         // flag for cluster QA
    Bool_t                fIsFromDesiredHeader;                                 // flag for MC headers
    Bool_t                fIsOverlappingWithOtherHeader;                        // flag for particles in MC overlapping between headers
    Int_t                 fIsMC;                                                // flag for MC information
    Bool_t                fDoTHnSparse;                                         // flag for using THnSparses for background estimation
    Bool_t                fSetPlotHistsExtQA;                                   // flag for extended QA hists
    Double_t              fWeightJetJetMC;                                      // weight for Jet-Jet MC
    Bool_t                fDoInOutTimingCluster;                                // manual timing cut for cluster to combine cluster within timing cut and without
    Double_t              fMinTimingCluster;                                    // corresponding ranges, min
    Double_t              fMaxTimingCluster;                                    // corresponding ranges, max
    Bool_t                fEnableSortForClusMC;                                 // switch on sorting for MC labels in cluster
    Bool_t                fProduceCellIDPlots;                                  // switch to produce CellID plots for fDoClusterQA==2
    Bool_t                fProduceTreeEOverP;                                   // flag for producing tree for E/p studies
    TTree*                tBrokenFiles;                                         // tree for keeping track of broken files
    TObjString*           fFileNameBroken;                                      // string object for broken file name
    TTree*                tClusterQATree;                                       // tree for specific cluster QA
    TObjString*           fCloseHighPtClusters;                                 // file name to indicate clusters with high pT (>15 GeV/c) very close to each other (<17 mrad)

    Int_t                 fLocalDebugFlag;                                      // debug flag for local running, must be '0' for grid running
    Bool_t                fAllowOverlapHeaders;                                 // enable overlapping headers for cluster selection

  private:
    AliAnalysisTaskGammaCalo(const AliAnalysisTaskGammaCalo&);                  // Prevent copy-construction
    AliAnalysisTaskGammaCalo &operator=(const AliAnalysisTaskGammaCalo&);       // Prevent assignment

    ClassDef(AliAnalysisTaskGammaCalo, 42);
};

#endif