ANALYSIS/AliAODParticle.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$ */
  17
  18 //___________________________________________________________
  19 /////////////////////////////////////////////////////////////
  20 //
  21 // class AliAODParticle
  22 //
  23 // Ali HBT Particle: simplified class TParticle
  24 // Simplified in order to minimize the size of object
  25 //  - we want to keep a lot of such a objects in memory
  26 // Additionaly adjusted for HBT Analysies purposes
  27 // + pointer to Track Points
  28 // + pointer to Cluster Map(s)
  29 //
  30 // Piotr.Skowronski@cern.ch
  31 //
  32 /////////////////////////////////////////////////////////////
  33 #include <TParticle.h>
  34
  35 #include "AliAODParticle.h"
  36 #include "AliClusterMap.h"
  37 #include "AliLog.h"
  38 #include "AliTrackPoints.h"
  39
  40 ClassImp(AliAODParticle)
  41
  42 //______________________________________________________________________________
  43 AliAODParticle::AliAODParticle():
  44  fPdgIdx(0), fIdxInEvent(0),fNPids(0),fPids(0x0),fPidProb(0x0),
  45  fCalcMass(0),fPx(0), fPy(0),fPz(0),fE(0), fVx(0), fVy(0),fVz(0),fVt(0),
  46  fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
  47 {//empty particle
  48 }
  49 //______________________________________________________________________________
  50
  51 AliAODParticle::AliAODParticle(Int_t pdg, Int_t idx,
  52                Double_t px, Double_t py, Double_t pz, Double_t etot,
  53                Double_t vx, Double_t vy, Double_t vz, Double_t time):
  54   fPdgIdx(0), fIdxInEvent(idx),fNPids(0),fPids(0x0),fPidProb(0x0),
  55   fCalcMass(0),
  56   fPx(px), fPy(py),fPz(pz),fE(etot),
  57   fVx(vx), fVy(vy),fVz(vz),fVt(time),
  58   fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
  59 {
  60 //mormal constructor
  61   SetPdgCode(pdg);
  62   if (GetPDG()) {
  63      fCalcMass    = GetPDG()->Mass();
  64   } else {
  65      Double_t a2 = fE*fE -fPx*fPx -fPy*fPy -fPz*fPz;
  66      if (a2 >= 0) fCalcMass =  TMath::Sqrt(a2);
  67      else         fCalcMass = -TMath::Sqrt(-a2);
  68   }
  69 }
  70 //______________________________________________________________________________
  71
  72 AliAODParticle::AliAODParticle(Int_t pdg, Float_t prob, Int_t idx,
  73                                Double_t px, Double_t py, Double_t pz, Double_t etot,
  74                                Double_t vx, Double_t vy, Double_t vz, Double_t time):
  75   fPdgIdx(0), fIdxInEvent(idx),fNPids(0),fPids(0x0),fPidProb(0x0),
  76   fCalcMass(0),
  77   fPx(px), fPy(py),fPz(pz),fE(etot),
  78   fVx(vx), fVy(vy),fVz(vz),fVt(time),
  79   fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
  80 {
  81 //mormal constructor
  82   SetPdgCode(pdg,prob);
  83   if (GetPDG()) {
  84      fCalcMass    = GetPDG()->Mass();
  85   } else {
  86      Double_t a2 = fE*fE -fPx*fPx -fPy*fPy -fPz*fPz;
  87      if (a2 >= 0) fCalcMass =  TMath::Sqrt(a2);
  88      else         fCalcMass = -TMath::Sqrt(-a2);
  89   }
  90 }
  91 //______________________________________________________________________________
  92
  93 AliAODParticle::AliAODParticle(const AliAODParticle& in):
  94    AliVAODParticle(in),
  95    fPdgIdx(in.fPdgIdx), fIdxInEvent(in.fIdxInEvent),
  96    fNPids(in.fNPids),fPids(new Int_t[fNPids]),fPidProb(new Float_t[fNPids]),
  97    fCalcMass(in.GetCalcMass()),
  98    fPx(in.Px()),fPy(in.Py()),fPz(in.Pz()),fE(in.E()),
  99    fVx(in.Vx()),fVy(in.Vy()),fVz(in.Vz()),fVt(in.T()),
 100    fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
 101 {
 102  //Copy constructor
 103 // Info("AliAODParticle(const AliAODParticle& in)","");
 104  for(Int_t i = 0; i<fNPids; i++)
 105   {
 106     fPids[i] =  in.fPids[i];
 107     fPidProb[i] = in.fPidProb[i];
 108   }
 109
 110  if (in.fTPCTrackPoints)
 111    fTPCTrackPoints = (AliTrackPoints*)in.fTPCTrackPoints->Clone();
 112  if (in.fITSTrackPoints)
 113    fITSTrackPoints = (AliTrackPoints*)in.fITSTrackPoints->Clone();
 114  if (in.fClusterMap)
 115    fClusterMap = (AliClusterMap*)in.fClusterMap->Clone();
 116 }
 117 //______________________________________________________________________________
 118
 119 AliAODParticle::AliAODParticle(const AliVAODParticle& in):
 120    AliVAODParticle(in),
 121    fPdgIdx(0), fIdxInEvent(in.GetUID()),
 122    fNPids(0),fPids(0x0),fPidProb(0x0),
 123    fCalcMass(-1.0),
 124    fPx(in.Px()),fPy(in.Py()),fPz(in.Pz()),fE(in.E()),
 125    fVx(in.Vx()),fVy(in.Vy()),fVz(in.Vz()),fVt(in.T()),
 126    fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
 127 {
 128  //Copy constructor
 129 // Info("AliAODParticle(const AliVAODParticle& in)","");
 130  for(Int_t i = 0; i<in.GetNumberOfPids(); i++)
 131   {
 132     SetPIDprobability(in.GetNthPid(i),in.GetNthPidProb(i));
 133   }
 134  SetPdgCode(in.GetPdgCode(),in.GetPidProb());
 135
 136  AliTrackPoints* tpts = in.GetTPCTrackPoints();
 137  if (tpts)  SetTPCTrackPoints((AliTrackPoints*)tpts->Clone());
 138
 139  tpts = in.GetITSTrackPoints();
 140  if (tpts) SetITSTrackPoints((AliTrackPoints*)tpts->Clone());
 141
 142  AliClusterMap* clmap = in.GetClusterMap();
 143  if (clmap) SetClusterMap((AliClusterMap*)clmap->Clone());
 144 }
 145 //______________________________________________________________________________
 146
 147 AliAODParticle::AliAODParticle(const TParticle &p,Int_t idx):
 148    fPdgIdx(0), fIdxInEvent(idx),
 149    fNPids(0),fPids(0x0),fPidProb(0x0),
 150    fCalcMass(p.GetCalcMass()),
 151    fPx(p.Px()),fPy(p.Py()),fPz(p.Pz()),fE(p.Energy()),
 152    fVx(p.Vx()),fVy(p.Vy()),fVz(p.Vz()),fVt(p.T()),
 153    fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
 154 {
 155  //all copied in the initialization
 156  SetPdgCode(p.GetPdgCode());
 157 }
 158 //______________________________________________________________________________
 159
 160 AliAODParticle::~AliAODParticle()
 161 {
 162 //dtor
 163   delete [] fPids;
 164   delete [] fPidProb;
 165   delete fTPCTrackPoints;
 166   delete fITSTrackPoints;
 167   delete fClusterMap;
 168 }
 169 //______________________________________________________________________________
 170
 171 void AliAODParticle::Clear(Option_t*)
 172 {
 173 //Must be implemented in order to store this object in Clones Array
 174   delete [] fPids;
 175   delete [] fPidProb;
 176   delete fTPCTrackPoints;
 177   delete fITSTrackPoints;
 178   delete fClusterMap;
 179
 180   fPids = 0x0;
 181   fPidProb = 0x0;
 182   fTPCTrackPoints = 0x0;
 183   fITSTrackPoints = 0x0;
 184   fClusterMap = 0x0;
 185 }
 186 //______________________________________________________________________________
 187
 188 AliVAODParticle& AliAODParticle::operator=(const AliVAODParticle& in)
 189 {
 190 //operator=
 191 //  Info("operator=(const AliVAODParticle& in)","AliAODParticle");
 192
 193   if (&in == this) return *this;
 194
 195   delete [] fPids;
 196   delete [] fPidProb;
 197   fPids = 0x0;
 198   fPidProb = 0x0;
 199   fNPids = 0;
 200
 201   Int_t npids = in.GetNumberOfPids();
 202   for (Int_t i = 0; i < npids; i++)
 203    {
 204      SetPIDprobability(in.GetNthPid(i),in.GetNthPidProb(i));
 205    }
 206
 207   SetPdgCode(in.GetPdgCode(),in.GetPidProb());
 208
 209   SetUID(in.GetUID());
 210
 211   fCalcMass = in.Mass();
 212
 213   fPx = in.Px();
 214   fPy = in.Py();
 215   fPz = in.Pz();
 216   fE = in.E();
 217   fVx = in.Vx();
 218   fVy = in.Vy();
 219   fVz = in.Vz();
 220   fVt = in.T();
 221
 222   delete fTPCTrackPoints;
 223   AliTrackPoints* tpts = in.GetTPCTrackPoints();
 224   fTPCTrackPoints = (tpts)?(AliTrackPoints*)tpts->Clone():0x0;
 225
 226   delete fITSTrackPoints;
 227   tpts = in.GetITSTrackPoints();
 228   fITSTrackPoints = (tpts)?(AliTrackPoints*)tpts->Clone():0x0;
 229
 230   delete fClusterMap;
 231   AliClusterMap* incmap = in.GetClusterMap();
 232   fClusterMap =  (incmap)?(AliClusterMap*)incmap->Clone():0x0;
 233
 234   return *this;
 235 }
 236 //______________________________________________________________________________
 237
 238 AliAODParticle& AliAODParticle::operator=(const AliAODParticle& in)
 239 {
 240 //assigment operator
 241 //  Info("operator=(const AliAODParticle& in)","AliAODParticle");
 242   if (&in == this) return *this;
 243   fNPids = in.fNPids;
 244   delete [] fPids;
 245   delete [] fPidProb;
 246   fPids = new Int_t[fNPids];
 247   fPidProb = new Float_t[fNPids];
 248   for (Int_t i = 0; i < fNPids;i++)
 249    {
 250      fPids[i]    = in.fPids[i];
 251      fPidProb[i] = in.fPidProb[i];
 252    }
 253
 254   fPdgIdx = in.fPdgIdx;
 255   fIdxInEvent = in.fIdxInEvent;
 256   fCalcMass = in.GetCalcMass();
 257   fPx = in.Px();
 258   fPy = in.Py();
 259   fPz = in.Pz();
 260   fE = in.E();
 261   fVx = in.Vx();
 262   fVy = in.Vy();
 263   fVz = in.Vz();
 264   fVt = in.T();
 265
 266   delete fTPCTrackPoints;
 267   fTPCTrackPoints = (in.fTPCTrackPoints)?(AliTrackPoints*)in.fTPCTrackPoints->Clone():0x0;
 268
 269   delete fITSTrackPoints;
 270   fITSTrackPoints = (in.fITSTrackPoints)?(AliTrackPoints*)in.fITSTrackPoints->Clone():0x0;
 271
 272   delete fClusterMap;
 273   fClusterMap =  (in.fClusterMap)?(AliClusterMap*)in.fClusterMap->Clone():0x0;
 274
 275   return *this;
 276 }
 277 //______________________________________________________________________________
 278
 279 void AliAODParticle::SetPdgCode(Int_t pdg,Float_t prob)
 280 {
 281 //Set PDG Code
 282   SetPIDprobability(pdg,prob);
 283   fPdgIdx = GetPidSlot(pdg);
 284 }
 285
 286 //______________________________________________________________________________
 287 void AliAODParticle::SetPIDprobability(Int_t pdg, Float_t prob)
 288 {
 289 //Sets another pdg code and corresponding probabilty
 290 //Ids are set in decreasing order
 291 //Check if total probability is not overcoming unity is performed
 292 //in case, warning is printed
 293   AliDebug(9,Form("SetPIDprobability","Setting PID %d prob %f",pdg,prob));
 294
 295   Float_t totprob = 0.0;//sums up probabilities
 296   Int_t idx = GetPidSlot(pdg);
 297   Int_t i;
 298
 299   if (idx > -1)
 300    {
 301      fPidProb[idx] = prob;
 302      for (i = 0; i < fNPids;i++) totprob+=fPidProb[i];
 303      if (totprob > (1.0+0.000001))
 304        {
 305          Warning("SetPIDprobability","Total probability greater than unity (%f)",totprob);
 306        }
 307      AliDebug(9,Form("Current Total probability: %f",totprob));
 308      return;
 309    }
 310
 311   Int_t currentpid = GetPdgCode();
 312   fNPids++;
 313   Float_t* aPidProbNew = new Float_t[fNPids];
 314   Int_t* aPidsNew = new Int_t[fNPids];
 315
 316   for (i = 0; i < fNPids-1;i++)//find a slot
 317    {
 318      if ( fPidProb[i] > prob)
 319       {
 320         AliDebug(9,Form("Copying entry %d",i));
 321         aPidProbNew[i] = fPidProb[i];
 322         aPidsNew[i] = fPids[i];
 323         totprob+=fPidProb[i];
 324       }
 325      else break;
 326    }
 327
 328   AliDebug(9,Form("SetPID","Setting new PID on entry %d",i));
 329   aPidProbNew[i] = prob;
 330   aPidsNew[i] = pdg;
 331   totprob+=prob;
 332
 333
 334   for (Int_t j = fNPids-1; j > i ;j--)//copy rest of old arays
 335    {
 336      AliDebug(9,Form("SetPID","Copying from old entry %d to new entry %d",j-1,j));
 337      aPidProbNew[j] = fPidProb[j-1];
 338      aPidsNew[j] = fPids[j-1];
 339      totprob+=fPidProb[j-1];
 340    }
 341
 342   delete [] fPidProb;
 343   delete [] fPids;
 344
 345   fPidProb = aPidProbNew;
 346   fPids = aPidsNew;
 347
 348   fPdgIdx = GetPidSlot(currentpid);
 349   if (fPdgIdx == -1) fPdgIdx = 0;
 350
 351   if (totprob > (1.0+0.000001))//space for numerical error
 352    {
 353      Warning("SetId","Total probability is greater than unity (%f)!!!",totprob);
 354      Print();
 355    }
 356 }
 357 //______________________________________________________________________________
 358
 359 Float_t AliAODParticle::GetPIDprobability(Int_t pdg) const
 360 {
 361 //Returns probability that this particle is the type of pdg
 362   Int_t idx = GetPidSlot(pdg);
 363   if (idx < 0) return 0.0;//such pid was not specified for this particle
 364   return fPidProb[idx];
 365 }
 366 //______________________________________________________________________________
 367
 368 const Char_t* AliAODParticle::GetName() const
 369 {
 370   //returns name of this particle
 371    static char def[4] = "XXX";
 372    const TParticlePDG *ap = TDatabasePDG::Instance()->GetParticle(GetPdgCode());
 373    if (ap) return ap->GetName();
 374    else    return def;
 375 }
 376 //______________________________________________________________________________
 377
 378 Int_t AliAODParticle::GetPidSlot(Int_t pdg) const
 379 {
 380  //returns position of the given PID in fPids (and fPidProb) array.
 381  if (fPids == 0x0) return -1;
 382  for (Int_t i = 0; i< fNPids; i++)
 383   {
 384    if (fPids[i] == pdg) return i;
 385   }
 386  return -1;
 387 }
 388 //______________________________________________________________________________
 389
 390 Int_t AliAODParticle::GetNthPid(Int_t idx) const
 391 {
 392   //returns PID sitting on slot idx in fPids
 393   if ( (idx < 0) || (idx >= fNPids) )
 394    {
 395      Error("GetNthPid","Out Of Bounds");
 396      return 0;
 397    }
 398   return fPids[idx];
 399 }
 400 //______________________________________________________________________________
 401
 402 Float_t AliAODParticle::GetNthPidProb(Int_t idx) const
 403 {
 404   //returns PID sitting on slot idx in fPidProb
 405   if ( (idx < 0) || (idx >= fNPids) )
 406    {
 407      Error("GetNthPid","Out Of Bounds");
 408      return 0;
 409    }
 410   return fPidProb[idx];
 411 }
 412 //______________________________________________________________________________
 413
 414 void AliAODParticle::Print(const Option_t * /*opt*/) const
 415 {
 416 //prints information about particle
 417   printf("____________________________________________________\n");
 418   printf("Idx: %d  PID: %d  Name: ",fIdxInEvent,GetPdgCode());
 419   TParticlePDG *pdgp = TDatabasePDG::Instance()->GetParticle(GetPdgCode());
 420   if (pdgp)
 421    {
 422      printf("%s Mass: %f\n",pdgp->GetName(),pdgp->Mass());
 423    }
 424   else
 425    {
 426      printf("Not known\n");
 427    }
 428
 429   printf("Px: %+f Py: %+f Pz: %+f E: %+f Calculated Mass: %f\nVx: %+f Vy: %+f Vz: %+f T: %+f\n",
 430           Px(),Py(),Pz(),E(),GetCalcMass(),Vx(),Vy(),Vz(),T());
 431
 432   for (Int_t i = 0; i < fNPids; i++)
 433    {
 434      printf("# %d  PID: %d  Probability %f name ",i,fPids[i],fPidProb[i]);
 435      const TParticlePDG *ap = TDatabasePDG::Instance()->GetParticle(fPids[i]);
 436      if (ap)
 437       {
 438         printf("%s Mass %f\n",ap->GetName(),ap->Mass());
 439       }
 440      else
 441       {
 442         printf("Not known\n");
 443       }
 444    }
 445
 446   if (fITSTrackPoints) fITSTrackPoints->Print();
 447   if (fTPCTrackPoints) fTPCTrackPoints->Print();
 448
 449 }
 450
 451 //______________________________________________________________________________
 452
 453 //void AliAODParticle::Streamer(TBuffer &b)
 454 //{
 455 //     // Stream all objects in the array to or from the I/O buffer.
 456 //   UInt_t R__s, R__c;
 457 //   Int_t i;
 458 //   if (b.IsReading())
 459 //    {
 460 //      delete [] fPids;
 461 //      delete [] fPidProb;
 462 //
 463 //      Version_t v = b.ReadVersion(&R__s, &R__c);
 464 //      if (v == 1)
 465 //       {
 466 //         AliAODParticle::Class()->ReadBuffer(b, this);
 467 //      }
 468 //      else
 469 //       {
 470 //        TObject::Streamer(b);
 471 //       b >> fPdgIdx;
 472 //       b >> fIdxInEvent;
 473 //
 474 //       b >> fNPids;
 475 //       Int_t* fPids = new Int_t[fNPids];
 476 //        Float_t* fPidProb = new Float_t[fNPids];
 477 //        for (i = 0;i<fNPids;i++)
 478 //         {
 479 //           b >> fPids[i];
 480 //         }
 481 //        for (i = 0;i<fNPids;i++)
 482 //        {
 483 //          b >> fPidProb[i];
 484 //         }
 485 //        b >> fCalcMass;
 486 //
 487 //        b >> fPx;
 488 //       b >> fPy;
 489 //       b >> fPz;
 490 //        b >> fE;
 491 //
 492 //       b >> fVx;
 493 //        b >> fVy;
 494 //        b >> fVz;
 495 //       b >> fVt;
 496 //       Info("Streamer","Read data");
 497 //        Print();
 498 //       }
 499 //
 500 //      b.CheckByteCount(R__s, R__c,AliAODParticle::IsA());
 501 //    }
 502 //  else
 503 //   {
 504 //     R__c = b.WriteVersion(AliAODParticle::IsA(), kTRUE);
 505 //     TObject::Streamer(b);
 506 //     Info("Streamer","Read data");
 507 //     Print();
 508 //
 509 //     b << fPdgIdx;
 510 //     b << fIdxInEvent;
 511 //     b << fNPids;
 512 //     for (i = 0;i<fNPids;i++)
 513 //      {
 514 //        b << fPids[i];
 515 //      }
 516 //      {
 517 //      {
 518 //     for (i = 0;i<fNPids;i++)
 519 //     {
 520 //        b << fPidProb[i];
 521 //      }
 522 //     b << fCalcMass;
 523 //
 524 //     b << fPx;
 525 //     b << fPy;
 526 //     b << fPz;
 527 //     b << fE;
 528 //
 529 //     b << fVx;
 530 //     b << fVy;
 531 //     b << fVz;
 532 //     b << fVt;
 533 //
 534 //    b.SetByteCount(R__c, kTRUE);
 535 //   }
 536 //}