CalibRootCnvSvc.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/CalibSvc/CalibROOTCnv/src/CalibRootCnvSvc.cxx,v 1.29
// 2022/03/04 03:49:16 maqm Exp $
 
#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IConverter.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IDetDataSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
 
#include "CalibData/CalibBase.h"
#include "CalibData/CalibBase1.h"
#include "CalibDataSvc/IInstrumentName.h"
 
#include "CalibRootCnvSvc.h"
#include "cnv/RootCalBaseCnv.h"
#include "cnv/RootCorrectedETSCnv.h"
#include "cnv/RootDedxCalibDataCnv.h"
#include "cnv/RootDedxSimDataCnv.h"
#include "cnv/RootEmcCalibDataCnv.h"
#include "cnv/RootEsTimeCalibDataCnv.h"
#include "cnv/RootEstTofCalibDataCnv.h"
#include "cnv/RootInjSigIntervalCnv.h"
#include "cnv/RootInjSigTimeCnv.h"
#include "cnv/RootMdcCalibDataCnv.h"
#include "cnv/RootMucCalibDataCnv.h"
#include "cnv/RootOffEvtFilterCnv.h"
#include "cnv/RootTofCalibDataCnv.h"
#include "cnv/RootTofQElecDataCnv.h"
#include "cnv/RootTofSimDataCnv.h"
 
// Make instances only via static factory class
// static SvcFactory<CalibRootCnvSvc> calibRootCnvSvc_factory;
// const ISvcFactory& CalibRootCnvSvcFactory = calibRootCnvSvc_factory;
DECLARE_COMPONENT( CalibRootCnvSvc )
CalibRootCnvSvc::CalibRootCnvSvc( const std::string& name, ISvcLocator* svc )
    : ConversionSvc( name, svc, CALIBROOT_StorageType ), m_detPersSvc( 0 ), m_detDataSvc( 0 ) {
  // huangb add
  declareProperty( "Mdcrootfile", m_rootfile[0] = std::string( "no rootfile" ) );
  declareProperty( "Tofrootfile", m_rootfile[1] = std::string( "no rootfile" ) );
  declareProperty( "Dedxrootfile", m_rootfile[2] = std::string( "no rootfile" ) );
  declareProperty( "Emcrootfile", m_rootfile[3] = std::string( "no rootfile" ) );
  declareProperty( "Mucrootfile", m_rootfile[4] = std::string( "no rootfile" ) );
  declareProperty( "EsTimerootfile", m_rootfile[5] = std::string( "no rootfile" ) );
  declareProperty( "EstTofrootfile", m_rootfile[6] = std::string( "no rootfile" ) );
  declareProperty( "TofQElecrootfile", m_rootfile[7] = std::string( "no rootfile" ) );
  declareProperty( "TofSimrootfile", m_rootfile[8] = std::string( "no rootfile" ) );
  declareProperty( "DedxSimrootfile", m_rootfile[9] = std::string( "no rootfile" ) );
  // Top_up Qiumei Ma
  declareProperty( "InjSigIntervalrootfile", m_rootfile[10] = std::string( "no rootfile" ) );
  declareProperty( "InjSigTimerootfile", m_rootfile[11] = std::string( "no rootfile" ) );
  declareProperty( "OffEvtFilterrootfile", m_rootfile[12] = std::string( "no rootfile" ) );
  declareProperty( "CorrectedETSrootfile", m_rootfile[13] = std::string( "no rootfile" ) );
  // Some day might have a property to declare having to do with path to
  // xml files.
}
 
/*StatusCode CalibRootCnvSvc::queryInterface(const InterfaceID& riid,
    void** ppvInterface) {
  // Uncomment if choose to derive from abstract root conv. interface
  if (IID_ICalibRootSvc.versionMatch(riid))  {
    *ppvInterface = (ICalibRootSvc*)this;
  }
  else {
    // Interface is not directly availible: try out a base class
    return ConversionSvc::queryInterface(riid, ppvInterface);
    //  }
  addRef();
}
return StatusCode::SUCCESS;
}
*/
 
