RootCalBaseCnv.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/CalibSvc/CalibROOTCnv/src/cnv/RootCalBaseCnv.cxx,v 1.8
// 2022/03/04 03:49:16 maqm Exp $
/**
            @file  RootCalBaseCnv.cxx
 
   Implementation file for Root calibration converter base class
*/
 
#include "RootCalBaseCnv.h"
 
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IAddressCreator.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/MsgStream.h"
 
#include "CalibData/CalibBase.h"
#include "CalibData/CalibBase1.h"
#include "CalibDataSvc/ICalibMetaCnvSvc.h"
#include "CalibDataSvc/ICalibRootSvc.h"
#include "CalibDataSvc/IInstrumentName.h"
#include "facilities/Util.h" // for translating env variables
// Guessing at needed Root includes
#include "TFile.h"
#include "TObject.h"
#include "TROOT.h" // need this for cd??
#include "TTree.h"
 
RootCalBaseCnv::~RootCalBaseCnv() {
  // release TFile, TTree if they need releasing.  With normal
  // termination they should already have been released.
 
  // doClean();
}
 
// static CnvFactory<RootCalBaseCnv> s_factory;
// const ICnvFactory& RootCalBaseCnvFactory = s_factory;
RootCalBaseCnv::RootCalBaseCnv( ISvcLocator* svc, const CLID& clid )
    : Converter( CALIBROOT_StorageType, clid, svc )
    , m_rootSvc( 0 )
    , m_metaSvc( 0 )
    , m_instrSvc( 0 )
    , m_vstart( 0 )
    , m_vend( 0 )
    , m_outFile( 0 )
    , m_ttree( 0 )
    , m_inFile( 0 )
    , m_saveDir( 0 ) {}
 
StatusCode RootCalBaseCnv::initialize() {
  StatusCode status = Converter::initialize();
 
  IDataProviderSvc* dp;
 
  // I guess the service names are assigned in jobOptions?
 
  /*serviceLocator()->getService ("CalibDataSvc",
                                IID_IDataProviderSvc,
                                (IInterface*&)dp);*/
  serviceLocator()->getService( "CalibDataSvc", IDataProviderSvc::interfaceID(),
                                (IInterface*&)dp );
  setDataProvider( dp );
  // Locate the Root Conversion Service
  serviceLocator()->getService( "CalibRootCnvSvc", ICalibRootSvc::interfaceID(),
                                (IInterface*&)m_rootSvc );
 
  // Locate meta conversion service
  // Will anything need to be changed here to accommodate possibility
  // of two concrete implementations of ICalibMetaCnvSvc?  Would
  // have different storage types.  Could specify type desired
  // as job option.  Ditto for name of class?
  serviceLocator()->getService( "CalibMySQLCnvSvc", ICalibMetaCnvSvc::interfaceID(),
                                (IInterface*&)m_metaSvc );
  serviceLocator()->getService( "CalibDataSvc", IInstrumentName::interfaceID(),
                                (IInterface*&)m_instrSvc );
 
  return status;
}
 
StatusCode RootCalBaseCnv::finalize() { return Converter::finalize(); }
 
/******      ROOT services     *****/
 
StatusCode RootCalBaseCnv::createRoot( const std::string& /* fname */,
                                       CalibData::CalibBase1* /* pTDSObj */ ) {
  MsgStream log( msgSvc(), "RootCalBaseCnv" );
  log << MSG::ERROR << "createRoot method not implemented for this calibration type" << endmsg;
  return StatusCode::FAILURE;
}
 
StatusCode RootCalBaseCnv::openRead( const std::string& fname ) {
 
  MsgStream log( msgSvc(), "RootCalBaseCnv" );
 
  // Check fname isn't empty
  if ( fname == std::string( "" ) ) return StatusCode::FAILURE;
 
  if ( doClean() ) { log << MSG::WARNING << "Previous operation didn't clean up! " << endmsg; }
  m_saveDir = gDirectory;
 
  std::string ourName( fname );
  facilities::Util::expandEnvVar( &ourName );
 
  m_inFile = new TFile( ourName.c_str() );
 
  if ( !m_inFile->IsOpen() )
  {
    log << MSG::ERROR << "ROOT file " << ourName << "could not be opened for reading "
        << endmsg;
    delete m_inFile;
    m_inFile = 0;
    return StatusCode::FAILURE;
  }
  else
  {
    log << MSG::INFO << "Successfully opened ROOT file " << fname << " aka " << ourName
        << " for reading " << endmsg;
  }
 
  m_inFile->cd(); //    Maybe will need this
 
  return StatusCode::SUCCESS;
}
 
StatusCode RootCalBaseCnv::closeRead() {
  m_inFile->Close();
 
  delete m_inFile;
  m_inFile = 0;
 
  if ( m_saveDir )
  {
    m_saveDir->cd();
    m_saveDir = 0;
  }
  return StatusCode::SUCCESS;
}
 
StatusCode RootCalBaseCnv::openWrite( const std::string& fname ) {
 
  MsgStream log( msgSvc(), "RootCalBaseCnv" );
 
  // Check fname isn't empty
  if ( fname == std::string( "" ) ) return StatusCode::FAILURE;
 
  std::string ourName( fname );
  facilities::Util::expandEnvVar( &ourName );
 
  if ( doClean() ) { log << MSG::WARNING << "Previous operation didn't clean up! " << endmsg; }
 
  m_saveDir = gDirectory;
 
  m_outFile = new TFile( ourName.c_str(), "RECREATE" );
  if ( !m_outFile->IsOpen() )
  {
    log << MSG::ERROR << "ROOT file " << fname << " aka " << ourName
        << " could not be opened for writing" << endmsg;
    delete m_outFile;
    m_outFile = 0;
    return StatusCode::FAILURE;
  }
  else
  {
    log << MSG::INFO << "Successfully opened ROOT file " << fname << " aka " << ourName
        << " for writing " << endmsg;
  }
  m_outFile->cd();
  return StatusCode::SUCCESS;
}
 
