[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowCommon / 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)
////////////////////////////////////////////////////////////////////


#include "AliFlowVector.h" //needed as include

//class AliFlowTrackSimple;
class AliFlowEventSimple;
class AliFlowLYZHist1; 
class AliFlowLYZHist2;
class AliFlowCommonHist;
class AliFlowCommonHistResults;

class TH1F;
class TH1D;
class TProfile;
class TProfile2D;
class TObjArray;
class TFile;
class TComplex;
class TString;
class TList;
class Riostream;

 
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
   
   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];} }

   TProfile*  GetHistProVtheta() const   {return this->fHistProVtheta; } 
   void       SetHistProVtheta(TProfile* const aHistProVtheta)     
     { this->fHistProVtheta = aHistProVtheta; }
   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; }
   TProfile*  GetHistProR0theta() const  {return this->fHistProR0theta; }
   void       SetHistProR0theta(TProfile* const aHistProR0theta)   
     {this->fHistProR0theta = aHistProR0theta; }
   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; }
   TProfile*  GetHistProReDtheta() const {return this->fHistProReDtheta; } 
   void       SetHistProReDtheta(TProfile* const aHistProReDtheta) 
     {this->fHistProReDtheta = aHistProReDtheta; }
   TProfile*  GetHistProImDtheta() const {return this->fHistProImDtheta; }
   void       SetHistProImDtheta(TProfile* const aHistProImDtheta) 
     {this->fHistProImDtheta = aHistProImDtheta; }
   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; }

 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);

   TComplex GetGrtheta(AliFlowEventSimple* anEvent, Double_t aR, Double_t aTheta);
   TComplex GetDiffFlow(AliFlowEventSimple* anEvent, Double_t aR, Int_t theta); 
   Double_t GetR0(TH1D* fHistGtheta);
   
#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
        
   TProfile*    fHistProVtheta;   //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
   TProfile*    fHistProR0theta;  //hist of r0(theta)    
   TProfile*    fHistProReDenom;  //hist of the real part of the denominator   
   TProfile*    fHistProImDenom;  //hist of the imaginary part of the denominator 
   TProfile*    fHistProReDtheta; //hist of the real part of D^theta   
   TProfile*    fHistProImDtheta; //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,1)  // 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
	19	#include "AliFlowVector.h" //needed as include
	20
882ffd6a	21	//class AliFlowTrackSimple;
f1d945a1	22	class AliFlowEventSimple;
	23	class AliFlowLYZHist1;
	24	class AliFlowLYZHist2;
	25	class AliFlowCommonHist;
	26	class AliFlowCommonHistResults;
	27
	28	class TH1F;
	29	class TH1D;
	30	class TProfile;
	31	class TProfile2D;
	32	class TObjArray;
	33	class TFile;
	34	class TComplex;
	35	class TString;
