CutFlowSvc Class Reference

This implements the methods for ICutFlowSvc. More...

#include <CutFlowSvc.h>

Inheritance diagram for CutFlowSvc:

Collaboration diagram for CutFlowSvc:

Public Member Functions
	CutFlowSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor.
virtual StatusCode	initialize () override final
	Gaudi Service Implementation.
virtual void	handle (const Incident &incident) override final
	Incident service handle listening for BeginInputFile, EndInputFile and MetaDataStop.
virtual CutIdentifier	registerFilter (const std::string &name, const std::string &description, bool nominalOnly) override final
	Register filter in the CutFlowSvc and returns the CutID of the corresponding CutBookkeeper.
virtual CutIdentifier registerTopFilter	ATLAS_NOT_THREAD_SAFE (const std::string &name, const std::string &description, unsigned int logic, const std::string &outputStream, bool nominalOnly) override final
	Tells CutFlowSvc that a filter is used directly by an outputStream with a given logical context.
virtual CutIdentifier	registerCut (const std::string &name, const std::string &description, CutIdentifier parentCutID, bool nominalOnly) override final
	Register cut as child of a filter in the CutFlowSvc and returns the CutID of the corresponding EventBookkeeper.
virtual void	setFilterDescription (CutIdentifier cutID, const std::string &descr) override final
	Set the description of an existing CutBookkeeper.
virtual void	addEvent (CutIdentifier cutID, const std::vector< float > &weights) override final
	Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID, using CutIdentifier returned by selfRegisterFilter.
virtual void	addEvent (CutIdentifier cutID, double weight) override final
	Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID, using CutIdentifier returned by selfRegisterFilter.
virtual uint64_t	getNAcceptedEvents (const CutIdentifier cutID) const override final
	Get number of accepted events for a cut.
const CutBookkeepersLocalCache &	getCutBookkeepers () const
	Get CutBookkeepers cache.
StatusCode	setNumberOfWeightVariations (size_t count)
	Set number of weight variations.

Private Member Functions
void	addEvent (CutIdentifier cutID, size_t index, double weight)
	Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID for a specific index in the cache.
StatusCode	determineCycleNumberFromInput (const std::string &collName)
	Helper function to determine the processing cycle number from the input meta-data store.
StatusCode	createContainers (size_t count)
	Helper function to create an empty containers (and its aux store)
xAOD::CutBookkeeper *	getCutBookkeeper (const CutIdentifier cutID, size_t index) const
	Get a CutBookkeeper given a CutID.

Private Attributes
Gaudi::Property< bool >	m_configured {this, "Configured", true, "configuration check"}
	CutFlow service should be explicitly configured.
ServiceHandle< StoreGateSvc >	m_inMetaDataStore {this, "InputMetaDataStore", "StoreGateSvc/InputMetaDataStore", ""}
	The input meta-data store.
Gaudi::Property< std::string >	m_completeCollName {this, "OutputCollName", "CutBookkeepers", ""}
	The name of the completed, i.e., fully processed, CutBookkeeperContainer.
CutBookkeepersLocalCache	m_containers
	Local CutBookkeeperContainers.
Gaudi::Property< int >	m_skimmingCycle {this, "SkimmingCycle", 0, "Skimming cycle of current job"}
	The current skimming cycle, i.e., how many processing stages we already had.
Gaudi::Property< std::string >	m_inputStream {this, "InputStream", "N/A", "The name of the input file stream"}
	The name of the currently used input file stream.
std::recursive_mutex	m_addEventMutex
	Mutex to protect adding an event.
std::unordered_set< CutIdentifier >	m_nominalOnlyCuts
	List of nominal-only filters.

Detailed Description

This implements the methods for ICutFlowSvc.

Definition at line 43 of file CutFlowSvc.h.

Constructor & Destructor Documentation

CutFlowSvc()

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

Constructor.

Definition at line 23 of file CutFlowSvc.cxx.

                                                  :
  base_class(name, pSvcLocator)
{
  assert( pSvcLocator );
}

Member Function Documentation

addEvent() [1/3]

void CutFlowSvc::addEvent ( CutIdentifier cutID, const std::vector< float > & weights )

finaloverridevirtual

Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID, using CutIdentifier returned by selfRegisterFilter.

Definition at line 178 of file CutFlowSvc.cxx.

