---

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() {
  setType( TrState::HasMomentum );
  m_z          = 0.;
  m_state      = HepVector(5,0);
  m_covariance = HepSymMatrix(5,0);
}

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

//=============================================================================
// Copy constructor
//=============================================================================
TrState::TrState( const TrState &state ):
  KeyedObject<int>()
{
  m_flags      = state.flags();
  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 errors on the momentum vector of the state
//=============================================================================
HepSymMatrix TrState::errMomentum() const
{
  if ( isFlagSet(TypeHasMomentumBits,TypeHasMomentumMask) ) {
    return posMomCovariance().sub(4,6);
  }
  else {
    //print out an error message ...
    return HepSymMatrix(3,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() const
{
  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);
};

//=============================================================================
// Check State type
//=============================================================================
bool TrState::type( unsigned value ) const
{
  if      ( value == TrState::HasMomentum)
    return isFlagSet( TypeHasMomentumBits, TypeHasMomentumMask );
  else if ( value == TrState::StraightLine)
    return isFlagSet( TypeStraightLineBits, TypeStraightLineMask );

  return false;
};

//=============================================================================
// Retrieve the location of the state
//=============================================================================
bool TrState::location( unsigned value ) const
{
  if      ( value == TrState::MostUpstream )
    return isFlagSet( LocationMostUpstreamMask, LocationMostUpstreamBits);
  else if ( value == TrState::FirstMeasurement )
    return isFlagSet( LocationFirstMeasurementMask, LocationFirstMeasurementBits);
  else if ( value == TrState::AtTT )
    return isFlagSet( LocationAtTTMask, LocationAtTTBits);
  else if ( value == TrState::AtT )
    return isFlagSet( LocationAtTMask, LocationAtTBits);
  else if ( value == TrState::BegRich1 )
    return isFlagSet( LocationBegRich1Mask, LocationBegRich1Bits);
  else if ( value == TrState::EndRich1 )
    return isFlagSet( LocationEndRich1Mask, LocationEndRich1Bits);
  else if ( value == TrState::BegRich2 )
    return isFlagSet( LocationBegRich2Mask, LocationBegRich2Bits);
  else if ( value == TrState::EndRich2 )
    return isFlagSet( LocationEndRich2Mask, LocationEndRich2Bits);
  else if ( value == TrState::Calo )
    return isFlagSet( LocationCaloMask, LocationCaloBits);
  else if ( value == TrState::Muon )
    return isFlagSet( LocationMuonMask, LocationMuonBits);

  return false;  
};

//=============================================================================
// 
//=============================================================================
bool TrState::isFlagSet( unsigned bits, unsigned mask )
{
  return (bool)((m_flags & mask) >> bits);
};

//=============================================================================
// 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 ( isFlagSet(TypeStraightLineBits,TypeStraightLineMask) ) {
    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;
};

//=============================================================================
// Update State type
//=============================================================================
void TrState::setType( unsigned value )
{
  if      ( value == TrState::HasMomentum )
    setFlag( true, TypeHasMomentumBits, TypeHasMomentumMask );
  else if ( value == TrState::StraightLine)
    setFlag( true, TypeStraightLineBits, TypeStraightLineMask );
};

//=============================================================================
// Update the location of the state
//=============================================================================
void TrState::setLocation( unsigned value )
{
  switch ( value )
  {
    case TrState::MostUpstream :
      setFlag( true, LocationMostUpstreamBits, LocationMostUpstreamMask );
      break;
    case TrState::FirstMeasurement :
      setFlag( true,  LocationFirstMeasurementBits, LocationFirstMeasurementMask );
      break;
    case TrState::AtTT :
      setFlag( true, LocationAtTTBits, LocationAtTTMask );
      break;
    case TrState::AtT :
      setFlag( true, LocationAtTBits, LocationAtTMask );
      break;
    case TrState::BegRich1 :
      setFlag( true, LocationBegRich1Bits, LocationBegRich1Mask );
      break;
    case TrState::EndRich1 :
      setFlag( true, LocationEndRich1Bits, LocationEndRich1Mask );
      break;
    case TrState::BegRich2 :
      setFlag( true, LocationBegRich2Bits, LocationBegRich2Mask );
      break;
    case TrState::EndRich2 :
      setFlag( true, LocationEndRich2Bits, LocationEndRich2Mask );
      break;
    case TrState::Calo :
      setFlag( true, LocationCaloBits, LocationCaloMask );
      break;
    case TrState::Muon :
      setFlag( true, LocationMuonBits, LocationMuonMask );
      break;
    default:
      ;
  }
};

//=============================================================================
// 
//=============================================================================
void TrState::setFlag( bool value, unsigned bits, unsigned mask )
{
  unsigned val  = (unsigned) value;
  m_flags &= ~mask;
  m_flags |= ((((unsigned)val) << bits) & mask);
};

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

---