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 "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:

  enum Type{ HasMomentum=1,
             StraightLine=2 };
  enum Location{ Unknown,
                 ClosestToBeam,
                 FirstMeasurement,
                 EndVelo,
                 AtTT,
                 AtT,
                 BegRich1,
                 EndRich1,
                 BegRich2,
                 EndRich2,
                 Calo,
                 Muon };

  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;

  virtual void reset();

  void setState(const HepVector& state);

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

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

  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);

  unsigned int flags() const;

  bool checkType(const Type& value) const;

  void setLocation(const Location& value);

  bool checkLocation(const Location& value) const;

  const HepVector& state() const;

  HepVector& state();

  const HepSymMatrix& covariance() const;

  HepSymMatrix& covariance();

protected:

  void setType(const State::Type& value);

  enum flagsBits{typeBits     = 0,
                 locationBits = 2};

  enum flagsMasks{typeMask     = 0x3L,
                  locationMask = 0xFFCL};


  unsigned int m_flags;      
  HepVector    m_state;      
  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 bool State::checkType(const Type& value) const
{
  unsigned int val = (unsigned int)value;
  return 0 != ( m_flags & typeMask & ( val << typeBits ));
}

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

inline bool State::checkLocation(const Location& value) const
{
  unsigned int val = (unsigned int)value;
  return 0 != ( m_flags & locationMask & ( val << locationBits ));
}

inline const HepVector& State::state() const 
{
  return m_state;
}

inline HepVector& State::state() 
{
  return m_state;
}

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_state.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_state[0], m_state[1], m_z );
        
}

inline double State::x() const 
{

  return m_state[0];
        
}

inline double State::y() const 
{

  return m_state[1];
        
}

inline double State::z() const 
{

  return m_z;
        
}

inline HepVector3D State::slopes() const 
{

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

inline double State::tx() const 
{

  return m_state[2];
        
}

inline double State::ty() const 
{

  return m_state[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_state = state;
        
}

inline void State::setState(double x,
                            double y,
                            double z,
                            double tx,
                            double ty) 
{

  m_state[0] = x;
  m_state[1] = y;
  m_state[2] = tx;
  m_state[3] = ty;
  m_z        = z;
        
}

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

  if ( value.num_row() == (int) nParameters() ) {
    m_covariance = value;
  }
  else {
    std::cerr << "ERROR   The dimension of the covariance matrix does not match that of the state!"
              << "ERROR   Using the default covariance matrix." << std::endl;
    int dim = nParameters();
    m_covariance = HepSymMatrix(dim,0);
  }
        
}

inline void State::setX(double value) 
{

  m_state[0] = value;
        
}

inline void State::setY(double value) 
{

  m_state[1] = value;
        
}

inline void State::setZ(double value) 
{

  m_z = value;
        
}

inline void State::setTx(double value) 
{

  m_state[2] = value;
        
}

inline void State::setTy(double value) 
{

  m_state[3] = value;
        
}

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



#endif 

---