AliAnalysisTaskSEB0toDminuspi.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKSEB0toDminuspi_H
#define ALIANALYSISTASKSEB0toDminuspi_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.                  *
 **************************************************************************/



#include <TH2F.h>
#include <TH3F.h>
#include <THnSparse.h>

#include "AliAnalysisTaskSE.h"

class AliRDHFCutsDplustoKpipi;
class AliNormalizationCounter;

class AliAnalysisTaskSEB0toDminuspi : public AliAnalysisTaskSE 
{
  
 public:
  
  AliAnalysisTaskSEB0toDminuspi();
  AliAnalysisTaskSEB0toDminuspi(const Char_t* name, AliRDHFCutsDplustoKpipi* dpluscutsana);
  virtual ~AliAnalysisTaskSEB0toDminuspi();

  AliAODVertex* RecalculateVertex(const AliVVertex *old,TObjArray *tracks,Double_t bField);

  void SetCutsDistr(Bool_t cutsDistr=kTRUE){fCutsDistr=cutsDistr;}

  // 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);
 

    // histos
  void FillSpectrum(Int_t nB0, Int_t* arrayMClabel, Double_t Bfield);
  void     DefineHistograms();
  
  
  void SetUseBit(Bool_t dols=kTRUE){fUseBit=dols;}
  void SetUseOnlyPositiveEta(){fEtaSelection=1;}
  void SetUseOnlyNegativeEta(){fEtaSelection=-1;}
  void SetUseFullEta(){fEtaSelection=0;}
  void SetReadMC(Bool_t readMC=kTRUE){fReadMC=readMC;}
  void SetUseQuarkLevelTag(Bool_t opt){fUseQuarkTagInKine=opt;}
  
  void SetTopomaticCutOnDDaughters(Double_t TopoCut){fInvertedTopomaticCutOnDDaughters=TopoCut;}
  void SetDpTCut(Double_t pTD){fpTD=pTD;} 
  void SetpipTCut(Double_t pTpi){fpTpi=pTpi;} 
  void Setprodd0Cut(Double_t prodd0){fprodd0=prodd0;} 
  void SetCosBCut(Double_t cosB){fcosB=cosB;} 
  void SetCosXYBCut(Double_t cosBXY){fcosBXY=cosBXY;} 
  void SetdlBCut(Double_t dlB){fdlB=dlB;} 
  void SetNdlXYBCut(Double_t NdlBXY){fNdlBXY=NdlBXY;} 
  void SetTopomaticD(Double_t TopomaticD){fTopomaticD=TopomaticD;} 
  void SetTopomaticpi(Double_t Topomaticpi){fTopomaticpi=Topomaticpi;} 
  void SetcosoaDpi(Double_t cosoaDpi){fcosoaDpi=cosoaDpi;}
  
  //to define the range of the D plus mass candidates to form a B meson

  void SetDplusMassLimit(Double_t DplusMassLowLimit,Double_t DplusMassUpLimit){
    fDplusMassUpLimit=DplusMassUpLimit;
    fDplusMassLowLimit=DplusMassLowLimit;}

  //range of the B meson invariant mass distributions
  void SetBMassLimits(Float_t lowlimit, Float_t uplimit);
  void SetBinWidth(Float_t w);


  Float_t GetUpperBMassLimit(){return fBMassUpLimit;}
  Float_t GetLowerBMassLimit(){return fBMassLowLimit;}
  Float_t GetBinWidth(){return fBinWidth;}
  Int_t GetNBinsHistos();

  
  //   void SetBMassLimitForHisto(Double_t BMassLowLimit,Double_t BMassUpLimit){
  //  fBMassLowLimit=BMassLowLimit;fBMassUpLimit=BMassUpLimit;}


  

 private:
  
  AliAnalysisTaskSEB0toDminuspi(const AliAnalysisTaskSEB0toDminuspi &source);
  AliAnalysisTaskSEB0toDminuspi& operator=(const AliAnalysisTaskSEB0toDminuspi& source); 
  
