1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 // $Id: AliEvent.cxx,v 1.18 2004/01/12 08:23:22 nick Exp $
18 ///////////////////////////////////////////////////////////////////////////
20 // Creation and investigation of an Alice physics event.
21 // An AliEvent can be constructed by adding AliTracks, Alivertices, AliJets
22 // and/or devices like AliCalorimeters.
23 // All objects which are derived from TObject can be regarded as a device.
25 // The basic functionality of AliEvent is identical to the one of AliVertex.
26 // So, an AliEvent may be used as the primary vertex with some additional
27 // functionality compared to AliVertex.
29 // To provide maximal flexibility to the user, the two modes of track/jet/vertex
30 // storage as described in AliJet and AliVertex can be used.
31 // In addition an identical structure is provided for the storage of devices like
32 // AliCalorimeter objects, which can be selected by means of the memberfunction
35 // a) SetDevCopy(0) (which is the default).
36 // Only the pointers of the 'added' devices are stored.
37 // This mode is typically used by making studies based on a fixed set
38 // of devices which stays under user control or is kept on an external
40 // In this way the AliEvent just represents a 'logical structure' for the
44 // Modifications made to the original devices also affect the device
45 // objects which are stored in the AliEvent.
48 // Of every 'added' device a private copy will be made of which the pointer
50 // In this way the AliEvent represents an entity on its own and modifications
51 // made to the original calorimeters do not affect the AliCalorimeter objects
52 // which are stored in the AliEvent.
53 // This mode will allow 'adding' many different devices into an AliEvent by
54 // creating only one device instance in the main programme and using the
55 // Reset() and parameter setting memberfunctions of the object representing the device.
58 // The copy is made using the Clone() memberfunction.
59 // All devices (i.e. classes derived from TObject) have the default TObject::Clone()
61 // However, devices generally contain an internal (signal) data structure
62 // which may include pointers to other objects. Therefore it is recommended to provide
63 // for all devices a specific copy constructor and override the default Clone()
64 // memberfunction using this copy constructor.
65 // An example for this may be seen from AliCalorimeter.
67 // See also the documentation provided for the memberfunction SetOwner().
69 // Coding example to make an event consisting of a primary vertex,
70 // 2 secondary vertices and a calorimeter.
71 // --------------------------------------------------------------
72 // vp contains the tracks 1,2,3 and 4 (primary vertex)
73 // v1 contains the tracks 5,6 and 7 (sec. vertex)
74 // v2 contains the jets 1 and 2 (sec. vertex)
78 // Specify the event object as the repository of all objects
79 // for the event building and physics analysis.
82 // evt.SetTrackCopy(1);
84 // Fill the event structure with the basic objects
86 // AliCalorimeter emcal;
88 // ... // code to fill the calorimeter data
91 // evt.AddDevice(emcal);
93 // AliTrack* tx=new AliTrack();
94 // for (Int_t i=0; i<10; i++)
97 // ... // code to fill the track data
109 // Build the event structure (vertices, jets, ...) for physics analysis
110 // based on the basic objects from the event repository.
113 // for (Int_t i=0; i<evt.GetNtracks(); i++)
115 // tx=evt.GetTrack(i);
117 // ... // code to fill the jet data
122 // tx=evt.GetTrack(1);
124 // tx=evt.GetTrack(2);
126 // tx=evt.GetTrack(3);
128 // tx=evt.GetTrack(4);
131 // Float_t rp[3]={2.4,0.1,-8.5};
132 // vp.SetPosition(rp,"car");
135 // tx=evt.GetTrack(5);
137 // tx=evt.GetTrack(6);
139 // tx=evt.GetTrack(7);
142 // Float_t r1[3]={1.6,-3.2,5.7};
143 // v1.SetPosition(r1,"car");
151 // Float_t r2[3]={6.2,4.8,1.3};
152 // v2.SetPosition(r2,"car");
154 // Specify the vertices v1 and v2 as secondary vertices of the primary
156 // vp.SetVertexCopy(1);
160 // Enter the physics structures into the event
161 // evt.SetVertexCopy(1);
162 // evt.AddVertex(vp,0);
164 // The jets j1 and j2 are already available via sec. vertex v2,
165 // but can be made available also from the event itself if desired.
176 // Float_t etot=evt.GetEnergy();
177 // Ali3Vector ptot=evt.Get3Momentum();
179 // evt.GetPosition(loc,"sph");
180 // AliPosition r=v1.GetPosition();
182 // Int_t nt=v2.GetNtracks();
183 // AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
187 // Int_t nv=evt.GetNvtx();
188 // AliVertex* vx=evt.GetVertex(1); // Access primary vertex
189 // Float_t e=vx->GetEnergy();
191 // Float_t M=evt.GetInvmass();
193 // Reconstruct the event from scratch
196 // evt.SetNvmax(25); // Increase initial no. of sec. vertices
198 // ... // code to create tracks etc...
201 // Note : All quantities are in GeV, GeV/c or GeV/c**2
203 //--- Author: Nick van Eijndhoven 27-may-2001 UU-SAP Utrecht
204 //- Modified: NvE $Date: 2004/01/12 08:23:22 $ UU-SAP Utrecht
205 ///////////////////////////////////////////////////////////////////////////
207 #include "AliEvent.h"
208 #include "Riostream.h"
210 ClassImp(AliEvent) // Class implementation to enable ROOT I/O
212 AliEvent::AliEvent() : AliVertex()
214 // Default constructor.
215 // All variables initialised to default values.
230 ///////////////////////////////////////////////////////////////////////////
231 AliEvent::AliEvent(Int_t n) : AliVertex(n)
233 // Create an event to hold initially a maximum of n tracks
234 // All variables initialised to default values
237 cout << " *** This AliVertex initialisation was invoked via the AliEvent ctor." << endl;
253 ///////////////////////////////////////////////////////////////////////////
254 AliEvent::~AliEvent()
256 // Default destructor
263 ///////////////////////////////////////////////////////////////////////////
264 AliEvent::AliEvent(AliEvent& evt) : AliVertex(evt)
267 fDaytime=evt.fDaytime;
272 fPnucProj=evt.fPnucProj;
276 fPnucTarg=evt.fPnucTarg;
278 fDevCopy=evt.fDevCopy;
281 Int_t ndevs=evt.GetNdevices();
284 fDevices=new TObjArray(ndevs);
285 if (fDevCopy) fDevices->SetOwner();
286 for (Int_t i=1; i<=ndevs; i++)
288 TObject* dev=evt.GetDevice(i);
293 fDevices->Add(dev->Clone());
303 ///////////////////////////////////////////////////////////////////////////
304 void AliEvent::Reset()
306 // Reset all variables to default values
307 // The max. number of tracks is set to the initial value again
308 // The max. number of vertices is set to the default value again
309 // Note : The CalCopy mode is maintained as it was set by the user before.
331 ///////////////////////////////////////////////////////////////////////////
332 void AliEvent::SetOwner(Bool_t own)
334 // Set ownership of all added objects.
335 // The default parameter is own=kTRUE.
337 // Invokation of this memberfunction also sets all the copy modes
338 // (e.g. TrackCopy & co.) according to the value of own.
340 // This function (with own=kTRUE) is particularly useful when reading data
341 // from a tree/file, since Reset() will then actually remove all the
342 // added objects from memory irrespective of the copy mode settings
343 // during the tree/file creation process. In this way it provides a nice way
344 // of preventing possible memory leaks in the reading/analysis process.
346 // In addition this memberfunction can also be used as a shortcut to set all
347 // copy modes in one go during a tree/file creation process.
348 // However, in this case the user has to take care to only set/change the
349 // ownership (and copy mode) for empty objects (e.g. newly created objects
350 // or after invokation of the Reset() memberfunction) otherwise it will
351 // very likely result in inconsistent destructor behaviour.
355 if (fDevices) fDevices->SetOwner(own);
358 AliVertex::SetOwner(own);
360 ///////////////////////////////////////////////////////////////////////////
361 void AliEvent::SetDayTime(TTimeStamp& stamp)
363 // Set the date and time stamp for this event.
364 // An exact copy of the entered date/time stamp will be saved with an
365 // accuracy of 1 nanosecond.
368 ///////////////////////////////////////////////////////////////////////////
369 void AliEvent::SetDayTime(TDatime& stamp)
371 // Set the date and time stamp for this event.
372 // The entered date/time will be interpreted as being the local date/time
373 // and the accuracy is 1 second.
374 // This function with the TDatime argument is mainly kept for backward
375 // compatibility reasons. It is recommended to use the corresponding
376 // function with the TTimeStamp argument.
378 fDaytime.Set(stamp.GetDate(),stamp.GetTime(),0,kFALSE,0);
380 ///////////////////////////////////////////////////////////////////////////
381 void AliEvent::SetRunNumber(Int_t run)
383 // Set the run number for this event
386 ///////////////////////////////////////////////////////////////////////////
387 void AliEvent::SetEventNumber(Int_t evt)
389 // Set the event number for this event
392 ///////////////////////////////////////////////////////////////////////////
393 TTimeStamp AliEvent::GetDayTime()
395 // Provide the date and time stamp for this event
398 ///////////////////////////////////////////////////////////////////////////
399 Int_t AliEvent::GetRunNumber()
401 // Provide the run number for this event
404 ///////////////////////////////////////////////////////////////////////////
405 Int_t AliEvent::GetEventNumber()
407 // Provide the event number for this event
410 ///////////////////////////////////////////////////////////////////////////
411 void AliEvent::SetProjectile(Int_t a,Int_t z,Double_t pnuc,Int_t id)
413 // Set the projectile A, Z, momentum per nucleon and user defined particle ID.
414 // By default the particle ID is set to zero.
420 ///////////////////////////////////////////////////////////////////////////
421 Int_t AliEvent::GetProjectileA()
423 // Provide the projectile A value.
426 ///////////////////////////////////////////////////////////////////////////
427 Int_t AliEvent::GetProjectileZ()
429 // Provide the projectile Z value.
432 ///////////////////////////////////////////////////////////////////////////
433 Double_t AliEvent::GetProjectilePnuc()
435 // Provide the projectile momentum value per nucleon.
438 ///////////////////////////////////////////////////////////////////////////
439 Int_t AliEvent::GetProjectileId()
441 // Provide the user defined particle ID of the projectile.
444 ///////////////////////////////////////////////////////////////////////////
445 void AliEvent::SetTarget(Int_t a,Int_t z,Double_t pnuc,Int_t id)
447 // Set the target A, Z, momentum per nucleon and user defined particle ID.
448 // By default the particle ID is set to zero.
454 ///////////////////////////////////////////////////////////////////////////
455 Int_t AliEvent::GetTargetA()
457 // Provide the target A value.
460 ///////////////////////////////////////////////////////////////////////////
461 Int_t AliEvent::GetTargetZ()
463 // Provide the target Z value.
466 ///////////////////////////////////////////////////////////////////////////
467 Double_t AliEvent::GetTargetPnuc()
469 // Provide the target momentum value per nucleon.
472 ///////////////////////////////////////////////////////////////////////////
473 Int_t AliEvent::GetTargetId()
475 // Provide the user defined particle ID of the target.
478 ///////////////////////////////////////////////////////////////////////////
479 void AliEvent::HeaderData()
481 // Provide event header information
482 const char* name=GetName();
483 const char* title=GetTitle();
484 Int_t ndevs=GetNdevices();
485 cout << " *" << ClassName() << "::Data*";
486 if (strlen(name)) cout << " Name : " << GetName();
487 if (strlen(title)) cout << " Title : " << GetTitle();
489 cout << " " << fDaytime.AsString() << endl;
490 cout << " Run : " << fRun << " Event : " << fEvent
491 << " Number of devices : " << ndevs << endl;
493 if (ndevs) ShowDevices();
495 ///////////////////////////////////////////////////////////////////////////
496 void AliEvent::Data(TString f)
498 // Provide event information within the coordinate frame f
502 ///////////////////////////////////////////////////////////////////////////
503 Int_t AliEvent::GetNdevices()
505 // Provide the number of stored devices
507 if (fDevices) ndevs=fDevices->GetEntries();
510 ///////////////////////////////////////////////////////////////////////////
511 void AliEvent::AddDevice(TObject& d)
513 // Add a device to the event.
516 // In case a private copy is made, this is performed via the Clone() memberfunction.
517 // All devices (i.e. classes derived from TObject) have the default TObject::Clone()
519 // However, devices generally contain an internal (signal) data structure
520 // which may include pointers to other objects. Therefore it is recommended to provide
521 // for all devices a specific copy constructor and override the default Clone()
522 // memberfunction using this copy constructor.
523 // An example for this may be seen from AliCalorimeter.
527 fDevices=new TObjArray();
528 if (fDevCopy) fDevices->SetOwner();
531 // Add the device to this event
534 fDevices->Add(d.Clone());
541 ///////////////////////////////////////////////////////////////////////////
542 void AliEvent::SetDevCopy(Int_t j)
544 // (De)activate the creation of private copies of the added devices.
545 // j=0 ==> No private copies are made; pointers of original devices are stored.
546 // j=1 ==> Private copies of the devices are made and these pointers are stored.
550 // In case a private copy is made, this is performed via the Clone() memberfunction.
551 // All devices (i.e. classes derived from TObject) have the default TObject::Clone()
553 // However, devices generally contain an internal (signal) data structure
554 // which may include pointers to other objects. Therefore it is recommended to provide
555 // for all devices a specific copy constructor and override the default Clone()
556 // memberfunction using this copy constructor.
557 // An example for this may be seen from AliCalorimeter.
559 // Once the storage contains pointer(s) to device(s) one cannot
560 // change the DevCopy mode anymore.
561 // To change the DevCopy mode for an existing AliEvent containing
562 // devices one first has to invoke Reset().
572 cout << " *" << ClassName() << "::SetDevCopy* Invalid argument : " << j << endl;
577 cout << " *" << ClassName() << "::SetDevCopy* Storage already contained devices."
578 << " ==> DevCopy mode not changed." << endl;
581 ///////////////////////////////////////////////////////////////////////////
582 Int_t AliEvent::GetDevCopy()
584 // Provide value of the DevCopy mode.
585 // 0 ==> No private copies are made; pointers of original devices are stored.
586 // 1 ==> Private copies of the devices are made and these pointers are stored.
589 // In case a private copy is made, this is performed via the Clone() memberfunction.
590 // All devices (i.e. classes derived from TObject) have the default TObject::Clone()
592 // However, devices generally contain an internal (signal) data structure
593 // which may include pointers to other objects. Therefore it is recommended to provide
594 // for all devices a specific copy constructor and override the default Clone()
595 // memberfunction using this copy constructor.
596 // An example for this may be seen from AliCalorimeter.
600 ///////////////////////////////////////////////////////////////////////////
601 TObject* AliEvent::GetDevice(Int_t i)
603 // Return the i-th device of this event.
604 // The first device corresponds to i=1.
612 Int_t ndevs=GetNdevices();
615 cout << " *" << ClassName() << "::GetDevice* Invalid argument i : " << i
616 << " ndevs = " << ndevs << endl;
621 return fDevices->At(i-1);
625 ///////////////////////////////////////////////////////////////////////////
626 TObject* AliEvent::GetDevice(TString name)
628 // Return the device with name tag "name"
636 Int_t ndevs=GetNdevices();
637 for (Int_t i=0; i<ndevs; i++)
639 TObject* dev=fDevices->At(i);
643 if (s == name) return dev;
647 return 0; // No matching name found
650 ///////////////////////////////////////////////////////////////////////////
651 void AliEvent::ShowDevices()
653 // Provide an overview of the available devices.
654 Int_t ndevs=GetNdevices();
657 cout << " The following " << ndevs << " devices are available :" << endl;
658 for (Int_t i=1; i<=ndevs; i++)
660 TObject* dev=GetDevice(i);
663 cout << " Device number : " << i
664 << " Class : " << dev->ClassName()
665 << " Name : " << dev->GetName() << endl;
671 cout << " No devices present for this event." << endl;
674 ///////////////////////////////////////////////////////////////////////////
675 TObject* AliEvent::Clone(const char* name)
677 // Make a deep copy of the current object and provide the pointer to the copy.
678 // This memberfunction enables automatic creation of new objects of the
679 // correct type depending on the object type, a feature which may be very useful
680 // for containers when adding objects in case the container owns the objects.
681 // This feature allows to store either AliEvent objects or objects derived from
682 // AliEvent via some generic AddEvent memberfunction, provided these derived
683 // classes also have a proper Clone memberfunction.
685 AliEvent* evt=new AliEvent(*this);
688 if (strlen(name)) evt->SetName(name);
692 ///////////////////////////////////////////////////////////////////////////