TrFitTrack2TrackCnv.cpp

Go to the documentation of this file.

// Include files 
// -------------
// from Gaudi
#include "GaudiKernel/AlgFactory.h"
#include "GaudiKernel/IDataProviderSvc.h"

// from TrFitEvent
#include "Event/TrFitTrack.h"
#include "Event/ITClusterOnTrack.h"
#include "Event/OTClusterOnTrack.h"
#include "Event/VeloRClusterOnTrack.h"
#include "Event/VeloPhiClusterOnTrack.h"

// from TrackEvent
#include "Event/Track.h"
#include "Event/TrackKeys.h"
#include "Event/Measurement.h"

// from Kernel
#include "Kernel/LHCbID.h"

// local
#include "TrFitTrack2TrackCnv.h"

//-----------------------------------------------------------------------------
// Implementation file for class : TrFitTrack2TrackCnv
//
// 13/12/2004 : Eduardo Rodrigues
//-----------------------------------------------------------------------------

// Declaration of the Algorithm Factory
static const AlgFactory<TrFitTrack2TrackCnv>           Factory ;
const        IAlgFactory& TrFitTrack2TrackCnvFactory = Factory ; 

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
TrFitTrack2TrackCnv::TrFitTrack2TrackCnv( const std::string& name,
                                          ISvcLocator* pSvcLocator)
  : GaudiAlgorithm    ( name , pSvcLocator )
  , m_inputTrackName  ( TrFitTrackLocation::Default )
  , m_outputTrackName ( TrackLocation::Default )
  , m_measProvider(0)
{
  declareProperty( "InputTracks" ,     m_inputTrackName  );
  declareProperty( "OutputTracks",     m_outputTrackName );
  declareProperty( "ConvertAllStates", m_convertAllStates = true );
  declareProperty( "LoadMeasurements", m_createMeasurements = true );
}

//=============================================================================
// Destructor
//=============================================================================
TrFitTrack2TrackCnv::~TrFitTrack2TrackCnv() {}; 

//=============================================================================
// Initialisation. Check parameters
//=============================================================================
StatusCode TrFitTrack2TrackCnv::initialize() {

  // Force the initialization of the base class
  //-------------------------------------------
  StatusCode sc = GaudiAlgorithm::initialize() ;
  if ( sc.isFailure() )
    return Error( "Base class \"GaudiAlgorithm\" was not initialized properly!" );

  debug() << "==> Initialize" << endreq;

  m_measProvider = tool<IMeasurementProvider>( "MeasurementProvider" );
  if ( 0 == m_measProvider )
    return Error( "Unable to retrieve the \"MeasurementProvider\" tool!" );
  else
    debug() << "Found the \"MeasurementProvider\" tool" << endreq;

  return StatusCode::SUCCESS;
};