  enum {kMaxPtBins=10};
 
  
  
  TList *fOutput;                
  TList *fOutputBins;             
  TList *fListCuts; 
  
  AliRDHFCutsDplustoKpipi *fRDCutsAnalysis; 
  std::vector<AliAODRecoDecayHF2Prong*> fArrayB0; 
 
  // define the histograms
  TH1F *fCEvents;                            
  TH1F *fB0InvMass;                          
  TH1F *fDplusInvMass;                       
  TH1F* fB0InvMass_PassCut1;                 
  TH1F* fB0InvMassMinusD_PassCut1;           
  TH1F* fDplusInvMass_PassCut1;              
  TH1F* fDplusInvMass_DplusMCmatch;          
  TH1F* fDplusInvMass_MCmatch;               
  TH1F* fBInvMass_MCmatch;                   
  TH1F* fBInvMass_MCmatch_PassCut1;          
  TH1F* fB0InvMassMinusD_MCmatch_PassCut1;   
  TH1F* fpiPt;                
  TH1F* fpiEta;               
  TH1F* fpiPhi;               
  TH1F* fDplusPt;             
  TH1F* fDplusEta;            
  TH1F* fDplusPhi;            
  TH1F* fDplusPointing;       
  TH1F* fDplusDecayLength;    
  TH1F* fDplusNormalizedDecayLength; 
  TH1F* fDplusSigmaVert;      
  TH1F* fBPt;                 
  TH1F* fBEta;                
  TH1F* fBPhi;                
  TH1F* fBPointing;           
  TH1F* fBPointingXY;         
  TH1F* fBDecayLength;        
  TH1F* fBNormalizedDecayLength; 
  TH1F* fDplusd0;             
  TH1F* fpid0;                
  TH1F* fproductd0;           
  TH1F* fpiPt_MCmatch;        
  TH1F* fpiEta_MCmatch;       
  TH1F* fpiPhi_MCmatch;       
  TH1F* fDplusPt_MCmatch;     
  TH1F* fDplusEta_MCmatch;    
  TH1F* fDplusPhi_MCmatch;    
  TH1F* fDplusPointing_MCmatch; 
  TH1F* fDplusDecayLength_MCmatch; 
  TH1F* fDplusNormalizedDecayLength_MCmatch;             
  TH1F* fDplusSigmaVert_MCmatch;  
  TH1F* fBPt_MCmatch;             
  TH1F* fBEta_MCmatch;            
  TH1F* fBPhi_MCmatch;            
  TH1F* fBPointing_MCmatch;       
  TH1F* fBPointingXY_MCmatch;     
  TH1F* fBDecayLength_MCmatch;    
  TH1F* fBNormalizedDecayLength_MCmatch; 
  TH1F* fDplusd0_MCmatch;         
  TH1F* fpid0_MCmatch;            
  TH1F* fproductd0_MCmatch;       


