DecisionSvc Class Reference

This implementes the methods for IDecisionSvc. More...

#include <DecisionSvc.h>

Inheritance diagram for DecisionSvc:

Collaboration diagram for DecisionSvc:

Public Member Functions
	DecisionSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor.
virtual	~DecisionSvc ()
	Destructor.
virtual StatusCode	initialize () override
	Gaudi Service Implementation.
virtual StatusCode start	ATLAS_NOT_THREAD_SAFE () override
virtual StatusCode	finalize () override
virtual StatusCode	addStream (const std::string &stream) override
	Add a stream.
virtual StatusCode	addAcceptAlg (const std::string &name, const std::string &stream) override
	Add an algorithm to the list of AcceptAlgs of a stream.
virtual StatusCode	addRequireAlg (const std::string &name, const std::string &stream) override
	Add an algorithm to the list of RequireAlgs of a stream.
virtual StatusCode	addVetoAlg (const std::string &name, const std::string &stream) override
	Add an algorithm to the list of VetoAlgs of a stream.
virtual const std::vector< std::string >	getAcceptAlgs (const std::string &stream) const override
	Return list of AcceptAlg names.
virtual const std::vector< std::string >	getRequireAlgs (const std::string &stream) const override
	Return list of RequireAlg names.
virtual const std::vector< std::string >	getVetoAlgs (const std::string &stream) const override
	Return list of VetoAlg names.
virtual const std::vector< std::string >	getStreams () const override
	Return list of Streams.
virtual bool	isEventAccepted (const std::string &stream) const override
	Test whether this event should be output.
virtual bool	isEventAccepted (const std::string &stream, const EventContext &) const override

Private Member Functions
StatusCode	interpretAlgMap ()
StatusCode DeclareToCutFlowSvc	ATLAS_NOT_THREAD_SAFE ()
StatusCode	fillMap (std::map< std::string, std::vector< std::string > > &streamsModeMap, const std::string &name, const std::string &stream)

Private Attributes
std::map< std::string, std::vector< std::string > >	m_stream_accept
	Maps of streams – algorithm names' vectors.
std::map< std::string, std::vector< std::string > >	m_stream_require
std::map< std::string, std::vector< std::string > >	m_stream_veto
std::vector< std::string >	m_streamNames
Gaudi::Property< bool >	m_calcStats {this, "CalcStats", false}
bool	m_frozen {false}
ServiceHandle< StoreGateSvc >	m_evtStore
ServiceHandle< ICutFlowSvc >	m_cutflowSvc
ServiceHandle< IAlgExecStateSvc >	m_algstateSvc

Detailed Description

This implementes the methods for IDecisionSvc.

Author

S.Binetbinet.nosp@m.@cer.nosp@m.n.ch

B.Radicsradba.nosp@m.l@ce.nosp@m.rn.ch

Definition at line 30 of file DecisionSvc.h.

Constructor & Destructor Documentation

DecisionSvc()

DecisionSvc::DecisionSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Constructor.

Definition at line 12 of file DecisionSvc.cxx.

                                          :
  base_class(name, pSvcLocator),
  m_evtStore("StoreGateSvc",name),
#ifdef SIMULATIONBASE
  m_cutflowSvc("",name),
#else
  m_cutflowSvc("CutFlowSvc/CutFlowSvc",name),
#endif
  m_algstateSvc("AlgExecStateSvc",name)
{
}

~DecisionSvc()

DecisionSvc::~DecisionSvc ( )

virtual

Destructor.

Definition at line 25 of file DecisionSvc.cxx.

{
}

Member Function Documentation

addAcceptAlg()

StatusCode DecisionSvc::addAcceptAlg ( const std::string & name, const std::string & stream )

overridevirtual

Add an algorithm to the list of AcceptAlgs of a stream.

Definition at line 162 of file DecisionSvc.cxx.

{
  // Add alg to list of streams
  auto it = std::find(m_streamNames.begin(), m_streamNames.end(),stream);
  if (it != m_streamNames.end()) m_streamNames.push_back(stream);
  // Fill map of stream to alg
  return fillMap(m_stream_accept,name,stream);
}

addRequireAlg()

