DataTree/interface/DecayParticle.h

//--------------------------------------------------------------------------------------------------
// $Id: DecayParticle.h,v 1.34 2011/04/07 11:30:45 bendavid Exp $
//
// DecayParticle
//
// The decay particle class is for use in vertexing based analyses. It
// stores vertex fit information (including four momentum) and links to daughters.
//
// Note that Charge() is still computed as a recursive loop over daughters, as inherited from
// CompositeParticle, but momentum is returned from the internally stored four vector.
//
// Authors: C.Paus, J.Bendavid
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATATREE_DECAYPARTICLE_H
#define MITANA_DATATREE_DECAYPARTICLE_H
 
#include <TDatabasePDG.h>
#include <TParticlePDG.h> 
#include "MitCommon/DataFormats/interface/Vect4M.h"
#include "MitAna/DataTree/interface/DaughterData.h"
#include "MitAna/DataTree/interface/Vertex.h"
#include "MitAna/DataTree/interface/ConversionQuality.h"
#include "MitAna/DataCont/interface/RefArray.h"

namespace mithep 
{
  class DecayParticle : public Particle
  {
    public:
      DecayParticle() :
        fAbsPdgId(0), fChi2(0), fNdof(0), fMassError(0), 
        fLxy(0), fLxyError(0), fDxy(0), fDxyError(0), fLz(0), fLzError(0), fDzBeamlineError(0),
        fDzBeamlineEcal(0), fDzBeamlineEcalError(0), fNSharedHits(0) {}
      DecayParticle(Int_t absPdgId) : 
        fAbsPdgId(absPdgId), fChi2(0), fNdof(0), fMassError(0), 
        fLxy(0), fLxyError(0), fDxy(0), fDxyError(0), fLz(0), fLzError(0), fDzBeamlineError(0),
        fDzBeamlineEcal(0), fDzBeamlineEcalError(0), fNSharedHits(0) {}

