[u/mrichter/AliRoot.git] / PWG2 / SPECTRA / AliProtonAnalysisBase.h

#ifndef ALIPROTONANALYSISBASE_H
#define ALIPROTONANALYSISBASE_H

/*  See cxx source for full Copyright notice */


/* $Id: AliProtonAnalysisBase.h 31056 2009-02-16 14:31:41Z pchrist $ */

//-------------------------------------------------------------------------
//                       Class AliProtonAnalysisBase
//   This is the base class for the baryon (proton) analysis
//
//    Origin: Panos Christakoglou | Panos.Christakoglou@cern.ch
//-------------------------------------------------------------------------

#include "TObject.h"
#include "TString.h"
class TF1;
class TCanvas;
class TList;

#include "AliPhysicsSelection.h"
#include "AliBackgroundSelection.h"
#include "AliPID.h"
class AliESDEvent;
class AliESDtrack;
class AliESDVertex;

class AliProtonAnalysisBase : public TObject {
 public:
  enum TriggerMode { kMB1 = 0, kMB2, kSPDFASTOR };
  enum AnalysisMode { kInvalid = -1, kTPC = 0, kHybrid, kFullHybrid, kGlobal };
  enum PIDMode { kBayesian = 0, kRatio, kSigma};

  AliProtonAnalysisBase();
  virtual ~AliProtonAnalysisBase();

  void SetAnalysisLevel(const char* type) {fProtonAnalysisLevel = type;}
  void SetAnalysisMode(AnalysisMode analysismode) {fProtonAnalysisMode = analysismode;}
  void SetEtaMode() {fAnalysisEtaMode = kTRUE;}
  void SetTriggerMode(TriggerMode triggermode) {
    fAnalysisMC = kTRUE; fTriggerMode = triggermode;}
  void SetPIDMode(PIDMode pidmode) {fProtonPIDMode = pidmode;}

  const char *GetAnalysisLevel() {return fProtonAnalysisLevel.Data();}
  AnalysisMode GetAnalysisMode() const {return fProtonAnalysisMode;}
  Bool_t GetEtaMode() const {return fAnalysisEtaMode;}
  TriggerMode GetTriggerMode() const {return fTriggerMode;}
  PIDMode GetPIDMode() const {return fProtonPIDMode;}
  Bool_t GetMCAnalysisMode() {return fAnalysisMC;}

  const  AliESDVertex *GetVertex(AliESDEvent *esd,
				 AnalysisMode mode,
				 Double_t gVx = 100.,
				 Double_t gVy = 100.,
				 Double_t gVz = 100.);
  void SetAcceptedVertexDiamond(Double_t gVx, Double_t gVy, Double_t gVz) {
    fVxMax = gVx; fVyMax = gVy; fVzMax = gVz;}
  Double_t GetVxMax() const {return fVxMax;}
  Double_t GetVyMax() const {return fVyMax;}
  Double_t GetVzMax() const {return fVzMax;}
  void SetMinNumOfContributors(Int_t nContributors) {
    fMinNumOfContributors = nContributors;}
  Int_t GetMinNumOfContributors() {return fMinNumOfContributors;}

  void SetPhaseSpace(Int_t nBinsX, Double_t gXmin, Double_t gXmax,
		     Int_t nBinsY, Double_t gYmin, Double_t gYmax) {
    fNBinsX = nBinsX; fMinX = gXmin; fMaxX = gXmax;
    fNBinsY = nBinsY; fMinY = gYmin; fMaxY = gYmax;
  }
  Int_t GetNBinsX() const {return fNBinsX;}
  Int_t GetNBinsY() const {return fNBinsY;}
  Double_t GetMinX() const {return fMinX;}
  Double_t GetMinY() const {return fMinY;}
  Double_t GetMaxX() const {return fMaxX;}
  Double_t GetMaxY() const {return fMaxY;}

  //Trigger
  Bool_t IsOnlineTriggerUsed() {return kUseOnlineTrigger;}
  void UseOnlineTrigger() {kUseOnlineTrigger = kTRUE;}
  Bool_t IsEventTriggered(const AliESDEvent *esd,
			  TriggerMode trigger = kMB2);
  void OfflineTriggerInit() {
    kUseOfflineTrigger = kTRUE;
    fPhysicsSelection = new AliPhysicsSelection();
    fPhysicsSelection->AddBackgroundIdentification(new AliBackgroundSelection());
    fPhysicsSelection->SetAnalyzeMC(fAnalysisMC);
  }
  Bool_t IsOfflineTriggerUsed() {return kUseOfflineTrigger;}
  AliPhysicsSelection *GetPhysicsSelectionObject() {return fPhysicsSelection;}

  Bool_t IsPrimary(AliESDEvent *esd,
		   const AliESDVertex *vertex, 
		   AliESDtrack *track);
  Bool_t IsAccepted(AliESDtrack *track);
  Bool_t IsInPhaseSpace(AliESDtrack *track);

  Float_t GetSigmaToVertex(AliESDtrack* esdTrack) const; 
  Double_t Rapidity(Double_t Px, Double_t Py, Double_t Pz) const;
  
