AliAnalysisTaskSELc2V0bachelorTMVA.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKSELC2V0BACHELORTMVA_H
#define ALIANALYSISTASKSELC2V0BACHELORTMVA_H
/**************************************************************************
 * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id: AliAnalysisTaskSELc2V0bachelorTMVA.h 61835 2013-04-05 23:07:23Z fprino $ */ 

#include "TROOT.h"
#include "TSystem.h"

#include "AliAnalysisTaskSE.h"
#include "AliAODEvent.h"
#include "AliAODMCHeader.h"
#include "AliPID.h"
#include "AliAODTrack.h"
#include "AliAODVertex.h"
#include "AliAODRecoDecay.h"
#include "AliPIDResponse.h"
#include "AliPIDCombined.h"
#include "AliTPCPIDResponse.h"
#include "AliRDHFCutsLctoV0.h"
#include "AliNormalizationCounter.h"
#include "AliVertexingHFUtils.h"
#include "AliAODRecoCascadeHF.h"


class TH1F;
class TH1D;

class AliAnalysisTaskSELc2V0bachelorTMVA : public AliAnalysisTaskSE 
{
  
 public:

  enum EBachelor {
    kBachInvalid = -1,
    kBachFake = 0,
    kBachNoProton = 1,
    kBachPrimary = 2,
    kBachNoLambdaMother = 3,
    kBachDifferentLambdaMother = 4,
    kBachCorrectLambdaMother = 5 };

  enum EK0S {
    kK0SInvalid = -1,
    kK0SFake = 0,
    kK0SNoK0S = 1,
    kK0SWithoutMother = 2,
    kK0SNotFromK0 = 3,
    kK0Primary = 4, 
    kK0NoLambdaMother = 5,
    kK0DifferentLambdaMother = 6,
    kK0CorrectLambdaMother = 7 };    

  enum EAnalysisType { 
     kpPb2013 = 0,
     kpPb2016 = 1,
     kpp2016 = 2,
     kpp2010 = 3};
  
  AliAnalysisTaskSELc2V0bachelorTMVA();
  AliAnalysisTaskSELc2V0bachelorTMVA(const Char_t* name, AliRDHFCutsLctoV0* cutsA,
         Bool_t useOnTheFly=kFALSE);
  virtual ~AliAnalysisTaskSELc2V0bachelorTMVA();

  virtual void UserCreateOutputObjects();
  virtual void Init();
  virtual void LocalInit() {Init();}
  virtual void UserExec(Option_t *option);
  virtual void Terminate(Option_t *option);
 
  void FillLc2pK0Sspectrum(AliAODRecoCascadeHF *part, Int_t isLc,
         Int_t &nSelectedAnal, AliRDHFCutsLctoV0 *cutsAnal,
         TClonesArray *mcArray, Int_t iLctopK0s);

  void MakeAnalysisForLc2prK0S(TClonesArray *arrayLctopK0s,
             TClonesArray *mcArray,
             Int_t &nSelectedAnal, AliRDHFCutsLctoV0 *cutsAnal, 
             TClonesArray *array3Prong, AliAODMCHeader *aodheader);
 
  void SetMC(Bool_t theMCon) {fUseMCInfo = theMCon;}
  Bool_t GetMC() const {return fUseMCInfo;}

  void SetK0sAnalysis(Bool_t a) {fIsK0sAnalysis=a;}
  Bool_t GetK0sAnalysis() const {return fIsK0sAnalysis;}

  void SetUseOnTheFlyV0(Bool_t a) { fUseOnTheFlyV0=a; }
  Bool_t GetUseOnTheFlyV0() { return fUseOnTheFlyV0; }

  void SetIspA(Bool_t a) { fIspA=a; }
  Bool_t GetIspA() { return fIspA; }

  void SetFillOnlySgn(Bool_t a) { fFillOnlySgn=a; }
  Bool_t GetFillOnlySgn() { return fFillOnlySgn; }

  void SetTopoConstraint(Bool_t a) { ftopoConstraint=a; }
  Bool_t GetTopoConstraint() { return ftopoConstraint; }

