CalibDataSvc.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/CalibSvc/CalibDataSvc/src/CalibDataSvc.cxx,v 1.30 2020/09/28 05:13:03 maqm Exp $
 
// Include files
#include "CalibDataSvc/CalibDataSvc.h"
#include "CalibDataSvc/CalibCLIDNode.h"
//#include "CalibData/CalibTime.h"
#include "GaudiKernel/IAddressCreator.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/IValidity.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SvcFactory.h"
//#include "GaudiKernel/TimePoint.h"
#include "GaudiKernel/SmartDataPtr.h"
 
#include "CalibDataSvc/ICalibRootSvc.h" //maqm add
#include "CalibData/CalibModelSvc.h"
#include "CalibData/CalibBase1.h"
#include "CalibData/Mdc/MdcCalStruct.h"
#include "GaudiKernel/RegistryEntry.h"//huangb add
#include "TROOT.h"
#include "TFile.h"
#include "TTree.h"
 
#include "EventModel/EventModel.h"
#include "EventModel/EventHeader.h"
//#include "EventModel/EventList.h"
 
//#include "CalibData/Mdc/Mdct0par.h"
#define CAST_REGENTRY(x,y) dynamic_cast<x>(y)
//#define CAST_REGENTRY(x,y) (x)(y)
typedef DataSvcHelpers::RegistryEntry RegEntry;
 
using namespace CalibData;
// Instantiation of a static factory class used by clients to create
// instances of this service
//static SvcFactory<CalibDataSvc> s_factory;
//const ISvcFactory& CalibDataSvcFactory = s_factory;
 
/// Standard Constructor
CalibDataSvc::CalibDataSvc(const std::string& name,ISvcLocator* svc) :
  DataSvc(name,svc)
{
 
  // declare a property which is a list of known calibrations.
  // Have default list in one of the standard options files.  
  // User can add others.
  declareProperty("CalibNameList", m_calibList);
  declareProperty("CalibFlavorList", m_flavorList);
  declareProperty("CalibRootName",   m_calibRootName  = "Calib" ); 
  declareProperty("Mdc_CalibStorageType",
      m_calibType[0] = CALIBROOT_StorageType );
  declareProperty("Tof_CalibStorageType",
      m_calibType[1] = CALIBROOT_StorageType );
  declareProperty("Dedx_CalibStorageType",
      m_calibType[2] = CALIBROOT_StorageType );
  declareProperty("EMC_CalibStorageType",
      m_calibType[3] = CALIBROOT_StorageType ); 
  declareProperty("MUC_CalibStorageType",
      m_calibType[4] = CALIBROOT_StorageType );
  declareProperty("EsTime_CalibStorageType",
      m_calibType[5] = CALIBROOT_StorageType );
  declareProperty("EstTof_CalibStorageType",
      m_calibType[6] = CALIBROOT_StorageType );
  declareProperty("TofQElec_CalibStorageType",
      m_calibType[8] = CALIBROOT_StorageType );
  declareProperty("TofSim_CalibStorageType",
      m_calibType[9] = CALIBROOT_StorageType );
  declareProperty("DedxSim_CalibStorageType",
      m_calibType[10] = CALIBROOT_StorageType );
  //Top_up Qiumei Ma
  declareProperty("InjSigInterval_CalibStorageType",
      m_calibType[12] = CALIBROOT_StorageType );
  declareProperty("InjSigTime_CalibStorageType",
      m_calibType[13] = CALIBROOT_StorageType );
  declareProperty("OffEvtFilter_CalibStorageType",
      m_calibType[14] = CALIBROOT_StorageType );
  declareProperty("CorrectedETS_CalibStorageType",
      m_calibType[15] = CALIBROOT_StorageType );
 
  std::cout<<"CALIBROOT_StorageType " <<CALIBROOT_StorageType<<" "<<std::endl;
  //MdcAlign
  m_calibType[7]=14;
  //MdcDataConst
  m_calibType[11]=14;
 
  // m_rootName and m_rootCLID are declared in base class DataSvc
  m_rootName = "/" + m_calibRootName;
  m_rootCLID = CLID_DataObject;  
 
 
 
}
 
/// Standard Destructor
CalibDataSvc::~CalibDataSvc()  {
  setDataLoader(0);
  clearStore();
}
 
