AliAODParticle -> AliVAODParticle; AliAODStdParticle -> AliAODParticle
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 Apr 2004 14:19:08 +0000 (14:19 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 Apr 2004 14:19:08 +0000 (14:19 +0000)
20 files changed:
ANALYSIS/ANALYSISLinkDef.h
ANALYSIS/AliAOD.cxx
ANALYSIS/AliAOD.h
ANALYSIS/AliAODParticle.cxx
ANALYSIS/AliAODParticle.h
ANALYSIS/AliAODParticleCut.cxx
ANALYSIS/AliAODParticleCut.h
ANALYSIS/AliAODRun.cxx
ANALYSIS/AliAODRun.h
ANALYSIS/AliClusterMap.cxx
ANALYSIS/AliFlowAnalysis.cxx
ANALYSIS/AliReader.cxx
ANALYSIS/AliReader.h
ANALYSIS/AliReaderESD.cxx
ANALYSIS/AliReaderESD.h
ANALYSIS/AliRunAnalysis.cxx
ANALYSIS/AliVAODParticle.cxx [new file with mode: 0644]
ANALYSIS/AliVAODParticle.h [new file with mode: 0644]
ANALYSIS/analysis.C
ANALYSIS/libANALYSIS.pkg

index 8d59d57f3534b0ae39fb5e644a23106f0b8bd9f6..347b7f2e72fc46324bdef06185ec67c362f1311d 100644 (file)
@@ -10,8 +10,8 @@
 #pragma link C++ class AliAnalysis+;
 
 #pragma link C++ class AliAOD+;
+#pragma link C++ class AliVAODParticle+;
 #pragma link C++ class AliAODParticle+;
-#pragma link C++ class AliAODStdParticle+;
 
 #pragma link C++ class AliAODRun+;
 
index 7e3de10297082aad604693d2ab4ac0a892f80b50..18f92254e3315171061677a15dd76d45598d4bd4 100644 (file)
@@ -24,7 +24,7 @@
 #include <TParticle.h>
 #include "AliAOD.h"
 
-#include "AliAODStdParticle.h"
+#include "AliAODParticle.h"
 
 ClassImp(AliAOD)
 
@@ -38,7 +38,7 @@ void  AliAOD::AddParticle(TParticle* part, Int_t idx)
      Error("AddParticle(TParticle*,Int_t)","pointer to particle is NULL");
      return;
    }
-  AddParticle( new AliAODStdParticle(*part,idx) );
+  AddParticle( new AliAODParticle(*part,idx) );
 }
 /**************************************************************************/
 
@@ -47,7 +47,7 @@ void  AliAOD::AddParticle(Int_t pdg, Int_t idx,
                           Double_t vx, Double_t vy, Double_t vz, Double_t time)
 {
   //adds particle to event
-  AddParticle(new  AliAODStdParticle(pdg,idx,px,py,pz,etot,vx,vy,vz,time));
+  AddParticle(new  AliAODParticle(pdg,idx,px,py,pz,etot,vx,vy,vz,time));
 }
 /**************************************************************************/
 
@@ -57,7 +57,7 @@ void AliAOD::SwapParticles(Int_t i, Int_t j)
   if ( (i<0) || (i>=GetNumberOfParticles()) ) return;
   if ( (j<0) || (j>=GetNumberOfParticles()) ) return;
 
-  AliAODParticle* tmp = (AliAODParticle*)fParticles.At(i);
+  AliVAODParticle* tmp = (AliVAODParticle*)fParticles.At(i);
   fParticles.AddAt(fParticles.At(j),i);
   fParticles.AddAt(tmp,j);
 }
index 0ab8c2f816dc74a87d501ead2d7b2f84edbcf3f3..bd66e8872c5d03bcbf12bef57f28522334e5e9ef 100644 (file)
@@ -13,7 +13,7 @@
 
 #include <TObject.h>
 #include <TObjArray.h>
-#include "AliAODParticle.h"
+#include "AliVAODParticle.h"
 
 class TParticle;
 
@@ -24,8 +24,8 @@ public:
 
   virtual TObjArray*       GetParticles() {return &fParticles;};
   virtual Int_t            GetNumberOfParticles() const  {return fParticles.GetEntriesFast();}
-  virtual AliAODParticle*  GetParticle(Int_t index) const {return (AliAODParticle*) fParticles[index];}
-  virtual void             AddParticle(AliAODParticle* particle)  {fParticles.Add(particle);};
+  virtual AliVAODParticle*  GetParticle(Int_t index) const {return (AliVAODParticle*) fParticles[index];}
+  virtual void             AddParticle(AliVAODParticle* particle)  {fParticles.Add(particle);};
   virtual void             AddParticle(TParticle* part, Int_t idx); //adds particle to the event
   virtual void             AddParticle(Int_t pdg, Int_t idx, Double_t px, Double_t py, Double_t pz, Double_t etot,
                                        Double_t vx, Double_t vy, Double_t vz, Double_t time);
index 36cf642fdb508c14981447afe8902ed556c1e18d..74c30d875b7ca319d89e35ec4de61b187fc20bee 100644 (file)
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
+#include "AliAODParticle.h"
+//___________________________________________________________
 /////////////////////////////////////////////////////////////
 //
-// base class for AOD particles
+// class AliAODParticle
 //
-// Most of the methods defined in this base class (or even all of them)
-// should be redefined in derived classes. Some methods like Pt() or
-// Vx() have default implementation, but they are not optimised for
-// performance. It is likely that they can be (and should be) implemented
-// in the derived classes in a way which gives faster access.
+// Ali HBT Particle: simplified class TParticle
+// Simplified in order to minimize the size of object
+//  - we want to keep a lot of such a objects in memory
+// Additionaly adjusted for HBT Analysies purposes
+// + pointer to Track Points
+// + pointer to Cluster Map(s)
 //
-// Algorithms and analysis classes should as much as possible use the
-// interface of the base class instead of special methods of derived
-// classes. This allows to run the code on all types of particles.
+// Piotr.Skowronski@cern.ch
 //
 /////////////////////////////////////////////////////////////
+#include <TParticle.h>
+#include "AliTrackPoints.h"
+#include "AliClusterMap.h"
 
-#include "AliAODParticle.h"
+ClassImp(AliAODParticle)
 
-Int_t AliAODParticle::fgDebug = 0;
+//______________________________________________________________________________
+AliAODParticle::AliAODParticle():  
+ fPdgIdx(0), fIdxInEvent(0),fNPids(0),fPids(0x0),fPidProb(0x0),
+ fCalcMass(0),fPx(0), fPy(0),fPz(0),fE(0), fVx(0), fVy(0),fVz(0),fVt(0),
+ fTrackPoints(0x0),fClusterMap(0x0)
+{//empty particle
+}
+//______________________________________________________________________________
 
