DataTree/interface/PFCandidate.h

//--------------------------------------------------------------------------------------------------
// $Id: PFCandidate.h,v 1.8 2012/03/11 22:32:00 pharris Exp $
//
// PFCandidate
//
// Particle-flow candidate class, for now mostly mirroring the PFCandidate from CMSSW.
//
// Authors: J.Bendavid
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATATREE_PFCandidate_H
#define MITANA_DATATREE_PFCandidate_H

#include "MitCommon/DataFormats/interface/Vect3.h"
#include "MitCommon/DataFormats/interface/Vect4M.h"
#include "MitAna/DataCont/interface/Ref.h"
#include "MitAna/DataTree/interface/CompositeParticle.h"
#include "MitAna/DataTree/interface/Track.h"
#include "MitAna/DataTree/interface/Muon.h"
#include "MitAna/DataTree/interface/Conversion.h"

namespace mithep 
{
  class PFCandidate : public CompositeParticle
  {
    public:
      enum EPFType { 
        eX = 0,          //unidentified
        eHadron,         //charged hadron
        eElectron,       //electron
        eMuon,           //muon
        eGamma,          //photon
        eNeutralHadron,  //neutral hadron
        eHadronHF,       //hadron in HF
        eEGammaHF        //EM object in HF
      };

      enum EPFFlags { 
        eNormal = 0,
        eEMPhiSModules,
        eEMEta0,
        eEMEtaModules,
        eEMBarrelEndcap,
        eEMPreshowerEdge,
        eEMPreshower,
        eEMEndCapEdge,
        eHEta0,
        eHBarrelEndcap,
        eHEndcapVFCal,
        eHVFCalEdge,
        eToDispVtx,
        eFromDispVtx,
        eFromV0,
        eFromGammaConv,
        eToConversion,
        ePFNoPileup
      };

      PFCandidate() : fCharge(0), fEECal(0), fEHCal(0), fEECalRaw(0), fEHCalRaw(0),
                      fEPS1(0), fEPS2(0), fPError(0),fMvaEPi(0), fMvaEMu(0),
                      fMvaPiMu(0), fMvaGamma(0), fMvaNeutralH(0), fMvaGammaNeutralH(0),
                      fEtaECal(0), fPhiECal(0), fPFType(eX) {}
      PFCandidate(Double_t px, Double_t py, Double_t pz, Double_t e) : 
                      fMom(FourVector(px,py,pz,e)),
                      fCharge(0), fEECal(0), fEHCal(0), fEECalRaw(0), fEHCalRaw(0),
                      fEPS1(0), fEPS2(0), fPError(0),fMvaEPi(0), fMvaEMu(0),
                      fMvaPiMu(0), fMvaGamma(0), fMvaNeutralH(0), fMvaGammaNeutralH(0),
                      fEtaECal(0), fPhiECal(0), fPFType(eX) {}