// Service initialization
StatusCode CalibDataSvc::initialize()   {
 
  StatusCode sc;
 
  sc  = DataSvc::initialize();     // Call base class initialisation
  if (sc.isFailure() )  return sc;
 
  // Set up MsgSvc, Data Loader
  MsgStream log(msgSvc(), name());
  IConversionSvc* cnv_svc;
  sc = serviceLocator()->service("DetectorPersistencySvc", cnv_svc, true);
  if (sc .isFailure() ) {
    log << MSG::ERROR << "Unable to find DetectorPersistencySvc " << endreq;
    return sc;
  }
 
  IIncidentSvc* incsvc;
  sc = service("IncidentSvc", incsvc);
  int priority = 100;
  if( sc.isSuccess() ){
    incsvc -> addListener(this, "NewRun", priority);
  }
 
  sc = serviceLocator()->service("EventDataSvc", m_eventSvc, true);
  if (sc .isFailure() ) {
    log << MSG::ERROR << "Unable to find EventDataSvc " << endreq;
    return sc;
  }
 
  sc = setDataLoader(cnv_svc);
  if (sc.isFailure() ) {
    log << MSG::ERROR << "Unable to set data loader " << endreq;
    return sc;
  }
  sc = setProperties();   
 
  // Initialize the calibration data transient store
  IAddressCreator*     calibCreator = 0;
 
  // Use Gaudi-supplied DetectorPersistencySvc; it's essentially
  // the same as base class PersistencySvc, which is all we need
  sc = serviceLocator()->service("DetectorPersistencySvc", calibCreator);
 
  if( sc.isFailure() ) {
    log << MSG::ERROR << "Unable to locate DetectorPersistencySvc." << endreq;
    return StatusCode::FAILURE; 
  }
 
  //   Make the root for the TDDS data
  DataObject* rootObj = new DataObject();
  sc = setRoot(m_rootName, rootObj);
  if (!sc.isSuccess() ) {
    log << MSG::ERROR << "Unable to set calib data store root." << endreq;
    delete rootObj;
    return sc;
  }
 
  // Create and register the next level of nodes.
  // Have one per calibration type. They are of a class trivially 
  // derived from DataObject, CalibCLIDNode.  Only additional 
  // information is CLID of child nodes.  List comes from CalibData 
  // namespace
  //StatusCode CalibDataSvc::makeFlavorNodes(IAddressCreator*  calibCreator,
  //                                         MsgStream* log) {
  typedef std::vector<CalibData::CalibModelSvc::CalibPair>::const_iterator 
    PairIt;
  PairIt  pairIt;
  CalibData::CalibModelSvc svc;
  const std::vector<CalibData::CalibModelSvc::CalibPair>& pairs = 
    svc.getPairs();
  int jj =0;
  for (pairIt = pairs.begin(); pairIt != pairs.end(); pairIt++,jj++) {
 
    CalibCLIDNode* node = new CalibCLIDNode(pairIt->second);
 
    std::string calibTypePath(pairIt->first);
    // sc =DataSvc::registerObject(calibTypePath, node);
 
    // Still have to figure out what to do about args, iargs
    unsigned long iargs[]={0,0};
    IOpaqueAddress* pAddress;
 
    // Set up nodes for each calibration type, default flavor
    // Create and register addresses suitable for the metadata
    // conversion service.  Ultimately, in order to find the "right"
    // set of constants,  it needs to know
    //    Calibration type, e.g. CAL Electronic gain
    //    Flavor            e.g. vanilla 
    //    Event time        validity period of constants must include this time
    //    Instrument        LAT, EM, etc.
    // We save the first two, or equivalent information, in the first
    // string parameter of a generic address
    // Consumers can use utilities in CalibData::CalibModelSvc to
    // extract fields they need
    // Event time and Instrument will be discovered by conversion service
    // when constants are requested by invoking our (CalibDataSvc) time
    // and instrument name services, resp.
 
    // Always do vanilla
    std::string fullpath = calibTypePath;
    std::string args[] = {fullpath};
 
    sc = calibCreator->createAddress(m_calibType[jj],
    pairIt->second,   // class id
    args, iargs, pAddress);
 
 
    if (!sc.isSuccess()) { 
      log<< MSG::INFO 
    << "Unable to create Calib address with path " << fullpath << endreq;
    }
 
    // A node unof a specific flavor is a child of the per-calibration type
    // node for which an object was registered above.
    sc = registerAddress(fullpath, pAddress);
    if (!sc.isSuccess()) {
      log<< MSG::ERROR << "Unable to register Calib address with path" 
    << fullpath << endreq;
    }
    // Now do the same for any requested flavors
    /*
       unsigned int ix;
 
       for (ix = 0; ix < m_flavorList.size(); ix++) { 
       log<<MSG::DEBUG<<"here is the flavor in the CalibDataSvc"<<endreq; 
    // Don't redo vanilla, if present in user list
    if (m_flavorList[ix] == std::string("vanilla")) continue;
 
    fullpath = calibTypePath + "/" + m_flavorList[ix];
    args[0] = fullpath;
 
    sc = calibCreator->createAddress(m_calibStorageType, 
    pairIt->second, args, iargs, pAddress); 
    if (!sc.isSuccess()) {
 
 
    log<< MSG::ERROR << "Unable to create Calib address with path " 
    << fullpath << endreq;
    }
    sc = DataSvc::registerAddress(fullpath, pAddress);
    if (!sc.isSuccess()) {
    log<< MSG::ERROR << "Unable to register Calib address with path " 
    << fullpath << endreq;
    }
    }   
    // end flavor loop 
    */
  } 
  // end calibType loop
  // initialize the parameters
 
  return StatusCode::SUCCESS;
}
 
 
 
