---

TrState.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 TrEvent_TrState_H
#define TrEvent_TrState_H 1

// Include files
#include "Kernel/CLHEPStreams.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Matrix/Vector.h"
#include "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/ObjectList.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/StreamBuffer.h"


// Class ID definition
  static const CLID& CLID_TrState = 10004;

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


class TrState: public KeyedObject<int>
{

public: 

  enum Type {HasMomentum,StraightLine};   
  enum ReferenceLocation {NotDefined=0,ClosestToBeam,AtFirstMeasurement,BeforeRICH1,AfterRICH1,BeforeRICH2,AfterRICH2};   

  TrState(const TrState& state)
  {

   m_type            = state.type();
   m_state           = state.state();
   m_stateCovariance = state.stateCovariance();
   m_z               = state.z();
        
  }

  TrState() 
    : m_type(0),
    m_state(),
    m_stateCovariance(),
    m_z(0.0) {}

  virtual ~TrState() {}

  virtual const CLID& clID() const; 
  static const CLID& classID(); 

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

  virtual HepPoint3D position() const;

  virtual double x() const;

  virtual double y() const;

  virtual double z() const;

  virtual HepVector3D slopes() const;

  virtual double tx() const;

  virtual double ty() const;

  virtual double qOverP() const;

  virtual double p() const;

  virtual double pt() const;

  virtual HepVector3D momentum() const;

  virtual HepSymMatrix posMomCovariance() const;

  virtual std::vector errPosition() const;

  virtual double errX2() const;

  virtual double errY2() const;

  virtual std::vector errSlopes() const;

  virtual double errTx2() const;

  virtual double errTy2() const;

  virtual double errQOverP2() const;

  virtual double errP2() const;

  virtual std::vector errMomentum() const;

  virtual TrState* clone() const;

  virtual void setState(const HepVector& state);

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

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

  virtual void setX(double value);

  virtual void setY(double value);

  virtual void setTx(double value);

  virtual void setTy(double value);

  virtual void setQOverP(double value);

  virtual void setErrX2(double value);

  virtual void setErrY2(double value);

  virtual void setErrTx2(double value);

  virtual void setErrTy2(double value);

  virtual void setErrQOverP2(double value);

  int type() const; 

  void setType(int value);

  const HepVector& state() const; 

  HepVector& state();

  const HepSymMatrix& stateCovariance() const; 

  HepSymMatrix& stateCovariance();

  void setStateCovariance(const HepSymMatrix& value);

  double z() const; 

  void setZ(double value);

  virtual StreamBuffer& serialize(StreamBuffer& s) const;

  virtual StreamBuffer& serialize(StreamBuffer& s);

  virtual std::ostream& fillStream(std::ostream& s) const;

protected: 

private: 

  int          m_type;            
  HepVector    m_state;           
  HepSymMatrix m_stateCovariance; 
  double       m_z;               

};

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


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

inline const CLID& TrState::classID()
{
  return CLID_TrState;
}

inline void TrState::positionAndMomentum(const HepPoint3D& pos, const HepVector3D& mom, const HepSymMatrix& cov6D) const
{
   
   HepPoint3D pos = state.position();
          
}

inline HepPoint3D TrState::position() const
{
   
   return HepPoint3D( m_state[0], m_state[1], m_z );
        
}

inline double TrState::x() const
{
   
   return m_state[0];
        
}

inline double TrState::y() const
{
   
   return m_state[1];
        
}

inline double TrState::z() const
{
   
   return m_z;
        
}

inline double TrState::tx() const
{
   
   return m_state[2];
        
}

inline double TrState::ty() const
{
   
   return m_state[3];
        
}

inline double TrState::qOverP() const
{
   
   return m_state[4];
        
}

inline double TrState::p() const
{
   
   if ( m_state.type() == TrState::StraightLine ) return 0.;
   return fabs( 1./m_state[4] );
        
}

inline double TrState::errX2() const
{
   
   return m_covariance.fast(1,1);
        
}

inline double TrState::errY2() const
{
   
   return m_covariance.fast(2,2);
        
}

inline double TrState::errTx2() const
{
   
   return m_covariance.fast(3,3);
        
}

inline double TrState::errTy2() const
{
   
   return m_covariance.fast(4,4);
        
}

inline void TrState::setState(double x, double y, double z, double tx, double ty, double qOverP)
{
   
   m_state[0] = x;
   m_state[1] = y;
   m_state[2] = tx;
   m_state[3] = ty;
   m_state[4] = qOverP;
   m_z        = z;
        
}

inline void TrState::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 TrState::setX(double value)
{
   
   m_state[0] = value;
        
}

inline void TrState::setY(double value)
{
   
   m_state[1] = value;
        
}

inline void TrState::setTx(double value)
{
   
   m_state[2] = value;
        
}

inline void TrState::setTy(double value)
{
   
   m_state[3] = value;
        
}

inline void TrState::setQOverP(double value)
{
   
   if ( m_state.type() == TrState::HasMomentum ) m_state[4] = value;
        
}

inline void TrState::setErrX2(double value)
{
   
   m_covariance(1,1) = value;
        
}

inline void TrState::setErrY2(double value)
{
   
   m_covariance(2,2) = value;
        
}

inline void TrState::setErrTx2(double value)
{
   
   m_covariance(3,3) = value;
        
}

inline void TrState::setErrTy2(double value)
{
   
   m_covariance(4,4) = value;
        
}

inline void TrState::setErrQOverP2(double value)
{
   
   if ( m_state.type() == TrState::HasMomentum ) m_covariance(5,5) = value;
        
}

inline int TrState::type() const 
{
  return m_type;
}

inline void TrState::setType(int value)
{
  m_type = value; 
}

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

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

inline const HepSymMatrix& TrState::stateCovariance() const 
{
  return m_stateCovariance;
}

inline HepSymMatrix& TrState::stateCovariance()
{
  return m_stateCovariance;
}

inline void TrState::setStateCovariance(const HepSymMatrix& value)
{
  m_stateCovariance = value; 
}

inline double TrState::z() const 
{
  return m_z;
}

inline void TrState::setZ(double value)
{
  m_z = value; 
}

inline StreamBuffer& TrState::serialize(StreamBuffer& s) const 
{
  KeyedObject<int>::serialize(s);
  s << m_type
    << m_state
    << m_stateCovariance
    << (float)m_z;
  return s;
}

inline StreamBuffer& TrState::serialize(StreamBuffer& s)
{
  float l_z;
  KeyedObject<int>::serialize(s);
  s >> m_type
    >> m_state
    >> m_stateCovariance
    >> l_z;
  m_z = l_z;
  return s;
}

inline std::ostream& TrState::fillStream(std::ostream& s) const
{
  s << "{ "
    << " type:\t" << m_type << std::endl
    << "   state:\t" << m_state << std::endl
    << "   stateCovariance:\t" << m_stateCovariance << std::endl
    << "   z:\t" << (float)m_z << " } ";
  return s;
}

//Definition of keyed container for TrState
typedef KeyedContainer<TrState, Containers::HashMap> TrStates;

#endif   

---