      void                      AddDaughterData(const DaughterData *dd) 
                                  { fDaughterData.Add(dd); ClearCharge(); }
      UInt_t                    AbsPdgId()            const { return fAbsPdgId;                    }
      Double_t                  Chi2()                const { return fChi2;                        }
      const Particle           *Daughter(UInt_t i)    const { return DaughterDat(i)->Original();   }
      const DaughterData       *DaughterDat(UInt_t i) const { return fDaughterData.At(i);          }
      Double_t                  Dxy()                 const { return fDxy;                         }
      Double_t                  DxyCorrected(const ThreeVector &v) const;
      Double_t                  DxyCorrected(const BaseVertex *v)  const;
      Double_t                  DxyError()            const { return fDxyError;                    }
      Double_t                  DzBeamlineError()     const { return fDzBeamlineError;             }
      Double_t                  DzBeamlineEcal()      const { return fDzBeamlineEcal;              }
      Double_t                  DzBeamlineEcalError() const { return fDzBeamlineEcalError;         }      
      Double_t                  DzCorrected(const ThreeVector &v) const;
      Double_t                  DzCorrected(const BaseVertex *v)  const;
      Double_t                  Z0EcalVtx(const ThreeVector &bspos, const ThreeVector &ecalpos) const;
      Bool_t                    HasDaughter(const Particle *p)            const;
      Bool_t                    HasCommonDaughter(const DecayParticle *p) const;
      Bool_t                    HasPriVertex()        const { return fPriVtx.IsValid();            }
      Bool_t                    HasPriVertex(const Vertex *v) 
                                                      const { return fPriVtx.RefsObject(v);        }
      Bool_t                    HasSameDaughters(const DecayParticle *p)  const;
      Double_t                  Lxy()                 const { return fLxy;                         }
      Double_t                  LxyError()            const { return fLxyError;                    }
      Double_t                  LxyCorrected(const BaseVertex *v)  const;
      Double_t                  Lz()                  const { return fLz;                          }
      Double_t                  LzError()             const { return fLzError;                     }
      Double_t                  MassError()           const { return fMassError;                   }
      UShort_t                  Ndof()                const { return fNdof;                        }
      UInt_t                    NDaughters()          const { return fDaughterData.Entries();      }
      EObjType                  ObjType()             const { return kDecayParticle;               }
      TParticlePDG             *ParticlePdgEntry()    const;
      Double_t                  PdgMass()             const;
      const Vertex             *PriVertex()           const { return fPriVtx.Obj();                }
      Double_t                  Prob()                const { return TMath::Prob(fChi2,fNdof);     }
      const ThreeVector        &Position()            const;
      const ConversionQuality  &Quality()             const { return fQuality;                     }
      ConversionQuality        &Quality()                   { return fQuality;                     }
      const ThreeVector         RelativePosition()    const;
      Bool_t                    SharedLayer(Track::EHitLayer l) const  { return fSharedLayers.TestBit(l); }
      const BitMask48          &SharedLayers()        const { return fSharedLayers;                }
      UInt_t                    NSharedLayers()       const { return fSharedLayers.NBitsSet();     }
      UInt_t                    NSharedHits()         const { return TMath::Max(UInt_t(fNSharedHits),NSharedLayers()); }      
      void                      SetAbsPdgId(UInt_t apid)                { fAbsPdgId=apid;          }
      void                      SetChi2(Double_t chi2)                  { fChi2 = chi2;            }
      void                      SetDxy(Double_t dxy)                    { fDxy = dxy; ClearPos();  }
      void                      SetDxyError(Double_t dxyError)          { fDxyError = dxyError;    }
      void                      SetDzBeamlineError(Double_t dzError)    { fDzBeamlineError = dzError; }
      void                      SetDzBeamlineEcal(Double_t dz)    { fDzBeamlineEcal = dz; }
      void                      SetDzBeamlineEcalError(Double_t dzError) { fDzBeamlineEcalError = dzError; }      
      void                      SetLxy(Double_t lxy)                    { fLxy = lxy; ClearPos();  }
      void                      SetLxyError(Double_t lxyError)          { fLxyError = lxyError;    }
      void                      SetLz(Double_t lz)                      { fLz = lz; ClearPos();    }
      void                      SetLzError(Double_t lzError)            { fLzError = lzError;      }
      void                      SetMassError(Double_t massError)        { fMassError = massError;  }
      void                      SetMom(Double_t px, Double_t py, Double_t pz, Double_t e);
      void                      SetMom(const FourVector &p)             
                                  { fMomentum = p; ClearMom(); ClearPos(); }
      void                      SetNdof(UShort_t ndof)                  { fNdof = ndof;            }
      void                      SetNSharedHits(UShort_t nhits)          { fNSharedHits = nhits;    }
      void                      SetPriVertex(const Vertex *v)           { fPriVtx = v; ClearPos(); }
      void                      SetSharedLayer(Track::EHitLayer l)      { fSharedLayers.SetBit(l); }
      void                      SetSharedLayers(const BitMask48 &layers) { fSharedLayers = layers; }
      using TObject::Error;

    protected:
      void                      ClearPos()            const { fCachePosFlag.ClearCache(); }
      Double_t                  GetCharge()           const;
      void                      GetMom()              const;
      void                      GetPos()              const;

