[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowConstants.h

//////////////////////////////////////////////////////////////////////
//
// $Id$
//
// Author: Emanuele Simili
//
//////////////////////////////////////////////////////////////////////
//
// Description: constants for the flow makers
//  bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla  
//  bla bla bla bla bla bla bla bla bla bla bla bla bla bla ...
//
// Original Authors:                 Art Poskanzer & Raimond Snellings
//
//////////////////////////////////////////////////////////////////////

#ifndef ALIFLOWCONSTANTS_H
#define ALIFLOWCONSTANTS_H

#include <TROOT.h>

class AliFlowConstants {


 public:

 // Enumerators
  enum {
    kHars        =   2, 					// number of harmonics (>= 2)
    kSels        =   2, 					// number of selections (for each harmonics) 
    kSubs        =   2, 					// number of sub-events
    kPhiBins     = 360, 					// number of phi bins in weighting histograms
    kEtaBins     = 100,						// number of eta bins in FlowAnalysis histograms
    kPtBins      = 100,						// number of pT bins in FlowAnalysis histograms
    kPtBinsPart  = 100,						// number of pT bins in flow histograms
    kCumulIntegOrders = 3, 					// order of the cumulant analysis
    kCumulIntegQmax   = 8,					// ..
    kCumulDiffOrders  = 2,					// ..
    kCumulDiffQmax    = 8,					// ..
    kCents       = 9,						// total number of centrality classes
    kPid         = 6						// total number of p.id. hypotesis
  };

 // new type
  typedef Double_t PhiWgt_t[kSels][kHars][kPhiBins]; 		// 3d_array type,used to import phi weights from histograms 

//  // Get methods  (not working ...)
//   Int_t   MClabel() const	   { return fgMClabel ; }
//   Bool_t  Debug() const	   { return fgDebug ; } 
//   Float_t MaxInt() const	   { return fgMaxInt ; }	  
// 
//   Float_t EtaMin() const	   { return fgEtaMin ; }	         
//   Float_t EtaMax() const	   { return fgEtaMax ; }	         
//   Float_t PtMin() const	   { return fgPtMin ; } 	       
//   Float_t PtMax() const	   { return fgPtMax ; } 	       
//   Float_t PtMaxPart() const	   { return fgPtMaxPart ; }	          
//   Float_t PtWgtSaturation() const  { return fgPtWgtSaturation ; }         
// 
//   Float_t EtaMid() const	   { return fgEtaMid ; }	 
//   Float_t EtaGood() const	   { return fgEtaGood ; }	        	
// 
//   Float_t  MaxMult() const	   { return fgMaxMult ; }			
//   Int_t    Cent(Int_t i) const     { return (Int_t)(fgMaxMult * fgCentNorm[i]) ; }
//   Int_t    Cent0(Int_t i) const	   { return fgCent0[i] ; }
//   Double_t Bayesian(Int_t i) const { return fgBayesian[i] ; }
// 
//   Float_t  ITSx() const     	   { return fgITSx ; }      	   
//   Float_t  TPCx() const     	   { return fgTPCx ; }      	   
//   Float_t  TRDx() const     	   { return fgTRDx ; }      	   
//   Float_t  TOFx() const     	   { return fgTOFx ; }      	   
// 
//   Double_t MagneticField() const      { return fgMagneticField ; } 	      
//   Double_t CenterOfMassEnergy() const { return fgCenterOfMassEnergy ; }  
//   Short_t  BeamMassNumberEast() const { return fgBeamMassNumberEast ; }  
//   Short_t  BeamMassNumberWest() const { return fgBeamMassNumberWest ; }  
// 
//  // Set methods
//   void SetEtaGood(Float_t eta)	           { fgEtaGood = eta; }			
//   void SetMClabel(Int_t mc)		   { fgMClabel = mc ; }
//   void SetDebug(Int_t db)		   { fgDebug = db ; } 
//   void SetMaxMult(Float_t mult)   	   { fgMaxMult = mult ; }		
//   void SetCent0(Int_t i, Int_t mult)       { fgCent0[i] = mult ; }
//   void SetBayesian(Int_t i, Double_t mult) { fgBayesian[i] = mult ; }
// 
// 
//  private:

 // Histograms limits
  static Float_t  fgEtaMin ;	     			        // eta lower limit for FlowAnalysis histograms
  static Float_t  fgEtaMax ;	     			        // eta upper limit for FlowAnalysis histograms
  static Float_t  fgPtMin ;	     			        // pT lower limit for FlowAnalysis histograms
  static Float_t  fgPtMax ;	     			        // pT upper limit for yield histograms
  static Float_t  fgPtMaxPart ;      			        // pT upper limit for flow histograms
  static Float_t  fgPtWgtSaturation ;			        // flow(pT) saturation value
  static Float_t  fgEtaMinTpcOnly ;  			        // eta lower limit of the full TPC acceptance (-0.9)
  static Float_t  fgEtaMaxTpcOnly ;  			        // eta upper limit of the full TPC acceptance (+0.9)

 // Centrality Measurement
  static Float_t  fgEtaMid ;              		    	// Mid-Rapidity interval, used for Centrality measurement
  static Float_t  fgEtaGood ;             		    	// Good Rapidity interval (TPC acceptance)
  static Int_t    fgCent0[AliFlowConstants::kCents] ;		// Expected Multiplicity for each Centrality class
  static Double_t fgBayesian[AliFlowConstants::kPid] ;		// Expected particles' abundance
  static Float_t  fgCentNorm[AliFlowConstants::kCents] ;	// Normalized Multiplicity for each Centrality class
  static Float_t  fgMaxMult ;              		    	// Maximum expected multiplicity

 // Experimental Conditions
  static Double_t fgMagneticField;	 		    	// magnetic field value (0.4 Tesla)
  static Double_t fgCenterOfMassEnergy;   		    	// center of mass energy (5.5 TeV)
  static Short_t  fgBeamMassNumberEast;   		    	// beam mass (Pb = 208)
  static Short_t  fgBeamMassNumberWest;   		    	// beam mass (Pb = 208)

 // ALICE detector measures
  static Float_t  fgITSx ;      			        // inner ITS radial distance from the interaction point
  static Float_t  fgTPCx ;      			        // inner TPC radial distance from the interaction point 
  static Float_t  fgTRDx ;      			        // inner TRD radial distance from the interaction point 
  static Float_t  fgTOFx ;      			        // inner TOF radial distance from the interaction point 

 // ...
  static Int_t    fgMClabel ;				        // checking the simulation: pTrack->Label()<fMClabel = primary track 
  static Bool_t   fgDebug ;  				        // for more cout statements (debugging purpose)
  static Float_t  fgMaxInt ; 				        // big number (to avoid overflows)

  ClassDef(AliFlowConstants,2)          			// macro for rootcint
};

#endif

//////////////////////////////////////////////////////////////////////
Commit	Line	Data
30a892e3	1	//////////////////////////////////////////////////////////////////////
	2	//
	3	// $Id$
	4	//
	5	// Author: Emanuele Simili
	6	//
	7	//////////////////////////////////////////////////////////////////////
	8	//
	9	// Description: constants for the flow makers
327288af	10	// bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla
327288af	11	// bla bla bla bla bla bla bla bla bla bla bla bla bla bla ...
30a892e3	12	//
	13	// Original Authors: Art Poskanzer & Raimond Snellings
	14	//
	15	//////////////////////////////////////////////////////////////////////
	16
327288af	17	#ifndef ALIFLOWCONSTANTS_H
327288af	18	#define ALIFLOWCONSTANTS_H
30a892e3	19
	20	#include <TROOT.h>
	21
327288af	22	class AliFlowConstants {
30a892e3	23
92016a03	24
30a892e3	25	public:
30a892e3	26
92016a03	27	// Enumerators
30a892e3	28	enum {
327288af	29	kHars = 2, // number of harmonics (>= 2)
	30	kSels = 2, // number of selections (for each harmonics)
	31	kSubs = 2, // number of sub-events
	32	kPhiBins = 360, // number of phi bins in weighting histograms
	33	kEtaBins = 100, // number of eta bins in FlowAnalysis histograms
	34	kPtBins = 100, // number of pT bins in FlowAnalysis histograms
	35	kPtBinsPart = 100, // number of pT bins in flow histograms
	36	kCumulIntegOrders = 3, // order of the cumulant analysis
	37	kCumulIntegQmax = 8, // ..
	38	kCumulDiffOrders = 2, // ..
	39	kCumulDiffQmax = 8, // ..
	40	kCents = 9, // total number of centrality classes
	41	kPid = 6 // total number of p.id. hypotesis
30a892e3	42	};
30a892e3	43
92016a03	44	// new type
92016a03	45	typedef Double_t PhiWgt_t[kSels][kHars][kPhiBins]; // 3d_array type,used to import phi weights from histograms
30a892e3	46
92016a03	47	// // Get methods (not working ...)
	48	// Int_t MClabel() const { return fgMClabel ; }
	49	// Bool_t Debug() const { return fgDebug ; }
	50	// Float_t MaxInt() const { return fgMaxInt ; }
	51	//
	52	// Float_t EtaMin() const { return fgEtaMin ; }
	53	// Float_t EtaMax() const { return fgEtaMax ; }
	54	// Float_t PtMin() const { return fgPtMin ; }
	55	// Float_t PtMax() const { return fgPtMax ; }
	56	// Float_t PtMaxPart() const { return fgPtMaxPart ; }
	57	// Float_t PtWgtSaturation() const { return fgPtWgtSaturation ; }
	58	//
	59	// Float_t EtaMid() const { return fgEtaMid ; }
	60	// Float_t EtaGood() const { return fgEtaGood ; }
	61	//
	62	// Float_t MaxMult() const { return fgMaxMult ; }
	63	// Int_t Cent(Int_t i) const { return (Int_t)(fgMaxMult * fgCentNorm[i]) ; }
	64	// Int_t Cent0(Int_t i) const { return fgCent0[i] ; }
	65	// Double_t Bayesian(Int_t i) const { return fgBayesian[i] ; }
	66	//
	67	// Float_t ITSx() const { return fgITSx ; }
	68	// Float_t TPCx() const { return fgTPCx ; }
	69	// Float_t TRDx() const { return fgTRDx ; }
	70	// Float_t TOFx() const { return fgTOFx ; }
	71	//
	72	// Double_t MagneticField() const { return fgMagneticField ; }
	73	// Double_t CenterOfMassEnergy() const { return fgCenterOfMassEnergy ; }
	74	// Short_t BeamMassNumberEast() const { return fgBeamMassNumberEast ; }
	75	// Short_t BeamMassNumberWest() const { return fgBeamMassNumberWest ; }
	76	//
	77	// // Set methods
	78	// void SetEtaGood(Float_t eta) { fgEtaGood = eta; }
	79	// void SetMClabel(Int_t mc) { fgMClabel = mc ; }
	80	// void SetDebug(Int_t db) { fgDebug = db ; }
	81	// void SetMaxMult(Float_t mult) { fgMaxMult = mult ; }
	82	// void SetCent0(Int_t i, Int_t mult) { fgCent0[i] = mult ; }
	83	// void SetBayesian(Int_t i, Double_t mult) { fgBayesian[i] = mult ; }
	84	//
	85	//
	86	// private:
30a892e3	87
30a892e3	88	// Histograms limits
92016a03	89	static Float_t fgEtaMin ; // eta lower limit for FlowAnalysis histograms
	90	static Float_t fgEtaMax ; // eta upper limit for FlowAnalysis histograms
	91	static Float_t fgPtMin ; // pT lower limit for FlowAnalysis histograms
	92	static Float_t fgPtMax ; // pT upper limit for yield histograms
	93	static Float_t fgPtMaxPart ; // pT upper limit for flow histograms
	94	static Float_t fgPtWgtSaturation ; // flow(pT) saturation value
	95	static Float_t fgEtaMinTpcOnly ; // eta lower limit of the full TPC acceptance (-0.9)
	96	static Float_t fgEtaMaxTpcOnly ; // eta upper limit of the full TPC acceptance (+0.9)
30a892e3	97
30a892e3	98	// Centrality Measurement
327288af	99	static Float_t fgEtaMid ; // Mid-Rapidity interval, used for Centrality measurement
	100	static Float_t fgEtaGood ; // Good Rapidity interval (TPC acceptance)
	101	static Int_t fgCent0[AliFlowConstants::kCents] ; // Expected Multiplicity for each Centrality class
	102	static Double_t fgBayesian[AliFlowConstants::kPid] ; // Expected particles' abundance
	103	static Float_t fgCentNorm[AliFlowConstants::kCents] ; // Normalized Multiplicity for each Centrality class
	104	static Float_t fgMaxMult ; // Maximum expected multiplicity
30a892e3	105
30a892e3	106	// Experimental Conditions
327288af	107	static Double_t fgMagneticField; // magnetic field value (0.4 Tesla)
	108	static Double_t fgCenterOfMassEnergy; // center of mass energy (5.5 TeV)
	109	static Short_t fgBeamMassNumberEast; // beam mass (Pb = 208)
	110	static Short_t fgBeamMassNumberWest; // beam mass (Pb = 208)
30a892e3	111
92016a03	112	// ALICE detector measures
	113	static Float_t fgITSx ; // inner ITS radial distance from the interaction point
	114	static Float_t fgTPCx ; // inner TPC radial distance from the interaction point
	115	static Float_t fgTRDx ; // inner TRD radial distance from the interaction point
	116	static Float_t fgTOFx ; // inner TOF radial distance from the interaction point
30a892e3	117
92016a03	118	// ...
	119	static Int_t fgMClabel ; // checking the simulation: pTrack->Label()<fMClabel = primary track
	120	static Bool_t fgDebug ; // for more cout statements (debugging purpose)
	121	static Float_t fgMaxInt ; // big number (to avoid overflows)
30a892e3	122
92016a03	123	ClassDef(AliFlowConstants,2) // macro for rootcint
30a892e3	124	};
30a892e3	125
30a892e3	126	#endif
	127
	128	//////////////////////////////////////////////////////////////////////