-ClassImp(AliAODParticle)
+AliAODParticle::AliAODParticle(Int_t pdg, Int_t idx,
+               Double_t px, Double_t py, Double_t pz, Double_t etot,
+               Double_t vx, Double_t vy, Double_t vz, Double_t time):  
+  fPdgIdx(0), fIdxInEvent(idx),fNPids(0),fPids(0x0),fPidProb(0x0),
+  fCalcMass(0), 
+  fPx(px), fPy(py),fPz(pz),fE(etot), 
+  fVx(vx), fVy(vy),fVz(vz),fVt(time),
+  fTrackPoints(0x0),fClusterMap(0x0)
+{
+//mormal constructor
+  SetPdgCode(pdg);
+  if (GetPDG()) {
+     fCalcMass    = GetPDG()->Mass();
+  } else {
+     Double_t a2 = fE*fE -fPx*fPx -fPy*fPy -fPz*fPz;
+     if (a2 >= 0) fCalcMass =  TMath::Sqrt(a2);
+     else         fCalcMass = -TMath::Sqrt(-a2);
+  }
+}
+//______________________________________________________________________________
+
+AliAODParticle::AliAODParticle(Int_t pdg, Float_t prob, Int_t idx, 
+                               Double_t px, Double_t py, Double_t pz, Double_t etot,
+                               Double_t vx, Double_t vy, Double_t vz, Double_t time):
+  fPdgIdx(0), fIdxInEvent(idx),fNPids(0),fPids(0x0),fPidProb(0x0),
+  fCalcMass(0), 
+  fPx(px), fPy(py),fPz(pz),fE(etot), 
+  fVx(vx), fVy(vy),fVz(vz),fVt(time),
+  fTrackPoints(0x0),fClusterMap(0x0)
+{
+//mormal constructor
+  SetPdgCode(pdg,prob);
+  if (GetPDG()) {
+     fCalcMass    = GetPDG()->Mass();
+  } else {
+     Double_t a2 = fE*fE -fPx*fPx -fPy*fPy -fPz*fPz;
+     if (a2 >= 0) fCalcMass =  TMath::Sqrt(a2);
+     else         fCalcMass = -TMath::Sqrt(-a2);
+  }
+}
+//______________________________________________________________________________
+AliAODParticle::AliAODParticle(const AliAODParticle& in):
+   AliVAODParticle(in),
+   fPdgIdx(in.fPdgIdx), fIdxInEvent(in.fIdxInEvent),
+   fNPids(in.fNPids),fPids(new Int_t[fNPids]),fPidProb(new Float_t[fNPids]),
+   fCalcMass(in.GetCalcMass()),
+   fPx(in.Px()),fPy(in.Py()),fPz(in.Pz()),fE(in.Energy()), 
+   fVx(in.Vx()),fVy(in.Vy()),fVz(in.Vz()),fVt(in.T()),
+   fTrackPoints(0x0), fClusterMap(0x0)
+{
+ //Copy constructor
+ for(Int_t i = 0; i<fNPids; i++)
+  {
+    fPids[i] =  in.fPids[i];
+    fPidProb[i] = in.fPidProb[i];
+  }
+ if (in.fTrackPoints)
+   fTrackPoints = (AliTrackPoints*)in.fTrackPoints->Clone();
+ if (in.fClusterMap)
+   fClusterMap = (AliClusterMap*)in.fClusterMap->Clone();
+}
+
+//______________________________________________________________________________
+AliAODParticle::AliAODParticle(const TParticle &p,Int_t idx):
+   fPdgIdx(0), fIdxInEvent(idx),
+   fNPids(0),fPids(0x0),fPidProb(0x0),
+   fCalcMass(p.GetCalcMass()),
+   fPx(p.Px()),fPy(p.Py()),fPz(p.Pz()),fE(p.Energy()), 
+   fVx(p.Vx()),fVy(p.Vy()),fVz(p.Vz()),fVt(p.T()),
+   fTrackPoints(0x0),fClusterMap(0x0)
+{
+ //all copied in the initialization
+ SetPdgCode(p.GetPdgCode());
+}
+//______________________________________________________________________________
+
+AliAODParticle::~AliAODParticle()
+{
+//dtor  
+  delete [] fPids;
+  delete [] fPidProb;
+  delete fTrackPoints;
+  delete fClusterMap;
+}
+//______________________________________________________________________________
+
+AliAODParticle& AliAODParticle::operator=(const AliAODParticle& in)
+{
+//assigment operator
+  
+  fNPids = in.fNPids;
+  delete [] fPids;
+  delete [] fPidProb;
+  Int_t* fPids = new Int_t[fNPids];
+  Float_t* fPidProb = new Float_t[fNPids];
+  for (Int_t i = 0; i < fNPids;i++)
+   {
+     fPids[i]    = in.fPids[i];
+     fPidProb[i] = in.fPidProb[i];
+   }
+   
+  fPdgIdx = in.fPdgIdx; 
+  fIdxInEvent = in.fIdxInEvent;  
+  fCalcMass = in.GetCalcMass();
+  fPx = in.Px();
+  fPy = in.Py();
+  fPz = in.Pz();
+  fE = in.Energy(); 
+  fVx = in.Vx();
+  fVy = in.Vy();
+  fVz = in.Vz();
+  fVt = in.T();
+  
+  delete fTrackPoints;
+  fTrackPoints = (in.fTrackPoints)?(AliTrackPoints*)fTrackPoints->Clone():0x0;
+  
+  delete fClusterMap;
+  fClusterMap =  (in.fClusterMap)?(AliClusterMap*)in.fClusterMap->Clone():0x0;
+  
+  return *this;
+}
+//______________________________________________________________________________
+
+void AliAODParticle::SetPdgCode(Int_t pdg,Float_t prob)
+{
+  SetPIDprobability(pdg,prob);
+  fPdgIdx = GetPidSlot(pdg);
+}
+
+//______________________________________________________________________________
+void AliAODParticle::SetPIDprobability(Int_t pdg, Float_t prob)
+{
+//Sets another pdg code and corresponding probabilty
+//Ids are set in decreasing order
+//Check if total prbaility is not ivercoming unity is performed
+//in case, warning is printed
+  if (GetDebug() > 9) Info("SetPIDprobability","Setting PID %d prob %f",pdg,prob);
+
+  Float_t totprob = 0.0;//sums up probabilities
+  Int_t idx = GetPidSlot(pdg);
+  Int_t i;
+  if (idx > -1) 
+   {
+     fPidProb[idx] = prob;
+     for (i = 0; i < fNPids;i++) totprob+=fPidProb[i];
+     if (totprob > (1.0+0.000001))
+       {
+         Warning("SetPIDprobability","Total probability greater than unity (%f)",totprob);
+       }
+     if (GetDebug() > 9) 
+      {
+        Info("SetPIDprobability","Current Total probability: %f",totprob);
+      }
+     return;
+   }
+    
+  Int_t currentpid = GetPdgCode();
+  fNPids++;
+  Float_t* aPidProbNew = new Float_t[fNPids];
+  Int_t* aPidsNew = new Int_t[fNPids];
+  
+  for (i = 0; i < fNPids-1;i++)//find a slot
+   {
+     if ( fPidProb[i] > prob)
+      {
+        if (GetDebug()>9) Info("SetPID","Copying entry %d",i);
+        aPidProbNew[i] = fPidProb[i];
+        aPidsNew[i] = fPids[i];
+        totprob+=fPidProb[i];
+      }
+     else break;
+   }
+
+  if (GetDebug() > 9) Info("SetPID","Setting new PID on entry %d",i);
+  aPidProbNew[i] = prob;
+  aPidsNew[i] = pdg;
+  totprob+=prob;
+  
+
+  for (Int_t j = fNPids-1; j > i ;j--)//copy rest of old araays 
+   {
+     if (GetDebug() > 9) Info("SetPID","Copying from old entry %d to new entry %d",j-1,j);
+     aPidProbNew[j] = fPidProb[j-1];
+     aPidsNew[j] = fPids[j-1];
+     totprob+=fPidProb[j-1];
+   }
+
+  delete [] fPidProb;
+  delete [] fPids;
+  
+  fPidProb = aPidProbNew;
+  fPids = aPidsNew;
+  
+  fPdgIdx = GetPidSlot(currentpid);
+  if (fPdgIdx == -1) fPdgIdx = 0;
+  
+  if (totprob > (1.0+0.000001))//place for numerical error
+   {
+     Warning("SetId","Total probability is greater than unity (%f)!!!",totprob);
+     Print();
+   }
+}
+//______________________________________________________________________________
 
