05-jul-2001 NvE Clone() facility used in AddTrack() etc... of AliEvent & co. instead of
[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.3 2001/07/04 15:59:20 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 // Coding example to make an event consisting of a primary vertex,
56 // 2 secondary vertices and a calorimeter.
57 // --------------------------------------------------------------
58 // vp contains the tracks 1,2,3 and 4 (primary vertex)
59 // v1 contains the tracks 5,6 and 7   (sec. vertex)
60 // v2 contains the jets 1 and 2       (sec. vertex)
61 //
62 //        AliEvent evt;
63 //
64 // Specify the event object as the repository of all objects
65 // for the event building and physics analysis.
66 // 
67 //        evt.SetCalCopy(1);
68 //        evt.SetTrackCopy(1);
69 //
70 // Fill the event structure with the basic objects
71 // 
72 //        AliCalorimeter emcal;
73 //         ...
74 //         ... // code to fill the calorimeter data
75 //         ...
76 //
77 //        evt.AddCalorimeter(emcal);
78 //
79 //        AliTrack* tx=new AliTrack();
80 //        for (Int_t i=0; i<10; i++)
81 //        {
82 //         ...
83 //         ... // code to fill the track data
84 //         ...
85 //         evt.AddTrack(tx);
86 //         tx->Reset(); 
87 //        }
88 //
89 //        if (tx)
90 //        {
91 //         delete tx;
92 //         tx=0;
93 //        }
94 //
95 // Build the event structure (vertices, jets, ...) for physics analysis
96 // based on the basic objects from the event repository.
97 //
98 //        AliJet j1,j2;
99 //        for (Int_t i=0; i<evt.GetNtracks(); i++)
100 //        {
101 //         tx=evt.GetTrack(i);
102 //         ...
103 //         ... // code to fill the jet data
104 //         ...
105 //        }
106 //
107 //        AliVertex vp;
108 //        tx=evt.GetTrack(1);
109 //        vp.AddTrack(tx);
110 //        tx=evt.GetTrack(2);
111 //        vp.AddTrack(tx);
112 //        tx=evt.GetTrack(3);
113 //        vp.AddTrack(tx);
114 //        tx=evt.GetTrack(4);
115 //        vp.AddTrack(tx);
116 //
117 //        Float_t rp[3]={2.4,0.1,-8.5};
118 //        vp.SetPosition(rp,"car");
119 //
120 //        AliVertex v1;
121 //        tx=evt.GetTrack(5);
122 //        v1.AddTrack(tx);
123 //        tx=evt.GetTrack(6);
124 //        v1.AddTrack(tx);
125 //        tx=evt.GetTrack(7);
126 //        v1.AddTrack(tx);
127 //
128 //        Float_t r1[3]={1.6,-3.2,5.7};
129 //        v1.SetPosition(r1,"car");
130 //
131 //
132 //        AliVertex v2;
133 //        v2.SetJetCopy(1);
134 //        v2.AddJet(j1);
135 //        v2.AddJet(j2);
136 //
137 //        Float_t r2[3]={6.2,4.8,1.3};
138 //        v2.SetPosition(r2,"car");
139 //
140 // Specify the vertices v1 and v2 as secondary vertices of the primary
141 //
142 //        vp.SetVertexCopy(1);
143 //        vp.AddVertex(v1);
144 //        vp.AddVertex(v2);
145 //
146 // Enter the physics structures into the event
147 //        evt.SetVertexCopy(1);
148 //        evt.AddVertex(vp,0);
149 //
150 // The jets j1 and j2 are already available via sec. vertex v2,
151 // but can be made available also from the event itself if desired.
152 //        AliJet* jx;
153 //        jx=v2.GetJet(1);
154 //        evt.AddJet(jx,0); 
155 //        jx=v2.GetJet(2);
156 //        evt.AddJet(jx,0); 
157 // 
158 //        evt.Info("sph");
159 //        v1.ListAll();
160 //        v2.List("cyl");
161 //
162 //        Float_t etot=evt.GetEnergy();
163 //        Ali3Vector ptot=evt.Get3Momentum();
164 //        Float_t loc[3];
165 //        evt.GetPosition(loc,"sph");
166 //        AliPosition r=v1.GetPosition();
167 //        r.Info(); 
168 //        Int_t nt=v2.GetNtracks();
169 //        AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
170 //
171 //        evt.List();
172 //
173 //        Int_t nv=evt.GetNvtx();
174 //        AliVertex* vx=evt.GetVertex(1); // Access primary vertex
175 //        Float_t e=vx->GetEnergy();
176 //
177 //        Float_t M=evt.GetInvmass(); 
178 //
179 // Reconstruct the event from scratch
180 //
181 //        evt.Reset();
182 //        evt.SetNvmax(25); // Increase initial no. of sec. vertices
183 //        ...
184 //        ... // code to create tracks etc... 
185 //        ...
186 //
187 // Note : All quantities are in GeV, GeV/c or GeV/c**2
188 //
189 //--- Author: Nick van Eijndhoven 27-may-2001 UU-SAP Utrecht
190 //- Modified: NvE $Date: 2001/07/04 15:59:20 $ UU-SAP Utrecht
191 ///////////////////////////////////////////////////////////////////////////
192
193 #include "AliEvent.h"
194  
195 ClassImp(AliEvent) // Class implementation to enable ROOT I/O
196  
197 AliEvent::AliEvent()
198 {
199 // Default constructor.
200 // All variables initialised to default values.
201  fDaytime.Set();
202  fRun=0;
203  fEvent=0;
204  fNcals=0;
205  fCalorimeters=0;
206  fCalCopy=0;
207 }
208 ///////////////////////////////////////////////////////////////////////////
209 AliEvent::AliEvent(Int_t n): AliVertex(n)
210 {
211 // Create an event to hold initially a maximum of n tracks
212 // All variables initialised to default values
213  fDaytime.Set();
214  fRun=0;
215  fEvent=0;
216  fNcals=0;
217  fCalorimeters=0;
218  fCalCopy=0;
219 }
220 ///////////////////////////////////////////////////////////////////////////
221 AliEvent::~AliEvent()
222 {
223 // Default destructor
224  if (fCalorimeters)
225  {
226   if (fCalCopy) fCalorimeters->Delete();
227   delete fCalorimeters;
228   fCalorimeters=0;
229  }
230 }
231 ///////////////////////////////////////////////////////////////////////////
232 void AliEvent::Reset()
233 {
234 // Reset all variables to default values
235 // The max. number of tracks is set to the initial value again
236 // The max. number of vertices is set to the default value again
237  fDaytime.Set();
238  fRun=0;
239  fEvent=0;
240
241  fNcals=0;
242  if (fCalorimeters)
243  {
244   if (fCalCopy) fCalorimeters->Delete();
245   delete fCalorimeters;
246   fCalorimeters=0;
247  }
248
249  AliVertex::Reset();
250 }
251 ///////////////////////////////////////////////////////////////////////////
252 void AliEvent::SetDayTime(TDatime& stamp)
253 {
254 // Set the date and time stamp for this event
255  fDaytime=stamp;
256 }
257 ///////////////////////////////////////////////////////////////////////////
258 void AliEvent::SetRunNumber(Int_t run)
259 {
260 // Set the run number for this event
261  fRun=run;
262 }
263 ///////////////////////////////////////////////////////////////////////////
264 void AliEvent::SetEventNumber(Int_t evt)
265 {
266 // Set the event number for this event
267  fEvent=evt;
268 }
269 ///////////////////////////////////////////////////////////////////////////
270 TDatime AliEvent::GetDayTime()
271 {
272 // Provide the date and time stamp for this event
273  return fDaytime;
274 }
275 ///////////////////////////////////////////////////////////////////////////
276 Int_t AliEvent::GetRunNumber()
277 {
278 // Provide the run number for this event
279  return fRun;
280 }
281 ///////////////////////////////////////////////////////////////////////////
282 Int_t AliEvent::GetEventNumber()
283 {
284 // Provide the event number for this event
285  return fEvent;
286 }
287 ///////////////////////////////////////////////////////////////////////////
288 void AliEvent::HeaderInfo()
289 {
290 // Provide event header information
291  Int_t date=fDaytime.GetDate();
292  Int_t time=fDaytime.GetTime();
293
294  Int_t year=date/10000;
295  Int_t month=(date%10000)/100;
296  Int_t day=date%100;
297  Int_t hh=time/10000;
298  Int_t mm=(time%10000)/100;
299  Int_t ss=time%100;
300
301  char* c[12]={"jan","feb","mar","apr","may","jun",
302               "jul","aug","sep","oct","nov","dec"};
303
304  cout << " *AliEvent::Info* Run : " << fRun << " Event : " << fEvent;
305  cout.fill('0');
306  cout << " Date : " << setw(2) << day << "-" << c[month-1] << "-" << year
307       << " Time : " << setw(2) << hh << ":" << setw(2) << mm << ":" << setw(2) << ss;
308  cout.fill(' ');
309  cout << " Ncalorimeters : " << fNcals << endl;
310 }
311 ///////////////////////////////////////////////////////////////////////////
312 void AliEvent::Info(TString f)
313 {
314 // Provide event information within the coordinate frame f
315  HeaderInfo();
316  AliVertex::Info(f);
317
318 ///////////////////////////////////////////////////////////////////////////
319 Int_t AliEvent::GetNcalorimeters()
320 {
321 // Provide the number of stored calorimeter systems
322  return fNcals;
323
324 ///////////////////////////////////////////////////////////////////////////
325 void AliEvent::AddCalorimeter(AliCalorimeter& c)
326 {
327 // Add a calorimeter system to the event
328  if (!fCalorimeters) fCalorimeters=new TObjArray();
329  
330  // Add the calorimeter system to this event
331  fNcals++;
332  if (fCalCopy)
333  {
334   fCalorimeters->AddLast(c.Clone());
335  }
336  else
337  {
338   fCalorimeters->AddLast(&c);
339  }
340 }
341 ///////////////////////////////////////////////////////////////////////////
342 void AliEvent::SetCalCopy(Int_t j)
343 {
344 // (De)activate the creation of private copies of the added calorimeters.
345 // j=0 ==> No private copies are made; pointers of original cals. are stored.
346 // j=1 ==> Private copies of the cals. are made and these pointers are stored.
347 //
348 // Note : Once the storage contains pointer(s) to AliCalorimeter(s) one cannot
349 //        change the CalCopy mode anymore.
350 //        To change the CalCopy mode for an existing AliEvent containing
351 //        calorimeters one first has to invoke Reset().
352  if (!fCalorimeters)
353  {
354   if (j==0 || j==1)
355   {
356    fCalCopy=j;
357   }
358   else
359   {
360    cout << "*AliEvent::SetCalCopy* Invalid argument : " << j << endl;
361   }
362  }
363  else
364  {
365   cout << "*AliEvent::SetCalCopy* Storage already contained calorimeters."
366        << "  ==> CalCopy mode not changed." << endl; 
367  }
368 }
369 ///////////////////////////////////////////////////////////////////////////
370 Int_t AliEvent::GetCalCopy()
371 {
372 // Provide value of the CalCopy mode.
373 // 0 ==> No private copies are made; pointers of original cals. are stored.
374 // 1 ==> Private copies of the cals. are made and these pointers are stored.
375  return fCalCopy;
376 }
377 ///////////////////////////////////////////////////////////////////////////
378 AliCalorimeter* AliEvent::GetCalorimeter(Int_t i)
379 {
380 // Return the i-th calorimeter of this event
381  if (!fCalorimeters)
382  {
383   cout << " *AliEvent::GetCalorimeter* No calorimeters present." << endl;
384   return 0;
385  }
386  else
387  {
388   if (i<=0 || i>fNcals)
389   {
390    cout << " *AliEvent::GetCalorimeter* Invalid argument i : " << i
391         << " Ncals = " << fNcals << endl;
392    return 0;
393   }
394   else
395   {
396    return (AliCalorimeter*)fCalorimeters->At(i-1);
397   }
398  }
399 }
400 ///////////////////////////////////////////////////////////////////////////
401 AliCalorimeter* AliEvent::GetCalorimeter(TString name)
402 {
403 // Return the calorimeter with name tag "name"
404  if (!fCalorimeters)
405  {
406   cout << " *AliEvent::GetCalorimeter* No calorimeters present." << endl;
407   return 0;
408  }
409  else
410  {
411   AliCalorimeter* cx;
412   TString s;
413   for (Int_t i=0; i<fNcals; i++)
414   {
415    cx=(AliCalorimeter*)fCalorimeters->At(i);
416    if (cx)
417    {
418     s=cx->GetName();
419     if (s == name) return cx;
420    }
421   }
422
423   return 0; // No matching name found
424  }
425 }
426 ///////////////////////////////////////////////////////////////////////////
427