CalibDataSvc Class Reference

#include <CalibDataSvc.h>

List of all members.

Public Member Functions
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
	Finalize the service.
virtual StatusCode	clearStore ()
	Remove all data objects in the data store.
virtual StatusCode	updateObject (DataObject *toUpdate)
	Update object.
virtual StatusCode	loadObject (IConversionSvc *pLoader, IRegistry *pRegistry)
virtual StatusCode	retrieveObject (const std::string &fullPath, DataObject *&pObject)
virtual StatusCode	registerObject (const std::string &parentPath, const std::string &objPath, DataObject *pObject)
	CalibDataSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor.
virtual	~CalibDataSvc ()
	Standard Destructor.
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	Query the interface of the service.
virtual void	handle (const Incident &)
	Inform that a new incident has occured.
Private Member Functions
StatusCode	updateRun (int &runfrm, int &runto, std::string &fullPath)
	For use of CalibMySQLCnvSvc, to set "use event time mode".
StatusCode	makeFlavorNodes (IAddressCreator *calibCreator, MsgStream *log)
	Private utility, called from initialize().
Private Attributes
int	m_calibType [12]
	Calibration Data Persistency Storage type.
std::string	m_calibRootName
	Name of the root node of the calib store.
StringArrayProperty	m_calibList
	calibration types
std::vector< std::string >	m_flavorList
IDataProviderSvc *	m_eventSvc
	Dumping place for various time-fetching methods to save the timestamp.
Friends
class	SvcFactory< CalibDataSvc >

---

Detailed Description

A DataSvc specialized for calibration data. This Service borrows heavily from DetDataSvc. In particular it implements the IDetDataSvc interface. The only significant difference is in initialize() and in the elimination of members concerned with detector (geometry) description.

Maybe will also need to implement another abstract service which gets (and sets?) instrument.

Author:

J. Bogart

Date:

15 Oct. 2002

Definition at line 36 of file CalibDataSvc.h.

---

Constructor & Destructor Documentation

CalibDataSvc::CalibDataSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Standard Constructor.

Definition at line 45 of file CalibDataSvc.cxx.

References CALIBROOT_StorageType, m_calibList, m_calibRootName, m_calibType, and m_flavorList.

                                                                 :
  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 );

  //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;  

 

}

CalibDataSvc::~CalibDataSvc

(

)

[virtual]

Standard Destructor.

Definition at line 90 of file CalibDataSvc.cxx.

References clearStore().

                             {
  setDataLoader(0);
  clearStore();
}

---

Member Function Documentation

StatusCode CalibDataSvc::clearStore

(

)

[virtual]

Remove all data objects in the data store.

Definition at line 290 of file CalibDataSvc.cxx.

Referenced by ~CalibDataSvc().

                                      {
  DataSvc::clearStore();
  return StatusCode::SUCCESS;
}

StatusCode CalibDataSvc::finalize

(

)

[virtual]

Finalize the service.

Definition at line 256 of file CalibDataSvc.cxx.

References Bes_Common::DEBUG, and msgSvc().

{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "Finalizing" << endreq;

  //  return StatusCode::SUCCESS;
  // Finalize the base class
  //  huangb temply delete
   return DataSvc::finalize();
}

void CalibDataSvc::handle

(

const Incident &

)

[virtual]

Inform that a new incident has occured.

Definition at line 296 of file CalibDataSvc.cxx.

References msgSvc().

                                                {
   MsgStream log( msgSvc(), name() );
     return; 
  }

StatusCode CalibDataSvc::initialize

(

)

[virtual]

Definition at line 96 of file CalibDataSvc.cxx.

References calibUtil::ERROR, CalibData::CalibModelSvc::getPairs(), Bes_Common::INFO, m_calibType, m_eventSvc, msgSvc(), CalibData::pairs, and deljobs::string.

                                      {

  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_calibStorageType, 
//                                   pairIt->second,   // class id
//                                     args, iargs, pAddress);
    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;
}

StatusCode CalibDataSvc::loadObject	(	IConversionSvc *	pLoader,
		IRegistry *	pRegistry
	)			[virtual]

Load object. Override DataSvc implementation to get current event time first if necessary

Definition at line 333 of file CalibDataSvc.cxx.

                                                          {
  return DataSvc::loadObject(pLoader, pRegistry);

}

StatusCode CalibDataSvc::makeFlavorNodes	(	IAddressCreator *	calibCreator,
		MsgStream *	log
	)			[private]

Private utility, called from initialize().

Redundant job option to indicate whether or not to check for valid event time when fetching calibrations. There already is a similar thing for CalibMySQLCnvSvc, but no easy way for one service to tell the other about it.

StatusCode CalibDataSvc::queryInterface	(	const InterfaceID &	riid,
		void **	ppvInterface
	)			[virtual]

Query the interface of the service.

Definition at line 267 of file CalibDataSvc.cxx.

References IInstrumentName::interfaceID().

{
  // 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;
}

StatusCode CalibDataSvc::registerObject	(	const std::string &	parentPath,
		const std::string &	objPath,
		DataObject *	pObject
	)			[virtual]

Definition at line 413 of file CalibDataSvc.cxx.

                                                           {
  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;
}
}

StatusCode CalibDataSvc::retrieveObject	(	const std::string &	fullPath,
		DataObject *&	pObject
	)			[virtual]

Definition at line 339 of file CalibDataSvc.cxx.

References CALIBROOT_StorageType, Bes_Common::DEBUG, calibUtil::ERROR, CalibData::CalibBase1::getrunfrm(), CalibData::CalibBase1::getrunto(), Bes_Common::INFO, m_calibType, m_eventSvc, msgSvc(), runNo, and Bes_Common::WARNING.

{  
   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;}
 

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::updateObject

(

DataObject *

toUpdate

)

[virtual]

Update object.

Definition at line 306 of file CalibDataSvc.cxx.

References calibUtil::ERROR, Bes_Common::INFO, and msgSvc().

                                                            {

   
  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::updateRun	(	int &	runfrm,
		int &	runto,
		std::string &	fullPath
	)			[private]

For use of CalibMySQLCnvSvc, to set "use event time mode".

---

Friends And Related Function Documentation

friend class SvcFactory< CalibDataSvc > [friend]

Definition at line 42 of file CalibDataSvc.h.

---

Member Data Documentation

StringArrayProperty CalibDataSvc::m_calibList [private]

calibration types

Definition at line 108 of file CalibDataSvc.h.

Referenced by CalibDataSvc().

std::string CalibDataSvc::m_calibRootName [private]

Name of the root node of the calib store.

Definition at line 105 of file CalibDataSvc.h.

Referenced by CalibDataSvc().

int CalibDataSvc::m_calibType[12] [private]

Calibration Data Persistency Storage type.

Definition at line 102 of file CalibDataSvc.h.

Referenced by CalibDataSvc(), initialize(), and retrieveObject().

IDataProviderSvc* CalibDataSvc::m_eventSvc [private]

Dumping place for various time-fetching methods to save the timestamp.

Definition at line 120 of file CalibDataSvc.h.

Referenced by initialize(), and retrieveObject().

std::vector<std::string> CalibDataSvc::m_flavorList [private]

Definition at line 111 of file CalibDataSvc.h.

Referenced by CalibDataSvc().

---