CalibDataSvc Class Reference

#include <CalibDataSvc.h>

Inheritance diagram for CalibDataSvc:

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 void	handle (const Incident &)
	Query the interface of the service.

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::CalibDataSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Standard Constructor.

Definition at line 47 of file CalibDataSvc.cxx.

                                                                 :
  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 is:::" <<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;  
 
 
 
}

~CalibDataSvc()

CalibDataSvc::~CalibDataSvc ( )

virtual

Standard Destructor.

Definition at line 102 of file CalibDataSvc.cxx.

                             {
  setDataLoader(0);
  clearStore();
}

Member Function Documentation

clearStore()

StatusCode CalibDataSvc::clearStore ( )

virtual

Remove all data objects in the data store.

Definition at line 299 of file CalibDataSvc.cxx.

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

Referenced by ~CalibDataSvc().

finalize()

StatusCode CalibDataSvc::finalize ( )

virtual

Finalize the service.

Definition at line 265 of file CalibDataSvc.cxx.

{
  MsgStream log(msgSvc(), name());
  log << MSG::DEBUG << "Finalizing" << endreq;
 
  //  return StatusCode::SUCCESS;
  // Finalize the base class
  //  huangb temply delete
  return DataSvc::finalize();
}

handle()

void CalibDataSvc::handle ( const Incident & inc )

virtual

Query the interface of the service.

Inform that a new incident has occured

Definition at line 305 of file CalibDataSvc.cxx.

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

initialize()

StatusCode CalibDataSvc::initialize ( )

virtual

Definition at line 108 of file CalibDataSvc.cxx.

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

loadObject()

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

virtual

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

Definition at line 342 of file CalibDataSvc.cxx.

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

registerObject()

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

virtual

Definition at line 430 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;
  }
}

retrieveObject()

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

virtual

Definition at line 348 of file CalibDataSvc.cxx.

{  
  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

updateObject()

StatusCode CalibDataSvc::updateObject ( DataObject * toUpdate )

virtual

Update object.

Definition at line 315 of file CalibDataSvc.cxx.

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

---

The documentation for this class was generated from the following files:

• CalibDataSvc.h
• CalibDataSvc.cxx