  void SetCallKFVertexing(Bool_t a) { fCallKFVertexing=a; }
  Bool_t GetCallKFVertexing() { return fCallKFVertexing; }

  void SetKeepingKeepingOnlyHIJINGBkg(Bool_t a) { fKeepingOnlyHIJINGBkg = a;}
  Bool_t GetKeepingOnlyHIJINGBkg() {return fKeepingOnlyHIJINGBkg;}

  void SetKFCutChi2NDF(Float_t a) {fCutKFChi2NDF = a;}
  Float_t GetKFCutChi2NDF() {return fCutKFChi2NDF;}

  void SetKFCutDeviationFromVtx(Float_t a) {fCutKFDeviationFromVtx = a;}
  Float_t GetKFCutDeviationFromVtx() {return fCutKFDeviationFromVtx;}

  void SetKFCutDeviationFromVtxV0(Float_t a) {fCutKFDeviationFromVtxV0 = a;}
  Float_t GetKFCutDeviationFromVtxV0() {return fCutKFDeviationFromVtxV0;}

  void SetKeepingKeepingOnlyPYTHIABkg(Bool_t a) { fKeepingOnlyPYTHIABkg = a;}
  Bool_t GetKeepingOnlyPYTHIABkg() {return fKeepingOnlyPYTHIABkg;}
  
  void SetTriggerMask(ULong64_t c) { fTriggerMask = c;} 
  
  void SetMCNchHisto(TH1F* h){
    if(fHistoMCNch) delete fHistoMCNch;
    fHistoMCNch = new TH1F(*h);
  }
  
