[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    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    SetITSRefit() {fITSRefitFlag = kTRUE;}
  void    SetTPCRefit() {fTPCRefitFlag = kTRUE;}
  void    SetESDpid() {fESDpidFlag = kTRUE;}
  void    SetTPCpid() {fTPCpidFlag = kTRUE;}

  //QA histograms
  void SetQAOn();
  void SetQAYPtBins(Int_t nbinsY, Double_t minY, Double_t maxY,
		    Int_t nbinsPt, Double_t minPt, Double_t maxPt);
  void InitQA();
  void RunQA(AliStack *stack, AliESDEvent *esd);
  TList *GetGlobalQAList() {return fGlobalQAList;}

  //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);
  void     FillQA(AliESDtrack *track, AliStack *stack);
  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
  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 fITSRefitFlag, fTPCRefitFlag; //shows if this cut is used or not
  Bool_t fESDpidFlag, fTPCpidFlag; //shows if this cut is used or not
  
  //QA histograms
  //Bool_t fQAHistograms; //Boolean to activate the QA histograms
  TList *fGlobalQAList; //TList storing the directories for the QA histograms
  TList *fQA2DList; //TList storing the accepted primary/secondary (anti)protons
  TList *fQAPrimaryProtonsAcceptedList; //list of the QA histos for accepted primary protons
  TList *fQAPrimaryProtonsRejectedList; //list of the QA histos for rejected primary protons
  TList *fQASecondaryProtonsAcceptedList; //list of the QA histos for accepted secondary protons
  TList *fQASecondaryProtonsRejectedList; //list of the QA histos for rejected secondary protons
  TList *fQAPrimaryAntiProtonsAcceptedList; //list of the QA histos for accepted primary antiprotons
  TList *fQAPrimaryAntiProtonsRejectedList; //list of the QA histos for rejected primary antiprotons
  TList *fQASecondaryAntiProtonsAcceptedList; //list of the QA histos for accepted secondary antiprotons
  TList *fQASecondaryAntiProtonsRejectedList; //list of the QA histos for rejected secondary antiprotons

  //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
734d2c12	77	void SetMinITSClusters(Int_t minITSClusters) {
	78	fMinITSClusters = minITSClusters;
	79	fMinITSClustersFlag = kTRUE;
	80	}
734d2c12	81	void SetMaxChi2PerITSCluster(Double_t maxChi2PerITSCluster) {
	82	fMaxChi2PerITSCluster = maxChi2PerITSCluster;
	83	fMaxChi2PerITSClusterFlag = kTRUE;
	84	}
f24a70b0	85	void SetMinTPCClusters(Int_t minTPCClusters) {
	86	fMinTPCClusters = minTPCClusters;
	87	fMinTPCClustersFlag = kTRUE;
	88	}
	89	void SetMaxChi2PerTPCCluster(Double_t maxChi2PerTPCCluster) {
	90	fMaxChi2PerTPCCluster = maxChi2PerTPCCluster;
	91	fMaxChi2PerTPCClusterFlag = kTRUE;
	92	}
251e4034	93	void SetMaxCov11(Double_t maxCov11) {
	94	fMaxCov11 = maxCov11; fMaxCov11Flag = kTRUE;}
	95	void SetMaxCov22(Double_t maxCov22) {
	96	fMaxCov22 = maxCov22; fMaxCov22Flag = kTRUE;}
	97	void SetMaxCov33(Double_t maxCov33) {
	98	fMaxCov33 = maxCov33; fMaxCov33Flag = kTRUE;}
	99	void SetMaxCov44(Double_t maxCov44) {
	100	fMaxCov44 = maxCov44; fMaxCov44Flag = kTRUE;}
	101	void SetMaxCov55(Double_t maxCov55) {
	102	fMaxCov55 = maxCov55; fMaxCov55Flag = kTRUE;}
734d2c12	103	void SetMaxSigmaToVertex(Double_t maxSigmaToVertex) {
	104	fMaxSigmaToVertex = maxSigmaToVertex;
	105	fMaxSigmaToVertexFlag = kTRUE;
	106	}
f24a70b0	107	void SetMaxSigmaToVertexTPC(Double_t maxSigmaToVertex) {
	108	fMaxSigmaToVertexTPC = maxSigmaToVertex;
	109	fMaxSigmaToVertexTPCFlag = kTRUE;
	110	}
734d2c12	111	void SetITSRefit() {fITSRefitFlag = kTRUE;}
734d2c12	112	void SetTPCRefit() {fTPCRefitFlag = kTRUE;}
f24a70b0	113	void SetESDpid() {fESDpidFlag = kTRUE;}
f24a70b0	114	void SetTPCpid() {fTPCpidFlag = kTRUE;}
ef1a8dbd	115
ef1a8dbd	116	//QA histograms
24421eb6	117	void SetQAOn();
ef1a8dbd	118	void SetQAYPtBins(Int_t nbinsY, Double_t minY, Double_t maxY,
24421eb6	119	Int_t nbinsPt, Double_t minPt, Double_t maxPt);
ef1a8dbd	120	void InitQA();
ef1a8dbd	121	void RunQA(AliStack stack, AliESDEvent esd);
7b59a00b	122	TList *GetGlobalQAList() {return fGlobalQAList;}
ef1a8dbd	123
734d2c12	124	//Prior probabilities
251e4034	125	void SetPriorProbabilities(Double_t *partFrac) {
251e4034	126	for(Int_t i = 0; i < AliPID::kSPECIESN; i++) fPartFrac[i] = partFrac[i];}
f24a70b0	127	void SetPriorProbabilityFunctions(TF1 felectron, TF1 fmuon, TF1 fpion, TF1 fkaon, TF1 *fproton) {
aafecd8b	128	fFunctionProbabilityFlag = kTRUE;
	129	fElectronFunction = felectron;
	130	fMuonFunction = fmuon;
	131	fPionFunction = fpion;
	132	fKaonFunction = fkaon;
	133	fProtonFunction = fproton;
	134	}
	135	Double_t GetParticleFraction(Int_t i, Double_t p);
	136
39f2a708	137	//interface to the correction framework
251e4034	138	void Correct(Int_t step);
39f2a708	139	Bool_t ReadCorrectionContainer(const char* filename);
cdb3530f	140	TList *GetCorrectionListProtons2D() {return fCorrectionListProtons2D;}
	141	TList *GetEfficiencyListProtons1D() {return fEfficiencyListProtons1D;}
	142	TList *GetCorrectionListProtons1D() {return fCorrectionListProtons1D;}
	143	TList *GetCorrectionListAntiProtons2D() {return fCorrectionListAntiProtons2D;}
	144	TList *GetEfficiencyListAntiProtons1D() {return fEfficiencyListAntiProtons1D;}
	145	TList *GetCorrectionListAntiProtons1D() {return fCorrectionListAntiProtons1D;}
24421eb6	146
	147	//iStep=0->MC - iStep=1->Acceptance - iStep=2->Reconstruction - iStep=3->PID
	148	TH1D *GetUncorrectedProtonYHistogram(Int_t iStep) {return fProtonContainer->ShowProjection(0, iStep);}
	149	TH1D *GetUncorrectedProtonPtHistogram(Int_t iStep) {return fProtonContainer->ShowProjection(1, iStep);}
	150	TH1D *GetUncorrectedAntiProtonYHistogram(Int_t iStep) {return fAntiProtonContainer->ShowProjection(0, iStep);}
	151	TH1D *GetUncorrectedAntiProtonPtHistogram(Int_t iStep) {return fAntiProtonContainer->ShowProjection(1, iStep);}
39f2a708	152
734d2c12	153	private:
8b8b0b7a	154	AliProtonAnalysis(const AliProtonAnalysis&); // Not implemented
	155	AliProtonAnalysis& operator=(const AliProtonAnalysis&); // Not implemented
	156
88c900f2	157	Bool_t IsAccepted(AliESDtrack *track);
	158	void FillQA(AliESDtrack track, AliStack stack);
	159	Float_t GetSigmaToVertex(AliESDtrack* esdTrack);
2b748670	160	Double_t Rapidity(Double_t Px, Double_t Py, Double_t Pz);
734d2c12	161
	162	Int_t fNBinsY; //number of bins in y
	163	Float_t fMinY, fMaxY; //min & max value of y
	164	Int_t fNBinsPt; //number of bins in pT
	165	Float_t fMinPt, fMaxPt; //min & max value of pT
	166
	167	//cuts
	168	Int_t fMinTPCClusters, fMinITSClusters; //min TPC & ITS clusters
	169	Double_t fMaxChi2PerTPCCluster, fMaxChi2PerITSCluster; //max chi2 per TPC & ITS cluster
	170	Double_t fMaxCov11, fMaxCov22, fMaxCov33, fMaxCov44, fMaxCov55; //max values of cov. matrix
	171	Double_t fMaxSigmaToVertex; //max sigma to vertex cut
f24a70b0	172	Double_t fMaxSigmaToVertexTPC; //max sigma to vertex cut
734d2c12	173	Bool_t fMinTPCClustersFlag, fMinITSClustersFlag; //shows if this cut is used or not
	174	Bool_t fMaxChi2PerTPCClusterFlag, fMaxChi2PerITSClusterFlag; //shows if this cut is used or not
	175	Bool_t fMaxCov11Flag, fMaxCov22Flag, fMaxCov33Flag, fMaxCov44Flag, fMaxCov55Flag; //shows if this cut is used or not
	176	Bool_t fMaxSigmaToVertexFlag; //shows if this cut is used or not
f24a70b0	177	Bool_t fMaxSigmaToVertexTPCFlag; //shows if this cut is used or not
734d2c12	178	Bool_t fITSRefitFlag, fTPCRefitFlag; //shows if this cut is used or not
f24a70b0	179	Bool_t fESDpidFlag, fTPCpidFlag; //shows if this cut is used or not
734d2c12	180
ef1a8dbd	181	//QA histograms
cc0fbd97	182	//Bool_t fQAHistograms; //Boolean to activate the QA histograms
ef1a8dbd	183	TList *fGlobalQAList; //TList storing the directories for the QA histograms
	184	TList *fQA2DList; //TList storing the accepted primary/secondary (anti)protons
	185	TList *fQAPrimaryProtonsAcceptedList; //list of the QA histos for accepted primary protons
	186	TList *fQAPrimaryProtonsRejectedList; //list of the QA histos for rejected primary protons
	187	TList *fQASecondaryProtonsAcceptedList; //list of the QA histos for accepted secondary protons
	188	TList *fQASecondaryProtonsRejectedList; //list of the QA histos for rejected secondary protons
	189	TList *fQAPrimaryAntiProtonsAcceptedList; //list of the QA histos for accepted primary antiprotons
	190	TList *fQAPrimaryAntiProtonsRejectedList; //list of the QA histos for rejected primary antiprotons
	191	TList *fQASecondaryAntiProtonsAcceptedList; //list of the QA histos for accepted secondary antiprotons
	192	TList *fQASecondaryAntiProtonsRejectedList; //list of the QA histos for rejected secondary antiprotons
ef1a8dbd	193
734d2c12	194	//pid
aafecd8b	195	Bool_t fFunctionProbabilityFlag; //flag: kTRUE if functions used
ee4ca40d	196	Double_t fPartFrac[10]; //prior probabilities
aafecd8b	197	TF1 *fElectronFunction; //momentum dependence of the prior probs
	198	TF1 *fMuonFunction; //momentum dependence of the prior probs
	199	TF1 *fPionFunction; //momentum dependence of the prior probs
	200	TF1 *fKaonFunction; //momentum dependence of the prior probs
	201	TF1 *fProtonFunction; //momentum dependence of the prior probs
	202
2b748670	203	//Detectors
	204	Bool_t fUseTPCOnly; //kTRUE if TPC only information is used
	205
251e4034	206	//Analysis containers
	207	AliCFContainer *fProtonContainer; //container for protons
	208	AliCFContainer *fAntiProtonContainer; //container for antiprotons
3f6d0c08	209	TH1I *fHistEvents; //event counter
251e4034	210	TH2D *fHistYPtProtons; //Y-Pt of Protons
251e4034	211	TH2D *fHistYPtAntiProtons; // Y-Pt of Antiprotons
39f2a708	212
39f2a708	213	//Corrections
251e4034	214	TList *fEffGridListProtons; //list for the efficiency grid - protons
cdb3530f	215	TList *fCorrectionListProtons2D; //list for the 2d corrections
	216	TList *fEfficiencyListProtons1D; //list for the 1d efficiencies
	217	TList *fCorrectionListProtons1D; //list for the 1d corrections
251e4034	218	TList *fEffGridListAntiProtons; //list for the efficiency grid - antiprotons
cdb3530f	219	TList *fCorrectionListAntiProtons2D; //list for the 2d corrections
	220	TList *fEfficiencyListAntiProtons1D; //list for the 1d efficiencies
	221	TList *fCorrectionListAntiProtons1D; //list for the 1d corrections
251e4034	222	AliCFDataGrid *fCorrectProtons; //corrected data grid for protons
	223	AliCFDataGrid *fCorrectAntiProtons; //corrected data grid for antiprotons
	224
734d2c12	225	ClassDef(AliProtonAnalysis,0);
	226	};
	227
	228	#endif