+Float_t AliAODParticle::GetPIDprobability(Int_t pdg) const
+{
+//Returns probability that this particle is the type of pdg
+  Int_t idx = GetPidSlot(pdg);
+  if (idx < 0) return 0.0;//such pid was not specified for this particle
+  return fPidProb[idx];
+}
+//______________________________________________________________________________
+
+const Char_t* AliAODParticle::GetName() const 
+{
+  //returns name of this particle 
+   static char def[4] = "XXX";
+   const TParticlePDG *ap = TDatabasePDG::Instance()->GetParticle(GetPdgCode());
+   if (ap) return ap->GetName();
+   else    return def;
+}
+//______________________________________________________________________________
+
+Int_t AliAODParticle::GetPidSlot(Int_t pdg) const
+{
+ //returns position of the given PID in fPids (and fPidProb) array.
+ if (fPids == 0x0) return -1;
+ for (Int_t i = 0; i< fNPids; i++)
+  {
+   if (fPids[i] == pdg) return i;
+  }
+ return -1;
+}
+//______________________________________________________________________________
+
+Int_t AliAODParticle::GetNthPid(Int_t idx) const
+{
+  //returns PID sitting on slot idx in fPids
+  if ( (idx < 0) || (idx >= fNPids) )
+   {
+     Error("GetNthPid","Out Of Bounds");
+     return 0;
+   }
+  return fPids[idx];
+}
+//______________________________________________________________________________
+
+Float_t AliAODParticle::GetNthPidProb(Int_t idx) const
+{
+  //returns PID sitting on slot idx in fPidProb
+  if ( (idx < 0) || (idx >= fNPids) )
+   {
+     Error("GetNthPid","Out Of Bounds");
+     return 0;
+   }
+  return fPidProb[idx];
+}
+//______________________________________________________________________________
+
+void AliAODParticle::Print() const
+{
+//prints information about particle
+  printf("____________________________________________________\n");
+  printf("Idx: %d  PID: %d  Name: ",fIdxInEvent,GetPdgCode());
+  TParticlePDG *pdgp = TDatabasePDG::Instance()->GetParticle(GetPdgCode());
+  if (pdgp)
+   {
+     printf("%s Mass: %f\n",pdgp->GetName(),pdgp->Mass());
+   }
+  else
+   {
+     printf("Not known\n");
+   }
+  
+  printf("Px: %+f Py: %+f Pz: %+f E: %+f Calculated Mass: %f\nVx: %+f Vy: %+f Vz: %+f T: %+f\n",
+          Px(),Py(),Pz(),Energy(),GetCalcMass(),Vx(),Vy(),Vz(),T());
+
+  for (Int_t i = 0; i < fNPids; i++)
+   {
+     printf("# %d  PID: %d  Probability %f name ",i,fPids[i],fPidProb[i]);
+     const TParticlePDG *ap = TDatabasePDG::Instance()->GetParticle(fPids[i]);
+     if (ap)
+      {
+        printf("%s Mass %f\n",ap->GetName(),ap->Mass());
+      }
+     else
+      {
+        printf("Not known\n");
+      }
+   }
+}
+
+//______________________________________________________________________________
+
+//void AliAODParticle::Streamer(TBuffer &b)
+//{
+//     // Stream all objects in the array to or from the I/O buffer.
+//   UInt_t R__s, R__c;
+//   Int_t i;
+//   if (b.IsReading()) 
+//    {
+//      delete [] fPids;
+//      delete [] fPidProb;
+//      
+//      Version_t v = b.ReadVersion(&R__s, &R__c);
+//      if (v == 1)
+//       {
+//         AliAODParticle::Class()->ReadBuffer(b, this);
+//      }
+//      else
+//       {
+//        TObject::Streamer(b);
+//       b >> fPdgIdx;
+//       b >> fIdxInEvent;
+//       
+//       b >> fNPids;
+//       Int_t* fPids = new Int_t[fNPids];
+//        Float_t* fPidProb = new Float_t[fNPids];
+//        for (i = 0;i<fNPids;i++) 
+//         {
+//           b >> fPids[i];
+//         }
+//        for (i = 0;i<fNPids;i++) 
+//        {
+//          b >> fPidProb[i];
+//         }
+//        b >> fCalcMass;
+//
+//        b >> fPx;
+//       b >> fPy;
+//       b >> fPz;
+//        b >> fE;
+//
+//       b >> fVx;
+//        b >> fVy;
+//        b >> fVz;
+//       b >> fVt;
+//       Info("Streamer","Read data");
+//        Print();
+//       }
+//
+//      b.CheckByteCount(R__s, R__c,AliAODParticle::IsA());
+//    } 
+//  else 
+//   {
+//     R__c = b.WriteVersion(AliAODParticle::IsA(), kTRUE);
+//     TObject::Streamer(b);
+//     Info("Streamer","Read data");
+//     Print();
+//
+//     b << fPdgIdx;
+//     b << fIdxInEvent;
+//     b << fNPids;
+//     for (i = 0;i<fNPids;i++) 
+//      {
+//        b << fPids[i];
+//      }
+//      {
+//      {
+//     for (i = 0;i<fNPids;i++) 
+//     {
+//        b << fPidProb[i];
+//      }
+//     b << fCalcMass;
+//
+//     b << fPx;
+//     b << fPy;
+//     b << fPz;
+//     b << fE;
+//
+//     b << fVx;
+//     b << fVy;
+//     b << fVz;
+//     b << fVt;
+//
+//    b.SetByteCount(R__c, kTRUE);
+//   }
+//}
index cc1d0325ae60b9a65f84ffa29a3de51157a7bd64..d9b81e955694f1b14a97e820fef17bf9867d67a6 100644 (file)
 #ifndef ALIAODPARTICLE_H
 #define ALIAODPARTICLE_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
+//___________________________________________________________
 /////////////////////////////////////////////////////////////
 //
-// base class for AOD particles
+// class AliAODParticle
+//
+// Ali HBT Particle: simplified class TParticle
+// Simplified in order to minimize the size of the object
+//  - we want to keep a lot of such a objects in memory
+// Additionaly adjusted for HBT Analysies purposes
+// + pointer to Track Points
+// + pointer to Cluster Map(s)
+//
+// Piotr.Skowronski@cern.ch
 //
 /////////////////////////////////////////////////////////////
 
-#include <TObject.h>
-#include <TLorentzVector.h>
-#include <TVector3.h>
+#include "AliVAODParticle.h"
+//#include <TLorentzVector.h>
+//#include <TMath.h>
+#include <TDatabasePDG.h>
 
-#include "AliAnalysis.h"
 
+class TParticle;
 class AliTrackPoints;
 class AliClusterMap;
 
