AliAnalysisTaskGammaPureMC.h

Go to the documentation of this file.

#ifndef ALIANLYSISTASKGAMMAPUREMC_cxx
#define ALIANLYSISTASKGAMMAPUREMC_cxx

#include "AliAnalysisTaskSE.h"
#include "AliAnalysisManager.h"

class AliAnalysisTaskGammaPureMC : public AliAnalysisTaskSE {
  public:
    enum AcceptanceType_t {
      kPCMAcceptance = 1,       
      kEMCALAcceptance = 2,     
      kPHOSAcceptance = 3       
    };

    enum SupportedPdg_t {
      kPdgPi0 = 111,           
      kPdgRho0 = 113,          
      kPdgK0Long = 130,        
      kPdgPiPlus = 211,        
      kPdgPiMinus = -211,      
      kPdgRhoPlus = 213,       
      kPdgRhoMinus = -213,     
      kPdgEta = 221,           
      kPdgOmega = 223,         
      kPdgK0Short = 310,       
      kPdgKStar = 313,         
      kPdgKPlus = 321,         
      kPdgKMinus = -321,       
      kPdgEtaPrime = 331,      
      kPdgPhi = 333,           
      kPdgJPsi = 443,          
      kPdgDeltaMinus = 1114,   
      kPdgDelta0 = 2114,       
      kPdgDeltaPlus = 2214,    
      kPdgDeltaPlusPlus = 2224,
      kPdgSigmaMinus = 3112,   
      kPdgSigma0 = 3212,       
      kPdgLambda = 3122,       
      kPdgSigmaPlus = 3222,    
      kPdgXiMinus = 3312,      
      kPdgXi0 = 3322           
    };

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

    virtual void   UserCreateOutputObjects();
    virtual void   UserExec(Option_t *);
    virtual void   Terminate(const Option_t*);

    // MC functions
    void SetIsMC(Int_t isMC){fIsMC=isMC;}
    void ProcessMCParticles();
    bool IsInPCMAcceptance(TParticle* part) const;
    bool IsInPHOSAcceptance(TParticle* part) const;
    bool IsInEMCalAcceptance(TParticle* part) const;
    
    // additional functions
    void SetLogBinningXTH1(TH1* histoRebin);
    void SetLogBinningXTH2(TH2* histoRebin);
    void SetIsK0(Int_t isK0){fIsK0 = isK0;}
    
  protected:
    AliStack*             fMCStack;                   
    TList*                fOutputContainer;           
    // histograms events
    TH1F*                 fHistNEvents;               
    TH1D*                 fHistXSection;              
    TH1F*                 fHistPtHard;                
    // histograms mesons
    TH2F*                 fHistPtYPi0;                
    TH2F*                 fHistPtYPiPl;               
    TH2F*                 fHistPtYPiMi;               
    TH2F*                 fHistPtYEta;                
    TH2F*                 fHistPtYEtaPrim;            
    TH2F*                 fHistPtYOmega;              
    TH2F*                 fHistPtYRho0;               
    TH2F*                 fHistPtYRhoPl;              
    TH2F*                 fHistPtYRhoMi;              
    TH2F*                 fHistPtYPhi;                
    TH2F*                 fHistPtYJPsi;               
    TH2F*                 fHistPtYSigma0;             
    TH2F*                 fHistPtYK0s;                
    TH2F*                 fHistPtYK0l;                
    TH2F*                 fHistPtYK0star;             
    TH2F*                 fHistPtYDeltaPlPl;          
    TH2F*                 fHistPtYDeltaPl;            
    TH2F*                 fHistPtYDeltaMi;            
    TH2F*                 fHistPtYDelta0;             
    TH2F*                 fHistPtYLambda;             

    TH2F*                 fHistPtYPi0FromEta;         
    TH2F*                 fHistPtYPi0FromLambda;      
    TH2F*                 fHistPtYPi0FromK;           
    TH2F*                 fHistPtYPiPlFromK;          
    TH2F*                 fHistPtYPiMiFromK;          
    TH2F*                 fHistPtYPi0GG;              
    TH2F*                 fHistPtYPi0GGPCMAcc;        
    TH2F*                 fHistPtYPi0GGEMCAcc;        
    TH2F*                 fHistPtYPi0GGPHOAcc;        
    TH2F*                 fHistPtYPi0GGPCMEMCAcc;     
    TH2F*                 fHistPtYPi0GGPCMPHOAcc;     
    TH2F*                 fHistPtAlphaPi0GGPCMAcc;    
    TH2F*                 fHistPtAlphaPi0GGEMCAcc;    
    TH2F*                 fHistPtAlphaPi0GGPHOAcc;    
    TH2F*                 fHistPtAlphaPi0GGPCMEMCAcc; 
    TH2F*                 fHistPtAlphaPi0GGPCMPHOAcc; 

    TH2F*                 fHistPtYEtaGG;              
    TH2F*                 fHistPtYEtaGGPCMAcc;        
    TH2F*                 fHistPtYEtaGGEMCAcc;        
    TH2F*                 fHistPtYEtaGGPHOAcc;        
    TH2F*                 fHistPtYEtaGGPCMEMCAcc;     
    TH2F*                 fHistPtYEtaGGPCMPHOAcc;     
    TH2F*                 fHistPtAlphaEtaGGPCMAcc;    
    TH2F*                 fHistPtAlphaEtaGGEMCAcc;    
    TH2F*                 fHistPtAlphaEtaGGPHOAcc;    
    TH2F*                 fHistPtAlphaEtaGGPCMEMCAcc; 
    TH2F*                 fHistPtAlphaEtaGGPCMPHOAcc; 

    TH2F*                 fHistPtYEtaPrimGG;          
    TH2F*                 fHistPtYEtaPrimGGPCMAcc;    
    TH2F*                 fHistPtYEtaPrimGGEMCAcc;    
    TH2F*                 fHistPtYEtaPrimGGPHOAcc;    
    TH2F*                 fHistPtYEtaPrimGGPCMEMCAcc; 
    TH2F*                 fHistPtYEtaPrimGGPCMPHOAcc; 

    TH2F*                 fHistPtYPi0FromKGG;         
    TH2F*                 fHistPtYPi0FromKGGPCMAcc;   
    TH2F*                 fHistPtYPi0FromKGGEMCAcc;   
    TH2F*                 fHistPtYPi0FromKGGPCMEMCAcc;
    TH2F*                 fHistPtYPi0FromKGGEMCPCMAcc;
    TH2F*                 fHistPtYPi0FromKGGEMCAccSamePi0;
    TH2F*                 fHistPtYPi0FromKGGEMCAccDiffPi0;
    
    
  Int_t         fIsK0;            // k0 flag    
    Int_t                 fIsMC;                      // MC flag

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

    ClassDef(AliAnalysisTaskGammaPureMC, 1);
};

#endif