  //Cut functions
  void    SetPointOnSPDLayers() {fPointOnSPDLayersFlag = kTRUE;}
  void    SetPointOnSDDLayers() {fPointOnSDDLayersFlag = kTRUE;}
  void    SetPointOnSSDLayers() {fPointOnSSDLayersFlag = kTRUE;}
  void    SetPointOnITSLayer1() {fPointOnITSLayer1Flag = kTRUE;}
  void    SetPointOnITSLayer2() {fPointOnITSLayer2Flag = kTRUE;}
  void    SetPointOnITSLayer3() {fPointOnITSLayer3Flag = kTRUE;}
  void    SetPointOnITSLayer4() {fPointOnITSLayer4Flag = kTRUE;}
  void    SetPointOnITSLayer5() {fPointOnITSLayer5Flag = kTRUE;}
  void    SetPointOnITSLayer6() {fPointOnITSLayer6Flag = kTRUE;}
  Bool_t  IsUsedPointOnSPDLayer() const {return fPointOnSPDLayersFlag;}
  Bool_t  IsUsedPointOnSDDLayer() const {return fPointOnSDDLayersFlag;}
  Bool_t  IsUsedPointOnSSDLayer() const {return fPointOnSSDLayersFlag;}
  Bool_t  IsUsedPointOnITSLayer1() const {return fPointOnITSLayer1Flag;}
  Bool_t  IsUsedPointOnITSLayer2() const {return fPointOnITSLayer2Flag;}
  Bool_t  IsUsedPointOnITSLayer3() const {return fPointOnITSLayer3Flag;}
  Bool_t  IsUsedPointOnITSLayer4() const {return fPointOnITSLayer4Flag;}
  Bool_t  IsUsedPointOnITSLayer5() const {return fPointOnITSLayer5Flag;}
  Bool_t  IsUsedPointOnITSLayer6() const {return fPointOnITSLayer6Flag;}
  void    SetMinITSClusters(Int_t minITSClusters) {
    fMinITSClusters = minITSClusters;
    fMinITSClustersFlag = kTRUE;
  }
  Int_t   GetMinITSClusters() const {return fMinITSClusters;}
  Bool_t  IsUsedMinITSClusters() const {return fMinITSClustersFlag;}

  void    SetMaxChi2PerITSCluster(Double_t maxChi2PerITSCluster) {
    fMaxChi2PerITSCluster = maxChi2PerITSCluster;
    fMaxChi2PerITSClusterFlag = kTRUE;
  }
  Bool_t  IsUsedMaxChi2PerITSCluster() const {return fMaxChi2PerITSClusterFlag;}
  Double_t   GetMaxChi2PerITSCluster() const {return fMaxChi2PerITSCluster;}

  void    SetMinTPCClusters(Int_t minTPCClusters) {
    fMinTPCClusters = minTPCClusters;
    fMinTPCClustersFlag = kTRUE;
  }
  Bool_t  IsUsedMinTPCClusters() const {return fMinTPCClustersFlag;}
  Int_t   GetMinTPCClusters() const {return fMinTPCClusters;}

  void    SetMaxChi2PerTPCCluster(Double_t maxChi2PerTPCCluster) {
    fMaxChi2PerTPCCluster = maxChi2PerTPCCluster;
    fMaxChi2PerTPCClusterFlag = kTRUE;
  }
  Bool_t  IsUsedMaxChi2PerTPCCluster() const {return fMaxChi2PerTPCClusterFlag;}
  Double_t   GetMaxChi2PerTPCCluster() const {return fMaxChi2PerTPCCluster;}

  void    SetMaxCov11(Double_t maxCov11) {
    fMaxCov11 = maxCov11; fMaxCov11Flag = kTRUE;}
  void    SetMaxCov22(Double_t maxCov22) {
    fMaxCov22 = maxCov22; fMaxCov22Flag = kTRUE;}
  void    SetMaxCov33(Double_t maxCov33) {
    fMaxCov33 = maxCov33; fMaxCov33Flag = kTRUE;}
  void    SetMaxCov44(Double_t maxCov44) {
    fMaxCov44 = maxCov44; fMaxCov44Flag = kTRUE;}
  void    SetMaxCov55(Double_t maxCov55) {
    fMaxCov55 = maxCov55; fMaxCov55Flag = kTRUE;}
  Bool_t  IsUsedMaxCov11() const {return fMaxCov11Flag;}
  Bool_t  IsUsedMaxCov22() const {return fMaxCov22Flag;}
  Bool_t  IsUsedMaxCov33() const {return fMaxCov33Flag;}
  Bool_t  IsUsedMaxCov44() const {return fMaxCov44Flag;}
  Bool_t  IsUsedMaxCov55() const {return fMaxCov55Flag;}
  Double_t   GetMaxCov11() const {return fMaxCov11;}
  Double_t   GetMaxCov22() const {return fMaxCov22;}
  Double_t   GetMaxCov33() const {return fMaxCov33;}
  Double_t   GetMaxCov44() const {return fMaxCov44;}
  Double_t   GetMaxCov55() const {return fMaxCov55;}

  void    SetMaxSigmaToVertex(Double_t maxSigmaToVertex) {
    fMaxSigmaToVertex = maxSigmaToVertex;
    fMaxSigmaToVertexFlag = kTRUE;
  }
  Bool_t  IsUsedMaxSigmaToVertex() const {return fMaxSigmaToVertexFlag;}
  Double_t   GetMaxSigmaToVertex() const {return fMaxSigmaToVertex;}

  void    SetMaxSigmaToVertexTPC(Double_t maxSigmaToVertex) {
    fMaxSigmaToVertexTPC = maxSigmaToVertex;
    fMaxSigmaToVertexTPCFlag = kTRUE;
  }
  Bool_t  IsUsedMaxSigmaToVertexTPC() const {return fMaxSigmaToVertexTPCFlag;}
  Double_t   GetMaxSigmaToVertexTPC() const {return fMaxSigmaToVertexTPC;}

  void    SetMaxDCAXY(Double_t maxDCAXY) {
    fMaxDCAXY = maxDCAXY;
    fMaxDCAXYFlag = kTRUE;
  }
  Bool_t  IsUsedMaxDCAXY() const {return fMaxDCAXYFlag;}
  Double_t   GetMaxDCAXY() const {return fMaxDCAXY;}

  void    SetMaxDCAXYTPC(Double_t maxDCAXY) {
    fMaxDCAXYTPC = maxDCAXY;
    fMaxDCAXYTPCFlag = kTRUE;
  }
  Bool_t  IsUsedMaxDCAXYTPC() const {return fMaxDCAXYTPCFlag;}
  Double_t   GetMaxDCAXYTPC() const {return fMaxDCAXYTPC;}

  void    SetMaxDCAZ(Double_t maxDCAZ) {
    fMaxDCAZ = maxDCAZ;
    fMaxDCAZFlag = kTRUE;
  }
  Bool_t  IsUsedMaxDCAZ() const {return fMaxDCAZFlag;}
  Double_t   GetMaxDCAZ() const {return fMaxDCAZ;}

