RecMdcDedxHitCnv.cxx

Go to the documentation of this file.

#ifndef RecMdcDedxHitCnv_CXX
#define RecMdcDedxHitCnv_CXX 1
#include "EventModel/EventModel.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ObjectVector.h"
#include "Identifier/Identifier.h"
#include "MdcRecEvent/RecMdcDedxHit.h"
#include "ReconEvent/ReconEvent.h"
#include "TClonesArray.h"
 
#include "RootEventData/TRecMdcDedxHit.h" // standard root object
#include "RootEventData/TRecTrackEvent.h"
 
#include "RootCnvSvc/Rec/RecMdcDedxHitCnv.h"
#include "RootCnvSvc/Rec/RecTrackCnv.h"
#include "RootCnvSvc/RootAddress.h"
 
#include <vector>
 
using namespace std;
 
// Instantiation of a static factory class used by clients to create
// instances of this service
// static CnvFactory<RecMdcDedxCnv> s_factory;
// const ICnvFactory& RecMdcDedxCnvFactory = s_factory;
 
RecMdcDedxHitCnv::RecMdcDedxHitCnv( ISvcLocator* svc ) : RootEventBaseCnv( classID(), svc ) {
 
  // Here we associate this converter with the /Event path on the TDS.
  MsgStream log( msgSvc(), "RecMdcDedxHitCnv" );
  // log << MSG::DEBUG << "Constructor called for " << objType() << endmsg;
  // m_rootTreename ="Rec";
  m_rootBranchname = "m_recMdcDedxHitCol";
  // declareObject(EventModel::Recon::RecMdcDedxCol, objType(), m_rootTreename,
  // m_rootBranchname);
  m_adresses.push_back( &m_recMdcDedxHitCol );
  m_recMdcDedxHitCol = 0;
}
 
StatusCode RecMdcDedxHitCnv::TObjectToDataObject( DataObject*& refpObject ) {
  // creation of TDS object from root object
  MsgStream log( msgSvc(), "RecMdcDedxHitCnv" );
  log << MSG::DEBUG << "RecMdcDedxHitCnv::TObjectToDataObject" << endmsg;
  StatusCode sc = StatusCode::SUCCESS;
  // create the TDS location for the Dedx Collection
  RecMdcDedxHitCol* recMdcDedxHitCol = new RecMdcDedxHitCol;
  refpObject                         = recMdcDedxHitCol;
 
  //***************************register rec hit data in TDS****************************
  IDataProviderSvc* dataSvc = 0;
  sc = serviceLocator()->getService( "EventDataSvc", IDataProviderSvc::interfaceID(),
                                     (IInterface*&)dataSvc );
  if ( sc.isFailure() )
  {
    log << MSG::FATAL << "Could not get EventDataSvc in RecMdcDedxHitCnv" << endmsg;
    return sc;
  }
 
  // Retrieve Mdc Hit
  SmartDataPtr<RecMdcHitCol> mdcHitCol( dataSvc, EventModel::Recon::RecMdcHitCol );
  if ( !mdcHitCol ) { log << MSG::INFO << "Could not find RecMdcHitCol" << endmsg; }
 
  // Retrieve MdcKal Helix Segment
  SmartDataPtr<RecMdcKalHelixSegCol> mdcKalHelixSegCol(
      dataSvc, EventModel::Recon::RecMdcKalHelixSegCol );
  if ( !mdcKalHelixSegCol )
  { log << MSG::INFO << "Could not find RecMdcKalHelixSegCol" << endmsg; }
  //**********************************************************************
 
  // now convert
  if ( !m_recMdcDedxHitCol ) return sc;
  TIter           dedxIter( m_recMdcDedxHitCol );
  TRecMdcDedxHit* recMdcDedxHitRoot = 0;
  while ( ( recMdcDedxHitRoot = (TRecMdcDedxHit*)dedxIter.Next() ) )
  {
    int trackId = recMdcDedxHitRoot->trkId();
    // cout<<"trackId: "<<trackId<<endl;
    int flagLR = recMdcDedxHitRoot->flagLR();
    // cout<<"flagLR: "<<flagLR<<endl;
    long int mdcId( recMdcDedxHitRoot->mdcId() );
    // cout<<"mdcID: "<<mdcId<<endl;
    double pathlength = recMdcDedxHitRoot->pathLength();
    // cout<<"pathlength: " <<pathlength<<endl;
    double dedx = recMdcDedxHitRoot->getDedx();
    // cout<<"dedx: "<<dedx<<endl;
 
    log << MSG::DEBUG << "TObjectToDataObject: check Reconstrunction of dE/dx Hit root::"
        << " trackId: " << trackId << " flagLR: " << flagLR << " pathlength: " << pathlength
        << " dedx: " << dedx << endmsg;
    RecMdcDedxHit* recMdcDedxHit                       = new RecMdcDedxHit();
    m_common.m_rootRecMdcDedxHitMap[recMdcDedxHitRoot] = recMdcDedxHit;
    recMdcDedxHit->setTrkId( trackId );
    recMdcDedxHit->setFlagLR( flagLR );
    recMdcDedxHit->setMdcId( Identifier( mdcId ) );
    recMdcDedxHit->setPathLength( pathlength );
    recMdcDedxHit->setDedx( dedx );
    //   log << MSG::DEBUG<<"check Reconstrunction of dE/dx Hit root"<<" pathlength 2 is :
    //   "<<(*recdedxhit)->getPathLength()<<endmsg;
 
    int mdcHitId = recMdcDedxHitRoot->mdcHitId();
    // std::cout << __FILE__ << __LINE__ << " size: " << mdcHitCol->size() << "  id: " <<
    // mdcHitId << std::endl;
    if ( mdcHitId >= 0 )
    {
      recMdcDedxHit->setMdcHit(
          dynamic_cast<RecMdcHit*>( mdcHitCol->containedObject( mdcHitId ) ) );
    }
    int mdcKalHelixSegId = recMdcDedxHitRoot->mdcKalHelixSegId();
    // std::cout << __FILE__ << __LINE__ << " size: " << mdcKalHelixSegCol->size() << "  id: "
    // << mdcKalHelixSegId << std::endl;
    if ( mdcKalHelixSegId >= 0 )
    {
      recMdcDedxHit->setMdcKalHelixSeg( dynamic_cast<RecMdcKalHelixSeg*>(
          mdcKalHelixSegCol->containedObject( mdcKalHelixSegId ) ) );
    }
 
    recMdcDedxHitCol->push_back( recMdcDedxHit );
    // delete dedxTds;
    //  dedxTds = NULL;
  }
  // m_dedxCol->Delete();
  delete m_recMdcDedxHitCol;
  m_recMdcDedxHitCol = 0;
 
  return StatusCode::SUCCESS;
}
 
