---

State.h

Go to the documentation of this file.

#ifndef State_h
#define State_h 1

#include "HepVector.h"
#include "HepSymMatrix.h"
#include "HepPoint3D.h"
#include "HepVector3D.h"

class State {
 public:
  
  // types of states
  // enum StateType {Helix};
  
 protected:
  
  // int m_type;

  HepVector m_x;
  
  HepSymMatrix m_cov;
  
  double m_z;
      

  public:
      
  State() 
    {}
  
  virtual ~State() 
    {}
  
  // void setType(const int type)
  //  {m_type = type;}
  
  // int type() const 
  //  {return m_type;}

  // [optinal: if we derive states], create derived class, return base
  //  virtual State* clone() const  
  // {State* state = new State(*this); return state;}
  
  void setVector(const HepVector& x)
    {m_x = x;}

  const HepVector& vector() const
    {return _hv.vector();}
  
  void setMatrix(const HepSymMatrix& cov)
    {m_cov = cov;}

  const HepSymMatrix& matrix() const
    {return m_cov;}
  
  void setZ(double par) 
    {_z = par;}
  
  double z() const
    {return _z;}
        
  HepPoint3D position() const
    {return HepPoint3D(m_x[0],m_x[1],m_z);}

  HepVector3D direction() const {
    double ocosz = sqrt(m_x[2]*m_x[2]+m_x[3]*m_x[3]+1);
    return HepVector3D(m_x[2]/ocosz,m_x[3]/ocosz,1/ocosz);
  }
  
  HepVector3D slopes() const
    {return HepVector3D(m_x[2],m_x[3],1.);}
  
  double p() const {
    //  [?]  if (m_x[4] == 0.) return ?;
    return (1/m_x[4]);
  }

  HepVector3D momentum() const {
    return p()*direction();
  }

  double pt() const {
    HepVector3D pp = momentum();
    return sqrt(pp.x()*pp.x()+pp.y()*pp.y());
  }

};
#endif

---