      UInt_t                    fAbsPdgId;     //absolute value of pid code
      Double32_t                fChi2;         //[0,0,12]chi-squared of fit
      UShort_t                  fNdof;         //degrees of freedom for fit
      Double32_t                fMassError;    //[0,0,14]fitted mass error
      Double32_t                fLxy;          //[0,0,14]fitted lxy (decay length)
      Double32_t                fLxyError;     //[0,0,14]fitted lxy error
      Double32_t                fDxy;          //[0,0,14]fitted impact parameter
      Double32_t                fDxyError;     //[0,0,14]fitted impact parameter error
      Double32_t                fLz;           //[0,0,14]fitted lz (decay length)
      Double32_t                fLzError;      //[0,0,14]fitted lz error
      Double32_t                fDzBeamlineError; //[0,0,14]fitted deltaz error at beamline
      Double32_t                fDzBeamlineEcal; //[0,0,14]fitted deltaz at beamline (with ecal constraint) 
      Double32_t                fDzBeamlineEcalError; //[0,0,14]fitted deltaz error at beamline (with ecal constraint)       
      Vect4M                    fMomentum;     //momentum fourvector
      RefArray<DaughterData>    fDaughterData; //momentum of daughters at vertex
      Ref<Vertex>               fPriVtx;       //reference to primary vertex
      BitMask48                 fSharedLayers; //layer mask for shared hits from daughter particles
      UShort_t                  fNSharedHits;  //number of shared hits
      ConversionQuality         fQuality;      //conversion quality flags
      mutable CacheFlag         fCachePosFlag; //||cache validity flag for position
      mutable ThreeVector       fCachedPos;    //!cached momentum vector (filled by derived classes)
      
      ClassDef(DecayParticle, 5) // Decay particle class
  };
}

//--------------------------------------------------------------------------------------------------
inline Double_t mithep::DecayParticle::GetCharge() const 
{
  // Return sum of charge of daughter particles.

  Double_t charge = 0;
  for (UInt_t i=0; i<NDaughters(); ++i)
    charge += DaughterDat(i)->Charge();
  
  return charge;
}

//--------------------------------------------------------------------------------------------------
inline void mithep::DecayParticle::GetMom() const
{
  // Get momentum values from stored values.

  fCachedMom.SetCoordinates(fMomentum.Pt(), fMomentum.Eta(), fMomentum.Phi(), fMomentum.M());
}

//--------------------------------------------------------------------------------------------------
inline TParticlePDG *mithep::DecayParticle::ParticlePdgEntry() const 
{ 
  // Return entry to pdg database for the particle.

  return TDatabasePDG::Instance()->GetParticle(fAbsPdgId); 
}

//--------------------------------------------------------------------------------------------------
inline void mithep::DecayParticle::SetMom(Double_t px, Double_t py, Double_t pz, Double_t e)
{ 
  // Set four vector.

  fMomentum.SetXYZT(px,py,pz,e);
  ClearMom();
  ClearPos();
}

//--------------------------------------------------------------------------------------------------
inline const mithep::ThreeVector &mithep::DecayParticle::Position() const
{
  // Return cached momentum value.

  if (!fCachePosFlag.IsValid()) {
    GetPos();
    fCachePosFlag.SetValid();
  }

  return fCachedPos;
}

//--------------------------------------------------------------------------------------------------
inline void mithep::DecayParticle::GetPos() const
{
  // Return absolute position of decay.

  const mithep::Vertex *pv = PriVertex();
    
  if (pv)
    fCachedPos = pv->Position() + RelativePosition();
  else
    fCachedPos = RelativePosition();
}

//--------------------------------------------------------------------------------------------------
inline const mithep::ThreeVector mithep::DecayParticle::RelativePosition() const
{
  // Compute the position vector of the decay vertex relative to the primary vertex.

  mithep::ThreeVector dz(0,0,fLz*TMath::Abs(Pz())/Pz());
  mithep::ThreeVector momPerp(Px(),Py(),0);
  mithep::ThreeVector zHat(0,0,1.0);
  mithep::ThreeVector dxy   = -momPerp.Cross(zHat)*fDxy/momPerp.R();
  mithep::ThreeVector dlxy  =  momPerp*fLxy/momPerp.R();
  return (dxy+dlxy+dz);
}

//--------------------------------------------------------------------------------------------------
inline Double_t mithep::DecayParticle::DxyCorrected(const mithep::ThreeVector &v) const
{
  // Compute Dxy with respect to a given position
  mithep::ThreeVector momPerp(Px(),Py(),0);
  return momPerp.Cross(Position() - v).Z()/Pt();
  
}

