AliAnalysisTaskSELambdacTMVA.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKSELAMBDACTMVA_H
#define ALIANALYSISTASKSELAMBDACTMVA_H

/* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */ 

//*************************************************************************
//*************************************************************************

#include <TROOT.h>
#include <TSystem.h>
#include <TNtuple.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TArrayD.h>

#include "AliAnalysisTaskSE.h"
#include "AliAnalysisVertexingHF.h"
#include "AliAODMCParticle.h"
#include "AliRDHFCutsLctopKpi.h"
#include "AliRDHFCuts.h"
#include "TClonesArray.h"
//#include "AliAODpidUtil.h"
#include "AliPIDResponse.h"
#include "AliNormalizationCounter.h"
#include "AliVertexingHFUtils.h"

class AliAnalysisTaskSELambdacTMVA : public AliAnalysisTaskSE
{
  enum {
    kGeneratedLimAcc = 0,
    kGeneratedAll = 1,
    kGenerated = 2,
    kGeneratedAcc = 3,
    kReco3Prong = 4,
    kLcBit = 5,
    kIsSelectedTracks = 6,
    kIsInFidAcc = 7,
    kPtRange = 8,
    kIsSelectedCandidate = 9,
    kIsSelectedPID = 10,
    kIsSelectedNtuple = 11 
  };  

 public:

  AliAnalysisTaskSELambdacTMVA();
  AliAnalysisTaskSELambdacTMVA(const char *name, Int_t fillNtuple,AliRDHFCutsLctopKpi *lccutsana);
  virtual ~AliAnalysisTaskSELambdacTMVA();

  void SetKeepLcNotFromQuark(Bool_t keep = kTRUE) {fKeepLcNotFromQuark = keep;}
  void SetReadMC(Bool_t readMC=kTRUE){fReadMC=readMC;}
  void SetMCPid(){fMCPid=kTRUE;fReadMC=kTRUE;fRealPid=kFALSE;fResPid=kFALSE;return;}
  void SetRealPid(){fRealPid=kTRUE;fMCPid=kFALSE;return;}
  void SetResonantPid(){fResPid=kTRUE;fRealPid=kTRUE;fMCPid=kFALSE;return;}
  void SetCutsKF(Float_t cutsKF[2]){for(Int_t i=0;i<2;i++){fCutsKF[i]=cutsKF[i];}return;}
  void SetUseKF(Bool_t useKF=kTRUE){fUseKF=useKF;}
  void SetIsHijing(Bool_t isHijing=kTRUE){fIsHijing=isHijing;}
  void SetKeepBkgNt(Bool_t keepBkgNt=kTRUE){fKeepBkgNt=keepBkgNt;}
  void SetAnalysis(Bool_t analysis=kTRUE){fAnalysis=analysis;}
  void SetUseFilterBitCut(Bool_t setter)   { fLcCut = setter;  return; }  
  void SetUseFilterBitPID(Bool_t setter)   { fLcPIDCut = setter; return; }
  void SetCollisionSystem(Int_t syst) {fSyst = syst; return; }
  void SetLambdacDaugh(AliAODMCParticle *part, TClonesArray *arrayMC, Bool_t &isInAcc) {fIsLcResonant=LambdacDaugh(part,arrayMC,isInAcc);} 
  void SetIsLcGen(AliAODMCParticle *partMC, TClonesArray *arrayMC);
  void SetIsLcReco(AliAODRecoDecayHF3Prong *part, TClonesArray *arrayMC);

  Bool_t GetLambdacDaugh(AliAODMCParticle *part, TClonesArray *arrayMC) const {Bool_t dummy=kTRUE; return LambdacDaugh(part,arrayMC,dummy)>=1 ? kTRUE : kFALSE;} 
  Int_t GetPIDselectionMaxProb(AliAODRecoDecayHF3Prong *part); 

