30-nov-2002 NvE Vertex position errors based on fResolution introduced in AliCollider...
[u/mrichter/AliRoot.git] / RALICE / AliEvent.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: AliEvent.cxx,v 1.7 2002/06/25 09:38:28 nick Exp $
17
18 ///////////////////////////////////////////////////////////////////////////
19 // Class AliEvent
20 // Creation and investigation of an Alice physics event.
21 // An AliEvent can be constructed by adding AliTracks, Alivertices, AliJets
22 // and/or AliCalorimeters.
23 //
24 // The basic functionality of AliEvent is identical to the one of AliVertex.
25 // So, an AliEvent may be used as the primary vertex with some additional
26 // functionality compared to AliVertex.
27 //
28 // To provide maximal flexibility to the user, the two modes of track/jet/vertex
29 // storage as described in AliJet and AliVertex can be used.
30 // In addition an identical structure is provided for the storage of AliCalorimeter
31 // objects, which can be selected by means of the memberfunction SetCalCopy().
32 //
33 // a) SetCalCopy(0) (which is the default).
34 //    Only the pointers of the 'added' calorimeters are stored.
35 //    This mode is typically used by making cal. studies based on a fixed set
36 //    of calorimeters which stays under user control or is kept on an external
37 //    file/tree. 
38 //    In this way the AliEvent just represents a 'logical structure' for the
39 //    physics analysis.
40 //
41 //    Note :
42 //    Modifications made to the original calorimeters also affect the AliCalorimeter
43 //    objects which are stored in the AliEvent. 
44 //
45 // b) SetCalCopy(1).
46 //    Of every 'added' calorimeter a private copy will be made of which the pointer
47 //    will be stored.
48 //    In this way the AliEvent represents an entity on its own and modifications
49 //    made to the original calorimeters do not affect the AliCalorimeter objects
50 //    which are stored in the AliEvent. 
51 //    This mode will allow 'adding' many different AliCalorimeters into an AliEvent by
52 //    creating only one AliCalorimeter instance in the main programme and using the
53 //    AliCalorimeter::Reset() and AliCalorimeter parameter setting memberfunctions.
54 //
55 // See also the documentation provided for the memberfunction SetOwner(). 
56 //
57 // Coding example to make an event consisting of a primary vertex,
58 // 2 secondary vertices and a calorimeter.
59 // --------------------------------------------------------------
60 // vp contains the tracks 1,2,3 and 4 (primary vertex)
61 // v1 contains the tracks 5,6 and 7   (sec. vertex)
62 // v2 contains the jets 1 and 2       (sec. vertex)
63 //
64 //        AliEvent evt;
65 //
66 // Specify the event object as the repository of all objects
67 // for the event building and physics analysis.
68 // 
69 //        evt.SetCalCopy(1);
70 //        evt.SetTrackCopy(1);
71 //
72 // Fill the event structure with the basic objects
73 // 
74 //        AliCalorimeter emcal;
75 //         ...
76 //         ... // code to fill the calorimeter data
77 //         ...
78 //
79 //        evt.AddCalorimeter(emcal);
80 //
81 //        AliTrack* tx=new AliTrack();
82 //        for (Int_t i=0; i<10; i++)
83 //        {
84 //         ...
85 //         ... // code to fill the track data
86 //         ...
87 //         evt.AddTrack(tx);
88 //         tx->Reset(); 
89 //        }
90 //
91 //        if (tx)
92 //        {
93 //         delete tx;
94 //         tx=0;
95 //        }
96 //
97 // Build the event structure (vertices, jets, ...) for physics analysis
98 // based on the basic objects from the event repository.
99 //
100 //        AliJet j1,j2;
101 //        for (Int_t i=0; i<evt.GetNtracks(); i++)
102 //        {
103 //         tx=evt.GetTrack(i);
104 //         ...
105 //         ... // code to fill the jet data
106 //         ...
107 //        }
108 //
109 //        AliVertex vp;
110 //        tx=evt.GetTrack(1);
111 //        vp.AddTrack(tx);
112 //        tx=evt.GetTrack(2);
113 //        vp.AddTrack(tx);
114 //        tx=evt.GetTrack(3);
115 //        vp.AddTrack(tx);
116 //        tx=evt.GetTrack(4);
117 //        vp.AddTrack(tx);
118 //
119 //        Float_t rp[3]={2.4,0.1,-8.5};
120 //        vp.SetPosition(rp,"car");
121 //
122 //        AliVertex v1;
123 //        tx=evt.GetTrack(5);
124 //        v1.AddTrack(tx);
125 //        tx=evt.GetTrack(6);
126 //        v1.AddTrack(tx);
127 //        tx=evt.GetTrack(7);
128 //        v1.AddTrack(tx);
129 //
130 //        Float_t r1[3]={1.6,-3.2,5.7};
131 //        v1.SetPosition(r1,"car");
132 //
133 //
134 //        AliVertex v2;
135 //        v2.SetJetCopy(1);
136 //        v2.AddJet(j1);
137 //        v2.AddJet(j2);
138 //
139 //        Float_t r2[3]={6.2,4.8,1.3};
140 //        v2.SetPosition(r2,"car");
141 //
142 // Specify the vertices v1 and v2 as secondary vertices of the primary
143 //
144 //        vp.SetVertexCopy(1);
145 //        vp.AddVertex(v1);
146 //        vp.AddVertex(v2);
147 //
148 // Enter the physics structures into the event
149 //        evt.SetVertexCopy(1);
150 //        evt.AddVertex(vp,0);
151 //
152 // The jets j1 and j2 are already available via sec. vertex v2,
153 // but can be made available also from the event itself if desired.
154 //        AliJet* jx;
155 //        jx=v2.GetJet(1);
156 //        evt.AddJet(jx,0); 
157 //        jx=v2.GetJet(2);
158 //        evt.AddJet(jx,0); 
159 // 
160 //        evt.Info("sph");
161 //        v1.ListAll();
162 //        v2.List("cyl");
163 //
164 //        Float_t etot=evt.GetEnergy();
165 //        Ali3Vector ptot=evt.Get3Momentum();
166 //        Float_t loc[3];
167 //        evt.GetPosition(loc,"sph");
168 //        AliPosition r=v1.GetPosition();
169 //        r.Info(); 
170 //        Int_t nt=v2.GetNtracks();
171 //        AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
172 //
173 //        evt.List();
174 //
175 //        Int_t nv=evt.GetNvtx();
176 //        AliVertex* vx=evt.GetVertex(1); // Access primary vertex
177 //        Float_t e=vx->GetEnergy();
178 //
179 //        Float_t M=evt.GetInvmass(); 
180 //
181 // Reconstruct the event from scratch
182 //
183 //        evt.Reset();
184 //        evt.SetNvmax(25); // Increase initial no. of sec. vertices
185 //        ...
186 //        ... // code to create tracks etc... 
187 //        ...
188 //
189 // Note : All quantities are in GeV, GeV/c or GeV/c**2
190 //
191 //--- Author: Nick van Eijndhoven 27-may-2001 UU-SAP Utrecht
192 //- Modified: NvE $Date: 2002/06/25 09:38:28 $ UU-SAP Utrecht
193 ///////////////////////////////////////////////////////////////////////////
194
195 #include "AliEvent.h"
196  
197 ClassImp(AliEvent) // Class implementation to enable ROOT I/O
198  
199 AliEvent::AliEvent()
200 {
201 // Default constructor.
202 // All variables initialised to default values.
203  fDaytime.Set();
204  fRun=0;
205  fEvent=0;
206  fAproj=0;
207  fZproj=0;
208  fPnucProj=0;
209  fIdProj=0;
210  fAtarg=0;
211  fZtarg=0;
212  fPnucTarg=0;
213  fIdTarg=0;
214  fNcals=0;
215  fCalorimeters=0;
216  fCalCopy=0;
217 }
218 ///////////////////////////////////////////////////////////////////////////
219 AliEvent::AliEvent(Int_t n): AliVertex(n)
220 {
221 // Create an event to hold initially a maximum of n tracks
222 // All variables initialised to default values
223  cout << "AliEvent init with n = " << n << endl;
224  fDaytime.Set();
225  fRun=0;
226  fEvent=0;
227  fAproj=0;
228  fZproj=0;
229  fPnucProj=0;
230  fIdProj=0;
231  fAtarg=0;
232  fZtarg=0;
233  fPnucTarg=0;
234  fIdTarg=0;
235  fNcals=0;
236  fCalorimeters=0;
237  fCalCopy=0;
238 }
239 ///////////////////////////////////////////////////////////////////////////
240 AliEvent::~AliEvent()
241 {
242 // Default destructor
243  if (fCalorimeters)
244  {
245   delete fCalorimeters;
246   fCalorimeters=0;
247  }
248 }
249 ///////////////////////////////////////////////////////////////////////////
250 void AliEvent::Reset()
251 {
252 // Reset all variables to default values
253 // The max. number of tracks is set to the initial value again
254 // The max. number of vertices is set to the default value again
255 // Note : The CalCopy mode is maintained as it was set by the user before.
256  fDaytime.Set();
257  fRun=0;
258  fEvent=0;
259  fAproj=0;
260  fZproj=0;
261  fPnucProj=0;
262  fIdProj=0;
263  fAtarg=0;
264  fZtarg=0;
265  fPnucTarg=0;
266  fIdTarg=0;
267
268  fNcals=0;
269  if (fCalorimeters)
270  {
271   delete fCalorimeters;
272   fCalorimeters=0;
273  }
274
275  AliVertex::Reset();
276 }
277 ///////////////////////////////////////////////////////////////////////////
278 void AliEvent::SetOwner(Bool_t own)
279 {
280 // Set ownership of all added objects. 
281 // The default parameter is own=kTRUE.
282 //
283 // Invokation of this memberfunction also sets all the copy modes
284 // (e.g. TrackCopy & co.) according to the value of own.
285 //
286 // This function (with own=kTRUE) is particularly useful when reading data
287 // from a tree/file, since Reset() will then actually remove all the
288 // added objects from memory irrespective of the copy mode settings
289 // during the tree/file creation process. In this way it provides a nice way
290 // of preventing possible memory leaks in the reading/analysis process.
291 //
292 // In addition this memberfunction can also be used as a shortcut to set all
293 // copy modes in one go during a tree/file creation process.
294 // However, in this case the user has to take care to only set/change the
295 // ownership (and copy mode) for empty objects (e.g. newly created objects
296 // or after invokation of the Reset() memberfunction) otherwise it will
297 // very likely result in inconsistent destructor behaviour.
298
299  Int_t mode=1;
300  if (!own) mode=0;
301  if (fCalorimeters) fCalorimeters->SetOwner(own);
302  fCalCopy=mode;
303
304  AliVertex::SetOwner(own);
305 }
306 ///////////////////////////////////////////////////////////////////////////
307 void AliEvent::SetDayTime(TDatime& stamp)
308 {
309 // Set the date and time stamp for this event
310  fDaytime=stamp;
311 }
312 ///////////////////////////////////////////////////////////////////////////
313 void AliEvent::SetRunNumber(Int_t run)
314 {
315 // Set the run number for this event
316  fRun=run;
317 }
318 ///////////////////////////////////////////////////////////////////////////
319 void AliEvent::SetEventNumber(Int_t evt)
320 {
321 // Set the event number for this event
322  fEvent=evt;
323 }
324 ///////////////////////////////////////////////////////////////////////////
325 TDatime AliEvent::GetDayTime()
326 {
327 // Provide the date and time stamp for this event
328  return fDaytime;
329 }
330 ///////////////////////////////////////////////////////////////////////////
331 Int_t AliEvent::GetRunNumber()
332 {
333 // Provide the run number for this event
334  return fRun;
335 }
336 ///////////////////////////////////////////////////////////////////////////
337 Int_t AliEvent::GetEventNumber()
338 {
339 // Provide the event number for this event
340  return fEvent;
341 }
342 ///////////////////////////////////////////////////////////////////////////
343 void AliEvent::SetProjectile(Int_t a,Int_t z,Double_t pnuc,Int_t id)
344 {
345 // Set the projectile A, Z, momentum per nucleon and user defined particle ID.
346 // By default the particle ID is set to zero.
347  fAproj=a;
348  fZproj=z;
349  fPnucProj=pnuc;
350  fIdProj=id;
351 }
352 ///////////////////////////////////////////////////////////////////////////
353 Int_t AliEvent::GetProjectileA()
354 {
355 // Provide the projectile A value.
356  return fAproj;
357 }
358 ///////////////////////////////////////////////////////////////////////////
359 Int_t AliEvent::GetProjectileZ()
360 {
361 // Provide the projectile Z value.
362  return fZproj;
363 }
364 ///////////////////////////////////////////////////////////////////////////
365 Double_t AliEvent::GetProjectilePnuc()
366 {
367 // Provide the projectile momentum value per nucleon.
368  return fPnucProj;
369 }
370 ///////////////////////////////////////////////////////////////////////////
371 Int_t AliEvent::GetProjectileId()
372 {
373 // Provide the user defined particle ID of the projectile.
374  return fIdProj;
375 }
376 ///////////////////////////////////////////////////////////////////////////
377 void AliEvent::SetTarget(Int_t a,Int_t z,Double_t pnuc,Int_t id)
378 {
379 // Set the target A, Z, momentum per nucleon and user defined particle ID.
380 // By default the particle ID is set to zero.
381  fAtarg=a;
382  fZtarg=z;
383  fPnucTarg=pnuc;
384  fIdTarg=id;
385 }
386 ///////////////////////////////////////////////////////////////////////////
387 Int_t AliEvent::GetTargetA()
388 {
389 // Provide the target A value.
390  return fAtarg;
391 }
392 ///////////////////////////////////////////////////////////////////////////
393 Int_t AliEvent::GetTargetZ()
394 {
395 // Provide the target Z value.
396  return fZtarg;
397 }
398 ///////////////////////////////////////////////////////////////////////////
399 Double_t AliEvent::GetTargetPnuc()
400 {
401 // Provide the target momentum value per nucleon.
402  return fPnucTarg;
403 }
404 ///////////////////////////////////////////////////////////////////////////
405 Int_t AliEvent::GetTargetId()
406 {
407 // Provide the user defined particle ID of the target.
408  return fIdTarg;
409 }
410 ///////////////////////////////////////////////////////////////////////////
411 void AliEvent::HeaderInfo()
412 {
413 // Provide event header information
414  Int_t date=fDaytime.GetDate();
415  Int_t time=fDaytime.GetTime();
416
417  Int_t year=date/10000;
418  Int_t month=(date%10000)/100;
419  Int_t day=date%100;
420  Int_t hh=time/10000;
421  Int_t mm=(time%10000)/100;
422  Int_t ss=time%100;
423
424  char* c[12]={"jan","feb","mar","apr","may","jun",
425               "jul","aug","sep","oct","nov","dec"};
426
427  cout << " *AliEvent::Info* Run : " << fRun << " Event : " << fEvent;
428  cout.fill('0');
429  cout << " Date : " << setw(2) << day << "-" << c[month-1] << "-" << year
430       << " Time : " << setw(2) << hh << ":" << setw(2) << mm << ":" << setw(2) << ss;
431  cout.fill(' ');
432  cout << " Ncalorimeters : " << fNcals << endl;
433 }
434 ///////////////////////////////////////////////////////////////////////////
435 void AliEvent::Info(TString f)
436 {
437 // Provide event information within the coordinate frame f
438  HeaderInfo();
439  AliVertex::Info(f);
440
441 ///////////////////////////////////////////////////////////////////////////
442 Int_t AliEvent::GetNcalorimeters()
443 {
444 // Provide the number of stored calorimeter systems
445  return fNcals;
446
447 ///////////////////////////////////////////////////////////////////////////
448 void AliEvent::AddCalorimeter(AliCalorimeter& c)
449 {
450 // Add a calorimeter system to the event
451  if (!fCalorimeters)
452  {
453   fCalorimeters=new TObjArray();
454   if (fCalCopy) fCalorimeters->SetOwner();
455  }
456  
457  // Add the calorimeter system to this event
458  fNcals++;
459  if (fCalCopy)
460  {
461   fCalorimeters->AddLast((AliCalorimeter*)c.Clone());
462  }
463  else
464  {
465   fCalorimeters->AddLast(&c);
466  }
467 }
468 ///////////////////////////////////////////////////////////////////////////
469 void AliEvent::SetCalCopy(Int_t j)
470 {
471 // (De)activate the creation of private copies of the added calorimeters.
472 // j=0 ==> No private copies are made; pointers of original cals. are stored.
473 // j=1 ==> Private copies of the cals. are made and these pointers are stored.
474 //
475 // Note : Once the storage contains pointer(s) to AliCalorimeter(s) one cannot
476 //        change the CalCopy mode anymore.
477 //        To change the CalCopy mode for an existing AliEvent containing
478 //        calorimeters one first has to invoke Reset().
479  if (!fCalorimeters)
480  {
481   if (j==0 || j==1)
482   {
483    fCalCopy=j;
484   }
485   else
486   {
487    cout << "*AliEvent::SetCalCopy* Invalid argument : " << j << endl;
488   }
489  }
490  else
491  {
492   cout << "*AliEvent::SetCalCopy* Storage already contained calorimeters."
493        << "  ==> CalCopy mode not changed." << endl; 
494  }
495 }
496 ///////////////////////////////////////////////////////////////////////////
497 Int_t AliEvent::GetCalCopy()
498 {
499 // Provide value of the CalCopy mode.
500 // 0 ==> No private copies are made; pointers of original cals. are stored.
501 // 1 ==> Private copies of the cals. are made and these pointers are stored.
502  return fCalCopy;
503 }
504 ///////////////////////////////////////////////////////////////////////////
505 AliCalorimeter* AliEvent::GetCalorimeter(Int_t i)
506 {
507 // Return the i-th calorimeter of this event
508  if (!fCalorimeters)
509  {
510   cout << " *AliEvent::GetCalorimeter* No calorimeters present." << endl;
511   return 0;
512  }
513  else
514  {
515   if (i<=0 || i>fNcals)
516   {
517    cout << " *AliEvent::GetCalorimeter* Invalid argument i : " << i
518         << " Ncals = " << fNcals << endl;
519    return 0;
520   }
521   else
522   {
523    return (AliCalorimeter*)fCalorimeters->At(i-1);
524   }
525  }
526 }
527 ///////////////////////////////////////////////////////////////////////////
528 AliCalorimeter* AliEvent::GetCalorimeter(TString name)
529 {
530 // Return the calorimeter with name tag "name"
531  if (!fCalorimeters)
532  {
533   cout << " *AliEvent::GetCalorimeter* No calorimeters present." << endl;
534   return 0;
535  }
536  else
537  {
538   AliCalorimeter* cx;
539   TString s;
540   for (Int_t i=0; i<fNcals; i++)
541   {
542    cx=(AliCalorimeter*)fCalorimeters->At(i);
543    if (cx)
544    {
545     s=cx->GetName();
546     if (s == name) return cx;
547    }
548   }
549
550   return 0; // No matching name found
551  }
552 }
553 ///////////////////////////////////////////////////////////////////////////
554