{
  if (weights.size() != m_containers.size()) {
    ATH_MSG_ERROR("Inconsistent weights and variation sizes " << weights.size() << " and " << m_containers.size());
    throw std::runtime_error("Inconsistent weights and variation sizes");
  }
 
  for (size_t i = 0; i < m_containers.size(); ++i) {
    addEvent(cutID, i, weights[i]);
  }
}

addEvent() [2/3]

void CutFlowSvc::addEvent ( CutIdentifier cutID, double weight )

finaloverridevirtual

Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID, using CutIdentifier returned by selfRegisterFilter.

Definition at line 193 of file CutFlowSvc.cxx.

{
  if (m_nominalOnlyCuts.count(cutID) == 1) {
    addEvent(cutID, 0, weight);
    return;
  }
 
  for (size_t i = 0; i < m_containers.size(); ++i) {
    addEvent(cutID, i, weight);
  }
}

addEvent() [3/3]

void CutFlowSvc::addEvent ( CutIdentifier cutID, size_t index, double weight )

private

Tells CutFlowSvc to update the weighted event counter of a CutIdentifier cutID for a specific index in the cache.

Definition at line 209 of file CutFlowSvc.cxx.

{
  std::lock_guard<std::recursive_mutex> lock(m_addEventMutex);
 
  ATH_MSG_VERBOSE("Adding event with weight " << weight << " to cut " << cutID << " for variation " << index);
 
  xAOD::CutBookkeeper* cbk = getCutBookkeeper(cutID, index);
  if (cbk == nullptr) {
    ATH_MSG_ERROR("Could not find CutBookkeeper for CutID " << cutID << " and variation " << index);
    throw std::runtime_error("Could not find CutBookkeeper");
  }
 
  cbk->addNAcceptedEvents(1);
  cbk->addSumOfEventWeights(weight);
  cbk->addSumOfEventWeightsSquared(weight*weight);
}

ATLAS_NOT_THREAD_SAFE()

virtual CutIdentifier registerTopFilter CutFlowSvc::ATLAS_NOT_THREAD_SAFE ( const std::string & name, const std::string & description, unsigned int logic, const std::string & outputStream, bool nominalOnly )

finaloverridevirtual

Tells CutFlowSvc that a filter is used directly by an outputStream with a given logical context.

The only foreseen client should the DecisionSvc, with its Accept/Require/Veto.

createContainers()

StatusCode CutFlowSvc::createContainers ( size_t count )

private

Helper function to create an empty containers (and its aux store)

Definition at line 336 of file CutFlowSvc.cxx.

