[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowCommon / AliFlowEventSimpleMakerOnTheFly.h

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

/********************************** 
 * create an event and perform    *
 * flow analysis 'on the fly'     * 
 *                                * 
 * authors: Raimond Snellings     *
 *           (snelling@nikhef.nl) * 
 *          Ante Bilandzic        * 
 *           (anteb@nikhef.nl)    *
 *********************************/ 

#ifndef ALIFLOWEVENTSIMPLEMAKERONTHEFLY_H
#define ALIFLOWEVENTSIMPLEMAKERONTHEFLY_H

class TF1;
class TRandom3;

#include "AliFlowEventSimple.h"  //needed as include
#include "AliFlowTrackSimpleCuts.h"
    
class AliFlowEventSimpleMakerOnTheFly {

 public:

  AliFlowEventSimpleMakerOnTheFly(UInt_t);    // constructor
  virtual ~AliFlowEventSimpleMakerOnTheFly(); // destructor

  virtual void Init(); 
  
  AliFlowEventSimple* CreateEventOnTheFly(AliFlowTrackSimpleCuts *cutsRP, AliFlowTrackSimpleCuts *cutsPOI);  // create an event on the fly
 
    
  //                        *****************************
  //                        **** SETTERS AND GETTERS ****
  //                        *****************************
  //................................................................................................
  // setters and getters for global parameters:
  void SetMultDistrOfRPsIsGauss(Bool_t const mdorig) {this->fMultDistrOfRPsIsGauss = mdorig;};
  Bool_t GetMultDistrOfRPsIsGauss() const {return this->fMultDistrOfRPsIsGauss;};
  
  void SetMultiplicityOfRP(Int_t multRP) {this->fMultiplicityOfRP = multRP;}
  Int_t GetMultiplicityOfRP() const {return this->fMultiplicityOfRP;} 
  
  void SetMultiplicitySpreadOfRP(Double_t multSpreadRP) {this->fMultiplicitySpreadOfRP = multSpreadRP;}
  Double_t GetMultiplicitySpreadOfRP() const {return this->fMultiplicitySpreadOfRP;} 
  
  void SetMinMultOfRP(Int_t minmr) {this->fMinMultOfRP = minmr;}
  Int_t GetMinMultOfRP() const {return this->fMinMultOfRP;} 
  
  void SetMaxMultOfRP(Int_t maxmr) {this->fMaxMultOfRP = maxmr;}
  Int_t GetMaxMultOfRP() const {return this->fMaxMultOfRP;} 
  
  void SetTemperatureOfRP(Double_t temperatureRP) {this->fTemperatureOfRP = temperatureRP;}
  Double_t GetTemperatureOfRP() const {return this->fTemperatureOfRP;} 
  
  void SetPtDependentHarmonicV1(Bool_t const pdhV1) {this->fPtDependentHarmonicV1 = pdhV1;};
  Bool_t GetPtDependentHarmonicV1() const {return this->fPtDependentHarmonicV1;};
  
  void SetEtaDependentHarmonicV1(Bool_t const edhV1) {this->fEtaDependentHarmonicV1 = edhV1;};
  Bool_t GetEtaDependentHarmonicV1() const {return this->fEtaDependentHarmonicV1;};
  
  void SetPtDependentHarmonicV2(Bool_t const pdhV2) {this->fPtDependentHarmonicV2 = pdhV2;};
  Bool_t GetPtDependentHarmonicV2() const {return this->fPtDependentHarmonicV2;};
  
  void SetEtaDependentHarmonicV2(Bool_t const edhV2) {this->fEtaDependentHarmonicV2 = edhV2;};
  Bool_t GetEtaDependentHarmonicV2() const {return this->fEtaDependentHarmonicV2;};
  
  void SetPtDependentHarmonicV4(Bool_t const pdhV4) {this->fPtDependentHarmonicV4 = pdhV4;};
  Bool_t GetPtDependentHarmonicV4() const {return this->fPtDependentHarmonicV4;};
  
  void SetEtaDependentHarmonicV4(Bool_t const edhV4) {this->fEtaDependentHarmonicV4 = edhV4;};
  Bool_t GetEtaDependentHarmonicV4() const {return this->fEtaDependentHarmonicV4;};
  
  // constant harmonics:  
  void SetV1RP(Double_t dV1RP) {this->fV1RP = dV1RP;}
  Double_t GetV1RP() const {return this->fV1RP;} 
  
  void SetV1SpreadRP(Double_t dV1SpreadRP) {this->fV1SpreadRP = dV1SpreadRP;}
  Double_t GetV1SpreadRP() const {return this->fV1SpreadRP;} 
  
  void SetConstantV2IsSampledFromGauss(Bool_t const cV2isfg) {this->fConstantV2IsSampledFromGauss = cV2isfg;};
  Bool_t GetConstantV2IsSampledFromGauss() const {return this->fConstantV2IsSampledFromGauss;};
  
  void SetV2RP(Double_t dV2RP) {this->fV2RP = dV2RP;}
  Double_t GetV2RP() const {return this->fV2RP;} 
  
  void SetV2SpreadRP(Double_t dV2SpreadRP) {this->fV2SpreadRP = dV2SpreadRP;}
  Double_t GetV2SpreadRP() const {return this->fV2SpreadRP;} 
  
  void SetMinV2RP(Double_t dMinV2RP) {this->fMinV2RP = dMinV2RP;}
  Double_t GetMinV2RP() const {return this->fMinV2RP;} 
  
  void SetMaxV2RP(Double_t dMaxV2RP) {this->fMaxV2RP = dMaxV2RP;}
  Double_t GetMaxV2RP() const {return this->fMaxV2RP;} 
  
  void SetV4RP(Double_t dV4RP) {this->fV4RP = dV4RP;}
  Double_t GetV4RP() const {return this->fV4RP;} 
  
  void SetV4SpreadRP(Double_t dV4SpreadRP) {this->fV4SpreadRP = dV4SpreadRP;}
  Double_t GetV4SpreadRP() const {return this->fV4SpreadRP;} 
  
  void SetV1vsPtEtaMax(Double_t dV1vsPtEtaMax) {this->fV1vsPtEtaMax = dV1vsPtEtaMax;}
  Double_t GetV1vsPtEtaMax() const {return this->fV1vsPtEtaMax;} 
  
  void SetV1PtCutOff(Double_t dV1PtCutOff) {this->fV1PtCutOff = dV1PtCutOff;}
  Double_t GetV1PtCutOff() const {return this->fV1PtCutOff;} 
  
  void SetV2vsPtEtaMax(Double_t dV2vsPtEtaMax) {this->fV2vsPtEtaMax = dV2vsPtEtaMax;}
  Double_t GetV2vsPtEtaMax() const {return this->fV2vsPtEtaMax;} 
  
  void SetV2PtCutOff(Double_t dV2PtCutOff) {this->fV2PtCutOff = dV2PtCutOff;}
  Double_t GetV2PtCutOff() const {return this->fV2PtCutOff;} 
  
  void SetV2vsEtaSpread(Double_t dV2vsEtaSpread) {this->fV2vsEtaSpread = dV2vsEtaSpread;}
  Double_t GetV2vsEtaSpread() const {return this->fV2vsEtaSpread;} 
  
  void SetFirstSectorPhiMin(Double_t dPhiMin1) {this->fPhiMin1 = dPhiMin1;}
  Double_t GetFirstSectorPhiMin() const {return this->fPhiMin1;} 
  
  void SetFirstSectorPhiMax(Double_t dPhiMax1) {this->fPhiMax1 = dPhiMax1;}
  Double_t GetFirstSectorPhiMax() const {return this->fPhiMax1;}
  
  void SetFirstSectorProbability(Double_t dProbability1) {this->fProbability1 = dProbability1;}
  Double_t GetFirstProbability() const {return this->fProbability1;}  
  
  void SetSecondSectorPhiMin(Double_t dPhiMin2) {this->fPhiMin2 = dPhiMin2;}
  Double_t GetSecondSectorPhiMin() const {return this->fPhiMin2;} 
  
  void SetSecondSectorPhiMax(Double_t dPhiMax2) {this->fPhiMax2 = dPhiMax2;}
  Double_t GetSecondSectorPhiMax() const {return this->fPhiMax2;}
  
  void SetSecondSectorProbability(Double_t dProbability2) {this->fProbability2 = dProbability2;}
  Double_t GetSecondProbability() const {return this->fProbability2;}  
  //................................................................................................
  
  void SetNoOfLoops(Int_t noofl) {this->fNoOfLoops = noofl;}
  Int_t GetNoOfLoops() const {return this->fNoOfLoops;} 
  void SetPhiRange(Double_t phr) {this->fPhiRange = phr;}
  Double_t GetPhiRange() const {return this->fPhiRange;}   
  void SetPtRange(Double_t pr) {this->fPtRange = pr;}
  Double_t GetPtRange() const {return this->fPtRange;}   
  void SetEtaRange(Double_t er) {this->fEtaRange = er;}
  Double_t GetEtaRange() const {return this->fEtaRange;} 
  void SetNonflowSectorMin(Double_t nsMin) {this->fNonflowSectorMin = nsMin;}
  Double_t GetNonflowSectorMin() const {return this->fNonflowSectorMin;} 
  void SetNonflowSectorMax(Double_t nsMax) {this->fNonflowSectorMax = nsMax;}
  Double_t GetNonflowSectorMax() const {return this->fNonflowSectorMax;} 
  void SetSubeventEtaRange(Double_t minA,Double_t maxA,Double_t minB,Double_t maxB) 
  {this->fEtaMinA = minA; this->fEtaMaxA = maxA;this->fEtaMinB = minB; this->fEtaMaxB = maxB;};

 private:
 
  AliFlowEventSimpleMakerOnTheFly(const AliFlowEventSimpleMakerOnTheFly& anAnalysis);            // copy constructor
  AliFlowEventSimpleMakerOnTheFly& operator=(const AliFlowEventSimpleMakerOnTheFly& anAnalysis); // assignment operator
  
  //................................................................................................
  // global parameters:
  Bool_t    fMultDistrOfRPsIsGauss;  // 1.) if kTRUE  = multiplicitiy of RPs is sampled e-b-e from Gaussian distribution with
                                     //                 mean = fMultiplicityOfRP and spread = fMultiplicitySpreadOfRP
                                     // 2.) if kFALSE = multiplicitiy of RPs is sampled e-b-e uniformly from 
                                     //                 interval [fMinMultOfRP,fMaxMultOfRP]
  Int_t     fMultiplicityOfRP;       // mean multiplicity of RPs (if sampled from Gaussian)
  Double_t  fMultiplicitySpreadOfRP; // multiplicity spread of RPs (if sampled from Gaussian)
  Int_t     fMinMultOfRP;            // minimal multiplicity of RPs (if sampled uniformly)
  Int_t     fMaxMultOfRP;            // maximum multiplicity of RPs (if sampled uniformly)
  Double_t  fTemperatureOfRP;        // "temperature" of RPs in GeV/c (increase this parameter to get more high pt RPs) 
  Bool_t    fPtDependentHarmonicV1;  // harmonic V1 is a function of pt     
  Bool_t    fEtaDependentHarmonicV1; // harmonic V1 is a function of eta     
  Bool_t    fPtDependentHarmonicV2;  // harmonic V2 is a function of pt     
  Bool_t    fEtaDependentHarmonicV2; // harmonic V2 is a function of eta     
  Bool_t    fPtDependentHarmonicV4;  // harmonic V4 is a function of pt     
  Bool_t    fEtaDependentHarmonicV4; // harmonic V4 is a function of eta     
  
  // constant harmonics: 
  Double_t  fV1RP;                   // directed flow of RPs
  Double_t  fV1SpreadRP;             // directed flow spread of RPs
  
  Bool_t    fConstantV2IsSampledFromGauss; // 1.) if kTRUE  = elliptic flow of RPs is sampled e-b-e from Gaussian distribution with
                                           //                 mean = fV2RP and spread = fV2SpreadRP
                                           // 2.) if kFALSE = elliptic flow of RPs is sampled e-b-e uniformly from 
                                           //                 interval [fMinV2RP,fMaxV2RP]
  Double_t  fV2RP;                   // mean elliptic flow of RPs (if sampled from Gaussian)
  Double_t  fV2SpreadRP;             // elliptic flow spread of RPs (if sampled from Gaussian)
  Double_t  fMinV2RP;                // minimal elliptic flow of RPs (if sampled uniformly)
  Double_t  fMaxV2RP;                // minimal elliptic flow of RPs (if sampled uniformly)
  
  Double_t  fV4RP;                   // harmonic V4 of RPs
  Double_t  fV4SpreadRP;             // harmonic V4's spread of RPs
  // (pt,eta) dependent harmonic V1:
  Double_t  fV1vsPtEtaMax;           // max value of (pt,eta) dependent V1
  Double_t  fV1PtCutOff;             // V1(pt) is linear up to pt = dV1PtCutOff and for pt > dV1PtCutOff it is constant, V1(pt) = dV1vsPtEtaMax
  // (pt,eta) dependent harmonic V2:
  Double_t  fV2vsPtEtaMax;           // max value of (pt,eta) dependent V2
  Double_t  fV2PtCutOff;               // V2(pt) is linear up to pt = dV2PtCutOff and for pt > dV2PtCutOff it is constant, V2(pt) = dV2vsPtEtaMax
  Double_t  fV2vsEtaSpread;          // V2(eta) is Gaussian centered at midrapidity (eta=0) with spread = dV2vsEtaSpread
  // non-uniform acceptance:
  Double_t  fPhiMin1;                // first non-uniform sector starts at azimuth fPhiMin1
  Double_t  fPhiMax1;                // first non-uniform sector ends at azimuth fPhiMax1
  Double_t  fProbability1;           // particles emitted in fPhiMin1 < phi < fPhiMax1 are taken with probability fProbability1 
  Double_t  fPhiMin2;                // second non-uniform sector starts at azimuth fPhiMin2
  Double_t  fPhiMax2;                // second non-uniform sector starts at azimuth fPhiMax2
  Double_t  fProbability2;           // particles emitted in fPhiMin2 < phi < fPhiMax2 are taken with probability fProbability2
  //................................................................................................
  
  //................................................................................................
  // equations for distributions: 
  TF1*      fPtSpectra;  // transverse momentum distribution
  TF1*      fPhiDistribution; // azimuthal distribution
  //................................................................................................
  
  TRandom3* fMyTRandom3;       // our TRandom3 generator
  Int_t     fCount;            // count number of events 
  Int_t     fNoOfLoops;        // number of times to use the same particle (nonflow)
  Double_t  fPhiRange;         // splitted track phi range (+/- from original track's phi) for uniform sampling
  Double_t  fPtRange;          // splitted track pt range (+/- from original track's pt) for uniform sampling
  Double_t  fEtaRange;         // splitted track eta range (+/- from original track's eta) for uniform sampling
  Double_t  fNonflowSectorMin; // detector's sector in which tracks are splitted starts at angle fNonflowSectorMin
  Double_t  fNonflowSectorMax; // detector's sector in which tracks are splitted ends at angle fNonflowSectorMin
  Double_t  fEtaMinA;          // minimum eta of subevent A eta range
  Double_t  fEtaMaxA;          // maximum eta of subevent A eta range
  Double_t  fEtaMinB;          // minimum eta of subevent B eta range
  Double_t  fEtaMaxB;          // maximum eta of subevent B eta range  

  ClassDef(AliFlowEventSimpleMakerOnTheFly,0) // macro for rootcint
};
 
#endif
Commit	Line	Data
93ff27bd	1	/*
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
	3	* See cxx source for full Copyright notice
	4	* $Id$
	5	*/
	6
	7	/**********************************
	8	* create an event and perform *
	9	* flow analysis 'on the fly' *
	10	* *
	11	* authors: Raimond Snellings *
	12	* (snelling@nikhef.nl) *
	13	* Ante Bilandzic *
	14	* (anteb@nikhef.nl) *
	15	*********************************/
	16
	17	#ifndef ALIFLOWEVENTSIMPLEMAKERONTHEFLY_H
	18	#define ALIFLOWEVENTSIMPLEMAKERONTHEFLY_H
	19
	20	class TF1;
5b8dccde	21	class TRandom3;
93ff27bd	22
93ff27bd	23	#include "AliFlowEventSimple.h" //needed as include
e1911c19	24	#include "AliFlowTrackSimpleCuts.h"
93ff27bd	25
	26	class AliFlowEventSimpleMakerOnTheFly {
	27
	28	public:
	29
5b8dccde	30	AliFlowEventSimpleMakerOnTheFly(UInt_t); // constructor
93ff27bd	31	virtual ~AliFlowEventSimpleMakerOnTheFly(); // destructor
93ff27bd	32
4d603348	33	virtual void Init();
4d603348	34
e1911c19	35	AliFlowEventSimple* CreateEventOnTheFly(AliFlowTrackSimpleCuts cutsRP, AliFlowTrackSimpleCuts cutsPOI); // create an event on the fly
93ff27bd	36
	37
	38	// *****************************
	39	// ** SETTERS AND GETTERS **
	40	// *****************************
	41	//................................................................................................
	42	// setters and getters for global parameters:
678f8252	43	void SetMultDistrOfRPsIsGauss(Bool_t const mdorig) {this->fMultDistrOfRPsIsGauss = mdorig;};
	44	Bool_t GetMultDistrOfRPsIsGauss() const {return this->fMultDistrOfRPsIsGauss;};
	45
93ff27bd	46	void SetMultiplicityOfRP(Int_t multRP) {this->fMultiplicityOfRP = multRP;}
93ff27bd	47	Int_t GetMultiplicityOfRP() const {return this->fMultiplicityOfRP;}
93ff27bd	48
93ff27bd	49	void SetMultiplicitySpreadOfRP(Double_t multSpreadRP) {this->fMultiplicitySpreadOfRP = multSpreadRP;}
93ff27bd	50	Double_t GetMultiplicitySpreadOfRP() const {return this->fMultiplicitySpreadOfRP;}
4d603348	51
678f8252	52	void SetMinMultOfRP(Int_t minmr) {this->fMinMultOfRP = minmr;}
	53	Int_t GetMinMultOfRP() const {return this->fMinMultOfRP;}
	54
	55	void SetMaxMultOfRP(Int_t maxmr) {this->fMaxMultOfRP = maxmr;}
	56	Int_t GetMaxMultOfRP() const {return this->fMaxMultOfRP;}
	57
cf90787f	58	void SetTemperatureOfRP(Double_t temperatureRP) {this->fTemperatureOfRP = temperatureRP;}
	59	Double_t GetTemperatureOfRP() const {return this->fTemperatureOfRP;}
	60
bdb5c432	61	void SetPtDependentHarmonicV1(Bool_t const pdhV1) {this->fPtDependentHarmonicV1 = pdhV1;};
bdb5c432	62	Bool_t GetPtDependentHarmonicV1() const {return this->fPtDependentHarmonicV1;};
524798bf	63
bdb5c432	64	void SetEtaDependentHarmonicV1(Bool_t const edhV1) {this->fEtaDependentHarmonicV1 = edhV1;};
	65	Bool_t GetEtaDependentHarmonicV1() const {return this->fEtaDependentHarmonicV1;};
	66
	67	void SetPtDependentHarmonicV2(Bool_t const pdhV2) {this->fPtDependentHarmonicV2 = pdhV2;};
	68	Bool_t GetPtDependentHarmonicV2() const {return this->fPtDependentHarmonicV2;};
	69
	70	void SetEtaDependentHarmonicV2(Bool_t const edhV2) {this->fEtaDependentHarmonicV2 = edhV2;};
	71	Bool_t GetEtaDependentHarmonicV2() const {return this->fEtaDependentHarmonicV2;};
	72
	73	void SetPtDependentHarmonicV4(Bool_t const pdhV4) {this->fPtDependentHarmonicV4 = pdhV4;};
	74	Bool_t GetPtDependentHarmonicV4() const {return this->fPtDependentHarmonicV4;};
	75
	76	void SetEtaDependentHarmonicV4(Bool_t const edhV4) {this->fEtaDependentHarmonicV4 = edhV4;};
	77	Bool_t GetEtaDependentHarmonicV4() const {return this->fEtaDependentHarmonicV4;};
4d603348	78
4d603348	79	// constant harmonics:
e8c7e66c	80	void SetV1RP(Double_t dV1RP) {this->fV1RP = dV1RP;}
	81	Double_t GetV1RP() const {return this->fV1RP;}
	82
	83	void SetV1SpreadRP(Double_t dV1SpreadRP) {this->fV1SpreadRP = dV1SpreadRP;}
	84	Double_t GetV1SpreadRP() const {return this->fV1SpreadRP;}
	85
524798bf	86	void SetConstantV2IsSampledFromGauss(Bool_t const cV2isfg) {this->fConstantV2IsSampledFromGauss = cV2isfg;};
524798bf	87	Bool_t GetConstantV2IsSampledFromGauss() const {return this->fConstantV2IsSampledFromGauss;};
55381065	88
e8c7e66c	89	void SetV2RP(Double_t dV2RP) {this->fV2RP = dV2RP;}
	90	Double_t GetV2RP() const {return this->fV2RP;}
	91
	92	void SetV2SpreadRP(Double_t dV2SpreadRP) {this->fV2SpreadRP = dV2SpreadRP;}
	93	Double_t GetV2SpreadRP() const {return this->fV2SpreadRP;}
4d603348	94
55381065	95	void SetMinV2RP(Double_t dMinV2RP) {this->fMinV2RP = dMinV2RP;}
	96	Double_t GetMinV2RP() const {return this->fMinV2RP;}
	97
	98	void SetMaxV2RP(Double_t dMaxV2RP) {this->fMaxV2RP = dMaxV2RP;}
	99	Double_t GetMaxV2RP() const {return this->fMaxV2RP;}
	100
4d603348	101	void SetV4RP(Double_t dV4RP) {this->fV4RP = dV4RP;}
	102	Double_t GetV4RP() const {return this->fV4RP;}
	103
	104	void SetV4SpreadRP(Double_t dV4SpreadRP) {this->fV4SpreadRP = dV4SpreadRP;}
	105	Double_t GetV4SpreadRP() const {return this->fV4SpreadRP;}
	106
bdb5c432	107	void SetV1vsPtEtaMax(Double_t dV1vsPtEtaMax) {this->fV1vsPtEtaMax = dV1vsPtEtaMax;}
	108	Double_t GetV1vsPtEtaMax() const {return this->fV1vsPtEtaMax;}
	109
	110	void SetV1PtCutOff(Double_t dV1PtCutOff) {this->fV1PtCutOff = dV1PtCutOff;}
	111	Double_t GetV1PtCutOff() const {return this->fV1PtCutOff;}
524798bf	112
	113	void SetV2vsPtEtaMax(Double_t dV2vsPtEtaMax) {this->fV2vsPtEtaMax = dV2vsPtEtaMax;}
	114	Double_t GetV2vsPtEtaMax() const {return this->fV2vsPtEtaMax;}
4d603348	115
bdb5c432	116	void SetV2PtCutOff(Double_t dV2PtCutOff) {this->fV2PtCutOff = dV2PtCutOff;}
bdb5c432	117	Double_t GetV2PtCutOff() const {return this->fV2PtCutOff;}
e23cbd39	118
524798bf	119	void SetV2vsEtaSpread(Double_t dV2vsEtaSpread) {this->fV2vsEtaSpread = dV2vsEtaSpread;}
	120	Double_t GetV2vsEtaSpread() const {return this->fV2vsEtaSpread;}
	121
e23cbd39	122	void SetFirstSectorPhiMin(Double_t dPhiMin1) {this->fPhiMin1 = dPhiMin1;}
	123	Double_t GetFirstSectorPhiMin() const {return this->fPhiMin1;}
	124
	125	void SetFirstSectorPhiMax(Double_t dPhiMax1) {this->fPhiMax1 = dPhiMax1;}
	126	Double_t GetFirstSectorPhiMax() const {return this->fPhiMax1;}
	127
	128	void SetFirstSectorProbability(Double_t dProbability1) {this->fProbability1 = dProbability1;}
	129	Double_t GetFirstProbability() const {return this->fProbability1;}
	130
	131	void SetSecondSectorPhiMin(Double_t dPhiMin2) {this->fPhiMin2 = dPhiMin2;}
	132	Double_t GetSecondSectorPhiMin() const {return this->fPhiMin2;}
	133
	134	void SetSecondSectorPhiMax(Double_t dPhiMax2) {this->fPhiMax2 = dPhiMax2;}
	135	Double_t GetSecondSectorPhiMax() const {return this->fPhiMax2;}
	136
	137	void SetSecondSectorProbability(Double_t dProbability2) {this->fProbability2 = dProbability2;}
	138	Double_t GetSecondProbability() const {return this->fProbability2;}
e8c7e66c	139	//................................................................................................
e8c7e66c	140
aaa62cf0	141	void SetNoOfLoops(Int_t noofl) {this->fNoOfLoops = noofl;}
aaa62cf0	142	Int_t GetNoOfLoops() const {return this->fNoOfLoops;}
524798bf	143	void SetPhiRange(Double_t phr) {this->fPhiRange = phr;}
524798bf	144	Double_t GetPhiRange() const {return this->fPhiRange;}
2a54d329	145	void SetPtRange(Double_t pr) {this->fPtRange = pr;}
	146	Double_t GetPtRange() const {return this->fPtRange;}
	147	void SetEtaRange(Double_t er) {this->fEtaRange = er;}
	148	Double_t GetEtaRange() const {return this->fEtaRange;}
e1911c19	149	void SetNonflowSectorMin(Double_t nsMin) {this->fNonflowSectorMin = nsMin;}
	150	Double_t GetNonflowSectorMin() const {return this->fNonflowSectorMin;}
	151	void SetNonflowSectorMax(Double_t nsMax) {this->fNonflowSectorMax = nsMax;}
	152	Double_t GetNonflowSectorMax() const {return this->fNonflowSectorMax;}
809f4e8b	153	void SetSubeventEtaRange(Double_t minA,Double_t maxA,Double_t minB,Double_t maxB)
	154	{this->fEtaMinA = minA; this->fEtaMaxA = maxA;this->fEtaMinB = minB; this->fEtaMaxB = maxB;};
	155
93ff27bd	156	private:
	157
	158	AliFlowEventSimpleMakerOnTheFly(const AliFlowEventSimpleMakerOnTheFly& anAnalysis); // copy constructor
	159	AliFlowEventSimpleMakerOnTheFly& operator=(const AliFlowEventSimpleMakerOnTheFly& anAnalysis); // assignment operator
	160
	161	//................................................................................................
	162	// global parameters:
678f8252	163	Bool_t fMultDistrOfRPsIsGauss; // 1.) if kTRUE = multiplicitiy of RPs is sampled e-b-e from Gaussian distribution with
	164	// mean = fMultiplicityOfRP and spread = fMultiplicitySpreadOfRP
	165	// 2.) if kFALSE = multiplicitiy of RPs is sampled e-b-e uniformly from
	166	// interval [fMinMultOfRP,fMaxMultOfRP]
	167	Int_t fMultiplicityOfRP; // mean multiplicity of RPs (if sampled from Gaussian)
	168	Double_t fMultiplicitySpreadOfRP; // multiplicity spread of RPs (if sampled from Gaussian)
	169	Int_t fMinMultOfRP; // minimal multiplicity of RPs (if sampled uniformly)
	170	Int_t fMaxMultOfRP; // maximum multiplicity of RPs (if sampled uniformly)
cf90787f	171	Double_t fTemperatureOfRP; // "temperature" of RPs in GeV/c (increase this parameter to get more high pt RPs)
bdb5c432	172	Bool_t fPtDependentHarmonicV1; // harmonic V1 is a function of pt
	173	Bool_t fEtaDependentHarmonicV1; // harmonic V1 is a function of eta
	174	Bool_t fPtDependentHarmonicV2; // harmonic V2 is a function of pt
	175	Bool_t fEtaDependentHarmonicV2; // harmonic V2 is a function of eta
	176	Bool_t fPtDependentHarmonicV4; // harmonic V4 is a function of pt
	177	Bool_t fEtaDependentHarmonicV4; // harmonic V4 is a function of eta
	178
4d603348	179	// constant harmonics:
aaa62cf0	180	Double_t fV1RP; // directed flow of RPs
aaa62cf0	181	Double_t fV1SpreadRP; // directed flow spread of RPs
55381065	182
524798bf	183	Bool_t fConstantV2IsSampledFromGauss; // 1.) if kTRUE = elliptic flow of RPs is sampled e-b-e from Gaussian distribution with
	184	// mean = fV2RP and spread = fV2SpreadRP
	185	// 2.) if kFALSE = elliptic flow of RPs is sampled e-b-e uniformly from
	186	// interval [fMinV2RP,fMaxV2RP]
55381065	187	Double_t fV2RP; // mean elliptic flow of RPs (if sampled from Gaussian)
	188	Double_t fV2SpreadRP; // elliptic flow spread of RPs (if sampled from Gaussian)
	189	Double_t fMinV2RP; // minimal elliptic flow of RPs (if sampled uniformly)
	190	Double_t fMaxV2RP; // minimal elliptic flow of RPs (if sampled uniformly)
	191
4d603348	192	Double_t fV4RP; // harmonic V4 of RPs
4d603348	193	Double_t fV4SpreadRP; // harmonic V4's spread of RPs
bdb5c432	194	// (pt,eta) dependent harmonic V1:
	195	Double_t fV1vsPtEtaMax; // max value of (pt,eta) dependent V1
	196	Double_t fV1PtCutOff; // V1(pt) is linear up to pt = dV1PtCutOff and for pt > dV1PtCutOff it is constant, V1(pt) = dV1vsPtEtaMax
	197	// (pt,eta) dependent harmonic V2:
524798bf	198	Double_t fV2vsPtEtaMax; // max value of (pt,eta) dependent V2
bdb5c432	199	Double_t fV2PtCutOff; // V2(pt) is linear up to pt = dV2PtCutOff and for pt > dV2PtCutOff it is constant, V2(pt) = dV2vsPtEtaMax
524798bf	200	Double_t fV2vsEtaSpread; // V2(eta) is Gaussian centered at midrapidity (eta=0) with spread = dV2vsEtaSpread
e23cbd39	201	// non-uniform acceptance:
	202	Double_t fPhiMin1; // first non-uniform sector starts at azimuth fPhiMin1
	203	Double_t fPhiMax1; // first non-uniform sector ends at azimuth fPhiMax1
	204	Double_t fProbability1; // particles emitted in fPhiMin1 < phi < fPhiMax1 are taken with probability fProbability1
	205	Double_t fPhiMin2; // second non-uniform sector starts at azimuth fPhiMin2
	206	Double_t fPhiMax2; // second non-uniform sector starts at azimuth fPhiMax2
	207	Double_t fProbability2; // particles emitted in fPhiMin2 < phi < fPhiMax2 are taken with probability fProbability2
93ff27bd	208	//................................................................................................
	209
	210	//................................................................................................
	211	// equations for distributions:
aaa62cf0	212	TF1* fPtSpectra; // transverse momentum distribution
aaa62cf0	213	TF1* fPhiDistribution; // azimuthal distribution
93ff27bd	214	//................................................................................................
93ff27bd	215
e1911c19	216	TRandom3* fMyTRandom3; // our TRandom3 generator
	217	Int_t fCount; // count number of events
	218	Int_t fNoOfLoops; // number of times to use the same particle (nonflow)
	219	Double_t fPhiRange; // splitted track phi range (+/- from original track's phi) for uniform sampling
	220	Double_t fPtRange; // splitted track pt range (+/- from original track's pt) for uniform sampling
	221	Double_t fEtaRange; // splitted track eta range (+/- from original track's eta) for uniform sampling
	222	Double_t fNonflowSectorMin; // detector's sector in which tracks are splitted starts at angle fNonflowSectorMin
	223	Double_t fNonflowSectorMax; // detector's sector in which tracks are splitted ends at angle fNonflowSectorMin
	224	Double_t fEtaMinA; // minimum eta of subevent A eta range
	225	Double_t fEtaMaxA; // maximum eta of subevent A eta range
	226	Double_t fEtaMinB; // minimum eta of subevent B eta range
	227	Double_t fEtaMaxB; // maximum eta of subevent B eta range
809f4e8b	228
93ff27bd	229	ClassDef(AliFlowEventSimpleMakerOnTheFly,0) // macro for rootcint
	230	};
	231
	232	#endif
	233
	234
	235