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.6 2002/04/26 11:23:37 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 // See also the documentation provided for the memberfunction SetOwner().
  56 //
  57 // Coding example to make an event consisting of a primary vertex,
  58 // 2 secondary vertices and a calorimeter.
  59 // --------------------------------------------------------------
  60 // vp contains the tracks 1,2,3 and 4 (primary vertex)
  61 // v1 contains the tracks 5,6 and 7   (sec. vertex)
  62 // v2 contains the jets 1 and 2       (sec. vertex)
  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 //        AliCalorimeter emcal;
  75 //         ...
  76 //         ... // code to fill the calorimeter data
  77 //         ...
  78 //
  79 //        evt.AddCalorimeter(emcal);
  80 //
  81 //        AliTrack* tx=new AliTrack();
  82 //        for (Int_t i=0; i<10; i++)
  83 //        {
  84 //         ...
  85 //         ... // code to fill the track data
  86 //         ...
  87 //         evt.AddTrack(tx);
  88 //         tx->Reset();
  89 //        }
  90 //
  91 //        if (tx)
  92 //        {
  93 //         delete tx;
  94 //         tx=0;
  95 //        }
  96 //
  97 // Build the event structure (vertices, jets, ...) for physics analysis
  98 // based on the basic objects from the event repository.
  99 //
 100 //        AliJet j1,j2;
 101 //        for (Int_t i=0; i<evt.GetNtracks(); i++)
 102 //        {
 103 //         tx=evt.GetTrack(i);
 104 //         ...
 105 //         ... // code to fill the jet data
 106 //         ...
 107 //        }
 108 //
 109 //        AliVertex vp;
 110 //        tx=evt.GetTrack(1);
 111 //        vp.AddTrack(tx);
 112 //        tx=evt.GetTrack(2);
 113 //        vp.AddTrack(tx);
 114 //        tx=evt.GetTrack(3);
 115 //        vp.AddTrack(tx);
 116 //        tx=evt.GetTrack(4);
 117 //        vp.AddTrack(tx);
 118 //
 119 //        Float_t rp[3]={2.4,0.1,-8.5};
 120 //        vp.SetPosition(rp,"car");
 121 //
 122 //        AliVertex v1;
 123 //        tx=evt.GetTrack(5);
 124 //        v1.AddTrack(tx);
 125 //        tx=evt.GetTrack(6);
 126 //        v1.AddTrack(tx);
 127 //        tx=evt.GetTrack(7);
 128 //        v1.AddTrack(tx);
 129 //
 130 //        Float_t r1[3]={1.6,-3.2,5.7};
 131 //        v1.SetPosition(r1,"car");
 132 //
 133 //
 134 //        AliVertex v2;
 135 //        v2.SetJetCopy(1);
 136 //        v2.AddJet(j1);
 137 //        v2.AddJet(j2);
 138 //
 139 //        Float_t r2[3]={6.2,4.8,1.3};
 140 //        v2.SetPosition(r2,"car");
 141 //
 142 // Specify the vertices v1 and v2 as secondary vertices of the primary
 143 //
 144 //        vp.SetVertexCopy(1);
 145 //        vp.AddVertex(v1);
 146 //        vp.AddVertex(v2);
 147 //
 148 // Enter the physics structures into the event
 149 //        evt.SetVertexCopy(1);
 150 //        evt.AddVertex(vp,0);
 151 //
 152 // The jets j1 and j2 are already available via sec. vertex v2,
 153 // but can be made available also from the event itself if desired.
 154 //        AliJet* jx;
 155 //        jx=v2.GetJet(1);
 156 //        evt.AddJet(jx,0);
 157 //        jx=v2.GetJet(2);
 158 //        evt.AddJet(jx,0);
 159 //
 160 //        evt.Info("sph");
 161 //        v1.ListAll();
 162 //        v2.List("cyl");
 163 //
 164 //        Float_t etot=evt.GetEnergy();
 165 //        Ali3Vector ptot=evt.Get3Momentum();
 166 //        Float_t loc[3];
 167 //        evt.GetPosition(loc,"sph");
 168 //        AliPosition r=v1.GetPosition();
 169 //        r.Info();
 170 //        Int_t nt=v2.GetNtracks();
 171 //        AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
 172 //
 173 //        evt.List();
 174 //
 175 //        Int_t nv=evt.GetNvtx();
 176 //        AliVertex* vx=evt.GetVertex(1); // Access primary vertex
 177 //        Float_t e=vx->GetEnergy();
 178 //
 179 //        Float_t M=evt.GetInvmass();
 180 //
 181 // Reconstruct the event from scratch
 182 //
 183 //        evt.Reset();
 184 //        evt.SetNvmax(25); // Increase initial no. of sec. vertices
 185 //        ...
 186 //        ... // code to create tracks etc...
 187 //        ...
 188 //
 189 // Note : All quantities are in GeV, GeV/c or GeV/c**2
 190 //
 191 //--- Author: Nick van Eijndhoven 27-may-2001 UU-SAP Utrecht
 192 //- Modified: NvE $Date: 2002/04/26 11:23:37 $ UU-SAP Utrecht
 193 ///////////////////////////////////////////////////////////////////////////
 194
 195 #include "AliEvent.h"
 196
 197 ClassImp(AliEvent) // Class implementation to enable ROOT I/O
 198
 199 AliEvent::AliEvent()
 200 {
 201 // Default constructor.
 202 // All variables initialised to default values.
 203  fDaytime.Set();
 204  fRun=0;
 205  fEvent=0;
 206  fAproj=0;
 207  fZproj=0;
 208  fPnucProj=0;
 209  fAtarg=0;
 210  fZtarg=0;
 211  fPnucTarg=0;
 212  fNcals=0;
 213  fCalorimeters=0;
 214  fCalCopy=0;
 215 }
 216 ///////////////////////////////////////////////////////////////////////////
 217 AliEvent::AliEvent(Int_t n): AliVertex(n)
 218 {
 219 // Create an event to hold initially a maximum of n tracks
 220 // All variables initialised to default values
 221  cout << "AliEvent init with n = " << n << endl;
 222  fDaytime.Set();
 223  fRun=0;
 224  fEvent=0;
 225  fAproj=0;
 226  fZproj=0;
 227  fPnucProj=0;
 228  fAtarg=0;
 229  fZtarg=0;
 230  fPnucTarg=0;
 231  fNcals=0;
 232  fCalorimeters=0;
 233  fCalCopy=0;
 234 }
 235 ///////////////////////////////////////////////////////////////////////////
 236 AliEvent::~AliEvent()
 237 {
 238 // Default destructor
 239  if (fCalorimeters)
 240  {
 241   delete fCalorimeters;
 242   fCalorimeters=0;
 243  }
 244 }
 245 ///////////////////////////////////////////////////////////////////////////
 246 void AliEvent::Reset()
 247 {
 248 // Reset all variables to default values
 249 // The max. number of tracks is set to the initial value again
 250 // The max. number of vertices is set to the default value again
 251 // Note : The CalCopy mode is maintained as it was set by the user before.
 252  fDaytime.Set();
 253  fRun=0;
 254  fEvent=0;
 255  fAproj=0;
 256  fZproj=0;
 257  fPnucProj=0;
 258  fAtarg=0;
 259  fZtarg=0;
 260  fPnucTarg=0;
 261
 262  fNcals=0;
 263  if (fCalorimeters)
 264  {
 265   delete fCalorimeters;
 266   fCalorimeters=0;
 267  }
 268
 269  AliVertex::Reset();
 270 }
 271 ///////////////////////////////////////////////////////////////////////////
 272 void AliEvent::SetOwner(Bool_t own)
 273 {
 274 // Set ownership of all added objects.
 275 // The default parameter is own=kTRUE.
 276 //
 277 // Invokation of this memberfunction also sets all the copy modes
 278 // (e.g. TrackCopy & co.) according to the value of own.
 279 //
 280 // This function (with own=kTRUE) is particularly useful when reading data
 281 // from a tree/file, since Reset() will then actually remove all the
 282 // added objects from memory irrespective of the copy mode settings
 283 // during the tree/file creation process. In this way it provides a nice way
 284 // of preventing possible memory leaks in the reading/analysis process.
 285 //
 286 // In addition this memberfunction can also be used as a shortcut to set all
 287 // copy modes in one go during a tree/file creation process.
 288 // However, in this case the user has to take care to only set/change the
 289 // ownership (and copy mode) for empty objects (e.g. newly created objects
 290 // or after invokation of the Reset() memberfunction) otherwise it will
 291 // very likely result in inconsistent destructor behaviour.
 292
 293  Int_t mode=1;
 294  if (!own) mode=0;
 295  if (fCalorimeters) fCalorimeters->SetOwner(own);
 296  fCalCopy=mode;
 297
 298  AliVertex::SetOwner(own);
 299 }
 300 ///////////////////////////////////////////////////////////////////////////
 301 void AliEvent::SetDayTime(TDatime& stamp)
 302 {
 303 // Set the date and time stamp for this event
 304  fDaytime=stamp;
 305 }
 306 ///////////////////////////////////////////////////////////////////////////
 307 void AliEvent::SetRunNumber(Int_t run)
 308 {
 309 // Set the run number for this event
 310  fRun=run;
 311 }
 312 ///////////////////////////////////////////////////////////////////////////
 313 void AliEvent::SetEventNumber(Int_t evt)
 314 {
 315 // Set the event number for this event
 316  fEvent=evt;
 317 }
 318 ///////////////////////////////////////////////////////////////////////////
 319 TDatime AliEvent::GetDayTime()
 320 {
 321 // Provide the date and time stamp for this event
 322  return fDaytime;
 323 }
 324 ///////////////////////////////////////////////////////////////////////////
 325 Int_t AliEvent::GetRunNumber()
 326 {
 327 // Provide the run number for this event
 328  return fRun;
 329 }
 330 ///////////////////////////////////////////////////////////////////////////
 331 Int_t AliEvent::GetEventNumber()
 332 {
 333 // Provide the event number for this event
 334  return fEvent;
 335 }
 336 ///////////////////////////////////////////////////////////////////////////
 337 void AliEvent::SetProjectile(Int_t a,Int_t z,Double_t pnuc)
 338 {
 339 // Set the projectile A, Z and momentum value per nucleon.
 340  fAproj=a;
 341  fZproj=z;
 342  fPnucProj=pnuc;
 343 }
 344 ///////////////////////////////////////////////////////////////////////////
 345 Int_t AliEvent::GetProjectileA()
 346 {
 347 // Provide the projectile A value.
 348  return fAproj;
 349 }
 350 ///////////////////////////////////////////////////////////////////////////
 351 Int_t AliEvent::GetProjectileZ()
 352 {
 353 // Provide the projectile Z value.
 354  return fZproj;
 355 }
 356 ///////////////////////////////////////////////////////////////////////////
 357 Double_t AliEvent::GetProjectilePnuc()
 358 {
 359 // Provide the projectile momentum value per nucleon.
 360  return fPnucProj;
 361 }
 362 ///////////////////////////////////////////////////////////////////////////
 363 void AliEvent::SetTarget(Int_t a,Int_t z,Double_t pnuc)
 364 {
 365 // Set the target A, Z and momentum value per nucleon.
 366  fAtarg=a;
 367  fZtarg=z;
 368  fPnucTarg=pnuc;
 369 }
 370 ///////////////////////////////////////////////////////////////////////////
 371 Int_t AliEvent::GetTargetA()
 372 {
 373 // Provide the target A value.
 374  return fAtarg;
 375 }
 376 ///////////////////////////////////////////////////////////////////////////
 377 Int_t AliEvent::GetTargetZ()
 378 {
 379 // Provide the target Z value.
 380  return fZtarg;
 381 }
 382 ///////////////////////////////////////////////////////////////////////////
 383 Double_t AliEvent::GetTargetPnuc()
 384 {
 385 // Provide the target momentum value per nucleon.
 386  return fPnucTarg;
 387 }
 388 ///////////////////////////////////////////////////////////////////////////
 389 void AliEvent::HeaderInfo()
 390 {
 391 // Provide event header information
 392  Int_t date=fDaytime.GetDate();
 393  Int_t time=fDaytime.GetTime();
 394
 395  Int_t year=date/10000;
 396  Int_t month=(date%10000)/100;
 397  Int_t day=date%100;
 398  Int_t hh=time/10000;
 399  Int_t mm=(time%10000)/100;
 400  Int_t ss=time%100;
 401
 402  char* c[12]={"jan","feb","mar","apr","may","jun",
 403               "jul","aug","sep","oct","nov","dec"};
 404
 405  cout << " *AliEvent::Info* Run : " << fRun << " Event : " << fEvent;
 406  cout.fill('0');
 407  cout << " Date : " << setw(2) << day << "-" << c[month-1] << "-" << year
 408       << " Time : " << setw(2) << hh << ":" << setw(2) << mm << ":" << setw(2) << ss;
 409  cout.fill(' ');
 410  cout << " Ncalorimeters : " << fNcals << endl;
 411 }
 412 ///////////////////////////////////////////////////////////////////////////
 413 void AliEvent::Info(TString f)
 414 {
 415 // Provide event information within the coordinate frame f
 416  HeaderInfo();
 417  AliVertex::Info(f);
 418 }
 419 ///////////////////////////////////////////////////////////////////////////
 420 Int_t AliEvent::GetNcalorimeters()
 421 {
 422 // Provide the number of stored calorimeter systems
 423  return fNcals;
 424 }
 425 ///////////////////////////////////////////////////////////////////////////
 426 void AliEvent::AddCalorimeter(AliCalorimeter& c)
 427 {
 428 // Add a calorimeter system to the event
 429  if (!fCalorimeters)
 430  {
 431   fCalorimeters=new TObjArray();
 432   if (fCalCopy) fCalorimeters->SetOwner();
 433  }
 434
 435  // Add the calorimeter system to this event
 436  fNcals++;
 437  if (fCalCopy)
 438  {
 439   fCalorimeters->AddLast((AliCalorimeter*)c.Clone());
 440  }
 441  else
 442  {
 443   fCalorimeters->AddLast(&c);
 444  }
 445 }
 446 ///////////////////////////////////////////////////////////////////////////
 447 void AliEvent::SetCalCopy(Int_t j)
 448 {
 449 // (De)activate the creation of private copies of the added calorimeters.
 450 // j=0 ==> No private copies are made; pointers of original cals. are stored.
 451 // j=1 ==> Private copies of the cals. are made and these pointers are stored.
 452 //
 453 // Note : Once the storage contains pointer(s) to AliCalorimeter(s) one cannot
 454 //        change the CalCopy mode anymore.
 455 //        To change the CalCopy mode for an existing AliEvent containing
 456 //        calorimeters one first has to invoke Reset().
 457  if (!fCalorimeters)
 458  {
 459   if (j==0 || j==1)
 460   {
 461    fCalCopy=j;
 462   }
 463   else
 464   {
 465    cout << "*AliEvent::SetCalCopy* Invalid argument : " << j << endl;
 466   }
 467  }
 468  else
 469  {
 470   cout << "*AliEvent::SetCalCopy* Storage already contained calorimeters."
 471        << "  ==> CalCopy mode not changed." << endl;
 472  }
 473 }
 474 ///////////////////////////////////////////////////////////////////////////
 475 Int_t AliEvent::GetCalCopy()
 476 {
 477 // Provide value of the CalCopy mode.
 478 // 0 ==> No private copies are made; pointers of original cals. are stored.
 479 // 1 ==> Private copies of the cals. are made and these pointers are stored.
 480  return fCalCopy;
 481 }
 482 ///////////////////////////////////////////////////////////////////////////
 483 AliCalorimeter* AliEvent::GetCalorimeter(Int_t i)
 484 {
 485 // Return the i-th calorimeter of this event
 486  if (!fCalorimeters)
 487  {
 488   cout << " *AliEvent::GetCalorimeter* No calorimeters present." << endl;
 489   return 0;
 490  }
 491  else
 492  {
 493   if (i<=0 || i>fNcals)
 494   {
 495    cout << " *AliEvent::GetCalorimeter* Invalid argument i : " << i
 496         << " Ncals = " << fNcals << endl;
 497    return 0;
 498   }
 499   else
 500   {
 501    return (AliCalorimeter*)fCalorimeters->At(i-1);
 502   }
 503  }
 504 }
 505 ///////////////////////////////////////////////////////////////////////////
 506 AliCalorimeter* AliEvent::GetCalorimeter(TString name)
 507 {
 508 // Return the calorimeter with name tag "name"
 509  if (!fCalorimeters)
 510  {
 511   cout << " *AliEvent::GetCalorimeter* No calorimeters present." << endl;
 512   return 0;
 513  }
 514  else
 515  {
 516   AliCalorimeter* cx;
 517   TString s;
 518   for (Int_t i=0; i<fNcals; i++)
 519   {
 520    cx=(AliCalorimeter*)fCalorimeters->At(i);
 521    if (cx)
 522    {
 523     s=cx->GetName();
 524     if (s == name) return cx;
 525    }
 526   }
 527
 528   return 0; // No matching name found
 529  }
 530 }
 531 ///////////////////////////////////////////////////////////////////////////
 532