  void    SetMaxDCAZTPC(Double_t maxDCAZ) {
    fMaxDCAZTPC = maxDCAZ;
    fMaxDCAZTPCFlag = kTRUE;
  }
  Bool_t  IsUsedMaxDCAZTPC() const {return fMaxDCAZTPCFlag;}
  Double_t   GetMaxDCAZTPC() const {return fMaxDCAZTPC;}

  void    SetMaxDCA3D(Double_t maxDCA3D) {
    fMaxDCA3D = maxDCA3D;
    fMaxDCA3DFlag = kTRUE;
  }
  Bool_t  IsUsedMaxDCA3D() const {return fMaxDCA3DFlag;}
  Double_t   GetMaxDCA3D() const {return fMaxDCA3D;}

  void SetPtDependentDCAxy(Int_t nSigma, Double_t p0, 
			   Double_t p1, Double_t p2);
  Bool_t  IsUsedPtDependentDCAxy() const {return fPtDependentDcaXYFlag;}

  void    SetMaxDCA3DTPC(Double_t maxDCA3D) {
    fMaxDCA3DTPC = maxDCA3D;
    fMaxDCA3DTPCFlag = kTRUE;
  }
  Bool_t  IsUsedMaxDCA3DTPC() const {return fMaxDCA3DTPCFlag;}
  Double_t   GetMaxDCA3DTPC() const {return fMaxDCA3DTPC;}

  void    SetMaxConstrainChi2(Double_t maxConstrainChi2) {
    fMaxConstrainChi2 = maxConstrainChi2;
    fMaxConstrainChi2Flag = kTRUE;
  }
  Bool_t  IsUsedMaxConstrainChi2() const {return fMaxConstrainChi2Flag;}
  Double_t   GetMaxConstrainChi2() const {return fMaxConstrainChi2;}

  void    SetMinTPCdEdxPoints(Int_t mindEdxpoints) {
    fMinTPCdEdxPoints = mindEdxpoints;
    fMinTPCdEdxPointsFlag = kTRUE;
  }
  Bool_t  IsUsedMinTPCdEdxPoints() const {return fMinTPCdEdxPointsFlag;}
  Int_t   GetMinTPCdEdxPoints() const {return fMinTPCdEdxPoints;}
  
  void    SetITSRefit() {fITSRefitFlag = kTRUE;}
  Bool_t  IsUsedITSRefit() const {return fITSRefitFlag;}
  void    SetTPCRefit() {fTPCRefitFlag = kTRUE;}
  Bool_t  IsUsedTPCRefit() const {return fTPCRefitFlag;}
  void    SetESDpid() {fESDpidFlag = kTRUE;}
  Bool_t  IsUsedESDpid() const {return fESDpidFlag;}
  void    SetTPCpid() {fTPCpidFlag = kTRUE;}
  Bool_t  IsUsedTPCpid() const {return fTPCpidFlag;}
  void    SetTOFpid() {fTOFpidFlag = kTRUE;}
  Bool_t  IsUsedTOFpid() const {return fTOFpidFlag;}

  TCanvas *GetListOfCuts();

  //PID related functions
  Bool_t IsProton(AliESDtrack *track);
  void SetNSigma(Int_t nsigma) {fNSigma = nsigma;}  
  Int_t GetNSigma() const {return fNSigma;}
  void SetRatio(Double_t ratio) {fNRatio = ratio;}
  Double_t GetRatio() {return fNRatio;}
  void SetPriorProbabilities(Double_t * const partFrac) {
    for(Int_t i = 0; i < AliPID::kSPECIESN; i++) fPartFrac[i] = partFrac[i];} 
  void SetPriorProbabilityFunctions(TF1 *const felectron, 
				    TF1 *const fmuon, 
				    TF1 *const fpion, 
				    TF1 *const fkaon, 
				    TF1 *const fproton) {
    fFunctionProbabilityFlag = kTRUE;
    fElectronFunction = felectron; fMuonFunction = fmuon; 
    fPionFunction = fpion; fKaonFunction = fkaon; fProtonFunction = fproton;
  }
  Bool_t IsPriorProbabilityFunctionUsed() const {return fFunctionProbabilityFlag;}
  Double_t GetParticleFraction(Int_t i, Double_t p);
  //Double_t Bethe(Double_t bg) const;

  void SetDebugMode() {fDebugMode = kTRUE;}
  Bool_t GetDebugMode() const {return fDebugMode;}

  void SetRunQA() {fRunQAAnalysis = kTRUE;}
  Bool_t IsQARun() {return fRunQAAnalysis;}
  TList *GetVertexQAList() {return fListVertexQA;}

 private:
  AliProtonAnalysisBase(const AliProtonAnalysisBase&); // Not implemented
  AliProtonAnalysisBase& operator=(const AliProtonAnalysisBase&); // Not implemented

  TString fProtonAnalysisLevel;//"ESD", "AOD" or "MC"
  Bool_t fAnalysisMC; //kTRUE if MC analysis while reading the ESDs
  TriggerMode fTriggerMode; //Trigger mode
  Bool_t kUseOnlineTrigger; //use the online trigger or not
  Bool_t kUseOfflineTrigger; //use the offline trigger or not
  AliPhysicsSelection *fPhysicsSelection; //Trigger selection: offline
  AnalysisMode fProtonAnalysisMode; //Analysis mode: TPC-Hybrid-Global
  PIDMode fProtonPIDMode; //PID mode: Bayesian-dE/dx ratio-Nsigma areas
  Bool_t fAnalysisEtaMode; //run the analysis in eta or y

  Bool_t fRunQAAnalysis; //boolnean to indicate to run the QA or not
  Double_t fVxMax, fVyMax, fVzMax; //vertex diamond constrain 
  Int_t fMinNumOfContributors;//min number of contributors