  void SetAnalysisType(Int_t mode){
     fAnalysisType = mode;
  }
  
  
  void SetMultVsZProfileLHC13b(TProfile* hprof){
    if(fMultEstimatorAvg[0]) delete fMultEstimatorAvg[0];
    fMultEstimatorAvg[0]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC13c(TProfile* hprof){
    if(fMultEstimatorAvg[1]) delete fMultEstimatorAvg[1];
    fMultEstimatorAvg[1]=new TProfile(*hprof);
  }

  void SetMultVsZProfileLHC16qt1stBunch(TProfile* hprof){
    if(fMultEstimatorAvg[0]) delete fMultEstimatorAvg[0];
    fMultEstimatorAvg[0]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC16qt2ndBunch(TProfile* hprof){
    if(fMultEstimatorAvg[1]) delete fMultEstimatorAvg[1];
    fMultEstimatorAvg[1]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC16qt3rdBunch(TProfile* hprof){
    if(fMultEstimatorAvg[2]) delete fMultEstimatorAvg[2];
    fMultEstimatorAvg[2]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC16qt4thBunch(TProfile* hprof){
    if(fMultEstimatorAvg[3]) delete fMultEstimatorAvg[3];
    fMultEstimatorAvg[3]=new TProfile(*hprof);
  }

  void SetMultVsZProfileLHC16j(TProfile* hprof){
    if(fMultEstimatorAvg[0]) delete fMultEstimatorAvg[0];
    fMultEstimatorAvg[0]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC16k(TProfile* hprof){
    if(fMultEstimatorAvg[1]) delete fMultEstimatorAvg[1];
    fMultEstimatorAvg[1]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC16l(TProfile* hprof){
    if(fMultEstimatorAvg[2]) delete fMultEstimatorAvg[2];
    fMultEstimatorAvg[2]=new TProfile(*hprof);
  }

  void SetMultVsZProfileLHC10b(TProfile* hprof){
    if(fMultEstimatorAvg[0]) delete fMultEstimatorAvg[0];
    fMultEstimatorAvg[0]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC10c(TProfile* hprof){
    if(fMultEstimatorAvg[1]) delete fMultEstimatorAvg[1];
    fMultEstimatorAvg[1]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC10d(TProfile* hprof){
    if(fMultEstimatorAvg[2]) delete fMultEstimatorAvg[2];
    fMultEstimatorAvg[2]=new TProfile(*hprof);
  }
  void SetMultVsZProfileLHC10e(TProfile* hprof){
    if(fMultEstimatorAvg[3]) delete fMultEstimatorAvg[3];
    fMultEstimatorAvg[3]=new TProfile(*hprof);
  }


  void SetReferenceMultiplicity(Double_t rmu){fRefMult=rmu;}
  
  


 private:
  
  EBachelor CheckBachelor(AliAODRecoCascadeHF *part, AliAODTrack* bachelor, TClonesArray *mcArray);
  EK0S CheckK0S(AliAODRecoCascadeHF *part, AliAODv0* v0part, TClonesArray *mcArray);
  //EK0S CheckK0S(AliAODRecoCascadeHF *part, AliAODTrack* v0part, TClonesArray *mcArray );
  Int_t FindV0Label(AliAODRecoDecay* v0part, TClonesArray *mcArray) const;
  Int_t FindLcLabel(AliAODRecoCascadeHF* cascade, TClonesArray *mcArray) const;
  Int_t CallKFVertexing(AliAODRecoCascadeHF *cascade, AliAODv0* v0part, AliAODTrack* bach, TClonesArray *mcArray, 
      Double_t* V0KF, Double_t* errV0KF, Double_t* LcKF, Double_t* errLcKF,
      Double_t* distances, Double_t* armPolKF);

  void FillMCHisto(TClonesArray *mcArray);

  AliAnalysisTaskSELc2V0bachelorTMVA(const AliAnalysisTaskSELc2V0bachelorTMVA &source);
  AliAnalysisTaskSELc2V0bachelorTMVA& operator=(const AliAnalysisTaskSELc2V0bachelorTMVA& source); 
  TProfile* GetEstimatorHistogram(const AliVEvent *event);
  
  Bool_t fUseMCInfo;          
  TList *fOutput;             

  // define the histograms
  TH1F *fCEvents;                    
  AliPIDResponse *fPIDResponse;      
  AliPIDCombined *fPIDCombined;      
  Bool_t fIsK0sAnalysis;             
  AliNormalizationCounter *fCounter; 
  AliRDHFCutsLctoV0 *fAnalCuts;      
  TList *fListCuts;                  
  TList *fListWeight;                
  TList *fListCounters;              
  TList *fListProfiles;              
  Bool_t fUseOnTheFlyV0;             
  Bool_t fIsEventSelected;           

  TTree   *fVariablesTreeSgn;        
  TTree   *fVariablesTreeBkg;        
  Float_t *fCandidateVariables;      

  Bool_t fIspA;                       

  TH1F* fHistoEvents;                 
  TH1F* fHistoLc;                     
  TH1F* fHistoLcOnTheFly;             
  Bool_t fFillOnlySgn;                
  TH1F* fHistoLcBeforeCuts;           
  TH1F* fHistoFiducialAcceptance;     
  TH2F* fHistoCodesSgn;               
  TH2F* fHistoCodesBkg;               
  TH1F* fHistoLcpKpiBeforeCuts;       
  AliAODVertex *fVtx1;                

  TH1D* fHistoDistanceLcToPrimVtx;    
  TH1D* fHistoDistanceV0ToPrimVtx;    
  TH1D* fHistoDistanceV0ToLc;         

  TH1D* fHistoDistanceLcToPrimVtxSgn; 
  TH1D* fHistoDistanceV0ToPrimVtxSgn; 
  TH1D* fHistoDistanceV0ToLcSgn;      
         
  TH1D* fHistoVtxLcResidualToPrimVtx; 
  TH1D* fHistoVtxV0ResidualToPrimVtx; 
  TH1D* fHistoVtxV0ResidualToLc;      

  TH1D* fHistoMassV0All;              
  TH1D* fHistoDecayLengthV0All;       
  TH1D* fHistoLifeTimeV0All;          

  TH1D* fHistoMassV0True;             
  TH1D* fHistoDecayLengthV0True;      
  TH1D* fHistoLifeTimeV0True;         

  TH1D* fHistoMassV0TrueFromAOD;      

  TH1D* fHistoMassV0TrueK0S;          
  TH1D* fHistoDecayLengthV0TrueK0S;   
  TH1D* fHistoLifeTimeV0TrueK0S;      

  TH1D* fHistoMassV0TrueK0SFromAOD;   

  TH1D* fHistoMassLcAll;              
  TH1D* fHistoDecayLengthLcAll;       
  TH1D* fHistoLifeTimeLcAll;          

  TH1D* fHistoMassLcTrue;             
  TH1D* fHistoDecayLengthLcTrue;      
  TH1D* fHistoLifeTimeLcTrue;         

  TH1D* fHistoMassLcTrueFromAOD;      

  TH1D* fHistoMassV0fromLcAll;        
  TH1D* fHistoDecayLengthV0fromLcAll; 
  TH1D* fHistoLifeTimeV0fromLcAll;    

  TH1D* fHistoMassV0fromLcTrue;       
  TH1D* fHistoDecayLengthV0fromLcTrue;
  TH1D* fHistoLifeTimeV0fromLcTrue;   

  TH1D* fHistoMassLcSgn;              
  TH1D* fHistoMassLcSgnFromAOD;       
  TH1D* fHistoDecayLengthLcSgn;       
  TH1D* fHistoLifeTimeLcSgn;          

  TH1D* fHistoMassV0fromLcSgn;        
  TH1D* fHistoDecayLengthV0fromLcSgn; 
  TH1D* fHistoLifeTimeV0fromLcSgn;    

  TH2D* fHistoKF;                     
  TH1D* fHistoKFV0;                   
  TH1D* fHistoKFLc;                   

  TH2D* fHistoMassKFV0;               
  TH2D* fHistoDecayLengthKFV0;        
  TH2D* fHistoLifeTimeKFV0;           

  TH2D* fHistoMassKFLc;               
  TH2D* fHistoDecayLengthKFLc;        
  TH2D* fHistoLifeTimeKFLc;           

  TH2D* fHistoArmenterosPodolanskiV0KF;      
  TH2D* fHistoArmenterosPodolanskiV0KFSgn;   
  TH2D* fHistoArmenterosPodolanskiV0AOD;     
  TH2D* fHistoArmenterosPodolanskiV0AODSgn;  

  TList *fOutputKF;             

  Int_t fmcLabelLc;             
  Bool_t ftopoConstraint;       
  Bool_t fCallKFVertexing;      
  Bool_t fKeepingOnlyHIJINGBkg; 
  AliVertexingHFUtils* fUtils;  
  TH1F* fHistoBackground;       
  Float_t fCutKFChi2NDF;        
  Float_t fCutKFDeviationFromVtx; 
  Float_t fCutKFDeviationFromVtxV0; 
  Int_t fCurrentEvent;              
  Double_t fBField;                   
  Bool_t fKeepingOnlyPYTHIABkg;       
  TH1F* fHistoMCLcK0SpGen;            
  TH1F* fHistoMCLcK0SpGenAcc;         
  TH1F* fHistoMCLcK0SpGenLimAcc;      

  ULong64_t fTriggerMask;       

  TF1 *fFuncWeightPythia; 
  TF1 *fFuncWeightFONLL5overLHC13d3; 
  TF1 *fFuncWeightFONLL5overLHC13d3Lc; 
  TH1F* fHistoMCNch;  
 
  Int_t fAnalysisType; 
  Int_t fNTracklets; 
  TProfile* fMultEstimatorAvg[4]; 
  Double_t fRefMult; 
  
  TList *fListMultiplicityHistograms; 
  TH2F *fHistNtrVsZvtx; 
  TH2F *fHistNtrCorrVsZvtx; 
  
  TH1F* fHistNtrUnCorrEvSel; 
  TH1F* fHistNtrUnCorrEvWithCand; 
  TH1F* fHistNtrCorrEvSel; 
  TH1F* fHistNtrCorrEvWithCand; 

  AliNormalizationCounter *fCounterC;           
  AliNormalizationCounter *fCounterU;           
  AliNormalizationCounter *fCounterCandidates;  

  
  ClassDef(AliAnalysisTaskSELc2V0bachelorTMVA, 12); 
};

#endif