]> git.uio.no Git - u/mrichter/AliRoot.git/blame - EVGEN/AliGenParam.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Correcting coding convention violations
[u/mrichter/AliRoot.git] / EVGEN / AliGenParam.cxx
CommitLineData
4c039060 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/*
17$Log$
65fb704d 18Revision 1.24 2000/10/18 19:11:27 hristov
19Division by zero fixed
20
919c2096 21Revision 1.23 2000/10/02 21:28:06 fca
22Removal of useless dependecies via forward declarations
23
94de3818 24Revision 1.22 2000/09/12 14:14:55 morsch
25Call fDecayer->ForceDecay() at the beginning of Generate().
26
00d6ce7d 27Revision 1.21 2000/09/08 15:39:01 morsch
28Handle the case fForceDecay=all during the generation, i.e. select all secondaries.
29
5ab0acc9 30Revision 1.20 2000/09/06 14:35:44 morsch
31Use AliDecayerPythia for particle decays.
32
fa480368 33Revision 1.19 2000/07/11 18:24:56 fca
34Coding convention corrections + few minor bug fixes
35
aee8290b 36Revision 1.18 2000/06/29 21:08:27 morsch
37All paramatrisation libraries derive from the pure virtual base class AliGenLib.
38This allows to pass a pointer to a library directly to AliGenParam and avoids the
39use of function pointers in Config.C.
40
b22ee262 41Revision 1.17 2000/06/09 20:33:30 morsch
42All coding rule violations except RS3 corrected
43
f87cfe57 44Revision 1.16 2000/05/02 07:51:31 morsch
45- Control precision of pT sampling TF1::SetNpx(..)
46- Correct initialisation of child-cuts in all constructors.
47- Most coding rule violations corrected.
48
749070b6 49Revision 1.15 2000/04/03 15:42:12 morsch
50Cuts on primary particles are separated from those on the decay products. Methods
51SetChildMomentumRange, SetChildPtRange, SetChildPhiRange, SetChildThetaRange added.
52
cc5d764c 53Revision 1.14 1999/11/09 07:38:48 fca
54Changes for compatibility with version 2.23 of ROOT
55
084c1b4a 56Revision 1.13 1999/11/04 11:30:31 fca
57Correct the logics for SetForceDecay
58
28337bc1 59Revision 1.12 1999/11/03 17:43:20 fca
60New version from G.Martinez & A.Morsch
61
886b6f73 62Revision 1.11 1999/09/29 09:24:14 fca
63Introduction of the Copyright and cvs Log
64
4c039060 65*/
66
fe4da5cc 67#include "AliGenParam.h"
fa480368 68#include "AliDecayerPythia.h"
fe4da5cc 69#include "AliGenMUONlib.h"
70#include "AliRun.h"
1578254f 71#include <TParticle.h>
fa480368 72#include <TParticlePDG.h>
73#include <TDatabasePDG.h>
74#include <TLorentzVector.h>
75
f87cfe57 76#include <TF1.h>
fe4da5cc 77
78ClassImp(AliGenParam)
79
80//------------------------------------------------------------
81
82 //Begin_Html
83 /*
1439f98e 84 <img src="picts/AliGenParam.gif">
fe4da5cc 85 */
86 //End_Html
87
88//____________________________________________________________
89//____________________________________________________________
90AliGenParam::AliGenParam()
fe4da5cc 91{
b22ee262 92// Deafault constructor
93 fPtPara = 0;
94 fYPara = 0;
95 fParam = jpsi_p;
96 fAnalog = analog;
97 SetCutOnChild();
98 SetChildMomentumRange();
99 SetChildPtRange();
100 SetChildPhiRange();
101 SetChildThetaRange();
102 SetDeltaPt();
103}
104
105AliGenParam::AliGenParam(Int_t npart, AliGenLib * Library, Param_t param, char* tname):AliGenerator(npart)
106{
107// Constructor using number of particles parameterisation id and library
108
109 fPtParaFunc = Library->GetPt(param, tname);
110 fYParaFunc = Library->GetY (param, tname);
111 fIpParaFunc = Library->GetIp(param, tname);
112
113 fPtPara = 0;
114 fYPara = 0;
115 fParam = param;
116 fAnalog = analog;
117 fChildSelect.Set(5);
118 for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
119 SetForceDecay();
120 SetCutOnChild();
121 SetChildMomentumRange();
122 SetChildPtRange();
123 SetChildPhiRange();
124 SetChildThetaRange();
125 SetDeltaPt();
fe4da5cc 126}
127
128//____________________________________________________________
886b6f73 129
b22ee262 130AliGenParam::AliGenParam(Int_t npart, Param_t param, char* tname):AliGenerator(npart)
fe4da5cc 131{
b22ee262 132// Constructor using parameterisation id and number of particles
133//
134 AliGenLib* Library = new AliGenMUONlib();
135
136 fPtParaFunc = Library->GetPt(param, tname);
137 fYParaFunc = Library->GetY (param, tname);
138 fIpParaFunc = Library->GetIp(param, tname);
139
140 fPtPara = 0;
141 fYPara = 0;
142 fParam = param;
143 fAnalog = analog;
144 fChildSelect.Set(5);
145 for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
146 SetForceDecay();
147 SetCutOnChild();
148 SetChildMomentumRange();
149 SetChildPtRange();
150 SetChildPhiRange();
151 SetChildThetaRange();
152 SetDeltaPt();
fe4da5cc 153}
154
886b6f73 155AliGenParam::AliGenParam(Int_t npart, Param_t param,
156 Double_t (*PtPara) (Double_t*, Double_t*),
157 Double_t (*YPara ) (Double_t* ,Double_t*),
65fb704d 158 Int_t (*IpPara) (TRandom *))
886b6f73 159 :AliGenerator(npart)
160{
749070b6 161// Constructor
28337bc1 162// Gines Martinez 1/10/99
886b6f73 163 fPtParaFunc = PtPara;
164 fYParaFunc = YPara;
165 fIpParaFunc = IpPara;
28337bc1 166//
886b6f73 167 fPtPara = 0;
168 fYPara = 0;
169 fParam = param;
170 fAnalog = analog;
171 fChildSelect.Set(5);
172 for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
173 SetForceDecay();
174 SetCutOnChild();
749070b6 175 SetChildMomentumRange();
176 SetChildPtRange();
177 SetChildPhiRange();
178 SetChildThetaRange();
179 SetDeltaPt();
886b6f73 180}
181
f87cfe57 182
183AliGenParam::AliGenParam(const AliGenParam & Paramd)
184{
185// copy constructor
186}
187
fe4da5cc 188//____________________________________________________________
189AliGenParam::~AliGenParam()
190{
749070b6 191// Destructor
fe4da5cc 192 delete fPtPara;
193 delete fYPara;
194}
195
196//____________________________________________________________
197void AliGenParam::Init()
198{
749070b6 199// Initialisation
fa480368 200
201 fDecayer = new AliDecayerPythia();
fe4da5cc 202 //Begin_Html
203 /*
1439f98e 204 <img src="picts/AliGenParam.gif">
fe4da5cc 205 */
206 //End_Html
207
749070b6 208 fPtPara = new TF1("Pt-Parametrization",fPtParaFunc,fPtMin,fPtMax,0);
209// Set representation precision to 10 MeV
210 Int_t npx= Int_t((fPtMax-fPtMin)/fDeltaPt);
211
212 fPtPara->SetNpx(npx);
213
214 fYPara = new TF1("Y -Parametrization",fYParaFunc,fYMin,fYMax,0);
215 TF1* ptPara = new TF1("Pt-Parametrization",fPtParaFunc,0,15,0);
216 TF1* yPara = new TF1("Y -Parametrization",fYParaFunc,-6,6,0);
b7601ac4 217
fe4da5cc 218//
219// dN/dy| y=0
749070b6 220 Double_t y1=0;
221 Double_t y2=0;
222
223 fdNdy0=fYParaFunc(&y1,&y2);
fe4da5cc 224//
225// Integral over generation region
749070b6 226 Float_t intYS = yPara ->Integral(fYMin, fYMax);
227 Float_t intPt0 = ptPara->Integral(0,15);
228 Float_t intPtS = ptPara->Integral(fPtMin,fPtMax);
229 Float_t phiWgt=(fPhiMax-fPhiMin)/2./TMath::Pi();
230 if (fAnalog == analog) {
231 fYWgt = intYS/fdNdy0;
232 fPtWgt = intPtS/intPt0;
233 fParentWeight = fYWgt*fPtWgt*phiWgt/fNpart;
234 } else {
235 fYWgt = intYS/fdNdy0;
236 fPtWgt = (fPtMax-fPtMin)/intPt0;
237 fParentWeight = fYWgt*fPtWgt*phiWgt/fNpart;
238 }
fe4da5cc 239//
240// particle decay related initialization
00d6ce7d 241 fDecayer->SetForceDecay(fForceDecay);
fa480368 242 fDecayer->Init();
00d6ce7d 243
fe4da5cc 244//
245 switch (fForceDecay)
246 {
247 case semielectronic:
248 case dielectron:
249 case b_jpsi_dielectron:
250 case b_psip_dielectron:
251 fChildSelect[0]=11;
252 break;
253 case semimuonic:
254 case dimuon:
255 case b_jpsi_dimuon:
256 case b_psip_dimuon:
257 fChildSelect[0]=13;
258 break;
b7601ac4 259 case pitomu:
260 fChildSelect[0]=13;
261 break;
262 case katomu:
263 fChildSelect[0]=13;
264 break;
886b6f73 265 case nodecay:
266 break;
267 case all:
268 break;
fe4da5cc 269 }
fe4da5cc 270}
271
272//____________________________________________________________
273void AliGenParam::Generate()
274{
28337bc1 275//
276// Generate 'npart' of light and heavy mesons (J/Psi, upsilon or phi, Pion,
277// Kaons, Etas, Omegas) and Baryons (proton, antiprotons, neutrons and
278// antineutrons in the the desired theta, phi and momentum windows;
279// Gaussian smearing on the vertex is done if selected.
cc5d764c 280// The decay of heavy mesons is done using lujet,
281// and the childern particle are tracked by GEANT
282// However, light mesons are directly tracked by GEANT
283// setting fForceDecay = nodecay (SetForceDecay(nodecay))
28337bc1 284//
fe4da5cc 285
00d6ce7d 286 fDecayer->ForceDecay();
28337bc1 287 Float_t polar[3]= {0,0,0}; // Polarisation of the parent particle (for GEANT tracking)
288 Float_t origin0[3]; // Origin of the generated parent particle (for GEANT tracking)
289 Float_t pt, pl, ptot; // Transverse, logitudinal and total momenta of the parent particle
290 Float_t phi, theta; // Phi and theta spherical angles of the parent particle momentum
291 Float_t p[3], pc[3],
292 och[3], pch[10][3]; // Momentum, polarisation and origin of the children particles from lujet
fe4da5cc 293 Float_t ty, xmt;
21aaa175 294 Int_t nt, i, j, kfch[10];
fe4da5cc 295 Float_t wgtp, wgtch;
296 Double_t dummy;
09fd3ea2 297 static TClonesArray *particles;
fe4da5cc 298 //
09fd3ea2 299 if(!particles) particles=new TClonesArray("TParticle",1000);
fa480368 300
301 static TDatabasePDG *DataBase = new TDatabasePDG();
302 if(!DataBase) DataBase = new TDatabasePDG();
fe4da5cc 303 //
304 Float_t random[6];
28337bc1 305
306// Calculating vertex position per event
fe4da5cc 307 for (j=0;j<3;j++) origin0[j]=fOrigin[j];
aee8290b 308 if(fVertexSmear==kPerEvent) {
65fb704d 309 Rndm(random,6);
fe4da5cc 310 for (j=0;j<3;j++) {
311 origin0[j]+=fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
312 TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
313 }
314 }
21aaa175 315 Int_t ipa=0;
28337bc1 316// Generating fNpart particles
21aaa175 317 while (ipa<fNpart) {
cc5d764c 318 while(1) {
fe4da5cc 319//
320// particle type
65fb704d 321 Int_t iPart = fIpParaFunc(fRandom);
fa480368 322 fChildWeight=(fDecayer->GetPartialBranchingRatio(iPart))*fParentWeight;
323 TParticlePDG *particle = DataBase->GetParticle(iPart);
324 Float_t am = particle->Mass();
325
65fb704d 326 Rndm(random,2);
fe4da5cc 327//
328// phi
329 phi=fPhiMin+random[0]*(fPhiMax-fPhiMin);
330//
331// y
332 ty=Float_t(TMath::TanH(fYPara->GetRandom()));
333//
334// pT
82db6e43 335 if (fAnalog == analog) {
fe4da5cc 336 pt=fPtPara->GetRandom();
337 wgtp=fParentWeight;
338 wgtch=fChildWeight;
339 } else {
340 pt=fPtMin+random[1]*(fPtMax-fPtMin);
341 Double_t ptd=pt;
342 wgtp=fParentWeight*fPtParaFunc(& ptd, &dummy);
343 wgtch=fChildWeight*fPtParaFunc(& ptd, &dummy);
344 }
345 xmt=sqrt(pt*pt+am*am);
919c2096 346 if (TMath::Abs(ty)==1) ty=0;
fe4da5cc 347 pl=xmt*ty/sqrt(1.-ty*ty);
348 theta=TMath::ATan2(pt,pl);
cc5d764c 349// Cut on theta
fe4da5cc 350 if(theta<fThetaMin || theta>fThetaMax) continue;
351 ptot=TMath::Sqrt(pt*pt+pl*pl);
cc5d764c 352// Cut on momentum
fe4da5cc 353 if(ptot<fPMin || ptot>fPMax) continue;
354 p[0]=pt*TMath::Cos(phi);
355 p[1]=pt*TMath::Sin(phi);
356 p[2]=pl;
aee8290b 357 if(fVertexSmear==kPerTrack) {
65fb704d 358 Rndm(random,6);
fe4da5cc 359 for (j=0;j<3;j++) {
360 origin0[j]=
361 fOrigin[j]+fOsigma[j]*TMath::Cos(2*random[2*j]*TMath::Pi())*
362 TMath::Sqrt(-2*TMath::Log(random[2*j+1]));
363 }
364 }
28337bc1 365
366// Looking at fForceDecay :
cc5d764c 367// if fForceDecay != none Primary particle decays using
368// AliPythia and children are tracked by GEANT
28337bc1 369//
cc5d764c 370// if fForceDecay == none Primary particle is tracked by GEANT
371// (In the latest, make sure that GEANT actually does all the decays you want)
fe4da5cc 372//
886b6f73 373 if (fForceDecay != nodecay) {
28337bc1 374// Using lujet to decay particle
886b6f73 375 Float_t energy=TMath::Sqrt(ptot*ptot+am*am);
fa480368 376 TLorentzVector pmom(p[0], p[1], p[2], energy);
377 fDecayer->Decay(iPart,&pmom);
fe4da5cc 378//
cc5d764c 379// select decay particles
fa480368 380 Int_t np=fDecayer->ImportParticles(particles);
886b6f73 381 Int_t ncsel=0;
382 for (i = 1; i<np; i++) {
383 TParticle * iparticle = (TParticle *) particles->At(i);
384 Int_t kf = iparticle->GetPdgCode();
fe4da5cc 385//
386// children
5ab0acc9 387 if (ChildSelected(TMath::Abs(kf)) || fForceDecay==all)
886b6f73 388 {
389 pc[0]=iparticle->Px();
390 pc[1]=iparticle->Py();
391 pc[2]=iparticle->Pz();
392 och[0]=origin0[0]+iparticle->Vx()/10;
393 och[1]=origin0[1]+iparticle->Vy()/10;
394 och[2]=origin0[2]+iparticle->Vz()/10;
395 if (fCutOnChild) {
749070b6 396 Float_t ptChild=TMath::Sqrt(pc[0]*pc[0]+pc[1]*pc[1]);
397 Float_t pChild=TMath::Sqrt(ptChild*ptChild+pc[2]*pc[2]);
398 Float_t thetaChild=TMath::ATan2(ptChild,pc[2]);
399 Float_t phiChild=TMath::ATan2(pc[1],pc[0]);
886b6f73 400 Bool_t childok =
749070b6 401 ((ptChild > fChildPtMin && ptChild <fChildPtMax) &&
402 (pChild > fChildPMin && pChild <fChildPMax) &&
403 (thetaChild > fChildThetaMin && thetaChild <fChildThetaMax) &&
404 (phiChild > fChildPhiMin && phiChild <fChildPhiMax));
886b6f73 405 if(childok)
406 {
407 pch[ncsel][0]=pc[0];
408 pch[ncsel][1]=pc[1];
409 pch[ncsel][2]=pc[2];
410 kfch[ncsel]=kf;
411 ncsel++;
412 } else {
413 ncsel=-1;
414 break;
415 } // child kine cuts
21aaa175 416 } else {
886b6f73 417 pch[ncsel][0]=pc[0];
418 pch[ncsel][1]=pc[1];
419 pch[ncsel][2]=pc[2];
420 kfch[ncsel]=kf;
421 ncsel++;
422 } // if child selection
423 } // select muon
424 } // decay particle loop
425 Int_t iparent;
426 if ((fCutOnChild && ncsel >0) || !fCutOnChild){
427 ipa++;
21aaa175 428//
429// parent
886b6f73 430 gAlice->
65fb704d 431 SetTrack(0,-1,iPart,p,origin0,polar,0,kPPrimary,nt,wgtp);
886b6f73 432 iparent=nt;
f87cfe57 433 gAlice->KeepTrack(nt);
886b6f73 434 for (i=0; i< ncsel; i++) {
435 gAlice->SetTrack(fTrackIt,iparent,kfch[i],
436 &pch[i][0],och,polar,
65fb704d 437 0,kPDecay,nt,wgtch);
886b6f73 438 gAlice->KeepTrack(nt);
439 }
28337bc1 440 } // Decays by Lujet
21aaa175 441 } // kinematic selection
28337bc1 442 else // nodecay option, so parent will be tracked by GEANT (pions, kaons, eta, omegas, baryons)
443 {
444 gAlice->
65fb704d 445 SetTrack(fTrackIt,-1,iPart,p,origin0,polar,0,kPPrimary,nt,wgtp);
28337bc1 446 ipa++;
447 }
fe4da5cc 448 break;
21aaa175 449 } // while
fe4da5cc 450 } // event loop
451}
452
453Bool_t AliGenParam::ChildSelected(Int_t ip)
454{
749070b6 455// True if particle is in list of selected children
fe4da5cc 456 for (Int_t i=0; i<5; i++)
457 {
458 if (fChildSelect[i]==ip) return kTRUE;
459 }
460 return kFALSE;
461}
462
1578254f 463Bool_t AliGenParam::KinematicSelection(TParticle *particle)
fe4da5cc 464{
749070b6 465// Perform kinematic cuts
1578254f 466 Float_t px=particle->Px();
467 Float_t py=particle->Py();
468 Float_t pz=particle->Pz();
fe4da5cc 469//
470// momentum cut
471 Float_t p=TMath::Sqrt(px*px+py*py+pz*pz);
472 if (p > fPMax || p < fPMin)
473 {
474// printf("\n failed p cut %f %f %f \n",p,fPMin,fPMax);
475 return kFALSE;
476 }
477 Float_t pt=TMath::Sqrt(px*px+py*py);
478
479//
480// theta cut
481 Float_t theta = Float_t(TMath::ATan2(Double_t(pt),Double_t(p)));
482 if (theta > fThetaMax || theta < fThetaMin)
483 {
484// printf("\n failed theta cut %f %f %f \n",theta,fThetaMin,fThetaMax);
485 return kFALSE;
486 }
487
488 return kTRUE;
489}
490
491
f87cfe57 492AliGenParam& AliGenParam::operator=(const AliGenParam& rhs)
493{
494// Assignment operator
495 return *this;
496}
497
fe4da5cc 498
499