/// Finalize the service.
StatusCode CalibDataSvc::finalize()
{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "Finalizing" << endreq;
 
  //  return StatusCode::SUCCESS;
  // Finalize the base class
  //  huangb temply delete
  return DataSvc::finalize();
}
 
StatusCode CalibDataSvc::queryInterface(const InterfaceID& riid, void** ppvInterface)
{
  // With the highest priority return the specific interfaces
  // If interfaces are not directly available, try out a base class
  if (IDetDataSvc::interfaceID().versionMatch(riid) ) {
    *ppvInterface = (IDetDataSvc*)this;
  } else if (IInstrumentName::interfaceID().versionMatch(riid) ) {
    *ppvInterface = (IInstrumentName*) this;
    //  } else if ( IID_IIncidentListener.versionMatch(riid) ) {
    //    *ppvInterface = (IIncidentListener*)this; 
} else {
  return DataSvc::queryInterface(riid, ppvInterface);
}
addRef();
return StatusCode::SUCCESS;
}
 
 
 
 
 
 
/// Remove all data objects in the data store.
StatusCode CalibDataSvc::clearStore()   {
  DataSvc::clearStore();
  return StatusCode::SUCCESS;
}
 
//update the calibration in TCDS if a new run comes
void CalibDataSvc::handle ( const Incident& inc ) {
  MsgStream log( msgSvc(), name() );
  return; 
}
 
 
 
 
 
 
StatusCode CalibDataSvc::updateObject( DataObject* toUpdate ) {
 
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO<<"begin of CalibDataSvc::updateObject"<<endreq;
  // Check that object to update exists
  if ( 0 == toUpdate ) { 
    log << MSG::ERROR
      << "There is no DataObject to update" << endreq;
    return INVALID_OBJECT; 
  }
 
  log << MSG::INFO<<"begin of CalibDataSvc::updateObject"<<endreq;
  // Now delegate update to the conversion service by calling the base class
  StatusCode status = DataSvc::updateObject(toUpdate);
  if ( !status.isSuccess() ) {
    log << MSG::ERROR 
      << "Could not update DataObject" << endreq; 
    if ( status == NO_DATA_LOADER )
      log << MSG::ERROR << "There is no data loader" << endreq; 
    return status;
  } 
  log << MSG::INFO<<"begin of CalibDataSvc::updateObject successfully updated"<<endreq;
  // DataObject was successfully updated
  return StatusCode::SUCCESS;
}
 
StatusCode CalibDataSvc::loadObject(IConversionSvc* pLoader, 
    IRegistry* pRegistry) {
  return DataSvc::loadObject(pLoader, pRegistry);
 
}
 
