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 AliRunLoader::GetNumberOfEvents()
34 #include <Riostream.h>
37 #include <TObjArray.h>
38 #include <TParticle.h>
40 #include "AliGenCocktailAfterBurner.h"
41 #include "AliGenCocktailEntry.h"
42 #include "AliGenCocktailEventHeader.h"
43 #include "AliCollisionGeometry.h"
48 ClassImp(AliGenCocktailAfterBurner)
49 /*********************************************************************/
50 /*********************************************************************/
52 AliGenCocktailAfterBurner::AliGenCocktailAfterBurner():
54 fAfterBurnerEntries(new TList()),
55 fGenerationDone(kFALSE),
57 fCollisionGeometries(0),
67 cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
68 SetName("AliGenCocktailAfterBurner");
69 SetTitle("AliGenCocktailAfterBurner");
72 /*********************************************************************/
74 AliGenCocktailAfterBurner::~AliGenCocktailAfterBurner()
78 if (fInternalStacks) //delete stacks
80 fInternalStacks->SetOwner();
81 delete fInternalStacks;
83 if (fAfterBurnerEntries) delete fAfterBurnerEntries; //delete entries
84 delete[] fCollisionGeometries;
87 /*********************************************************************/
88 /*********************************************************************/
90 void AliGenCocktailAfterBurner::
91 AddAfterBurner(AliGenerator *AfterBurner, char* Name, Float_t RateExp)
94 // Forward parameters to the new AfterBurner
96 if (gDebug>0)cout<<"AliGenCocktailAfterBurner::AddAfterBurner Named "<<Name<<endl;
99 AfterBurner->SetPtRange(fPtMin,fPtMax);
100 if(TestBit(kMomentumRange))
101 AfterBurner->SetMomentumRange(fPMin,fPMax);
103 AfterBurner->SetYRange(fYMin,fYMax);
104 AfterBurner->SetPhiRange(fPhiMin*180/TMath::Pi(),fPhiMax*180/TMath::Pi());
105 AfterBurner->SetThetaRange(fThetaMin*180/TMath::Pi(),fThetaMax*180/TMath::Pi());
106 AfterBurner->SetOrigin(fOrigin[0], fOrigin[1], fOrigin[2]);
107 AfterBurner->SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
108 AfterBurner->SetVertexSmear(fVertexSmear);
109 AfterBurner->SetTrackingFlag(fTrackIt);
110 AfterBurner->SetVertexSource(kContainer);
112 // Add AfterBurner to list
114 AliGenCocktailEntry *entry =
115 new AliGenCocktailEntry(AfterBurner, Name, RateExp);
116 fAfterBurnerEntries->Add(entry);
121 /*********************************************************************/
122 /*********************************************************************/
124 void AliGenCocktailAfterBurner::Init()
127 fGenerationDone = kFALSE;
128 if (fInternalStacks) //delete stacks
130 fInternalStacks->SetOwner();
131 fInternalStacks->Delete(); //clean after previous generation cycle
134 if (fCollisionGeometries) delete[] fCollisionGeometries;
136 this->AliGenCocktail::Init();
138 if (gDebug>0) cout<<"AliGenCocktailAfterBurner::Init"<<endl;
139 TIter next(fAfterBurnerEntries);
140 AliGenCocktailEntry *entry;
142 // Loop over generators and initialize
143 while((entry = (AliGenCocktailEntry*)next())) {
144 entry->Generator()->Init();
147 /*********************************************************************/
148 /*********************************************************************/
150 void AliGenCocktailAfterBurner::Generate()
154 // Firsts runs each generator for all events
155 // than after burners ones for each event
157 // It generates and processes all events during
159 // In next calls it just returns already generated
160 // and processed events to the gAlice
163 cout<<"#####################################"<<endl
164 <<"#AliGenCocktailAfterBurner::Generate#"<<endl
165 <<"#####################################"<<endl;
172 {//if generation is done (in first call)
173 //just copy particles from the stack to the gAlice
174 SetTracks(++fCurrentEvent);
175 fHeader = fHeaders[fCurrentEvent];
176 gAlice->SetGenEventHeader(fHeader);
177 cout<<"Returning event " << fCurrentEvent<<endl;
181 { //Here we are in the first call of the method
182 Int_t numberOfEvents = AliRunLoader::Instance()->GetNumberOfEventsPerRun();
183 cout << "Number of events per run" << numberOfEvents << endl;
185 eventVertex.Set(3 * (numberOfEvents + fNBgEvents));
188 fInternalStacks = new TObjArray(numberOfEvents + fNBgEvents); //Create array of internal stacks
189 fCollisionGeometries = new AliCollisionGeometry*[numberOfEvents + fNBgEvents]; //Create array of collision geometries
190 fHeaders = new AliGenCocktailEventHeader*[numberOfEvents + fNBgEvents]; //Create array of headers
192 for(i = 0; i < numberOfEvents + fNBgEvents; i++)
194 stack = new AliStack(10000);
196 fInternalStacks->Add(stack);
198 for (Int_t j = 0; j < 3; j++) eventVertex[3 * i + j] = fVertex[j];
199 fHeaders[i] = new AliGenCocktailEventHeader();
201 /*********************************************************************/
202 TIter next(fEntries);
203 AliGenCocktailEntry *entry;
204 AliGenCocktailEntry *e1;
205 AliGenCocktailEntry *e2;
206 const TObjArray *partArray;
208 // Loop over generators and generate events
210 while((entry = (AliGenCocktailEntry*)next()))
213 cout<<"Generator "<<igen<<" : "<<entry->GetName()<<endl;
214 /***********************************************/
215 //First generator for all evenets, than second for all events, etc...
216 for(i = 0; i < numberOfEvents + fNBgEvents; i++)
218 cout<<" EVENT "<<i << endl;
220 partArray = stack->Particles();
221 fCurrentGenerator = entry->Generator();
222 fCurrentGenerator->SetStack(stack);
229 entry->SetFirst((partArray->GetEntriesFast())+1);
231 // Set the vertex for the generator
233 fCurrentGenerator->SetVertex(eventVertex.At(ioff), eventVertex.At(ioff + 1), eventVertex.At(ioff + 2));
234 fHeader = fHeaders[i];
235 // Set the vertex for the cocktail
237 for (Int_t j=0; j<3; j++) v[j] = eventVertex.At(ioff + j);
238 fHeader->SetPrimaryVertex(v);
240 fCurrentGenerator->Generate();
242 entry->SetLast(partArray->GetEntriesFast());
244 if (fCurrentGenerator->ProvidesCollisionGeometry()) fCollisionGeometries[i] = fCurrentGenerator->CollisionGeometry();
247 /***********************************************/
250 while((entry = (AliGenCocktailEntry*)next()))
254 for ( entry=FirstGenerator();entry;entry=NextGenerator() )
258 for (FirstGeneratorPair(e1,e2); (e1&&e2); NextGeneratorPair(e1,e2) )
260 printf("\n -----------------------------");
266 /***********************************************/
267 /*******After Burners Processing****************/
268 /***********************************************/
269 TIter nextAfterBurner(fAfterBurnerEntries);
270 AliGenCocktailEntry *afterBurnerEntry;
271 Int_t iab =0; //number of current after burner / counter
273 cout<<"\n\nRunning After Burners"<<endl;
274 while((afterBurnerEntry = (AliGenCocktailEntry*)nextAfterBurner()))
276 cout<<"After Burner "<<iab++<<" :"<<afterBurnerEntry->GetName()<<endl;
277 fCurrentGenerator = afterBurnerEntry->Generator();
278 fCurrentGenerator->Generate();
280 cout<<endl<<"Finished. Processed "<<iab<<" After Burners"<<endl;
282 /***********************************************/
283 /***********************************************/
284 /***********************************************/
286 fGenerationDone=kTRUE;
287 SetTracks(0); //copy event 0 to gAlice stack
289 /*********************************************************************/
290 // Pass the header to gAlice
291 fHeader = fHeaders[0];
292 gAlice->SetGenEventHeader(fHeader);
295 /*********************************************************************/
296 /*********************************************************************/
298 AliStack* AliGenCocktailAfterBurner::GetStack(Int_t n) const
300 //Returns the pointer to the N'th stack (event)
301 if( ( n<0 ) || ( n >= (GetNumberOfEvents()) ) )
303 Fatal("AliGenCocktailAfterBurner::GetStack","Asked for non existing stack (%d)",n);
306 return ((AliStack*) fInternalStacks->At(n) );
309 /*********************************************************************/
310 /*********************************************************************/
312 AliCollisionGeometry* AliGenCocktailAfterBurner::GetCollisionGeometry(Int_t n) const
314 //Returns the pointer to the N'th stack (event)
315 if( ( n<0 ) || ( n>=GetNumberOfEvents() ) )
317 Fatal("AliGenCocktailAfterBurner::GetCollisionGeometry","Asked for non existing stack (%d)",n);
320 return fCollisionGeometries[n];
323 /*********************************************************************/
324 /*********************************************************************/
326 void AliGenCocktailAfterBurner::SetActiveEventNumber(Int_t actev)
328 //Set Active Events Number and Active Stack
329 //There is only one active event number
330 //Made fo convinience of work with AfterBurners (HBT processor)
332 fActiveEvent = actev;
333 fActiveStack = GetStack(actev);
335 /*********************************************************************/
336 /*********************************************************************/
338 void AliGenCocktailAfterBurner::SetTracks(Int_t stackno)
340 //Method which copies tracks from given stack to the
342 AliStack* instack = GetStack(stackno);
346 Double_t px, py, pz, e, vx, vy, vz, tof, polx, poly, polz;
353 Int_t n = instack->GetNtrack();
356 cout<<"AliGenCocktailAfterBurner::SetTracks("<<stackno<<"). Number of particles is: "<<n<<"\n";
359 for(Int_t i = 0; i < n; i++)
362 p = instack->Particle(i);
363 done = !p->TestBit(kDoneBit);
364 parent = p->GetMother(0);
365 pdg = p->GetPdgCode();
374 p->GetPolarisation(pol);
378 mech = AliGenCocktailAfterBurner::IntToMCProcess(p->GetUniqueID());
379 weight = p->GetWeight();
381 gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,polx, poly, polz, mech, ntr, weight);
383 SetHighWaterMark(ntr) ;
387 /*********************************************************************/
388 /*********************************************************************/
390 TMCProcess AliGenCocktailAfterBurner::IntToMCProcess(Int_t no)
392 //Mothod used to convert uniqueID (integer) to TMCProcess type
393 const TMCProcess kMCprocesses[kMaxMCProcess] =
395 kPNoProcess, kPMultipleScattering, kPEnergyLoss, kPMagneticFieldL,
396 kPDecay, kPPair, kPCompton, kPPhotoelectric, kPBrem, kPDeltaRay,
397 kPAnnihilation, kPHadronic, kPNoProcess, kPEvaporation, kPNuclearFission,
398 kPNuclearAbsorption, kPPbarAnnihilation, kPNCapture, kPHElastic,
399 kPHInhelastic, kPMuonNuclear, kPTOFlimit,kPPhotoFission, kPNoProcess,
400 kPRayleigh, kPNoProcess, kPNoProcess, kPNoProcess, kPNull, kPStop
403 for (Int_t i = 0;i<kMaxMCProcess;i++)
405 if (kMCprocesses[i] == no)
407 return kMCprocesses[i];