  TH1F* fB0InvMassBin[kMaxPtBins];                        
  TH1F* fDplusInvMassBin[kMaxPtBins];                     
  TH1F* fB0InvMassBin_MCmatch[kMaxPtBins];                
  TH1F* fDplusInvMassBin_MCmatch[kMaxPtBins];             
  TH1F* fB0InvMassBin_PassCut1[kMaxPtBins];               
  TH1F* fDplusInvMassBin_PassCut1[kMaxPtBins];            
  TH1F* fB0InvMassBinMinusD_PassCut1[kMaxPtBins];         
  TH1F* fB0InvMassBin_MCmatch_PassCut1[kMaxPtBins];       
  TH1F* fB0InvMassBinMinusD_MCmatch_PassCut1[kMaxPtBins]; 
  TH1F* fBDecayLengthBin[kMaxPtBins];                     
  TH1F* fBNormalizedDecayLengthBin[kMaxPtBins];           
  TH1F* fBPointingBin[kMaxPtBins];                        
  TH1F* fBPointingXYBin[kMaxPtBins];                       
  TH1F* fDplusd0Bin[kMaxPtBins];                          
  TH1F* fBpTBin[kMaxPtBins];                              
  TH1F* fDpluspTBin[kMaxPtBins];                          
  TH1F* fproductd0Bin[kMaxPtBins];                        
  TH1F* fDplusPointingBin[kMaxPtBins];                    
  TH1F* fDplusDecayLengthBin[kMaxPtBins];                 
  TH1F* fDplusNormalizedDecayLengthBin[kMaxPtBins];       
  TH1F* fDplusSigmaVertBin[kMaxPtBins];                   
  TH1F* fBDecayLengthBin_MCmatch[kMaxPtBins];             
  TH1F* fBNormalizedDecayLengthBin_MCmatch[kMaxPtBins];   
  TH1F* fBPointingBin_MCmatch[kMaxPtBins];                
  TH1F* fBPointingXYBin_MCmatch[kMaxPtBins];              
  TH1F* fDplusd0Bin_MCmatch[kMaxPtBins];                  
  TH1F* fBpTBin_MCmatch[kMaxPtBins];                      
  TH1F* fDpluspTBin_MCmatch[kMaxPtBins];                  
  TH1F* fproductd0Bin_MCmatch[kMaxPtBins];                
  TH1F* fDplusPointingBin_MCmatch[kMaxPtBins];            
  TH1F* fDplusDecayLengthBin_MCmatch[kMaxPtBins];         
  TH1F* fDplusNormalizedDecayLengthBin_MCmatch[kMaxPtBins];
  TH1F* fDplusSigmaVertBin_MCmatch[kMaxPtBins];      

  TH1F* fd0MMExpD;                                  
  TH1F* fd0MMExpDMCmatch;                           
  TH1F* fd0MMExppi;                                 
  TH1F* fd0MMExppiMCmatch;                          
  TH1F* fd0MMExpDBin[kMaxPtBins];                   
  TH1F* fd0MMExpDBin_MCmatch[kMaxPtBins];           
  TH1F* fd0MMExppiBin[kMaxPtBins];                  
  TH1F* fd0MMExppiBin_MCmatch[kMaxPtBins];          
  TH1F* fd0MMExpDDaughters;                         
  TH1F* fd0MMExpDDaughters_MCmatch;                 
  TH1F* fd0MMExpDDaughtersBin[kMaxPtBins];          
  TH1F* fd0MMExpDDaughtersBin_MCmatch[kMaxPtBins];  
  TH1F* fcosoa;                                     
  TH1F* fcosoa_MCmatch;                             
 
  TH2F* fBDplusPt;           
  TH2F* fBDplusPt_MCmatch;   
  TH2F* fBpiPt;              
  TH2F* fBpiPt_MCmatch;      
  TH2F* fBDplusPtBin[kMaxPtBins];           
  TH2F* fBDplusPtBin_MCmatch[kMaxPtBins];   
  TH2F* fBpiPtBin[kMaxPtBins];              
  TH2F* fBpiPtBin_MCmatch[kMaxPtBins];      

  AliNormalizationCounter *fCounter; 


  Int_t  fEvents;       
  Bool_t fUseBit;       
  Int_t fEtaSelection;  
  Bool_t fReadMC;       
  Bool_t kbins = kTRUE; 
  Bool_t fUseQuarkTagInKine; 
  Bool_t fCutsDistr;    
  
  Double_t fDplusMassLowLimit; 
  Double_t fDplusMassUpLimit;  
  Double_t fBMassLowLimit;     
  Double_t fBMassUpLimit;      
  Float_t fBinWidth;           
 
 

  Double_t fInvertedTopomaticCutOnDDaughters;
  Double_t fpTD;   
  Double_t fpTpi;  
  Double_t fprodd0;
  Double_t fcosB;  
  Double_t fcosBXY;  
  Double_t fdlB;   
  Double_t fNdlBXY; 
  Double_t fTopomaticD; 
  Double_t fTopomaticpi;
  Double_t fcosoaDpi;   
  
  

  ClassDef(AliAnalysisTaskSEB0toDminuspi,2); 
};

#endif