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