  Int_t fNBinsX; //number of bins in y or eta
  Double_t fMinX, fMaxX; //min & max value of y or eta
  Int_t fNBinsY;  //number of bins in pT
  Double_t fMinY, fMaxY; //min & max value of pT
  
  //cuts
  Int_t fMinTPCClusters, fMinITSClusters; //min TPC & ITS clusters
  Double_t fMaxChi2PerTPCCluster, fMaxChi2PerITSCluster; //max chi2 per TPC & ITS cluster
  Double_t fMaxCov11, fMaxCov22, fMaxCov33, fMaxCov44, fMaxCov55; //max values of cov. matrix
  Double_t fMaxSigmaToVertex; //max sigma to vertex cut
  Double_t fMaxSigmaToVertexTPC; //max sigma to vertex cut
  Double_t fMaxDCAXY, fMaxDCAXYTPC; //max DCA xy
  Double_t fMaxDCAZ, fMaxDCAZTPC; //max DCA z
  Double_t fMaxDCA3D, fMaxDCA3DTPC; //max DCA 3D
  Double_t fMaxConstrainChi2; //max constrain chi2 - vertex
  Int_t  fMinTPCdEdxPoints;//min number of TPC points used for the dE/dx
  Bool_t fMinTPCClustersFlag, fMinITSClustersFlag; //shows if this cut is used or not
  Bool_t fMaxChi2PerTPCClusterFlag, fMaxChi2PerITSClusterFlag; //shows if this cut is used or not
  Bool_t fMaxCov11Flag, fMaxCov22Flag, fMaxCov33Flag, fMaxCov44Flag, fMaxCov55Flag; //shows if this cut is used or not
  Bool_t fMaxSigmaToVertexFlag; //shows if this cut is used or not
  Bool_t fMaxSigmaToVertexTPCFlag; //shows if this cut is used or not
  Bool_t fMaxDCAXYFlag, fMaxDCAXYTPCFlag; //shows if this cut is used or not
  Bool_t fMaxDCAZFlag, fMaxDCAZTPCFlag; //shows if this cut is used or not
  Bool_t fMaxDCA3DFlag, fMaxDCA3DTPCFlag; //shows if this cut is used or not
  Bool_t fMaxConstrainChi2Flag; //shows if this cut is used or not
  Bool_t fITSRefitFlag, fTPCRefitFlag; //shows if this cut is used or not
  Bool_t fESDpidFlag, fTPCpidFlag, fTOFpidFlag; //shows if this cut is used or not
  Bool_t fPointOnSPDLayersFlag;//shows if this cut is used or not
  Bool_t fPointOnSDDLayersFlag;//shows if this cut is used or not
  Bool_t fPointOnSSDLayersFlag;//shows if this cut is used or not
  Bool_t fPointOnITSLayer1Flag, fPointOnITSLayer2Flag; //shows if this cut is used or not
  Bool_t fPointOnITSLayer3Flag, fPointOnITSLayer4Flag; //shows if this cut is used or not
  Bool_t fPointOnITSLayer5Flag, fPointOnITSLayer6Flag; //shows if this cut is used or not
  Bool_t fMinTPCdEdxPointsFlag; //shows if this cut is used or not
  TF1  *fPtDependentDcaXY; //pt dependence dca cut (xy)
  Bool_t fPtDependentDcaXYFlag; //shows if this cut is used or not
  Int_t fNSigmaDCAXY; //n-sigma dca xy cut (pt dependent)

  //pid
  Bool_t fFunctionProbabilityFlag; //flag: kTRUE if functions used
  Int_t fNSigma; //N-sigma cut in the dE/dx band
  Double_t fNRatio; //min value of the ratio of the measured dE/dx vs the expected
  Double_t fPartFrac[10]; //prior probabilities
  TF1  *fElectronFunction; //momentum dependence of the prior probs
  TF1  *fMuonFunction; //momentum dependence of the prior probs
  TF1  *fPionFunction; //momentum dependence of the prior probs
  TF1  *fKaonFunction; //momentum dependence of the prior probs
  TF1  *fProtonFunction; //momentum dependence of the prior probs

  //Debug
  Bool_t fDebugMode; //Enable the debug mode

  //QA list
  TList *fListVertexQA; //vertex QA list

  ClassDef(AliProtonAnalysisBase,1);
};

#endif
Commit	Line	Data
0ab648ea	1	#ifndef ALIPROTONANALYSISBASE_H
	2	#define ALIPROTONANALYSISBASE_H
	3
	4	/* See cxx source for full Copyright notice */
	5
	6
	7	/* $Id: AliProtonAnalysisBase.h 31056 2009-02-16 14:31:41Z pchrist $ */
	8
	9	//-------------------------------------------------------------------------
	10	// Class AliProtonAnalysisBase
	11	// This is the base class for the baryon (proton) analysis
	12	//
	13	// Origin: Panos Christakoglou \| Panos.Christakoglou@cern.ch
	14	//-------------------------------------------------------------------------
	15
	16	#include "TObject.h"
	17	#include "TString.h"
	18	class TF1;
	19	class TCanvas;