StatusCode CalibDataSvc::retrieveObject(const std::string& fullPath,DataObject*& pObject)
{  
  MsgStream log( msgSvc(), name() );
 
  int runNo;
  //maqm SmartDataPtr<Event::EventHeader> evt(m_eventSvc,"/Event");
  SmartDataPtr<Event::EventHeader> evt(m_eventSvc,"/Event/EventHeader");
  if( evt ){
    runNo = evt -> runNumber();
    log << MSG::DEBUG <<"The runNumber of current event is  "<<runNo<<endreq;
  }
 
  else{
    log << MSG::WARNING << "WARNING accessing Event" <<endreq;
    //   return StatusCode::FAILURE;
  }
 
 
  StatusCode  sc =DataSvc::retrieveObject(fullPath,pObject);
  if (!sc.isSuccess()) {
    log<< MSG::ERROR << "Unable to get the retrieveObject" 
      << endreq;
    return sc;
  }
  // if(fullPath=="/Calib/MdcAlign"&&m_calibType[0]==CALIBROOT_StorageType) 
  //   { return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/MdcCal"&&m_calibType[0]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/DedxCal"&&m_calibType[2]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/TofCal"&&m_calibType[1]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/EmcCal"&&m_calibType[3]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/MucCal"&&m_calibType[4]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/EsTimeCal"&&m_calibType[5]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/EstTofCal"&&m_calibType[6]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/TofQElec"&&m_calibType[8]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/TofSim"&&m_calibType[9]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/DedxSim"&&m_calibType[10]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  //Top_up Qiumei Ma
  if(fullPath=="/Calib/InjSigInterval"&&m_calibType[12]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;} 
  if(fullPath=="/Calib/InjSigTime"&&m_calibType[13]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/OffEvtFilter"&&m_calibType[14]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/CorrectedETS"&&m_calibType[15]==CALIBROOT_StorageType){
    return StatusCode::SUCCESS;}
 
  CalibData::CalibBase1* tmpObject = dynamic_cast<CalibData::CalibBase1*>(pObject);
  if(fullPath=="/Calib/TofCal"&&runNo>= tmpObject->getrunfrm()&&runNo<=tmpObject->getrunto())
  { return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/EstTofCal"&&runNo>= tmpObject->getrunfrm()&&runNo<=tmpObject->getrunto())
  { return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/TofSim"&&runNo>= tmpObject->getrunfrm()&&runNo<=tmpObject->getrunto())
  { return StatusCode::SUCCESS;}
  if(fullPath=="/Calib/DedxSim"&&runNo>= tmpObject->getrunfrm()&&runNo<=tmpObject->getrunto())
  { return StatusCode::SUCCESS;}
 
 
 
  if( fabs(runNo) >= tmpObject->getrunfrm() && fabs(runNo)<=tmpObject->getrunto())
  {
    log << MSG::DEBUG <<__LINE__<< " runfrm @CalibDataSvc is:"<<tmpObject->getrunfrm()<<" runto min is:"<<tmpObject->getrunto()<<endreq;
    return StatusCode::SUCCESS;}
  else
  { 
    log<< MSG::INFO <<"@CalibDataSvc runfrm="<< tmpObject->getrunfrm()<<"runto="<<tmpObject->getrunto()<<"runNo="<<runNo<<endreq;
    log<< MSG::DEBUG << "update the Object" 
      << endreq;
    sc =DataSvc:: updateObject(pObject);
    return sc;    
  }//end of else
}//end of if
 
StatusCode CalibDataSvc::registerObject (const std::string& parentPath,
    const std::string& objPath,
    DataObject* pObject)   {
  DataObject* pO = 0;
  StatusCode status =DataSvc::retrieveObject(parentPath, pO);
  if ( !status.isSuccess() && m_forceLeaves )   {
    pO = createDefaultObject();
    status =DataSvc::registerObject(parentPath, pO);
    if ( !status.isSuccess() )   {
      pO->release();
    }//end of if
  }//end of if( !status.isSuccess() && m_forceLeaves )
  if ( status.isSuccess() )   {
    status =DataSvc::registerObject(pO, objPath, pObject);
  }
  if(status.isSuccess() ){
    return status;
  }
}