State.h

Go to the documentation of this file.

//   **************************************************************************
//   *                                                                        *
//   *                      ! ! ! A T T E N T I O N ! ! !                     *
//   *                                                                        *
//   *  This file was created automatically by GaudiObjDesc, please do not    *
//   *  delete it or edit it by hand.                                         *
//   *                                                                        *
//   *  If you want to change this file, first change the corresponding       *
//   *  xml-file and rerun the tools from GaudiObjDesc (or run make if you    *
//   *  are using it from inside a Gaudi-package).                            *
//   *                                                                        *
//   **************************************************************************

#ifndef TrackEvent_State_H
#define TrackEvent_State_H 1

// Include files
#include "GaudiKernel/GaudiException.h"
#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Geometry/Vector3D.h"
#include "GaudiKernel/KeyedContainer.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Matrix/SymMatrix.h"


// Forward declarations

// Class ID definition
static const CLID& CLID_State = 10011;

// Namespace for locations in TDS
namespace StateLocation {
  static const std::string& Default = "Rec/Track/States";
}


class State
{
public:

  State();

  virtual ~State() {}

  // Retrieve pointer to class definition structure
  virtual const CLID& clID() const;
  static const CLID& classID();

  unsigned int nParameters() const;

  void positionAndMomentum(HepPoint3D& pos,
                           HepVector3D& mom,
                           HepSymMatrix& cov6D) const;

  void positionAndMomentum(HepPoint3D& pos,
                           HepVector3D& mom) const;

  HepPoint3D position() const;

  double x() const;

  double y() const;

  double z() const;

  HepVector3D slopes() const;

  double tx() const;

  double ty() const;

  virtual double qOverP() const;

  virtual double p() const;

  virtual double pt() const;

  HepVector3D momentum() const;

  double qOverPperp() const;

  virtual HepSymMatrix posMomCovariance() const;

  HepSymMatrix errPosition() const;

  double errX2() const;

  double errY2() const;

  HepSymMatrix errSlopes() const;

  double errTx2() const;

  double errTy2() const;

  virtual double errQOverP2() const;

  virtual double errP2() const;

  virtual HepSymMatrix errMomentum() const;

  virtual double errQOverPperp2() const;

  virtual State* clone() const;

  void setState(const HepVector& state);

  virtual void setState(double x,
                        double y,
                        double z,
                        double tx,
                        double ty,
                        double qOverP);

  void setCovariance(const HepSymMatrix& value);

  void setX(double value);

  void setY(double value);

  void setZ(double value);

  void setTx(double value);

  void setTy(double value);

  virtual void setQOverP(double value);

  bool checkLocation(unsigned int value) const;

  unsigned int flags() const;

  void setFlags(unsigned int value);

  unsigned int location() const;

  void setLocation(unsigned int value);

  const HepVector& stateVector() const;

  HepVector& stateVector();

  const HepSymMatrix& covariance() const;

  HepSymMatrix& covariance();

protected:

  enum flagsBits{locationBits = 0};

  enum flagsMasks{locationMask = 0xFFFFL};


  unsigned int m_flags;       
  HepVector    m_stateVector; 
  HepSymMatrix m_covariance;  
  double       m_z;           

private:

};

// -----------------------------------------------------------------------------
//   end of class
// -----------------------------------------------------------------------------

// Including forward declarations

inline const CLID& State::clID() const
{
  return State::classID();
}

inline const CLID& State::classID()
{
  return CLID_State;
}

inline unsigned int State::flags() const 
{
  return m_flags;
}

inline void State::setFlags(unsigned int value) 
{
  m_flags = value;
}

inline unsigned int State::location() const
{
  return (unsigned int)((m_flags & locationMask) >> locationBits);
}

inline void State::setLocation(unsigned int value)
{
  unsigned int val = (unsigned int)value;
  m_flags &= ~locationMask;
  m_flags |= ((((unsigned int)val) << locationBits) & locationMask);
}

inline const HepVector& State::stateVector() const 
{
  return m_stateVector;
}

inline HepVector& State::stateVector() 
{
  return m_stateVector;
}

inline const HepSymMatrix& State::covariance() const 
{
  return m_covariance;
}

inline HepSymMatrix& State::covariance() 
{
  return m_covariance;
}

inline unsigned int State::nParameters() const 
{

  return (unsigned int) m_stateVector.num_row();
        
}

inline void State::positionAndMomentum(HepPoint3D& pos,
                                       HepVector3D& mom,
                                       HepSymMatrix& cov6D) const 
{

  pos   = position();
  mom   = momentum();
  cov6D = posMomCovariance();
        
}

inline void State::positionAndMomentum(HepPoint3D& pos,
                                       HepVector3D& mom) const 
{

  pos   = position();
  mom   = momentum();
        
}

inline HepPoint3D State::position() const 
{

  return HepPoint3D( m_stateVector[0], m_stateVector[1], m_z );
        
}

inline double State::x() const 
{

  return m_stateVector[0];
        
}

inline double State::y() const 
{

  return m_stateVector[1];
        
}

inline double State::z() const 
{

  return m_z;
        
}

inline HepVector3D State::slopes() const 
{

  return HepVector3D( m_stateVector[2], m_stateVector[3], 1.);
        
}

inline double State::tx() const 
{

  return m_stateVector[2];
        
}

inline double State::ty() const 
{

  return m_stateVector[3];
        
}

inline HepVector3D State::momentum() const 
{

  HepVector3D mom = slopes();
  mom *= ( p() / mom.mag() );
  return mom;
        
}

inline double State::qOverPperp() const 
{

  double tx2 = tx() * tx();
  return ( qOverP() * sqrt( (1.+ tx2 + ty()*ty()) / (1. + tx2 ) ) );
        
}

inline HepSymMatrix State::errPosition() const 
{

  const HepSymMatrix temp = posMomCovariance();
  return temp.sub(1,3);
        
}

inline double State::errX2() const 
{

  return m_covariance.fast(1,1);
        
}

inline double State::errY2() const 
{

  return m_covariance.fast(2,2);
        
}

inline HepSymMatrix State::errSlopes() const 
{

  const HepSymMatrix temp = m_covariance;
  HepSymMatrix err = temp.sub(3,5);
  err.fast(2,1) = 0.;
  err.fast(3,1) = 0.;
  err.fast(3,2) = 0.;
  err.fast(3,3) = 0.;
  return err;
        
}

inline double State::errTx2() const 
{

  return m_covariance.fast(3,3);
        
}

inline double State::errTy2() const 
{

  return m_covariance.fast(4,4);
        
}

inline void State::setState(const HepVector& state) 
{

  m_stateVector = state;
        
}

inline void State::setCovariance(const HepSymMatrix& value) 
{

  if ( value.num_row() != (int) nParameters() )
    throw GaudiException( "The dimension of the covariance matrix does not match that of the State!",
                          "State.h",
                          StatusCode::FAILURE );
  m_covariance = value;
        
}

inline void State::setX(double value) 
{

  m_stateVector[0] = value;
        
}

inline void State::setY(double value) 
{

  m_stateVector[1] = value;
        
}

inline void State::setZ(double value) 
{

  m_z = value;
        
}

inline void State::setTx(double value) 
{

  m_stateVector[2] = value;
        
}

inline void State::setTy(double value) 
{

  m_stateVector[3] = value;
        
}

inline bool State::checkLocation(unsigned int value) const 
{

  return location() == value;
        
}

// Definition of Keyed Container for State
typedef KeyedContainer<State, Containers::HashMap> States;



#endif 

---