[u/mrichter/AliRoot.git] / PWG / FLOW / Base / AliFlowAnalysisWithLeeYangZeros.h

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */


#ifndef ALIFLOWANALYSISWITHLEEYANGZEROS_H
#define ALIFLOWANALYSISWITHLEEYANGZEROS_H

////////////////////////////////////////////////////////////////////
// Description: Maker to analyze Flow by the LeeYangZeros method
//              One needs to do two runs over the data; 
//              First to calculate the integrated flow 
//              and in the second to calculate the differential flow
// Author: Naomi van der Kolk (kolk@nikhef.nl)
////////////////////////////////////////////////////////////////////

class TH1F;
class TProfile;
class TDirectoryFile;
class TComplex;
class TString;
class TList;
class TVector2;
 
class AliFlowVector;
class AliFlowEventSimple;
class AliFlowLYZHist1; 
class AliFlowLYZHist2;
class AliFlowCommonHist;
class AliFlowCommonHistResults;

class AliFlowAnalysisWithLeeYangZeros {

 public:
 
   AliFlowAnalysisWithLeeYangZeros();                         //default constructor
   virtual  ~AliFlowAnalysisWithLeeYangZeros();               //destructor
 
   Bool_t    Init();                                          //defines variables and histograms
   Bool_t    Make(AliFlowEventSimple* anEvent);               //calculates variables and fills histograms
   void      GetOutputHistograms(TList *outputListHistos);    //get pointers to all output histograms (called before Finish()) 
   Bool_t    Finish();                                        //saves histograms
   void      WriteHistograms(TString* outputFileName);        //writes histograms locally
   void      WriteHistograms(TString outputFileName);         //writes histograms locally
   void      WriteHistograms(TDirectoryFile *outputFileName); //writes histograms locally
   
   Double_t  GetQtheta(AliFlowVector aQ, Double_t aTheta);
   
   void      SetFirstRun(Bool_t kt)       { this->fFirstRun = kt ; }
   Bool_t    GetFirstRun() const          { return this->fFirstRun ; }
   void      SetUseSum(Bool_t kt)         { this->fUseSum = kt ; }
   Bool_t    GetUseSum() const            { return this->fUseSum ; }
   void      SetDoubleLoop(Bool_t kt)     { this->fDoubleLoop = kt ; }
   Bool_t    GetDoubleLoop() const        { return this->fDoubleLoop ; }
   void      SetDebug(Bool_t kt)          { this->fDebug = kt ; }
   Bool_t    GetDebug() const             { return this->fDebug ; }
   
   void      SetEventNumber(Int_t n)      { this->fEventNumber = n; }
   Int_t     GetEventNumber() const       { return this->fEventNumber; }
   void      SetQ2sum(Double_t d)         { this->fQ2sum = d; }
   Double_t  GetQ2sum() const             { return this->fQ2sum; }

   // Output 
   TList*             GetHistList() const      { return this->fHistList ; }     
   AliFlowCommonHist* GetCommonHists() const   { return this->fCommonHists; }
   void               SetCommonHists(AliFlowCommonHist* const aCommonHist)  
     { this->fCommonHists = aCommonHist; }
   AliFlowCommonHistResults* GetCommonHistsRes() const  
     { return this->fCommonHistsRes; }
   void               SetCommonHistsRes(AliFlowCommonHistResults* const aCommonHistResult) 
     { this->fCommonHistsRes = aCommonHistResult; }
   //AliFlowLYZHist1* GetHist1() const             {return this->fHist1; } 
   void               SetHist1(AliFlowLYZHist1* const aLYZHist1[])  
     {for (Int_t i=0;i<5;i++) {this->fHist1[i] = aLYZHist1[i];} }
   //AliFlowLYZHist2* GetHist2() const             {return this->fHist2; } 
   void               SetHist2RP(AliFlowLYZHist2* const aLYZHist2RP[])  
     {for (Int_t i=0;i<5;i++) {this->fHist2RP[i] = aLYZHist2RP[i];} }
   void               SetHist2POI(AliFlowLYZHist2* const aLYZHist2POI[])  
     {for (Int_t i=0;i<5;i++) {this->fHist2POI[i] = aLYZHist2POI[i];} }