      void                AddDaughter(const PFCandidate *p) { fDaughters.Add(p);                  }
      void                ClearFlag(EPFFlags f)             { fPFFlags.ClearBit(f);               }
      void                ClearFlags()                      { fPFFlags.Clear();                   }
      const Conversion   *Conv()                   const    { return fConversion.Obj();           }
      const PFCandidate  *Daughter(UInt_t i)       const;
      Double_t            EECal()                  const    { return fEECal;                      }
      Double_t            EHCal()                  const    { return fEHCal;                      }
      Double_t            EECalRaw()               const    { return fEECalRaw;                   }
      Double_t            EHCalRaw()               const    { return fEHCalRaw;                   }
      Double_t            EPS1()                   const    { return fEPS1;                       }
      Double_t            EPS2()                   const    { return fEPS2;                       }
      Double_t            PError()                 const    { return fPError;                     }
      Double_t            MvaEPi()                 const    { return fMvaEPi;                     }
      Double_t            MvaEMu()                 const    { return fMvaEMu;                     }
      Double_t            MvaPiMu()                const    { return fMvaPiMu;                    }
      Double_t            MvaGamma()               const    { return fMvaGamma;                   }
      Double_t            MvaNeutralH()            const    { return fMvaNeutralH;                }
      Double_t            MvaGammaNeutralH()       const    { return fMvaGammaNeutralH;           }
      Double_t            EtaECal()                const    { return fEtaECal;                    }
      Double_t            PhiECal()                const    { return fPhiECal;                    }
      Bool_t              Flag(EPFFlags f)         const    { return fPFFlags.TestBit(f);         }
      Bool_t              HasConversion()          const    { return fConversion.IsValid();       }
      Bool_t              HasMother()              const    { return fMother.IsValid();           }
      Bool_t              HasMother(const PFCandidate *m) const;
      Bool_t              HasTrackerTrk()          const    { return fTrackerTrack.IsValid();     }
      Bool_t              HasGsfTrk()              const    { return fGsfTrack.IsValid();         }
      Bool_t              HasTrk()                 const 
                            { return (HasTrackerTrk() || HasGsfTrk()); }
      const PFCandidate  *Mother()                 const    { return fMother.Obj();               }
      const Muon         *Mu()                     const    { return fMuon.Obj();                 }
      EObjType            ObjType()                const    { return kPFCandidate;                }
      EPFType             PFType()                 const    { return fPFType;                     }
      void                SetCharge(Double_t c)             { fCharge = c; ClearCharge();         }
      void                SetEECal(Double_t e)              { fEECal = e;                         }
      void                SetEHCal(Double_t e)              { fEHCal = e;                         }
      void                SetEECalRaw(Double_t e)           { fEECalRaw = e;                      }
      void                SetEHCalRaw(Double_t e)           { fEHCalRaw = e;                      }
      void                SetEPS1(Double_t e)               { fEPS1 = e;                          }
      void                SetEPS2(Double_t e)               { fEPS2 = e;                          }
      void                SetPError(Double_t err)           { fPError = err;                      }
      void                SetMvaEPi(Double_t d)             { fMvaEPi = d;                        }
      void                SetMvaEMu(Double_t d)             { fMvaEMu = d;                        }
      void                SetMvaPiMu(Double_t d)            { fMvaPiMu = d;                       }
      void                SetMvaGamma(Double_t d)           { fMvaGamma = d;                      }
      void                SetMvaNeutralH(Double_t d)        { fMvaNeutralH = d;                   }
      void                SetMvaGammaNeutralH(Double_t d)   { fMvaGammaNeutralH = d;              }
      void                SetEtaECal(Double_t eta)          { fEtaECal = eta;                     }
      void                SetPhiECal(Double_t phi)          { fPhiECal = phi;                     }
      void                SetPFType(EPFType t)              { fPFType = t;                        }
      void                SetFlag(EPFFlags f, Bool_t b=1)   { fPFFlags.SetBit(f,b);               }
      void                SetMom(Double_t px, Double_t py, Double_t pz, Double_t e);
      void                SetMother(const PFCandidate *p)   { fMother = p;                        }
      void                SetTrackerTrk(const Track *t)     { fTrackerTrack = t;                  }
      void                SetGsfTrk(const Track *t)         { fGsfTrack = t;                      }
      void                SetMuon(const Muon *m)            { fMuon = m;                          }
      void                SetConversion(const Conversion *c) 
                            { fConversion = c; }
      void                SetVertex(Double_t x, Double_t y, Double_t z);
      const ThreeVector   SourceVertex()           const    { return fSourceVertex.V();           }
      const Track        *TrackerTrk()             const    { return fTrackerTrack.Obj();         }
      const Track        *GsfTrk()                 const    { return fGsfTrack.Obj();             }
      const Track        *BestTrk()                const;
      const Track        *Trk()                    const    { return BestTrk();                   }
      
      // Some structural tools
      void                Mark()                   const;

    protected:
      Double_t            GetCharge()              const;
      void                GetMom()                 const;

