// ============================================================================
StatusCode GslErrorPrint::handle
( const GslError& error ) const
{
MsgStream log( msgSvc() , name() );
log << MSG::ERROR
<< " GSL code " << error.code
<< " Message '" << error.reason << "'"
<< " File '" << error.file << "'"
<< " Line " << error.line << endmsg ;
//
return StatusCode::SUCCESS ;
}
//-----------------------------------------------------------------------------
StatusCode RootHistCnv::PersSvc::finalize()
//-----------------------------------------------------------------------------
{
// Close ROOT only if the output file name is defined
MsgStream log( msgSvc(), name() );
log << MSG::DEBUG << "RootHistCnv::PersSvc::finalize()" << endmsg;
if( undefFileName != m_defFileName ) {
m_hfile->Write("",TObject::kOverwrite);
m_hfile->Close();
}
return ConversionSvc::finalize();
}
//--------------------------------------------------------------------------------------------
// 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;
}
//=============================================================================
// Check if a given LHCbID is associated to the MCParticle of the specified key
//=============================================================================
bool PrPixelDebugTool::matchKey(LHCb::LHCbID id, int key) {
LinkedTo<LHCb::MCParticle> vLink(evtSvc(), msgSvc(),
LHCb::VPClusterLocation::Default);
LHCb::VPChannelID idV = id.vpID();
LHCb::MCParticle* part = vLink.first(idV);
while (part) {
if (key == part->key()) return true;
part = vLink.next();
}
return false;
}
//=========================================================================
// Check if a given LHCbID is associated to the MCParticle of the specified key
//=========================================================================
bool PrTStationDebugTool::matchKey ( LHCb::LHCbID id, int key ) {
if ( id.isOT() ) {
LinkedTo<LHCb::MCParticle> oLink( evtSvc(), msgSvc(), LHCb::OTTimeLocation::Default );
LHCb::OTChannelID idO = id.otID();
LHCb::MCParticle* part = oLink.first( idO );
while ( 0 != part ) {
if ( key == part->key() ) return true;
part = oLink.next();
}
} else if ( id.isFT() ) {
LinkedTo<LHCb::MCParticle> fLink( evtSvc(), msgSvc(), LHCb::FTClusterLocation::Default );
LHCb::FTChannelID idO = id.ftID();
LHCb::MCParticle* part = fLink.first( idO );
while ( 0 != part ) {
if ( key == part->key() ) return true;
part = fLink.next();
}
}
return false;
}
StatusCode
FileMgrTest::allCloseAction(const Io::FileAttr* fa, const std::string& c) {
MsgStream log(msgSvc(), name());
log << MSG::INFO << "AllCloseAction called by " << c << " for tech "
<< fa->tech() << " on " << fa
<< endmsg;
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 MyAlgorithm::finalize() {
//------------------------------------------------------------------------------
MsgStream log(msgSvc(), name());
log << MSG::INFO << "finalizing...." << endmsg;
toolSvc()->releaseTool( m_publicTool ).ignore();
toolSvc()->releaseTool( m_privateTool ).ignore();
toolSvc()->releaseTool( m_publicGTool ).ignore();
toolSvc()->releaseTool( m_privateGTool ).ignore();
toolSvc()->releaseTool( m_privateToolWithName ).ignore();
toolSvc()->releaseTool( m_privateOtherInterface ).ignore();
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;
}
// Progress report
void EventSelector::printEvtInfo(const EvtSelectorContext* iter) const {
if ( 0 != iter ) {
long count = iter->numEvent();
// Print an message every m_evtPrintFrequency events
if ( 0 == iter->context() ) {
MsgStream log(msgSvc(), name());
log << MSG::INFO << "End of event input reached." << endmsg;
}
else if( iter->numStreamEvent() == -1 ) {
// Intial value for this stream
}
else if( m_evtPrintFrequency != -1 && (count % m_evtPrintFrequency == 0)) {
MsgStream log(msgSvc(), name());
log << MSG::ALWAYS << "Reading Event record " << count+1
<< ". Record number within stream " << iter->ID()+1
<< ": " << iter->numStreamEvent()+1 << endmsg;
}
}
else {
MsgStream log(msgSvc(), name());
log << MSG::INFO << "End of event input reached." << endmsg;
}
}
// 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;
}
//------------------------------------------------------------------------------
StatusCode MyAlgorithm::execute() {
//------------------------------------------------------------------------------
MsgStream log( msgSvc(), name() );
log << MSG::INFO << "executing...." << endmsg;
m_publicTool->doIt();
m_privateTool->doIt();
m_publicGTool->doIt();
m_privateGTool->doIt();
m_privateToolWithName->doIt();
m_privateOtherInterface->doItAgain();
return StatusCode::SUCCESS;
}
/// Service initialisation
virtual STATUS initialize() {
// Nothing to do: just call base class initialisation
STATUS sc = Service::initialize();
if ( !sc.isSuccess() ) {
return sc;
}
sc = makePartitions();
if (!sc.isSuccess()) {
MsgStream log(msgSvc(), name());
log << MSG::ERROR << "Failed to connect to all store partitions." << endmsg;
return sc;
}
return attachServices();
}
//=========================================================================
// Print the list of MCParticle keys associated to the specified LHCbID
//=========================================================================
void PrTStationDebugTool::printKey( MsgStream& msg, LHCb::LHCbID id ) {
if ( id.isOT() ) {
LinkedTo<LHCb::MCParticle> oLink( evtSvc(), msgSvc(), LHCb::OTTimeLocation::Default );
LHCb::OTChannelID idO = id.otID();
LHCb::MCParticle* part = oLink.first( idO );
if ( 0 != part ) msg << " MC:";
while ( 0 != part ) {
msg << " " << part->key();
part = oLink.next();
}
} else if ( id.isFT() ) {
LinkedTo<LHCb::MCParticle> fLink( evtSvc(), msgSvc(), LHCb::FTClusterLocation::Default );
LHCb::FTChannelID idO = id.ftID();
LHCb::MCParticle* part = fLink.first( idO );
if ( 0 != part ) msg << " MC:";
while ( 0 != part ) {
msg << " " << part->key();
part = fLink.next();
}
}
}
/// 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;
}
void DataSvcFileEntriesTool::handle(const Incident& incident) {
// Get the file id of the root node at every event
IOpaqueAddress *addr = i_getRootNode()->address();
if (addr)
m_initialBase = addr->par()[0];
else
m_initialBase.clear(); // use empty file id if there is no address
m_leaves.clear();
if (m_scanOnBeginEvent) {
MsgStream log(msgSvc(), name());
log << MSG::VERBOSE << "::handle scanning on " << incident.type() << endmsg;
i_collectLeaves();
}
}
/// Finalize
virtual StatusCode finalize()
{
MsgStream log(msgSvc(), name());
ICounterSvc::Printout p(m_cntSvc);
log << MSG::INFO << "Single counter:CounterTest::EventCount" << endmsg;
m_cntSvc->print(m_counterBaseName, "EventCount", p).ignore();
log << MSG::INFO << "Counter group: CounterTest" << endmsg;
m_cntSvc->print(m_counterBaseName, p).ignore();
m_cntSvc->remove(m_counterBaseName, "EventCount").ignore();
log << MSG::INFO << "After removal CounterTest::EventCount:" << endmsg;
m_cntSvc->print(p).ignore();
if ( m_cntSvc ) m_cntSvc->release();
m_cntSvc = 0;
return StatusCode::SUCCESS;
}
//------------------------------------------------------------------------------
StatusCode MyAlgorithm::initialize() {
//------------------------------------------------------------------------------
MsgStream log(msgSvc(), name());
StatusCode sc;
log << MSG::INFO << "initializing...." << endmsg;
sc = toolSvc()->retrieveTool(m_toolName, m_tool, this );
if( sc.isFailure() ) {
log << MSG::ERROR<< "Error retrieving the tool" << endmsg;
return sc;
}
log << MSG::INFO << "....initialization done" << endmsg;
return StatusCode::SUCCESS;
}
// Re-initialize
StatusCode EventSelector::reinitialize() {
if ( FSMState() != Gaudi::StateMachine::INITIALIZED ) {
MsgStream logger(msgSvc(), name());
logger << MSG::ERROR << "Cannot reinitialize: service not in state initialized" << endmsg;
return StatusCode::FAILURE;
}
if( m_streamSpecsLast != m_streamSpecs ) {
StatusCode status = m_streamtool->clear();
if ( status.isFailure() ) return status;
m_streamSpecsLast = m_streamSpecs;
m_reconfigure = true;
return m_streamtool->addStreams(m_streamSpecs);
}
return StatusCode::SUCCESS;
}
//------------------------------------------------------------------------------
StatusCode MyAlgorithm::initialize() {
//------------------------------------------------------------------------------
MsgStream log(msgSvc(), name());
StatusCode sc;
log << MSG::INFO << "initializing...." << endmsg;
sc = toolSvc()->retrieveTool("MyTool", m_publicTool );
if( sc.isFailure() ) {
log << MSG::ERROR<< "Error retrieving the public tool" << endmsg;
return sc;
}
sc = toolSvc()->retrieveTool("MyTool", m_privateTool, this );
if( sc.isFailure() ) {
log << MSG::ERROR<< "Error retrieving the private tool" << endmsg;
return sc;
}
sc = toolSvc()->retrieveTool("MyGaudiTool", m_publicGTool );
if( sc.isFailure() ) {
log << MSG::ERROR<< "Error retrieving the Gaudi public tool" << endmsg;
return sc;
}
sc = toolSvc()->retrieveTool("MyGaudiTool", m_privateGTool, this );
if( sc.isFailure() ) {
log << MSG::ERROR<< "Error retrieving the Gaudi private tool" << endmsg;
return sc;
}
sc = toolSvc()->retrieveTool(m_privateToolType, "ToolWithName",
m_privateToolWithName, this );
if( sc.isFailure() ) {
log << MSG::ERROR<< "Error retrieving the private tool with name" << endmsg;
return sc;
}
sc = toolSvc()->retrieveTool("MyGaudiTool", m_privateOtherInterface, this );
if( sc.isFailure() ) {
log << MSG::ERROR << "Error retrieving the Gaudi private tool with second interface" << endmsg;
return sc;
}
log << MSG::INFO << "....initialization done" << endmsg;
return StatusCode::SUCCESS;
}
// Add item to output streamer list
void EvtCollectionStream::addItem(const std::string& descriptor) {
MsgStream log(msgSvc(), name());
int sep = descriptor.rfind("#");
int level = 0;
std::string obj_path (descriptor,0,sep);
std::string slevel (descriptor,sep+1,descriptor.length());
if ( slevel == "*" ) {
level = 9999999;
}
else {
level = ::atoi(slevel.c_str());
}
DataStoreItem* item = new DataStoreItem(obj_path, level);
log << MSG::INFO << "Adding OutputStream item " << item->path()
<< " with " << item->depth()
<< " level(s)." << endmsg;
m_itemList.push_back( item );
}
//------------------------------------------------------------------------------
StatusCode StopperAlg::execute() {
//------------------------------------------------------------------------------
MsgStream log( msgSvc(), name() );
static int count = 0;
if ( ++count >= m_stopcount ) {
log << MSG::INFO << "scheduling a event processing stop...." << endmsg;
IEventProcessor* evt = svc<IEventProcessor>("ApplicationMgr");
if (evt->stopRun().isFailure()) {
log << MSG::ERROR << "unable to issue a stopRun to the EventProcessor"
<< endmsg;
return StatusCode::FAILURE;
}
evt->release();
}
return StatusCode::SUCCESS;
}
static DD4hep::Geometry::Ref_t createCaloDiscs(DD4hep::Geometry::LCDD& aLcdd,
DD4hep::XML::Handle_t aXmlElement,
DD4hep::Geometry::SensitiveDetector aSensDet) {
ServiceHandle<IMessageSvc> msgSvc("MessageSvc", "CalDiscsConstruction");
MsgStream lLog(&(*msgSvc), "CalDiscsConstruction");
DD4hep::XML::DetElement xmlDetElem = aXmlElement;
std::string nameDet = xmlDetElem.nameStr();
int idDet = xmlDetElem.id();
DD4hep::XML::Dimension dim(xmlDetElem.dimensions());
DD4hep::Geometry::DetElement caloDetElem(nameDet, idDet);
// Create air envelope for the whole endcap
DD4hep::Geometry::Cone envelopePositive(dim.dz(), dim.rmin1(), dim.rmax(), dim.rmin2(), dim.rmax());
DD4hep::Geometry::Cone envelopeNegative(dim.dz(), dim.rmin2(), dim.rmax(), dim.rmin1(), dim.rmax());
DD4hep::Geometry::UnionSolid envelopeShape(envelopePositive, envelopeNegative,
DD4hep::Geometry::Position(0, 0, -2 * dim.z_offset()));
DD4hep::Geometry::Volume envelopeVol(nameDet + "_vol", envelopeShape, aLcdd.material("Air"));
DD4hep::Geometry::Volume envelopePositiveVol(nameDet + "_positive_vol", envelopePositive, aLcdd.material("Air"));
DD4hep::Geometry::Volume envelopeNegativeVol(nameDet + "_negative_vol", envelopeNegative, aLcdd.material("Air"));
lLog << MSG::DEBUG << "Placing dector on the positive side: (cm) " << dim.z_offset() << endmsg;
buildOneSide(lLog, aLcdd, aSensDet, envelopePositiveVol, aXmlElement, 1);
lLog << MSG::DEBUG << "Placing dector on the negative side: (cm) " << -dim.z_offset() << endmsg;
buildOneSide(lLog, aLcdd, aSensDet, envelopeNegativeVol, aXmlElement, -1);
// Place the envelope
DD4hep::Geometry::PlacedVolume envelopePositivePhysVol = envelopeVol.placeVolume(envelopePositiveVol);
envelopePositivePhysVol.addPhysVolID("subsystem", 0);
DD4hep::Geometry::DetElement caloPositiveDetElem(caloDetElem, "positive", 0);
caloPositiveDetElem.setPlacement(envelopePositivePhysVol);
DD4hep::Geometry::PlacedVolume envelopeNegativePhysVol =
envelopeVol.placeVolume(envelopeNegativeVol, DD4hep::Geometry::Position(0, 0, -2 * dim.z_offset()));
envelopeNegativePhysVol.addPhysVolID("subsystem", 1);
DD4hep::Geometry::DetElement caloNegativeDetElem(caloDetElem, "negative", 0);
caloNegativeDetElem.setPlacement(envelopeNegativePhysVol);
DD4hep::Geometry::Volume motherVol = aLcdd.pickMotherVolume(caloDetElem);
DD4hep::Geometry::PlacedVolume envelopePhysVol =
motherVol.placeVolume(envelopeVol, DD4hep::Geometry::Position(0., 0., dim.z_offset()));
caloDetElem.setPlacement(envelopePhysVol);
envelopePhysVol.addPhysVolID("system", idDet);
return caloDetElem;
}
/// Rewind the dataset
StatusCode EventSelector::rewind(Context& refCtxt) const {
EvtSelectorContext *ctxt = dynamic_cast<EvtSelectorContext*>(&refCtxt);
if ( ctxt ) {
ctxt->set(0, -1, 0, 0);
firstOfNextStream(true, *ctxt);
long nskip = m_firstEvent;
while( --nskip > 0 ) {
StatusCode sc = next(*ctxt);
if ( sc.isFailure() ) {
MsgStream log(msgSvc(), name());
log << MSG::ERROR << "rewind() failed to start with event number "
<< m_firstEvent << endmsg;
return StatusCode::FAILURE;
}
}
return StatusCode::SUCCESS;
}
return StatusCode::FAILURE;
}
//------------------------------------------------------------------------------
StatusCode HelloWorld::initialize() {
//------------------------------------------------------------------------------
// avoid calling initialize more than once
if( m_initialized ) return StatusCode::SUCCESS;
MsgStream log(msgSvc(), name());
log << MSG::INFO << "initializing...." << endmsg;
IntegerProperty m_int;
DoubleProperty m_double;
StringProperty m_string;
declareInfo("int_value",t_int, "description");
declareInfo("double_value",t_double, "description");
declareInfo("string_value",t_string, "description");
m_initialized = true;
return StatusCode::SUCCESS;
}
// initialize data writer
StatusCode EvtCollectionStream::initialize() {
MsgStream log(msgSvc(), name());
// Use the Job options service to set the Algorithm's parameters
setProperties();
// Get access to the DataManagerSvc
m_pTupleSvc = serviceLocator()->service(m_storeName);
if( !m_pTupleSvc.isValid() ) {
log << MSG::FATAL << "Unable to locate IDataManagerSvc interface" << endmsg;
return StatusCode::FAILURE;
}
// Clear the item list
clearItems();
// Take the new item list from the properties.
for(ItemNames::iterator i = m_itemNames.begin(); i != m_itemNames.end(); i++) {
addItem( *i );
}
log << MSG::INFO << "Data source: " << m_storeName << endmsg;
return StatusCode::SUCCESS;
}
// 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 RootHistCnv::RConverter::regTFile(const std::string id,
const TFile* tfile)
//-----------------------------------------------------------------------------
{
MsgStream log(msgSvc(), "RConverter");
std::map<std::string,TFile*>::const_iterator imap;
imap = s_fileMap.find(id);
if ( imap != s_fileMap.end() ) {
log << MSG::ERROR << "cannot register TTree " << id
<< ": already exists" << endmsg;
return StatusCode::FAILURE;
}
s_fileMap[id] = const_cast<TFile*>(tfile);
return StatusCode::SUCCESS;
}
//=============================================================================
StatusCode InputStreamParser::extractFileReferences(std::string input) {
MsgStream log(msgSvc(), name());
TFile *f(0);
f = TFile::Open(input.c_str(),"READ");
if (f ==0) {
log << MSG::ERROR << "Couldn't access the file: "<< input <<endmsg;
return StatusCode::FAILURE;
}
if (!f->IsOpen()) {
log << MSG::ERROR << "File "<<input <<" cannot be "
<< "opened for reading."<< endmsg;
return StatusCode::FAILURE;
}
std::string sre = "([=]*)DB=([^\\]\\[]*)";
boost::smatch matches;
boost::match_flag_type flags = boost::match_default;
char text[16000];
TBranch* b=0;
int i;
b = ((TTree*)f->Get("##Links"))->GetBranch("db_string");
Tokenizer tok(true);
for(i=0,b->SetAddress(text); i < b->GetEntries(); ++i) {
b->GetEvent(i);
const std::string text1(text);
// log << MSG::INFO <<"The text: "<< text <<endmsg;
if(!boost::find_first(text, "CNT=/Event"))
continue;
else {
m_regex.assign (sre, boost::regex_constants::icase);
if(boost::regex_search(text1.begin(),text1.end(), matches, m_regex, flags)) {
std::string match_db(matches[2].first, matches[2].second);
m_inCollection->push_back("gfal:guid:"+match_db);
log << MSG::DEBUG << "Match db: " << match_db << endmsg ;
}
}
}
f->Close("R");
return StatusCode::SUCCESS;
}