   TH1D*      GetHistVtheta() const   {return this->fHistVtheta; } 
   void       SetHistVtheta(TH1D* const aHistVtheta)     
   { this->fHistVtheta = aHistVtheta; }
   TProfile*  GetHistProVetaRP() const     {return this->fHistProVetaRP; }  
   void       SetHistProVetaRP(TProfile* const aHistProVetaRP)         
     {this->fHistProVetaRP = aHistProVetaRP; }
   TProfile*  GetHistProVetaPOI() const     {return this->fHistProVetaPOI; }  
   void       SetHistProVetaPOI(TProfile* const aHistProVetaPOI)         
     {this->fHistProVetaPOI = aHistProVetaPOI; }
   TProfile*  GetHistProVPtRP() const      {return this->fHistProVPtRP;}
   void       SetHistProVPtRP(TProfile* const aHistProVPtRP)           
     {this->fHistProVPtRP = aHistProVPtRP; }
   TProfile*  GetHistProVPtPOI() const      {return this->fHistProVPtPOI;}
   void       SetHistProVPtPOI(TProfile* const aHistProVPtPOI)           
     {this->fHistProVPtPOI = aHistProVPtPOI; }
   TH1D*      GetHistR0theta() const  {return this->fHistR0theta; }
   void       SetHistR0theta(TH1D* const aHistR0theta)   
     {this->fHistR0theta = aHistR0theta; }
   TProfile*  GetHistProReDenom() const  {return this->fHistProReDenom; } 
   void       SetHistProReDenom(TProfile* const aHistProReDenom)   
     {this->fHistProReDenom = aHistProReDenom; }
   TProfile*  GetHistProImDenom() const  {return this->fHistProImDenom; }
   void       SetHistProImDenom(TProfile* const aHistProImDenom)   
     {this->fHistProImDenom = aHistProImDenom; }
   TH1D*      GetHistReDtheta() const {return this->fHistReDtheta; } 
   void       SetHistReDtheta(TH1D* const aHistReDtheta) 
     {this->fHistReDtheta = aHistReDtheta; }
   TH1D*      GetHistImDtheta() const {return this->fHistImDtheta; }
   void       SetHistImDtheta(TH1D* const aHistImDtheta) 
     {this->fHistImDtheta = aHistImDtheta; } 
   TH1F*      GetHistQsumforChi() const  {return this->fHistQsumforChi; }
   void       SetHistQsumforChi(TH1F* const aHistQsumforChi) 
    {this->fHistQsumforChi = aHistQsumforChi; }

   void       SetFirstRunList(TList* const list) { this->fFirstRunList = list; }
   TList*     GetFirstRunList() const            { return this->fFirstRunList; }

   TComplex   GetGrtheta(AliFlowEventSimple* anEvent, Double_t aR, Double_t aTheta);
   TComplex   GetDiffFlow(AliFlowEventSimple* anEvent, Double_t aR, Int_t theta); 
	

 private:

   AliFlowAnalysisWithLeeYangZeros(const AliFlowAnalysisWithLeeYangZeros& aAnalysis);            // copy constructor
   AliFlowAnalysisWithLeeYangZeros& operator=(const AliFlowAnalysisWithLeeYangZeros& aAnalysis); //assignment operator

   Bool_t   MakeControlHistograms(AliFlowEventSimple* anEvent); 
   Bool_t   FillFromFlowEvent(AliFlowEventSimple* anEvent);
   Bool_t   SecondFillFromFlowEvent(AliFlowEventSimple* anEvent);

#ifndef __CINT__
   
   TVector2*  fQsum;         // flow vector sum              
   Double_t  fQ2sum;         // flow vector sum squared                 
      
#endif /*__CINT__*/

   Int_t        fEventNumber;     // event counter
        
   Bool_t       fFirstRun ;       // flag for lyz analysis: true=first run over data, false=second run 
   Bool_t       fUseSum ;         // flag for lyz analysis: true=use sum gen.function, false=use product gen.function
   Bool_t       fDoubleLoop ;     // flag for studying non flow effects
   Bool_t       fDebug ;          // flag for lyz analysis: more print statements

   TList*       fHistList;        //list to hold all output histograms 
   TList*       fFirstRunList;    //list from first run output
        
   TH1D*        fHistVtheta;      //hist of V(theta)      
   TProfile*    fHistProVetaRP;   //hist of v(eta) for RP selection
   TProfile*    fHistProVetaPOI;  //hist of v(eta) for POI selection
   TProfile*    fHistProVPtRP;    //hist of v(pt) for RP selection
   TProfile*    fHistProVPtPOI;   //hist of v(pt) for POI selection
   TH1D*        fHistR0theta;     //hist of r0(theta)    
   TProfile*    fHistProReDenom;  //hist of the real part of the denominator   
   TProfile*    fHistProImDenom;  //hist of the imaginary part of the denominator 
   TH1D*        fHistReDtheta;    //hist of the real part of D^theta   
   TH1D*        fHistImDtheta;    //hist of the imaginary part of D^theta  
   TH1F*        fHistQsumforChi;  //hist of sum of Q-vectors and the sum of the square of Q-vectors
  
    
  //class AliFlowLYZHist1 defines the histograms: fHistProGtheta, fHistProReGtheta, fHistProImGtheta
  AliFlowLYZHist1* fHist1[5];     //array of hist1

