---

TrState.cpp

Go to the documentation of this file.

// $Id: $
// Include files 

// local
#include "Event/TrState.h"

//-----------------------------------------------------------------------------
// Implementation file for class : TrState
//
// 2004-10-04 : Eduardo Rodrigues
//-----------------------------------------------------------------------------

//=============================================================================
// Default constructor. State defined to be of type TrState::HasMomentum
//=============================================================================
TrState::TrState() {
  m_type       = TrState::HasMomentum;
  m_z          = 0.;
  m_state      = HepVector(5,0);
  m_covariance = HepSymMatrix(5,0);
}

//=============================================================================
// Constructor with specification of the state type
//=============================================================================
TrState::TrState( const Type &type ):
  KeyedObject<int>()
{
  m_type       = type;
  m_z          = 0.;
  m_state      = HepVector(5,0);
  m_covariance = HepSymMatrix(5,0);
}

//=============================================================================
// Copy constructor
//=============================================================================
TrState::TrState( const TrState &state ):
  KeyedObject<int>()
{
  m_type       = state.type();
  m_z          = state.z();
  m_state      = state.state();
  m_covariance = state.covariance();
}

//=============================================================================
// Retrieve the charge-over-momentum Q/P of the state
//=============================================================================
double TrState::qOverP() const
{
  return m_state[4];
};

//=============================================================================
// Retrieve the momentum of the state
//=============================================================================
double TrState::p() const
{
  if ( m_state[4] != 0. ) return fabs( 1./m_state[4] );
  return 0.;
};

//=============================================================================
// Retrieve the transverse momentum of the state
//=============================================================================
double TrState::pt() const
{
  if ( m_state[4] != 0. ) {
    double txy2 = m_state[2]*m_state[2] + m_state[3]*m_state[3];
    return sqrt( txy2/(1.+txy2) ) / fabs( m_state[4] );
  }
  return 0.;
};


//=============================================================================
// Retrieve the 6D covariance matrix (x,y,z,px,py,pz) of the state
//=============================================================================
HepSymMatrix TrState::posMomCovariance() const
{
  HepSymMatrix cov = covariance();
  // to be written ...

  return cov;
  
};

//=============================================================================
// Retrieve the squared error on the charge-over-momentum Q/P of the state
//=============================================================================
double TrState::errQOverP2() const
{
  return m_covariance.fast(5,5);
};

//=============================================================================
// Retrieve the squared error on the momentum of the state
//=============================================================================
double TrState::errP2() const
{
  if ( m_state[4] != 0. ) return errQOverP2() / pow( m_state[4], 4. );
  return 0.;
};

//=============================================================================
// Retrieve the squared error on the Q/Pperp of the state
//=============================================================================
double TrState::errQOverPperp2() const
{
  double tx2        = tx() * tx();
  double ty2        = ty() * ty();
  double qOverP2    = qOverP() * qOverP();
  double transSlope = 1. + tx2;
  double norm       = 1 + tx2 + ty2;

  double QOverPperpError = ( (norm/transSlope) * m_covariance[4][4] )

    + ( qOverP2 * tx2 * ty2*ty2 * m_covariance[2][2]/
       (pow(transSlope,3.)*norm))

    + ( qOverP2 * ty2 * m_covariance[3][3] / (norm*transSlope) )

    - ( 2. * qOverP() * tx() * ty2 * m_covariance[2][4]
        / ( transSlope*transSlope ) )

    + 2. * qOverP() * ty() * m_covariance[3][4] / transSlope

    - 2. * ( qOverP2 * tx() * ty() * ty2 * m_covariance[2][3]
         / ( norm* transSlope*transSlope ) );

  return QOverPperpError;
};

//=============================================================================
// Clone the state
//=============================================================================
TrState* TrState::clone()
{
  return new TrState(*this);
};

//=============================================================================
// Clear the state before re-using it
//=============================================================================
void TrState::reset()
{
  m_z          = 0.;
  m_state      = HepVector(5,0);
  m_covariance = HepSymMatrix(5,0);
};

//=============================================================================
// Update the state vector (presumably of type TrState::HasMomentum)
//=============================================================================
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_z        = z;
  if ( m_type == TrState::StraightLine ) {
    std::cerr
      << "ERROR   You're trying to set the Q/P value for a state of type TrState::StraightLine!"
      << "ERROR   This value will be discarded." << std::endl;
  }
  else {
     m_state[4] = qOverP;
  }
};

//=============================================================================
// Update the Q/P value of the state
//=============================================================================
void TrState::setQOverP( double value )
{
  m_state[4] = value;
};

//=============================================================================

---