---

Momentum.h

#ifndef PARTICLE_CLASS_MOMENTUM_H
#define PARTICLE_CLASS_MOMENTUM_H

#include <string>

#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Matrix/Matrix.h"
#include "CLHEP/Geometry/Point3D.h"

class Momentum 
{

public:
  Momentum();
  
  Momentum(const Momentum &);
  
  Momentum(const HepLorentzVector &, 
           const HepSymMatrix &error = HepSymMatrix(4,0));

  virtual ~Momentum();

  virtual std::string className(void) { return std::string("Momentum"); }

  virtual void dump(const std::string &keyword = std::string("mass momentum return"),
                    const std::string &prefix  = std::string("")) const;

  virtual const HepLorentzVector & p(void) const { return m_momentum; }
  
  virtual const HepSymMatrix dp(void) const { return m_error.sub(1,4); }
  
  virtual const HepPoint3D & x(void) const { return m_position; }
  
  virtual const HepSymMatrix dx(void) const { return m_error.sub(5,7); }

  virtual const HepSymMatrix & dpx(void) const { return m_error; }

  virtual double mass(void) const { return m_momentum.mag(); }
  
  virtual double dMass(void) const;

  virtual double eta(void) const { return m_momentum.vect().pseudoRapidity(); }
  
  virtual double phi(void) const { return m_momentum.phi(); }

  virtual double pt(void) const { 
    if (e() >= 0.) { return m_momentum.vect().perp(); }
    else { return -m_momentum.vect().perp(); }
  }

  virtual double e(void) const { return m_momentum.t(); }

  double deltaR(const Momentum *trk) const;

  double deltaR(const Momentum &trk) const { return deltaR(&trk); }
  
  virtual const HepPoint3D & vertex(void) const { return m_vertex; }

  virtual const HepSymMatrix & dVertex(void) const { return m_vertexError; }

  virtual const HepPoint3D & decayVertex(void) const { return m_decayVertex; }

  virtual const HepSymMatrix & dDecayVertex(void) const { return m_decayVertexError; }

  virtual void momentum(const HepLorentzVector &,
                        const HepSymMatrix     &error = HepSymMatrix(4,0));
  
  virtual void position(const HepPoint3D   &, 
                        const HepSymMatrix &error = HepSymMatrix(3,0));

  virtual void momentumPosition(const HepLorentzVector &, const HepPoint3D &, 
                                const HepSymMatrix &error = HepSymMatrix(7,0));

  virtual HepPoint3D & vertex(const HepPoint3D &, 
                              const HepSymMatrix &error = HepSymMatrix(3,0)); 

  virtual HepPoint3D & decayVertex(const HepPoint3D &, 
                                   const HepSymMatrix &error = HepSymMatrix(3,0)); 

  virtual Momentum & operator = (const Momentum &);

protected:
  HepLorentzVector m_momentum;       // 4
  HepPoint3D       m_position;       // 3
  HepSymMatrix     m_error;          // 7 x 7

  HepPoint3D       m_vertex;         // 3      ... production vertex
  HepSymMatrix     m_vertexError;    // 3 x 3  ... production vertex
  HepPoint3D       m_decayVertex;         // 3
  HepSymMatrix     m_decayVertexError;    // 3 x 3
};
#endif // PARTICLE_CLASS_MOMENTUM_H

---