735cc63d	20	class TList;
0ab648ea	21
f203beb9	22	#include "AliPhysicsSelection.h"
df201289	23	#include "AliBackgroundSelection.h"
0ab648ea	24	#include "AliPID.h"
	25	class AliESDEvent;
	26	class AliESDtrack;
	27	class AliESDVertex;
	28
	29	class AliProtonAnalysisBase : public TObject {
	30	public:
	31	enum TriggerMode { kMB1 = 0, kMB2, kSPDFASTOR };
afc2ac17	32	enum AnalysisMode { kInvalid = -1, kTPC = 0, kHybrid, kFullHybrid, kGlobal };
c6909683	33	enum PIDMode { kBayesian = 0, kRatio, kSigma};
0ab648ea	34
	35	AliProtonAnalysisBase();
	36	virtual ~AliProtonAnalysisBase();
	37
	38	void SetAnalysisLevel(const char* type) {fProtonAnalysisLevel = type;}
	39	void SetAnalysisMode(AnalysisMode analysismode) {fProtonAnalysisMode = analysismode;}
	40	void SetEtaMode() {fAnalysisEtaMode = kTRUE;}
790140ac	41	void SetTriggerMode(TriggerMode triggermode) {
790140ac	42	fAnalysisMC = kTRUE; fTriggerMode = triggermode;}
0ab648ea	43	void SetPIDMode(PIDMode pidmode) {fProtonPIDMode = pidmode;}
	44
	45	const char *GetAnalysisLevel() {return fProtonAnalysisLevel.Data();}
73aba974	46	AnalysisMode GetAnalysisMode() const {return fProtonAnalysisMode;}
	47	Bool_t GetEtaMode() const {return fAnalysisEtaMode;}
	48	TriggerMode GetTriggerMode() const {return fTriggerMode;}
	49	PIDMode GetPIDMode() const {return fProtonPIDMode;}
790140ac	50	Bool_t GetMCAnalysisMode() {return fAnalysisMC;}
0ab648ea	51
	52	const AliESDVertex GetVertex(AliESDEvent esd,
	53	AnalysisMode mode,
	54	Double_t gVx = 100.,
	55	Double_t gVy = 100.,
	56	Double_t gVz = 100.);
	57	void SetAcceptedVertexDiamond(Double_t gVx, Double_t gVy, Double_t gVz) {
	58	fVxMax = gVx; fVyMax = gVy; fVzMax = gVz;}
73aba974	59	Double_t GetVxMax() const {return fVxMax;}
	60	Double_t GetVyMax() const {return fVyMax;}
	61	Double_t GetVzMax() const {return fVzMax;}
e56f08ed	62	void SetMinNumOfContributors(Int_t nContributors) {
	63	fMinNumOfContributors = nContributors;}
	64	Int_t GetMinNumOfContributors() {return fMinNumOfContributors;}
0ab648ea	65
	66	void SetPhaseSpace(Int_t nBinsX, Double_t gXmin, Double_t gXmax,
	67	Int_t nBinsY, Double_t gYmin, Double_t gYmax) {
	68	fNBinsX = nBinsX; fMinX = gXmin; fMaxX = gXmax;
	69	fNBinsY = nBinsY; fMinY = gYmin; fMaxY = gYmax;
	70	}
73aba974	71	Int_t GetNBinsX() const {return fNBinsX;}
	72	Int_t GetNBinsY() const {return fNBinsY;}
	73	Double_t GetMinX() const {return fMinX;}
	74	Double_t GetMinY() const {return fMinY;}
	75	Double_t GetMaxX() const {return fMaxX;}
	76	Double_t GetMaxY() const {return fMaxY;}
0ab648ea	77
c21b8f31	78	//Trigger
e56f08ed	79	Bool_t IsOnlineTriggerUsed() {return kUseOnlineTrigger;}
e56f08ed	80	void UseOnlineTrigger() {kUseOnlineTrigger = kTRUE;}
42270c4c	81	Bool_t IsEventTriggered(const AliESDEvent *esd,
42270c4c	82	TriggerMode trigger = kMB2);
df201289	83	void OfflineTriggerInit() {
f203beb9	84	kUseOfflineTrigger = kTRUE;
f203beb9	85	fPhysicsSelection = new AliPhysicsSelection();
c21b8f31	86	fPhysicsSelection->AddBackgroundIdentification(new AliBackgroundSelection());
df201289	87	fPhysicsSelection->SetAnalyzeMC(fAnalysisMC);
f203beb9	88	}
	89	Bool_t IsOfflineTriggerUsed() {return kUseOfflineTrigger;}
	90	AliPhysicsSelection *GetPhysicsSelectionObject() {return fPhysicsSelection;}
c21b8f31	91
e56f08ed	92	Bool_t IsPrimary(AliESDEvent *esd,
	93	const AliESDVertex *vertex,
	94	AliESDtrack *track);
30f87a5b	95	Bool_t IsAccepted(AliESDtrack *track);
0ab648ea	96	Bool_t IsInPhaseSpace(AliESDtrack *track);
	97
	98	Float_t GetSigmaToVertex(AliESDtrack* esdTrack) const;
	99	Double_t Rapidity(Double_t Px, Double_t Py, Double_t Pz) const;
	100
	101	//Cut functions
4787e0ca	102	void SetPointOnSPDLayers() {fPointOnSPDLayersFlag = kTRUE;}
	103	void SetPointOnSDDLayers() {fPointOnSDDLayersFlag = kTRUE;}
	104	void SetPointOnSSDLayers() {fPointOnSSDLayersFlag = kTRUE;}
0ab648ea	105	void SetPointOnITSLayer1() {fPointOnITSLayer1Flag = kTRUE;}
	106	void SetPointOnITSLayer2() {fPointOnITSLayer2Flag = kTRUE;}
	107	void SetPointOnITSLayer3() {fPointOnITSLayer3Flag = kTRUE;}
	108	void SetPointOnITSLayer4() {fPointOnITSLayer4Flag = kTRUE;}
	109	void SetPointOnITSLayer5() {fPointOnITSLayer5Flag = kTRUE;}
	110	void SetPointOnITSLayer6() {fPointOnITSLayer6Flag = kTRUE;}
4787e0ca	111	Bool_t IsUsedPointOnSPDLayer() const {return fPointOnSPDLayersFlag;}
	112	Bool_t IsUsedPointOnSDDLayer() const {return fPointOnSDDLayersFlag;}
	113	Bool_t IsUsedPointOnSSDLayer() const {return fPointOnSSDLayersFlag;}
73aba974	114	Bool_t IsUsedPointOnITSLayer1() const {return fPointOnITSLayer1Flag;}
	115	Bool_t IsUsedPointOnITSLayer2() const {return fPointOnITSLayer2Flag;}
	116	Bool_t IsUsedPointOnITSLayer3() const {return fPointOnITSLayer3Flag;}
	117	Bool_t IsUsedPointOnITSLayer4() const {return fPointOnITSLayer4Flag;}
	118	Bool_t IsUsedPointOnITSLayer5() const {return fPointOnITSLayer5Flag;}
	119	Bool_t IsUsedPointOnITSLayer6() const {return fPointOnITSLayer6Flag;}
0ab648ea	120	void SetMinITSClusters(Int_t minITSClusters) {
	121	fMinITSClusters = minITSClusters;
	122	fMinITSClustersFlag = kTRUE;
	123	}
73aba974	124	Int_t GetMinITSClusters() const {return fMinITSClusters;}
73aba974	125	Bool_t IsUsedMinITSClusters() const {return fMinITSClustersFlag;}
e7df5638	126
0ab648ea	127	void SetMaxChi2PerITSCluster(Double_t maxChi2PerITSCluster) {
	128	fMaxChi2PerITSCluster = maxChi2PerITSCluster;
	129	fMaxChi2PerITSClusterFlag = kTRUE;
	130	}
73aba974	131	Bool_t IsUsedMaxChi2PerITSCluster() const {return fMaxChi2PerITSClusterFlag;}
73aba974	132	Double_t GetMaxChi2PerITSCluster() const {return fMaxChi2PerITSCluster;}
e7df5638	133
0ab648ea	134	void SetMinTPCClusters(Int_t minTPCClusters) {
	135	fMinTPCClusters = minTPCClusters;
	136	fMinTPCClustersFlag = kTRUE;
	137	}
73aba974	138	Bool_t IsUsedMinTPCClusters() const {return fMinTPCClustersFlag;}
73aba974	139	Int_t GetMinTPCClusters() const {return fMinTPCClusters;}
e7df5638	140
0ab648ea	141	void SetMaxChi2PerTPCCluster(Double_t maxChi2PerTPCCluster) {
	142	fMaxChi2PerTPCCluster = maxChi2PerTPCCluster;
	143	fMaxChi2PerTPCClusterFlag = kTRUE;
	144	}
73aba974	145	Bool_t IsUsedMaxChi2PerTPCCluster() const {return fMaxChi2PerTPCClusterFlag;}
73aba974	146	Double_t GetMaxChi2PerTPCCluster() const {return fMaxChi2PerTPCCluster;}
e7df5638	147
0ab648ea	148	void SetMaxCov11(Double_t maxCov11) {
	149	fMaxCov11 = maxCov11; fMaxCov11Flag = kTRUE;}
	150	void SetMaxCov22(Double_t maxCov22) {
	151	fMaxCov22 = maxCov22; fMaxCov22Flag = kTRUE;}
	152	void SetMaxCov33(Double_t maxCov33) {
	153	fMaxCov33 = maxCov33; fMaxCov33Flag = kTRUE;}
	154	void SetMaxCov44(Double_t maxCov44) {
	155	fMaxCov44 = maxCov44; fMaxCov44Flag = kTRUE;}
	156	void SetMaxCov55(Double_t maxCov55) {
	157	fMaxCov55 = maxCov55; fMaxCov55Flag = kTRUE;}
73aba974	158	Bool_t IsUsedMaxCov11() const {return fMaxCov11Flag;}
	159	Bool_t IsUsedMaxCov22() const {return fMaxCov22Flag;}
	160	Bool_t IsUsedMaxCov33() const {return fMaxCov33Flag;}
	161	Bool_t IsUsedMaxCov44() const {return fMaxCov44Flag;}
	162	Bool_t IsUsedMaxCov55() const {return fMaxCov55Flag;}
	163	Double_t GetMaxCov11() const {return fMaxCov11;}
	164	Double_t GetMaxCov22() const {return fMaxCov22;}
	165	Double_t GetMaxCov33() const {return fMaxCov33;}
	166	Double_t GetMaxCov44() const {return fMaxCov44;}
	167	Double_t GetMaxCov55() const {return fMaxCov55;}
e7df5638	168
0ab648ea	169	void SetMaxSigmaToVertex(Double_t maxSigmaToVertex) {
	170	fMaxSigmaToVertex = maxSigmaToVertex;
	171	fMaxSigmaToVertexFlag = kTRUE;
	172	}
73aba974	173	Bool_t IsUsedMaxSigmaToVertex() const {return fMaxSigmaToVertexFlag;}
73aba974	174	Double_t GetMaxSigmaToVertex() const {return fMaxSigmaToVertex;}
e7df5638	175
0ab648ea	176	void SetMaxSigmaToVertexTPC(Double_t maxSigmaToVertex) {
	177	fMaxSigmaToVertexTPC = maxSigmaToVertex;
	178	fMaxSigmaToVertexTPCFlag = kTRUE;
	179	}
73aba974	180	Bool_t IsUsedMaxSigmaToVertexTPC() const {return fMaxSigmaToVertexTPCFlag;}
73aba974	181	Double_t GetMaxSigmaToVertexTPC() const {return fMaxSigmaToVertexTPC;}
e7df5638	182
0ab648ea	183	void SetMaxDCAXY(Double_t maxDCAXY) {
	184	fMaxDCAXY = maxDCAXY;
	185	fMaxDCAXYFlag = kTRUE;
	186	}
73aba974	187	Bool_t IsUsedMaxDCAXY() const {return fMaxDCAXYFlag;}
73aba974	188	Double_t GetMaxDCAXY() const {return fMaxDCAXY;}
e7df5638	189
0ab648ea	190	void SetMaxDCAXYTPC(Double_t maxDCAXY) {
	191	fMaxDCAXYTPC = maxDCAXY;
	192	fMaxDCAXYTPCFlag = kTRUE;
	193	}
73aba974	194	Bool_t IsUsedMaxDCAXYTPC() const {return fMaxDCAXYTPCFlag;}
73aba974	195	Double_t GetMaxDCAXYTPC() const {return fMaxDCAXYTPC;}
e7df5638	196
0ab648ea	197	void SetMaxDCAZ(Double_t maxDCAZ) {
	198	fMaxDCAZ = maxDCAZ;
	199	fMaxDCAZFlag = kTRUE;
	200	}
73aba974	201	Bool_t IsUsedMaxDCAZ() const {return fMaxDCAZFlag;}
73aba974	202	Double_t GetMaxDCAZ() const {return fMaxDCAZ;}
e7df5638	203
0ab648ea	204	void SetMaxDCAZTPC(Double_t maxDCAZ) {
	205	fMaxDCAZTPC = maxDCAZ;
	206	fMaxDCAZTPCFlag = kTRUE;
	207	}
73aba974	208	Bool_t IsUsedMaxDCAZTPC() const {return fMaxDCAZTPCFlag;}
73aba974	209	Double_t GetMaxDCAZTPC() const {return fMaxDCAZTPC;}
e7df5638	210
0ab648ea	211	void SetMaxDCA3D(Double_t maxDCA3D) {
	212	fMaxDCA3D = maxDCA3D;
	213	fMaxDCA3DFlag = kTRUE;
	214	}
73aba974	215	Bool_t IsUsedMaxDCA3D() const {return fMaxDCA3DFlag;}
73aba974	216	Double_t GetMaxDCA3D() const {return fMaxDCA3D;}
e7df5638	217
ff1c9f70	218	void SetPtDependentDCAxy(Int_t nSigma, Double_t p0,
	219	Double_t p1, Double_t p2);
	220	Bool_t IsUsedPtDependentDCAxy() const {return fPtDependentDcaXYFlag;}
	221
0ab648ea	222	void SetMaxDCA3DTPC(Double_t maxDCA3D) {
	223	fMaxDCA3DTPC = maxDCA3D;
	224	fMaxDCA3DTPCFlag = kTRUE;
	225	}
73aba974	226	Bool_t IsUsedMaxDCA3DTPC() const {return fMaxDCA3DTPCFlag;}
73aba974	227	Double_t GetMaxDCA3DTPC() const {return fMaxDCA3DTPC;}
e7df5638	228
0ab648ea	229	void SetMaxConstrainChi2(Double_t maxConstrainChi2) {
	230	fMaxConstrainChi2 = maxConstrainChi2;
	231	fMaxConstrainChi2Flag = kTRUE;
	232	}
73aba974	233	Bool_t IsUsedMaxConstrainChi2() const {return fMaxConstrainChi2Flag;}
73aba974	234	Double_t GetMaxConstrainChi2() const {return fMaxConstrainChi2;}
e7df5638	235
87a55728	236	void SetMinTPCdEdxPoints(Int_t mindEdxpoints) {
	237	fMinTPCdEdxPoints = mindEdxpoints;
	238	fMinTPCdEdxPointsFlag = kTRUE;
	239	}
73aba974	240	Bool_t IsUsedMinTPCdEdxPoints() const {return fMinTPCdEdxPointsFlag;}
73aba974	241	Int_t GetMinTPCdEdxPoints() const {return fMinTPCdEdxPoints;}
87a55728	242
0ab648ea	243	void SetITSRefit() {fITSRefitFlag = kTRUE;}
73aba974	244	Bool_t IsUsedITSRefit() const {return fITSRefitFlag;}
0ab648ea	245	void SetTPCRefit() {fTPCRefitFlag = kTRUE;}
73aba974	246	Bool_t IsUsedTPCRefit() const {return fTPCRefitFlag;}
0ab648ea	247	void SetESDpid() {fESDpidFlag = kTRUE;}
73aba974	248	Bool_t IsUsedESDpid() const {return fESDpidFlag;}
0ab648ea	249	void SetTPCpid() {fTPCpidFlag = kTRUE;}
73aba974	250	Bool_t IsUsedTPCpid() const {return fTPCpidFlag;}
f62e9410	251	void SetTOFpid() {fTOFpidFlag = kTRUE;}
f62e9410	252	Bool_t IsUsedTOFpid() const {return fTOFpidFlag;}
0ab648ea	253
	254	TCanvas *GetListOfCuts();
	255
	256	//PID related functions
	257	Bool_t IsProton(AliESDtrack *track);
87a55728	258	void SetNSigma(Int_t nsigma) {fNSigma = nsigma;}
73aba974	259	Int_t GetNSigma() const {return fNSigma;}
c6909683	260	void SetRatio(Double_t ratio) {fNRatio = ratio;}
c6909683	261	Double_t GetRatio() {return fNRatio;}
0ab648ea	262	void SetPriorProbabilities(Double_t * const partFrac) {
	263	for(Int_t i = 0; i < AliPID::kSPECIESN; i++) fPartFrac[i] = partFrac[i];}
	264	void SetPriorProbabilityFunctions(TF1 *const felectron,
	265	TF1 *const fmuon,
	266	TF1 *const fpion,
	267	TF1 *const fkaon,
	268	TF1 *const fproton) {
	269	fFunctionProbabilityFlag = kTRUE;
73aba974	270	fElectronFunction = felectron; fMuonFunction = fmuon;
73aba974	271	fPionFunction = fpion; fKaonFunction = fkaon; fProtonFunction = fproton;
0ab648ea	272	}
73aba974	273	Bool_t IsPriorProbabilityFunctionUsed() const {return fFunctionProbabilityFlag;}
0ab648ea	274	Double_t GetParticleFraction(Int_t i, Double_t p);
c6909683	275	//Double_t Bethe(Double_t bg) const;
0ab648ea	276
0ab648ea	277	void SetDebugMode() {fDebugMode = kTRUE;}
73aba974	278	Bool_t GetDebugMode() const {return fDebugMode;}
0ab648ea	279
2f6dae44	280	void SetRunQA() {fRunQAAnalysis = kTRUE;}
2f6dae44	281	Bool_t IsQARun() {return fRunQAAnalysis;}
735cc63d	282	TList *GetVertexQAList() {return fListVertexQA;}
735cc63d	283
0ab648ea	284	private:
	285	AliProtonAnalysisBase(const AliProtonAnalysisBase&); // Not implemented
	286	AliProtonAnalysisBase& operator=(const AliProtonAnalysisBase&); // Not implemented
	287
	288	TString fProtonAnalysisLevel;//"ESD", "AOD" or "MC"
0bb8f6b4	289	Bool_t fAnalysisMC; //kTRUE if MC analysis while reading the ESDs
0ab648ea	290	TriggerMode fTriggerMode; //Trigger mode
e56f08ed	291	Bool_t kUseOnlineTrigger; //use the online trigger or not
f203beb9	292	Bool_t kUseOfflineTrigger; //use the offline trigger or not
f203beb9	293	AliPhysicsSelection *fPhysicsSelection; //Trigger selection: offline
0ab648ea	294	AnalysisMode fProtonAnalysisMode; //Analysis mode: TPC-Hybrid-Global
	295	PIDMode fProtonPIDMode; //PID mode: Bayesian-dE/dx ratio-Nsigma areas
	296	Bool_t fAnalysisEtaMode; //run the analysis in eta or y
	297
2f6dae44	298	Bool_t fRunQAAnalysis; //boolnean to indicate to run the QA or not
0ab648ea	299	Double_t fVxMax, fVyMax, fVzMax; //vertex diamond constrain
e56f08ed	300	Int_t fMinNumOfContributors;//min number of contributors
0ab648ea	301
	302	Int_t fNBinsX; //number of bins in y or eta
	303	Double_t fMinX, fMaxX; //min & max value of y or eta
	304	Int_t fNBinsY; //number of bins in pT
	305	Double_t fMinY, fMaxY; //min & max value of pT
	306
	307	//cuts
	308	Int_t fMinTPCClusters, fMinITSClusters; //min TPC & ITS clusters
	309	Double_t fMaxChi2PerTPCCluster, fMaxChi2PerITSCluster; //max chi2 per TPC & ITS cluster
	310	Double_t fMaxCov11, fMaxCov22, fMaxCov33, fMaxCov44, fMaxCov55; //max values of cov. matrix
	311	Double_t fMaxSigmaToVertex; //max sigma to vertex cut
	312	Double_t fMaxSigmaToVertexTPC; //max sigma to vertex cut
	313	Double_t fMaxDCAXY, fMaxDCAXYTPC; //max DCA xy
	314	Double_t fMaxDCAZ, fMaxDCAZTPC; //max DCA z
	315	Double_t fMaxDCA3D, fMaxDCA3DTPC; //max DCA 3D
	316	Double_t fMaxConstrainChi2; //max constrain chi2 - vertex
87a55728	317	Int_t fMinTPCdEdxPoints;//min number of TPC points used for the dE/dx
0ab648ea	318	Bool_t fMinTPCClustersFlag, fMinITSClustersFlag; //shows if this cut is used or not
	319	Bool_t fMaxChi2PerTPCClusterFlag, fMaxChi2PerITSClusterFlag; //shows if this cut is used or not
	320	Bool_t fMaxCov11Flag, fMaxCov22Flag, fMaxCov33Flag, fMaxCov44Flag, fMaxCov55Flag; //shows if this cut is used or not
	321	Bool_t fMaxSigmaToVertexFlag; //shows if this cut is used or not
	322	Bool_t fMaxSigmaToVertexTPCFlag; //shows if this cut is used or not
	323	Bool_t fMaxDCAXYFlag, fMaxDCAXYTPCFlag; //shows if this cut is used or not
	324	Bool_t fMaxDCAZFlag, fMaxDCAZTPCFlag; //shows if this cut is used or not
	325	Bool_t fMaxDCA3DFlag, fMaxDCA3DTPCFlag; //shows if this cut is used or not
	326	Bool_t fMaxConstrainChi2Flag; //shows if this cut is used or not
	327	Bool_t fITSRefitFlag, fTPCRefitFlag; //shows if this cut is used or not
f62e9410	328	Bool_t fESDpidFlag, fTPCpidFlag, fTOFpidFlag; //shows if this cut is used or not
4787e0ca	329	Bool_t fPointOnSPDLayersFlag;//shows if this cut is used or not
	330	Bool_t fPointOnSDDLayersFlag;//shows if this cut is used or not
	331	Bool_t fPointOnSSDLayersFlag;//shows if this cut is used or not
0ab648ea	332	Bool_t fPointOnITSLayer1Flag, fPointOnITSLayer2Flag; //shows if this cut is used or not
	333	Bool_t fPointOnITSLayer3Flag, fPointOnITSLayer4Flag; //shows if this cut is used or not
	334	Bool_t fPointOnITSLayer5Flag, fPointOnITSLayer6Flag; //shows if this cut is used or not
87a55728	335	Bool_t fMinTPCdEdxPointsFlag; //shows if this cut is used or not
ff1c9f70	336	TF1 *fPtDependentDcaXY; //pt dependence dca cut (xy)
	337	Bool_t fPtDependentDcaXYFlag; //shows if this cut is used or not
	338	Int_t fNSigmaDCAXY; //n-sigma dca xy cut (pt dependent)
87a55728	339
0ab648ea	340	//pid
0ab648ea	341	Bool_t fFunctionProbabilityFlag; //flag: kTRUE if functions used
87a55728	342	Int_t fNSigma; //N-sigma cut in the dE/dx band
c6909683	343	Double_t fNRatio; //min value of the ratio of the measured dE/dx vs the expected
0ab648ea	344	Double_t fPartFrac[10]; //prior probabilities
	345	TF1 *fElectronFunction; //momentum dependence of the prior probs
	346	TF1 *fMuonFunction; //momentum dependence of the prior probs
	347	TF1 *fPionFunction; //momentum dependence of the prior probs
	348	TF1 *fKaonFunction; //momentum dependence of the prior probs
	349	TF1 *fProtonFunction; //momentum dependence of the prior probs
	350
	351	//Debug
	352	Bool_t fDebugMode; //Enable the debug mode
	353
735cc63d	354	//QA list
	355	TList *fListVertexQA; //vertex QA list
	356
e7df5638	357	ClassDef(AliProtonAnalysisBase,1);
0ab648ea	358	};
	359
	360	#endif