      Vect4M              fMom;              //four momentum vector
      Vect3               fSourceVertex;     //pflow source vertex
      Double32_t          fCharge;           //[-1,1,2]charge
      Double32_t          fEECal;            //[0,0,14]corrected Ecal energy
      Double32_t          fEHCal;            //[0,0,14]corrected Hcal energy
      Double32_t          fEECalRaw;         //[0,0,14]uncorrected Ecal energy
      Double32_t          fEHCalRaw;         //[0,0,14]uncorrected Hcal energy
      Double32_t          fEPS1;             //[0,0,14]corrected PS1 energy
      Double32_t          fEPS2;             //[0,0,14]corrected PS2 energy
      Double32_t          fPError;           //[0,0,14]uncertainty on P (three-mom magnitude)
      Double32_t          fMvaEPi;           //[0,0,14]electron-pion discriminant
      Double32_t          fMvaEMu;           //[0,0,14]electron-muon discriminant
      Double32_t          fMvaPiMu;          //[0,0,14]pion-muon discriminant
      Double32_t          fMvaGamma;         //[0,0,14]photon id discriminant
      Double32_t          fMvaNeutralH;      //[0,0,14]neutral hadron id discriminant
      Double32_t          fMvaGammaNeutralH; //[0,0,14]photon-neutralhadron discriminant
      Double32_t          fEtaECal;          //[0,0,12]eta at ecal front face
      Double32_t          fPhiECal;          //[0,0,12]phi at ecal front face
      EPFType             fPFType;           //particle flow type
      BitMask32           fPFFlags;          //various PF flags
      Ref<PFCandidate>    fMother;           //reference to mother
      Ref<Track>          fTrackerTrack;     //reference to (standard) track
      Ref<Track>          fGsfTrack;         //reference to gsf track (for electrons only)
      Ref<Muon>           fMuon;             //reference to corresponding reco muon
      Ref<Conversion>     fConversion;       //reference to corresponding reco conversion

    ClassDef(PFCandidate,1) // Particle-flow candidate class
  };
}

//--------------------------------------------------------------------------------------------------
inline void mithep::PFCandidate::Mark() const
{
  // mark myself
  mithep::DataObject::Mark();
  // mark my dependencies if they are there
  if (fMother.IsValid())
    fMother.Obj()->Mark();
  if (fTrackerTrack.IsValid())
    fTrackerTrack.Obj()->Mark();
  if (fGsfTrack.IsValid())
    fGsfTrack.Obj()->Mark();
  if (fMuon.IsValid())
    fMuon.Obj()->Mark();
  if (fConversion.IsValid())
    fConversion.Obj()->Mark();
}

//--------------------------------------------------------------------------------------------------
inline const mithep::Track *mithep::PFCandidate::BestTrk() const 
{ 
  // Return gsf track if present, or else tracker track if present

  if (HasGsfTrk())
    return GsfTrk();

  if (HasTrackerTrk())
    return TrackerTrk();

  return 0;

}

//--------------------------------------------------------------------------------------------------
inline const mithep::PFCandidate *mithep::PFCandidate::Daughter(UInt_t i) const 
{ 
  // Return daughter corresponding to given index.

  return static_cast<const PFCandidate*>(fDaughters.At(i)); 
}

//--------------------------------------------------------------------------------------------------
inline Double_t mithep::PFCandidate::GetCharge() const
{
  // Get stored charge

  return fCharge;
}

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

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

//--------------------------------------------------------------------------------------------------
inline Bool_t mithep::PFCandidate::HasMother(const PFCandidate *m) const
{
  // Return true if the given particle is among mothers. (Note the comparison
  // is made on pointers and therefore will fail if you work on copies.)

  if (!m) 
    return kFALSE;

  const mithep::PFCandidate *mother = Mother();
  while (mother && mother!=m)
    mother = mother->Mother();

  if (mother) 
    return kTRUE;
  return kFALSE;
}

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

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