StatusCode CalibRootCnvSvc::initialize() {
  StatusCode sc = ConversionSvc::initialize();
 
  MsgStream log( msgSvc(), "CalibRootCnvSvc" );
 
  if ( !sc.isSuccess() ) return sc;
 
  // Locate the Calib Data Service.  Since it inherits from DataSvc
  // it has to implement IDataProviderSvc
  m_detDataSvc = 0;
  /*sc = serviceLocator()->getService
    ("CalibDataSvc",  IID_IDataProviderSvc,(IInterface*&) m_detDataSvc);*/
  sc = serviceLocator()->getService( "CalibDataSvc", IDataProviderSvc::interfaceID(),
                                     (IInterface*&)m_detDataSvc );
  if ( !sc.isSuccess() )
  {
    log << MSG::ERROR << "Could not locate CalibDataSvc" << endmsg;
    return sc;
  }
 
  /*  IInstrumentName* iInstrumentName;
      sc = m_detDataSvc->queryInterface(IID_IInstrumentName,
      (void**) &iInstrumentName);
      */
  // Set the CalibDataSvc as data provider service
  sc = setDataProvider( m_detDataSvc );
  if ( !sc.isSuccess() )
  {
    log << MSG::ERROR << "Could not set data provider" << endmsg;
    return sc;
  }
  // huangb add
  // sc = setProperties();
 
  // Locate IConversionSvc interface of the DetectorPersistencySvc
  sc = serviceLocator()->service( "DetectorPersistencySvc", m_detPersSvc, true );
  if ( !sc.isSuccess() )
  {
    log << MSG::ERROR << "Cannot locate IConversionSvc interface of DetectorPersistencySvc"
        << endmsg;
    return sc;
  }
  else
  {
    log << MSG::DEBUG << "Retrieved IConversionSvc interface of DetectorPersistencySvc"
        << endmsg;
  }
 
  // Query the IAddressCreator interface of the detector persistency service
  IAddressCreator* iAddrCreator;
  /*  sc = m_detPersSvc->queryInterface(IID_IAddressCreator,
 
      (void**) &iAddrCreator);*/
 
  sc = m_detPersSvc->queryInterface( IAddressCreator::interfaceID(), (void**)&iAddrCreator );
  if ( !sc.isSuccess() )
  {
    log << MSG::ERROR << "Cannot query IAddressCreator interface of DetectorPersistencySvc"
        << endmsg;
    return sc;
  }
  else
  {
    log << MSG::DEBUG << "Retrieved IAddressCreator interface of DetectorPersistencySvc"
        << endmsg;
  }
  log << MSG::DEBUG << "Set it as the address creator of the CalibRootCnvSvc" << endmsg;
  sc = setAddressCreator( iAddrCreator );
  if ( !sc.isSuccess() )
  {
    log << MSG::ERROR << "Cannot set the address creator" << endmsg;
    return sc;
  }
 
  // set properties if there are any??
 
  return sc;
}
 
StatusCode CalibRootCnvSvc::finalize() {
  // If anything was allocated, get rid of it.  So far, nothing was.
 
  return ConversionSvc::finalize();
}
 
