]>
Commit | Line | Data |
---|---|---|
36b81802 | 1 | // Implementation of the interface for THBTprocessor |
2 | // which is a wrapper itself to Fortran | |
3 | // program "HBT processor" written by Lanny Ray | |
4 | // Author: Piotr Krzysztof Skowronski <Piotr.Skowronski@cern.ch> | |
5 | // | |
6 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
7 | * See cxx source for full Copyright notice */ | |
8 | ||
9 | /* $Id$ */ | |
10 | ||
11 | #ifndef ALIGENHBTPROCESSOR_H | |
12 | #define ALIGENHBTPROCESSOR_H | |
13 | ||
36b81802 | 14 | #include "AliGenerator.h" |
88cb7938 | 15 | #include "TPDGCode.h" |
36b81802 | 16 | |
17 | class THBTprocessor; | |
18 | class TClonesArray; | |
88cb7938 | 19 | class TParticle; |
36b81802 | 20 | |
21 | enum {kHBTPMaxParticleTypes = 50}; | |
22 | ||
23 | class AliGenHBTprocessor : public AliGenerator | |
24 | { | |
25 | //Wrapper class for THBTProcessor | |
26 | //which is a wrapper itself to Fortran | |
27 | //program "HBT processor" written by Lanny Ray | |
28 | // | |
29 | //Piotr.Skowronski@cern.ch | |
30 | ||
31 | public: | |
32 | AliGenHBTprocessor(); | |
36b81802 | 33 | virtual ~AliGenHBTprocessor(); |
34 | ||
35 | virtual void Init(); | |
36 | virtual void Generate(); | |
37 | virtual void GetParticles(TClonesArray * particles) const; | |
38 | Int_t IdFromPDG(Int_t pdg) const; | |
39 | Int_t PDGFromId(Int_t id) const; | |
40 | ||
41 | Int_t GetHbtPStatusCode(Int_t part) const; | |
42 | void SetHbtPStatusCode(Int_t hbtstatcode, Int_t part); | |
43 | /************* S E T T E R S ******************/ | |
44 | ||
45 | virtual void SetTrackRejectionFactor(Float_t trf = 1.0); | |
46 | ||
47 | virtual void SetRefControl(Int_t rc =2); | |
48 | virtual void SetPIDs(Int_t pid1 = kPiPlus,Int_t pid2 = kPiMinus); //PDG Codes of particles to be processed, default \\Pi^{+} and \\Pi^{-} | |
49 | virtual void SetNPIDtypes(Int_t npidt = 2); //Number ofparticle types to be processed | |
50 | virtual void SetDeltap(Float_t deltp = 0.1); //maximum range for random momentum shifts in GeV/c; | |
51 | //px,py,pz independent; Default = 0.1 GeV/c. | |
52 | virtual void SetMaxIterations(Int_t maxiter = 50);// | |
53 | virtual void SetDelChi(Float_t dc = 0.1); | |
54 | virtual void SetIRand(Int_t irnd = 76564) ; | |
55 | ||
56 | virtual void SetLambda(Float_t lam = 0.6); | |
57 | virtual void SetR1d(Float_t r = 7.0) ; | |
58 | virtual void SetRSide(Float_t rs = 6.0); | |
59 | virtual void SetROut(Float_t ro = 7.0) ; | |
60 | virtual void SetRLong(Float_t rl = 4.0) ; | |
61 | virtual void SetRPerp(Float_t rp = 6.0); | |
62 | virtual void SetRParallel(Float_t rprl = 4.0); | |
63 | virtual void SetR0(Float_t r0 = 4.0) ; | |
64 | virtual void SetQ0(Float_t q0 = 9.0) ; | |
65 | virtual void SetSwitch1D(Int_t s1d = 3); | |
66 | virtual void SetSwitch3D(Int_t s3d = 0) ; | |
67 | virtual void SetSwitchType(Int_t st = 3); | |
68 | virtual void SetSwitchCoherence(Int_t sc = 0); | |
69 | virtual void SetSwitchCoulomb(Int_t scol = 2); | |
70 | virtual void SetSwitchFermiBose(Int_t sfb = 1); | |
71 | ||
371660fe | 72 | virtual void SetMomentumRange(Float_t pmin=0, Float_t pmax=0); //Dummy method |
36b81802 | 73 | virtual void SetPtRange(Float_t ptmin = 0.1, Float_t ptmax = 0.98); |
74 | virtual void SetPxRange(Float_t pxmin = -1.0, Float_t pxmax = 1.0); | |
75 | virtual void SetPyRange(Float_t pymin = -1.0, Float_t pymax = 1.0); | |
76 | virtual void SetPzRange(Float_t pzmin = -3.6, Float_t pzmax = 3.6); | |
77 | ||
88cb7938 | 78 | virtual void SetPhiRange(Float_t phimin = -180.0, Float_t phimax = 180.0);//Phi angle |
36b81802 | 79 | virtual void SetEtaRange(Float_t etamin = -1.5, Float_t etamax = 1.5);//Pseudorapidity |
80 | void SetThetaRange(Float_t thetamin = 0, Float_t thetamax = 180); //Azimuthal angle, override AliGenerator method | |
81 | //which uses this, core fortran HBTProcessor uses Eta (pseudorapidity) | |
82 | //so these methods has to be synchronized | |
83 | ||
84 | virtual void SetNPtBins(Int_t nptbin = 50); | |
85 | virtual void SetNPhiBins(Int_t nphibin = 50); | |
86 | virtual void SetNEtaBins(Int_t netabin = 50); | |
87 | virtual void SetNPxBins(Int_t npxbin = 20); | |
88 | virtual void SetNPyBins(Int_t npybin = 20); | |
89 | virtual void SetNPzBins(Int_t npzbin = 70); | |
90 | ||
91 | ||
92 | virtual void SetNBins1DFineMesh(Int_t n = 10); | |
93 | virtual void SetBinSize1DFineMesh(Float_t x=0.01); | |
94 | ||
95 | virtual void SetNBins1DCoarseMesh(Int_t n =2 ); | |
96 | virtual void SetBinSize1DCoarseMesh(Float_t x=0.05); | |
97 | ||
98 | virtual void SetNBins3DFineMesh(Int_t n = 8); | |
99 | virtual void SetBinSize3DFineMesh(Float_t x=0.01); | |
100 | ||
101 | virtual void SetNBins3DCoarseMesh(Int_t n = 2); | |
102 | virtual void SetBinSize3DCoarseMesh(Float_t x=0.08); | |
103 | ||
104 | virtual void SetNBins3DFineProjectMesh(Int_t n =3 ); | |
88cb7938 | 105 | |
106 | virtual void SetPrintFull(Int_t flag = 1); | |
107 | ||
108 | /************* E V E N T M E R G E ******************/ | |
109 | ||
110 | Int_t GetNumberOfEvents(); | |
111 | Int_t GetNumberOfTracks(); | |
112 | void SetActiveEventNumber(Int_t n); | |
113 | TParticle* GetTrack(Int_t n); | |
114 | void SetNEventsToMerge(Int_t nev); | |
b456eb2e | 115 | |
116 | ||
117 | //conveerts Eta (pseudorapidity) to etha(azimuthal angle). Returns radians | |
118 | static Double_t EtaToTheta(Double_t arg){return 2.*TMath::ATan(TMath::Exp(-arg));} | |
119 | //converts tetha(azimuthal angle) to Eta (pseudorapidity). Argument in radians | |
120 | static Double_t ThetaToEta(Double_t arg); | |
121 | //converts Degrees To Radians | |
122 | static Double_t DegreesToRadians(Double_t arg){return arg*TMath::Pi()/180.;} | |
123 | //converts Radians To Degrees | |
124 | static Double_t RadiansToDegrees(Double_t arg){return arg*180./TMath::Pi();} | |
125 | ||
126 | static Int_t GetDebug() {return fgDebug;} | |
127 | // static Int_t GetDebug() {return fgDebug;} | |
128 | ||
36b81802 | 129 | /***********************************************************************/ |
130 | /* * * * * * * P R O T E C T E D A R E A * * * * * * * * * * * */ | |
131 | /***********************************************************************/ | |
132 | protected: | |
133 | ||
134 | THBTprocessor * fHBTprocessor; //pointer to generator (TGenerator) | |
135 | Int_t **fHbtPStatCodes; //! hbtp status codes of particles | |
136 | Int_t fNPDGCodes; //! Number of defined particles | |
137 | Int_t fPDGCode[kHBTPMaxParticleTypes]; //! PDG codes (for conversion PDG<->Geant) | |
138 | void DefineParticles(); //initiates array with PDG codes | |
139 | void InitStatusCodes(); //Initiates status codes (allocates memory and sets everything to zero) | |
140 | void CleanStatusCodes(); //deletes array with status codes | |
141 | /********** P A R A M E T E R S OF THE GENERATOR****************/ | |
142 | ||
143 | Float_t fTrackRejectionFactor; //variates in range 0.0 <-> 1.0 | |
144 | //Describes the factor of particles rejected from the output. | |
145 | //Used only in case of low muliplicity particles e.g. lambdas. | |
146 | //Processor generates addisional particles and builds the | |
147 | //correletions on such a statistics. | |
148 | //At the end these particels are left in the event according | |
149 | //to this factor: 1==all particles are left | |
150 | // 0==all are removed | |
151 | Int_t fReferenceControl; //switch wether read reference histograms from file =1 | |
152 | // compute from input events =2 - default | |
153 | Int_t fPrintFull; // Full print out option - each event | |
154 | Int_t fPrintSectorData; // Print sector overflow diagnostics | |
155 | Int_t fNPidTypes; // # particle ID types to correlate | |
156 | Int_t fPid[2]; // Geant particle ID #s, max of 2 types | |
157 | Int_t fNevents ; // # events in input event text file | |
158 | Int_t fSwitch1d; // Include 1D correlations | |
159 | Int_t fSwitch3d; // Include 3D correlations | |
160 | Int_t fSwitchType ; // For like, unlike or both PID pairs | |
161 | Int_t fSwitchCoherence; // To include incoh/coher mixed source | |
162 | Int_t fSwitchCoulomb; // Coulomb correction selection options | |
163 | Int_t fSwitchFermiBose; // For fermions or bosons | |
164 | ||
165 | // Counters: | |
166 | ||
167 | Int_t fEventLineCounter; // Input event text file line counter | |
168 | Int_t fMaxit; // Max # iterations in track adjustment | |
169 | Int_t fIrand; // Random # starting seed (Def=12345) | |
170 | // // line counter | |
171 | ||
172 | // Correlation Model Parameters: | |
173 | ||
174 | Float_t fLambda; // Chaoticity parameter | |
175 | Float_t fR1d; // Spherical source radius (fm) | |
176 | Float_t fRside; // 3D Bertsch-Pratt source 'side' R (fm) | |
177 | Float_t fRout; // 3D Bertsch-Pratt source 'out' R (fm) | |
178 | Float_t fRlong; // 3D Bertsch-Pratt source 'long' R (fm) | |
179 | Float_t fRperp; // 3D YKP source transverse radius (fm) | |
180 | Float_t fRparallel; // 3D YKP source longitudinal radius(fm) | |
181 | Float_t fR0; // 3D YKP source emission time durat(fm) | |
182 | Float_t fQ0; // NA35 Coulomb parameter (GeV/c) or | |
183 | // // Coul radius for Pratt finite src (fm) | |
184 | ||
185 | // Search Control Parameters: | |
186 | ||
187 | ||
188 | Float_t fDeltap; // Max limit for x,y,z momt shifts(GeV/c) | |
189 | Float_t fDelchi; // Min% change in Chi-Sq to stop iterat. | |
190 | ||
191 | ||
192 | // Particle Masses: | |
193 | ||
194 | ||
195 | /********** M E S H ****************/ | |
196 | ||
197 | ||
198 | Int_t fNPtBins; // # one-body pt bins | |
199 | Int_t fNPhiBins; // # one-body phi bins | |
200 | Int_t fNEtaBins; // # one-body eta bins | |
201 | ||
202 | Int_t fN1dFine; // # bins for 1D, Fine Mesh | |
203 | Int_t fN1dCoarse; // # bins for 1D, Coarse Mesh | |
204 | Int_t fN1dTotal; // Total # bins for 1D | |
205 | Int_t fN3dFine ; // # bins for 3D, Fine Mesh | |
206 | Int_t fN3dCoarse; // # bins for 3D, Coarse Mesh | |
207 | Int_t fN3dTotal; // Total # bins for 3D | |
208 | Int_t fN3dFineProject; // # 3D fine mesh bins to sum over for | |
209 | ||
210 | // Momentum Space Sectors for Track Sorting: | |
211 | ||
212 | Int_t fNPxBins; // # sector bins in px | |
213 | Int_t fNPyBins; // # sector bins in py | |
214 | Int_t fNPzBins; // # sector bins in pz | |
215 | Int_t fNSectors; // Total # sectors in 3D momentum space | |
216 | ||
217 | ||
218 | Float_t fPtBinSize ; // One-body pt bin size in (GeV/c) | |
219 | ||
220 | ||
221 | Float_t fPhiBinSize; // One-body phi bin size in (degrees) | |
222 | ||
223 | Float_t fEtaBinSize ; // One-body eta bin size | |
224 | Float_t fEtaMin; // One-body eta min | |
225 | Float_t fEtaMax; // One-body eta max | |
226 | // Two-Body Histograms and Correlation Mesh for 1D and 3D distributions: | |
227 | // // projections onto single axis. | |
228 | ||
229 | Float_t fBinsize1dFine; // Bin Size - 1D, Fine Mesh in (GeV/c) | |
230 | Float_t fBinsize1dCoarse; // Bin Size - 1D, Coarse Mesh in (GeV/c) | |
231 | Float_t fQmid1d; // q (GeV/c) at fine-coarse mesh boundary | |
232 | Float_t fQmax1d; // Max q (GeV/c) for 1D distributions | |
233 | Float_t fBinsize3dFine; // Bin Size - 3D, Fine Mesh in (GeV/c) | |
234 | Float_t fBinsize3dCoarse; // Bin Size - 3D, Coarse Mesh in (GeV/c) | |
235 | Float_t fQmid3d; // q (GeV/c) at fine-coarse mesh boundary | |
236 | Float_t fQmax3d; // Max q (GeV/c) for 3D distributions | |
237 | ||
238 | Float_t fPxMin; // Sector range in px in GeV/c | |
239 | Float_t fPxMax; //--//-- | |
240 | Float_t fDelpx; // Mom. space sector cell size - px(GeV/c) | |
241 | ||
242 | Float_t fPyMin; // Sector range in py in GeV/c | |
243 | Float_t fPyMax; // --//-- | |
244 | Float_t fDelpy; // Mom. space sector cell size - py(GeV/c) | |
245 | ||
246 | Float_t fPzMin; // Sector range in pz in GeV/c min | |
247 | Float_t fPzMax; // Sector range in pz in GeV/c max | |
248 | Float_t fDelpz; // Mom. space sector cell size - pz(GeV/c) | |
249 | ||
250 | ||
88cb7938 | 251 | Int_t fEventMerge; //number of events that are masked as an one event |
b456eb2e | 252 | Int_t fActiveStack; //current active stack |
253 | ||
254 | static Int_t fgDebug; //debug level | |
255 | ||
36b81802 | 256 | /******* P R O T E C T E D M E T H O D S *****/ |
88cb7938 | 257 | void GetTrackEventIndex(Int_t n, Int_t &evno, Int_t &index) const; //returns event(stack) number and |
b456eb2e | 258 | |
93a2041b | 259 | private: |
260 | AliGenHBTprocessor(const AliGenHBTprocessor& in); | |
261 | AliGenHBTprocessor & operator=(const AliGenHBTprocessor& in); | |
262 | ||
36b81802 | 263 | ClassDef(AliGenHBTprocessor,1) // Interface class for AliMevsim |
264 | ||
265 | }; | |
36b81802 | 266 | #endif |