  //class AliFlowLYZHist1 defines the histograms: fHistProReNumer, fHistProImNumer, fHistProReNumerPt,
  //fHistProImNumerPt, fHistProReNumer2D, fHistProImNumer2D.
  AliFlowLYZHist2* fHist2RP[5];   //array of hist2
  AliFlowLYZHist2* fHist2POI[5];  //array of hist2

  AliFlowCommonHist*        fCommonHists;     //control histograms
  AliFlowCommonHistResults* fCommonHistsRes;  //final results histograms
 
  ClassDef(AliFlowAnalysisWithLeeYangZeros,0)  // macro for rootcint
};
 
     
#endif
Commit	Line	Data
f1d945a1	1	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	2	* See cxx source for full Copyright notice */
	3
	4	/* $Id$ */
	5
	6
80f72ed6	7	#ifndef ALIFLOWANALYSISWITHLEEYANGZEROS_H
	8	#define ALIFLOWANALYSISWITHLEEYANGZEROS_H
	9
	10	////////////////////////////////////////////////////////////////////
	11	// Description: Maker to analyze Flow by the LeeYangZeros method
	12	// One needs to do two runs over the data;
	13	// First to calculate the integrated flow
	14	// and in the second to calculate the differential flow
	15	// Author: Naomi van der Kolk (kolk@nikhef.nl)
	16	////////////////////////////////////////////////////////////////////
	17
f1d945a1	18	class TH1F;
f1d945a1	19	class TProfile;
ad87ae62	20	class TDirectoryFile;
f1d945a1	21	class TComplex;
f1d945a1	22	class TString;
88e00a8a	23	class TList;
e77f0120	24	class TVector2;
f1d945a1	25
e77f0120	26	class AliFlowVector;
	27	class AliFlowEventSimple;
	28	class AliFlowLYZHist1;
	29	class AliFlowLYZHist2;
	30	class AliFlowCommonHist;
	31	class AliFlowCommonHistResults;
	32