StatusCode CalibRootCnvSvc::createAddress( long svc_type, const CLID& clid,
                                           const std::string* par, const unsigned long* ip,
                                           IOpaqueAddress*& refpAddress ) {
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "here is the createAddress in the CalibRootCnvSvc" << endmsg;
  if ( svc_type != CALIBROOT_StorageType )
  {
    log << MSG::ERROR << "bad storage type" << (int)svc_type << endmsg;
    return StatusCode::FAILURE;
  }
  // std::cout<<"clid=="<<clid<<std::endl;
  std::string dataIdent;
  std::string fullpath;
  int         index = -99;
  if ( clid == 6412 ) return StatusCode::SUCCESS;
  if ( clid == CLID_Calib_MdcCal ) { index = 0; }
  else if ( clid == CLID_Calib_TofCal ) { index = 1; }
  else if ( clid == CLID_Calib_DedxCal ) { index = 2; }
  else if ( clid == CLID_Calib_EmcCal ) { index = 3; }
  else if ( clid == CLID_Calib_MucCal ) { index = 4; }
  else if ( clid == CLID_Calib_EsTimeCal ) { index = 5; }
  else if ( clid == CLID_Calib_EstTofCal ) { index = 6; }
  else if ( clid == CLID_TofQ_Elec ) { index = 7; }
  else if ( clid == CLID_Calib_TofSim ) { index = 8; }
  else if ( clid == CLID_Dedx_Sim ) { index = 9; }
  // Top_up Qiumei Ma
  else if ( clid == CLID_Calib_InjSigInterval ) { index = 10; }
  else if ( clid == CLID_Calib_InjSigTime ) { index = 11; }
  else if ( clid == CLID_Calib_OffEvtFilter ) { index = 12; }
  else if ( clid == CLID_Calib_CorrectedETS ) { index = 13; }
 
  else { log << MSG::WARNING << "Wrong CLID" << endmsg; }
  // std::cout<<"index=="<<index<<std::endl;
  // see if svctype set in the CalibDataSvc is MYSQL_StorageType or  CALIBROOT_StorageType
  /* IInstrumentName* iInstrumentName;
     StatusCode sc = m_detDataSvc->queryInterface(IID_IInstrumentName,
     (void**) &iInstrumentName);
 
     if ( !sc.isSuccess() ) {
     log << MSG::ERROR
     << "Cannot query IInstrumentName interface of CalibDataSvc"
     << endmsg;
     return sc;
     } else {
     log << MSG::DEBUG
     << "Retrieved IInstrumentName interface of CalibDataSvc"
     << endmsg;
     }
 
     int svctype = iInstrumentName->getsvctype();
     if(svctype== CALIBROOT_StorageType)
     {
     */
  //    dataIdent = m_rootfile[index];
  if ( m_rootfile[index] == "no rootfile" )
  {
    log << MSG::INFO << "no sepcified calibration file path of type " << index << endmsg;
    return StatusCode::FAILURE;
  }
  decodeDescription( m_rootfile[index], dataIdent );
  fullpath = par[0];
  /*    }
 
        if(svctype== MYSQL_StorageType)
        {   log << MSG::INFO<<"rootfile is not set in the jobOption,get it from MySQL"<<endmsg;
        dataIdent = par[0];
        fullpath = par[1];
        }
 
        if ((svctype != CALIBROOT_StorageType)&&(svctype!= MYSQL_StorageType)) {
        log << MSG::ERROR << "bad storage type" << (int)svctype << endmsg;
        return StatusCode::FAILURE;
        }
        */
 
  // std::string dataIdent(par[0]); // file identifier for PDS version of data
  log << MSG::INFO << "dataIdent is:" << dataIdent << endmsg;
  // std::string fullpath(par[1]);  // path within TCDS for the object
  log << MSG::INFO << "fullpath is :" << fullpath << endmsg;
 
  int runfrm = ip[0];
  int runto  = ip[1];
 
  // for now have to ignore fmtVersion because of defective implementation
  // of GenericAddress. If we want it, should probably write new
  // opaque address implementation for this package to use.  All
  // dealings with (calibration) opaque addresses are confined to
  // the CalibSvc package.
  refpAddress =
      new GenericAddress( CALIBROOT_StorageType, clid, dataIdent, fullpath, runfrm, runto );
 
  return StatusCode::SUCCESS;
}
 
StatusCode CalibRootCnvSvc::writeToRoot( const std::string& outfile,
                                         const std::string& tdsPath ) {
  MsgStream log( msgSvc(), name() );
 
  // Find corresponding object
  DataObject* pObj;
  m_detDataSvc->findObject( tdsPath, pObj );
  if ( !pObj )
  {
    log << "No object in TDS with path " << tdsPath << endmsg;
    return StatusCode::FAILURE;
  }
 
  CalibData::CalibBase1* pCalib = dynamic_cast<CalibData::CalibBase1*>( pObj );
 
  if ( !pCalib )
  {
    log << "Object with path " << tdsPath << " not of proper type" << endmsg;
    return StatusCode::FAILURE;
  }
  return writeToRoot( outfile, pCalib );
}
StatusCode CalibRootCnvSvc::writeToRoot( const std::string&     outfile,
                                         CalibData::CalibBase1* pCalib ) {
  MsgStream log( msgSvc(), name() );
  // Find converter corresponding to this object
  IConverter* converter = ConversionSvc::converter( pCalib->clID() );
  if ( !converter )
  {
    log << "No converter found for object with CLID  " << pCalib->clID() << endmsg;
    return StatusCode::FAILURE;
  }
  RootCalBaseCnv* pCnv = dynamic_cast<RootCalBaseCnv*>( converter );
  if ( !pCnv )
  {
    log << "Converter for CLID " << pCalib->clID() << " not of proper type" << endmsg;
    return StatusCode::FAILURE;
  }
  // Call its createRoot method
  return pCnv->createRoot( outfile, pCalib );
}
 
