end-of-line normalization

[u/mrichter/AliRoot.git] / PWGLF / SPECTRA / AntiprotonToProton / AliProtonFeedDownAnalysis.h

diff --git a/PWGLF/SPECTRA/AntiprotonToProton/AliProtonFeedDownAnalysis.h b/PWGLF/SPECTRA/AntiprotonToProton/AliProtonFeedDownAnalysis.h
index 7af8afe9287a23e2a8bec35b5220f600d5bcc126..8dbc73e9495e6ba233602700134c21bde8fddf34 100644 (file)
--- a/PWGLF/SPECTRA/AntiprotonToProton/AliProtonFeedDownAnalysis.h
+++ b/PWGLF/SPECTRA/AntiprotonToProton/AliProtonFeedDownAnalysis.h
@@ -1,86 +1,86 @@
-#ifndef ALIPROTONFEEDDOWNANALYSIS_H\r
-#define ALIPROTONFEEDDOWNANALYSIS_H\r
-\r
-#include "TObject.h"\r
-#include "TH1I.h"\r
-#include "AliCFContainer.h"\r
-class TF1;\r
-class TH2D;\r
-class TH1F;\r
-class TList;\r
-\r
-//#include "AliPID.h"\r
-class AliPID;\r
-\r
-class AliCFDataGrid;\r
-class AliAODEvent;\r
-class AliAODtrack;\r
-class AliESDEvent;\r
-class AliESDtrack;\r
-class AliExternalTrackParam;\r
-class AliStack;\r
-class AliESDVertex;\r
-class AliProtonAnalysisBase;\r
-\r
-class AliProtonFeedDownAnalysis : public TObject \r
-{\r
-       public:\r
-       enum \r
-               {\r
-                       kAll      = 0, //without protons reject the secondaries from hadronic inter. \r
-                       kPrimary = 1,\r
-                       kFromLambda        = 2,\r
-                       kSelected = 3 ,\r
-                       kSelectedfromLambda = 4,\r
-                       kNSteps=5\r
-               };\r
-               AliProtonFeedDownAnalysis();\r
-               //AliProtonFeedDownAnalysis(Int_t nbinsY, Float_t fLowY, Float_t fHighY,Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);\r
-               virtual ~AliProtonFeedDownAnalysis();\r
-               \r
-               void SetBaseAnalysis(AliProtonAnalysisBase * const baseAnalysis) {fProtonAnalysisBase = baseAnalysis;}\r
-               AliProtonAnalysisBase *GetProtonAnalysisBaseObject() const {return fProtonAnalysisBase;}\r
-               \r
-               void InitAnalysisHistograms(Int_t nbinsY, Float_t fLowY, Float_t fHighY, Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);\r
-               void Analyze(AliESDEvent *fESD, const AliESDVertex *vertex,AliStack *stack);\r
-               void Analyze(AliAODEvent *fAOD);\r
-               void Analyze(AliStack *stack);\r
-               \r
-               AliCFContainer *GetProtonContainer() const {return fProtonContainer;}\r
-               AliCFContainer *GetAntiProtonContainer() const {return fAntiProtonContainer;}\r
-               \r
-               void SetWeightFunction(TF1* weightfunction){fweightfunction=weightfunction;}\r
-               TF1* GetWeightFunction() const{return fweightfunction;} \r
-               TH2F* GetLambdaHist() const{return fLambda;}\r
-               TH2F* GetLambdaweightedHist() const{return fLambdaweighted;}\r
-               TH2F* GetAntiLambdaHist() const{return fAntiLambda;}\r
-               TH2F* GetAntiLambdaweightedHist() const{return fAntiLambdaweighted;}\r
-       private:\r
-               AliProtonFeedDownAnalysis(const AliProtonFeedDownAnalysis&); // Not implemented\r
-               AliProtonFeedDownAnalysis& operator=(const AliProtonFeedDownAnalysis&); // Not implemented\r
-               \r
-               AliProtonAnalysisBase *fProtonAnalysisBase;//base analysis object\r
-               Int_t LambdaIsMother(Int_t numbe, AliStack *stack); \r
-               Float_t GetWeightforProton(Int_t number, AliStack *stack);\r
-               Float_t GetWeightforLambda(Float_t pt);\r
-               \r
-               Int_t fNBinsY; //number of bins in y or eta\r
-               Double_t fMinY, fMaxY; //min & max value of y or eta\r
-               Int_t fNBinsPt;  //number of bins in pT\r
-               Double_t fMinPt, fMaxPt; //min & max value of pT\r
-               \r
-               //Analysis containers\r
-               AliCFContainer *fProtonContainer; //container for protons\r
-               AliCFContainer *fAntiProtonContainer; //container for antiprotons\r
-               \r
-               TF1*fweightfunction; \r
-               TH2F *fLambda;\r
-               TH2F *fLambdaweighted;\r
-               TH2F *fAntiLambda;\r
-               TH2F *fAntiLambdaweighted;\r
-               \r
-  ClassDef(AliProtonFeedDownAnalysis,2);\r
-};\r
-\r
-#endif\r
-\r
+#ifndef ALIPROTONFEEDDOWNANALYSIS_H
+#define ALIPROTONFEEDDOWNANALYSIS_H
+
+#include "TObject.h"
+#include "TH1I.h"
+#include "AliCFContainer.h"
+class TF1;
+class TH2D;
+class TH1F;
+class TList;
+
+//#include "AliPID.h"
+class AliPID;
+
+class AliCFDataGrid;
+class AliAODEvent;
+class AliAODtrack;
+class AliESDEvent;
+class AliESDtrack;
+class AliExternalTrackParam;
+class AliStack;
+class AliESDVertex;
+class AliProtonAnalysisBase;
+
+class AliProtonFeedDownAnalysis : public TObject 
+{
+       public:
+       enum 
+               {
+                       kAll      = 0, //without protons reject the secondaries from hadronic inter. 
+                       kPrimary = 1,
+                       kFromLambda        = 2,
+                       kSelected = 3 ,
+                       kSelectedfromLambda = 4,
+                       kNSteps=5
+               };
+               AliProtonFeedDownAnalysis();
+               //AliProtonFeedDownAnalysis(Int_t nbinsY, Float_t fLowY, Float_t fHighY,Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);
+               virtual ~AliProtonFeedDownAnalysis();
+               
+               void SetBaseAnalysis(AliProtonAnalysisBase * const baseAnalysis) {fProtonAnalysisBase = baseAnalysis;}
+               AliProtonAnalysisBase *GetProtonAnalysisBaseObject() const {return fProtonAnalysisBase;}
+               
+               void InitAnalysisHistograms(Int_t nbinsY, Float_t fLowY, Float_t fHighY, Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);
+               void Analyze(AliESDEvent *fESD, const AliESDVertex *vertex,AliStack *stack);
+               void Analyze(AliAODEvent *fAOD);
+               void Analyze(AliStack *stack);
+               
+               AliCFContainer *GetProtonContainer() const {return fProtonContainer;}
+               AliCFContainer *GetAntiProtonContainer() const {return fAntiProtonContainer;}
+               
+               void SetWeightFunction(TF1* weightfunction){fweightfunction=weightfunction;}
+               TF1* GetWeightFunction() const{return fweightfunction;} 
+               TH2F* GetLambdaHist() const{return fLambda;}
+               TH2F* GetLambdaweightedHist() const{return fLambdaweighted;}
+               TH2F* GetAntiLambdaHist() const{return fAntiLambda;}
+               TH2F* GetAntiLambdaweightedHist() const{return fAntiLambdaweighted;}
+       private:
+               AliProtonFeedDownAnalysis(const AliProtonFeedDownAnalysis&); // Not implemented
+               AliProtonFeedDownAnalysis& operator=(const AliProtonFeedDownAnalysis&); // Not implemented
+               
+               AliProtonAnalysisBase *fProtonAnalysisBase;//base analysis object
+               Int_t LambdaIsMother(Int_t numbe, AliStack *stack); 
+               Float_t GetWeightforProton(Int_t number, AliStack *stack);
+               Float_t GetWeightforLambda(Float_t pt);
+               
+               Int_t fNBinsY; //number of bins in y or eta
+               Double_t fMinY, fMaxY; //min & max value of y or eta
+               Int_t fNBinsPt;  //number of bins in pT
+               Double_t fMinPt, fMaxPt; //min & max value of pT
+               
+               //Analysis containers
+               AliCFContainer *fProtonContainer; //container for protons
+               AliCFContainer *fAntiProtonContainer; //container for antiprotons
+               
+               TF1*fweightfunction; 
+               TH2F *fLambda;
+               TH2F *fLambdaweighted;
+               TH2F *fAntiLambda;
+               TH2F *fAntiLambdaweighted;
+               
+  ClassDef(AliProtonFeedDownAnalysis,2);
+};
+
+#endif
+