---

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 "CLHEP/Geometry/Point3D.h"
#include "GaudiKernel/StreamBuffer.h"
#include "CLHEP/Geometry/Vector3D.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 Location {BegVelo,EndVelo,AtTT,AtT,BegRICH1,EndRICH1,BegRICH2,EndRICH2,Calo,Muon};   

  TrState();

  TrState(const Type& type);

  TrState(const TrState& state);

  virtual ~TrState() {}

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

  unsigned int nParameters() const;

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

  HepPoint3D position();

  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;

  HepSymMatrix errMomentum() const;

  virtual double errQOverPperp2() const;

  virtual TrState* clone();

  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 setTx(double value);

  void setTy(double value);

  virtual void setQOverP(double value);

  unsigned int type() const; 

  unsigned int location() const; 

  void setLocation(unsigned int value);

  const HepVector& state() const; 

  HepVector& state();

  const HepSymMatrix& covariance() const; 

  HepSymMatrix& covariance();

  virtual StreamBuffer& serialize(StreamBuffer& s) const;

  virtual StreamBuffer& serialize(StreamBuffer& s);

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

protected: 

private: 

  unsigned int m_type;       
  unsigned int m_location;   
  HepVector    m_state;      
  HepSymMatrix m_covariance; 
  double       m_z;          

};

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


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

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

inline unsigned int TrState::nParameters() const
{
   
  return (unsigned int) m_state.num_row();
        
}

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

inline HepPoint3D TrState::position()
{
   
  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 HepVector3D TrState::slopes() const
{
   
  return HepVector3D( m_state[2], m_state[3], 1.);
        
}

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

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

inline HepVector3D TrState::momentum() const
{
   
  HepVector3D mom = slopes();
  mom *= ( p() / mom.mag() );
  return mom;
        
}

inline double TrState::qOverPperp() const
{
   
  double tx2 = tx() * tx();
  return ( qOverP() * sqrt( (1.+ tx2 + ty()*ty()) / (1. + tx2 ) ) );
        
}

inline HepSymMatrix TrState::errPosition() const
{
   
  return posMomCovariance().sub(1,3);
        
}

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

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

inline HepSymMatrix TrState::errSlopes() const
{
   
  HepSymMatrix err = m_covariance.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 TrState::errTx2() const
{
   
  return m_covariance.fast(3,3);
        
}

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

inline HepSymMatrix TrState::errMomentum() const
{
   
  if ( m_type == TrState::HasMomentum ) {
    return posMomCovariance().sub(4,6);
  }
  else {
    // print out an error message ...
    return HepSymMatrix(3,0);
  }
        
}

inline void TrState::setState(const HepVector& state)
{
   
  m_state = state;
        
}

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::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 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 unsigned int TrState::type() const 
{
  return m_type;
}

inline unsigned int TrState::location() const 
{
  return m_location;
}

inline void TrState::setLocation(unsigned int value)
{
  m_location = value; 
}

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

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

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

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

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

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

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

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

#endif   

---