-class AliAODParticle : public TObject {
+class AliAODParticle: public AliVAODParticle
+{
 public:
-   AliAODParticle(){}
-   virtual ~AliAODParticle(){}
-  // kinematics
-  virtual TLorentzVector   FourMomentum() const = 0;
-  virtual TVector3         Momentum() const {return FourMomentum().Vect();};
-  virtual Double_t         Mass() const {return FourMomentum().M();};
-  virtual Double_t         E() const {return FourMomentum().E();};
-  virtual Double_t         P() const {return FourMomentum().P();};
-  virtual Double_t         Pt() const {return FourMomentum().Pt();};
-  virtual Double_t         Px() const {return FourMomentum().Px();};
-  virtual Double_t         Py() const {return FourMomentum().Py();};
-  virtual Double_t         Pz() const {return FourMomentum().Pz();};
-  virtual Double_t         Phi() const {return FourMomentum().Phi();};
-  virtual Double_t         Theta() const {return FourMomentum().Theta();};
-  virtual Double_t         Eta() const {return FourMomentum().Eta();};
-  virtual Double_t         Y() const {return FourMomentum().Rapidity();};
-
-  // PID
-  virtual Double_t         Charge() const = 0;
-  virtual Double_t         GetProbability(Int_t pdg) const = 0;
-  virtual Int_t            GetMostProbable() const = 0;
-  
-  virtual Int_t            GetPdgCode() const = 0;//We need to assume some PID (f.e. energy calculation) 
-                                                  //sotimes one track can apear in analysis twise (e.g. ones as pion ones as kaon)
-  
-  // vertices
-  virtual TVector3         ProductionVertex() const = 0;
-  virtual Double_t         Vx() const {return ProductionVertex().X();};
-  virtual Double_t         Vy() const {return ProductionVertex().Y();};
-  virtual Double_t         Vz() const {return ProductionVertex().Z();};
-  virtual AliAODParticle*  Mother() const {return NULL;};
-  virtual Bool_t           HasDecayVertex() const {return kFALSE;};
-  virtual TVector3         DecayVertex() const {return TVector3();};
-  virtual Int_t            NumberOfDaughters() const {return 0;};
-  virtual AliAODParticle*  Daughter(Int_t /*index*/) const {return NULL;};
-
-
-  // type information
-  virtual Bool_t           IsSimulated() {return kFALSE;};
-  virtual Bool_t           IsTrack() {return kFALSE;};
-  virtual Bool_t           IsCluster() {return kFALSE;};
-
-  //HBT specific 
-  virtual AliTrackPoints*  GetTrackPoints() const {return 0x0;}
-  virtual AliClusterMap*   GetClusterMap() const {return 0x0;}
-  virtual void             Print() const = 0;
-
-  static void    SetDebug(Int_t dbg=1){fgDebug=dbg;}
-  static Int_t   GetDebug(){return fgDebug;}
+                                // ****** constructors and destructor
+  AliAODParticle();
+  AliAODParticle(const AliAODParticle& in); 
+  AliAODParticle(Int_t pdg, Int_t idx, Double_t px, Double_t py, Double_t pz, Double_t etot,
+                 Double_t vx, Double_t vy, Double_t vz, Double_t time);
+
+  AliAODParticle(Int_t pdg, Float_t prob, Int_t idx, Double_t px, Double_t py, Double_t pz, Double_t etot,
+                 Double_t vx, Double_t vy, Double_t vz, Double_t time);
+
+  AliAODParticle(const TParticle& p, Int_t idx);
+
+  virtual ~AliAODParticle();
+  
+  AliAODParticle& operator=(const AliAODParticle& in); 
+  
+  TLorentzVector FourMomentum() const {TLorentzVector v(fPx,fPy,fPz,fE);return v;}
+  TVector3       ProductionVertex() const {TVector3 v(fVx,fVy,fVz);return v;}
+  
+  void           SetPIDprobability(Int_t pdg, Float_t prob = 1.0);
+  Float_t        GetPIDprobability(Int_t pdg) const;
+  Double_t       GetProbability(Int_t pdg) const {return GetPIDprobability(pdg);}
+  Int_t          GetMostProbable() const { return (fPids)?fPids[0]:0;}
+  
+  Int_t          GetPdgCode      () const { return (fPids)?fPids[fPdgIdx]:0;}
+
+  Float_t        GetPidProb      () const { return (fPidProb)?fPidProb[fPdgIdx]:0;}
+  
+  Int_t          GetUID          () const { return fIdxInEvent;}
+  Int_t          GetNumberOfPids () const { return fNPids;}
+  Int_t          GetNthPid         (Int_t idx) const;
+  Float_t        GetNthPidProb     (Int_t idx) const;
+      
+  void           SetPdgCode(Int_t pdg, Float_t prob = 1.0);
+  Double_t       GetCalcMass     () const { return fCalcMass; }
+  Double_t       Mass            () const { return (GetPDG())?GetPDG()->Mass():-1.;}
+  
+  
+  TParticlePDG*  GetPDG          () const {return TDatabasePDG::Instance()->GetParticle(GetPdgCode());}
+  Double_t       Charge          () const { return (GetPDG())?GetPDG()->Charge():1.e8;}
+  
+  Int_t          Beauty          ()  { return GetPDG()->Beauty(); }
+  Int_t          Charm           ()  { return GetPDG()->Charm(); }
+  Int_t          Strangeness     ()  { return GetPDG()->Strangeness();}
+  void ProductionVertex(TLorentzVector &v) const { v.SetXYZT(fVx,fVy,fVz,fVt);}
+
+
+  Double_t         Vx    () const { return fVx;}
+  Double_t         Vy    () const { return fVy;}
+  Double_t         Vz    () const { return fVz;}
+  Double_t         T     () const { return fVt;}
+
+  Double_t         Px    () const { return fPx; } //X coordinate of the momentum
+  Double_t         Py    () const { return fPy; } //Y coordinate of the momentum
+  Double_t         Pz    () const { return fPz; } //Z coordinate of the momentum
+  Double_t         P     () const                 //momentum
+    { return TMath::Sqrt(fPx*fPx+fPy*fPy+fPz*fPz); }
+  
+  void Momentum(TLorentzVector &v) const { v.SetPxPyPzE(fPx,fPy,fPz,fE);}
+    
+  Double_t         Pt    () const  //transverse momentum
+    { return TMath::Sqrt(fPx*fPx+fPy*fPy); }
+  Double_t         Energy() const { return fE; }
+  
+                                   //Pseudo Rapidity
+  Double_t         Eta   () const { if (P() != fPz) return 0.5*TMath::Log((P()+fPz)/(P()-fPz)); 
+                                    else return 1.e30;}
+
+                                   //Rapidity
+  Double_t         Y     () const { if (fE  != fPz) return 0.5*TMath::Log((fE+fPz)/(fE-fPz));
+                                    else return 1.e30;}
+
+  Double_t         Phi   () const { return TMath::Pi()+TMath::ATan2(-fPy,-fPx); }
+
+  Double_t         Theta () const { return (fPz==0)?TMath::PiOver2():TMath::ACos(fPz/P()); }
+
+  // setters
+
+  void           SetMomentum(Double_t px, Double_t py, Double_t pz, Double_t e)
+                             {fPx=px; fPy=py; fPz=pz; fE=e;}
+  void           SetMomentum(const TLorentzVector& p)
+                             {SetMomentum(p.Px(),p.Py(),p.Pz(),p.Energy());}
+
+  void           SetProductionVertex(Double_t vx, Double_t vy, Double_t vz, Double_t t)
+                             {fVx=vx; fVy=vy; fVz=vz; fVt=t;}
+  void           SetProductionVertex(const TLorentzVector& v)
+                             {SetProductionVertex(v.X(),v.Y(),v.Z(),v.T());}
+  void           SetCalcMass(Double_t mass) {fCalcMass = mass;}
+  
+  void           SetUID(Int_t id){fIdxInEvent = id;}
+  
+  const Char_t*  GetName() const; 
+  void           Print() const;
+  
+  void           SetTrackPoints(AliTrackPoints* tpts){fTrackPoints = tpts;}
+  AliTrackPoints* GetTrackPoints() const {return fTrackPoints;}
+  void           SetClusterMap(AliClusterMap* cm){fClusterMap = cm;}
+  AliClusterMap* GetClusterMap() const {return fClusterMap;}
+  
+  
+protected:
+  Int_t          GetPidSlot(Int_t pdg) const;//returns position of the given PID in fPids (and fPidProb) array.
 
 private:
-  static Int_t fgDebug;//! debug level for all the analysis package
+  Char_t         fPdgIdx;               // index of PDG code of the particle in fPids
+  Int_t          fIdxInEvent;           // index of a particle: the same particle can appear in the event
+                                        //  many times with different pid's. Idx allows to check that they are the same particles
+  Int_t          fNPids;                // number of non-zero proboble Pids
+  Int_t         *fPids;                 // [fNPids] Array with PIDs
+  Float_t       *fPidProb;              // [fNPids] PIDs probabilities
+  Double_t       fCalcMass;             // Calculated mass
+
+  
+  Double_t       fPx;                   // x component of momentum
+  Double_t       fPy;                   // y component of momentum
+  Double_t       fPz;                   // z component of momentum
+  Double_t       fE;                    // Energy
+
+  Double_t       fVx;                   // x of production vertex
+  Double_t       fVy;                   // y of production vertex
+  Double_t       fVz;                   // z of production vertex
+  Double_t       fVt;                   // t of production vertex
 
-  ClassDef(AliAODParticle,1)  // base class for AOD particles
+  AliTrackPoints* fTrackPoints;      // track positions along trajectory - used by anti-merging cut
+  AliClusterMap*  fClusterMap;       // bit map of cluters occupation; 1 if has cluter on given layer/padrow/...
+    
+  ClassDef(AliAODParticle,3)  // TParticle vertex particle information
 };
 
 #endif
index aa4a40e6e412198adea9f45285580aa4b5c55443..ea9cb5f78bae4976c2485c1d7c90f71e94e08003 100644 (file)
@@ -81,7 +81,7 @@ AliAODParticleCut::~AliAODParticleCut()
 } 
 /******************************************************************/
 
-Bool_t AliAODParticleCut::Pass(AliAODParticle* p) const
+Bool_t AliAODParticleCut::Pass(AliVAODParticle* p) const
 {
 //method checks all the cuts that are set (in the list)
 //If any of the baseCuts rejects particle False(rejection) is returned
@@ -424,7 +424,7 @@ AliAODLogicalOperCut::~AliAODLogicalOperCut()
 }
 /******************************************************************/
 
