]>
Commit | Line | Data |
---|---|---|
65a39007 | 1 | |
2 | ////////////////////////////////////////////////////////////////////////// | |
3 | // // | |
4 | // AliFast // | |
5 | // // | |
6 | // Main class to control the AliFast program. // | |
7 | // // | |
8 | // This class is a general framework for programs that needs to: // | |
9 | // - Initialise some parameters // | |
10 | // - Loop on events // | |
11 | // - Print results and save histograms, etc // | |
12 | // // | |
13 | // The event processor AliFast::Make loops on a list of Makers // | |
14 | // where each maker performs some task on the event data and generates // | |
15 | // results. // | |
16 | // New Makers can be inserted by a user without modifying this class. // | |
17 | // Note that the order in which the Makers are called is the order // | |
18 | // of insertion in the list of Makers. // | |
19 | // Each Maker is responsible for creating its branch of the Tree. // | |
20 | // The following table shows the list of makers currently implemented // | |
21 | // The default option to Save the Maker info in the Tree is mentioned. // | |
22 | // // | |
23 | // Maker name Save in Tree // | |
24 | // ========== ============ // | |
25 | // MCMaker NO // | |
26 | // TrackMaker NO // | |
27 | // // | |
28 | // Makers must derive from the base class AliFMaker. // | |
29 | // AliFMaker provides a common interface to all Makers. // | |
30 | // Each Maker is responsible for defining its own parameters and // | |
31 | // histograms. // | |
32 | // Each Maker has its own list of histograms. // | |
33 | // Each Maker has an associated companion class corresponding to the // | |
34 | // type of physics object reconstructed by the Maker. // | |
35 | // For example, AliFClusterMaker creates AliFCluster objects. // | |
36 | // AliFTriggerMaker creates one single AliFTrigger object. // | |
37 | // The pointer supporting the created object(s) is defined in AliFMaker // | |
38 | // fFruits may point to a single object (eg. AliFTrigger) or to a // | |
39 | // TClonesArray of objects (eg. AliFCluster). // | |
40 | // // | |
41 | // The function AliFast::Maketree must be called after the creation // | |
42 | // of the AliFast object to create a Root Tree. // | |
43 | // // | |
44 | // An example of main program/macro to use AliFast is given below: // | |
45 | //======================================================================== | |
46 | //void umain(Int_t nevents=100) | |
47 | //{ | |
48 | // gROOT->Reset(); | |
49 | // gSystem->Load("libalifast.so"); // dynamically link the compiled shared library | |
50 | // | |
51 | // // Open the root output file | |
52 | // TFile file("alifast.root","recreate","AliFast root file",2); | |
53 | // | |
54 | // AliFast alifast("alifast"); // create main object to run alifast | |
55 | // | |
56 | // User user; // create an object of the User class defined in user.C | |
57 | // | |
58 | // alifast.Init(); // Initialise event (maker histograms,etc) | |
59 | // alifast.MakeTree(); // Create the Root tree | |
60 | // | |
61 | // gROOT->LoadMacro("user.C"); // compile/interpret user file | |
62 | // | |
63 | // for (Int_t i=0; i<nevents; i++) { | |
64 | // if (i%100 == 0) printf("In loop:%d\n",i); | |
65 | // alifast.Make(i); // Generate and reconstruct event | |
66 | // user.FillHistograms(); // User has possibility to decide if store event here! | |
67 | // alifast.FillTree(); | |
68 | // alifast.Clear(); // Clear all event lists | |
69 | // } | |
70 | // alifast.Finish(); | |
71 | // | |
72 | // // save objects in Root file | |
73 | // alifast.Write(); //save main alifast object (and run parameters) | |
74 | //} | |
75 | //======================================================================== | |
76 | // // | |
77 | // This example illustrates how to: // | |
78 | // - Load a shared library // | |
79 | // - Open a Root file // | |
80 | // - Initialise AliFast // | |
81 | // - Load some user code (interpreted) // | |
82 | // This user code may redefine some Maker parameters // | |
83 | // - Make a loop on events // | |
84 | // - Save histograms and the main AliFast object and its Makers // | |
85 | // // | |
86 | //======================================================================== | |
87 | // An example of a User class is given below: // | |
88 | //======================================================================== | |
89 | // | |
90 | //#ifndef user_H | |
91 | //#define user_H | |
92 | // | |
93 | ////////////////////////////////////////////////////////////////////////// | |
94 | // // | |
95 | // User // | |
96 | // // | |
97 | // Example of a user class to perform user specific tasks when running // | |
98 | // the ALIfast program. // | |
99 | // // | |
100 | // This class illustrates: // | |
101 | // - How to set run parameters // | |
102 | // - How to create and fill histograms // | |
103 | // // | |
104 | ////////////////////////////////////////////////////////////////////////// | |
105 | // | |
106 | //class TH1F; | |
107 | //class AliFast; | |
108 | //class AliFClusterMaker; | |
109 | //class AliFPhotonMaker; | |
110 | // | |
111 | //class User { | |
112 | // | |
113 | //private: | |
114 | // TH1F *fhist1; //pointer to histogram | |
115 | // TH1F *fhist2; //pointer to histogram | |
116 | // TH1F *fhist3; //pointer to histogram | |
117 | //public: | |
118 | // User(); | |
119 | // void FillHistograms(); | |
120 | // void SetRunParameters(); | |
121 | // | |
122 | //#endif | |
123 | //}; | |
124 | // | |
125 | //_________________________________________________________________________ | |
126 | //User::User() | |
127 | //{ | |
128 | // SetRunParameters(); //change default parameters | |
129 | // | |
130 | // Create a few histograms | |
131 | // fhist1 = new TH1F("hist1","Number of tracks per event",100,0,100); | |
132 | // fhist2 = new TH1F("hist2","Number of clusters",100,0,100); | |
133 | // fhist3 = new TH1F("hist3","Number of isolated muons",20,0,20); | |
134 | //} | |
135 | // | |
136 | //_________________________________________________________________________ | |
137 | //void User::FillHistograms() | |
138 | //{ | |
139 | //// fhist1.Fill(event->GetNtracks()); | |
140 | //// fhist2.Fill(event->GetNclusters)); | |
141 | //// fhist3.Fill(event->GetNIsoMuons()); | |
142 | //} | |
143 | // | |
144 | //_________________________________________________________________________ | |
145 | //void User::SetRunParameters() | |
146 | //{ | |
147 | // // change Alifast default parameters | |
148 | // | |
149 | // gAliFast->SetSmearMuonOpt(0); | |
150 | // gAliFast->ClusterMaker()->SetGranBarrelEta(0.12); | |
151 | // gAliFast->PhotonMaker()->SetMinPT(6.); | |
152 | // gAliFast->TriggerMaker()->SetMuoEtaCoverage(2.8); | |
153 | // | |
154 | //} | |
155 | //======================end of User class================================= | |
156 | // | |
157 | ////////////////////////////////////////////////////////////////////////// | |
158 | ||
159 | #include <TROOT.h> | |
160 | #include <TChain.h> | |
161 | #include <TTree.h> | |
162 | #include <TBrowser.h> | |
163 | #include <TClonesArray.h> | |
164 | #include "AliRun.h" | |
165 | #include "AliFast.h" | |
166 | //#include "AliFMCMaker.h" | |
167 | #include "AliFTrackMaker.h" | |
168 | #include "AliFHistBrowser.h" | |
169 | #include "AliFBigBang.h" | |
170 | #include "AliFVirtualDisplay.h" | |
171 | ||
172 | ||
173 | R__EXTERN AliRun * gAlice; | |
174 | AliFast *gAliFast; | |
175 | ||
176 | ClassImp(AliFast) | |
177 | ||
178 | ||
179 | //_____________________________________________________________________________ | |
180 | //AliFast::AliFast() : TNamed("alifast","The ALICE fast simulation") | |
181 | AliFast::AliFast() : AliRun("alifast","The ALICE fast simulation") | |
182 | { | |
183 | ||
184 | fTree = 0; | |
185 | fMakers = 0; | |
186 | fMode = 0; | |
187 | // fMCMaker = 0; | |
188 | fTrackMaker = 0; | |
189 | fDisplay = 0; | |
190 | fDet = new AliFDet("Detector","Make AliFast detector"); | |
191 | gAliFast = this; | |
192 | gAlice = (AliRun*)this; | |
193 | } | |
194 | ||
195 | //_____________________________________________________________________________ | |
196 | //AliFast::AliFast(const char *name, const char *title): TNamed(name,title) | |
197 | AliFast::AliFast(const char *name, const char *title): AliRun(name,title) | |
198 | { | |
199 | ||
200 | gAliFast = this; | |
201 | fVersion = 001; //AliFAST version number and release date | |
202 | fVersionDate = 150399; | |
203 | fTree = 0; | |
204 | fMode = 0; | |
205 | fDisplay = 0; | |
206 | ||
207 | SetDefaultParameters(); | |
208 | ||
209 | gROOT->GetListOfBrowsables()->Add(this,"AliFast"); | |
210 | ||
211 | // create the support list for the various lists of AliFast objects | |
212 | fMakers = new TList(); | |
213 | ||
214 | // create "standard" makers and add them to the list of makers (in AliFMaker constructor | |
215 | // Note that the order in which makers are added to the list of makers is important | |
216 | // makers will be processed in this order !! | |
217 | ||
218 | //fMCMaker = new AliFMCMaker("MCMaker","Make MC events"); | |
219 | fTrackMaker = new AliFTrackMaker("TrackMaker","Make AliFast tracks"); | |
220 | //create detector | |
221 | fDet = new AliFDet("Detector","Make AliFast detector"); | |
222 | } | |
223 | ||
224 | //_____________________________________________________________________________ | |
225 | AliFast::~AliFast() | |
226 | { | |
227 | // fMakers->Delete(); | |
228 | // delete fMakers; | |
229 | } | |
230 | ||
231 | ||
232 | //______________________________________________________________________________ | |
233 | void AliFast::Browse(TBrowser *b) | |
234 | { | |
235 | ||
236 | if( b == 0) return; | |
237 | ||
238 | if (fTree) b->Add(fTree,fTree->GetName()); | |
239 | // fca | |
240 | b->Add(&fHistBrowser, "Histograms"); | |
241 | b->Add(&fBigBang, "BigBang"); | |
242 | // fca | |
243 | ||
244 | TIter next(fMakers); | |
245 | AliFMaker *maker; | |
246 | while ((maker = (AliFMaker*)next())) { | |
247 | b->Add(maker,maker->GetName()); | |
248 | } | |
249 | } | |
250 | ||
251 | //_____________________________________________________________________________ | |
252 | void AliFast::Clear(Option_t *option) | |
253 | { | |
254 | // Reset lists of event objects | |
255 | TIter next(fMakers); | |
256 | AliFMaker *maker; | |
257 | while ((maker = (AliFMaker*)next())) { | |
258 | maker->Clear(option); | |
259 | } | |
260 | //fca if (fDisplay) fDisplay->Clear(); | |
261 | } | |
262 | ||
263 | //_____________________________________________________________________________ | |
264 | void AliFast::Draw(Option_t *option) | |
265 | { | |
266 | // Insert current event in graphics pad list | |
267 | ||
268 | // Check if the Event Display object has been created | |
269 | if (!fDisplay) { | |
270 | Error("Draw","You must create an AliFDisplay object first"); | |
271 | return; | |
272 | } | |
273 | ||
274 | //fca fDisplay->Draw(option); | |
275 | } | |
276 | ||
277 | //_____________________________________________________________________________ | |
278 | void AliFast::GetTreeEvent(Int_t event) | |
279 | { | |
280 | // Read event from Tree | |
281 | if (fTree) fTree->GetEvent(event); | |
282 | fEvent = event; | |
283 | } | |
284 | ||
285 | //_____________________________________________________________________________ | |
286 | void AliFast::Init() | |
287 | { | |
288 | // Initialise detector | |
289 | AliFDet *detector=gAliFast->Detector(); | |
290 | detector->InitDetParam(); | |
291 | ||
292 | // Initialise makers | |
293 | TIter next(fMakers); | |
294 | AliFMaker *maker; | |
295 | TObject *objfirst, *objlast; | |
296 | while ((maker = (AliFMaker*)next())) { | |
297 | // save last created histogram in current Root directory | |
298 | objlast = gDirectory->GetList()->Last(); | |
299 | ||
300 | // Initialise maker | |
301 | maker->Init(); | |
302 | ||
303 | // Add Maker histograms in Maker list of histograms | |
304 | if (objlast) objfirst = gDirectory->GetList()->After(objlast); | |
305 | else objfirst = gDirectory->GetList()->First(); | |
306 | while (objfirst) { | |
307 | maker->Histograms()->Add(objfirst); | |
308 | objfirst = gDirectory->GetList()->After(objfirst); | |
309 | } | |
310 | } | |
311 | ||
312 | } | |
313 | ||
314 | //_____________________________________________________________________________ | |
315 | void AliFast::Paint(Option_t *option) | |
316 | { | |
317 | // Paint AliFast objects | |
318 | ||
319 | //fca fDisplay->Paint(option); | |
320 | } | |
321 | ||
322 | //_____________________________________________________________________________ | |
323 | void AliFast::PrintInfo() | |
324 | { | |
325 | // Gives information about versions etc. | |
326 | printf("\n\n"); | |
327 | printf("**************************************************************\n"); | |
328 | printf("* AliFast version:00%1d last update %6d *\n", | |
329 | fVersion, fVersionDate); | |
330 | printf("**************************************************************\n"); | |
331 | printf("* *\n"); | |
332 | printf("* Simulates and reconstructs events on particle level *\n"); | |
333 | printf("* Package by: Yiota Foka and Elzbieta Richter-Was *\n"); | |
334 | printf("* Design based on ATLFast++ *\n"); | |
335 | printf("* by R. Brun and E. Richter-Was *\n"); | |
336 | printf("**************************************************************\n"); | |
337 | printf("\n\n"); | |
338 | ||
339 | // Print info for detector geometry | |
340 | AliFDet *detector=gAliFast->Detector(); | |
341 | detector->PrintDetInfo(); | |
342 | ||
343 | // Print info for all defined Makers | |
344 | TIter next(fMakers); | |
345 | AliFMaker *maker; | |
346 | while ((maker = (AliFMaker*)next())) { | |
347 | maker->PrintInfo(); | |
348 | } | |
349 | } | |
350 | ||
351 | //_____________________________________________________________________________ | |
352 | void AliFast::FillTree() | |
353 | { | |
354 | // Fill the ROOT tree, looping on all active branches | |
355 | ||
356 | // Clean generated particles (depending on option Save) | |
357 | //MCMaker()->CleanParticles(); | |
358 | ||
359 | // Now ready to fill the Root Tree | |
360 | if(fTree) fTree->Fill(); | |
361 | } | |
362 | ||
363 | //_____________________________________________________________________________ | |
364 | void AliFast::InitChain(TChain *chain) | |
365 | { | |
366 | // Initialize branch addresses for all makers in a TChain | |
367 | ||
368 | if (chain == 0) return; | |
369 | ||
370 | fTree = chain; | |
371 | ||
372 | TIter next(fMakers); | |
373 | AliFMaker *maker; | |
374 | while ((maker = (AliFMaker*)next())) { | |
375 | maker->SetChainAddress(chain); | |
376 | } | |
377 | } | |
378 | ||
379 | //_____________________________________________________________________________ | |
380 | void AliFast::MakeTree(const char* name, const char*title) | |
381 | { | |
382 | // Create a ROOT tree | |
383 | // Loop on all makers to create the Root branch (if any) | |
384 | ||
385 | if (fTree) return; | |
386 | ||
387 | fTree = new TTree(name,title); | |
388 | ||
389 | TIter next(fMakers); | |
390 | AliFMaker *maker; | |
391 | while ((maker = (AliFMaker*)next())) { | |
392 | maker->MakeBranch(); | |
393 | } | |
394 | } | |
395 | ||
396 | //_____________________________________________________________________________ | |
397 | void AliFast::SetDefaultParameters() | |
398 | { | |
399 | ||
400 | // Setters for flags and switches | |
401 | SetLuminosity(); | |
402 | SetBfield(); | |
403 | SetSmearing(); | |
404 | SetSUSYcodeLSP(); | |
405 | SetTrackFinding(); | |
406 | } | |
407 | ||
408 | //_____________________________________________________________________________ | |
409 | void AliFast::Make(Int_t i) | |
410 | { | |
411 | fEvent = i; | |
412 | ||
413 | // Loop on all makers | |
414 | TIter next(fMakers); | |
415 | AliFMaker *maker; | |
416 | while ((maker = (AliFMaker*)next())) { | |
417 | maker->Make(); | |
418 | } | |
419 | ||
420 | } | |
421 | ||
422 | //_____________________________________________________________________________ | |
423 | void AliFast::FillClone() | |
424 | { | |
425 | // Fill Makers fruits clones | |
426 | ||
427 | TIter next(fMakers); | |
428 | AliFMaker *maker; | |
429 | while ((maker = (AliFMaker*)next())) { | |
430 | maker->FillClone(); | |
431 | } | |
432 | } | |
433 | ||
434 | //_____________________________________________________________________________ | |
435 | void AliFast::Finish() | |
436 | { | |
437 | // Terminate a run | |
438 | // place to make operations on histograms, normalization,etc. | |
439 | ||
440 | TIter next(fMakers); | |
441 | AliFMaker *maker; | |
442 | while ((maker = (AliFMaker*)next())) { | |
443 | maker->Finish(); | |
444 | } | |
445 | } | |
446 | ||
447 | //_____________________________________________________________________________ | |
448 | void AliFast::SortDown(Int_t n1, Float_t *a, Int_t *index, Bool_t down) | |
449 | { | |
450 | // sort the n1 elements of array a. | |
451 | // In output the array index contains the indices of the sorted array. | |
452 | // if down is false sort in increasing order (default is decreasing order) | |
453 | // This is a translation of the CERNLIB routine sortzv (M101) | |
454 | // based on the quicksort algorithm | |
455 | ||
456 | Int_t i,i1,n,i2,i3,i33,i222,iswap,n2; | |
457 | Int_t i22 = 0; | |
458 | Float_t ai; | |
459 | n = n1; | |
460 | if (n <= 0) return; | |
461 | if (n == 1) {index[0] = 0; return;} | |
462 | for (i=0;i<n;i++) index[i] = i+1; | |
463 | for (i1=2;i1<=n;i1++) { | |
464 | i3 = i1; | |
465 | i33 = index[i3-1]; | |
466 | ai = a[i33-1]; | |
467 | while(1) { | |
468 | i2 = i3/2; | |
469 | if (i2 <= 0) break; | |
470 | i22 = index[i2-1]; | |
471 | if (ai <= a[i22-1]) break; | |
472 | index[i3-1] = i22; | |
473 | i3 = i2; | |
474 | } | |
475 | index[i3-1] = i33; | |
476 | } | |
477 | ||
478 | while(1) { | |
479 | i3 = index[n-1]; | |
480 | index[n-1] = index[0]; | |
481 | ai = a[i3-1]; | |
482 | n--; | |
483 | if(n-1 < 0) {index[0] = i3; break;} | |
484 | i1 = 1; | |
485 | while(2) { | |
486 | i2 = i1+i1; | |
487 | if (i2 <= n) i22 = index[i2-1]; | |
488 | if (i2-n > 0) {index[i1-1] = i3; break;} | |
489 | if (i2-n < 0) { | |
490 | i222 = index[i2]; | |
491 | if (a[i22-1] - a[i222-1] < 0) { | |
492 | i2++; | |
493 | i22 = i222; | |
494 | } | |
495 | } | |
496 | if (ai - a[i22-1] > 0) {index[i1-1] = i3; break;} | |
497 | index[i1-1] = i22; | |
498 | i1 = i2; | |
499 | } | |
500 | } | |
501 | if (!down) return; | |
502 | n2 = n1/2; | |
503 | for (i=0;i<n1;i++) index[i]--; | |
504 | for (i=0;i<n2;i++) { | |
505 | iswap = index[i]; | |
506 | index[i] = index[n1-i-1]; | |
507 | index[n1-i-1] = iswap; | |
508 | } | |
509 | } | |
510 | //______________________________________________________________________________ | |
511 | void AliFast::Streamer(TBuffer &R__b) | |
512 | { | |
513 | // Stream an object of class AliFast. | |
514 | ||
515 | if (R__b.IsReading()) { | |
a8a6107b | 516 | UInt_t R__s, R__c; |
65a39007 | 517 | if (!gAliFast) gAliFast = this; |
518 | gROOT->GetListOfBrowsables()->Add(this,"AliFast"); | |
a8a6107b | 519 | |
520 | Version_t R__v = R__b.ReadVersion(&R__s, &R__c); | |
521 | ||
522 | AliFast::Class()->ReadBuffer(R__b, this, R__v, R__s, R__c); | |
523 | ||
65a39007 | 524 | fTree = (TTree*)gDirectory->Get("T"); |
65a39007 | 525 | } else { |
a8a6107b | 526 | AliFast::Class()->WriteBuffer(R__b,this); |
65a39007 | 527 | } |
528 | } | |
529 | ||
530 | ||
531 | ||
532 | ||
533 |