TreeCalBaseCnv.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/CalibSvc/CalibTreeCnv/src/cnv/TreeCalBaseCnv.cxx,v 1.8
// 2022/02/21 06:45:17 maqm Exp $
/**
            @file  TreeCalBaseCnv.cxx
 
   Implementation file for Root calibration converter base class
*/
 
#include "TreeCalBaseCnv.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 "CalibMySQLCnvSvc/TreeAddress.h"
#include "DatabaseSvc/IDatabaseSvc.h"
#include "TFile.h"
#include "TObject.h"
#include "TROOT.h" // need this for cd??
#include "TTree.h"
 
TreeCalBaseCnv::~TreeCalBaseCnv() {
  // release TFile, TTree if they need releasing.  With normal
  // termination they should already have been released.
 
  // doClean();
}
 
// static CnvFactory<TreeCalBaseCnv> s_factory;
// const ICnvFactory& TreeCalBaseCnvFactory = s_factory;
TreeCalBaseCnv::TreeCalBaseCnv( ISvcLocator* svc, const CLID& clid )
    : Converter( CALIBTREE_StorageType, clid, svc )
    , m_treeSvc( 0 )
    , m_metaSvc( 0 )
    , m_instrSvc( 0 )
    , m_outFile( 0 )
    , m_ttree( 0 )
    , m_inFile( 0 )
    , m_saveDir( 0 ) {}
 
StatusCode TreeCalBaseCnv::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 ("CalibTreeCnvSvc",
  //                              IID_ICalibTreeSvc,
  //                              (IInterface*&) m_treeSvc);
  IInterface* m_treeSvc = serviceLocator()->service( "CalibTreeCnvSvc" );
  // 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",
                               IID_ICalibMetaCnvSvc,
                                (IInterface*&)m_metaSvc);
  */
  IInterface* m_metaSvc = serviceLocator()->service( "CalibMySQLCnvSvc" );
  /*serviceLocator()->getService ("CalibDataSvc",
                                IID_IInstrumentName,
                                (IInterface*&)m_instrSvc);*/
  IInterface* m_instrSvc = serviceLocator()->service( "CalibDataSvc" );
 
  return status;
}
 
StatusCode TreeCalBaseCnv::finalize() { return Converter::finalize(); }
 
/******      ROOT services     *****/
 
StatusCode TreeCalBaseCnv::createRoot( const std::string& /* fname */,
                                       CalibData::CalibBase1* /* pTDSObj */ ) {
  MsgStream log( msgSvc(), "TreeCalBaseCnv" );
  log << MSG::ERROR << "createRoot method not implemented for this calibration type" << endmsg;
  return StatusCode::FAILURE;
}
 
// Do our part to write out object -- which is nothing
StatusCode TreeCalBaseCnv::fillRoot( CalibData::CalibBase* /*pTDSObj */,
                                     TObject* /* pRootObj */ ) {
 
  // Get instrument name from InstrumentName service  Now handled by
  // TreeCalBaseCnv
  //  TString instr = TString((m_instrSvc->getInstrumentName()).c_str());
  //  pRootObj->setInstrument(instr);
  return StatusCode::SUCCESS;
}
 
// (To TDS) Conversion stuff
StatusCode TreeCalBaseCnv::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(), "TreeCalBaseCnv" );
  log << MSG::DEBUG << "TreeCalBaseCnv::createObj( starting ...." << endmsg;
  //  const std::string* par = addr->par();
 
  // std::string par0 = par[0];
 
  //  return internalCreateObj(par0, refpObject, addr);
  return internalCreateObj( refpObject, addr );
}
 
// StatusCode TreeCalBaseCnv::internalCreateObj(const std::string& fname,
//                                           DataObject*& refpObject,
//                                           IOpaqueAddress* address) {
StatusCode TreeCalBaseCnv::internalCreateObj( DataObject*&    refpObject,
                                              IOpaqueAddress* address ) {
 
  MsgStream log( msgSvc(), "TreeCalBaseCnv" );
  log << MSG::DEBUG << "TreeCalBaseCnv::internalCreateObj( starting ..... " << endmsg;
  TreeCalBaseCnv* 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<TreeCalBaseCnv*>( conv );
    if ( 0 == converter )
    {
      log << MSG::ERROR << "The converter found for classID " << classId
          << " was not a descendent of TreeCalBaseCnv as it should be "
          << "( was of type " << typeid( *converter ).name() << "). "
          << "The default converter will be used" << endmsg;
      converter = this;
    }
  }
 
  TreeAddress* treeAddress = dynamic_cast<TreeAddress*>( address );
  m_runfrm                 = treeAddress->getRunFrom();
  m_runto                  = treeAddress->getRunTo();
  // m_runfrm =*( address->ipar());
  // m_runto =*( address->ipar()+1);
  //   m_runfrm = 100;
  //   m_runto =1000;
  // creates an object for the node found
  StatusCode sc = converter->i_createObj( address, 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 TreeCalBaseCnv::i_createObj( IOpaqueAddress* address,
                                        DataObject*& /* refpObject */ ) {
  return StatusCode::FAILURE; // shouldn't ever get here
}
 
// Default is to do nothing.  Derived classes may override.
StatusCode TreeCalBaseCnv::i_processObj( DataObject*, // pObject,
                                         IOpaqueAddress* ) /* address */ {
  return StatusCode::SUCCESS;
}
 
/// Another utility for derived classes to use
void TreeCalBaseCnv::setBaseInfo( CalibData::CalibBase1* pObj ) {
  MsgStream log( msgSvc(), "TreeCalBaseCnv" );
  log << MSG::DEBUG << "set the runfrm and runto Numbers in the converter" << endmsg;
  pObj->setrunfrm( m_runfrm );
  pObj->setrunto( m_runto );
}