StatusCode DecisionSvc::addRequireAlg ( const std::string & name, const std::string & stream )

overridevirtual

Add an algorithm to the list of RequireAlgs of a stream.

Definition at line 172 of file DecisionSvc.cxx.

{
  // Add alg to list of streams
  auto it = std::find(m_streamNames.begin(), m_streamNames.end(),stream);
  if (it != m_streamNames.end()) m_streamNames.push_back(stream);
  // Fill map of stream to alg
  return fillMap(m_stream_require,name,stream);
}

addStream()

StatusCode DecisionSvc::addStream ( const std::string & stream )

overridevirtual

Add a stream.

Definition at line 98 of file DecisionSvc.cxx.

{
  StatusCode status = StatusCode::SUCCESS;
  if(m_frozen != true){
    // check if this stream already exist
    auto it = m_stream_accept.find(stream);
    if(it != m_stream_accept.end()){
      // ok, it exists, then do nothing
      ATH_MSG_WARNING("Stream name : {} already been registered!", stream);
      status = StatusCode::FAILURE;
    }else{
      //if the stream doesn't exist yet, then insert it to the accept list with an empty vector of Algs
      std::vector<std::string> tmpvec;
      tmpvec.clear();
      ATH_MSG_INFO("Inserting stream: {} with no Algs", stream);
      m_stream_accept.insert(std::make_pair(stream, tmpvec));
      status = StatusCode::SUCCESS;
    }
  }
  return status;
}

addVetoAlg()

StatusCode DecisionSvc::addVetoAlg ( const std::string & name, const std::string & stream )

overridevirtual

Add an algorithm to the list of VetoAlgs of a stream.

Definition at line 183 of file DecisionSvc.cxx.

{
  // Add alg to list of streams
  auto it = std::find(m_streamNames.begin(), m_streamNames.end(),stream);
  if (it != m_streamNames.end()) m_streamNames.push_back(stream);
  // Fill map of stream to alg
  return fillMap(m_stream_veto,name,stream);
}

ATLAS_NOT_THREAD_SAFE() [1/2]

StatusCode DeclareToCutFlowSvc DecisionSvc::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [2/2]

virtual StatusCode start DecisionSvc::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

fillMap()

StatusCode DecisionSvc::fillMap ( std::map< std::string, std::vector< std::string > > & streamsModeMap, const std::string & name, const std::string & stream )

private

Definition at line 121 of file DecisionSvc.cxx.