f1d945a1	33	class AliFlowAnalysisWithLeeYangZeros {
	34
	35	public:
	36
ad87ae62	37	AliFlowAnalysisWithLeeYangZeros(); //default constructor
ad87ae62	38	virtual ~AliFlowAnalysisWithLeeYangZeros(); //destructor
f1d945a1	39
ad87ae62	40	Bool_t Init(); //defines variables and histograms
	41	Bool_t Make(AliFlowEventSimple* anEvent); //calculates variables and fills histograms
	42	void GetOutputHistograms(TList *outputListHistos); //get pointers to all output histograms (called before Finish())
	43	Bool_t Finish(); //saves histograms
	44	void WriteHistograms(TString* outputFileName); //writes histograms locally
	45	void WriteHistograms(TString outputFileName); //writes histograms locally
	46	void WriteHistograms(TDirectoryFile *outputFileName); //writes histograms locally
9d062fe3	47
882ffd6a	48	Double_t GetQtheta(AliFlowVector aQ, Double_t aTheta);
e8c3ff94	49
9d062fe3	50	void SetFirstRun(Bool_t kt) { this->fFirstRun = kt ; }
	51	Bool_t GetFirstRun() const { return this->fFirstRun ; }
	52	void SetUseSum(Bool_t kt) { this->fUseSum = kt ; }
	53	Bool_t GetUseSum() const { return this->fUseSum ; }
	54	void SetDoubleLoop(Bool_t kt) { this->fDoubleLoop = kt ; }
	55	Bool_t GetDoubleLoop() const { return this->fDoubleLoop ; }
	56	void SetDebug(Bool_t kt) { this->fDebug = kt ; }
	57	Bool_t GetDebug() const { return this->fDebug ; }
	58
	59	void SetEventNumber(Int_t n) { this->fEventNumber = n; }
	60	Int_t GetEventNumber() const { return this->fEventNumber; }
	61	void SetQ2sum(Double_t d) { this->fQ2sum = d; }
80f72ed6	62	Double_t GetQ2sum() const { return this->fQ2sum; }
f1d945a1	63
f1d945a1	64	// Output
9d062fe3	65	TList* GetHistList() const { return this->fHistList ; }
9d062fe3	66	AliFlowCommonHist* GetCommonHists() const { return this->fCommonHists; }
80f72ed6	67	void SetCommonHists(AliFlowCommonHist* const aCommonHist)
9d062fe3	68	{ this->fCommonHists = aCommonHist; }
	69	AliFlowCommonHistResults* GetCommonHistsRes() const
	70	{ return this->fCommonHistsRes; }
80f72ed6	71	void SetCommonHistsRes(AliFlowCommonHistResults* const aCommonHistResult)
9d062fe3	72	{ this->fCommonHistsRes = aCommonHistResult; }
9d062fe3	73	//AliFlowLYZHist1* GetHist1() const {return this->fHist1; }
80f72ed6	74	void SetHist1(AliFlowLYZHist1* const aLYZHist1[])
9d062fe3	75	{for (Int_t i=0;i<5;i++) {this->fHist1[i] = aLYZHist1[i];} }
9d062fe3	76	//AliFlowLYZHist2* GetHist2() const {return this->fHist2; }
80f72ed6	77	void SetHist2RP(AliFlowLYZHist2* const aLYZHist2RP[])
e8c3ff94	78	{for (Int_t i=0;i<5;i++) {this->fHist2RP[i] = aLYZHist2RP[i];} }
80f72ed6	79	void SetHist2POI(AliFlowLYZHist2* const aLYZHist2POI[])
e8c3ff94	80	{for (Int_t i=0;i<5;i++) {this->fHist2POI[i] = aLYZHist2POI[i];} }
9d062fe3	81
b9ac26e9	82	TH1D* GetHistVtheta() const {return this->fHistVtheta; }
	83	void SetHistVtheta(TH1D* const aHistVtheta)
	84	{ this->fHistVtheta = aHistVtheta; }
e8c3ff94	85	TProfile* GetHistProVetaRP() const {return this->fHistProVetaRP; }
80f72ed6	86	void SetHistProVetaRP(TProfile* const aHistProVetaRP)
e8c3ff94	87	{this->fHistProVetaRP = aHistProVetaRP; }
e8c3ff94	88	TProfile* GetHistProVetaPOI() const {return this->fHistProVetaPOI; }
80f72ed6	89	void SetHistProVetaPOI(TProfile* const aHistProVetaPOI)
e8c3ff94	90	{this->fHistProVetaPOI = aHistProVetaPOI; }
e8c3ff94	91	TProfile* GetHistProVPtRP() const {return this->fHistProVPtRP;}
80f72ed6	92	void SetHistProVPtRP(TProfile* const aHistProVPtRP)
e8c3ff94	93	{this->fHistProVPtRP = aHistProVPtRP; }
e8c3ff94	94	TProfile* GetHistProVPtPOI() const {return this->fHistProVPtPOI;}
80f72ed6	95	void SetHistProVPtPOI(TProfile* const aHistProVPtPOI)
e8c3ff94	96	{this->fHistProVPtPOI = aHistProVPtPOI; }
b9ac26e9	97	TH1D* GetHistR0theta() const {return this->fHistR0theta; }
	98	void SetHistR0theta(TH1D* const aHistR0theta)
	99	{this->fHistR0theta = aHistR0theta; }
9d062fe3	100	TProfile* GetHistProReDenom() const {return this->fHistProReDenom; }
80f72ed6	101	void SetHistProReDenom(TProfile* const aHistProReDenom)
9d062fe3	102	{this->fHistProReDenom = aHistProReDenom; }
9d062fe3	103	TProfile* GetHistProImDenom() const {return this->fHistProImDenom; }
80f72ed6	104	void SetHistProImDenom(TProfile* const aHistProImDenom)
9d062fe3	105	{this->fHistProImDenom = aHistProImDenom; }
b9ac26e9	106	TH1D* GetHistReDtheta() const {return this->fHistReDtheta; }
	107	void SetHistReDtheta(TH1D* const aHistReDtheta)
	108	{this->fHistReDtheta = aHistReDtheta; }
	109	TH1D* GetHistImDtheta() const {return this->fHistImDtheta; }
	110	void SetHistImDtheta(TH1D* const aHistImDtheta)
	111	{this->fHistImDtheta = aHistImDtheta; }
80f72ed6	112	TH1F* GetHistQsumforChi() const {return this->fHistQsumforChi; }
80f72ed6	113	void SetHistQsumforChi(TH1F* const aHistQsumforChi)
9d062fe3	114	{this->fHistQsumforChi = aHistQsumforChi; }
9d062fe3	115
80f72ed6	116	void SetFirstRunList(TList* const list) { this->fFirstRunList = list; }
80f72ed6	117	TList* GetFirstRunList() const { return this->fFirstRunList; }
f1d945a1	118
153c1b38	119	TComplex GetGrtheta(AliFlowEventSimple* anEvent, Double_t aR, Double_t aTheta);
	120	TComplex GetDiffFlow(AliFlowEventSimple* anEvent, Double_t aR, Int_t theta);
	121
	122
f1d945a1	123	private:
f1d945a1	124
9d062fe3	125	AliFlowAnalysisWithLeeYangZeros(const AliFlowAnalysisWithLeeYangZeros& aAnalysis); // copy constructor
882ffd6a	126	AliFlowAnalysisWithLeeYangZeros& operator=(const AliFlowAnalysisWithLeeYangZeros& aAnalysis); //assignment operator
f1d945a1	127
0092f3c2	128	Bool_t MakeControlHistograms(AliFlowEventSimple* anEvent);
	129	Bool_t FillFromFlowEvent(AliFlowEventSimple* anEvent);
	130	Bool_t SecondFillFromFlowEvent(AliFlowEventSimple* anEvent);
f1d945a1	131
f1d945a1	132	#ifndef __CINT__
f1d945a1	133
882ffd6a	134	TVector2* fQsum; // flow vector sum
80f72ed6	135	Double_t fQ2sum; // flow vector sum squared
882ffd6a	136
f1d945a1	137	#endif /__CINT__/
f1d945a1	138
80f72ed6	139	Int_t fEventNumber; // event counter
882ffd6a	140
80f72ed6	141	Bool_t fFirstRun ; // flag for lyz analysis: true=first run over data, false=second run
	142	Bool_t fUseSum ; // flag for lyz analysis: true=use sum gen.function, false=use product gen.function
	143	Bool_t fDoubleLoop ; // flag for studying non flow effects
	144	Bool_t fDebug ; // flag for lyz analysis: more print statements
882ffd6a	145
80f72ed6	146	TList* fHistList; //list to hold all output histograms
80f72ed6	147	TList* fFirstRunList; //list from first run output
9d062fe3	148
b9ac26e9	149	TH1D* fHistVtheta; //hist of V(theta)
80f72ed6	150	TProfile* fHistProVetaRP; //hist of v(eta) for RP selection
	151	TProfile* fHistProVetaPOI; //hist of v(eta) for POI selection
	152	TProfile* fHistProVPtRP; //hist of v(pt) for RP selection
	153	TProfile* fHistProVPtPOI; //hist of v(pt) for POI selection
b9ac26e9	154	TH1D* fHistR0theta; //hist of r0(theta)
80f72ed6	155	TProfile* fHistProReDenom; //hist of the real part of the denominator
80f72ed6	156	TProfile* fHistProImDenom; //hist of the imaginary part of the denominator
b9ac26e9	157	TH1D* fHistReDtheta; //hist of the real part of D^theta
b9ac26e9	158	TH1D* fHistImDtheta; //hist of the imaginary part of D^theta
80f72ed6	159	TH1F* fHistQsumforChi; //hist of sum of Q-vectors and the sum of the square of Q-vectors
9d062fe3	160
9d062fe3	161
f1d945a1	162	//class AliFlowLYZHist1 defines the histograms: fHistProGtheta, fHistProReGtheta, fHistProImGtheta
80f72ed6	163	AliFlowLYZHist1* fHist1[5]; //array of hist1
f1d945a1	164
	165	//class AliFlowLYZHist1 defines the histograms: fHistProReNumer, fHistProImNumer, fHistProReNumerPt,
	166	//fHistProImNumerPt, fHistProReNumer2D, fHistProImNumer2D.
80f72ed6	167	AliFlowLYZHist2* fHist2RP[5]; //array of hist2
80f72ed6	168	AliFlowLYZHist2* fHist2POI[5]; //array of hist2
f1d945a1	169
80f72ed6	170	AliFlowCommonHist* fCommonHists; //control histograms
80f72ed6	171	AliFlowCommonHistResults* fCommonHistsRes; //final results histograms
f1d945a1	172
c109b8c7	173	ClassDef(AliFlowAnalysisWithLeeYangZeros,0) // macro for rootcint
153c1b38	174	};
f1d945a1	175
	176
	177	#endif
882ffd6a	178