StatusCode RootCalBaseCnv::closeWrite() {
 
  MsgStream log( msgSvc(), "RootCalBaseCnv" );
 
  StatusCode ret = StatusCode::SUCCESS;
 
  m_outFile->cd();
  m_outFile->Close();
  delete m_outFile;
  m_outFile = 0;
  if ( m_saveDir ) m_saveDir->cd();
  m_saveDir = 0;
  return ret;
}
 
StatusCode RootCalBaseCnv::readRootObj( const std::string& treename, const std::string& branch,
                                        TObject*& pObj, unsigned ix ) {
  TTree* pTree = (TTree*)m_inFile->Get( treename.c_str() );
 
  return readRootObj( pTree, branch, pObj, ix );
}
 
StatusCode RootCalBaseCnv::readRootObj( TTree* pTree, const std::string& branch,
                                        TObject*& pObj, unsigned ix ) {
  TBranch* pBranch = pTree->GetBranch( branch.c_str() );
  pBranch->SetAddress( &pObj );
  int nBytes = pBranch->GetEntry( ix );
  return ( nBytes > 0 ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
}
 
bool RootCalBaseCnv::doClean() {
  bool ret = false;
 
  if ( m_outFile )
  {
    m_outFile->Close();
    delete m_outFile;
    m_outFile = 0;
    ret       = true;
  }
 
  if ( m_inFile )
  {
    m_inFile->Close();
    delete m_inFile;
    m_inFile = 0;
    ret      = true;
  }
  m_ttree = 0;
  if ( m_saveDir )
  {
    m_saveDir->cd();
    m_saveDir = 0;
  }
  return ret;
}
 
// Do our part to write out object -- which is nothing
StatusCode RootCalBaseCnv::fillRoot( CalibData::CalibBase* /*pTDSObj */,
                                     TObject* /* pRootObj */ ) {
 
  // Get instrument name from InstrumentName service  Now handled by
  // RootCalBaseCnv
  //  TString instr = TString((m_instrSvc->getInstrumentName()).c_str());
  //  pRootObj->setInstrument(instr);
  return StatusCode::SUCCESS;
}
 
// (To TDS) Conversion stuff
StatusCode RootCalBaseCnv::createObj( IOpaqueAddress* addr, DataObject*& refpObject ) {
  //  StatusCode ret;
 
  // first do the things we always need:
  //   First string parameter of opaque address is file ident
  MsgStream log( msgSvc(), "RootCalBaseCnv" );
  log << MSG::DEBUG << "RootCalBaseCnv::createObj( starting ...." << endmsg;
  const std::string* par = addr->par();
 
  std::string par0 = par[0];
 
  return internalCreateObj( par0, refpObject, addr );
}
 
StatusCode RootCalBaseCnv::internalCreateObj( const std::string& fname,
                                              DataObject*&       refpObject,
                                              IOpaqueAddress*    address ) {
  MsgStream log( msgSvc(), "RootCalBaseCnv" );
  log << MSG::DEBUG << "RootCalBaseCnv::internalCreateObj( starting ..... " << endmsg;
  RootCalBaseCnv* converter = this;
  CLID            classId   = address->clID();
 
  IConverter* conv = this->conversionSvc()->converter( classId );
  if ( 0 == conv )
  {
    log << MSG::WARNING << "No proper converter found for classID " << classId
        << ", the default converter"
        << " will be used. " << endmsg;
  }
  else
  {
    converter = dynamic_cast<RootCalBaseCnv*>( conv );
    if ( 0 == converter )
    {
      log << MSG::ERROR << "The converter found for classID " << classId
          << " was not a descendent of RootCalBaseCnv as it should be "
          << "( was of type " << typeid( *converter ).name() << "). "
          << "The default converter will be used" << endmsg;
      converter = this;
    }
  }
 
  m_runfrm = *( address->ipar() );
  m_runto  = *( address->ipar() + 1 );
  // creates an object for the node found
  StatusCode sc = converter->i_createObj( fname, refpObject );
  if ( sc.isFailure() ) { return sc; }
  CalibData::CalibBase1* tmpObject = dynamic_cast<CalibData::CalibBase1*>( refpObject );
  setBaseInfo( tmpObject );
  // ends up the object construction
  sc = converter->i_processObj( refpObject, address );
  if ( sc.isSuccess() )
  { log << MSG::DEBUG << "Successfully created calib. object " << endmsg; }
  closeRead();
  return sc;
}
 
/*
   Base class version of this routine shouldn't really be called
   since it doesn't correspond to a TDS object.
*/
StatusCode RootCalBaseCnv::i_createObj( const std::string& /* fname */,
                                        DataObject*& /* refpObject */ ) {
  return StatusCode::FAILURE; // shouldn't ever get here
}
 
// Default is to do nothing.  Derived classes may override.
StatusCode RootCalBaseCnv::i_processObj( DataObject*, // pObject,
                                         IOpaqueAddress* ) /* address */ {
  return StatusCode::SUCCESS;
}
 
/// Another utility for derived classes to use
void RootCalBaseCnv::setBaseInfo( CalibData::CalibBase1* pObj ) {
  MsgStream log( msgSvc(), "RootCalBaseCnv" );
  log << MSG::DEBUG << "set the runfrm and runto Numbers in the converter" << endmsg;
  pObj->setrunfrm( m_runfrm );
  pObj->setrunto( m_runto );
}