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

#ifndef ALIPROTONANALYSIS_H
#define ALIPROTONANALYSIS_H

/*  See cxx source for full Copyright notice */


/* $Id$ */

//-------------------------------------------------------------------------
//                       Class AliProtonAnalysis
//   This is the class for the baryon (proton) analysis
//
//    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
//-------------------------------------------------------------------------

#include "TObject.h"
#include "TH1I.h"
#include "TList.h"

#include "AliPID.h"

class TF1;
class TH2D;
class TH1F;

#include "AliCFContainer.h"
class AliCFDataGrid;
class AliAODEvent;
class AliAODtrack;
class AliESDEvent;
class AliESDtrack;
class AliExternalTrackParam;
class AliStack;

class AliProtonAnalysis : public TObject {
 public:
  AliProtonAnalysis();
  AliProtonAnalysis(Int_t nbinsY, Float_t fLowY, Float_t fHighY,
		    Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);
  virtual ~AliProtonAnalysis();

  void UseTPCOnly() {fUseTPCOnly = kTRUE;}
  
  void InitAnalysisHistograms(Int_t nbinsY, Float_t fLowY, Float_t fHighY,
			      Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);
  Bool_t ReadFromFile(const char* filename);
  void Analyze(AliESDEvent *fESD);
  void Analyze(AliAODEvent *fAOD);
  void Analyze(AliStack *stack);
  
  AliCFContainer *GetProtonContainer() {return fProtonContainer;}
  AliCFContainer *GetAntiProtonContainer() {return fAntiProtonContainer;}

  TH2D *GetProtonYPtHistogram() {return fHistYPtProtons;}
  TH2D *GetAntiProtonYPtHistogram() {return fHistYPtAntiProtons;}
  TH1D *GetProtonYHistogram();
  TH1D *GetAntiProtonYHistogram();
  TH1D *GetProtonPtHistogram();
  TH1D *GetAntiProtonPtHistogram();
  TH1D *GetProtonCorrectedYHistogram();
  TH1D *GetAntiProtonCorrectedYHistogram();
  TH1D *GetProtonCorrectedPtHistogram();
  TH1D *GetAntiProtonCorrectedPtHistogram();
  
  TH1D *GetYRatioHistogram();
  TH1D *GetPtRatioHistogram();
  TH1D *GetYAsymmetryHistogram();
  TH1D *GetPtAsymmetryHistogram();

  TH1I *GetEventHistogram() {return fHistEvents;}

  Int_t   GetNumberOfAnalyzedEvents() {return (Int_t)fHistEvents->GetEntries();} 
  Bool_t  PrintMean(TH1 *hist, Double_t edge);
  Bool_t  PrintYields(TH1 *hist, Double_t edge); 

