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