/// Initialize Particle Gun parameters StatusCode ConstPtParticleGun::initialize() { StatusCode sc = GaudiTool::initialize(); if (!sc.isSuccess()) return sc; IRndmGenSvc* randSvc = svc<IRndmGenSvc>("RndmGenSvc", true); sc = m_flatGenerator.initialize(randSvc, Rndm::Flat(0., 1.)); if (!sc.isSuccess()) return Error("Cannot initialize flat generator"); // check momentum and angles if ((m_minEta > m_maxEta) || (m_minPhi > m_maxPhi)) return Error("Incorrect values for eta or phi!"); m_deltaPhi = m_maxPhi - m_minPhi; m_deltaEta = m_maxEta - m_minEta; // setup particle information m_masses.clear(); auto pd = Pythia8::ParticleData(); info() << "Particle type chosen randomly from :"; PIDs::iterator icode; for (icode = m_pdgCodes.begin(); icode != m_pdgCodes.end(); ++icode) { info() << " " << *icode; m_masses.push_back(pd.m0(*icode)); } info() << endmsg; info() << "Eta range: " << m_minEta << " <-> " << m_maxEta << endmsg; info() << "Phi range: " << m_minPhi / Gaudi::Units::rad << " rad <-> " << m_maxPhi / Gaudi::Units::rad << " rad" << endmsg; return sc; }
/// Initialize virtual StatusCode initialize() { MsgStream log(msgSvc(), name()); StatusCode sc = service("CounterSvc", m_cntSvc, true); if ( !sc.isSuccess() ) { log << MSG::ERROR << "Could not connect to CounterSvc." << endmsg; return sc; } sc = m_cntSvc->create(m_counterBaseName, "EventCount", 1000, m_evtCount); if ( !sc.isSuccess() ) { log << MSG::ERROR << "Could not create counter CounterTest::EventCount." << endmsg; return sc; } m_total = m_cntSvc->create(m_counterBaseName, "TotalCount").counter(); try { m_total = m_cntSvc->create(m_counterBaseName, "TotalCount").counter(); } catch( std::exception& e) { log << MSG::ALWAYS << "Exception: " << e.what() << endmsg; } ICounterSvc::Printout p(m_cntSvc); m_cntSvc->print(m_counterBaseName, "EventCount", p).ignore(); m_cntSvc->print(m_counterBaseName, p).ignore(); // m_cntSvc->create(m_counterBaseName, "Eff1") ; m_cntSvc->create(m_counterBaseName, "Eff2") ; m_cntSvc->create(m_counterBaseName, "Sum") ; return sc ; }
//------------------------------------------------------------------------------ DataObject* HistogramSvc::createDirectory(CSTR parentDir,CSTR subDir) { DataObject* directory = new DataObject(); if (0 != directory) { DataObject* pnode; StatusCode status = DataSvc::retrieveObject(parentDir, pnode); if(status.isSuccess()) { status = DataSvc::registerObject(pnode, subDir, directory); if (!status.isSuccess()) { MsgStream log(msgSvc(), name()); log << MSG::ERROR << "Unable to create the histogram directory: " << parentDir << "/" << subDir << endmsg; delete directory; return 0; } } else { MsgStream log(msgSvc(), name()); log << MSG::ERROR << "Unable to create the histogram directory: " << parentDir << "/" << subDir << endmsg; delete directory; return 0; } } return directory; }
/// Get previous iteration item from the event loop context, but skip jump elements StatusCode EventSelector::previous(Context& refCtxt, int jump) const { EvtSelectorContext *pIt = dynamic_cast<EvtSelectorContext*>(&refCtxt); if ( pIt && jump > 0 ) { StatusCode sc = StatusCode::SUCCESS; for ( int i = 0; i < jump && sc.isSuccess(); ++i ) { const EventSelectorDataStream* s = m_streamtool->getStream(pIt->ID()); Context* it = pIt->context(); IEvtSelector* sel = s->selector(); if ( it && sel ) { // First exploit the current stream // This stream is empty: advance to the next stream sc = sel->previous(*it); // This stream is empty: advance to the next stream if ( !sc.isSuccess() ) { sc = lastOfPreviousStream(true, *pIt); } else { pIt->increaseCounters(false); pIt->set(it, 0); } printEvtInfo(pIt); if ( !sc.isSuccess() ) { return sc; } } pIt->increaseCounters(false); } return sc; } printEvtInfo(pIt); return StatusCode::FAILURE; }
// IEvtSelector::first() StatusCode EventSelector::firstOfNextStream(bool shutDown, EvtSelectorContext& iter) const { StatusCode status = StatusCode::SUCCESS; IDataStreamTool::size_type iter_id = (m_reconfigure) ? 0 : iter.ID()+1; if ( m_reconfigure ) const_cast<EventSelector*>(this)->m_reconfigure = false; if ( shutDown ) { if ( iter.ID() >= 0 && iter.ID() < (long)m_streamtool->size() ) { const EventSelectorDataStream* s = m_streamtool->getStream(iter.ID()); if ( s->isInitialized() ) { EventSelector* thisPtr = const_cast<EventSelector*>(this); if ( s->selector() && iter.context() ) { Context* ctxt = iter.context(); s->selector()->releaseContext(ctxt).ignore(); iter.set(0,0); } status = thisPtr->m_streamtool->finalizeStream(const_cast<EventSelectorDataStream*>(s)); iter.set(0,0); } } } const EventSelectorDataStream* s ; status = m_streamtool->getNextStream( s , iter_id ); if ( status.isSuccess() ) { if(s!=NULL) { if ( !s->isInitialized() ) { EventSelector* thisPtr = const_cast<EventSelector*>(this); status = thisPtr->m_streamtool->initializeStream(const_cast<EventSelectorDataStream*>(s)); } if ( status.isSuccess() ) { const IEvtSelector* sel = s->selector(); if ( sel ) { Context* ctxt = 0; status = sel->createContext(ctxt); if ( status.isSuccess() ) { status = sel->resetCriteria(s->criteria(), *ctxt); if ( status.isSuccess() ) { MsgStream log(msgSvc(), name()); iter.set(this, iter_id, ctxt, 0); log << MSG::INFO << *s << endmsg; m_incidentSvc->fireIncident(Incident(s->dbName(),IncidentType::BeginInputFile)); return StatusCode::SUCCESS; } } } } m_incidentSvc->fireIncident(Incident(s->dbName(),IncidentType::FailInputFile)); } } iter.set(this, -1, 0, 0); status.setChecked(); //m_incidentSvc->fireIncident(Incident(s->dbName(),IncidentType::FailInputFile)); return StatusCode::FAILURE; }
//------------------------------------------------------------------------------ StatusCode HistogramSvc::connectInput(CSTR ident) { MsgStream log (msgSvc(), name()); DataObject* pO = 0; StatusCode status = this->findObject(m_rootName, pO); if (status.isSuccess()) { Tokenizer tok(true); std::string::size_type loc = ident.find(" "); std::string filename, auth, svc = "", typ = ""; std::string logname = ident.substr(0,loc); tok.analyse(ident.substr(loc+1,ident.length()), " ", "", "", "=", "'", "'"); for (Tokenizer::Items::iterator i = tok.items().begin(); i != tok.items().end(); i++) { CSTR tag = (*i).tag(); switch(::toupper(tag[0])) { case 'F': // FILE='<file name>' case 'D': // DATAFILE='<file name>' filename = (*i).value(); break; case 'T': // TYP='<HBOOK,ROOT,OBJY,...>' typ = (*i).value(); break; default: break; } } if (typ.length() > 0) { // Now add the registry entry to the store std::string entryname = m_rootName; entryname += '/'; entryname += logname; GenericAddress* pA = 0; switch(::toupper(typ[0])) { case 'H': pA=new GenericAddress(HBOOK_StorageType,CLID_StatisticsFile, filename,entryname,0,'O'); break; case 'R': pA=new GenericAddress(ROOT_StorageType,CLID_StatisticsFile, filename,entryname,0,'O'); break; } if (0 != pA) { status = registerAddress(pO, logname, pA); if (status.isSuccess()) { log << MSG::INFO << "Added stream file:" << filename << " as " << logname << endmsg; return status; } pA->release(); } } } log << MSG::ERROR << "Cannot add " << ident << " invalid filename!" << endmsg; return StatusCode::FAILURE; }
// Work entry point StatusCode EvtCollectionStream::execute() { StatusCode status = (m_pTupleSvc) ? StatusCode::SUCCESS : StatusCode::FAILURE; if ( status.isSuccess() ) { for ( Items::iterator i = m_itemList.begin(); i != m_itemList.end(); i++ ) { StatusCode iret = m_pTupleSvc->writeRecord((*i)->path()); if ( !iret.isSuccess() ) { status = iret; } } } return status; }
//-------------------------------------------------------------------------------------------- // implementation of IService::reinitialize //-------------------------------------------------------------------------------------------- StatusCode MTEventLoopMgr::reinitialize() { // initilaize the base class StatusCode sc = MinimalEventLoopMgr::reinitialize(); MsgStream log(msgSvc(), name()); if( sc.isFailure() ) { log << MSG::DEBUG << "Error Initializing base class MinimalEventLoopMgr." << endmsg; return sc; } // Check to see whether a new Event Selector has been specified setProperty(m_appMgrProperty->getProperty("EvtSel")); if( m_evtsel != "NONE" || m_evtsel.length() == 0) { IEvtSelector* theEvtSel; IService* theSvc; sc = service( "EventSelector", theEvtSel ); sc = service( "EventSelector", theSvc ); if( sc.isSuccess() && ( theEvtSel != m_evtSelector ) ) { // Setup Event Selector m_evtSelector = theEvtSel; if (theSvc->state() == IService::INITIALIZED) { sc = theSvc->reinitialize(); if( sc.isFailure() ){ log << MSG::ERROR << "Failure Reinitializing EventSelector " << theSvc->name( ) << endmsg; return sc; } } else { sc = theSvc->initialize(); if( sc.isFailure() ){ log << MSG::ERROR << "Failure Initializing EventSelector " << theSvc->name( ) << endmsg; return sc; } } sc = theEvtSel->createContext(m_evtCtxt); if( !sc.isSuccess() ) { log << MSG::ERROR << "Can not create Context " << theSvc->name( ) << endmsg; return sc; } log << MSG::INFO << "EventSelector service changed to " << theSvc->name( ) << endmsg; } } else { m_evtSelector = 0; m_evtCtxt = 0; } return StatusCode::SUCCESS; }
// IEvtSelector::first() StatusCode EventSelector::lastOfPreviousStream(bool shutDown, EvtSelectorContext& iter) const { StatusCode status = StatusCode::SUCCESS; if ( shutDown ) { if ( iter.ID() >= 0 && iter.ID() < (long)m_streamtool->size() ) { const EventSelectorDataStream* s = m_streamtool->getStream(iter.ID()); if ( s->isInitialized() ) { EventSelector* thisPtr = const_cast<EventSelector*>(this); if ( s->selector() && iter.context() ) { Context* ctxt = iter.context(); s->selector()->releaseContext(ctxt); iter.set(0,0); } status = thisPtr->m_streamtool->finalizeStream(const_cast<EventSelectorDataStream*>(s)); iter.set(0,0); } } } IDataStreamTool::size_type iter_id = iter.ID()-1; const EventSelectorDataStream* s ; status = m_streamtool->getPreviousStream( s , iter_id ); if ( status.isSuccess() ) { if ( !s->isInitialized() ) { EventSelector* thisPtr = const_cast<EventSelector*>(this); status = thisPtr->m_streamtool->initializeStream(const_cast<EventSelectorDataStream*>(s)); } if ( status.isSuccess() ) { const IEvtSelector* sel = s->selector(); if ( sel ) { Context* ctxt = 0; status = sel->createContext(ctxt); if ( status.isSuccess() ) { status = sel->resetCriteria(s->criteria(), *ctxt); if ( status.isSuccess() ) { MsgStream log(msgSvc(), name()); iter.set(this, iter_id, ctxt, 0); log << MSG::INFO << *s << endmsg; return StatusCode::SUCCESS; } } } } } iter.set(this, -1, 0, 0); return StatusCode::FAILURE; }
// IService::sysInitialize StatusCode Service::sysInitialize() { StatusCode sc; try { m_targetState = Gaudi::StateMachine::INITIALIZED; Gaudi::Guards::AuditorGuard guard(this, // check if we want to audit the initialize (m_auditorInitialize) ? auditorSvc().get() : 0, IAuditor::Initialize); if ((name() != "MessageSvc") && msgSvc().isValid()) // pre-set the outputLevel from the MessageSvc value m_outputLevel = msgSvc()->outputLevel(name()); sc = initialize(); // This should change the state to Gaudi::StateMachine::CONFIGURED if (sc.isSuccess()) m_state = m_targetState; return sc; } catch ( const GaudiException& Exception ) { fatal() << "in sysInitialize(): exception with tag=" << Exception.tag() << " is caught" << endmsg; error() << Exception << endmsg; // Stat stat( chronoSvc() , Exception.tag() ); } catch( const std::exception& Exception ) { fatal() << "in sysInitialize(): standard std::exception is caught" << endmsg; error() << Exception.what() << endmsg; // Stat stat( chronoSvc() , "*std::exception*" ); } catch(...) { fatal() << "in sysInitialize(): UNKNOWN Exception is caught" << endmsg; // Stat stat( chronoSvc() , "*UNKNOWN Exception*" ) ; } return StatusCode::FAILURE; }
//============================================================================= // Initialization //============================================================================= StatusCode PatPixelHitManager::initialize() { m_event_number = 0; m_max_hits = 0; StatusCode sc = GaudiTool::initialize(); // must be executed first if ( sc.isFailure() ) return sc; // error printed already by GaudiAlgorithm if ( msgLevel(MSG::DEBUG) ) debug() << "==> Initialize" << endmsg; m_veloPix = getDet<DeVeloPix>( DeVeloPixLocation::Default ); // make sure we are up-to-date on populated VELO stations registerCondition( (*(m_veloPix->leftSensorsBegin()))->geometry(), &PatPixelHitManager::rebuildGeometry ); registerCondition( (*(m_veloPix->rightSensorsBegin()))->geometry(), &PatPixelHitManager::rebuildGeometry ); // first update sc = updMgrSvc()->update(this); if(!sc.isSuccess()) { return Error( "Failed to update station structure." ); } // invalidate measurements at the beginning of each event incSvc()->addListener(this, IncidentType::BeginEvent); m_pool.resize( 10000 ); m_nextInPool = m_pool.begin(); m_maxSize = 0; m_eventReady = false; return StatusCode::SUCCESS; }
// ============================================================================ StatusCode Tuples::TupleObj::fill( const char* format ... ) { // check the underlying tuple if ( invalid() ) { return InvalidTuple ; } // decode format string into tokens Tokens tokens ; tokenize( format , tokens , " ,;" ); if ( tokens.empty() ) { return StatusCode::SUCCESS ; } /// decode arguments va_list valist ; va_start( valist , format ) ; // loop over all tokens StatusCode status = StatusCode::SUCCESS ; for( Tokens::const_iterator token = tokens.begin() ; tokens.end() != token && status.isSuccess() ; ++token ) { const double val = va_arg( valist , double ); status = column( *token , val ); if( status.isFailure() ) { Error ( "fill(): Can not add column '" + *token + "' " ) ; } } // mandatory !!! va_end( valist ); // return status ; }
//----------------------------------------------------------------------------- /// Switch to object directory (=Parent directory) TDirectory* RootHistCnv::RConverter::changeDirectory(DataObject* pObject) //----------------------------------------------------------------------------- { if ( pObject ) { IRegistry* pReg = pObject->registry(); if ( pReg ) { SmartIF<IDataManagerSvc> dataMgr(dataProvider()); if ( dataMgr.isValid() ) { IRegistry* pParentReg = 0; StatusCode status = dataMgr->objectParent(pReg, pParentReg); if ( status.isSuccess() ) { IOpaqueAddress* pParAddr = pParentReg->address(); if ( pParAddr ) { TDirectory* pParentDir = (TDirectory*)pParAddr->ipar()[0]; if ( pParentDir ) { gDirectory->cd(pParentDir->GetPath()); return pParentDir; } } } } } } return 0; }
//------------------------------------------------------------------------------ DataObject* HistogramSvc::createPath(CSTR newPath) { std::string tmpPath = newPath; if (tmpPath[0] != SEPARATOR) { tmpPath.insert(tmpPath.begin(), SEPARATOR); tmpPath.insert(tmpPath.begin(), m_rootName.begin(), m_rootName.end()); } // Remove trailing "/" from newPath if it exists if (tmpPath.rfind(SEPARATOR) == tmpPath.length()-1) { tmpPath.erase(tmpPath.rfind(SEPARATOR),1); } DataObject* pObject = 0; StatusCode sc = DataSvc::findObject(tmpPath, pObject); if(sc.isSuccess()) { return pObject; } int sep = tmpPath.rfind(SEPARATOR); std::string rest(tmpPath, sep+1, tmpPath.length()-sep); std::string subPath(tmpPath, 0, sep); if(0 != sep) { createPath(subPath); } else { MsgStream log(msgSvc(), name()); log << MSG::ERROR << "Unable to create the histogram path" << endmsg; return 0; } pObject = createDirectory(subPath, rest); return pObject; }
/// IService implementation: Db event selector override StatusCode StagedIODataManager::initialize() { // Initialize base class StatusCode status = Service::initialize(); MsgStream log(msgSvc(), name()); log << MSG::DEBUG << "StagedIODataManager initializing..." << endmsg; if ( !status.isSuccess() ) { log << MSG::ERROR << "Error initializing base class Service!" << endmsg; return status; } // Retrieve conversion service handling event iteration m_catalog = serviceLocator()->service(m_catalogSvcName); if( !m_catalog.isValid() ) { log << MSG::ERROR << "Unable to localize interface IFileCatalog from service:" << m_catalogSvcName << endmsg; return StatusCode::FAILURE; } m_incSvc = serviceLocator()->service("IncidentSvc"); if( !m_incSvc.isValid() ) { log << MSG::ERROR << "Error initializing IncidentSvc Service!" << endmsg; return status; } m_stager = serviceLocator()->service("FileStagerSvc", false); if( !m_stager.isValid() ) { log << MSG::ERROR << "Error initializing File Stager Service!" << endmsg; return status; } return status; }
StatusCode StatusCodeSvc::initialize() { StatusCode sc = Service::initialize(); if (!sc.isSuccess()) return sc; MsgStream log( msgSvc(), name() ); log << MSG::INFO << "initialize" << endmsg; std::vector<std::string>::const_iterator itr; for (itr = m_pFilter.value().begin(); itr != m_pFilter.value().end(); ++itr) { // we need to do this if someone has gotten to regFnc before initialize string fnc,lib; parseFilter(*itr,fnc,lib); if (fnc != "") { filterFnc(fnc); m_filterfnc.insert(fnc); } if (lib != "") { filterLib(lib); m_filterlib.insert(lib); } } return StatusCode::SUCCESS; }
// IService::sysStart StatusCode Service::sysStart() { StatusCode sc; try { m_targetState = Gaudi::StateMachine::ChangeState(Gaudi::StateMachine::START,m_state); Gaudi::Guards::AuditorGuard guard(this, // check if we want to audit the initialize (m_auditorStart) ? auditorSvc().get() : 0, IAuditor::Start); sc = start(); if (sc.isSuccess()) m_state = m_targetState; return sc; } catch ( const GaudiException& Exception ) { fatal() << "in sysStart(): exception with tag=" << Exception.tag() << " is caught" << endmsg; error() << Exception << endmsg; // Stat stat( chronoSvc() , Exception.tag() ); } catch( const std::exception& Exception ) { fatal() << "in sysStart(): standard std::exception is caught" << endmsg; fatal() << Exception.what() << endmsg; // Stat stat( chronoSvc() , "*std::exception*" ); } catch(...) { fatal() << "in sysStart(): UNKNOWN Exception is caught" << endmsg; // Stat stat( chronoSvc() , "*UNKNOWN Exception*" ) ; } return StatusCode::FAILURE; }
/// Add data service StatusCode PersistencySvc::addCnvService(IConversionSvc* servc) { if ( 0 != servc ) { long type = servc->repSvcType(); long def_typ = (m_cnvDefault) ? m_cnvDefault->repSvcType() : 0; Services::iterator it = m_cnvServices.find( type ); IConversionSvc* cnv_svc = 0; if ( it != m_cnvServices.end() ) { cnv_svc = (*it).second.conversionSvc(); } if ( type == def_typ ) { m_cnvDefault = servc; } if ( cnv_svc != servc ) { IAddressCreator* icr = 0; StatusCode status = servc->queryInterface(IAddressCreator::interfaceID(), pp_cast<void>(&icr)); if ( status.isSuccess() ) { IService* isvc = 0; status = servc->queryInterface(IService::interfaceID(), pp_cast<void>(&isvc)); if ( status.isSuccess() ) { if ( 0 != cnv_svc ) { removeCnvService (type).ignore(); } std::pair<Services::iterator, bool> p = m_cnvServices.insert( Services::value_type( type, ServiceEntry(type, isvc, servc, icr))); if( p.second ) { info() << "Added successfully Conversion service:" << isvc->name() << endmsg; servc->addRef(); servc->setAddressCreator(this).ignore(); servc->setDataProvider(m_dataSvc).ignore(); return StatusCode::SUCCESS; } info() << "Cannot add Conversion service of type " << isvc->name() << endmsg; isvc->release(); icr->release(); return StatusCode::FAILURE; } icr->release(); } info() << "Cannot add Conversion service of type " << type << endmsg; return StatusCode::FAILURE; } else { return StatusCode::SUCCESS; } } return BAD_STORAGE_TYPE; }
//------------------------------------------------------------------------------ StatusCode HistogramSvc::initialize() { MsgStream log(msgSvc(), name()); StatusCode status = DataSvc::initialize(); // Set root object if (status.isSuccess()) { DataObject* rootObj = new DataObject(); status = setRoot("/stat", rootObj); if (!status.isSuccess()) { log << MSG::ERROR << "Unable to set hstogram data store root." << endmsg; delete rootObj; return status; } IConversionSvc* svc = 0; status = service("HistogramPersistencySvc",svc,true); if ( status.isSuccess() ) { setDataLoader( svc ).ignore(); svc->release(); } else { log << MSG::ERROR << "Could not find HistogramPersistencySvc." << endmsg; return status; } // Connect all input streams (if any) for (DBaseEntries::iterator j = m_input.begin(); j != m_input.end(); j++) { status = connectInput(*j); if (!status.isSuccess()) { return status; } } } if ( !m_defs1D.empty() ) { log << MSG::INFO << " Predefined 1D-Histograms: " << endmsg ; for ( Histo1DMap::const_iterator ih = m_defs1D.begin() ; m_defs1D.end() != ih ; ++ih ) { log << MSG::INFO << " Path='" << ih->first << "'" << " Description " << ih->second << endmsg ; } } return status; }
// Initialize engine template <class TYPE> StatusCode Engine<TYPE>::initialize() { m_seeds.erase(m_seeds.begin(), m_seeds.end()); StatusCode status = RndmEngine::initialize(); if ( m_seeds.size() == 0 ) { // Default seeds long theSeed = 1234567; m_seeds.push_back(theSeed); m_seeds.push_back(0); } MsgStream log(msgSvc(), name()); if ( status.isSuccess() ) { status = initializeEngine(); if ( status.isSuccess() ) { log << MSG::INFO << "Generator engine type:" << System::typeinfoName(typeid(TYPE)) << endmsg; if ( m_useTable ) { if ( m_row > 214 || m_col > 1 ) { log << MSG::ERROR << "Generator engine seed table has dimension [215][2], you gave:" << " Row=" << m_row << " Column:" << m_col << endmsg; status = StatusCode::FAILURE; } else { log << MSG::INFO << "Generator engine seeds from table." << " Row=" << m_row << " Column:" << m_col << endmsg; } } log << "Current Seed:" << m_hepEngine->getSeed(); log << " Luxury:" << m_lux; log << endmsg; // Use the default static engine if required (e.g. for GEANT4) if ( m_setSingleton ) { HepRandom::setTheEngine(m_hepEngine); log << "This is the GEANT4 engine!" << endmsg; } return status; } } log << MSG::ERROR << "Cannot initialze random engine of type:" << System::typeinfoName(typeid(TYPE)) << endmsg; return status; }
/// Create event address using event selector StatusCode MTEventLoopMgr::getEventRoot(IOpaqueAddress*& refpAddr) { refpAddr = 0; StatusCode sc = m_evtSelector->next(*m_evtCtxt); if ( !sc.isSuccess() ) { return sc; } // Create root address and assign address to data service sc = m_evtSelector->createAddress(*m_evtCtxt,refpAddr); if( !sc.isSuccess() ) { sc = m_evtSelector->next(*m_evtCtxt); if ( sc.isSuccess() ) { sc = m_evtSelector->createAddress(*m_evtCtxt,refpAddr); if ( !sc.isSuccess() ) { MsgStream log( msgSvc(), name() ); log << MSG::WARNING << "Error creating IOpaqueAddress." << endmsg; } } } return sc; }
StatusCode RecordStream::finalize() { MsgStream log(msgSvc(), name()); log << MSG::INFO << "Set up File Summary Record" << endmsg; if( !m_fireIncidents && log.level() <= MSG::VERBOSE ) log << MSG::VERBOSE << "will not fire incidents" << endmsg; StatusCode sc = OutputStream::execute(); if( !sc.isSuccess() ) { log << MSG::WARNING << "Error writing run summary record....." << endmsg; } return OutputStream::finalize(); }
// IService implementation: initialize the service StatusCode AppMgrRunable::initialize() { StatusCode sc = Service::initialize(); if ( sc.isSuccess() ) { sc = serviceLocator()->queryInterface(IAppMgrUI::interfaceID(), pp_cast<void>(&m_appMgrUI)); // get property from application manager if ( m_evtMax == (int)0xFEEDBABE ) { SmartIF<IProperty> props(serviceLocator()); setProperty(props->getProperty("EvtMax")).ignore(); } } return sc; }
//============================================================================= // Initialisation //============================================================================= StatusCode TbPacketRecycler::initialize() { // Initialise the base class. StatusCode sc = TbAlgorithm::initialize(); if (sc.isFailure()) return sc; IToolSvc* toolsvc = nullptr; sc = service("ToolSvc", toolsvc); if (!sc.isSuccess()) { return Error("Unable to get a handle to the tool service", sc); } for (unsigned int i = 0; i < m_nPlanes; ++i) { TbRawStream* foo = nullptr; sc = toolSvc()->retrieveTool("TbRawStream/" + std::to_string(i), foo); if (!sc.isSuccess()) { return Error("Unable to retrieve TbRawStream for plane " + std::to_string(i), sc); } m_streams.push_back(foo); } return StatusCode::SUCCESS; }
//============================================================================= StatusCode InputStreamParser::initialize() { MsgStream logger(msgSvc(), name()); StatusCode status = AlgTool::initialize(); if( !status.isSuccess() ) { logger << MSG::FATAL << "Error. Cannot initialize base class." << endmsg; return status; } return StatusCode::SUCCESS; }
//==================================================== StatusCode InputStreamParser::extractStreams(const StreamSpecs & inputs, StreamSpecs & parsedInputs) { m_inCollection = & parsedInputs; StatusCode sc = StatusCode::FAILURE; MsgStream log(msgSvc(), name()); for ( std::vector<std::string>::const_iterator itr = inputs.begin(); itr != inputs.end(); ++itr ) { sc = extractStream(*itr); if (!sc.isSuccess()) { log << MSG::ERROR << " Could not access the file(s). " << endmsg; ::abort(); } } return sc; }
/// Get next iteration item from the event loop context, but skip jump elements StatusCode EventSelector::next(Context& refCtxt, int /* jump */ ) const { EvtSelectorContext *pIt = dynamic_cast<EvtSelectorContext*>(&refCtxt); if ( pIt ) { if ( pIt->ID() != -1 ) { const EventSelectorDataStream* s = m_streamtool->getStream(pIt->ID()); Context* it = pIt->context(); IEvtSelector* sel = s->selector(); if ( it && sel ) { // First exploit the current stream StatusCode sc = sel->next(*it); // This stream is empty: advance to the next stream if ( !sc.isSuccess() ) { m_incidentSvc->fireIncident(Incident(s->dbName(),IncidentType::EndInputFile)); sc = firstOfNextStream(true, *pIt); if (sc.isSuccess() ) sc = next(*pIt); } else { pIt->increaseCounters(false); pIt->set(it, 0); printEvtInfo(pIt); } return sc; } else if ( m_reconfigure ) { StatusCode sc = firstOfNextStream(false, *pIt); printEvtInfo(pIt); return sc; } } else if ( m_reconfigure ) { StatusCode sc = firstOfNextStream(false, *pIt); printEvtInfo(pIt); return sc; } pIt->increaseCounters(false); } printEvtInfo(pIt); return StatusCode::FAILURE; }
/// IService implementation: Db event selector override StatusCode EventSelector::initialize() { // Initialize base class StatusCode status = Service::initialize(); MsgStream logger(msgSvc(), name()); if ( !status.isSuccess() ) { logger << MSG::ERROR << "Error initializing base class Service!" << endmsg; return status; } // Get the references to the services that are needed by the ApplicationMgr itself m_incidentSvc = serviceLocator()->service("IncidentSvc"); if( !m_incidentSvc.isValid() ) { logger << MSG::FATAL << "Error retrieving IncidentSvc." << endmsg; return StatusCode::FAILURE; } if ( m_evtMax != INT_MAX ) { logger << MSG::ERROR << "EvtMax is an obsolete property of the event selector." << endmsg; logger << MSG::ERROR << "Please set \"ApplicationMgr.EvtMax = " << m_evtMax << ";\" to process the requested number of events." << endmsg; return StatusCode::FAILURE; } m_toolSvc = serviceLocator()->service("ToolSvc"); if ( !m_toolSvc.isValid() ) { logger << MSG::ERROR << " Could not locate the Tool Service! " << endmsg; return StatusCode::FAILURE; } status = m_toolSvc->retrieveTool(m_streamManager.c_str(), m_streamtool, this); if( status.isFailure() ) { logger << MSG::ERROR << "Error initializing " << m_streamManager << endmsg; return status; } status = m_streamtool->clear(); if( status.isFailure() ) { // Message already printed by the tool return status; } status = m_streamtool->addStreams(m_streamSpecs); m_streamSpecsLast = m_streamSpecs; m_streamID = 0; return status; }
StatusCode ServiceLocatorHelper::createService(const std::string& name, const InterfaceID& iid, void** ppSvc) const { SmartIF<IService> theSvc = service(name, false, true); if (!theSvc.isValid()) return StatusCode::FAILURE; StatusCode sc = theSvc->queryInterface(iid, ppSvc); if (!sc.isSuccess()) { *ppSvc = 0; log() << MSG::ERROR << "ServiceLocatorHelper::createService: wrong interface id " << iid << " for service " << name << endmsg; } return sc; }
//-------------------------------------------------------------------------- StatusCode RootHistCnv::RConverter::createAddress(const std::string& rzdir, const CLID& clid, long id, TObject* pTobj, IOpaqueAddress*& refpAddress) //-------------------------------------------------------------------------- { std::ostringstream obj; obj << id; StatusCode status = createAddress(rzdir, clid, obj.str(), pTobj, refpAddress); if ( status.isSuccess() ) { unsigned long* ipar = (unsigned long*)refpAddress->ipar(); ipar[0] = id; } return status; }