1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
19 // Container class for AliGenerator and AfterBurners
20 // (which are AliGenerators as well) through recursion.
21 // The container is itself an AliGenerator a
22 // what is stored are not the pointers to the generators directly
23 // but to objects of type
24 // AliGenCocktailAfterBurner entry.
25 // The class provides also iterator functionality.
26 // Author: andreas.morsch@cern.ch and piotr.skowronski@cern.ch
28 // 24.09.2001 Piotr Skowronski
30 // fNEvents replaced with gAlice->GetEventsPerRun()
34 #include <Riostream.h>
37 #include <TObjArray.h>
38 #include <TParticle.h>
40 #include "AliGenCocktailAfterBurner.h"
41 #include "AliGenCocktailEntry.h"
42 #include "AliCollisionGeometry.h"
47 ClassImp(AliGenCocktailAfterBurner)
48 /*********************************************************************/
49 /*********************************************************************/
51 AliGenCocktailAfterBurner::AliGenCocktailAfterBurner():
53 fAfterBurnerEntries(new TList()),
54 fGenerationDone(kFALSE),
56 fCollisionGeometries(0),
65 cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
66 SetName("AliGenCocktailAfterBurner");
67 SetTitle("AliGenCocktailAfterBurner");
70 /*********************************************************************/
72 AliGenCocktailAfterBurner::~AliGenCocktailAfterBurner()
76 if (fInternalStacks) //delete stacks
78 fInternalStacks->SetOwner();
79 delete fInternalStacks;
81 if (fAfterBurnerEntries) delete fAfterBurnerEntries; //delete entries
82 delete[] fCollisionGeometries;
84 /*********************************************************************/
85 /*********************************************************************/
87 void AliGenCocktailAfterBurner::
88 AddAfterBurner(AliGenerator *AfterBurner, char* Name, Float_t RateExp)
91 // Forward parameters to the new AfterBurner
93 if (gDebug>0)cout<<"AliGenCocktailAfterBurner::AddAfterBurner Named "<<Name<<endl;
96 AfterBurner->SetPtRange(fPtMin,fPtMax);
97 if(TestBit(kMomentumRange))
98 AfterBurner->SetMomentumRange(fPMin,fPMax);
100 AfterBurner->SetYRange(fYMin,fYMax);
101 AfterBurner->SetPhiRange(fPhiMin*180/TMath::Pi(),fPhiMax*180/TMath::Pi());
102 AfterBurner->SetThetaRange(fThetaMin*180/TMath::Pi(),fThetaMax*180/TMath::Pi());
103 AfterBurner->SetOrigin(fOrigin[0], fOrigin[1], fOrigin[2]);
104 AfterBurner->SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
105 AfterBurner->SetVertexSmear(fVertexSmear);
106 AfterBurner->SetTrackingFlag(fTrackIt);
108 // Add AfterBurner to list
110 AliGenCocktailEntry *entry =
111 new AliGenCocktailEntry(AfterBurner, Name, RateExp);
112 fAfterBurnerEntries->Add(entry);
117 /*********************************************************************/
118 /*********************************************************************/
120 void AliGenCocktailAfterBurner::Init()
123 fGenerationDone = kFALSE;
124 if (fInternalStacks) //delete stacks
126 fInternalStacks->SetOwner();
127 fInternalStacks->Delete(); //clean after previous generation cycle
130 // ANDREAS MORSCH ---------------------------------------------------(
131 if (fCollisionGeometries) delete[] fCollisionGeometries;
132 // ANDREAS MORSCH ---------------------------------------------------)
134 this->AliGenCocktail::Init();
136 if (gDebug>0) cout<<"AliGenCocktailAfterBurner::Init"<<endl;
137 TIter next(fAfterBurnerEntries);
138 AliGenCocktailEntry *entry;
140 // Loop over generators and initialize
141 while((entry = (AliGenCocktailEntry*)next())) {
142 entry->Generator()->Init();
145 /*********************************************************************/
146 /*********************************************************************/
148 void AliGenCocktailAfterBurner::Generate()
152 // Firsts runs each generator for all events
153 // than after burners ones for each event
155 // It generates and processes all events during
157 // In next calls it just returns already generated
158 // and processed events to the gAlice
161 cout<<"#####################################"<<endl
162 <<"#AliGenCocktailAfterBurner::Generate#"<<endl
163 <<"#####################################"<<endl;
169 {//if generation is done (in first call)
170 //just copy particles from the stack to the gAlice
171 SetTracks(++fCurrentEvent);
172 cout<<"Returning event "<<fCurrentEvent<<endl;
176 { //Here we are in the first call of the method
178 Int_t numberOfEvents = gAlice->GetEventsPerRun();
180 fInternalStacks = new TObjArray(numberOfEvents + fNBgEvents); //Create array of internal stacks
181 fCollisionGeometries = new AliCollisionGeometry*[numberOfEvents + fNBgEvents]; //Create array of collision geometries
182 for(i=0;i<numberOfEvents + fNBgEvents;i++)
184 stack = new AliStack(10000);
186 fInternalStacks->Add(stack);
188 /*********************************************************************/
189 TIter next(fEntries);
190 AliGenCocktailEntry *entry;
191 AliGenCocktailEntry *e1;
192 AliGenCocktailEntry *e2;
193 TObjArray *partArray;
195 // Loop over generators and generate events
197 while((entry = (AliGenCocktailEntry*)next()))
200 cout<<"Generator "<<igen<<" : "<<entry->GetName()<<endl;
201 /***********************************************/
202 //First generator for all evenets, than second for all events, etc...
203 for(i=0;i<numberOfEvents + fNBgEvents;i++)
205 cout<<" EVENT "<<i<<endl;
207 partArray = stack->Particles();
208 fCurrentGenerator = entry->Generator();
209 fCurrentGenerator->SetStack(stack);
216 entry->SetFirst((partArray->GetEntriesFast())+1);
218 fCurrentGenerator->Generate();
219 entry->SetLast(partArray->GetEntriesFast());
221 // ANDREAS MORSCH ---------------------------------------------------(
222 if (fCurrentGenerator->ProvidesCollisionGeometry()) fCollisionGeometries[i] = fCurrentGenerator->CollisionGeometry();
223 // ANDREAS MORSCH ---------------------------------------------------)
226 /***********************************************/
229 while((entry = (AliGenCocktailEntry*)next()))
233 for ( entry=FirstGenerator();entry;entry=NextGenerator() )
237 for (FirstGeneratorPair(e1,e2); (e1&&e2); NextGeneratorPair(e1,e2) )
239 printf("\n -----------------------------");
245 /***********************************************/
246 /*******After Burners Processing****************/
247 /***********************************************/
248 TIter nextAfterBurner(fAfterBurnerEntries);
249 AliGenCocktailEntry *afterBurnerEntry;
250 Int_t iab =0; //number of current after burner / counter
252 cout<<"\n\nRunning After Burners"<<endl;
253 while((afterBurnerEntry = (AliGenCocktailEntry*)nextAfterBurner()))
255 cout<<"After Burner "<<iab++<<" :"<<afterBurnerEntry->GetName()<<endl;
256 fCurrentGenerator = afterBurnerEntry->Generator();
257 fCurrentGenerator->Generate();
259 cout<<endl<<"Finished. Processed "<<iab<<" After Burners"<<endl;
261 /***********************************************/
262 /***********************************************/
263 /***********************************************/
265 fGenerationDone=kTRUE;
266 SetTracks(0); //copy event 0 to gAlice stack
268 /*********************************************************************/
272 /*********************************************************************/
273 /*********************************************************************/
275 AliStack* AliGenCocktailAfterBurner::GetStack(Int_t n) const
277 //Returns the pointer to the N'th stack (event)
278 if( ( n<0 ) || ( n>=GetNumberOfEvents() ) )
280 Fatal("AliGenCocktailAfterBurner::GetStack","Asked for non existing stack (%d)",n);
283 return ((AliStack*) fInternalStacks->At(n) );
286 /*********************************************************************/
287 /*********************************************************************/
289 // ANDREAS MORSCH ---------------------------------------------------(
291 AliCollisionGeometry* AliGenCocktailAfterBurner::GetCollisionGeometry(Int_t n) const
293 //Returns the pointer to the N'th stack (event)
294 if( ( n<0 ) || ( n>=GetNumberOfEvents() ) )
296 Fatal("AliGenCocktailAfterBurner::GetCollisionGeometry","Asked for non existing stack (%d)",n);
299 return fCollisionGeometries[n];
302 // ANDREAS MORSCH ---------------------------------------------------)
304 /*********************************************************************/
305 /*********************************************************************/
307 void AliGenCocktailAfterBurner::SetActiveEventNumber(Int_t actev)
309 //Set Active Events Number and Active Stack
310 //There is only one active event number
311 //Made fo convinience of work with AfterBurners (HBT processor)
313 fActiveEvent = actev;
314 fActiveStack = GetStack(actev);
316 /*********************************************************************/
317 /*********************************************************************/
319 void AliGenCocktailAfterBurner::SetTracks(Int_t stackno)
321 //Method which copies tracks from given stack to the
323 AliStack* instack = GetStack(stackno);
327 Double_t px, py, pz, e, vx, vy, vz, tof, polx, poly, polz;
334 Int_t n = instack->GetNtrack();
337 cout<<"AliGenCocktailAfterBurner::SetTracks("<<stackno<<"). Number of particles is: "<<n<<"\n";
340 for(Int_t i = 0; i < n; i++)
343 p = instack->Particle(i);
344 done = !p->TestBit(kDoneBit);
345 parent = p->GetMother(0);
346 pdg = p->GetPdgCode();
355 p->GetPolarisation(pol);
359 mech = AliGenCocktailAfterBurner::IntToMCProcess(p->GetUniqueID());
360 weight = p->GetWeight();
362 gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,polx, poly, polz, mech, ntr, weight);
364 // ANDREAS MORSCH ---------------------------------------------------(
365 SetHighWaterMark(ntr) ;
366 // ANDREAS MORSCH ---------------------------------------------------)
370 /*********************************************************************/
371 /*********************************************************************/
373 TMCProcess AliGenCocktailAfterBurner::IntToMCProcess(Int_t no)
375 //Mothod used to convert uniqueID (integer) to TMCProcess type
376 const TMCProcess kMCprocesses[kMaxMCProcess] =
378 kPNoProcess, kPMultipleScattering, kPEnergyLoss, kPMagneticFieldL,
379 kPDecay, kPPair, kPCompton, kPPhotoelectric, kPBrem, kPDeltaRay,
380 kPAnnihilation, kPHadronic, kPNoProcess, kPEvaporation, kPNuclearFission,
381 kPNuclearAbsorption, kPPbarAnnihilation, kPNCapture, kPHElastic,
382 kPHInhelastic, kPMuonNuclear, kPTOFlimit,kPPhotoFission, kPNoProcess,
383 kPRayleigh, kPNoProcess, kPNoProcess, kPNoProcess, kPNull, kPStop
386 for (Int_t i = 0;i<kMaxMCProcess;i++)
388 if (kMCprocesses[i] == no)
390 return kMCprocesses[i];