{
  // check if this stream already exist
  std::map<std::string, std::vector<std::string> >::iterator it = streamsModeMap.find(stream);
  if(it != streamsModeMap.end()){
    // ok, it exists, then check if the algname was already been inserted
 
 
    bool algexist = false;
    // Check if alg already registered for this stream
    for(auto vit = (it->second).begin();
             vit != (it->second).end(); ++vit) {
      if((*vit) == name){
        algexist = true;
        // it seems the alg was already inserted, warn the user
        ATH_MSG_ERROR("Alg name : {} of stream {} has already been registered!",
                      name, stream);
        return StatusCode::FAILURE;
      }
    }
 
 
    // So, if the stream exist but the alg has not been registered
    // update its content std::vector with a alg
    if(algexist == false){
      std::vector<std::string> &tmpvec = it->second;
      tmpvec.push_back(name);
    }
 
    //if the stream doesn't exist yet, then insert it
  } else {
    std::vector<std::string> tmpvec;
    tmpvec.push_back(name);
    streamsModeMap[stream] = std::move(tmpvec);
  }
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode DecisionSvc::finalize ( )

overridevirtual

Definition at line 57 of file DecisionSvc.cxx.

{
  ATH_MSG_INFO ("Finalized successfully.");
  return StatusCode::SUCCESS;
}

getAcceptAlgs()

const std::vector< std::string > DecisionSvc::getAcceptAlgs ( const std::string & stream ) const

overridevirtual

Return list of AcceptAlg names.

Definition at line 201 of file DecisionSvc.cxx.

{
  auto iter = m_stream_accept.find(stream);
  if (iter != m_stream_accept.end()) return iter->second;
  return std::vector<std::string>();
}

getRequireAlgs()

const std::vector< std::string > DecisionSvc::getRequireAlgs ( const std::string & stream ) const

overridevirtual

Return list of RequireAlg names.

Definition at line 210 of file DecisionSvc.cxx.

{
  auto iter = m_stream_require.find(stream);
  if (iter != m_stream_require.end()) return iter->second;
  return std::vector<std::string>();
}

getStreams()

const std::vector< std::string > DecisionSvc::getStreams ( ) const

overridevirtual

Return list of Streams.

Definition at line 194 of file DecisionSvc.cxx.

{
  return m_streamNames;
}

getVetoAlgs()

const std::vector< std::string > DecisionSvc::getVetoAlgs ( const std::string & stream ) const

overridevirtual

Return list of VetoAlg names.

Definition at line 219 of file DecisionSvc.cxx.

{
  auto iter = m_stream_veto.find(stream);
  if (iter != m_stream_veto.end()) return iter->second;
  return std::vector<std::string>();
}

initialize()

StatusCode DecisionSvc::initialize ( )

overridevirtual

Gaudi Service Implementation.

Definition at line 30 of file DecisionSvc.cxx.

{
  // Decode the accept, required and veto Algorithms.
  // The logic is the following:
  //  a. The event is accepted if all lists are empty.
  //  b. The event is provisionally accepted if any Algorithm in the
  //     accept list
  //     has been executed and has indicated that its filter is passed. This
  //     provisional acceptance can be overridden by the other lists.
  //  c. The event is rejected unless all Algorithms in the required list have
  //     been executed and have indicated that their filter passed.
  //  d. The event is rejected if any Algorithm in the veto list has been
  //     executed and has indicated that its filter has passed.
 
  // Set to be listener for BeginRun
  // Declares top filters to ICutFlowSvc if (and only if) needed (David Cote, Sep 2010)
 
  // Get handle to exec state service for retrieving decisions
  ATH_CHECK( m_algstateSvc.retrieve() );
 
  ATH_CHECK(m_evtStore.retrieve());
 
  return StatusCode::SUCCESS;
}

interpretAlgMap()

StatusCode DecisionSvc::interpretAlgMap ( )

private

Definition at line 64 of file DecisionSvc.cxx.

{
  StatusCode status = StatusCode::SUCCESS;
 
  // Fill up m_streamNames vector
  std::set<std::string> uniStreams;
  m_streamNames.clear();
  // first take list of streams from accept streams
  for(auto iter = m_stream_accept.begin();
           iter != m_stream_accept.end(); ++iter){
    uniStreams.insert(iter->first);
  }
  // then require
  for(auto iter = m_stream_require.begin();
           iter != m_stream_require.end(); ++iter){
    uniStreams.insert(iter->first);
  }
  // then veto
  for(auto iter = m_stream_veto.begin();
           iter != m_stream_veto.end(); ++iter){
    uniStreams.insert(iter->first);
  }
  std::copy(uniStreams.begin(),uniStreams.end(),std::back_inserter(m_streamNames));
 
  return status;
}

isEventAccepted() [1/2]

bool DecisionSvc::isEventAccepted ( const std::string & stream ) const

overridevirtual

Test whether this event should be output.

Definition at line 234 of file DecisionSvc.cxx.

{
  EventContext ec;
  ec.setValid(false);
  ec.setSlot(0);
  return isEventAccepted(stream,ec);
}

isEventAccepted() [2/2]

bool DecisionSvc::isEventAccepted ( const std::string & stream, const EventContext & ectx ) const

overridevirtual

Definition at line 243 of file DecisionSvc.cxx.

{
 
  ATH_MSG_DEBUG("In DecisionSvc::isEventAccepted( {} )", stream);
 
  // By construction a stream is accepted
  bool result = true;
  
  bool found_accept = false;
  bool found_require = false;
  bool found_veto = false;
 
  //Loop over all streams of accept type and find the one of interest
  auto itAlgs = m_stream_accept.find(stream);
  if(itAlgs != m_stream_accept.end()){
    found_accept = true;
    // get a handle of the streams' algos vector
    const auto &vecAlgs = itAlgs->second;
    // Loop over all Algorithms in the list to see
    // whether any have been executed and have their filter
    // passed flag set. Any match causes the event to be
    // provisionally accepted.
    if ( ! vecAlgs.empty( ) ) {
      result = false;
      for (auto it = vecAlgs.begin(); it != vecAlgs.end(); it++) {
        bool isE,fp;
        isE = (m_algstateSvc->algExecState(*it,ectx).state() == AlgExecState::State::Done);
        fp = m_algstateSvc->algExecState(*it,ectx).filterPassed();
        if (isE && fp) {
      result = true;
      break;
    }
      }
    }
  }
 
  //Loop over all streams of require type and find the one of interest
  itAlgs = m_stream_require.find(stream);
  if(itAlgs != m_stream_require.end()){
    found_require = true;
    // get a handle of the streams' algos vector
    const auto &vecAlgs = itAlgs->second;
    // Loop over all Algorithms in the list to see
    // whether any have been executed and have their filter
    // passed flag set. Any match causes the event to be
    // provisionally accepted.
    if ( ! vecAlgs.empty( ) ) {
      for (auto it = vecAlgs.begin(); it != vecAlgs.end(); it++) {
        bool isE,fp;
        isE = (m_algstateSvc->algExecState(*it,ectx).state() == AlgExecState::State::Done);
        fp = m_algstateSvc->algExecState(*it,ectx).filterPassed();
        if (!isE || !fp) {
          result = false;
          break;
        }
      }
    }
  }
 
  //Loop over all streams of veto type and find the one of interest
  itAlgs = m_stream_veto.find(stream);
  if(itAlgs != m_stream_veto.end()){
    found_veto = true;
    // get a handle of the streams' algos vector
    const auto &vecAlgs = itAlgs->second;
    // Loop over all Algorithms in the list to see
    // whether any have been executed and have their filter
    // passed flag set. Any match causes the event to be
    // provisionally accepted.
    if ( ! vecAlgs.empty( ) ) {
      for (auto it = vecAlgs.begin(); it != vecAlgs.end(); it++) {
        bool isE,fp;
        isE = (m_algstateSvc->algExecState(*it,ectx).state() == AlgExecState::State::Done);
        fp = m_algstateSvc->algExecState(*it,ectx).filterPassed();
    if ( isE && fp ) {
          result = false;
          break;
    }
      }
    }
  }
 
  if(found_accept == false && found_require == false && found_veto == false){
    ATH_MSG_DEBUG("Stream: {} not found registered in DecisionSvc -- accepting event by default ", stream);
  }
 
  return result;
}

Member Data Documentation

m_algstateSvc

ServiceHandle<IAlgExecStateSvc> DecisionSvc::m_algstateSvc

private

Definition at line 99 of file DecisionSvc.h.

m_calcStats

Gaudi::Property<bool> DecisionSvc::m_calcStats {this, "CalcStats", false}

private

Definition at line 95 of file DecisionSvc.h.

{this, "CalcStats", false};

m_cutflowSvc

ServiceHandle<ICutFlowSvc> DecisionSvc::m_cutflowSvc

private

Definition at line 98 of file DecisionSvc.h.

m_evtStore

ServiceHandle<StoreGateSvc> DecisionSvc::m_evtStore

private

Definition at line 97 of file DecisionSvc.h.

m_frozen

bool DecisionSvc::m_frozen {false}

private

Definition at line 96 of file DecisionSvc.h.

{false};

m_stream_accept

std::map<std::string, std::vector<std::string> > DecisionSvc::m_stream_accept

private

Maps of streams – algorithm names' vectors.

Definition at line 89 of file DecisionSvc.h.

m_stream_require

std::map<std::string, std::vector<std::string> > DecisionSvc::m_stream_require

private

Definition at line 90 of file DecisionSvc.h.

m_stream_veto

std::map<std::string, std::vector<std::string> > DecisionSvc::m_stream_veto

private

Definition at line 91 of file DecisionSvc.h.

m_streamNames

std::vector<std::string> DecisionSvc::m_streamNames

private

Definition at line 93 of file DecisionSvc.h.

---

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

• DecisionSvc.h
• DecisionSvc.cxx