  Bool_t IspiKpMC(AliAODRecoDecayHF3Prong *d,TClonesArray *arrayMC) const ;
  Bool_t IspKpiMC(AliAODRecoDecayHF3Prong *d,TClonesArray *arrayMC) const ;
  Int_t MatchToMCLambdac(AliAODRecoDecayHF3Prong *d,TClonesArray *arrayMC) const ;
  Int_t LambdacDaugh(AliAODMCParticle *part,TClonesArray *arrayMC, Bool_t &isInAcc) const;
  void FillMassHists(AliAODEvent *aod,AliAODRecoDecayHF3Prong *d, TClonesArray *arrayMC, Int_t selection, Int_t selectionProb);
  void FillNtuple(AliAODEvent *aod,AliAODRecoDecayHF3Prong *part, TClonesArray *arrayMC, Int_t selection);
  void FillEffHists(Int_t kStep);
  void FillSelectionBits(AliAODRecoDecayHF3Prong *d, TH2F *hSelectionBits);

  // Implementation of interface methods
  virtual void UserCreateOutputObjects();
  virtual void Init();
  virtual void LocalInit() {Init();}
  virtual void UserExec(Option_t *option);
  virtual void Terminate(Option_t *option);
    
 private:

  AliAnalysisTaskSELambdacTMVA(const AliAnalysisTaskSELambdacTMVA &source);
  AliAnalysisTaskSELambdacTMVA& operator=(const AliAnalysisTaskSELambdacTMVA& source); 
  
  Bool_t ReconstructKF(AliAODRecoDecayHF3Prong *d,Int_t *pdgs,Double_t field) const;
  
