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