STEER/AOD/AliAODMCParticle.h

   1 #ifndef AliAODMCPARTICLE_H
   2 #define AliAODMCPARTICLE_H
   3 /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6
   7 //-------------------------------------------------------------------------
   8 //     AliVParticle realisation for MC Particles in the AOD
   9 //     Stripped dow AliMCParticle
  10 //     Author: Christian Klein Bösing, CERN
  11 //-------------------------------------------------------------------------
  12
  13 #include <Rtypes.h>
  14 #include <TParticlePDG.h>
  15 #include <TExMap.h>
  16 #include <TString.h>
  17
  18
  19 #include "AliTrackReference.h"
  20 #include "AliVParticle.h"
  21 #include "AliMCParticle.h"
  22
  23 class AliAODEvent;
  24 class TParticle;
  25 class TClonesArray;
  26
  27 class AliAODMCParticle: public AliVParticle {
  28  public:
  29   AliAODMCParticle();
  30   AliAODMCParticle(const AliMCParticle* part, Int_t label=0,Int_t flag = 0);
  31   virtual ~AliAODMCParticle(){};
  32   AliAODMCParticle(const AliAODMCParticle& mcPart);
  33   AliAODMCParticle& operator=(const AliAODMCParticle& mcPart);
  34
  35   // Kinematics
  36     virtual Double_t Px()        const;
  37     virtual Double_t Py()        const;
  38     virtual Double_t Pz()        const;
  39     virtual Double_t Pt()        const;
  40     virtual Double_t P()         const;
  41     virtual Bool_t   PxPyPz(Double_t p[3]) const;
  42
  43     virtual Double_t OneOverPt() const;
  44     virtual Double_t Phi()       const;
  45     virtual Double_t Theta()     const;
  46
  47     virtual Double_t Xv() const;
  48     virtual Double_t Yv() const;
  49     virtual Double_t Zv() const;
  50     virtual Bool_t   XvYvZv(Double_t x[3]) const;
  51     virtual Double_t T() const;
  52
  53     virtual Double_t E()          const;
  54     virtual Double_t M()          const;
  55
  56     virtual Double_t Eta()        const;
  57     virtual Double_t Y()          const;
  58
  59     virtual Short_t Charge()      const;
  60
  61     virtual Int_t   Label()       const;
  62     virtual Int_t   GetLabel()    const {return Label();}
  63
  64     // PID
  65     virtual const Double_t *PID() const {return 0;} // return PID object (to be defined, still)
  66
  67     //
  68     virtual Double_t GetCalcMass() const;
  69     virtual void SetDaughter(Int_t i,Int_t id){if(i<2)fDaughter[i] = id;}
  70     virtual Int_t GetDaughter(Int_t i) const {return fDaughter[i];}
  71     virtual Int_t GetNDaughters  () const { return fDaughter[1]>0 ? fDaughter[1]-fDaughter[0]+1 : 0;}
  72     virtual void SetMother(Int_t im){fMother = im;}
  73     virtual Int_t GetMother() const {return fMother;}
  74     virtual void Print(const Option_t *opt = "") const;
  75     virtual Int_t GetPdgCode() const { return fPdgCode;}
  76     virtual Int_t PdgCode()    const { return GetPdgCode();}
  77
  78     enum { kPrimary = 1<<0, kPhysicalPrim = 1<<1 };
  79     void SetFlag(UInt_t flag){fFlag = flag;}
  80     UInt_t GetFlag() const {return fFlag;}
  81
  82
  83     // for the status we use the upper 16 bits/2 bytes of the flag word
  84     void SetStatus(Int_t status){
  85       if(status<0)return; // a TParticle can have a negative stuts, catch this here and do nothing
  86       fFlag &= 0xffff;   // reset the upper bins keep the lower bins
  87       fFlag |= (((UInt_t)status)<<16); // bit shift by 16
  88     }
  89     UInt_t GetStatus() const {
  90       // bit shift by 16
  91       return fFlag>>16;
  92     }
  93
  94     // Bitwise operations
  95     void SetPrimary(Bool_t b = kTRUE){
  96       if(b)fFlag |= kPrimary;
  97       else fFlag &= ~kPrimary;
  98     }
  99     Bool_t IsPrimary() const {return ((fFlag&kPrimary)==kPrimary);}
 100
 101     void SetPhysicalPrimary(Bool_t b = kTRUE){
 102      if(b)fFlag |= kPhysicalPrim;
 103      else fFlag &= ~kPhysicalPrim;
 104     }
 105     Bool_t IsPhysicalPrimary() const {return ((fFlag&kPhysicalPrim)==kPhysicalPrim);}
 106     static const char* StdBranchName(){return fgkStdBranchName.Data();}
 107
 108  private:
 109
 110     static TString fgkStdBranchName;      // Standard branch name
 111
 112
 113   Int_t            fPdgCode;              // PDG code of the particle
 114   UInt_t           fFlag;                 // Flag for indication of primary etc
 115   Int_t            fLabel;                // Label of the original MCParticle
 116   Int_t            fMother;               // Index of the mother particles
 117   Int_t            fDaughter[2];          // Indices of the daughter particles
 118   Double32_t       fPx;                   // x component of momentum
 119   Double32_t       fPy;                   // y component of momentum
 120   Double32_t       fPz;                   // z component of momentum
 121   Double32_t       fE;                    // Energy
 122
 123   Double32_t       fVx;                   // [0.,0.,12] x of production vertex
 124   Double32_t       fVy;                   // [0.,0.,12] y of production vertex
 125   Double32_t       fVz;                   // [0.,0.,12] z of production vertex
 126   Double32_t       fVt;                   // [0.,0.,12] t of production vertex
 127
 128   // Copy the uniquID to another data member? unique ID is correctly handled
 129   // via TOBject Copy construct but not by AliVParticle ctor (no passing of
 130   // TParticles
 131   // Need a flag for primaries?
 132
 133   /*
 134     const TMCProcess kMCprocesses[kMaxMCProcess] =
 135     {
 136      kPNoProcess, kPMultipleScattering, kPEnergyLoss, kPMagneticFieldL,
 137      kPDecay, kPPair, kPCompton, kPPhotoelectric, kPBrem, kPDeltaRay,
 138      kPAnnihilation, kPHadronic, kPNoProcess, kPEvaporation, kPNuclearFission,
 139      kPNuclearAbsorption, kPPbarAnnihilation, kPNCapture, kPHElastic,
 140      kPHInhelastic, kPMuonNuclear, kPTOFlimit,kPPhotoFission, kPNoProcess,
 141      kPRayleigh, kPNoProcess, kPNoProcess, kPNoProcess, kPNull, kPStop
 142     };
 143   */
 144
 145   ClassDef(AliAODMCParticle,5)  // AliVParticle realisation for AODMCParticles
 146
 147 };
 148
 149 inline Double_t AliAODMCParticle::Px()        const {return fPx;}
 150 inline Double_t AliAODMCParticle::Py()        const {return fPy;}
 151 inline Double_t AliAODMCParticle::Pz()        const {return fPz;}
 152 inline Double_t AliAODMCParticle::Pt()        const {return TMath::Sqrt(fPx*fPx+fPy*fPy);}
 153 inline Double_t AliAODMCParticle::P()         const {return TMath::Sqrt(fPx*fPx+fPy*fPy+fPz*fPz); }
 154 inline Double_t AliAODMCParticle::OneOverPt() const {return 1. / Pt();}
 155 inline Bool_t   AliAODMCParticle::PxPyPz(Double_t p[3]) const { p[0] = fPx; p[1] = fPy; p[2] = fPz; return kTRUE; }
 156 inline Double_t AliAODMCParticle::Phi()       const {return TMath::Pi()+TMath::ATan2(-fPy,-fPx); }  // note that Phi() returns an angle between 0 and 2pi
 157 inline Double_t AliAODMCParticle::Theta()     const {return (fPz==0)?TMath::PiOver2():TMath::ACos(fPz/P()); }
 158 inline Double_t AliAODMCParticle::Xv()        const {return fVx;}
 159 inline Double_t AliAODMCParticle::Yv()        const {return fVy;}
 160 inline Double_t AliAODMCParticle::Zv()        const {return fVz;}
 161 inline Bool_t   AliAODMCParticle::XvYvZv(Double_t x[3]) const { x[0] = fVx; x[1] = fVy; x[2] = fVz; return kTRUE; }
 162 inline Double_t AliAODMCParticle::T()         const {return fVt;}
 163 inline Double_t AliAODMCParticle::E()         const {return fE;}
 164 inline Double_t AliAODMCParticle::Eta()       const {
 165   Double_t pmom = P();
 166   if (pmom != TMath::Abs(fPz)) return 0.5*TMath::Log((pmom+fPz)/(pmom-fPz));
 167   else                         return 1.e30;
 168 }
 169
 170
 171 inline Double_t AliAODMCParticle::Y()         const
 172 {
 173     Double_t e  = E();
 174     Double_t pz = Pz();
 175
 176     if (e > TMath::Abs(pz)) {
 177         return 0.5*TMath::Log((e+pz)/(e-pz));
 178     } else {
 179         return -999.;
 180     }
 181 }
 182
 183 inline Int_t AliAODMCParticle::Label()       const {return fLabel;}
 184
 185 inline Double_t AliAODMCParticle::GetCalcMass() const {
 186
 187   Double_t m2 = E()*E()-Px()*Px()-Py()*Py()-Pz()*Pz();
 188   if(m2<0)return 0;
 189   return TMath::Sqrt(m2);
 190 }
 191
 192
 193 #endif