  //Cut functions
  void    SetPointOnITSLayer1() {fPointOnITSLayer1Flag = kTRUE;}
  void    SetPointOnITSLayer2() {fPointOnITSLayer2Flag = kTRUE;}
  void    SetPointOnITSLayer3() {fPointOnITSLayer3Flag = kTRUE;}
  void    SetPointOnITSLayer4() {fPointOnITSLayer4Flag = kTRUE;}
  void    SetPointOnITSLayer5() {fPointOnITSLayer5Flag = kTRUE;}
  void    SetPointOnITSLayer6() {fPointOnITSLayer6Flag = kTRUE;}
  void    SetMinITSClusters(Int_t minITSClusters) {
    fMinITSClusters = minITSClusters;
    fMinITSClustersFlag = kTRUE;
  }
  void    SetMaxChi2PerITSCluster(Double_t maxChi2PerITSCluster) {
    fMaxChi2PerITSCluster = maxChi2PerITSCluster;
    fMaxChi2PerITSClusterFlag = kTRUE;
  }
  void    SetMinTPCClusters(Int_t minTPCClusters) {
    fMinTPCClusters = minTPCClusters;
    fMinTPCClustersFlag = kTRUE;
  }
  void    SetMaxChi2PerTPCCluster(Double_t maxChi2PerTPCCluster) {
    fMaxChi2PerTPCCluster = maxChi2PerTPCCluster;
    fMaxChi2PerTPCClusterFlag = kTRUE;
  }
  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;}
  void    SetMaxSigmaToVertex(Double_t maxSigmaToVertex) {
    fMaxSigmaToVertex = maxSigmaToVertex;
    fMaxSigmaToVertexFlag = kTRUE;
  }
  void    SetMaxSigmaToVertexTPC(Double_t maxSigmaToVertex) {
    fMaxSigmaToVertexTPC = maxSigmaToVertex;
    fMaxSigmaToVertexTPCFlag = kTRUE;
  }
  void    SetMaxDCAXY(Double_t maxDCAXY) {
    fMaxDCAXY = maxDCAXY;
    fMaxDCAXYFlag = kTRUE;
  }
  void    SetMaxDCAXYTPC(Double_t maxDCAXY) {
    fMaxDCAXYTPC = maxDCAXY;
    fMaxDCAXYTPCFlag = kTRUE;
  }
  void    SetMaxDCAZ(Double_t maxDCAZ) {
    fMaxDCAZ = maxDCAZ;
    fMaxDCAZFlag = kTRUE;
  }
  void    SetMaxDCAZTPC(Double_t maxDCAZ) {
    fMaxDCAZTPC = maxDCAZ;
    fMaxDCAZTPCFlag = kTRUE;
  }
  void    SetMaxConstrainChi2(Double_t maxConstrainChi2) {
    fMaxConstrainChi2 = maxConstrainChi2;
    fMaxConstrainChi2Flag = kTRUE;
  }
  void    SetITSRefit() {fITSRefitFlag = kTRUE;}
  void    SetTPCRefit() {fTPCRefitFlag = kTRUE;}
  void    SetESDpid() {fESDpidFlag = kTRUE;}
  void    SetTPCpid() {fTPCpidFlag = kTRUE;}

  //Prior probabilities
  void SetPriorProbabilities(Double_t *partFrac) {
    for(Int_t i = 0; i < AliPID::kSPECIESN; i++) fPartFrac[i] = partFrac[i];} 
  void SetPriorProbabilityFunctions(TF1 *felectron, TF1 *fmuon, TF1 *fpion, TF1 *fkaon, TF1 *fproton) {
    fFunctionProbabilityFlag = kTRUE;
    fElectronFunction = felectron; 
    fMuonFunction = fmuon; 
    fPionFunction = fpion;
    fKaonFunction = fkaon;
    fProtonFunction = fproton;
  } 
  Double_t GetParticleFraction(Int_t i, Double_t p);

  //interface to the correction framework
  void Correct(Int_t step);
  Bool_t ReadCorrectionContainer(const char* filename);
  TList *GetCorrectionListProtons2D() {return fCorrectionListProtons2D;} 
  TList *GetEfficiencyListProtons1D() {return fEfficiencyListProtons1D;} 
  TList *GetCorrectionListProtons1D() {return fCorrectionListProtons1D;} 
  TList *GetCorrectionListAntiProtons2D() {return fCorrectionListAntiProtons2D;} 
  TList *GetEfficiencyListAntiProtons1D() {return fEfficiencyListAntiProtons1D;} 
  TList *GetCorrectionListAntiProtons1D() {return fCorrectionListAntiProtons1D;} 
  
  //iStep=0->MC - iStep=1->Acceptance - iStep=2->Reconstruction - iStep=3->PID
  TH1D  *GetUncorrectedProtonYHistogram(Int_t iStep) {return fProtonContainer->ShowProjection(0, iStep);}
  TH1D  *GetUncorrectedProtonPtHistogram(Int_t iStep) {return fProtonContainer->ShowProjection(1, iStep);}
  TH1D  *GetUncorrectedAntiProtonYHistogram(Int_t iStep) {return fAntiProtonContainer->ShowProjection(0, iStep);}
  TH1D  *GetUncorrectedAntiProtonPtHistogram(Int_t iStep) {return fAntiProtonContainer->ShowProjection(1, iStep);}

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

  Bool_t   IsAccepted(AliESDtrack *track);
  Float_t  GetSigmaToVertex(AliESDtrack* esdTrack); 
  Double_t Rapidity(Double_t Px, Double_t Py, Double_t Pz);
  
  Int_t fNBinsY; //number of bins in y
  Float_t fMinY, fMaxY; //min & max value of y
  Int_t fNBinsPt;  //number of bins in pT
  Float_t fMinPt, fMaxPt; //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 fMaxConstrainChi2; //max constrain chi2 - vertex
  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 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; //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
  
  //pid
  Bool_t fFunctionProbabilityFlag; //flag: kTRUE if functions used
  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

  //Detectors
  Bool_t fUseTPCOnly; //kTRUE if TPC only information is used

  //Analysis containers
  AliCFContainer *fProtonContainer; //container for protons
  AliCFContainer *fAntiProtonContainer; //container for antiprotons
  TH1I *fHistEvents; //event counter
  TH2D *fHistYPtProtons; //Y-Pt of Protons
  TH2D *fHistYPtAntiProtons; // Y-Pt of Antiprotons

  //Corrections
  TList *fEffGridListProtons; //list for the efficiency grid - protons 
  TList *fCorrectionListProtons2D; //list for the 2d corrections 
  TList *fEfficiencyListProtons1D; //list for the 1d efficiencies
  TList *fCorrectionListProtons1D; //list for the 1d corrections 
  TList *fEffGridListAntiProtons; //list for the efficiency grid - antiprotons 
  TList *fCorrectionListAntiProtons2D; //list for the 2d corrections 
  TList *fEfficiencyListAntiProtons1D; //list for the 1d efficiencies
  TList *fCorrectionListAntiProtons1D; //list for the 1d corrections 
  AliCFDataGrid *fCorrectProtons; //corrected data grid for protons
  AliCFDataGrid *fCorrectAntiProtons; //corrected data grid for antiprotons

  ClassDef(AliProtonAnalysis,0);
};