//--------------------------------------------------------------------------------------------------
inline Double_t mithep::DecayParticle::DxyCorrected(const mithep::BaseVertex *v) const
{
  // Compute Dxy with respect to a given beamspot/vertex
  return DxyCorrected(v->Position());
  
}

//--------------------------------------------------------------------------------------------------
inline Double_t mithep::DecayParticle::DzCorrected(const mithep::ThreeVector &v) const
{
  // Compute Dxy with respect to a given position
  mithep::ThreeVector momPerp(Px(),Py(),0);
  mithep::ThreeVector posPerp(Position().X()-v.X(),Position().Y()-v.Y(),0);
  return Position().Z() - v.Z() - posPerp.Dot(momPerp)/Pt() * (Pz()/Pt());
  
}

//--------------------------------------------------------------------------------------------------
inline Double_t mithep::DecayParticle::DzCorrected(const mithep::BaseVertex *v) const
{
  // Compute Dxy with respect to a given beamspot/vertex
  return DzCorrected(v->Position());
  
}


//--------------------------------------------------------------------------------------------------
inline Double_t mithep::DecayParticle::Z0EcalVtx(const ThreeVector &bspos, const ThreeVector &ecalpos) const
{
  // Compute z position at beamline with vector joining conversion vertex to ecal position
  mithep::ThreeVector dirscvtx = ecalpos - Position();
  
  mithep::ThreeVector momPerp(Px(),Py(),0);
  mithep::ThreeVector posPerp(Position().X()-bspos.X(),Position().Y()-bspos.Y(),0);
  return Position().Z() - posPerp.Dot(momPerp)/Pt() * (dirscvtx.Z()/dirscvtx.Rho());
  
}

inline Double_t mithep::DecayParticle::LxyCorrected(const mithep::BaseVertex *v) const
{
  // Compute Dxy with respect to a given beamspot/vertex
  Double_t dx = Position().X() - v->X();
  Double_t dy = Position().Y() - v->Y();
  Double_t lxy = (dx*Px() + dy*Py())/Pt();
  return lxy;
  
}

