Line data Source code
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 : /* $Id$ */
17 :
18 : //
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
27 : //
28 : // 24.09.2001 Piotr Skowronski
29 : // debug -> gDebug,
30 : // fNEvents replaced with AliRunLoader::GetNumberOfEvents()
31 : //
32 :
33 :
34 : #include <Riostream.h>
35 :
36 : #include <TList.h>
37 : #include <TObjArray.h>
38 : #include <TParticle.h>
39 :
40 : #include "AliGenCocktailAfterBurner.h"
41 : #include "AliGenCocktailEntry.h"
42 : #include "AliGenCocktailEventHeader.h"
43 : #include "AliCollisionGeometry.h"
44 : #include "AliStack.h"
45 : #include "AliMC.h"
46 : #include "AliRun.h"
47 :
48 : using std::cout;
49 : using std::endl;
50 6 : ClassImp(AliGenCocktailAfterBurner)
51 : /*********************************************************************/
52 : /*********************************************************************/
53 :
54 0 : AliGenCocktailAfterBurner::AliGenCocktailAfterBurner():
55 0 : fNAfterBurners(0),
56 0 : fAfterBurnerEntries(0),
57 0 : fGenerationDone(kFALSE),
58 0 : fInternalStacks(0),
59 0 : fCollisionGeometries(0),
60 0 : fHeaders(0),
61 0 : fCurrentEvent(0),
62 0 : fActiveStack(0),
63 0 : fActiveEvent(-1),
64 0 : fCurrentGenerator(0),
65 0 : fNBgEvents(0)
66 0 : {
67 : // Constructor
68 0 : if (gDebug > 0)
69 0 : cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
70 0 : SetName("AliGenCocktailAfterBurner");
71 0 : SetTitle("AliGenCocktailAfterBurner");
72 0 : }
73 :
74 : /*********************************************************************/
75 :
76 0 : AliGenCocktailAfterBurner::~AliGenCocktailAfterBurner()
77 0 : {
78 : //destructor
79 :
80 0 : if (fInternalStacks) //delete stacks
81 : {
82 0 : fInternalStacks->SetOwner();
83 0 : delete fInternalStacks;
84 : }
85 0 : if (fAfterBurnerEntries) delete fAfterBurnerEntries; //delete entries
86 0 : Int_t numberOfEvents = AliRunLoader::Instance()->GetNumberOfEventsPerRun();
87 0 : if (fCollisionGeometries) {
88 0 : for (Int_t i = 0; i < (numberOfEvents + fNBgEvents); i++)
89 0 : if (fCollisionGeometries[i]) delete fCollisionGeometries[i];
90 0 : delete[] fCollisionGeometries;
91 : }
92 0 : if (fHeaders) {
93 0 : for (Int_t i = 0; i < (numberOfEvents + fNBgEvents); i++)
94 0 : if (fHeaders[i]) delete fHeaders[i];
95 0 : delete[] fHeaders;
96 : }
97 0 : }
98 : /*********************************************************************/
99 : /*********************************************************************/
100 :
101 : void AliGenCocktailAfterBurner::
102 : AddAfterBurner(AliGenerator *AfterBurner, const char* Name, Float_t RateExp)
103 : {
104 : //
105 : // Forward parameters to the new AfterBurner
106 :
107 0 : if (gDebug>0)cout<<"AliGenCocktailAfterBurner::AddAfterBurner Named "<<Name<<endl;
108 :
109 0 : if(TestBit(kPtRange) && !(AfterBurner->TestBit(kPtRange)) && !(AfterBurner->TestBit(kMomentumRange)))
110 0 : AfterBurner->SetPtRange(fPtMin,fPtMax);
111 0 : if(TestBit(kMomentumRange) && !(AfterBurner->TestBit(kPtRange)) && !(AfterBurner->TestBit(kMomentumRange)))
112 0 : AfterBurner->SetMomentumRange(fPMin,fPMax);
113 :
114 0 : if (TestBit(kYRange) && !(AfterBurner->TestBit(kYRange)))
115 0 : AfterBurner->SetYRange(fYMin,fYMax);
116 0 : if (TestBit(kPhiRange) && !(AfterBurner->TestBit(kPhiRange)))
117 0 : AfterBurner->SetPhiRange(fPhiMin*180/TMath::Pi(),fPhiMax*180/TMath::Pi());
118 0 : if (TestBit(kThetaRange) && !(AfterBurner->TestBit(kThetaRange)) && !(AfterBurner->TestBit(kEtaRange)))
119 0 : AfterBurner->SetThetaRange(fThetaMin*180/TMath::Pi(),fThetaMax*180/TMath::Pi());
120 0 : if (!(AfterBurner->TestBit(kVertexRange))) {
121 0 : AfterBurner->SetOrigin(fOrigin[0], fOrigin[1], fOrigin[2]);
122 0 : AfterBurner->SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
123 0 : AfterBurner->SetVertexSmear(fVertexSmear);
124 0 : AfterBurner->SetVertexSource(kContainer);
125 0 : AfterBurner->SetTimeOrigin(fTimeOrigin);
126 0 : }
127 0 : AfterBurner->SetTrackingFlag(fTrackIt);
128 : //AfterBurner->SetContainer(this);
129 :
130 : //
131 : // Add AfterBurner to list
132 :
133 : AliGenCocktailEntry *entry =
134 0 : new AliGenCocktailEntry(AfterBurner, Name, RateExp);
135 0 : if (!fAfterBurnerEntries) fAfterBurnerEntries = new TList();
136 :
137 0 : fAfterBurnerEntries->Add(entry);
138 0 : fNAfterBurners++;
139 : //
140 :
141 0 : }
142 : /*********************************************************************/
143 : /*********************************************************************/
144 :
145 : void AliGenCocktailAfterBurner::Init()
146 : {
147 : // Initialisation
148 0 : Int_t numberOfEvents = AliRunLoader::Instance()->GetNumberOfEventsPerRun();
149 0 : fGenerationDone = kFALSE;
150 0 : if (fInternalStacks) //delete stacks
151 : {
152 0 : fInternalStacks->SetOwner();
153 0 : fInternalStacks->Delete(); //clean after previous generation cycle
154 0 : }
155 :
156 0 : if (fCollisionGeometries) {
157 0 : for (Int_t i = 0; i < (numberOfEvents + fNBgEvents); i++)
158 0 : if (fCollisionGeometries[i]) delete fCollisionGeometries[i];
159 0 : delete[] fCollisionGeometries;
160 : }
161 0 : if (fHeaders) {
162 0 : for (Int_t i = 0; i < (numberOfEvents + fNBgEvents); i++)
163 0 : if (fHeaders[i]) delete fHeaders[i];
164 0 : delete[] fHeaders;
165 : }
166 :
167 0 : this->AliGenCocktail::Init();
168 :
169 0 : if (gDebug>0) cout<<"AliGenCocktailAfterBurner::Init"<<endl;
170 0 : TIter next(fAfterBurnerEntries);
171 : AliGenCocktailEntry *entry;
172 : //
173 : // Loop over generators and initialize
174 0 : while((entry = (AliGenCocktailEntry*)next())) {
175 0 : entry->Generator()->Init();
176 : }
177 0 : }
178 : /*********************************************************************/
179 : /*********************************************************************/
180 :
181 : void AliGenCocktailAfterBurner::Generate()
182 : {
183 : //
184 : // Generate event
185 : // Firsts runs each generator for all events
186 : // than after burners ones for each event
187 : //
188 : // It generates and processes all events during
189 : // first call only.
190 : // In next calls it just returns already generated
191 : // and processed events to the gAlice
192 :
193 0 : if (gDebug>0)
194 0 : cout<<"#####################################"<<endl
195 0 : <<"#AliGenCocktailAfterBurner::Generate#"<<endl
196 0 : <<"#####################################"<<endl;
197 : // Initialize header
198 : //
199 : Int_t i; //iterator
200 : AliStack * stack;
201 :
202 0 : if (fGenerationDone)
203 : {//if generation is done (in first call)
204 : //just copy particles from the stack to the gAlice
205 0 : SetTracks(++fCurrentEvent);
206 0 : fHeader = fHeaders[fCurrentEvent];
207 0 : gAlice->SetGenEventHeader(fHeader);
208 0 : cout<<"Returning event " << fCurrentEvent<<endl;
209 0 : return;
210 : }
211 : else
212 : { //Here we are in the first call of the method
213 0 : Int_t numberOfEvents = AliRunLoader::Instance()->GetNumberOfEventsPerRun();
214 0 : cout << "Number of events per run" << numberOfEvents << endl;
215 0 : TArrayF eventVertex;
216 0 : eventVertex.Set(3 * (numberOfEvents + fNBgEvents));
217 0 : TArrayF eventTime;
218 0 : eventTime.Set(numberOfEvents + fNBgEvents);
219 0 : fCurrentEvent=0;
220 : //Create stacks
221 0 : fInternalStacks = new TObjArray(numberOfEvents + fNBgEvents); //Create array of internal stacks
222 0 : fCollisionGeometries = new AliCollisionGeometry*[numberOfEvents + fNBgEvents]; //Create array of collision geometries
223 0 : fHeaders = new AliGenCocktailEventHeader*[numberOfEvents + fNBgEvents]; //Create array of headers
224 :
225 0 : for(i = 0; i < numberOfEvents + fNBgEvents; i++)
226 : {
227 0 : stack = new AliStack(10000);
228 0 : stack->Reset();
229 0 : fInternalStacks->Add(stack);
230 0 : Vertex();
231 0 : for (Int_t j = 0; j < 3; j++) eventVertex[3 * i + j] = fVertex[j];
232 0 : eventTime[i] = fTime;
233 0 : fHeaders[i] = new AliGenCocktailEventHeader();
234 0 : fCollisionGeometries[i] = 0;
235 : }
236 : /*********************************************************************/
237 0 : TIter next(fEntries);
238 : AliGenCocktailEntry *entry;
239 0 : AliGenCocktailEntry *e1;
240 0 : AliGenCocktailEntry *e2;
241 : const TObjArray *partArray;
242 : //
243 : // Loop over generators and generate events
244 : Int_t igen=0;
245 0 : while((entry = (AliGenCocktailEntry*)next()))
246 : {
247 0 : igen++;
248 0 : cout<<"Generator "<<igen<<" : "<<entry->GetName()<<endl;
249 : /***********************************************/
250 : //First generator for all evenets, than second for all events, etc...
251 0 : for(i = 0; i < numberOfEvents + fNBgEvents; i++)
252 : {
253 0 : cout<<" EVENT "<<i << endl;
254 0 : stack = GetStack(i);
255 0 : partArray = stack->Particles();
256 0 : fCurrentGenerator = entry->Generator();
257 0 : fCurrentGenerator->SetStack(stack);
258 0 : if (igen ==1)
259 : {
260 0 : entry->SetFirst(0);
261 0 : }
262 : else
263 : {
264 0 : entry->SetFirst((partArray->GetEntriesFast())+1);
265 : }
266 : // Set the vertex for the generator
267 0 : Int_t ioff = 3 * i;
268 0 : fCurrentGenerator->SetVertex(eventVertex.At(ioff), eventVertex.At(ioff + 1), eventVertex.At(ioff + 2));
269 0 : fCurrentGenerator->SetTime(eventTime.At(i));
270 0 : fHeader = fHeaders[i];
271 : // Set the vertex and time for the cocktail
272 0 : TArrayF v(3);
273 0 : for (Int_t j=0; j<3; j++) v[j] = eventVertex.At(ioff + j);
274 0 : fHeader->SetPrimaryVertex(v);
275 0 : fHeader->SetInteractionTime(eventTime.At(i));
276 : // Generate event
277 0 : fCurrentGenerator->Generate();
278 : //
279 0 : entry->SetLast(partArray->GetEntriesFast());
280 :
281 0 : if (fCurrentGenerator->ProvidesCollisionGeometry())
282 0 : fCollisionGeometries[i] =
283 0 : new AliCollisionGeometry(*(fCurrentGenerator->CollisionGeometry()));
284 0 : } // event loop
285 : /***********************************************/
286 : } // generator loop
287 0 : next.Reset();
288 0 : while((entry = (AliGenCocktailEntry*)next()))
289 : {
290 0 : entry->PrintInfo();
291 : }
292 0 : for ( entry=FirstGenerator();entry;entry=NextGenerator() )
293 : {
294 0 : entry->PrintInfo();
295 : }
296 0 : for (FirstGeneratorPair(e1,e2); (e1&&e2); NextGeneratorPair(e1,e2) )
297 : {
298 0 : printf("\n -----------------------------");
299 0 : e1->PrintInfo();
300 0 : e2->PrintInfo();
301 : }
302 :
303 :
304 : /***********************************************/
305 : /*******After Burners Processing****************/
306 : /***********************************************/
307 0 : TIter nextAfterBurner(fAfterBurnerEntries);
308 : AliGenCocktailEntry *afterBurnerEntry;
309 : Int_t iab =0; //number of current after burner / counter
310 :
311 0 : cout<<"\n\nRunning After Burners"<<endl;
312 0 : while((afterBurnerEntry = (AliGenCocktailEntry*)nextAfterBurner()))
313 : {
314 0 : cout<<"After Burner "<<iab++<<" :"<<afterBurnerEntry->GetName()<<endl;
315 0 : fCurrentGenerator = afterBurnerEntry->Generator();
316 0 : fCurrentGenerator->Generate();
317 : }
318 0 : cout<<endl<<"Finished. Processed "<<iab<<" After Burners"<<endl;
319 :
320 : /***********************************************/
321 : /***********************************************/
322 : /***********************************************/
323 :
324 0 : fGenerationDone=kTRUE;
325 0 : SetTracks(0); //copy event 0 to gAlice stack
326 :
327 : /*********************************************************************/
328 : // Pass the header to gAlice
329 0 : fHeader = fHeaders[0];
330 0 : gAlice->SetGenEventHeader(fHeader);
331 0 : } //else generated
332 0 : }
333 : /*********************************************************************/
334 : /*********************************************************************/
335 :
336 : AliStack* AliGenCocktailAfterBurner::GetStack(Int_t n) const
337 : {
338 : //Returns the pointer to the N'th stack (event)
339 0 : if( ( n<0 ) || ( n >= (GetNumberOfEvents()) ) )
340 : {
341 0 : Fatal("AliGenCocktailAfterBurner::GetStack","Asked for non existing stack (%d)",n);
342 0 : return 0;
343 : }
344 0 : return ((AliStack*) fInternalStacks->At(n) );
345 0 : }
346 :
347 : /*********************************************************************/
348 : /*********************************************************************/
349 :
350 : AliCollisionGeometry* AliGenCocktailAfterBurner::GetCollisionGeometry(Int_t n) const
351 : {
352 : //Returns the pointer to the N'th stack (event)
353 0 : if( ( n<0 ) || ( n>=GetNumberOfEvents() ) )
354 : {
355 0 : Fatal("AliGenCocktailAfterBurner::GetCollisionGeometry","Asked for non existing stack (%d)",n);
356 0 : return 0;
357 : }
358 0 : return fCollisionGeometries[n];
359 0 : }
360 :
361 : /*********************************************************************/
362 : /*********************************************************************/
363 :
364 : void AliGenCocktailAfterBurner::SetActiveEventNumber(Int_t actev)
365 : {
366 : //Set Active Events Number and Active Stack
367 : //There is only one active event number
368 : //Made fo convinience of work with AfterBurners (HBT processor)
369 :
370 0 : fActiveEvent = actev;
371 0 : fActiveStack = GetStack(actev);
372 0 : }
373 : /*********************************************************************/
374 : /*********************************************************************/
375 :
376 : void AliGenCocktailAfterBurner::SetTracks(Int_t stackno)
377 : {
378 : //Method which copies tracks from given stack to the
379 : //gAlice's stack
380 0 : AliStack* instack = GetStack(stackno);
381 : Int_t done;
382 : Int_t parent;
383 : Int_t pdg;
384 : Double_t px, py, pz, e, vx, vy, vz, tof, polx, poly, polz;
385 : TMCProcess mech;
386 0 : Int_t ntr;
387 : Float_t weight;
388 0 : TVector3 pol;
389 : Int_t is;
390 :
391 : TParticle * p;
392 0 : Int_t n = instack->GetNtrack();
393 0 : if (gDebug)
394 : {
395 0 : cout<<"AliGenCocktailAfterBurner::SetTracks("<<stackno<<"). Number of particles is: "<<n<<"\n";
396 : }
397 :
398 0 : for(Int_t i = 0; i < n; i++)
399 : {
400 :
401 0 : p = instack->Particle(i);
402 0 : done = !p->TestBit(kDoneBit);
403 0 : parent = p->GetMother(0);
404 0 : pdg = p->GetPdgCode();
405 0 : px = p->Px();
406 0 : py = p->Py();
407 0 : pz = p->Pz();
408 0 : e = p->Energy();
409 0 : vx = p->Vx();
410 0 : vy = p->Vy();
411 0 : vz = p->Vz();
412 0 : tof = p->T();
413 0 : p->GetPolarisation(pol);
414 0 : polx = pol.X();
415 0 : poly = pol.Y();
416 0 : polz = pol.Z();
417 0 : mech = AliGenCocktailAfterBurner::IntToMCProcess(p->GetUniqueID());
418 0 : weight = p->GetWeight();
419 0 : is = p->GetStatusCode();
420 :
421 0 : gAlice->GetMCApp()->PushTrack(done, parent, pdg, px, py, pz, e, vx, vy, vz, tof,polx, poly, polz, mech, ntr, weight, is);
422 :
423 0 : SetHighWaterMark(ntr) ;
424 :
425 : }
426 0 : }
427 : /*********************************************************************/
428 : /*********************************************************************/
429 :
430 : TMCProcess AliGenCocktailAfterBurner::IntToMCProcess(Int_t no)
431 : {
432 : //Mothod used to convert uniqueID (integer) to TMCProcess type
433 : const TMCProcess kMCprocesses[kMaxMCProcess] =
434 : {
435 : kPNoProcess, kPMultipleScattering, kPEnergyLoss, kPMagneticFieldL,
436 : kPDecay, kPPair, kPCompton, kPPhotoelectric, kPBrem, kPDeltaRay,
437 : kPAnnihilation, kPHadronic, kPNoProcess, kPEvaporation, kPNuclearFission,
438 : kPNuclearAbsorption, kPPbarAnnihilation, kPNCapture, kPHElastic,
439 : kPHInhelastic, kPMuonNuclear, kPTOFlimit,kPPhotoFission, kPNoProcess,
440 : kPRayleigh, kPNoProcess, kPNoProcess, kPNoProcess, kPNull, kPStop
441 : };
442 :
443 0 : for (Int_t i = 0;i<kMaxMCProcess;i++)
444 : {
445 0 : if (kMCprocesses[i] == no)
446 : {
447 0 : return kMCprocesses[i];
448 : }
449 : }
450 0 : return kPNoProcess;
451 0 : }
452 :
|