#endif
Commit	Line	Data
734d2c12	1	#ifndef ALIPROTONANALYSIS_H
	2	#define ALIPROTONANALYSIS_H
	3
	4	/* See cxx source for full Copyright notice */
	5
	6
	7	/* $Id$ */
	8
	9	//-------------------------------------------------------------------------
	10	// Class AliProtonAnalysis
	11	// This is the class for the baryon (proton) analysis
	12	//
	13	// Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
	14	//-------------------------------------------------------------------------
	15
251e4034	16	#include "TObject.h"
3f6d0c08	17	#include "TH1I.h"
ef1a8dbd	18	#include "TList.h"
3f6d0c08	19
ee4ca40d	20	#include "AliPID.h"
734d2c12	21
aafecd8b	22	class TF1;
251e4034	23	class TH2D;
251e4034	24	class TH1F;
3f6d0c08	25
24421eb6	26	#include "AliCFContainer.h"
251e4034	27	class AliCFDataGrid;
ee4ca40d	28	class AliAODEvent;
ee4ca40d	29	class AliAODtrack;
734d2c12	30	class AliESDEvent;
734d2c12	31	class AliESDtrack;
2b748670	32	class AliExternalTrackParam;
e4358d7f	33	class AliStack;
734d2c12	34
	35	class AliProtonAnalysis : public TObject {
	36	public:
	37	AliProtonAnalysis();
	38	AliProtonAnalysis(Int_t nbinsY, Float_t fLowY, Float_t fHighY,
	39	Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);
	40	virtual ~AliProtonAnalysis();
2b748670	41
2b748670	42	void UseTPCOnly() {fUseTPCOnly = kTRUE;}
734d2c12	43
ef1a8dbd	44	void InitAnalysisHistograms(Int_t nbinsY, Float_t fLowY, Float_t fHighY,
ef1a8dbd	45	Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);
2b748670	46	Bool_t ReadFromFile(const char* filename);
ef1a8dbd	47	void Analyze(AliESDEvent *fESD);
	48	void Analyze(AliAODEvent *fAOD);
	49	void Analyze(AliStack *stack);
734d2c12	50
251e4034	51	AliCFContainer *GetProtonContainer() {return fProtonContainer;}
	52	AliCFContainer *GetAntiProtonContainer() {return fAntiProtonContainer;}
	53
	54	TH2D *GetProtonYPtHistogram() {return fHistYPtProtons;}
	55	TH2D *GetAntiProtonYPtHistogram() {return fHistYPtAntiProtons;}
734d2c12	56	TH1D *GetProtonYHistogram();
	57	TH1D *GetAntiProtonYHistogram();
	58	TH1D *GetProtonPtHistogram();
	59	TH1D *GetAntiProtonPtHistogram();
251e4034	60	TH1D *GetProtonCorrectedYHistogram();
	61	TH1D *GetAntiProtonCorrectedYHistogram();
	62	TH1D *GetProtonCorrectedPtHistogram();
	63	TH1D *GetAntiProtonCorrectedPtHistogram();
24421eb6	64
734d2c12	65	TH1D *GetYRatioHistogram();
	66	TH1D *GetPtRatioHistogram();
	67	TH1D *GetYAsymmetryHistogram();
	68	TH1D *GetPtAsymmetryHistogram();
3f6d0c08	69
251e4034	70	TH1I *GetEventHistogram() {return fHistEvents;}
41beb956	71
3f6d0c08	72	Int_t GetNumberOfAnalyzedEvents() {return (Int_t)fHistEvents->GetEntries();}
	73	Bool_t PrintMean(TH1 *hist, Double_t edge);
	74	Bool_t PrintYields(TH1 *hist, Double_t edge);
	75
734d2c12	76	//Cut functions
0008a5a6	77	void SetPointOnITSLayer1() {fPointOnITSLayer1Flag = kTRUE;}
	78	void SetPointOnITSLayer2() {fPointOnITSLayer2Flag = kTRUE;}
	79	void SetPointOnITSLayer3() {fPointOnITSLayer3Flag = kTRUE;}
	80	void SetPointOnITSLayer4() {fPointOnITSLayer4Flag = kTRUE;}
	81	void SetPointOnITSLayer5() {fPointOnITSLayer5Flag = kTRUE;}
	82	void SetPointOnITSLayer6() {fPointOnITSLayer6Flag = kTRUE;}
734d2c12	83	void SetMinITSClusters(Int_t minITSClusters) {
	84	fMinITSClusters = minITSClusters;
	85	fMinITSClustersFlag = kTRUE;
	86	}
734d2c12	87	void SetMaxChi2PerITSCluster(Double_t maxChi2PerITSCluster) {
	88	fMaxChi2PerITSCluster = maxChi2PerITSCluster;
	89	fMaxChi2PerITSClusterFlag = kTRUE;
	90	}
f24a70b0	91	void SetMinTPCClusters(Int_t minTPCClusters) {
	92	fMinTPCClusters = minTPCClusters;
	93	fMinTPCClustersFlag = kTRUE;
	94	}
	95	void SetMaxChi2PerTPCCluster(Double_t maxChi2PerTPCCluster) {
	96	fMaxChi2PerTPCCluster = maxChi2PerTPCCluster;
	97	fMaxChi2PerTPCClusterFlag = kTRUE;
	98	}
251e4034	99	void SetMaxCov11(Double_t maxCov11) {
	100	fMaxCov11 = maxCov11; fMaxCov11Flag = kTRUE;}
	101	void SetMaxCov22(Double_t maxCov22) {
	102	fMaxCov22 = maxCov22; fMaxCov22Flag = kTRUE;}
	103	void SetMaxCov33(Double_t maxCov33) {
	104	fMaxCov33 = maxCov33; fMaxCov33Flag = kTRUE;}
	105	void SetMaxCov44(Double_t maxCov44) {
	106	fMaxCov44 = maxCov44; fMaxCov44Flag = kTRUE;}
	107	void SetMaxCov55(Double_t maxCov55) {
	108	fMaxCov55 = maxCov55; fMaxCov55Flag = kTRUE;}
734d2c12	109	void SetMaxSigmaToVertex(Double_t maxSigmaToVertex) {
	110	fMaxSigmaToVertex = maxSigmaToVertex;
	111	fMaxSigmaToVertexFlag = kTRUE;
	112	}
f24a70b0	113	void SetMaxSigmaToVertexTPC(Double_t maxSigmaToVertex) {
	114	fMaxSigmaToVertexTPC = maxSigmaToVertex;
	115	fMaxSigmaToVertexTPCFlag = kTRUE;
	116	}
96f84c25	117	void SetMaxDCAXY(Double_t maxDCAXY) {
	118	fMaxDCAXY = maxDCAXY;
	119	fMaxDCAXYFlag = kTRUE;
	120	}
	121	void SetMaxDCAXYTPC(Double_t maxDCAXY) {
	122	fMaxDCAXYTPC = maxDCAXY;
	123	fMaxDCAXYTPCFlag = kTRUE;
	124	}
	125	void SetMaxDCAZ(Double_t maxDCAZ) {
	126	fMaxDCAZ = maxDCAZ;
	127	fMaxDCAZFlag = kTRUE;
	128	}
	129	void SetMaxDCAZTPC(Double_t maxDCAZ) {
	130	fMaxDCAZTPC = maxDCAZ;
	131	fMaxDCAZTPCFlag = kTRUE;
	132	}
	133	void SetMaxConstrainChi2(Double_t maxConstrainChi2) {
	134	fMaxConstrainChi2 = maxConstrainChi2;
	135	fMaxConstrainChi2Flag = kTRUE;
	136	}
734d2c12	137	void SetITSRefit() {fITSRefitFlag = kTRUE;}
734d2c12	138	void SetTPCRefit() {fTPCRefitFlag = kTRUE;}
f24a70b0	139	void SetESDpid() {fESDpidFlag = kTRUE;}
f24a70b0	140	void SetTPCpid() {fTPCpidFlag = kTRUE;}
ef1a8dbd	141
734d2c12	142	//Prior probabilities
251e4034	143	void SetPriorProbabilities(Double_t *partFrac) {
251e4034	144	for(Int_t i = 0; i < AliPID::kSPECIESN; i++) fPartFrac[i] = partFrac[i];}
f24a70b0	145	void SetPriorProbabilityFunctions(TF1 felectron, TF1 fmuon, TF1 fpion, TF1 fkaon, TF1 *fproton) {
aafecd8b	146	fFunctionProbabilityFlag = kTRUE;
	147	fElectronFunction = felectron;
	148	fMuonFunction = fmuon;
	149	fPionFunction = fpion;
	150	fKaonFunction = fkaon;
	151	fProtonFunction = fproton;
	152	}
	153	Double_t GetParticleFraction(Int_t i, Double_t p);
	154
39f2a708	155	//interface to the correction framework
251e4034	156	void Correct(Int_t step);
39f2a708	157	Bool_t ReadCorrectionContainer(const char* filename);
cdb3530f	158	TList *GetCorrectionListProtons2D() {return fCorrectionListProtons2D;}
	159	TList *GetEfficiencyListProtons1D() {return fEfficiencyListProtons1D;}
	160	TList *GetCorrectionListProtons1D() {return fCorrectionListProtons1D;}
	161	TList *GetCorrectionListAntiProtons2D() {return fCorrectionListAntiProtons2D;}
	162	TList *GetEfficiencyListAntiProtons1D() {return fEfficiencyListAntiProtons1D;}
	163	TList *GetCorrectionListAntiProtons1D() {return fCorrectionListAntiProtons1D;}
24421eb6	164
	165	//iStep=0->MC - iStep=1->Acceptance - iStep=2->Reconstruction - iStep=3->PID
	166	TH1D *GetUncorrectedProtonYHistogram(Int_t iStep) {return fProtonContainer->ShowProjection(0, iStep);}
	167	TH1D *GetUncorrectedProtonPtHistogram(Int_t iStep) {return fProtonContainer->ShowProjection(1, iStep);}
	168	TH1D *GetUncorrectedAntiProtonYHistogram(Int_t iStep) {return fAntiProtonContainer->ShowProjection(0, iStep);}
	169	TH1D *GetUncorrectedAntiProtonPtHistogram(Int_t iStep) {return fAntiProtonContainer->ShowProjection(1, iStep);}
39f2a708	170
734d2c12	171	private:
8b8b0b7a	172	AliProtonAnalysis(const AliProtonAnalysis&); // Not implemented
	173	AliProtonAnalysis& operator=(const AliProtonAnalysis&); // Not implemented
	174
88c900f2	175	Bool_t IsAccepted(AliESDtrack *track);
88c900f2	176	Float_t GetSigmaToVertex(AliESDtrack* esdTrack);
2b748670	177	Double_t Rapidity(Double_t Px, Double_t Py, Double_t Pz);
734d2c12	178
	179	Int_t fNBinsY; //number of bins in y
	180	Float_t fMinY, fMaxY; //min & max value of y
	181	Int_t fNBinsPt; //number of bins in pT
	182	Float_t fMinPt, fMaxPt; //min & max value of pT
	183
	184	//cuts
	185	Int_t fMinTPCClusters, fMinITSClusters; //min TPC & ITS clusters
	186	Double_t fMaxChi2PerTPCCluster, fMaxChi2PerITSCluster; //max chi2 per TPC & ITS cluster
	187	Double_t fMaxCov11, fMaxCov22, fMaxCov33, fMaxCov44, fMaxCov55; //max values of cov. matrix
	188	Double_t fMaxSigmaToVertex; //max sigma to vertex cut
f24a70b0	189	Double_t fMaxSigmaToVertexTPC; //max sigma to vertex cut
96f84c25	190	Double_t fMaxDCAXY, fMaxDCAXYTPC; //max DCA xy
	191	Double_t fMaxDCAZ, fMaxDCAZTPC; //max DCA z
	192	Double_t fMaxConstrainChi2; //max constrain chi2 - vertex
734d2c12	193	Bool_t fMinTPCClustersFlag, fMinITSClustersFlag; //shows if this cut is used or not
	194	Bool_t fMaxChi2PerTPCClusterFlag, fMaxChi2PerITSClusterFlag; //shows if this cut is used or not
	195	Bool_t fMaxCov11Flag, fMaxCov22Flag, fMaxCov33Flag, fMaxCov44Flag, fMaxCov55Flag; //shows if this cut is used or not
	196	Bool_t fMaxSigmaToVertexFlag; //shows if this cut is used or not
f24a70b0	197	Bool_t fMaxSigmaToVertexTPCFlag; //shows if this cut is used or not
96f84c25	198	Bool_t fMaxDCAXYFlag, fMaxDCAXYTPCFlag; //shows if this cut is used or not
	199	Bool_t fMaxDCAZFlag, fMaxDCAZTPCFlag; //shows if this cut is used or not
	200	Bool_t fMaxConstrainChi2Flag; //shows if this cut is used or not
734d2c12	201	Bool_t fITSRefitFlag, fTPCRefitFlag; //shows if this cut is used or not
f24a70b0	202	Bool_t fESDpidFlag, fTPCpidFlag; //shows if this cut is used or not
0008a5a6	203	Bool_t fPointOnITSLayer1Flag, fPointOnITSLayer2Flag; //shows if this cut is used or not
	204	Bool_t fPointOnITSLayer3Flag, fPointOnITSLayer4Flag; //shows if this cut is used or not
	205	Bool_t fPointOnITSLayer5Flag, fPointOnITSLayer6Flag; //shows if this cut is used or not
734d2c12	206
734d2c12	207	//pid
aafecd8b	208	Bool_t fFunctionProbabilityFlag; //flag: kTRUE if functions used
ee4ca40d	209	Double_t fPartFrac[10]; //prior probabilities
aafecd8b	210	TF1 *fElectronFunction; //momentum dependence of the prior probs
	211	TF1 *fMuonFunction; //momentum dependence of the prior probs
	212	TF1 *fPionFunction; //momentum dependence of the prior probs
	213	TF1 *fKaonFunction; //momentum dependence of the prior probs
	214	TF1 *fProtonFunction; //momentum dependence of the prior probs
	215
2b748670	216	//Detectors
	217	Bool_t fUseTPCOnly; //kTRUE if TPC only information is used
	218
251e4034	219	//Analysis containers
	220	AliCFContainer *fProtonContainer; //container for protons
	221	AliCFContainer *fAntiProtonContainer; //container for antiprotons
3f6d0c08	222	TH1I *fHistEvents; //event counter
251e4034	223	TH2D *fHistYPtProtons; //Y-Pt of Protons
251e4034	224	TH2D *fHistYPtAntiProtons; // Y-Pt of Antiprotons
39f2a708	225
39f2a708	226	//Corrections
251e4034	227	TList *fEffGridListProtons; //list for the efficiency grid - protons
cdb3530f	228	TList *fCorrectionListProtons2D; //list for the 2d corrections
	229	TList *fEfficiencyListProtons1D; //list for the 1d efficiencies
	230	TList *fCorrectionListProtons1D; //list for the 1d corrections
251e4034	231	TList *fEffGridListAntiProtons; //list for the efficiency grid - antiprotons
cdb3530f	232	TList *fCorrectionListAntiProtons2D; //list for the 2d corrections
	233	TList *fEfficiencyListAntiProtons1D; //list for the 1d efficiencies
	234	TList *fCorrectionListAntiProtons1D; //list for the 1d corrections
251e4034	235	AliCFDataGrid *fCorrectProtons; //corrected data grid for protons
	236	AliCFDataGrid *fCorrectAntiProtons; //corrected data grid for antiprotons
	237
734d2c12	238	ClassDef(AliProtonAnalysis,0);
	239	};
	240
	241	#endif