//=============================================================================
// Main execution
//=============================================================================
StatusCode TrFitTrack2TrackCnv::execute() {

  debug() << "==> Execute" << endreq;

  // retrieve the TrFitTracks container
  TrFitTracks* inTra = get<TrFitTracks>( m_inputTrackName );
  debug() << "- # TrFitTracks = " << inTra -> size() << endreq;

  // create and register the Tracks container
  Tracks* outTra = new Tracks();
  StatusCode sc = eventSvc() -> registerObject( m_outputTrackName, outTra );
  if( sc.isFailure() ) {
    delete outTra;
    error() << "Unable to register the output container "
            << m_outputTrackName << ". Status is " << sc << endreq;
    return sc ;
  }
  else {
    debug() << "Output container " << m_outputTrackName
            << " registered" << endreq;
  }

  TrStateP*                               trStaP;
  TrStateL*                               trStaL;
  TrState*                                trSta;
  OTClusterOnTrack*                       myOt;
  ITClusterOnTrack*                       myIt;
  VeloRClusterOnTrack*                    myRV;
  VeloPhiClusterOnTrack*                  myPV;
  TrFitTracks::const_iterator             itF;
  TrStates::const_iterator                itS;
  TrTrack::TrMeasurements::const_iterator itM;

  Track*              trSto;
  LHCbID              myID;
  std::vector<LHCbID> myIDs;

  // need to load XxxClusters and OTTimes
  if ( m_createMeasurements ) m_measProvider -> load();

  debug() << "Processing TrFitTracks ... " << endreq;

  for ( itF = inTra->begin() ; inTra->end() != itF ; ++itF ) {
    // create the Track
    trSto = new Track();
    outTra -> insert( trSto, (*itF)->key() );   // Same key, for associators

    // debugging TrFitTrack ...
    debug()
      << "- TrFitTrack with key # " << (*itF) -> key() << endreq
      << "  * # states       = " << (*itF) -> nStates() << endreq
      << "  * # measurements = " << (*itF) -> nMeasurements() << endreq
      << "    - # IT         = " << (*itF) -> nMeasurements( TrMeasurement::kITClusterOnTrack ) << endreq
      << "    - # OT         = " << (*itF) -> nMeasurements( TrMeasurement::kOTClusterOnTrack ) << endreq
      << "    - # VeloR      = " << (*itF) -> nMeasurements( TrMeasurement::kVeloRClusterOnTrack ) << endreq
      << "    - # VeloPhi    = " << (*itF) -> nMeasurements( TrMeasurement::kVeloPhiClusterOnTrack ) << endreq
      << "  * charge         = " << (*itF) -> charge() << endreq
      << "  * error flag     = " << (*itF) -> errorFlag() << endreq
      << "  * is Unique      = " << (*itF) -> unique() << endreq
      << "  * is Long        = " << (*itF) -> isLong() << endreq
      << "  * is Upstream    = " << (*itF) -> isUpstream() << endreq
      << "  * is Downstream  = " << (*itF) -> isDownstream() << endreq
      << "  * is Velotrack   = " << (*itF) -> isVelotrack() << endreq
      << "  * is Backward    = " << (*itF) -> isBackward() << endreq
      << "  * is Ttrack      = " << (*itF) -> isTtrack() << endreq
      << "  * velo           = " << (*itF) -> velo() << endreq
      << "  * seed           = " << (*itF) -> seed() << endreq
      << "  * match          = " << (*itF) -> match() << endreq
      << "  * forward        = " << (*itF) -> forward() << endreq
      << "  * follow         = " << (*itF) -> follow() << endreq
      << "  * veloTT         = " << (*itF) -> veloTT() << endreq
      << "  * veloBack       = " << (*itF) -> veloBack() << endreq
      << "  * ksTrack        = " << (*itF) -> ksTrack() << endreq;

    // set the properties of Track
    // (the charge is calculated from Q/P of the first state)
    if ( (bool) (*itF)->errorFlag() )  trSto -> setFlag( TrackKeys::Invalid, true );
    if ( (bool) (*itF)->unique() )     trSto -> setFlag( TrackKeys::Unique, true );

    if      ( (*itF)->isLong() )       trSto -> setType( TrackKeys::Long );
    else if ( (*itF)->isUpstream() )   trSto -> setType( TrackKeys::Upstream );
    else if ( (*itF)->isDownstream() ) trSto -> setType( TrackKeys::Downstream );
    else if ( (*itF)->isVelotrack() )  trSto -> setType( TrackKeys::Velo );
    else if ( (*itF)->isBackward() ) { trSto -> setType( TrackKeys::Velo );
                                       trSto -> setFlag( TrackKeys::Backward, true );
                                     }
    
    else if ( (*itF)->isTtrack() )     trSto -> setType( TrackKeys::Ttrack );

    if ( (*itF)->ksTrack() ) trSto -> setHistory( TrackKeys::TrKshort );

    // debugging Track ...
    debug()
      << "  -> Track stored with key # " << trSto -> key() << endreq
      << "    * is Invalid    = "
      << trSto -> checkFlag( TrackKeys::Invalid ) << endreq
      << "    * is Unique     = "
      << trSto -> checkFlag( TrackKeys::Unique ) << endreq
      << "    * is Long       = "
      << trSto -> checkType( TrackKeys::Long ) << endreq
      << "    * is Upstream   = "
      << trSto -> checkType( TrackKeys::Upstream ) << endreq
      << "    * is Downstream = "
      << trSto -> checkType( TrackKeys::Downstream ) << endreq
      << "    * is Velo       = "
      << trSto -> checkType( TrackKeys::Velo ) << endreq
      << "    * is Backward   = "
      << trSto -> checkFlag( TrackKeys::Backward ) << endreq
      << "    * is Ttrack     = "
      << trSto -> checkType( TrackKeys::Ttrack ) << endreq;

    // loop over the states in TrFitTrack
    if ( m_convertAllStates ) {
      unsigned ist = 0;
      for ( itS = (*itF)->beginS() ; (*itF)->endS() != itS; itS++ ) {
        trSta = (*itS)->clone();
        trStaP = dynamic_cast<TrStateP*>(trSta);
        trStaL = dynamic_cast<TrStateL*>(trSta);
        if ( 0 != trStaP ) {
          verbose() << "  * TrStateP # " << ist++ << endreq
                    << "    - (x,y,z)     = (" << trStaP -> x() << ", "
                    << trStaP -> y() << ", "
                    << trStaP -> z() << ")" << endreq
                    << "    - tx, ty, Q/P = " << trStaP -> tx() << ", "
                    << trStaP -> ty() << ", "
                    << trStaP -> qDivP() << endreq;
          State pstate = State();
          pstate.setState( trStaP->x(), trStaP->y(), trStaP->z(),
                           trStaP->tx(), trStaP->ty(), trStaP->qDivP() );
          pstate.setCovariance( trStaP->stateCov() );
          trSto -> addToStates( pstate );
          verbose() << "  -> stored TrStateP at z = " << trStaP -> z()
                    << " as state # " << ist << endreq;
        }
        else if ( 0 != trStaL ) {
          verbose() << "  * TrStateL # " << ist++ << endreq
                    << "    - (x,y,z) = (" << trStaL -> x() << ", "
                    << trStaL -> y() << ", "
                    << trStaL -> z() << ")" << endreq
                    << "    - tx, ty  = " << trStaL -> tx() << ", "
                    << trStaL -> ty() << endreq;
          State lstate = State();
          lstate.setState( trStaL->x(), trStaL->y(), trStaL->z(),
                           trStaL->tx(), trStaL->ty(), 0. );
          lstate.setCovariance( trStaL->stateCov() );
          trSto -> addToStates( lstate );
          verbose() << "  -> stored TrStateL at z = " << trStaL -> z()
                    << " as state # " << ist << endreq;
        }
        else {
          verbose() << "  * unknown state at z =" << trSta -> z() << "!" << endreq;
          delete trSta;
        }
      }
    }
    else {
      // store the state closest to the nominal IP as the "first state"
      trSta = (*itF) -> closestState(0.);
      trStaP = dynamic_cast<TrStateP*>(trSta);
      trStaL = dynamic_cast<TrStateL*>(trSta);
      if ( 0 != trStaP ) {
        //State& pstate = trSto -> firstState();
        State pstate = State();
        pstate.setState( trStaP->x(), trStaP->y(), trStaP->z(),
                         trStaP->tx(), trStaP->ty(), trStaP->qDivP() );
        pstate.setCovariance( trStaP->stateCov() );
        trSto -> addToStates( pstate );
        verbose() << "  -> stored TrStateP at z = " << trStaP -> z()
                << " as first state" << endreq;
      }
      else if ( 0 != trStaL ) {
        verbose() << "  -> no first state stored!" << endreq;
      }
      debug() << "  -> track charge = " << trSto -> charge() << endreq;
    }
    debug() << "  -> # States stored = " << trSto -> states().size() << endreq;
    
    // loop over the measurements in TrFitTrack
    myIDs.clear();
    for ( itM = (*itF)->beginM() ; (*itF)->endM() != itM ; itM++ ) {
      if ( TrMeasurement::kOTClusterOnTrack == (*itM)->measType()) {
        // old event model stored the following OT measurement properties:
        //   cluster       <- OTTime
        //   ambiguity     <- from pattern recognition algorithms
        //   z             <- calculated from the detector element,
        //                    OTTime and drift ambiguity
        //   residual      <- from track fit
        //   errorResidual <- from track fit
        // -> only needs to be stored: OTTime and drift ambiguity
        myOt = dynamic_cast<OTClusterOnTrack*>(*itM);
        OTTime* otTime = myOt -> time();
        myID = LHCbID( otTime -> channel() );
        int amb = myOt -> ambiguity();
        // spareBits: 11 / 10 for ambiguity = +1 / -1
        if ( amb != 0 ) {
          ( amb < 0 ) ? myID.setSpareBits( 2 ) : myID.setSpareBits( 3 );
        }
        else {
          myID.setSpareBits( 0 );
        }
        myIDs.push_back( myID );
        verbose() << "  * OTCluster at z = " << myOt -> z()
                  << " , channelID = " << otTime -> channel().channelID()
                  << " , ambiguity = " << amb << endreq
                  << "  -> stored as LHCbID = " << myID.lhcbID()
                  << "  (detectorType / spareBits = "
                  << myID.detectorType() << " / "
                  << myID.spareBits() << ")" << endreq;
        if ( m_createMeasurements ) {
          Measurement& meas = m_measProvider -> measurement( myID, amb);
          trSto -> addToMeasurements(meas);          
        }
      }
      else if ( TrMeasurement::kITClusterOnTrack == (*itM)->measType() ) {
        // old event model stored the following IT measurement properties:
        //   cluster       <- ITCluster
        //   z             <- calculated from the detector element
        //                    and the ITCluster
        //   residual      <- from track fit
        //   errorResidual <- from track fit
        // -> only needs to be stored: ITCluster
        myIt = dynamic_cast<ITClusterOnTrack*>(*itM);
        ITCluster* itClu = myIt -> cluster();
        myID = LHCbID( itClu -> channelID() );
        myIDs.push_back( myID );
        verbose() << "  * ITCluster at z = " << myIt -> z()
                  << " , channelID = "
                  << itClu -> channelID().channelID() << endreq
                  << "  -> stored as LHCbID = " << myID.lhcbID()
                  << "  (detectorType / spareBits = "
                  << myID.detectorType() << " / "
                  << myID.spareBits() << ")" << endreq;
        if ( m_createMeasurements ) {
          Measurement& meas = m_measProvider -> measurement( myID );
          trSto -> addToMeasurements(meas);          
        }
      }
      else if ( TrMeasurement::kVeloRClusterOnTrack == (*itM)->measType() ) {
        // old event model stored the following Velo-R measurement properties:
        //   cluster       <- VeloCluster
        //   z             <- calculated from the detector element
        //                    and the VeloCluster
        //   residual      <- from track fit
        //   errorResidual <- from track fit
        // -> only needs to be stored: VeloCluster
        myRV = dynamic_cast<VeloRClusterOnTrack*>(*itM);
        VeloCluster* veloClu = myRV -> cluster();
        int sensor = veloClu -> sensor();
        std::vector< std::pair<long,double> > sign = veloClu->stripSignals();
        int strip = (*sign.begin()).first;
        VeloChannelID channel(sensor,strip);
        myID = LHCbID( channel );
        myIDs.push_back( myID );
        verbose() << "  * R Velo Cluster at z = " << myRV -> z()
                  << " , VeloChannelID = " << channel << endreq
                  << " , key = " << veloClu -> key() << endreq
                  << "  -> stored as LHCbID = " << myID.lhcbID()
                  << "  (detectorType / spareBits = "
                  << myID.detectorType() << " / "
                  << myID.spareBits() << ")" << endreq;
        if ( m_createMeasurements ) {
          Measurement& meas = m_measProvider -> measurement( myID );
          trSto -> addToMeasurements(meas);          
        }
      }
      else if ( TrMeasurement::kVeloPhiClusterOnTrack == (*itM)->measType() ) {
        // old event model stored the following Velo-Phi measurement properties:
        //   cluster       <- VeloCluster
        //   z             <- calculated from the det. elem. and VeloCluster
        //   residual      <- from track fit
        //   errorResidual <- from track fit
        // -> only needs to be stored: VeloCluster
        myPV = dynamic_cast<VeloPhiClusterOnTrack*>(*itM);
        VeloCluster* veloClu = myPV -> cluster();
        int sensor = veloClu -> sensor();
        std::vector< std::pair<long,double> > sign = veloClu->stripSignals();
        int strip = (*sign.begin()).first;
        VeloChannelID channel(sensor,strip);
        myID = LHCbID( channel );
        myIDs.push_back( myID );
        verbose() << "  * Phi Velo Cluster at z = " << myPV -> z()
                  << " , VeloChannelID = " << channel << endreq
                  << " , key = " << veloClu -> key() << endreq
                  << "  -> stored as LHCbID = " << myID.lhcbID()
                  << "  (detectorType / spareBits = "
                  << myID.detectorType() << " / "
                  << myID.spareBits() << ")" << endreq;
        if ( m_createMeasurements ) {
          Measurement& meas = m_measProvider -> measurement( myID );
          trSto -> addToMeasurements(meas);          
        }
      }
    }
    // store all the measurements as LHCbIDs
    trSto -> setLhcbIDs( myIDs );
    debug() << "  -> # LHCbIDs stored = " << myIDs.size() << endreq;
    // create also the measurements if requested
    if ( m_createMeasurements ) {
      //sc = m_measProvider -> load( *trSto );
      trSto -> setStatus( TrackKeys::PatRecMeas );
      debug() << "  -> # measurements created = "
              << trSto -> measurements().size() << endreq;
    }
  } // end of loop over TrFitTracks

  // summary of stored information
  debug() << "-> stored " << outTra -> size() << " Tracks " << endreq;

  return StatusCode::SUCCESS;
};

//=============================================================================
//  Finalize
//=============================================================================
StatusCode TrFitTrack2TrackCnv::finalize() {

  debug() << "==> Finalize" << endreq;

  // Force the finalization of the base class
  //-----------------------------------------
  return GaudiAlgorithm::finalize();
}

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

---