  TList   *fOutput; 
  TH1F    *fHistNEvents; 
  TH1F    *fHistNEventsRejTM; 
  TH1F *fhSelectBit; 
  TH2F *fhSelectionBits;    
  TH2F *fhSelectionBitsSigc; 
  TH2F *fhSelectionBitsSigb; 
  TH1F *fhSetIsLc; 
  TH2F *fhPIDmassLcPt; 
  TH2F *fhPIDmassLcPtSig; 
  TH2F *fhPIDmassLcPtSigc; 
  TH2F *fhPIDmassLcPtSigb; 
  TH2F *fhMCmassLcPt; 
  TH2F *fhMCmassLcPtSig; 
  TH2F *fhMCmassLcPtSigc; 
  TH2F *fhMCmassLcPtSigb; 
  TH2F *fhProbmassLcPt; 
  TH2F *fhProbmassLcPtSig; 
  TH2F *fhProbmassLcPtSigc; 
  TH2F *fhProbmassLcPtSigb; 
  TH1F *fhIsLcResonantGen; 
  TH1F *fhIsLcResonantReco;
  TH1F *fhIsLcGen;
  TH1F *fhIsLcReco;
  TH1F *fhRecoPDGmom; 
  TH1F *fhNBkgNI[12];        
  TH1F *fhNLc[12];             
  TH1F *fhNLcc[12];            
  TH1F *fhNLcNonRc[12];        
  TH1F *fhNLcL1520c[12];       
  TH1F *fhNLcKstarc[12];       
  TH1F *fhNLcDeltac[12];       
  TH1F *fhNLcb[12];            
  TH1F *fhNLcNonRb[12];        
  TH1F *fhNLcL1520b[12];       
  TH1F *fhNLcKstarb[12];       
  TH1F *fhNLcDeltab[12];       
  TH2F *fhPtEtaBkgNI[12];      
  TH2F *fhPtEtaLc[12];         
  TH2F *fhPtEtaLcc[12];        
  TH2F *fhPtEtaLcNonRc[12];    
  TH2F *fhPtEtaLcL1520c[12];   
  TH2F *fhPtEtaLcKstarc[12];   
  TH2F *fhPtEtaLcDeltac[12];   
  TH2F *fhPtEtaLcb[12];        
  TH2F *fhPtEtaLcNonRb[12];    
  TH2F *fhPtEtaLcL1520b[12];   
  TH2F *fhPtEtaLcKstarb[12];   
  TH2F *fhPtEtaLcDeltab[12];   
  TH2F *fhPtYBkgNI[12];        
  TH2F *fhPtYLc[12];           
  TH2F *fhPtYLcc[12];          
  TH2F *fhPtYLcNonRc[12];      
  TH2F *fhPtYLcL1520c[12];     
  TH2F *fhPtYLcKstarc[12];     
  TH2F *fhPtYLcDeltac[12];     
  TH2F *fhPtYLcb[12];          
  TH2F *fhPtYLcNonRb[12];      
  TH2F *fhPtYLcL1520b[12];     
  TH2F *fhPtYLcKstarb[12];     
  TH2F *fhPtYLcDeltab[12];     
  TH2F *fhPtPhiBkgNI[12];      
  TH2F *fhPtPhiLc[12];         
  TH2F *fhPtPhiLcc[12];        
  TH2F *fhPtPhiLcNonRc[12];    
  TH2F *fhPtPhiLcL1520c[12];   
  TH2F *fhPtPhiLcKstarc[12];   
  TH2F *fhPtPhiLcDeltac[12];   
  TH2F *fhPtPhiLcb[12];        
  TH2F *fhPtPhiLcNonRb[12];    
  TH2F *fhPtPhiLcL1520b[12];   
  TH2F *fhPtPhiLcKstarb[12];   
  TH2F *fhPtPhiLcDeltab[12];   
  TH1F *fhPtMisIdpKpi; 
  TH1F *fhPtMisIdpiKp; 
  TH1F *fhPtCorrId; 
  TH2F *fhInvMassMisIdpKpi; 
  TH2F *fhInvMassMisIdpiKp; 
  TH1F *fhPtMisIdpKpiProb; 
  TH1F *fhPtMisIdpiKpProb; 
  TH1F *fhPtCorrIdProb; 
  TH2F *fhInvMassMisIdpKpiProb; 
  TH2F *fhInvMassMisIdpiKpProb; 
  TNtuple *fNtupleLambdac; 
  TF1 *fFuncWeightPythia; 
  TF1 *fFuncWeightFONLL7overLHC10f6a; 
  TF1 *fFuncWeightFONLL5overLHC13d3; 
  TF1 *fFuncWeightFONLL5overLHC10f6a; 
  TF1 *fFuncWeightFONLL5overLHC13d3Lc; 
  TF1 *fFuncWeightFONLL7overLHC11b2Lc; 
  TF1 *fFuncWeightFONLL7overLHC10f7aLc; 
  Float_t fCutsKF[2]; 
  Int_t fIsLc; 
  Int_t fIsLcResonant; 
  Float_t fCandidateVars[4]; 
  Float_t fPtLc; 
  Float_t fUpmasslimit;  
  Float_t fLowmasslimit; 
  AliRDHFCutsLctopKpi *fRDCutsAnalysis; 
  TList *fListCuts; 
  Int_t fFillNtuple;   
  Bool_t fKeepLcNotFromQuark; 
  Bool_t fKeepBkgNt; 
  Int_t fSyst; 
  Bool_t fReadMC;    
  Bool_t fMCPid;    
  Bool_t fRealPid;    
  Bool_t fResPid;      
  Bool_t fUseKF;      
  Bool_t fAnalysis;      
  AliAnalysisVertexingHF *fVHF;  
  Bool_t fLcCut;  
  Bool_t fLcPIDCut;  
  Bool_t fIsHijing; 
  TH1F *fNentries;      
  //AliAODpidUtil* fUtilPid;
  AliPIDResponse *fPIDResponse;     
  AliNormalizationCounter *fCounter;
  AliVertexingHFUtils *fVertUtil;         

  ClassDef(AliAnalysisTaskSELambdacTMVA,9); 
};

#endif