Adding AliGenEventHeader
[u/mrichter/AliRoot.git] / EVGEN / AliGenCocktail.cxx
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 // Container class for AliGenerator through recursion.
19 // Container is itself an AliGenerator.
20 // What is stored are not the pointers to the generators directly but to objects of type
21 // AliGenCocktail entry.   
22 // The class provides also iterator functionality.  
23 // Author: andreas.morsch@cern.ch 
24 //
25
26 #include <TList.h>
27 #include <TObjArray.h>
28
29 #include "AliGenCocktail.h"
30 #include "AliGenCocktailEntry.h"
31 #include "AliCollisionGeometry.h"
32 #include "AliRun.h"
33 #include "AliMC.h"
34 #include "AliGenEventHeader.h"
35
36 ClassImp(AliGenCocktail)
37
38 AliGenCocktail::AliGenCocktail()
39                  :AliGenerator()
40 {
41 // Constructor
42     fName = "Cocktail";
43     fTitle= "Particle Generator using cocktail of generators";
44     flnk1 = 0;
45     flnk2 = 0;
46     fNGenerators=0;
47     fEntries = 0;
48     
49 }
50
51 AliGenCocktail::AliGenCocktail(const AliGenCocktail & cocktail):
52     AliGenerator(cocktail)
53 {
54 // Copy constructor
55     cocktail.Copy(*this);
56 }
57
58 AliGenCocktail::~AliGenCocktail()
59 {
60 // Destructor
61     delete fEntries;
62 }
63
64 void AliGenCocktail::
65 AddGenerator(AliGenerator *Generator, const char* Name, Float_t RateExp)
66 {
67 //
68 // Add a generator to the list 
69 // First check that list exists
70     if (!fEntries) fEntries = new TList();
71
72 //
73 //  Forward parameters to the new generator
74     if(TestBit(kPtRange) && !(Generator->TestBit(kPtRange)) && !(Generator->TestBit(kMomentumRange))) 
75         Generator->SetPtRange(fPtMin,fPtMax);
76     if(TestBit(kMomentumRange) && !(Generator->TestBit(kPtRange)) && !(Generator->TestBit(kMomentumRange)))
77         Generator->SetMomentumRange(fPMin,fPMax);
78     
79     if (!(Generator->TestBit(kYRange)))    
80         Generator->SetYRange(fYMin,fYMax);
81     if (!(Generator->TestBit(kPhiRange)))   
82         Generator->SetPhiRange(fPhiMin*180/TMath::Pi(),fPhiMax*180/TMath::Pi());
83     if (!(Generator->TestBit(kThetaRange))) 
84         Generator->SetThetaRange(fThetaMin*180/TMath::Pi(),fThetaMax*180/TMath::Pi());
85     if (!(Generator->TestBit(kVertexRange))) 
86         Generator->SetOrigin(fOrigin[0], fOrigin[1], fOrigin[2]);
87
88     Generator->SetSigma(fOsigma[0], fOsigma[1], fOsigma[2]);
89     Generator->SetVertexSmear(fVertexSmear);
90     Generator->SetVertexSource(kContainer);
91     Generator->SetTrackingFlag(fTrackIt);
92         
93 //
94 //  Add generator to list   
95     char theName[256];
96     sprintf(theName, "%s_%d",Name, fNGenerators);
97     Generator->SetName(theName);
98
99     AliGenCocktailEntry *entry = 
100         new AliGenCocktailEntry(Generator, Name, RateExp);
101     
102      fEntries->Add(entry);
103      fNGenerators++;
104  }
105
106   void AliGenCocktail::Init()
107 {
108 // Initialisation
109     TIter next(fEntries);
110     AliGenCocktailEntry *entry;
111     //
112     // Loop over generators and initialize
113     while((entry = (AliGenCocktailEntry*)next())) {
114         if (fStack)  entry->Generator()->SetStack(fStack);
115         entry->Generator()->Init();
116     }  
117 }
118
119   void AliGenCocktail::FinishRun()
120 {
121 // Initialisation
122     TIter next(fEntries);
123     AliGenCocktailEntry *entry;
124     //
125     // Loop over generators and initialize
126     while((entry = (AliGenCocktailEntry*)next())) {
127         entry->Generator()->FinishRun();
128     }  
129 }
130
131  void AliGenCocktail::Generate()
132 {
133 //
134 // Generate event 
135     TIter next(fEntries);
136     AliGenCocktailEntry *entry = 0;
137     AliGenCocktailEntry *preventry = 0;
138     AliGenerator* gen = 0;
139
140     TObjArray *partArray = gAlice->GetMCApp()->Particles();
141
142 //
143 //  Generate the vertex position used by all generators
144 //    
145     if(fVertexSmear == kPerEvent) Vertex();
146
147     TArrayF eventVertex;
148     eventVertex.Set(3);
149     for (Int_t j=0; j < 3; j++) eventVertex[j] = fVertex[j];
150
151     
152   //
153     // Loop over generators and generate events
154     Int_t igen=0;
155     
156     while((entry = (AliGenCocktailEntry*)next())) {
157         igen++;
158         if (igen ==1) {
159             entry->SetFirst(0);
160         } else {
161             entry->SetFirst((partArray->GetEntriesFast())+1);
162         }
163 //
164 //      Handle case in which current generator needs collision geometry from previous generator
165 //
166         gen = entry->Generator();
167         if (gen->NeedsCollisionGeometry())
168         {
169             if (preventry && preventry->Generator()->ProvidesCollisionGeometry())
170             {
171                 gen->SetCollisionGeometry(preventry->Generator()->CollisionGeometry());
172             } else {
173                 Fatal("Generate()", "No Collision Geometry Provided");
174             }
175         }
176         entry->Generator()->SetVertex(fVertex.At(0), fVertex.At(1), fVertex.At(2));
177         entry->Generator()->Generate();
178         entry->SetLast(partArray->GetEntriesFast());
179         preventry = entry;
180     }  
181     next.Reset();
182 // Header
183     AliGenEventHeader* header = new AliGenEventHeader("AliGenCocktail");
184 // Event Vertex
185     header->SetPrimaryVertex(eventVertex);
186     gAlice->SetGenEventHeader(header); 
187 }
188
189 AliGenCocktailEntry *  AliGenCocktail::FirstGenerator()
190 {
191 // Iterator over generators: Initialisation
192     flnk1 = fEntries->FirstLink();
193     if (flnk1) {
194         return (AliGenCocktailEntry*) (flnk1->GetObject());
195     } else {
196         return 0;
197     }
198 }
199
200 AliGenCocktailEntry*  AliGenCocktail::NextGenerator()
201 {
202 // Iterator over generators: Increment
203     flnk1 = flnk1->Next();
204     if (flnk1) {
205         return (AliGenCocktailEntry*) (flnk1->GetObject());
206     } else {
207         return 0;
208     }
209 }
210
211 void AliGenCocktail::
212 FirstGeneratorPair(AliGenCocktailEntry*& e1, AliGenCocktailEntry*& e2)
213 {
214 // Iterator over generator pairs: Initialisation
215     flnk2 = flnk1 = fEntries->FirstLink();
216     if (flnk1) {
217         e2 = e1 = (AliGenCocktailEntry*) (flnk1->GetObject());
218     } else {
219         e2= e1 = 0;
220     }
221 }
222
223 void AliGenCocktail::
224 NextGeneratorPair(AliGenCocktailEntry*& e1, AliGenCocktailEntry*& e2)
225 {
226 // Iterator over generators: Increment
227     flnk2 = flnk2->Next();
228     if (flnk2) {
229         e1 = (AliGenCocktailEntry*) (flnk1->GetObject());
230         e2 = (AliGenCocktailEntry*) (flnk2->GetObject());       
231     } else {
232         flnk2 = flnk1 = flnk1->Next();
233         if (flnk1) {
234             e1 = (AliGenCocktailEntry*) (flnk1->GetObject());
235             e2 = (AliGenCocktailEntry*) (flnk2->GetObject());
236         } else {
237             e1=0;
238             e2=0;
239         }
240     }
241 }
242
243 AliGenCocktail& AliGenCocktail::operator=(const  AliGenCocktail& rhs)
244 {
245 // Assignment operator
246     rhs.Copy(*this); 
247     return (*this);
248 }
249
250 void AliGenCocktail::Copy(TObject &) const
251 {
252     Fatal("Copy","Not implemented!\n");
253 }
254
255
256