//--------------------------------------------------------------------------------------------------
inline void mithep::PFCandidate::SetVertex(Double_t x, Double_t y, Double_t z)
{
  // Set decay vertex.

  fSourceVertex.SetXYZ(x,y,z);
}
#endif
Revision:	1.9
Committed:	Wed Mar 28 12:15:34 2012 UTC (13 years, 1 month ago) by paus
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+22 -1 lines
Log Message:	Enable skimming.
#	User	Rev	Content
1	bendavid	1.1	//--------------------------------------------------------------------------------------------------
2	paus	1.9	// $Id: PFCandidate.h,v 1.8 2012/03/11 22:32:00 pharris Exp $
3	bendavid	1.1	//
4			// PFCandidate
5			//
6	loizides	1.2	// Particle-flow candidate class, for now mostly mirroring the PFCandidate from CMSSW.
7	bendavid	1.1	//
8			// Authors: J.Bendavid
9			//--------------------------------------------------------------------------------------------------
10
11			#ifndef MITANA_DATATREE_PFCandidate_H
12			#define MITANA_DATATREE_PFCandidate_H
13
14	loizides	1.2	#include "MitCommon/DataFormats/interface/Vect3.h"
15			#include "MitCommon/DataFormats/interface/Vect4M.h"
16	bendavid	1.1	#include "MitAna/DataCont/interface/Ref.h"
17			#include "MitAna/DataTree/interface/CompositeParticle.h"
18			#include "MitAna/DataTree/interface/Track.h"
19			#include "MitAna/DataTree/interface/Muon.h"
20			#include "MitAna/DataTree/interface/Conversion.h"
21
22			namespace mithep
23			{
24			class PFCandidate : public CompositeParticle
25			{
26			public:
27			enum EPFType {
28	loizides	1.2	eX = 0, //unidentified
29			eHadron, //charged hadron
30			eElectron, //electron
31			eMuon, //muon
32			eGamma, //photon
33	bendavid	1.1	eNeutralHadron, //neutral hadron
34	loizides	1.2	eHadronHF, //hadron in HF
35			eEGammaHF //EM object in HF
36	bendavid	1.1	};
37
38			enum EPFFlags {
39			eNormal = 0,
40			eEMPhiSModules,
41			eEMEta0,
42			eEMEtaModules,
43			eEMBarrelEndcap,
44			eEMPreshowerEdge,
45			eEMPreshower,
46			eEMEndCapEdge,
47			eHEta0,
48			eHBarrelEndcap,
49			eHEndcapVFCal,
50			eHVFCalEdge,
51	bendavid	1.7	eToDispVtx,
52			eFromDispVtx,
53	bendavid	1.1	eFromV0,
54			eFromGammaConv,
55	pharris	1.8	eToConversion,
56			ePFNoPileup
57	bendavid	1.1	};
58
59			PFCandidate() : fCharge(0), fEECal(0), fEHCal(0), fEECalRaw(0), fEHCalRaw(0),
60			fEPS1(0), fEPS2(0), fPError(0),fMvaEPi(0), fMvaEMu(0),
61			fMvaPiMu(0), fMvaGamma(0), fMvaNeutralH(0), fMvaGammaNeutralH(0),
62			fEtaECal(0), fPhiECal(0), fPFType(eX) {}
63			PFCandidate(Double_t px, Double_t py, Double_t pz, Double_t e) :
64			fMom(FourVector(px,py,pz,e)),
65			fCharge(0), fEECal(0), fEHCal(0), fEECalRaw(0), fEHCalRaw(0),
66			fEPS1(0), fEPS2(0), fPError(0),fMvaEPi(0), fMvaEMu(0),
67			fMvaPiMu(0), fMvaGamma(0), fMvaNeutralH(0), fMvaGammaNeutralH(0),
68			fEtaECal(0), fPhiECal(0), fPFType(eX) {}
69
70	loizides	1.2	void AddDaughter(const PFCandidate *p) { fDaughters.Add(p); }
71			void ClearFlag(EPFFlags f) { fPFFlags.ClearBit(f); }
72			void ClearFlags() { fPFFlags.Clear(); }
73			const Conversion *Conv() const { return fConversion.Obj(); }
74	bendavid	1.1	const PFCandidate *Daughter(UInt_t i) const;
75	loizides	1.2	Double_t EECal() const { return fEECal; }
76			Double_t EHCal() const { return fEHCal; }
77			Double_t EECalRaw() const { return fEECalRaw; }
78			Double_t EHCalRaw() const { return fEHCalRaw; }
79			Double_t EPS1() const { return fEPS1; }
80			Double_t EPS2() const { return fEPS2; }
81			Double_t PError() const { return fPError; }
82			Double_t MvaEPi() const { return fMvaEPi; }
83			Double_t MvaEMu() const { return fMvaEMu; }
84			Double_t MvaPiMu() const { return fMvaPiMu; }
85			Double_t MvaGamma() const { return fMvaGamma; }
86			Double_t MvaNeutralH() const { return fMvaNeutralH; }
87			Double_t MvaGammaNeutralH() const { return fMvaGammaNeutralH; }
88			Double_t EtaECal() const { return fEtaECal; }
89			Double_t PhiECal() const { return fPhiECal; }
90			Bool_t Flag(EPFFlags f) const { return fPFFlags.TestBit(f); }
91			Bool_t HasConversion() const { return fConversion.IsValid(); }
92			Bool_t HasMother() const { return fMother.IsValid(); }
93			Bool_t HasMother(const PFCandidate *m) const;
94			Bool_t HasTrackerTrk() const { return fTrackerTrack.IsValid(); }
95			Bool_t HasGsfTrk() const { return fGsfTrack.IsValid(); }
96			Bool_t HasTrk() const
97			{ return (HasTrackerTrk() \|\| HasGsfTrk()); }
98			const PFCandidate *Mother() const { return fMother.Obj(); }
99			const Muon *Mu() const { return fMuon.Obj(); }
100			EObjType ObjType() const { return kPFCandidate; }
101			EPFType PFType() const { return fPFType; }
102			void SetCharge(Double_t c) { fCharge = c; ClearCharge(); }
103			void SetEECal(Double_t e) { fEECal = e; }
104			void SetEHCal(Double_t e) { fEHCal = e; }
105			void SetEECalRaw(Double_t e) { fEECalRaw = e; }
106			void SetEHCalRaw(Double_t e) { fEHCalRaw = e; }
107			void SetEPS1(Double_t e) { fEPS1 = e; }
108			void SetEPS2(Double_t e) { fEPS2 = e; }
109			void SetPError(Double_t err) { fPError = err; }
110			void SetMvaEPi(Double_t d) { fMvaEPi = d; }
111			void SetMvaEMu(Double_t d) { fMvaEMu = d; }
112			void SetMvaPiMu(Double_t d) { fMvaPiMu = d; }
113			void SetMvaGamma(Double_t d) { fMvaGamma = d; }
114			void SetMvaNeutralH(Double_t d) { fMvaNeutralH = d; }
115			void SetMvaGammaNeutralH(Double_t d) { fMvaGammaNeutralH = d; }
116			void SetEtaECal(Double_t eta) { fEtaECal = eta; }
117			void SetPhiECal(Double_t phi) { fPhiECal = phi; }
118			void SetPFType(EPFType t) { fPFType = t; }
119			void SetFlag(EPFFlags f, Bool_t b=1) { fPFFlags.SetBit(f,b); }
120	bendavid	1.1	void SetMom(Double_t px, Double_t py, Double_t pz, Double_t e);
121	loizides	1.2	void SetMother(const PFCandidate *p) { fMother = p; }
122			void SetTrackerTrk(const Track *t) { fTrackerTrack = t; }
123			void SetGsfTrk(const Track *t) { fGsfTrack = t; }
124			void SetMuon(const Muon *m) { fMuon = m; }
125			void SetConversion(const Conversion *c)
126			{ fConversion = c; }
127	bendavid	1.1	void SetVertex(Double_t x, Double_t y, Double_t z);
128	loizides	1.2	const ThreeVector SourceVertex() const { return fSourceVertex.V(); }
129			const Track *TrackerTrk() const { return fTrackerTrack.Obj(); }
130			const Track *GsfTrk() const { return fGsfTrack.Obj(); }
131	bendavid	1.1	const Track *BestTrk() const;
132	loizides	1.2	const Track *Trk() const { return BestTrk(); }
133	bendavid	1.1
134	paus	1.9	// Some structural tools
135			void Mark() const;
136
137	bendavid	1.1	protected:
138			Double_t GetCharge() const;
139			void GetMom() const;
140
141	loizides	1.2	Vect4M fMom; //four momentum vector
142			Vect3 fSourceVertex; //pflow source vertex
143			Double32_t fCharge; //[-1,1,2]charge
144			Double32_t fEECal; //[0,0,14]corrected Ecal energy
145			Double32_t fEHCal; //[0,0,14]corrected Hcal energy
146			Double32_t fEECalRaw; //[0,0,14]uncorrected Ecal energy
147			Double32_t fEHCalRaw; //[0,0,14]uncorrected Hcal energy
148			Double32_t fEPS1; //[0,0,14]corrected PS1 energy
149			Double32_t fEPS2; //[0,0,14]corrected PS2 energy
150			Double32_t fPError; //[0,0,14]uncertainty on P (three-mom magnitude)
151			Double32_t fMvaEPi; //[0,0,14]electron-pion discriminant
152			Double32_t fMvaEMu; //[0,0,14]electron-muon discriminant
153			Double32_t fMvaPiMu; //[0,0,14]pion-muon discriminant
154			Double32_t fMvaGamma; //[0,0,14]photon id discriminant
155			Double32_t fMvaNeutralH; //[0,0,14]neutral hadron id discriminant
156			Double32_t fMvaGammaNeutralH; //[0,0,14]photon-neutralhadron discriminant
157	loizides	1.3	Double32_t fEtaECal; //[0,0,12]eta at ecal front face
158			Double32_t fPhiECal; //[0,0,12]phi at ecal front face
159	loizides	1.2	EPFType fPFType; //particle flow type
160			BitMask32 fPFFlags; //various PF flags
161			Ref<PFCandidate> fMother; //reference to mother
162			Ref<Track> fTrackerTrack; //reference to (standard) track
163			Ref<Track> fGsfTrack; //reference to gsf track (for electrons only)
164			Ref<Muon> fMuon; //reference to corresponding reco muon
165			Ref<Conversion> fConversion; //reference to corresponding reco conversion
166	bendavid	1.1
167	loizides	1.2	ClassDef(PFCandidate,1) // Particle-flow candidate class
168	bendavid	1.1	};
169			}
170
171			//--------------------------------------------------------------------------------------------------
172	paus	1.9	inline void mithep::PFCandidate::Mark() const
173			{
174			// mark myself
175			mithep::DataObject::Mark();
176			// mark my dependencies if they are there
177			if (fMother.IsValid())
178			fMother.Obj()->Mark();
179			if (fTrackerTrack.IsValid())
180			fTrackerTrack.Obj()->Mark();
181			if (fGsfTrack.IsValid())
182			fGsfTrack.Obj()->Mark();
183			if (fMuon.IsValid())
184			fMuon.Obj()->Mark();
185			if (fConversion.IsValid())
186			fConversion.Obj()->Mark();
187			}
188
189			//--------------------------------------------------------------------------------------------------
190	bendavid	1.1	inline const mithep::Track *mithep::PFCandidate::BestTrk() const
191			{
192			// Return gsf track if present, or else tracker track if present
193
194			if (HasGsfTrk())
195			return GsfTrk();
196
197			if (HasTrackerTrk())
198			return TrackerTrk();
199
200			return 0;
201
202			}
203
204			//--------------------------------------------------------------------------------------------------
205			inline const mithep::PFCandidate *mithep::PFCandidate::Daughter(UInt_t i) const
206			{
207			// Return daughter corresponding to given index.
208
209			return static_cast<const PFCandidate*>(fDaughters.At(i));
210			}
211
212			//--------------------------------------------------------------------------------------------------
213			inline Double_t mithep::PFCandidate::GetCharge() const
214			{
215			// Get stored charge
216
217			return fCharge;
218			}
219
220			//--------------------------------------------------------------------------------------------------
221			inline void mithep::PFCandidate::GetMom() const
222			{
223			// Get momentum values from stored values.
224
225	loizides	1.2	fCachedMom.SetCoordinates(fMom.Pt(),fMom.Eta(),fMom.Phi(),fMom.M());
226	bendavid	1.1	}
227
228			//--------------------------------------------------------------------------------------------------
229			inline Bool_t mithep::PFCandidate::HasMother(const PFCandidate *m) const
230			{
231			// Return true if the given particle is among mothers. (Note the comparison
232			// is made on pointers and therefore will fail if you work on copies.)
233
234			if (!m)
235			return kFALSE;
236
237			const mithep::PFCandidate *mother = Mother();
238			while (mother && mother!=m)
239			mother = mother->Mother();
240
241			if (mother)
242			return kTRUE;
243			return kFALSE;
244			}
245
246			//--------------------------------------------------------------------------------------------------
247			inline void mithep::PFCandidate::SetMom(Double_t px, Double_t py, Double_t pz, Double_t e)
248			{
249			// Set four vector.
250
251			fMom.SetXYZT(px, py, pz, e);
252			ClearMom();
253			}
254
255			//--------------------------------------------------------------------------------------------------
256			inline void mithep::PFCandidate::SetVertex(Double_t x, Double_t y, Double_t z)
257			{
258			// Set decay vertex.
259
260			fSourceVertex.SetXYZ(x,y,z);
261			}
262			#endif