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 TrEvent
#include "Event/Track.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 )
{
  declareProperty( "InputTracks" , m_inputTrackName  );
  declareProperty( "OutputTracks", m_outputTrackName );
}

//=============================================================================
// 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;

  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;

  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 physics state)
    if ( (bool) (!(*itF)->errorFlag()) ) trSto -> setFlag( Track::Valid );
    if ( (bool) (*itF)->unique() )       trSto -> setFlag( Track::Unique );

    if      ( (*itF)->isLong() )       trSto -> setType( Track::Long );
    else if ( (*itF)->isUpstream() )   trSto -> setType( Track::Upstream );
    else if ( (*itF)->isDownstream() ) trSto -> setType( Track::Downstream );
    else if ( (*itF)->isVelotrack() )  trSto -> setType( Track::Velo );
    else if ( (*itF)->isBackward() )   trSto -> setType( Track::Backward );
    else if ( (*itF)->isTtrack() )     trSto -> setType( Track::Ttrack );

    if ( (*itF)->ksTrack() ) trSto -> setProducedByAlgo( Track::TrKshort );

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

    // print out the states in TrFitTrack
    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 ) {
        debug() << "  * TrStateP # " << ist++ << endreq
                << "    - (x,y,z)     = (" << trStaP -> x() << ", "
                                           << trStaP -> y() << ", "
                                           << trStaP -> z() << ")" << endreq
                << "    - tx, ty, Q/P = " << trStaP -> tx() << ", "
                                          << trStaP -> ty() << ", "
                                          << trStaP -> qDivP() << endreq;
      }
      else if ( 0 != trStaL ) {
        debug() << "  * TrStateL # " << ist++ << endreq
                << "    - (x,y,z) = (" << trStaL -> x() << ", "
                                       << trStaL -> y() << ", "
                                       << trStaL -> z() << ")" << endreq
                << "    - tx, ty  = " << trStaL -> tx() << ", "
                                      << trStaL -> ty() << endreq;
      }
      else {
        verbose() << "  * unknown state at z =" << trSta -> z() << "!" << endreq;
        delete trSta;
      }
    }

    // store the state closest to the nominal IP as the "physics state"
    trSta = (*itF) -> closestState(0.);
    trStaP = dynamic_cast<TrStateP*>(trSta);
    trStaL = dynamic_cast<TrStateL*>(trSta);
    if ( 0 != trStaP ) {
      State& pstate = trSto->physicsState();
      pstate.setState( trStaP->x(), trStaP->y(), trStaP->z(),
                       trStaP->tx(), trStaP->ty(), trStaP->qDivP() );
      pstate.setCovariance( trStaP->stateCov() );
      debug() << "  -> stored TrStateP at z = " << trStaP -> z()
              << " as physics state" << endreq;
    }
    else if ( 0 != trStaL ) {
      verbose() << "  -> no physics state stored!" << endreq;
    }
    debug() << "  -> track charge = " << trSto -> charge() << endreq;

    // print out 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 );
        debug() << "  * OTCluster at z = " << myOt -> z()
                << " , channelID = " << otTime -> channel().channelID()
                << " , ambiguity = " << amb << endreq
                << "  -> stored as LHCbID = " << myID.lhcbID()
                << "  (detectorType / spareBits = "
                << myID.detectorType() << " / "
                << myID.spareBits() << ")" << endreq;
      }
      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 );
        debug() << "  * ITCluster at z = " << myIt -> z()
                << " , channelID = "
                << itClu -> channelID().channelID() << endreq
                << "  -> stored as LHCbID = " << myID.lhcbID()
                << "  (detectorType / spareBits = "
                << myID.detectorType() << " / "
                << myID.spareBits() << ")" << endreq;
      }
      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();
              debug() << "  -> VeloChannelID of type "
                << veloClu->channelID(0).type() << endreq;
        myID = LHCbID( veloClu -> channelID( 0 ) );
        myIDs.push_back( myID );
        debug() << "  * R Velo Cluster at z = " << myRV -> z()
                << " , channelID = "
                << veloClu -> channelID(0).channelID() << endreq
                << "  -> stored as LHCbID = " << myID.lhcbID()
                << "  (detectorType / spareBits = "
                << myID.detectorType() << " / "
                << myID.spareBits() << ")" << endreq;
      }
      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();
              myID = LHCbID( veloClu -> channelID(0) );
              debug() << "  -> VeloChannelID of type "
                << veloClu->channelID(0).type() << endreq;
        myIDs.push_back( myID );
        debug() << "  * Phi Velo Cluster at z = " << myPV -> z()
                << " , channelID = "
                << veloClu -> channelID(0).channelID() << endreq
                << "  -> stored as LHCbID = " << myID.lhcbID()
                << "  (detectorType / spareBits = "
                << myID.detectorType() << " / "
                << myID.spareBits() << ")" << endreq;
      }
    }
    // store all the measurements as LHCbIDs
    trSto -> setLhcbIDs( myIDs );
    debug() << "  -> # LHCbIDs stored = " << myIDs.size() << endreq;
  }
  // 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();
}

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

---