88e00a8a	36	class TList;
f1d945a1	37	class Riostream;
f1d945a1	38
f1d945a1	39
	40	class AliFlowAnalysisWithLeeYangZeros {
	41
	42	public:
	43
48385911	44	AliFlowAnalysisWithLeeYangZeros(); //default constructor
48385911	45	virtual ~AliFlowAnalysisWithLeeYangZeros(); //destructor
f1d945a1	46
48385911	47	Bool_t Init(); //defines variables and histograms
	48	Bool_t Make(AliFlowEventSimple* anEvent); //calculates variables and fills histograms
	49	void GetOutputHistograms(TList *outputListHistos); //get pointers to all output histograms (called before Finish())
	50	Bool_t Finish(); //saves histograms
	51	void WriteHistograms(TString* outputFileName); //writes histograms locally
	52	void WriteHistograms(TString outputFileName); //writes histograms locally
9d062fe3	53
882ffd6a	54	Double_t GetQtheta(AliFlowVector aQ, Double_t aTheta);
e8c3ff94	55
9d062fe3	56	void SetFirstRun(Bool_t kt) { this->fFirstRun = kt ; }
	57	Bool_t GetFirstRun() const { return this->fFirstRun ; }
	58	void SetUseSum(Bool_t kt) { this->fUseSum = kt ; }
	59	Bool_t GetUseSum() const { return this->fUseSum ; }
	60	void SetDoubleLoop(Bool_t kt) { this->fDoubleLoop = kt ; }
	61	Bool_t GetDoubleLoop() const { return this->fDoubleLoop ; }
	62	void SetDebug(Bool_t kt) { this->fDebug = kt ; }
	63	Bool_t GetDebug() const { return this->fDebug ; }
	64
	65	void SetEventNumber(Int_t n) { this->fEventNumber = n; }
	66	Int_t GetEventNumber() const { return this->fEventNumber; }
	67	void SetQ2sum(Double_t d) { this->fQ2sum = d; }
80f72ed6	68	Double_t GetQ2sum() const { return this->fQ2sum; }
f1d945a1	69
f1d945a1	70	// Output
9d062fe3	71	TList* GetHistList() const { return this->fHistList ; }
9d062fe3	72	AliFlowCommonHist* GetCommonHists() const { return this->fCommonHists; }
80f72ed6	73	void SetCommonHists(AliFlowCommonHist* const aCommonHist)
9d062fe3	74	{ this->fCommonHists = aCommonHist; }
	75	AliFlowCommonHistResults* GetCommonHistsRes() const
	76	{ return this->fCommonHistsRes; }
80f72ed6	77	void SetCommonHistsRes(AliFlowCommonHistResults* const aCommonHistResult)
9d062fe3	78	{ this->fCommonHistsRes = aCommonHistResult; }
9d062fe3	79	//AliFlowLYZHist1* GetHist1() const {return this->fHist1; }
80f72ed6	80	void SetHist1(AliFlowLYZHist1* const aLYZHist1[])
9d062fe3	81	{for (Int_t i=0;i<5;i++) {this->fHist1[i] = aLYZHist1[i];} }
9d062fe3	82	//AliFlowLYZHist2* GetHist2() const {return this->fHist2; }
80f72ed6	83	void SetHist2RP(AliFlowLYZHist2* const aLYZHist2RP[])
e8c3ff94	84	{for (Int_t i=0;i<5;i++) {this->fHist2RP[i] = aLYZHist2RP[i];} }
80f72ed6	85	void SetHist2POI(AliFlowLYZHist2* const aLYZHist2POI[])
e8c3ff94	86	{for (Int_t i=0;i<5;i++) {this->fHist2POI[i] = aLYZHist2POI[i];} }
9d062fe3	87
9d062fe3	88	TProfile* GetHistProVtheta() const {return this->fHistProVtheta; }
80f72ed6	89	void SetHistProVtheta(TProfile* const aHistProVtheta)
9d062fe3	90	{ this->fHistProVtheta = aHistProVtheta; }
e8c3ff94	91	TProfile* GetHistProVetaRP() const {return this->fHistProVetaRP; }
80f72ed6	92	void SetHistProVetaRP(TProfile* const aHistProVetaRP)
e8c3ff94	93	{this->fHistProVetaRP = aHistProVetaRP; }
e8c3ff94	94	TProfile* GetHistProVetaPOI() const {return this->fHistProVetaPOI; }
80f72ed6	95	void SetHistProVetaPOI(TProfile* const aHistProVetaPOI)
e8c3ff94	96	{this->fHistProVetaPOI = aHistProVetaPOI; }
e8c3ff94	97	TProfile* GetHistProVPtRP() const {return this->fHistProVPtRP;}
80f72ed6	98	void SetHistProVPtRP(TProfile* const aHistProVPtRP)
e8c3ff94	99	{this->fHistProVPtRP = aHistProVPtRP; }
e8c3ff94	100	TProfile* GetHistProVPtPOI() const {return this->fHistProVPtPOI;}
80f72ed6	101	void SetHistProVPtPOI(TProfile* const aHistProVPtPOI)
e8c3ff94	102	{this->fHistProVPtPOI = aHistProVPtPOI; }
9d062fe3	103	TProfile* GetHistProR0theta() const {return this->fHistProR0theta; }
80f72ed6	104	void SetHistProR0theta(TProfile* const aHistProR0theta)
9d062fe3	105	{this->fHistProR0theta = aHistProR0theta; }
9d062fe3	106	TProfile* GetHistProReDenom() const {return this->fHistProReDenom; }
80f72ed6	107	void SetHistProReDenom(TProfile* const aHistProReDenom)
9d062fe3	108	{this->fHistProReDenom = aHistProReDenom; }
9d062fe3	109	TProfile* GetHistProImDenom() const {return this->fHistProImDenom; }
80f72ed6	110	void SetHistProImDenom(TProfile* const aHistProImDenom)
9d062fe3	111	{this->fHistProImDenom = aHistProImDenom; }
9d062fe3	112	TProfile* GetHistProReDtheta() const {return this->fHistProReDtheta; }
80f72ed6	113	void SetHistProReDtheta(TProfile* const aHistProReDtheta)
9d062fe3	114	{this->fHistProReDtheta = aHistProReDtheta; }
9d062fe3	115	TProfile* GetHistProImDtheta() const {return this->fHistProImDtheta; }
80f72ed6	116	void SetHistProImDtheta(TProfile* const aHistProImDtheta)
9d062fe3	117	{this->fHistProImDtheta = aHistProImDtheta; }
80f72ed6	118	TH1F* GetHistQsumforChi() const {return this->fHistQsumforChi; }
80f72ed6	119	void SetHistQsumforChi(TH1F* const aHistQsumforChi)
9d062fe3	120	{this->fHistQsumforChi = aHistQsumforChi; }
9d062fe3	121
80f72ed6	122	void SetFirstRunList(TList* const list) { this->fFirstRunList = list; }
80f72ed6	123	TList* GetFirstRunList() const { return this->fFirstRunList; }
f1d945a1	124
	125	private:
	126
9d062fe3	127	AliFlowAnalysisWithLeeYangZeros(const AliFlowAnalysisWithLeeYangZeros& aAnalysis); // copy constructor
882ffd6a	128	AliFlowAnalysisWithLeeYangZeros& operator=(const AliFlowAnalysisWithLeeYangZeros& aAnalysis); //assignment operator
f1d945a1	129
0092f3c2	130	Bool_t MakeControlHistograms(AliFlowEventSimple* anEvent);
	131	Bool_t FillFromFlowEvent(AliFlowEventSimple* anEvent);
	132	Bool_t SecondFillFromFlowEvent(AliFlowEventSimple* anEvent);
f1d945a1	133
882ffd6a	134	TComplex GetGrtheta(AliFlowEventSimple* anEvent, Double_t aR, Double_t aTheta);
882ffd6a	135	TComplex GetDiffFlow(AliFlowEventSimple* anEvent, Double_t aR, Int_t theta);
9d062fe3	136	Double_t GetR0(TH1D* fHistGtheta);
f1d945a1	137
f1d945a1	138	#ifndef __CINT__
f1d945a1	139
882ffd6a	140	TVector2* fQsum; // flow vector sum
80f72ed6	141	Double_t fQ2sum; // flow vector sum squared
882ffd6a	142
f1d945a1	143	#endif /__CINT__/
f1d945a1	144
80f72ed6	145	Int_t fEventNumber; // event counter
882ffd6a	146
80f72ed6	147	Bool_t fFirstRun ; // flag for lyz analysis: true=first run over data, false=second run
	148	Bool_t fUseSum ; // flag for lyz analysis: true=use sum gen.function, false=use product gen.function
	149	Bool_t fDoubleLoop ; // flag for studying non flow effects
	150	Bool_t fDebug ; // flag for lyz analysis: more print statements
882ffd6a	151
80f72ed6	152	TList* fHistList; //list to hold all output histograms
80f72ed6	153	TList* fFirstRunList; //list from first run output
9d062fe3	154
80f72ed6	155	TProfile* fHistProVtheta; //hist of V(theta)
	156	TProfile* fHistProVetaRP; //hist of v(eta) for RP selection
	157	TProfile* fHistProVetaPOI; //hist of v(eta) for POI selection
	158	TProfile* fHistProVPtRP; //hist of v(pt) for RP selection
	159	TProfile* fHistProVPtPOI; //hist of v(pt) for POI selection
	160	TProfile* fHistProR0theta; //hist of r0(theta)
	161	TProfile* fHistProReDenom; //hist of the real part of the denominator
	162	TProfile* fHistProImDenom; //hist of the imaginary part of the denominator
	163	TProfile* fHistProReDtheta; //hist of the real part of D^theta
	164	TProfile* fHistProImDtheta; //hist of the imaginary part of D^theta
	165	TH1F* fHistQsumforChi; //hist of sum of Q-vectors and the sum of the square of Q-vectors
9d062fe3	166
9d062fe3	167
f1d945a1	168	//class AliFlowLYZHist1 defines the histograms: fHistProGtheta, fHistProReGtheta, fHistProImGtheta
80f72ed6	169	AliFlowLYZHist1* fHist1[5]; //array of hist1
f1d945a1	170
	171	//class AliFlowLYZHist1 defines the histograms: fHistProReNumer, fHistProImNumer, fHistProReNumerPt,
	172	//fHistProImNumerPt, fHistProReNumer2D, fHistProImNumer2D.
80f72ed6	173	AliFlowLYZHist2* fHist2RP[5]; //array of hist2
80f72ed6	174	AliFlowLYZHist2* fHist2POI[5]; //array of hist2
f1d945a1	175
80f72ed6	176	AliFlowCommonHist* fCommonHists; //control histograms
80f72ed6	177	AliFlowCommonHistResults* fCommonHistsRes; //final results histograms
f1d945a1	178
9d062fe3	179	ClassDef(AliFlowAnalysisWithLeeYangZeros,1) // macro for rootcint
f1d945a1	180	};
	181
	182
	183	#endif
882ffd6a	184