{
  // Expect that this should only be called once for now
  if (!m_containers.empty() && m_containers.size() == count) {
    return StatusCode::SUCCESS;
  }
 
  if (m_containers.size() > count) {
    ATH_MSG_ERROR("Inconsistent variation count");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_VERBOSE("Create containers with count " << count);
 
  ATH_MSG_VERBOSE("Existing size " << m_containers.size());
 
  // Create the containers
  CutBookkeepersLocalCache::prepareContainers(m_containers, count, true);
  if (count == 1) {
    return StatusCode::SUCCESS;
  }
 
  // Copy existing CutBookkeepers for consistency
  xAOD::CutBookkeeperContainer *first = m_containers.at(0);
  if (first->empty()) {
    return StatusCode::SUCCESS;
  }
  for (size_t i = 1; i < count; ++i) {
    xAOD::CutBookkeeperContainer *cont = m_containers.at(i);
    for (const xAOD::CutBookkeeper *cbk : *first) {
      xAOD::CutBookkeeper *newCbk = new xAOD::CutBookkeeper();
      cont->push_back(newCbk);
      *newCbk = *cbk;
    }
  }
 
  return StatusCode::SUCCESS;
}

determineCycleNumberFromInput()

StatusCode CutFlowSvc::determineCycleNumberFromInput ( const std::string & collName )

private

Helper function to determine the processing cycle number from the input meta-data store.

Definition at line 309 of file CutFlowSvc.cxx.

{
  ATH_MSG_DEBUG("calling determineCycleNumberFromInput('" << collName
                  << "')... have currently cycle number = " << m_skimmingCycle );
 
  // Try to get CutBookkeepers from the input file
  if ( m_inMetaDataStore->contains<xAOD::CutBookkeeperContainer>(collName) ) {
    ATH_MSG_VERBOSE("Found xAOD::CutBookkeeperContainer in input MetaStore with name: " << collName);
 
    const xAOD::CutBookkeeperContainer* inputContainer{};
    ATH_CHECK( m_inMetaDataStore->retrieve( inputContainer, collName ) );
    // Now, iterate over all CutBookkeepers and search for the highest cycle number
    int maxCycle{};
    for (const xAOD::CutBookkeeper* cbk : *inputContainer) {
      int inCycle = cbk->cycle();
      if (inCycle > maxCycle) maxCycle = inCycle;
    }
    m_skimmingCycle = std::max(m_skimmingCycle.value(), maxCycle + 1);
  }
 
  ATH_MSG_DEBUG("done calling determineCycleNumberFromInput('" << collName
                  << "')... have now cycle number = " << m_skimmingCycle );
  return StatusCode::SUCCESS;
}

getCutBookkeeper()

xAOD::CutBookkeeper * CutFlowSvc::getCutBookkeeper ( const CutIdentifier cutID, size_t index ) const

private

Get a CutBookkeeper given a CutID.

Definition at line 392 of file CutFlowSvc.cxx.

{
  if (index >= m_containers.size()) {
    return nullptr;
  }
 
  for (xAOD::CutBookkeeper* cbk : *m_containers.at(index)) {
    if (cbk->uniqueIdentifier() == cutID) {
      return cbk;
    }
  }
  return nullptr;
}

getCutBookkeepers()

const CutBookkeepersLocalCache & CutFlowSvc::getCutBookkeepers

(

)

const

Get CutBookkeepers cache.

Definition at line 385 of file CutFlowSvc.cxx.

{
  return m_containers;
}

getNAcceptedEvents()

uint64_t CutFlowSvc::getNAcceptedEvents ( const CutIdentifier cutID ) const

finaloverridevirtual

Get number of accepted events for a cut.

Definition at line 409 of file CutFlowSvc.cxx.

{
  const xAOD::CutBookkeeper* cbk = getCutBookkeeper(cutID, 0);
  if (cbk == nullptr) {
    return std::numeric_limits<uint64_t>::max();
  }
  return cbk->nAcceptedEvents();
}

handle()

void CutFlowSvc::handle ( const Incident & incident )

finaloverridevirtual

Incident service handle listening for BeginInputFile, EndInputFile and MetaDataStop.

Definition at line 231 of file CutFlowSvc.cxx.

{
  ATH_MSG_VERBOSE( "Start incident " << inc.type() );
 
  if (inc.type() == IncidentType::BeginInputFile) {
    // Look up input stream name from FileMetaData
    std::string inputstream = "";
    if (m_inMetaDataStore->contains<xAOD::FileMetaData>("FileMetaData")) {
      const xAOD::FileMetaData* fmd = nullptr;
      if (m_inMetaDataStore->retrieve(fmd).isFailure()) {
        ATH_MSG_ERROR("Failed to retrieve input FileMetaData");
      } else if (fmd &&
                 !fmd->value(xAOD::FileMetaData::dataType, inputstream)) {
        ATH_MSG_WARNING("Failed to get input stream name from FileMetaData");
      }
    } else {
      ATH_MSG_DEBUG("No FileMetaData in input, trying EventStreamInfo");
      // determine key for EventStreamInfo
      std::vector<std::string> vKeys;
      m_inMetaDataStore->keys<EventStreamInfo>(vKeys);
      // eliminate duplicate keys
      std::set<std::string> keys(vKeys.begin(), vKeys.end());
      if (keys.size() == 1) {
        std::string key = *keys.begin();  // get the one key
        auto esi = m_inMetaDataStore->tryConstRetrieve<EventStreamInfo>(key);
        if (esi && !esi->getProcessingTags().empty()) {
          // use the first tag
          inputstream = *esi->getProcessingTags().begin();
        }
      }
    }
 
    if (inputstream.empty()) {
      if (m_inputStream.empty()) {
        ATH_MSG_FATAL("Cannot determine input stream name");
        return;
      }
      ATH_MSG_DEBUG(
          "Failed to parse stream name from metadata, using "
          "property \"InputStream\"");
      inputstream = m_inputStream;
    }
 
    // Check that input stream is consistent with previous file
    ATH_MSG_DEBUG("Input stream name: \"" << inputstream << '"');
    if (m_inputStream.empty()) {
      m_inputStream = inputstream;
    } else if (m_inputStream != inputstream) {
      const FileIncident* finc = dynamic_cast<const FileIncident*>(&inc);
      if (m_inputStream != "N/A" && m_inputStream != "unknownStream") {
        ATH_MSG_FATAL("File " << (finc?finc->fileName():"???") << " stream " << inputstream
                              << " does not match previous file "
                              << m_inputStream);
        return;
      }
    }
  }
 
  // Clear the local bookkeepers
  if (inc.type() == "MetaDataStop") {
    if (!m_containers.empty()) {
      // Reset existing container
      for (size_t i = 0; i < m_containers.size(); ++i) {
        for (xAOD::CutBookkeeper* cbk : *m_containers.at(i)) {
          cbk->setNAcceptedEvents(0);
          cbk->setSumOfEventWeights(0);
          cbk->setSumOfEventWeightsSquared(0);
        }
      }
    }
  }
 
  ATH_MSG_VERBOSE( "End incident " << inc.type() );
  return;
}

initialize()

StatusCode CutFlowSvc::initialize ( )

finaloverridevirtual

Gaudi Service Implementation.

Definition at line 32 of file CutFlowSvc.cxx.

{
  ATH_MSG_DEBUG( "Initializing " << name() );
 
  // Only run if explicitly configured
  if (m_configured.value() == false) {
    ATH_MSG_ERROR("CutFlowSvc should be explicitly configured!");
    return StatusCode::FAILURE;
  }
 
  //Get input MetaData StoreGate
  ATH_CHECK( m_inMetaDataStore.retrieve() );
 
  //Get IncidentSvc
  ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", this->name());
  ATH_CHECK( incSvc.retrieve() );
  incSvc->addListener(this, IncidentType::BeginInputFile, 60); // pri has to be < 100 to be after MetaDataSvc.
  incSvc->addListener(this, "MetaDataStop", 30);
 
  // Create initial bookkeeper container for bookkeepers in _this_ processing
  ATH_CHECK(createContainers(1));
 
  // Determine the skimming cycle number that we should use now from the input file
  ATH_MSG_VERBOSE("Have currently the cycle number = " << m_skimmingCycle );
  ATH_CHECK( this->determineCycleNumberFromInput(m_completeCollName) );
  ATH_MSG_VERBOSE("Will use cycle number = " << m_skimmingCycle );
 
  return StatusCode::SUCCESS;
}

registerCut()

CutIdentifier CutFlowSvc::registerCut ( const std::string & name, const std::string & description, CutIdentifier parentCutID, bool nominalOnly )

finaloverridevirtual

Register cut as child of a filter in the CutFlowSvc and returns the CutID of the corresponding EventBookkeeper.

This method should be used by filters to register their internal cuts that are not the Algs themselves.

Definition at line 130 of file CutFlowSvc.cxx.

{
  ATH_MSG_DEBUG("Registering cut with name '" << name << "', description '" << description
                << "' and original CutID " << parentCutID);
 
  // Get the CutBookkeeper of the origin Filter Algorithm/Tool
  xAOD::CutBookkeeper* parentCbk = getCutBookkeeper(parentCutID, 0);
  if (parentCbk == nullptr) {
    ATH_MSG_ERROR("Could not find parent CutBookkeeper with CutID " << parentCutID);
    throw std::runtime_error("Could not find CutBookkeeper");
  }
 
  // Call the registerFilter method and get the correct CutBookkeeper
  // from the returned cutID
  CutIdentifier cutID = registerFilter(name, description, nominalOnly);
  xAOD::CutBookkeeper* cbk = getCutBookkeeper(cutID, 0);
  if (cbk == nullptr) {
    ATH_MSG_ERROR("Could not find CutBookkeeper with CutID " << cutID);
    throw std::runtime_error("Could not find CutBookkeeper");
  }
 
  // Add child to parent
  parentCbk->addChild(cbk);
 
  return cutID;
}

registerFilter()

CutIdentifier CutFlowSvc::registerFilter ( const std::string & name, const std::string & description, bool nominalOnly )

finaloverridevirtual

Register filter in the CutFlowSvc and returns the CutID of the corresponding CutBookkeeper.

This method should be used by filters that register themselves.

Definition at line 64 of file CutFlowSvc.cxx.

{
  ATH_MSG_DEBUG("Registering filter with name '" << name << "' and description '" << description << "'");
 
  auto newCbk = std::make_unique<xAOD::CutBookkeeper>();
  newCbk->setName(name);
  newCbk->setDescription(description);
  newCbk->setInputStream(m_inputStream);
  newCbk->setCycle(m_skimmingCycle);
  CutIdentifier cutID = newCbk->uniqueIdentifier();
 
  // Let's see if an CutBookkeeper of this name already exists
  xAOD::CutBookkeeperContainer *container = m_containers.at(0);
  ATH_MSG_VERBOSE("Searching if this CutBookkeeper already exists");
  for (xAOD::CutBookkeeper* cbk : *container) {
    if (newCbk->isEqualTo(cbk)) {
      ATH_MSG_DEBUG("The CutBookkeeper with name '" << name << "' already exists"
                    << " and has CutID " << cbk->uniqueIdentifier() << "... Not adding!" );
      // Return the existing cut ID
      return cbk->uniqueIdentifier();
    }
  }
 
  // If it is a new CutBookkeeper, add it to the container
  ATH_MSG_DEBUG("Declaring a new filter with name '" << name << "' and CutID " << cutID );
  container->push_back(std::move(newCbk));
 
  if (nominalOnly) {
    m_nominalOnlyCuts.emplace(cutID);
  }
 
  return cutID;
}

setFilterDescription()

void CutFlowSvc::setFilterDescription ( CutIdentifier cutID, const std::string & descr )

finaloverridevirtual

Set the description of an existing CutBookkeeper.

Definition at line 162 of file CutFlowSvc.cxx.

{
  ATH_MSG_DEBUG("calling setFilterDescription(" << cutID << ", " << descr << ")" );
 
  for (size_t i = 0; i < m_containers.size(); ++i) {
    xAOD::CutBookkeeper* cbk = getCutBookkeeper(cutID, i);
    if (cbk != nullptr) {
      cbk->setDescription(descr);
    }
  }
  return;
}

setNumberOfWeightVariations()

StatusCode CutFlowSvc::setNumberOfWeightVariations

(

size_t

count

)

Set number of weight variations.

Definition at line 377 of file CutFlowSvc.cxx.

{
  ATH_CHECK(createContainers(count));
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_addEventMutex

std::recursive_mutex CutFlowSvc::m_addEventMutex

mutableprivate

Mutex to protect adding an event.

Definition at line 149 of file CutFlowSvc.h.

m_completeCollName

Gaudi::Property<std::string> CutFlowSvc::m_completeCollName {this, "OutputCollName", "CutBookkeepers", ""}

private

The name of the completed, i.e., fully processed, CutBookkeeperContainer.

Definition at line 137 of file CutFlowSvc.h.

{this, "OutputCollName", "CutBookkeepers", ""};

m_configured

Gaudi::Property<bool> CutFlowSvc::m_configured {this, "Configured", true, "configuration check"}

private

CutFlow service should be explicitly configured.

Definition at line 131 of file CutFlowSvc.h.

{this, "Configured", true, "configuration check"};

m_containers

CutBookkeepersLocalCache CutFlowSvc::m_containers

private

Local CutBookkeeperContainers.

Definition at line 140 of file CutFlowSvc.h.

m_inMetaDataStore

ServiceHandle<StoreGateSvc> CutFlowSvc::m_inMetaDataStore {this, "InputMetaDataStore", "StoreGateSvc/InputMetaDataStore", ""}

private

The input meta-data store.

Definition at line 134 of file CutFlowSvc.h.

{this, "InputMetaDataStore", "StoreGateSvc/InputMetaDataStore", ""};

m_inputStream

Gaudi::Property<std::string> CutFlowSvc::m_inputStream {this, "InputStream", "N/A", "The name of the input file stream"}

private

The name of the currently used input file stream.

Definition at line 146 of file CutFlowSvc.h.

{this, "InputStream", "N/A", "The name of the input file stream"};

m_nominalOnlyCuts

std::unordered_set<CutIdentifier> CutFlowSvc::m_nominalOnlyCuts

private

List of nominal-only filters.

Definition at line 152 of file CutFlowSvc.h.

m_skimmingCycle

Gaudi::Property<int> CutFlowSvc::m_skimmingCycle {this, "SkimmingCycle", 0, "Skimming cycle of current job"}

private

The current skimming cycle, i.e., how many processing stages we already had.

Definition at line 143 of file CutFlowSvc.h.

{this, "SkimmingCycle", 0, "Skimming cycle of current job"};

---

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

• CutFlowSvc.h
• CutFlowSvc.cxx