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 **************************************************************************/
17 // Container class for AliGenerator and AfterBurners
18 // (which are AliGenerators as well) through recursion.
19 // The container is itself an AliGenerator a
20 // what is stored are not the pointers to the generators directly
21 // but to objects of type
22 // AliGenCocktailAfterBurner entry.
23 // The class provides also iterator functionality.
24 // Author: andreas.morsch@cern.ch and piotr.skowronski@cern.ch
26 // 24.09.2001 Piotr Skowronski
28 // fNEvents replaced with gAlice->GetEventsPerRun()
30 #include "AliGenCocktailAfterBurner.h"
31 #include "AliGenCocktailEntry.h"
34 #include <TObjArray.h>
36 #include <TParticle.h>
37 #include <Riostream.h>
40 ClassImp(AliGenCocktailAfterBurner)
41 /*********************************************************************/
42 /*********************************************************************/
44 AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()
48 cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
49 SetName("AliGenCocktailAfterBurner");
50 SetTitle("AliGenCocktailAfterBurner");
53 fCurrentGenerator = 0;
55 fAfterBurnerEntries = new TList();
57 fGenerationDone = kFALSE;
62 /*********************************************************************/
63 AliGenCocktailAfterBurner::AliGenCocktailAfterBurner(const AliGenCocktailAfterBurner& in)
68 /*********************************************************************/
70 AliGenCocktailAfterBurner::~AliGenCocktailAfterBurner()
74 if (fInternalStacks) //delete stacks
76 fInternalStacks->SetOwner();
77 delete fInternalStacks;
79 if (fAfterBurnerEntries) delete fAfterBurnerEntries; //delete entries
81 /*********************************************************************/
82 /*********************************************************************/
84 void AliGenCocktailAfterBurner::
85 AddAfterBurner(AliGenerator *AfterBurner, char* Name, Float_t RateExp)
88 // Forward parameters to the new AfterBurner
90 if (gDebug>0)cout<<"AliGenCocktailAfterBurner::AddAfterBurner Named "<<Name<<endl;
93 AfterBurner->SetPtRange(fPtMin,fPtMax);
94 if(TestBit(kMomentumRange))
95 AfterBurner->SetMomentumRange(fPMin,fPMax);
97 AfterBurner->SetYRange(fYMin,fYMax);
98 AfterBurner->SetPhiRange(fPhiMin*180/TMath::Pi(),fPhiMax*180/TMath::Pi());
99 AfterBurner->SetThetaRange(fThetaMin*180/TMath::Pi(),fThetaMax*180/TMath::Pi());
100 AfterBurner->SetOrigin(fOrigin[0], fOrigin[1], fOrigin[2]);
101 AfterBurner->SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
102 AfterBurner->SetVertexSmear(fVertexSmear);
103 AfterBurner->SetTrackingFlag(fTrackIt);
105 // Add AfterBurner to list
107 AliGenCocktailEntry *entry =
108 new AliGenCocktailEntry(AfterBurner, Name, RateExp);
109 fAfterBurnerEntries->Add(entry);
114 /*********************************************************************/
115 /*********************************************************************/
117 void AliGenCocktailAfterBurner::Init()
120 fGenerationDone = kFALSE;
121 if (fInternalStacks) //delete stacks
123 fInternalStacks->SetOwner();
124 fInternalStacks->Delete(); //clean after previous generation cycle
127 this->AliGenCocktail::Init();
129 if (gDebug>0) cout<<"AliGenCocktailAfterBurner::Init"<<endl;
130 TIter next(fAfterBurnerEntries);
131 AliGenCocktailEntry *entry;
133 // Loop over generators and initialize
134 while((entry = (AliGenCocktailEntry*)next())) {
135 entry->Generator()->Init();
138 /*********************************************************************/
139 /*********************************************************************/
141 void AliGenCocktailAfterBurner::Generate()
145 // Firsts runs each generator for all events
146 // than after burners ones for each event
148 // It generates and processes all events during
150 // In next calls it just returns already generated
151 // and processed events to the gAlice
154 cout<<"#####################################"<<endl
155 <<"#AliGenCocktailAfterBurner::Generate#"<<endl
156 <<"#####################################"<<endl;
162 {//if generation is done (in first call)
163 //just copy particles from the stack to the gAlice
164 SetTracks(++fCurrentEvent);
165 cout<<"Returning event "<<fCurrentEvent<<endl;
169 { //Here we are in the first call of the method
171 Int_t numberOfEvents = gAlice->GetEventsPerRun();
173 fInternalStacks = new TObjArray(numberOfEvents + fNBgEvents); //Create array of internal stacks
174 for(i=0;i<numberOfEvents + fNBgEvents;i++)
176 stack = new AliStack(10000);
178 fInternalStacks->Add(stack);
180 /*********************************************************************/
181 TIter next(fEntries);
182 AliGenCocktailEntry *entry;
183 AliGenCocktailEntry *e1;
184 AliGenCocktailEntry *e2;
185 TObjArray *partArray;
187 // Loop over generators and generate events
189 while((entry = (AliGenCocktailEntry*)next()))
192 cout<<"Generator "<<igen<<" : "<<entry->GetName()<<endl;
193 /***********************************************/
194 //First generator for all evenets, than second for all events, etc...
195 for(i=0;i<numberOfEvents + fNBgEvents;i++)
197 cout<<" EVENT "<<i<<endl;
199 partArray = stack->Particles();
200 fCurrentGenerator = entry->Generator();
201 fCurrentGenerator->SetStack(stack);
208 entry->SetFirst((partArray->GetEntriesFast())+1);
210 fCurrentGenerator->Generate();
211 entry->SetLast(partArray->GetEntriesFast());
213 /***********************************************/
216 while((entry = (AliGenCocktailEntry*)next()))
220 for ( entry=FirstGenerator();entry;entry=NextGenerator() )
224 for (FirstGeneratorPair(e1,e2); (e1&&e2); NextGeneratorPair(e1,e2) )
226 printf("\n -----------------------------");
232 /***********************************************/
233 /*******After Burners Processing****************/
234 /***********************************************/
235 TIter nextAfterBurner(fAfterBurnerEntries);
236 AliGenCocktailEntry *afterBurnerEntry;
237 Int_t iab =0; //number of current after burner / counter
239 cout<<"\n\nRunning After Burners"<<endl;
240 while((afterBurnerEntry = (AliGenCocktailEntry*)nextAfterBurner()))
242 cout<<"After Burner "<<iab++<<" :"<<afterBurnerEntry->GetName()<<endl;
243 fCurrentGenerator = afterBurnerEntry->Generator();
244 fCurrentGenerator->Generate();
246 cout<<endl<<"Finished. Processed "<<iab<<" After Burners"<<endl;
248 /***********************************************/
249 /***********************************************/
250 /***********************************************/
252 fGenerationDone=kTRUE;
253 SetTracks(0); //copy event 0 to gAlice stack
255 /*********************************************************************/
259 /*********************************************************************/
260 /*********************************************************************/
262 AliGenCocktailAfterBurner& AliGenCocktailAfterBurner::operator=(const AliGenCocktailAfterBurner& rhs)
264 // Assignment operator
267 /*********************************************************************/
268 /*********************************************************************/
270 AliStack* AliGenCocktailAfterBurner::GetStack(Int_t n) const
272 //Returns the pointer to the N'th stack (event)
273 if( ( n<0 ) || ( n>=GetNumberOfEvents() ) )
275 Fatal("AliGenCocktailAfterBurner::GetStack","Asked for non existing stack (%d)",n);
278 return ((AliStack*) fInternalStacks->At(n) );
280 /*********************************************************************/
281 /*********************************************************************/
283 void AliGenCocktailAfterBurner::SetActiveEventNumber(Int_t actev)
285 //Set Active Events Number and Active Stack
286 //There is only one active event number
287 //Made fo convinience of work with AfterBurners (HBT processor)
289 fActiveEvent = actev;
290 fActiveStack = GetStack(actev);
292 /*********************************************************************/
293 /*********************************************************************/
295 void AliGenCocktailAfterBurner::SetTracks(Int_t stackno)
297 //Method which copies tracks from given stack to the
299 AliStack* instack = GetStack(stackno);
303 Double_t px, py, pz, e, vx, vy, vz, tof, polx, poly, polz;
310 Int_t n = instack->GetNtrack();
313 cout<<"AliGenCocktailAfterBurner::SetTracks("<<stackno<<"). Number of particles is: "<<n<<"\n";
316 for(Int_t i = 0; i < n; i++)
319 p = instack->Particle(i);
320 done = !p->TestBit(kDoneBit);
321 parent = p->GetMother(0);
322 pdg = p->GetPdgCode();
331 p->GetPolarisation(pol);
335 mech = AliGenCocktailAfterBurner::IntToMCProcess(p->GetUniqueID());
336 weight = p->GetWeight();
338 gAlice->SetTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,
339 polx, poly, polz, mech, ntr, weight);
342 /*********************************************************************/
343 /*********************************************************************/
345 TMCProcess AliGenCocktailAfterBurner::IntToMCProcess(Int_t no)
347 //Mothod used to convert uniqueID (integer) to TMCProcess type
348 const TMCProcess kMCprocesses[kMaxMCProcess] =
350 kPNoProcess, kPMultipleScattering, kPEnergyLoss, kPMagneticFieldL,
351 kPDecay, kPPair, kPCompton, kPPhotoelectric, kPBrem, kPDeltaRay,
352 kPAnnihilation, kPHadronic, kPNoProcess, kPEvaporation, kPNuclearFission,
353 kPNuclearAbsorption, kPPbarAnnihilation, kPNCapture, kPHElastic,
354 kPHInhelastic, kPMuonNuclear, kPTOFlimit,kPPhotoFission, kPNoProcess,
355 kPRayleigh, kPNoProcess, kPNoProcess, kPNoProcess, kPNull, kPStop
358 for (Int_t i = 0;i<kMaxMCProcess;i++)
360 if (kMCprocesses[i] == no)
362 return kMCprocesses[i];