-Bool_t AliAODLogicalOperCut::AliAODDummyBaseCut::Pass(AliAODParticle* /*part*/)  const
+Bool_t AliAODLogicalOperCut::AliAODDummyBaseCut::Pass(AliVAODParticle* /*part*/)  const
 {
   //checks if particles passes properties defined by this cut
   Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
@@ -462,7 +462,7 @@ void AliAODLogicalOperCut::Streamer(TBuffer &b)
 /******************************************************************/
 ClassImp(AliAODOrCut)
 
-Bool_t AliAODOrCut::Pass(AliAODParticle * p) const
+Bool_t AliAODOrCut::Pass(AliVAODParticle * p) const
 {
   //returns true when rejected 
   //AND operation is a little bit misleading but is correct
@@ -475,7 +475,7 @@ Bool_t AliAODOrCut::Pass(AliAODParticle * p) const
 
 ClassImp(AliAODAndCut)
 
-Bool_t AliAODAndCut::Pass(AliAODParticle * p)  const
+Bool_t AliAODAndCut::Pass(AliVAODParticle * p)  const
 {
   //returns true when rejected 
   //OR operation is a little bit misleading but is correct
index ae7aac2e47ddfe1cd7d1a3816f21c029350f1dcd..a65e69981eb0bba9f447eb0477dabfa9e66c8252 100644 (file)
@@ -24,7 +24,7 @@
 
 
 #include <TObject.h>
-#include "AliAODParticle.h"
+#include "AliVAODParticle.h"
 
 
 class AliAODEmptyParticleCut;
@@ -70,7 +70,7 @@ class AliAODParticleCut: public TObject
     virtual ~AliAODParticleCut();
     AliAODParticleCut& operator = (const AliAODParticleCut& in);
     
-    virtual Bool_t Pass(AliAODParticle* p) const;
+    virtual Bool_t Pass(AliVAODParticle* p) const;
     Bool_t IsEmpty() const {return kFALSE;}
     
     void AddBasePartCut(AliAODBaseCut* basecut);
@@ -120,7 +120,7 @@ class AliAODEmptyParticleCut:  public AliAODParticleCut
     AliAODEmptyParticleCut(){};
     virtual ~AliAODEmptyParticleCut(){};
     
-    Bool_t Pass(AliAODParticle*) const {return kFALSE;} //accept everything
+    Bool_t Pass(AliVAODParticle*) const {return kFALSE;} //accept everything
     Bool_t IsEmpty() const {return kTRUE;}
 
     ClassDef(AliAODEmptyParticleCut,1)
@@ -143,7 +143,7 @@ class AliAODBaseCut: public TObject
 
      virtual           ~AliAODBaseCut(){}
      
-     virtual Bool_t    Pass(AliAODParticle *p) const;
+     virtual Bool_t    Pass(AliVAODParticle *p) const;
      
      void              SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
 
@@ -157,7 +157,7 @@ class AliAODBaseCut: public TObject
      virtual void Print(void) const;
      
    protected:
-     virtual Double_t  GetValue(AliAODParticle *) const = 0;
+     virtual Double_t  GetValue(AliVAODParticle *) const = 0;
 
      AliAODCutProperty fProperty; //property that this cut describes
      Double_t fMin;//minimum value
@@ -170,7 +170,7 @@ class AliAODBaseCut: public TObject
  };
 
 inline Bool_t
-AliAODBaseCut::Pass(AliAODParticle *p) const
+AliAODBaseCut::Pass(AliVAODParticle *p) const
 {
   //cjecks if particle property fits in range
   if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
@@ -187,7 +187,7 @@ class AliAODMomentumCut: public AliAODBaseCut
     AliAODMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODP){}
     virtual ~AliAODMomentumCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->P();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->P();}
     ClassDef(AliAODMomentumCut,1)
  };
 
@@ -197,7 +197,7 @@ class AliAODPtCut: public AliAODBaseCut
     AliAODPtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPt){}
     virtual ~AliAODPtCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Pt();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Pt();}
     ClassDef(AliAODPtCut,1)
  };
 
@@ -208,7 +208,7 @@ class AliAODEnergyCut: public AliAODBaseCut
     AliAODEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODE){}
     virtual ~AliAODEnergyCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const {return p->E();}
+    Double_t  GetValue(AliVAODParticle * p)const {return p->E();}
     ClassDef(AliAODEnergyCut,1)
  };
 
@@ -218,7 +218,7 @@ class AliAODRapidityCut: public AliAODBaseCut
     AliAODRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODRapidity){}
     virtual ~AliAODRapidityCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Y();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Y();}
     ClassDef(AliAODRapidityCut,1)
  };
 
@@ -228,7 +228,7 @@ class AliAODPseudoRapidityCut: public AliAODBaseCut
     AliAODPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPseudoRapidity){}
     virtual ~AliAODPseudoRapidityCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Eta();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Eta();}
     ClassDef(AliAODPseudoRapidityCut,1)
  };
 
@@ -238,7 +238,7 @@ class AliAODPxCut: public AliAODBaseCut
     AliAODPxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPx){}
     virtual ~AliAODPxCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Px();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Px();}
     ClassDef(AliAODPxCut,1)
  };
 
@@ -248,7 +248,7 @@ class AliAODPyCut: public AliAODBaseCut
     AliAODPyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPy){}
     virtual ~AliAODPyCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Py();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Py();}
     ClassDef(AliAODPyCut,1)
  };
 
@@ -259,7 +259,7 @@ class AliAODPzCut: public AliAODBaseCut
     AliAODPzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPz){}
     virtual ~AliAODPzCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Pz();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Pz();}
     ClassDef(AliAODPzCut,1)
  };
 
@@ -269,7 +269,7 @@ class AliAODPhiCut: public AliAODBaseCut
     AliAODPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODPhi){}
     virtual ~AliAODPhiCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Phi();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Phi();}
     ClassDef(AliAODPhiCut,1)
   
  };
@@ -280,7 +280,7 @@ class AliAODThetaCut: public AliAODBaseCut
     AliAODThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODTheta){}
     virtual ~AliAODThetaCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Theta();}
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Theta();}
     ClassDef(AliAODThetaCut,1)
   
  };
@@ -292,7 +292,7 @@ class AliAODVxCut: public AliAODBaseCut
     AliAODVxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVx){}
     virtual ~AliAODVxCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Vx();} //retruns value of the vertex
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Vx();} //retruns value of the vertex
     ClassDef(AliAODVxCut,1)
   
  };
@@ -305,7 +305,7 @@ class AliAODVyCut: public AliAODBaseCut
     AliAODVyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVy){}
     virtual ~AliAODVyCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Vy();} //retruns value of the vertex
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Vy();} //retruns value of the vertex
     ClassDef(AliAODVyCut,1)
   
  };
@@ -317,7 +317,7 @@ class AliAODVzCut: public AliAODBaseCut
     AliAODVzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODBaseCut(min,max,kAODVz){}
     virtual ~AliAODVzCut(){}
   protected:
-    Double_t  GetValue(AliAODParticle * p)const{return p->Vz();} //retruns value of the vertex
+    Double_t  GetValue(AliVAODParticle * p)const{return p->Vz();} //retruns value of the vertex
     
     ClassDef(AliAODVzCut,1)
   
@@ -333,7 +333,7 @@ class AliAODPIDCut:  public AliAODBaseCut
      void SetPID(Int_t pid){fPID = pid;}
      void Print(void) const;
    protected:
-     Double_t  GetValue(AliAODParticle * p)const{return p->GetProbability(fPID);}
+     Double_t  GetValue(AliVAODParticle * p)const{return p->GetProbability(fPID);}
      Int_t     fPID; //pid of particle that the pid is set 
      ClassDef(AliAODPIDCut,1)
  };
@@ -353,15 +353,15 @@ class AliAODLogicalOperCut:  public AliAODBaseCut
      AliAODLogicalOperCut(AliAODBaseCut* first, AliAODBaseCut* second);
      virtual   ~AliAODLogicalOperCut();
    protected:
-     Double_t  GetValue(AliAODParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
+     Double_t  GetValue(AliVAODParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
      
      AliAODBaseCut* fFirst;   //second cut
      AliAODBaseCut* fSecond;  //first cut
    private:  
     class  AliAODDummyBaseCut: public AliAODBaseCut 
      {
-       Double_t  GetValue(AliAODParticle * /*part*/) const {return 0.0;}
-       Bool_t    Pass(AliAODParticle* /*part*/) const;
+       Double_t  GetValue(AliVAODParticle * /*part*/) const {return 0.0;}
+       Bool_t    Pass(AliVAODParticle* /*part*/) const;
      };
      
     ClassDef(AliAODLogicalOperCut,1)
@@ -373,7 +373,7 @@ class AliAODOrCut: public AliAODLogicalOperCut
      AliAODOrCut(){}
      AliAODOrCut(AliAODBaseCut* first, AliAODBaseCut* second):AliAODLogicalOperCut(first,second){}
      virtual   ~AliAODOrCut(){}
-     Bool_t    Pass(AliAODParticle *p) const;
+     Bool_t    Pass(AliVAODParticle *p) const;
      ClassDef(AliAODOrCut,1)
 };
 
@@ -383,7 +383,7 @@ class AliAODAndCut: public AliAODLogicalOperCut
      AliAODAndCut(){}
      AliAODAndCut(AliAODBaseCut* first, AliAODBaseCut* second):AliAODLogicalOperCut(first,second){}
      virtual   ~AliAODAndCut(){}
-     Bool_t    Pass(AliAODParticle *p) const;
+     Bool_t    Pass(AliVAODParticle *p) const;
      ClassDef(AliAODAndCut,1)
 };
 
index 1f96274391018bf16256b2f4418215c8cd6d857a..b601eee4d94d740ff6162a6ba8061cfba59b2326 100644 (file)
@@ -39,7 +39,7 @@ void AliAODRun::Reset()
  }
 /**************************************************************************/
 
-void AliAODRun::AddParticle(Int_t event, AliAODParticle* part)
+void AliAODRun::AddParticle(Int_t event, AliVAODParticle* part)
 {
  //Adds particle to event
  //if there is no event of this number, crate it and add to the collection
index bbd7d817db33d565544b106e116d1db4237e01f7..7cb35698e372d6ca685438221b7782ef5de031bf 100644 (file)
@@ -17,7 +17,7 @@
 #include "AliAOD.h"
 #include <TObjArray.h>
 
-class AliAODParticle;
+class AliVAODParticle;
 class TParticle;
 
 class AliAODRun: public TObject
@@ -26,7 +26,7 @@ class AliAODRun: public TObject
     AliAODRun();
     virtual ~AliAODRun();
 
-    void            AddParticle(Int_t event, AliAODParticle* part); //inerface to AliAOD::AddParticle(AliAODParticle*) 
+    void            AddParticle(Int_t event, AliVAODParticle* part); //inerface to AliAOD::AddParticle(AliVAODParticle*) 
     void            AddParticle(Int_t event, TParticle* part, Int_t idx);//inerface to AliAOD::AddParticle(TParticle*) 
     
     //inerface to AliAOD::AddParticle(Int_t.Double_t,Double_t,Double_t,Double_t,Double_t,Double_t,Double_t,Double_t,Double_t)
@@ -35,7 +35,7 @@ class AliAODRun: public TObject
                                 Double_t vx, Double_t vy, Double_t vz, Double_t time); 
     
     void            SetEvent(Int_t number, AliAOD* event);
-    AliAODParticle* GetParticle(Int_t event, Int_t n); //returns nth particle from event
+    AliVAODParticle* GetParticle(Int_t event, Int_t n); //returns nth particle from event
     AliAOD*    GetEvent(Int_t event) const; //returns AliAOD number "event"
     
     Int_t           GetNumberOfEvents() const; //returns number of events
@@ -64,7 +64,7 @@ AliAOD* AliAODRun::GetEvent(Int_t event) const
 }
 /**************************************************************************/
 inline