StatusCode RecMdcDedxHitCnv::DataObjectToTObject( DataObject* obj, RootAddress* rootaddr ) {
  MsgStream log( msgSvc(), "RecMdcDedxHitCnv" );
  log << MSG::DEBUG << "RecMdcDedxHitCnv::DataObjectToTObject" << endmsg;
  StatusCode sc = StatusCode::SUCCESS;
 
  RecMdcDedxHitCol* recMdcDedxHitCol = dynamic_cast<RecMdcDedxHitCol*>( obj );
  if ( !recMdcDedxHitCol )
  {
    log << MSG::ERROR << "Could not downcast to RecMdcDedxHitCol" << endmsg;
    return StatusCode::FAILURE;
  }
 
  DataObject* evt;
  m_eds->findObject( EventModel::Recon::Event, evt );
  if ( evt == NULL )
  {
    log << MSG::ERROR << "Could not get RecEvent in TDS " << endmsg;
    return StatusCode::FAILURE;
  }
  ReconEvent* devtTds = dynamic_cast<ReconEvent*>( evt );
  if ( !devtTds )
  { log << MSG::ERROR << "RecMdcDedxHitCnv:Could not downcast to TDS RecEvent" << endmsg; }
  IOpaqueAddress* addr;
  m_cnvSvc->getRecTrackCnv()->createRep( evt, addr );
  TRecTrackEvent*  recEvt             = m_cnvSvc->getRecTrackCnv()->getWriteObject();
  const TObjArray* m_recMdcDedxHitCol = recEvt->getRecMdcDedxHitCol();
  if ( !m_recMdcDedxHitCol ) return sc;
  recEvt->clearRecMdcDedxHitCol(); // necessary in case there is I/O at the same time since
                                   // array is static
 
  //******************** get according mdcHIt and mdcKalHelixSeg of MdcDedxHit ****************
 
  RecMdcHitCol::iterator         recMdcHitColbegin, recMdcHitColend;
  RecMdcKalHelixSegCol::iterator recMdcKalHelixSegColbegin, recMdcKalHelixSegColend;
 
  IDataProviderSvc* dataSvc = 0;
  sc = serviceLocator()->getService( "EventDataSvc", IDataProviderSvc::interfaceID(),
                                     (IInterface*&)dataSvc );
  if ( sc.isFailure() )
  {
    log << MSG::FATAL << "Could not get EventDataSvc in RecMdcDedxHitCnv" << endmsg;
    return sc;
  }
 
  // Retrieve Mdc Hit
  SmartDataPtr<RecMdcHitCol> recMdcHitCol( dataSvc, EventModel::Recon::RecMdcHitCol );
  if ( !recMdcHitCol )
  {
    log << MSG::ERROR << "Could not downcast to RecMdcHitCol" << endmsg;
    return StatusCode::FAILURE;
  }
  else
  {
    recMdcHitColbegin = recMdcHitCol->begin();
    recMdcHitColend   = recMdcHitCol->end();
  }
 
  SmartDataPtr<RecMdcKalHelixSegCol> recMdcKalHelixSegCol(
      dataSvc, EventModel::Recon::RecMdcKalHelixSegCol );
  if ( !recMdcKalHelixSegCol )
  {
    log << MSG::ERROR << "Could not downcast to RecMdcKalHelixSegCol" << endmsg;
    return StatusCode::FAILURE;
  }
  else
  {
    recMdcKalHelixSegColbegin = recMdcKalHelixSegCol->begin();
    recMdcKalHelixSegColend   = recMdcKalHelixSegCol->end();
  }
  //******************************************************************************
 
  RecMdcDedxHitCol::const_iterator recMdcDedxHit;
  for ( recMdcDedxHit = recMdcDedxHitCol->begin(); recMdcDedxHit != recMdcDedxHitCol->end();
        recMdcDedxHit++ )
  {
    int    trackId    = ( *recMdcDedxHit )->getTrkId();
    int    flagLR     = ( *recMdcDedxHit )->getFlagLR();
    UInt_t mdcId      = ( *recMdcDedxHit )->getMdcId().get_value();
    double pathlength = ( *recMdcDedxHit )->getPathLength();
    double dedx       = ( *recMdcDedxHit )->getDedx();
 
    log << MSG::DEBUG << "DataObjectToTObject: check Reconstrunction of dE/dx Hit::"
        << " trackId: " << trackId << " flagLR: " << flagLR << " pathlength: " << pathlength
        << " dedx: " << dedx << endmsg;
    TRecMdcDedxHit* recMdcDedxHitRoot = new TRecMdcDedxHit();
    // m_common.m_recMdcDedxHitMap[(*recMdcDedxHit)] = recMdcDedxHitRoot;
    recMdcDedxHitRoot->setTrkId( trackId );
    recMdcDedxHitRoot->setFlagLR( flagLR );
    recMdcDedxHitRoot->setMdcId( mdcId );
    recMdcDedxHitRoot->setPathLength( pathlength );
    recMdcDedxHitRoot->setDedx( dedx );
 
    // int trackId1 = recMdcDedxHitRoot->trkId();
    // cout<<"trackId: "<<trackId1<<endl;
    // int flagLR1 = recMdcDedxHitRoot->flagLR();
    // cout<<"flagLR: "<<flagLR1<<endl;
    // long int mdcId1(recMdcDedxHitRoot->mdcId());
    // cout<<"mdcID: "<<mdcId1<<endl;
    // double pathlength1 =  recMdcDedxHitRoot->pathLength();
    // cout<<"pathlength: " <<pathlength1<<endl;
    // double dedx1 = recMdcDedxHitRoot->getDedx();
    // cout<<"dedx: "<<dedx1<<endl;
 
    if ( ( *recMdcDedxHit )->isMdcHitValid() )
    {
      RecMdcHitCol::iterator it =
          find( recMdcHitColbegin, recMdcHitColend, ( *recMdcDedxHit )->getMdcHit() );
      recMdcDedxHitRoot->setMdcHitId( it - recMdcHitColbegin );
    }
    else { recMdcDedxHitRoot->setMdcHitId( -1 ); }
 
    if ( ( *recMdcDedxHit )->isMdcKalHelixSegValid() )
    {
      RecMdcKalHelixSegCol::iterator it =
          find( recMdcKalHelixSegColbegin, recMdcKalHelixSegColend,
                ( *recMdcDedxHit )->getMdcKalHelixSeg() );
      recMdcDedxHitRoot->setMdcKalHelixSegId( it - recMdcKalHelixSegColbegin );
    }
    else { recMdcDedxHitRoot->setMdcKalHelixSegId( -1 ); }
 
    // log << MSG::DEBUG<<"check Reconstrunction of dE/dx Hit root"<<" pathlength 2 is :
    // "<<(*recMdcDedxHit)->getPathLength()<<endmsg;
    recEvt->addRecMdcDedxHit( recMdcDedxHitRoot );
  }
 
  return StatusCode::SUCCESS;
}
 
#endif