05-jul-2001 NvE Clone() facility used in AddTrack() etc... of AliEvent & co. instead of
[u/mrichter/AliRoot.git] / RALICE / AliEvent.cxx
CommitLineData
d16062ac 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
35044448 16// $Id: AliEvent.cxx,v 1.3 2001/07/04 15:59:20 nick Exp $
d16062ac 17
18///////////////////////////////////////////////////////////////////////////
19// Class AliEvent
20// Creation and investigation of an Alice physics event.
7849a8ab 21// An AliEvent can be constructed by adding AliTracks, Alivertices, AliJets
22// and/or AliCalorimeters.
d16062ac 23//
24// The basic functionality of AliEvent is identical to the one of AliVertex.
35044448 25// So, an AliEvent may be used as the primary vertex with some additional
26// functionality compared to AliVertex.
d16062ac 27//
7849a8ab 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.
35044448 40//
41// Note :
7849a8ab 42// Modifications made to the original calorimeters also affect the AliCalorimeter
43// objects which are stored in the AliEvent.
35044448 44//
7849a8ab 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.
d16062ac 57// --------------------------------------------------------------
7849a8ab 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//
7849a8ab 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//
35044448 72// AliCalorimeter emcal;
73// ...
74// ... // code to fill the calorimeter data
75// ...
76//
7849a8ab 77// evt.AddCalorimeter(emcal);
78//
35044448 79// AliTrack* tx=new AliTrack();
7849a8ab 80// for (Int_t i=0; i<10; i++)
81// {
d16062ac 82// ...
83// ... // code to fill the track data
84// ...
7849a8ab 85// evt.AddTrack(tx);
86// tx->Reset();
87// }
88//
35044448 89// if (tx)
90// {
91// delete tx;
92// tx=0;
93// }
94//
7849a8ab 95// Build the event structure (vertices, jets, ...) for physics analysis
96// based on the basic objects from the event repository.
d16062ac 97//
98// AliJet j1,j2;
7849a8ab 99// for (Int_t i=0; i<evt.GetNtracks(); i++)
100// {
101// tx=evt.GetTrack(i);
d16062ac 102// ...
103// ... // code to fill the jet data
104// ...
7849a8ab 105// }
d16062ac 106//
7849a8ab 107// AliVertex vp;
35044448 108// tx=evt.GetTrack(1);
7849a8ab 109// vp.AddTrack(tx);
35044448 110// tx=evt.GetTrack(2);
7849a8ab 111// vp.AddTrack(tx);
35044448 112// tx=evt.GetTrack(3);
7849a8ab 113// vp.AddTrack(tx);
35044448 114// tx=evt.GetTrack(4);
7849a8ab 115// vp.AddTrack(tx);
d16062ac 116//
7849a8ab 117// Float_t rp[3]={2.4,0.1,-8.5};
118// vp.SetPosition(rp,"car");
d16062ac 119//
7849a8ab 120// AliVertex v1;
35044448 121// tx=evt.GetTrack(5);
7849a8ab 122// v1.AddTrack(tx);
35044448 123// tx=evt.GetTrack(6);
7849a8ab 124// v1.AddTrack(tx);
35044448 125// tx=evt.GetTrack(7);
7849a8ab 126// v1.AddTrack(tx);
d16062ac 127//
128// Float_t r1[3]={1.6,-3.2,5.7};
129// v1.SetPosition(r1,"car");
130//
d16062ac 131//
7849a8ab 132// AliVertex v2;
133// v2.SetJetCopy(1);
d16062ac 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//
7849a8ab 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//
d16062ac 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//
d16062ac 171// evt.List();
172//
173// Int_t nv=evt.GetNvtx();
7849a8ab 174// AliVertex* vx=evt.GetVertex(1); // Access primary vertex
d16062ac 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
7849a8ab 183// ...
184// ... // code to create tracks etc...
185// ...
d16062ac 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
35044448 190//- Modified: NvE $Date: 2001/07/04 15:59:20 $ UU-SAP Utrecht
d16062ac 191///////////////////////////////////////////////////////////////////////////
192
193#include "AliEvent.h"
194
195ClassImp(AliEvent) // Class implementation to enable ROOT I/O
196
197AliEvent::AliEvent()
198{
199// Default constructor.
200// All variables initialised to default values.
201 fDaytime.Set();
202 fRun=0;
203 fEvent=0;
7849a8ab 204 fNcals=0;
205 fCalorimeters=0;
206 fCalCopy=0;
d16062ac 207}
208///////////////////////////////////////////////////////////////////////////
81508922 209AliEvent::AliEvent(Int_t n): AliVertex(n)
d16062ac 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;
7849a8ab 216 fNcals=0;
217 fCalorimeters=0;
218 fCalCopy=0;
d16062ac 219}
220///////////////////////////////////////////////////////////////////////////
221AliEvent::~AliEvent()
222{
223// Default destructor
7849a8ab 224 if (fCalorimeters)
225 {
226 if (fCalCopy) fCalorimeters->Delete();
227 delete fCalorimeters;
228 fCalorimeters=0;
229 }
d16062ac 230}
231///////////////////////////////////////////////////////////////////////////
232void 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
7849a8ab 241 fNcals=0;
242 if (fCalorimeters)
243 {
244 if (fCalCopy) fCalorimeters->Delete();
245 delete fCalorimeters;
246 fCalorimeters=0;
247 }
248
d16062ac 249 AliVertex::Reset();
250}
251///////////////////////////////////////////////////////////////////////////
252void AliEvent::SetDayTime(TDatime& stamp)
253{
254// Set the date and time stamp for this event
255 fDaytime=stamp;
256}
257///////////////////////////////////////////////////////////////////////////
258void AliEvent::SetRunNumber(Int_t run)
259{
260// Set the run number for this event
261 fRun=run;
262}
263///////////////////////////////////////////////////////////////////////////
264void AliEvent::SetEventNumber(Int_t evt)
265{
266// Set the event number for this event
267 fEvent=evt;
268}
269///////////////////////////////////////////////////////////////////////////
270TDatime AliEvent::GetDayTime()
271{
272// Provide the date and time stamp for this event
273 return fDaytime;
274}
275///////////////////////////////////////////////////////////////////////////
276Int_t AliEvent::GetRunNumber()
277{
278// Provide the run number for this event
279 return fRun;
280}
281///////////////////////////////////////////////////////////////////////////
282Int_t AliEvent::GetEventNumber()
283{
284// Provide the event number for this event
285 return fEvent;
286}
287///////////////////////////////////////////////////////////////////////////
288void 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
35044448 307 << " Time : " << setw(2) << hh << ":" << setw(2) << mm << ":" << setw(2) << ss;
d16062ac 308 cout.fill(' ');
7849a8ab 309 cout << " Ncalorimeters : " << fNcals << endl;
d16062ac 310}
311///////////////////////////////////////////////////////////////////////////
312void AliEvent::Info(TString f)
313{
314// Provide event information within the coordinate frame f
315 HeaderInfo();
316 AliVertex::Info(f);
317}
318///////////////////////////////////////////////////////////////////////////
7849a8ab 319Int_t AliEvent::GetNcalorimeters()
320{
321// Provide the number of stored calorimeter systems
322 return fNcals;
323}
324///////////////////////////////////////////////////////////////////////////
325void 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 {
35044448 334 fCalorimeters->AddLast(c.Clone());
7849a8ab 335 }
336 else
337 {
338 fCalorimeters->AddLast(&c);
339 }
340}
341///////////////////////////////////////////////////////////////////////////
342void 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///////////////////////////////////////////////////////////////////////////
370Int_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///////////////////////////////////////////////////////////////////////////
378AliCalorimeter* 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///////////////////////////////////////////////////////////////////////////
401AliCalorimeter* 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);
35044448 416 if (cx)
417 {
418 s=cx->GetName();
419 if (s == name) return cx;
420 }
7849a8ab 421 }
422
423 return 0; // No matching name found
424 }
425}
426///////////////////////////////////////////////////////////////////////////
d16062ac 427