#endif
Revision:	1.35
Committed:	Fri Apr 8 00:01:29 2011 UTC (14 years, 1 month ago) by bendavid
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_025c_branch2, Mit_025c_branch1, Mit_025c_branch0, Mit_025c, Mit_025b, Mit_025a, Mit_025, Mit_025pre2, Mit_024b, Mit_025pre1, Mit_024a, Mit_024, Mit_023, Mit_022a, Mit_022, Mit_020d, TMit_020d, Mit_020c, Mit_021, Mit_021pre2, Mit_021pre1, Mit_020b
Branch point for:	Mit_025c_branch
Changes since 1.34:	+3 -3 lines
Log Message:	use momentum direction rather than vertex phi
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	bendavid	1.35	// $Id: DecayParticle.h,v 1.34 2011/04/07 11:30:45 bendavid Exp $
3	loizides	1.1	//
4	loizides	1.20	// DecayParticle
5	loizides	1.1	//
6	loizides	1.20	// The decay particle class is for use in vertexing based analyses. It
7			// stores vertex fit information (including four momentum) and links to daughters.
8	loizides	1.1	//
9	loizides	1.20	// Note that Charge() is still computed as a recursive loop over daughters, as inherited from
10			// CompositeParticle, but momentum is returned from the internally stored four vector.
11	bendavid	1.10	//
12	loizides	1.14	// Authors: C.Paus, J.Bendavid
13	loizides	1.1	//--------------------------------------------------------------------------------------------------
14
15	loizides	1.21	#ifndef MITANA_DATATREE_DECAYPARTICLE_H
16			#define MITANA_DATATREE_DECAYPARTICLE_H
17	loizides	1.1
18	loizides	1.26	#include <TDatabasePDG.h>
19			#include <TParticlePDG.h>
20			#include "MitCommon/DataFormats/interface/Vect4M.h"
21	bendavid	1.11	#include "MitAna/DataTree/interface/DaughterData.h"
22	bendavid	1.13	#include "MitAna/DataTree/interface/Vertex.h"
23	bendavid	1.30	#include "MitAna/DataTree/interface/ConversionQuality.h"
24	bendavid	1.13	#include "MitAna/DataCont/interface/RefArray.h"
25	loizides	1.20
26	loizides	1.1	namespace mithep
27			{
28	bendavid	1.13	class DecayParticle : public Particle
29	loizides	1.1	{
30			public:
31	loizides	1.23	DecayParticle() :
32			fAbsPdgId(0), fChi2(0), fNdof(0), fMassError(0),
33	bendavid	1.33	fLxy(0), fLxyError(0), fDxy(0), fDxyError(0), fLz(0), fLzError(0), fDzBeamlineError(0),
34			fDzBeamlineEcal(0), fDzBeamlineEcalError(0), fNSharedHits(0) {}
35	loizides	1.20	DecayParticle(Int_t absPdgId) :
36	loizides	1.23	fAbsPdgId(absPdgId), fChi2(0), fNdof(0), fMassError(0),
37	bendavid	1.33	fLxy(0), fLxyError(0), fDxy(0), fDxyError(0), fLz(0), fLzError(0), fDzBeamlineError(0),
38			fDzBeamlineEcal(0), fDzBeamlineEcalError(0), fNSharedHits(0) {}
39	bendavid	1.7
40	loizides	1.26	void AddDaughterData(const DaughterData *dd)
41			{ fDaughterData.Add(dd); ClearCharge(); }
42	loizides	1.25	UInt_t AbsPdgId() const { return fAbsPdgId; }
43			Double_t Chi2() const { return fChi2; }
44			const Particle *Daughter(UInt_t i) const { return DaughterDat(i)->Original(); }
45			const DaughterData *DaughterDat(UInt_t i) const { return fDaughterData.At(i); }
46			Double_t Dxy() const { return fDxy; }
47	bendavid	1.29	Double_t DxyCorrected(const ThreeVector &v) const;
48			Double_t DxyCorrected(const BaseVertex *v) const;
49	loizides	1.25	Double_t DxyError() const { return fDxyError; }
50	bendavid	1.32	Double_t DzBeamlineError() const { return fDzBeamlineError; }
51	bendavid	1.33	Double_t DzBeamlineEcal() const { return fDzBeamlineEcal; }
52			Double_t DzBeamlineEcalError() const { return fDzBeamlineEcalError; }
53	bendavid	1.29	Double_t DzCorrected(const ThreeVector &v) const;
54			Double_t DzCorrected(const BaseVertex *v) const;
55	bendavid	1.34	Double_t Z0EcalVtx(const ThreeVector &bspos, const ThreeVector &ecalpos) const;
56	loizides	1.20	Bool_t HasDaughter(const Particle *p) const;
57			Bool_t HasCommonDaughter(const DecayParticle *p) const;
58	loizides	1.25	Bool_t HasPriVertex() const { return fPriVtx.IsValid(); }
59	loizides	1.23	Bool_t HasPriVertex(const Vertex *v)
60	loizides	1.25	const { return fPriVtx.RefsObject(v); }
61	loizides	1.26	Bool_t HasSameDaughters(const DecayParticle *p) const;
62	loizides	1.25	Double_t Lxy() const { return fLxy; }
63			Double_t LxyError() const { return fLxyError; }
64	bendavid	1.31	Double_t LxyCorrected(const BaseVertex *v) const;
65	loizides	1.25	Double_t Lz() const { return fLz; }
66			Double_t LzError() const { return fLzError; }
67	loizides	1.26	Double_t MassError() const { return fMassError; }
68			UShort_t Ndof() const { return fNdof; }
69	loizides	1.25	UInt_t NDaughters() const { return fDaughterData.Entries(); }
70			EObjType ObjType() const { return kDecayParticle; }
71	loizides	1.20	TParticlePDG *ParticlePdgEntry() const;
72			Double_t PdgMass() const;
73	loizides	1.26	const Vertex *PriVertex() const { return fPriVtx.Obj(); }
74	loizides	1.25	Double_t Prob() const { return TMath::Prob(fChi2,fNdof); }
75	bendavid	1.24	const ThreeVector &Position() const;
76	bendavid	1.30	const ConversionQuality &Quality() const { return fQuality; }
77			ConversionQuality &Quality() { return fQuality; }
78	loizides	1.20	const ThreeVector RelativePosition() const;
79	bendavid	1.28	Bool_t SharedLayer(Track::EHitLayer l) const { return fSharedLayers.TestBit(l); }
80			const BitMask48 &SharedLayers() const { return fSharedLayers; }
81	bendavid	1.30	UInt_t NSharedLayers() const { return fSharedLayers.NBitsSet(); }
82			UInt_t NSharedHits() const { return TMath::Max(UInt_t(fNSharedHits),NSharedLayers()); }
83	loizides	1.25	void SetAbsPdgId(UInt_t apid) { fAbsPdgId=apid; }
84			void SetChi2(Double_t chi2) { fChi2 = chi2; }
85			void SetDxy(Double_t dxy) { fDxy = dxy; ClearPos(); }
86			void SetDxyError(Double_t dxyError) { fDxyError = dxyError; }
87	bendavid	1.32	void SetDzBeamlineError(Double_t dzError) { fDzBeamlineError = dzError; }
88	bendavid	1.33	void SetDzBeamlineEcal(Double_t dz) { fDzBeamlineEcal = dz; }
89			void SetDzBeamlineEcalError(Double_t dzError) { fDzBeamlineEcalError = dzError; }
90	loizides	1.25	void SetLxy(Double_t lxy) { fLxy = lxy; ClearPos(); }
91			void SetLxyError(Double_t lxyError) { fLxyError = lxyError; }
92			void SetLz(Double_t lz) { fLz = lz; ClearPos(); }
93			void SetLzError(Double_t lzError) { fLzError = lzError; }
94	loizides	1.26	void SetMassError(Double_t massError) { fMassError = massError; }
95			void SetMom(Double_t px, Double_t py, Double_t pz, Double_t e);
96			void SetMom(const FourVector &p)
97			{ fMomentum = p; ClearMom(); ClearPos(); }
98			void SetNdof(UShort_t ndof) { fNdof = ndof; }
99	bendavid	1.30	void SetNSharedHits(UShort_t nhits) { fNSharedHits = nhits; }
100	bendavid	1.24	void SetPriVertex(const Vertex *v) { fPriVtx = v; ClearPos(); }
101	bendavid	1.28	void SetSharedLayer(Track::EHitLayer l) { fSharedLayers.SetBit(l); }
102			void SetSharedLayers(const BitMask48 &layers) { fSharedLayers = layers; }
103	loizides	1.12	using TObject::Error;
104	loizides	1.20
105	loizides	1.1	protected:
106	bendavid	1.24	void ClearPos() const { fCachePosFlag.ClearCache(); }
107	loizides	1.23	Double_t GetCharge() const;
108			void GetMom() const;
109	bendavid	1.24	void GetPos() const;
110	loizides	1.23
111	loizides	1.20	UInt_t fAbsPdgId; //absolute value of pid code
112	loizides	1.26	Double32_t fChi2; //[0,0,12]chi-squared of fit
113			UShort_t fNdof; //degrees of freedom for fit
114			Double32_t fMassError; //[0,0,14]fitted mass error
115			Double32_t fLxy; //[0,0,14]fitted lxy (decay length)
116			Double32_t fLxyError; //[0,0,14]fitted lxy error
117			Double32_t fDxy; //[0,0,14]fitted impact parameter
118			Double32_t fDxyError; //[0,0,14]fitted impact parameter error
119			Double32_t fLz; //[0,0,14]fitted lz (decay length)
120			Double32_t fLzError; //[0,0,14]fitted lz error
121	bendavid	1.32	Double32_t fDzBeamlineError; //[0,0,14]fitted deltaz error at beamline
122	bendavid	1.33	Double32_t fDzBeamlineEcal; //[0,0,14]fitted deltaz at beamline (with ecal constraint)
123			Double32_t fDzBeamlineEcalError; //[0,0,14]fitted deltaz error at beamline (with ecal constraint)
124	loizides	1.26	Vect4M fMomentum; //momentum fourvector
125	bendavid	1.24	RefArray<DaughterData> fDaughterData; //momentum of daughters at vertex
126	loizides	1.25	Ref<Vertex> fPriVtx; //reference to primary vertex
127	bendavid	1.28	BitMask48 fSharedLayers; //layer mask for shared hits from daughter particles
128	bendavid	1.30	UShort_t fNSharedHits; //number of shared hits
129			ConversionQuality fQuality; //conversion quality flags
130	bendavid	1.24	mutable CacheFlag fCachePosFlag; //\|\|cache validity flag for position
131			mutable ThreeVector fCachedPos; //!cached momentum vector (filled by derived classes)
132
133	bendavid	1.33	ClassDef(DecayParticle, 5) // Decay particle class
134	loizides	1.1	};
135			}
136	bendavid	1.7
137			//--------------------------------------------------------------------------------------------------
138	loizides	1.23	inline Double_t mithep::DecayParticle::GetCharge() const
139			{
140			// Return sum of charge of daughter particles.
141
142			Double_t charge = 0;
143			for (UInt_t i=0; i<NDaughters(); ++i)
144			charge += DaughterDat(i)->Charge();
145
146			return charge;
147			}
148
149			//--------------------------------------------------------------------------------------------------
150			inline void mithep::DecayParticle::GetMom() const
151			{
152			// Get momentum values from stored values.
153
154	loizides	1.26	fCachedMom.SetCoordinates(fMomentum.Pt(), fMomentum.Eta(), fMomentum.Phi(), fMomentum.M());
155	loizides	1.23	}
156
157			//--------------------------------------------------------------------------------------------------
158	bendavid	1.7	inline TParticlePDG *mithep::DecayParticle::ParticlePdgEntry() const
159			{
160	loizides	1.20	// Return entry to pdg database for the particle.
161	bendavid	1.7
162			return TDatabasePDG::Instance()->GetParticle(fAbsPdgId);
163			}
164	bendavid	1.8
165			//--------------------------------------------------------------------------------------------------
166			inline void mithep::DecayParticle::SetMom(Double_t px, Double_t py, Double_t pz, Double_t e)
167			{
168	loizides	1.20	// Set four vector.
169	bendavid	1.8
170	bendavid	1.11	fMomentum.SetXYZT(px,py,pz,e);
171	bendavid	1.24	ClearMom();
172			ClearPos();
173			}
174
175			//--------------------------------------------------------------------------------------------------
176			inline const mithep::ThreeVector &mithep::DecayParticle::Position() const
177			{
178			// Return cached momentum value.
179
180			if (!fCachePosFlag.IsValid()) {
181			GetPos();
182			fCachePosFlag.SetValid();
183			}
184
185			return fCachedPos;
186	bendavid	1.11	}
187
188			//--------------------------------------------------------------------------------------------------
189	bendavid	1.24	inline void mithep::DecayParticle::GetPos() const
190	bendavid	1.13	{
191	loizides	1.20	// Return absolute position of decay.
192	bendavid	1.13
193			const mithep::Vertex *pv = PriVertex();
194
195			if (pv)
196	bendavid	1.24	fCachedPos = pv->Position() + RelativePosition();
197	bendavid	1.13	else
198	bendavid	1.24	fCachedPos = RelativePosition();
199	bendavid	1.13	}
200
201			//--------------------------------------------------------------------------------------------------
202			inline const mithep::ThreeVector mithep::DecayParticle::RelativePosition() const
203			{
204	loizides	1.20	// Compute the position vector of the decay vertex relative to the primary vertex.
205	bendavid	1.13
206	loizides	1.26	mithep::ThreeVector dz(0,0,fLz*TMath::Abs(Pz())/Pz());
207			mithep::ThreeVector momPerp(Px(),Py(),0);
208	bendavid	1.13	mithep::ThreeVector zHat(0,0,1.0);
209	paus	1.17	mithep::ThreeVector dxy = -momPerp.Cross(zHat)*fDxy/momPerp.R();
210			mithep::ThreeVector dlxy = momPerp*fLxy/momPerp.R();
211	bendavid	1.13	return (dxy+dlxy+dz);
212			}
213	bendavid	1.29
214			//--------------------------------------------------------------------------------------------------
215			inline Double_t mithep::DecayParticle::DxyCorrected(const mithep::ThreeVector &v) const
216			{
217			// Compute Dxy with respect to a given position
218			mithep::ThreeVector momPerp(Px(),Py(),0);
219			return momPerp.Cross(Position() - v).Z()/Pt();
220
221			}
222
223			//--------------------------------------------------------------------------------------------------
224			inline Double_t mithep::DecayParticle::DxyCorrected(const mithep::BaseVertex *v) const
225			{
226			// Compute Dxy with respect to a given beamspot/vertex
227			return DxyCorrected(v->Position());
228
229			}
230
231			//--------------------------------------------------------------------------------------------------
232			inline Double_t mithep::DecayParticle::DzCorrected(const mithep::ThreeVector &v) const
233			{
234			// Compute Dxy with respect to a given position
235			mithep::ThreeVector momPerp(Px(),Py(),0);
236			mithep::ThreeVector posPerp(Position().X()-v.X(),Position().Y()-v.Y(),0);
237			return Position().Z() - v.Z() - posPerp.Dot(momPerp)/Pt() * (Pz()/Pt());
238
239			}
240
241			//--------------------------------------------------------------------------------------------------
242			inline Double_t mithep::DecayParticle::DzCorrected(const mithep::BaseVertex *v) const
243			{
244			// Compute Dxy with respect to a given beamspot/vertex
245			return DzCorrected(v->Position());
246
247			}
248
249	bendavid	1.34
250			//--------------------------------------------------------------------------------------------------
251			inline Double_t mithep::DecayParticle::Z0EcalVtx(const ThreeVector &bspos, const ThreeVector &ecalpos) const
252			{
253			// Compute z position at beamline with vector joining conversion vertex to ecal position
254			mithep::ThreeVector dirscvtx = ecalpos - Position();
255
256	bendavid	1.35	mithep::ThreeVector momPerp(Px(),Py(),0);
257	bendavid	1.34	mithep::ThreeVector posPerp(Position().X()-bspos.X(),Position().Y()-bspos.Y(),0);
258	bendavid	1.35	return Position().Z() - posPerp.Dot(momPerp)/Pt() * (dirscvtx.Z()/dirscvtx.Rho());
259	bendavid	1.34
260			}
261
262	bendavid	1.31	inline Double_t mithep::DecayParticle::LxyCorrected(const mithep::BaseVertex *v) const
263			{
264			// Compute Dxy with respect to a given beamspot/vertex
265			Double_t dx = Position().X() - v->X();
266			Double_t dy = Position().Y() - v->Y();
267			Double_t lxy = (dxPx() + dyPy())/Pt();
268			return lxy;
269
270			}
271
272	loizides	1.1	#endif