-AliAODParticle* AliAODRun::GetParticle(Int_t event, Int_t n) 
+AliVAODParticle* AliAODRun::GetParticle(Int_t event, Int_t n) 
 {
  //returns nth particle from event number event
   AliAOD* e = GetEvent(event);
index fafdba536aadee748ef21002a40daa252911bfb6..94e501862a06754ad83005440ce5c30f15eccb46 100644 (file)
@@ -17,7 +17,7 @@
 
 #include "AliESDtrack.h"
 #include "AliTPCtrack.h"
-#include "AliAODParticle.h"
+#include "AliVAODParticle.h"
 #include <TString.h>
 const Int_t AliClusterMap::fNPadRows = 159;
 
@@ -33,7 +33,7 @@ AliClusterMap::AliClusterMap(AliESDtrack* track):
 {
  //ctor
  
- if (AliAODParticle::GetDebug() > 2)
+ if (AliVAODParticle::GetDebug() > 2)
   { 
     Info("AliClusterMap(AliESDtrack*)","");
     Print();
@@ -48,7 +48,7 @@ AliClusterMap::AliClusterMap(AliTPCtrack* track):
  
  //Does not work since indeces in the claster index array 
  //in the TPC track does not correspond to the padraw segmatation
- if (AliAODParticle::GetDebug() > 9) 
+ if (AliVAODParticle::GetDebug() > 9) 
    Info("AliClusterMap",
       "#####################################################################"); 
  if (track == 0x0)
@@ -64,7 +64,7 @@ AliClusterMap::AliClusterMap(AliTPCtrack* track):
     Int_t sect = (idx&0xff000000)>>24;
     Int_t row = (idx&0x00ff0000)>>16;
     if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
-    if (AliAODParticle::GetDebug() > 9)  
+    if (AliVAODParticle::GetDebug() > 9)  
       Info("AliClusterMap","Cl.idx is %d, sect %d, row %d",idx,sect,row);
       
     fPadRawMap.SetBitNumber(row,kTRUE);
@@ -96,7 +96,7 @@ AliClusterMap::AliClusterMap(AliTPCtrack* track):
      }
   }
   
- if (AliAODParticle::GetDebug() > 2)
+ if (AliVAODParticle::GetDebug() > 2)
   { 
     Info("AliClusterMap(AliTPCtrack*)","");
     Print();
@@ -169,7 +169,7 @@ Float_t AliClusterMap::GetOverlapFactor(const AliClusterMap& clmap) const
   if (nh > 0) retval = ((Float_t)an)/((Float_t)nh);
   else Warning("GetOverlapFactor","Number of counted cluters is 0.");
   
-  if (AliAODParticle::GetDebug() > 2)
+  if (AliVAODParticle::GetDebug() > 2)
    {
      Info("GetOverlapFactor","Splitting Quality Factor is %f. SumAn = %d, SumClusters %d",retval,an,nh); 
      if (retval == 1.0) 
index 2d5184e26c657bf61833a02221e4c6ab901767b7..46046f3765b0829a0280957e82ca58fa03285059 100644 (file)
@@ -18,7 +18,7 @@
 
 #include <AliStack.h>
 #include <AliAOD.h>
-#include <AliAODParticle.h>
+#include <AliVAODParticle.h>
 #include <AliAODParticleCut.h>
 
 #include <AliESDtrack.h>
@@ -94,7 +94,7 @@ Double_t AliFlowAnalysis::GetEventPlane(AliAOD* aod)
 
   for (Int_t i=0; i<mult; i++) 
    {
-     AliAODParticle* aodtrack = aod->GetParticle(i);
+     AliVAODParticle* aodtrack = aod->GetParticle(i);
      if (aodtrack == 0x0)
       {
         Error("AliFlowAnalysis::GetEventPlane","Can not get track %d", i);
@@ -135,7 +135,7 @@ void AliFlowAnalysis::GetFlow(AliAOD* aod,Double_t& v2,Double_t& psi)
 
   for (Int_t i=0; i<mult; i++) 
    {
-     AliAODParticle* aodtrack = aod->GetParticle(i);
+     AliVAODParticle* aodtrack = aod->GetParticle(i);
      if (aodtrack == 0x0)
       {
         Error("AliFlowAnalysis::GetEventPlane","Can not get track %d", i);
index 1b5743c5576808efb4c15e204bbfd2a120266ea9..5f4e58dae5f7009cb6f83c6beb3fae9d4e0ab1f8 100644 (file)
@@ -323,7 +323,7 @@ Int_t AliReader::Read(AliAODRun* particles, AliAODRun *tracks)
 }      
 /*************************************************************************************/
 
-Bool_t AliReader::Pass(AliAODParticle* p)
+Bool_t AliReader::Pass(AliVAODParticle* p)
 {
  //Method examines whether particle meets all cut and particle type criteria
   
index bf891a48bf3f95e8c1184a28064908a86bb2864c..18dd01ecc4a0c5af2d7615446819e1ed1ea65c73 100644 (file)
@@ -19,7 +19,7 @@
 class AliAODRun;
 class AliAOD;
 class AliAODParticleCut;
-class AliAODParticle;
+class AliVAODParticle;
 class TString;
 class TH1I;
  
@@ -87,7 +87,7 @@ class AliReader: public TNamed
     TH1I*                fTrackCounter; //histogram with number of tracks read
     
     virtual Int_t        ReadNext() = 0; //this methods reads next event and put result in fTracksEvent and/or fParticlesEvent
-    Bool_t               Pass(AliAODParticle* p);
+    Bool_t               Pass(AliVAODParticle* p);
     Bool_t               Pass(Int_t pid);
     void                 Blend();
     
index 4d2e75bea8a174e47c2972698fb0dad942b5099a..cc02a73f9082ed30ad84b34bb3a14ca77a15e450 100644 (file)
@@ -28,7 +28,7 @@
 #include "AliAnalysis.h"
 #include "AliAODRun.h"
 #include "AliAOD.h"
-#include "AliAODStdParticle.h"
+#include "AliAODParticle.h"
 #include "AliAODParticleCut.h"
 #include "AliTrackPoints.h"
 #include "AliClusterMap.h"
@@ -140,7 +140,7 @@ Int_t AliReaderESD::ReadNext()
 //reads next event from fFile
   //fRunLoader is for reading Kine
   
-  if (AliAODParticle::GetDebug())
+  if (AliVAODParticle::GetDebug())
     Info("ReadNext","Entered");
     
   if (fEventSim == 0x0)  fEventSim = new AliAOD();
@@ -168,7 +168,7 @@ Int_t AliReaderESD::ReadNext()
      TKey* key = (TKey*)fKeyIterator->Next();
      if (key == 0x0)
       {
-        if (AliAODParticle::GetDebug() > 2 )
+        if (AliVAODParticle::GetDebug() > 2 )
           {
             Info("ReadNext","No more keys.");
           }
@@ -187,7 +187,7 @@ Int_t AliReaderESD::ReadNext()
 //     TObject* esdobj = key->ReadObj();
 //     if (esdobj == 0x0)
 //      {
-//        if (AliAODParticle::GetDebug() > 2 )
+//        if (AliVAODParticle::GetDebug() > 2 )
 //          {
 //            Info("ReadNext","Key read NULL. Key Name is %s",key->GetName());
 //            key->Dump();
@@ -202,11 +202,11 @@ Int_t AliReaderESD::ReadNext()
      AliESD* esd = dynamic_cast<AliESD*>(fFile->Get(esdname));
      if (esd == 0x0)
       {
-//        if (AliAODParticle::GetDebug() > 2 )
+//        if (AliVAODParticle::GetDebug() > 2 )
 //          {
 //            Info("ReadNext","This key is not an AliESD object %s",key->GetName());
 //          }
-        if (AliAODParticle::GetDebug() > 2 )
+        if (AliVAODParticle::GetDebug() > 2 )
           {
             Info("ReadNext","Can not find AliESD object named %s",esdname.Data());
           }
@@ -284,7 +284,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
      vertex->GetXYZ(vertexpos);
    }
    
-  if (AliAODParticle::GetDebug() > 0)
+  if (AliVAODParticle::GetDebug() > 0)
    {
      Info("ReadESD","Primary Vertex is (%f,%f,%f)",vertexpos[0],vertexpos[1],vertexpos[2]);
    }
@@ -305,14 +305,14 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
      //if (esdtrack->HasVertexParameters() == kFALSE) 
      if ((esdtrack->GetStatus() & AliESDtrack::kITSrefit) == kFALSE)
       {
-        if (AliAODParticle::GetDebug() > 2) 
+        if (AliVAODParticle::GetDebug() > 2) 
           Info("ReadNext","Particle skipped: Data at vertex not available.");
         continue;
       }
 
      if ((esdtrack->GetStatus() & AliESDtrack::kESDpid) == kFALSE) 
       {
-        if (AliAODParticle::GetDebug() > 2) 
+        if (AliVAODParticle::GetDebug() > 2) 
           Info("ReadNext","Particle skipped: PID BIT is not set.");
         continue;
       }
@@ -323,7 +323,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
      esdtrack->GetConstrainedExternalParameters(extx,extp);
      if (extp[4] == 0.0)
       {
-        if (AliAODParticle::GetDebug() > 2) 
+        if (AliVAODParticle::GetDebug() > 2) 
           Info("ReadNext","Track has 0 contrianed curvature -> Probobly parameters never updated. Skipping.");
         continue;
       } 
@@ -337,7 +337,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
      Int_t charge = (extp[4] > 0)?1:-1;//if curvature=charg/Pt is positive charge is positive
 
      //Particle from kinematics
-     AliAODStdParticle* particle = 0;
+     AliAODParticle* particle = 0;
      Bool_t keeppart = kFALSE;
      if ( fReadSim && stack  )
       {
@@ -350,12 +350,12 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
          }
         if(Pass(p->GetPdgCode())) 
          {
-           if ( AliAODParticle::GetDebug() > 5 )
+           if ( AliVAODParticle::GetDebug() > 5 )
              Info("ReadNext","Simulated Particle PID (%d) did not pass the cut.",p->GetPdgCode());
            continue; //check if we are intersted with particles of this type 
          }
 //           if(p->GetPdgCode()<0) charge = -1;
-        particle = new AliAODStdParticle(*p,i);
+        particle = new AliAODParticle(*p,i);
 
       }
       
@@ -366,14 +366,14 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
      for (Int_t s=0; s<AliESDtrack::kSPECIES; s++) rc+=concentr[s]*pidtable[s];
      if (rc==0.0) 
       {
-        if (AliAODParticle::GetDebug() > 2) 
+        if (AliVAODParticle::GetDebug() > 2) 
           Info("ReadNext","Particle rejected since total bayessian PID probab. is zero.");
         continue;
       }
 
      for (Int_t s=0; s<AliESDtrack::kSPECIES; s++) w[s]=concentr[s]*pidtable[s]/rc;
 
-     if (AliAODParticle::GetDebug() > 4)
+     if (AliVAODParticle::GetDebug() > 4)
       { 
         Info("ReadNext","###########################################################################");
         Info("ReadNext","Momentum: %f %f %f",mom[0],mom[1],mom[2]);
@@ -392,7 +392,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
            msg+=")";
          }
         Info("ReadNext","%s",msg.Data());
-      }//if (AliAODParticle::GetDebug()>4)
+      }//if (AliVAODParticle::GetDebug()>4)
 
       AliTrackPoints* tpts = 0x0;
       if (fNTrackPoints > 0) 
@@ -437,14 +437,14 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
         Float_t pp = w[s];
         if (pp == 0.0) 
          {
-           if ( AliAODParticle::GetDebug() > 5 )
+           if ( AliVAODParticle::GetDebug() > 5 )
              Info("ReadNext","Probability of being PID %d is zero. Continuing.",pdgcode);
            continue;
          }
 
         if(Pass(pdgcode)) 
          {
-           if ( AliAODParticle::GetDebug() > 5 )
+           if ( AliVAODParticle::GetDebug() > 5 )
              Info("ReadNext","PID (%d) did not pass the cut.",pdgcode);
            continue; //check if we are intersted with particles of this type 
          }
@@ -452,7 +452,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
         Double_t mass = pdgdb->GetParticle(pdgcode)->Mass();
         Double_t tEtot = TMath::Sqrt( mom[0]*mom[0] + mom[1]*mom[1] + mom[2]*mom[2] + mass*mass);//total energy of the track
 
-        AliAODStdParticle* track = new AliAODStdParticle(pdgcode, w[s],i, 
+        AliAODParticle* track = new AliAODParticle(pdgcode, w[s],i, 
                                                    mom[0], mom[1], mom[2], tEtot,
                                                    pos[0], pos[1], pos[2], 0.);
         //copy probabilitis of other species (if not zero)
@@ -466,7 +466,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
         if(Pass(track))//check if meets all criteria of any of our cuts
                        //if it does not delete it and take next good track
          { 
-           if ( AliAODParticle::GetDebug() > 4 )
+           if ( AliVAODParticle::GetDebug() > 4 )
              Info("ReadNext","Track did not pass the cut");
            delete track;
            continue;
@@ -487,7 +487,7 @@ Int_t AliReaderESD::ReadESD(AliESD* esd)
         if (particle) fEventSim->AddParticle(particle);
         keeppart = kTRUE;
 
-        if (AliAODParticle::GetDebug() > 4 )
+        if (AliVAODParticle::GetDebug() > 4 )
          {
            Info("ReadNext","\n\nAdding Particle with incarnation %d",pdgcode);
            track->Print();
index 0b6fe2dc180bb09582be94a929a4ec48e86c0496..7e9e3d9c07d8a0ef90d77646a21fd5e0b49102d2 100644 (file)
@@ -54,7 +54,7 @@ class AliReaderESD: public AliReader
 
     
     enum ESpecies {kESDElectron = 0, kESDMuon, kESDPion, kESDKaon, kESDProton, kNSpecies};
-    static Int_t  GetSpeciesPdgCode(ESpecies spec);//skowron
+    static Int_t  GetSpeciesPdgCode(ESpecies spec);
     
     Int_t         ReadESD(AliESD* esd);
     
index 20d90431320c40821d414e69e0432d3f444267f1..f383c92ecd5b58ef599a08d624e9f5fcdc7de914 100644 (file)
@@ -27,7 +27,7 @@
 
 #include "AliEventCut.h"
 #include "AliReader.h"
-#include "AliAODParticle.h"
+#include "AliVAODParticle.h"
 
 
 ClassImp(AliRunAnalysis)
@@ -79,7 +79,7 @@ Int_t AliRunAnalysis::Run()
       /******************************/ 
       if ( Pass(eventrec,eventsim) )
        {
-         if (AliAODParticle::GetDebug()) Info("Run","Event rejected by Event Cut");
+         if (AliVAODParticle::GetDebug()) Info("Run","Event rejected by Event Cut");
          continue; //Did not pass the 
        }
       /******************************/ 
@@ -88,7 +88,7 @@ Int_t AliRunAnalysis::Run()
       for (Int_t an = 0; an < fAnalysies.GetEntries(); an++)
        {
            AliAnalysis* analysis = (AliAnalysis*)fAnalysies.At(an);
-           analysis->ProcessEvent(eventsim,eventrec);
+           analysis->ProcessEvent(eventrec,eventsim);
        }
     
   }//end of loop over events
diff --git a/ANALYSIS/AliVAODParticle.cxx b/ANALYSIS/AliVAODParticle.cxx
new file mode 100644 (file)
index 0000000..e6fb52f
--- /dev/null
@@ -0,0 +1,39 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+/////////////////////////////////////////////////////////////
+//
+// base class for AOD particles
+//
+// Most of the methods defined in this base class (or even all of them)
+// should be redefined in derived classes. Some methods like Pt() or
+// Vx() have default implementation, but they are not optimised for
+// performance. It is likely that they can be (and should be) implemented
+// in the derived classes in a way which gives faster access.
+//
+// Algorithms and analysis classes should as much as possible use the
+// interface of the base class instead of special methods of derived
+// classes. This allows to run the code on all types of particles.
+//
+/////////////////////////////////////////////////////////////
+
+#include "AliVAODParticle.h"
+
+Int_t AliVAODParticle::fgDebug = 0;
+
+ClassImp(AliVAODParticle)
+
diff --git a/ANALYSIS/AliVAODParticle.h b/ANALYSIS/AliVAODParticle.h
new file mode 100644 (file)
index 0000000..0bd5233
--- /dev/null
@@ -0,0 +1,81 @@
+#ifndef ALIVAODPARTICLE_H
+#define ALIVAODPARTICLE_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/////////////////////////////////////////////////////////////
+//
+// base class for AOD particles
+//
+/////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+#include <TLorentzVector.h>
+#include <TVector3.h>
+
+#include "AliAnalysis.h"
+
+class AliTrackPoints;
+class AliClusterMap;
+
+class AliVAODParticle : public TObject {
+public:
+   AliVAODParticle(){}
+   virtual ~AliVAODParticle(){}
+  // kinematics
+  virtual TLorentzVector   FourMomentum() const = 0;
+  virtual TVector3         Momentum() const {return FourMomentum().Vect();};
+  virtual Double_t         Mass() const {return FourMomentum().M();};
+  virtual Double_t         E() const {return FourMomentum().E();};
+  virtual Double_t         P() const {return FourMomentum().P();};
+  virtual Double_t         Pt() const {return FourMomentum().Pt();};
+  virtual Double_t         Px() const {return FourMomentum().Px();};
+  virtual Double_t         Py() const {return FourMomentum().Py();};
+  virtual Double_t         Pz() const {return FourMomentum().Pz();};
+  virtual Double_t         Phi() const {return FourMomentum().Phi();};
+  virtual Double_t         Theta() const {return FourMomentum().Theta();};
+  virtual Double_t         Eta() const {return FourMomentum().Eta();};
+  virtual Double_t         Y() const {return FourMomentum().Rapidity();};
+
+  // PID
+  virtual Double_t         Charge() const = 0;
+  virtual Double_t         GetProbability(Int_t pdg) const = 0;
+  virtual Int_t            GetMostProbable() const = 0;
+  
+  virtual Int_t            GetPdgCode() const = 0;//We need to assume some PID (f.e. energy calculation) 
+                                                  //sotimes one track can apear in analysis twise (e.g. ones as pion ones as kaon)
+  
+  // vertices
+  virtual TVector3         ProductionVertex() const = 0;
+  virtual Double_t         Vx() const {return ProductionVertex().X();};
+  virtual Double_t         Vy() const {return ProductionVertex().Y();};
+  virtual Double_t         Vz() const {return ProductionVertex().Z();};
+  virtual AliVAODParticle*  Mother() const {return NULL;};
+  virtual Bool_t           HasDecayVertex() const {return kFALSE;};
+  virtual TVector3         DecayVertex() const {return TVector3();};
+  virtual Int_t            NumberOfDaughters() const {return 0;};
+  virtual AliVAODParticle*  Daughter(Int_t /*index*/) const {return NULL;};
+
+
+  // type information
+  virtual Bool_t           IsSimulated() {return kFALSE;};
+  virtual Bool_t           IsTrack() {return kFALSE;};
+  virtual Bool_t           IsCluster() {return kFALSE;};
+
+  //HBT specific 
+  virtual AliTrackPoints*  GetTrackPoints() const {return 0x0;}
+  virtual AliClusterMap*   GetClusterMap() const {return 0x0;}
+  virtual void             Print() const = 0;
+
+  static void    SetDebug(Int_t dbg=1){fgDebug=dbg;}
+  static Int_t   GetDebug(){return fgDebug;}
+
+private:
+  static Int_t fgDebug;//! debug level for all the analysis package
+
+  ClassDef(AliVAODParticle,1)  // base class for AOD particles
+};
+
+#endif
index 090b82b0c00549b8ce834f0bc449e9d9323c4685..0a62ca967e7d4c81f5bfb366c20369d2fba6370b 100644 (file)
@@ -3,7 +3,7 @@ void analysis(Int_t first = -1, Int_t last = -1, const char* directory=".")
 
   gSystem->Load("$(ALICE_ROOT)/lib/tgt_$(ALICE_TARGET)/libANALYSIS");
 
-  AliAODParticle::SetDebug(0);
+  AliVAODParticle::SetDebug(0);
   AliRunAnalysis* analysis = new AliRunAnalysis();
   
   ::Info("analysis.C","Setting dirs");
index a336363d355694dc6a15bd21f131d170702b144b..44caad506b0505712373f8ba12d4c4a156b48bc1 100644 (file)
@@ -1,5 +1,5 @@
 SRCS= AliAOD.cxx \
-      AliAODParticle.cxx AliAODStdParticle.cxx \
+      AliVAODParticle.cxx AliAODParticle.cxx \
       AliAODParticleCut.cxx AliAODRun.cxx \
       AliRunAnalysis.cxx AliAnalysis.cxx AliEventCut.cxx \
       AliReader.cxx AliReaderESD.cxx\