StatusCode CalibRootCnvSvc::updateObj( IOpaqueAddress* pAddress, DataObject* pObject ) {
 
  //  using facilities::Timestamp;
 
  MsgStream log( msgSvc(), "CalibRootCnvSvc" );
 
  // Don't update when we're using enter time
  log << MSG::DEBUG << "CalibRootCnvSvc::updateObj starting ...." << endmsg;
  /*
     if (!m_useEventTime)
     {  log << MSG::DEBUG << "Method updateObj needn't update" << endmsg;
     return StatusCode::SUCCESS;
     }
     */
  return StatusCode::SUCCESS;
}
 
StatusCode CalibRootCnvSvc::decodeDescription( const std::string& oldpath,
                                               std::string&       realpath ) {
  MsgStream log( msgSvc(), "CalibMySQLCnvSvc" );
 
  if ( oldpath[0] != '$' ) { realpath = oldpath; }
  if ( oldpath[0] == '$' )
  {
    std::string::size_type idx = oldpath.find( "/" );
    if ( std::string::npos != idx )
    {
      std::string relpath;
      for ( int i = 1; i < idx - 1; i++ ) { relpath[i - 1] = oldpath[i]; }
      std::string otherpath;
      for ( int i = idx - 1; i < oldpath.size(); i++ ) { otherpath[i - idx + 1] = oldpath[i]; }
      realpath = std::string( getenv( relpath.c_str() ) ) + otherpath;
    }
    if ( std::string::npos == idx )
    {
      std::string relpath;
      for ( int i = 1; i < oldpath.size(); i++ ) { relpath[i - 1] = oldpath[i]; }
      realpath = std::string( getenv( relpath.c_str() ) );
    }
  }
 
  return StatusCode::SUCCESS;
}
 
IConverter* CalibRootCnvSvc::createConverter( long typ, const CLID& wanted,
                                              const ICnvFactory* fac ) {
  if ( wanted == RootCorrectedETSCnv::classID() )
    return new RootCorrectedETSCnv( serviceLocator().get() );
  if ( wanted == RootDedxCalibDataCnv::classID() )
    return new RootDedxCalibDataCnv( serviceLocator().get() );
  if ( wanted == RootDedxSimDataCnv::classID() )
    return new RootDedxSimDataCnv( serviceLocator().get() );
  if ( wanted == RootEmcCalibDataCnv::classID() )
    return new RootEmcCalibDataCnv( serviceLocator().get() );
  if ( wanted == RootEsTimeCalibDataCnv::classID() )
    return new RootEsTimeCalibDataCnv( serviceLocator().get() );
  if ( wanted == RootEstTofCalibDataCnv::classID() )
    return new RootEstTofCalibDataCnv( serviceLocator().get() );
  if ( wanted == RootInjSigIntervalCnv::classID() )
    return new RootInjSigIntervalCnv( serviceLocator().get() );
  if ( wanted == RootInjSigTimeCnv::classID() )
    return new RootInjSigTimeCnv( serviceLocator().get() );
  if ( wanted == RootMdcCalibDataCnv::classID() )
    return new RootMdcCalibDataCnv( serviceLocator().get() );
  if ( wanted == RootMucCalibDataCnv::classID() )
    return new RootMucCalibDataCnv( serviceLocator().get() );
  if ( wanted == RootOffEvtFilterCnv::classID() )
    return new RootOffEvtFilterCnv( serviceLocator().get() );
  if ( wanted == RootTofCalibDataCnv::classID() )
    return new RootTofCalibDataCnv( serviceLocator().get() );
  if ( wanted == RootTofElecDataCnv::classID() )
    return new RootTofElecDataCnv( serviceLocator().get() );
  if ( wanted == RootTofSimDataCnv::classID() )
    return new RootTofSimDataCnv( serviceLocator().get() );
 
  return ConversionSvc::createConverter( typ, wanted, fac );
}