TrigCostAnalysis Class Reference

Athena algorithm used to process Trigger cost monitoring data in Run 3 and above. Outputs histograms. More...

#include <TrigCostAnalysis.h>

Inheritance diagram for TrigCostAnalysis:

Collaboration diagram for TrigCostAnalysis:

Public Member Functions
	TrigCostAnalysis (const std::string &name, ISvcLocator *pSvcLocator)
	Construct TrigCostAnalysis. More...
virtual	~TrigCostAnalysis ()=default
	Default destructor. More...
virtual StatusCode	initialize () final
	Retrieve tools and initialise read handles. More...
virtual StatusCode	start ()
	Retrieve menu handle. More...
virtual StatusCode	execute () final
	Monitor event, unless max range limit reached and event outside of all ranges. More...
virtual StatusCode	finalize () final
	Currently a noop for this algorithm. More...
TH1 *	bookGetPointer (TH1 *hist, const std::string &tDir="") const
	Public method forwarded to this class' AthHistogramAlgorithm::bookGetPointer base. More...
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Public Attributes
ServiceHandle< ITHistSvc >	m_histSvc { this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" }
Gaudi::Property< bool >	m_singleTimeRange
Gaudi::Property< std::string >	m_singleTimeRangeName
Gaudi::Property< std::string >	m_additionalHashMap
Gaudi::Property< std::vector< std::string > >	m_additionalHashList
Gaudi::Property< size_t >	m_TimeRangeLengthLB
Gaudi::Property< size_t >	m_maxTimeRange
Gaudi::Property< bool >	m_doMonitorAlgorithm
Gaudi::Property< bool >	m_doMonitorAlgorithmClass
Gaudi::Property< bool >	m_doMonitorGlobal
Gaudi::Property< bool >	m_doMonitorThreadOccupancy
Gaudi::Property< bool >	m_doMonitorROS
Gaudi::Property< bool >	m_doMonitorChain
Gaudi::Property< bool >	m_doMonitorChainAlgorithm
Gaudi::Property< bool >	m_doMonitorSequence
Gaudi::Property< bool >	m_useEBWeights
Gaudi::Property< size_t >	m_maxFullEventDumps
Gaudi::Property< uint64_t >	m_fullEventDumpProbability
Gaudi::Property< float >	m_baseEventWeight
Gaudi::Property< std::map< std::string, std::vector< uint32_t > > >	m_rosToRob
SG::ReadHandleKey< xAOD::TrigCompositeContainer >	m_costDataKey
SG::ReadHandleKey< xAOD::TrigCompositeContainer >	m_rosDataKey
SG::ReadHandleKey< xAOD::TrigCompositeContainer >	m_metadataDataKey
SG::ReadHandleKey< TrigConf::HLTMenu >	m_HLTMenuKey
ToolHandle< IEnhancedBiasWeighter >	m_enhancedBiasTool
ToolHandle< TrigCompositeUtils::AlgToChainTool >	m_algToChainTool

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	checkDoFullEventDump (const EventContext &context, const CostData &costData)
	Check if event dumping should be performed for the current event. More...
StatusCode	getRange (const EventContext &context, MonitoredRange *&range)
	Return or construct and return a Range for the Context. More...
StatusCode	dumpEvent (const EventContext &context) const
	Dump event algorithm execution data in ASCII format. More...
StatusCode	registerMonitors (MonitoredRange *range)
	Populate a newly minted Range object with all configured Monitors. More...
float	getWeight (const EventContext &context)
	Compute global event weight to correct for online prescales. More...
uint32_t	getOnlineSlot (const xAOD::TrigCompositeContainer *costCollection) const
	Return the slot used to process the event online. More...
StatusCode	checkUpdateMaxView (const size_t max)
	High watermark for pre-cached string hashes for the SLOT category. More...
void	writeMetadata ()
	Write to outpute tree (if any) the metadata needed downstream. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::unordered_map< std::string, std::unique_ptr< MonitoredRange > >	m_monitoredRanges
	Owned storage of Ranges. More...
std::unordered_map< uint32_t, std::string >	m_algTypeMap
	Cache of algorithm's type, read from configuration data. More...
std::set< std::string >	m_storeIdentifiers
	Identifiers of object stores, needed to cache STORE string-hash values. More...
TTree *	m_metadataTree
	Used to write out some metadata needed by post-processing (e.g. More...
std::atomic< size_t >	m_fullEventDumps
	Counter to keep track of how many events have been full-dumped. More...
std::atomic< size_t >	m_maxViewsNumber
	What is the maximum number of View instances we've so far cached string hashes to cover? More...
std::mutex	m_addHostnameMutex
	Mutex to update set below. More...
std::set< std::string > m_hostnames	ATLAS_THREAD_SAFE
	Save unique hostnames for the run. More...
CostROSData	m_costROSData
	Cached CostROSData class with details needed for ROS monitoring. More...
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Athena algorithm used to process Trigger cost monitoring data in Run 3 and above. Outputs histograms.

Algorithm to read relevant trigger cost data from the event store and trigger configuration data from the config service, identify the time Range that the event falls into, and dispatches monitoring to the correct time range. Time ranges, their monitors, and their monitor's counters are all instantiated on-demand.

Definition at line 36 of file TrigCostAnalysis.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TrigCostAnalysis()

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

Construct TrigCostAnalysis.

Parameters

[in]	name	Athena algorithm's name.
[in]	pSvcLocator	Framework service pointer.

Definition at line 26 of file TrigCostAnalysis.cxx.

                                                                                    :
  AthAlgorithm(name, pSvcLocator),
  m_metadataTree(nullptr),
  m_fullEventDumps(0),
  m_maxViewsNumber(0) {
}

~TrigCostAnalysis()

virtual TrigCostAnalysis::~TrigCostAnalysis ( )

virtualdefault

Default destructor.

Member Function Documentation

bookGetPointer()

TH1 * TrigCostAnalysis::bookGetPointer	(	TH1 *	hist,
		const std::string &	tDir = ""
	)		const

Public method forwarded to this class' AthHistogramAlgorithm::bookGetPointer base.

Parameters

[in]	hist	Bare pointer to histogram. Ownership transferred to THistSvc.
[in]	tDir	Histogram name & directory.

Returns

Cached pointer to histogram. Used to fill histogram without having to perform THishSvc lookup.

Definition at line 171 of file TrigCostAnalysis.cxx.

                                                                            {
  std::string histName(hist->GetName());
  std::string bookingString = "/COSTSTREAM/" + tDir + "/" + histName;
 
  if (!((m_histSvc->regHist(bookingString, hist)).isSuccess())) {
    ATH_MSG_WARNING( "Problem registering histogram with name " << histName);
    return nullptr;
  }
 
  return hist;
}

checkDoFullEventDump()

bool TrigCostAnalysis::checkDoFullEventDump ( const EventContext &  context, const CostData &  costData  )

private

Check if event dumping should be performed for the current event.

Parameters

[in]	context	Event context.
[in]	costData	We only dump the master-slot (slot:0) as these events cary payload data for all slots / all threads.

Returns

True, if the event should be dumped.

Definition at line 304 of file TrigCostAnalysis.cxx.

                                                                                                 {
  if (costData.isMasterSlot()
    and m_fullEventDumps < m_maxFullEventDumps 
    and context.eventID().event_number() % m_fullEventDumpProbability == 0)
  {
    ++m_fullEventDumps;
    return true;
  }
  return false;
}

checkUpdateMaxView()

StatusCode TrigCostAnalysis::checkUpdateMaxView ( const size_t  max )

private

High watermark for pre-cached string hashes for the SLOT category.

Corresponding to SG and View IProxyDict names.

Parameters

[in]

max

Pre-compute string hashes for View or Slot multiplicities up to this number.

Definition at line 138 of file TrigCostAnalysis.cxx.

                                                                {
  if (max <= m_maxViewsNumber) {
    return StatusCode::SUCCESS;
  }
  const size_t current = m_maxViewsNumber;
  m_maxViewsNumber = max;
  ATH_MSG_DEBUG("Extending maximum View instances from " << current << " to " << max);
  for (size_t viewID = current; viewID <= m_maxViewsNumber; ++ viewID) {
    // Allow for this many individual View instances
    for (const std::string& store : m_storeIdentifiers) {
      std::stringstream ss;
      ss << store << "_view_" << viewID;
      TrigConf::HLTUtils::string2hash(ss.str(), "STORE");
    }
    // And this many global Slots. Though, in general, it will be the Views which are driving this. 
    std::stringstream ss;
    ss << viewID << "_StoreGateSvc_Impl";
    TrigConf::HLTUtils::string2hash(ss.str(), "STORE");
  }
  return StatusCode::SUCCESS;
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

dumpEvent()

StatusCode TrigCostAnalysis::dumpEvent ( const EventContext &  context ) const

private

Dump event algorithm execution data in ASCII format.

Parameters

[in]

context

Event context.

Definition at line 421 of file TrigCostAnalysis.cxx.

                                                                        {
  ++m_fullEventDumps;
  SG::ReadHandle<xAOD::TrigCompositeContainer> costDataHandle(m_costDataKey, context);
 
  std::stringstream ss;
  size_t algID = 0;
 
  for ( const xAOD::TrigComposite* tc : *costDataHandle ) {
    const uint64_t start = tc->getDetail<uint64_t>("start"); // in mus
    const uint64_t stop  = tc->getDetail<uint64_t>("stop"); // in mus
    const uint32_t slot  = tc->getDetail<uint32_t>("slot");
    const uint64_t start_ms_round = std::llround( start * 1e-3 ); // in ms
    const uint64_t stop_ms_round  = std::llround( stop  * 1e-3 ); // in ms
    const uint32_t threadID = tc->getDetail<uint32_t>("thread");
 
    ss << "{id:" << algID++;
    ss << ", group:" << threadID;
    ss << ", className:'slot" << slot << "'";
    ss << ", content:'" << TrigConf::HLTUtils::hash2string( tc->getDetail<TrigConf::HLTHash>("alg"), "ALG");
    ss << "<br>" << TrigConf::HLTUtils::hash2string( tc->getDetail<TrigConf::HLTHash>("store"), "STORE") << "'";
    ss << ", duration:" << (stop - start); // For tooltip display: in mus
    ss << ", start:" << start_ms_round; // in ms
    if (stop_ms_round > start_ms_round) {
      ss << ", end:" << stop_ms_round;
    } else {
      ss << ", type:'point'";
    }
    ss  << "}," << std::endl;
  }
 
  ATH_MSG_DEBUG("Full Event Summary for event " << context.eventID().event_number());
  ATH_MSG_DEBUG(ss.str());
  // TODO Persist this
 
  return StatusCode::SUCCESS;
}

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode TrigCostAnalysis::execute ( )

finalvirtual

Monitor event, unless max range limit reached and event outside of all ranges.

Definition at line 184 of file TrigCostAnalysis.cxx.

                                     {
  const EventContext& context = Gaudi::Hive::currentContext();
 
  MonitoredRange* range = nullptr;
  ATH_CHECK(getRange(context, range));
 
  if (!range) {
 
    ATH_MSG_DEBUG("Not monitoring event");
    return StatusCode::SUCCESS;
 
  }
 
  ATH_MSG_DEBUG("Monitoring event " << context.eventID().event_number() << " in LB " << context.eventID().lumi_block() << " in range " << range->getName());
  
  SG::ReadHandle<xAOD::TrigCompositeContainer> costDataHandle(m_costDataKey, context);
  ATH_CHECK( costDataHandle.isValid() );
 
  SG::ReadHandle<xAOD::TrigCompositeContainer> rosDataHandle(m_rosDataKey, context);
  ATH_CHECK( rosDataHandle.isValid() );
 
 
  if (!m_metadataDataKey.empty()){
    SG::ReadHandle<xAOD::TrigCompositeContainer> metadataDataHandle(m_metadataDataKey, context);
    if (metadataDataHandle.isValid()){
      for (const xAOD::TrigComposite* tc : *metadataDataHandle) {
        try {
          std::lock_guard<std::mutex> lock(m_addHostnameMutex);
          const std::string hostname = tc->getDetail<std::string>("hostname");
          m_hostnames.insert(hostname);
        } catch ( const std::exception& ) {
          ATH_MSG_WARNING("Missing HLT_RuntimeMetadata EDM hostname for event " << context.eventID().event_number());
        }
 
      }
    } 
    else {
      ATH_MSG_DEBUG("Not valid HLT_RuntimeMetadata handle for the event " << context.eventID().event_number());
    }
  }
 
  // Save indexes of algorithm in costDataHandle
  std::map<std::string, std::set<size_t>> chainToAlgIdx;
  std::map<std::string, std::set<size_t>> chainToUniqAlgs; // List for unique algorithms for each chain
  std::map<std::string, std::map<int16_t, std::set<size_t>>> seqToAlgIdx; // Map of algorithms split in views
  std::map<std::string, std::set<std::string>> algToChain;
  m_algToChainTool->cacheSGKeys(context);
  ATH_CHECK( m_algToChainTool->getChainsForAllAlgs(context, algToChain) );
 
  // Retrieve active sequences and algorithms
  std::map<std::string, std::string> algToSeq;
  ATH_CHECK(m_algToChainTool->getAllActiveSequences(context, algToSeq));
 
  for (const xAOD::TrigComposite* tc : *costDataHandle) {
    const uint32_t nameHash = tc->getDetail<TrigConf::HLTHash>("alg");
    const std::string algName = TrigConf::HLTUtils::hash2string(nameHash, "ALG");
 
    size_t i = 0;
    for (const std::string& chain : algToChain[algName]){
      chainToAlgIdx[chain].insert(tc->index());
      ++i;
    }
 
    if (i == 1){
      ATH_MSG_DEBUG("Algorithm " << algName << " executed uniquely for " << *algToChain[algName].begin() << " chain");
      chainToUniqAlgs[*algToChain[algName].begin()].insert(tc->index());
    }
 
    if (algToSeq.count(algName)){
      const int16_t view = tc->getDetail<int16_t>("view");
      seqToAlgIdx[algToSeq[algName]][view].insert(tc->index());
    }
  }
 
  const std::set<TrigCompositeUtils::DecisionID> seededChains = m_algToChainTool->retrieveActiveChains(context, "HLTNav_L1");
  std::vector<TrigCompositeUtils::AlgToChainTool::ChainInfo> seededChainsInfo;
 
  // Skip empty events, where only cost chain was active
  bool skipMonitoringThisEvent = false;
  if ((seededChains.size() == 1 && seededChains.count(TrigConf::HLTUtils::string2hash("HLT_noalg_CostMonDS_L1All")))
    || (seededChains.size() == 2 && seededChains.count(TrigConf::HLTUtils::string2hash("HLT_noalg_CostMonDS_L1All")) && seededChains.count(TrigConf::HLTUtils::string2hash("HLT_noalg_L1All"))) ){
    skipMonitoringThisEvent = true;
  }
 
  for (auto id : seededChains){
      TrigCompositeUtils::AlgToChainTool::ChainInfo chainInfo;
      ATH_CHECK(m_algToChainTool->getChainInfo(context, id, chainInfo));
      seededChainsInfo.push_back(chainInfo);
  }
 
  const uint32_t onlineSlot = getOnlineSlot( costDataHandle.get() );
  CostData costData;
  ATH_CHECK( costData.set(costDataHandle.get(), rosDataHandle.get(), onlineSlot) );
  costData.setCostROSData(m_costROSData);
  costData.setChainToAlgMap(chainToAlgIdx);
  costData.setChainToUniqAlgMap(chainToUniqAlgs);
  costData.setSequencersMap(seqToAlgIdx);
  costData.setSeededChains(seededChainsInfo);
  costData.setLb( context.eventID().lumi_block() );
  costData.setTypeMap( m_algTypeMap );
  if (!m_enhancedBiasTool.name().empty() && !m_enhancedBiasTool->isMC()) {
    double liveTime = m_enhancedBiasTool->getEBLiveTime(context);
    bool liveTimeIsPerEvent = true;
    if (liveTime == 0.0) { // Note: This comes from a direct "return 0.", hence no delta
      liveTime = m_enhancedBiasTool->getLBLength(context);
      liveTimeIsPerEvent = false;
    }
    costData.setLivetime( liveTime, liveTimeIsPerEvent );
  }
 
  ATH_CHECK( range->newEvent( costData, getWeight(context), skipMonitoringThisEvent ) );
 
  if (checkDoFullEventDump(context, costData)) {
    ATH_CHECK( dumpEvent(context) );
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode TrigCostAnalysis::finalize ( )

finalvirtual

Currently a noop for this algorithm.

Definition at line 459 of file TrigCostAnalysis.cxx.

                                      {
  ATH_MSG_VERBOSE("In finalize()");
 
  writeMetadata();
  return StatusCode::SUCCESS;
}

getOnlineSlot()

uint32_t TrigCostAnalysis::getOnlineSlot ( const xAOD::TrigCompositeContainer *  costCollection ) const

private

Return the slot used to process the event online.

Parameters

[in]

costCollection

Cost data.

Returns

Oneline slot number..

Definition at line 401 of file TrigCostAnalysis.cxx.

                                                                                               {
  // Online, Slot 0 can be configured as the master-slot. In this mode, events in Slot 0
  // hoover up data about algorithm executions in other slots too.
  // This all-slots data stored in the master slot is exploited by dumpEvent, and some specialist monitors.
  // Other monitors will want to avoid it for fear of double-counting 
  if (costCollection->size() == 0) {
    return 0;
  }
  const uint32_t initialSlot = costCollection->at(0)->getDetail<uint32_t>("slot");
  for ( const xAOD::TrigComposite* tc : *costCollection ) {
    const uint32_t algSlot = tc->getDetail<uint32_t>("slot");
    if (algSlot == 0 or algSlot != initialSlot) {
      return 0; // If we see a zero, or two different slot numbers, then we're in the master slot
    }
  }
  // If we saw exclusivly one non-zero slot, then we're in that slot
  return initialSlot;
}

getRange()

StatusCode TrigCostAnalysis::getRange ( const EventContext &  context, MonitoredRange *&  range  )

private

Return or construct and return a Range for the Context.

Might return nullptr range.

Parameters

[in]	context	Event context.
[out]	range	Reference to a mutable range ptr. Will be set to point to the Range. If range does not exist it will be created unless the maximum number of ranges has been reached. If this happens, range will be set to nullptr.

Definition at line 361 of file TrigCostAnalysis.cxx.

                                                                                         {
  std::string rangeName;
  range = nullptr;
  bool includeEndOfLB = false;
 
  if (m_singleTimeRange) {
    rangeName = m_singleTimeRangeName;
  } else {
    const EventIDBase::number_type lumiBlock = context.eventID().lumi_block();
    const size_t lumiBlockRangeStart = lumiBlock - (lumiBlock % m_TimeRangeLengthLB);
    const size_t lumiBlockRangeStop  = lumiBlockRangeStart + m_TimeRangeLengthLB - 1;
    std::stringstream ss;
    ss << "LumiBlock_" << std::setfill('0') << std::setw(5) << lumiBlockRangeStart;
    if (includeEndOfLB && lumiBlockRangeStop != lumiBlockRangeStart) {
      ss << "_" << lumiBlockRangeStop;
    }
    rangeName = ss.str();
  }
 
  std::unordered_map<std::string, std::unique_ptr<MonitoredRange>>::iterator it;
  it = m_monitoredRanges.find(rangeName);
 
  // If we don't have a MonitoredRange with this name, try and make one.
  if (it == m_monitoredRanges.end()) {
    if (m_monitoredRanges.size() < m_maxTimeRange) {
      auto result = m_monitoredRanges.insert( 
        std::make_pair(rangeName, std::make_unique<MonitoredRange>(rangeName, this))
      );
      it = result.first; // Returns pair. First: map iterator. Second: insertion boolean
      ATH_CHECK(registerMonitors( it->second.get() ));
    } else {
      range = nullptr; // Not monitoring any more ranges
      return StatusCode::SUCCESS;
    }
  }
 
  range = it->second.get(); // Pointer to MonitoredRange
  return StatusCode::SUCCESS;
}

getWeight()

float TrigCostAnalysis::getWeight ( const EventContext &  context )

private

Compute global event weight to correct for online prescales.

Parameters

[in]

context

Event context.

Returns

Global event weight.

Definition at line 160 of file TrigCostAnalysis.cxx.

                                                             {
  // TODO Prescale of CostMon chain for P1
  double ebWeight = 1.0;
  if (m_useEBWeights) {
    ebWeight = m_enhancedBiasTool->getEBWeight(context);
    ATH_MSG_DEBUG("EB Weight is " << ebWeight);
  }
  return m_baseEventWeight * ebWeight;
}

initialize()

StatusCode TrigCostAnalysis::initialize ( )

finalvirtual

Retrieve tools and initialise read handles.

Definition at line 34 of file TrigCostAnalysis.cxx.

                                         {
  ATH_MSG_VERBOSE("In initialize()");
 
  ATH_MSG_DEBUG("Reading from " << m_costDataKey.key() << ", " << m_HLTMenuKey.key());
  ATH_CHECK( m_costDataKey.initialize() );
  ATH_CHECK( m_rosDataKey.initialize() );
  ATH_CHECK( m_HLTMenuKey.initialize() );
 
  ATH_CHECK( m_metadataDataKey.initialize( SG::AllowEmpty ) );
 
 
  if (!m_enhancedBiasTool.name().empty()) {
    ATH_CHECK( m_enhancedBiasTool.retrieve() );
  } else {
    ATH_MSG_DEBUG("No EnhancedBiasTool. Not doing additional weighting.");
    if (m_useEBWeights) {
      ATH_MSG_FATAL("Configured to use Enhanced Bias weights. Must supply weighting tool.");
      return StatusCode::FAILURE;
    }
  }
 
  ATH_CHECK( m_TimeRangeLengthLB > 0 );
 
  if (not m_additionalHashMap.empty()) {
    std::string hashFile = PathResolverFindCalibFile( m_additionalHashMap );
    if (hashFile.empty()) {
      ATH_MSG_WARNING("Could not retrieve " << m_additionalHashMap << ", won't load additional hash maps.");
    } else {
      TrigConf::HLTUtils::file2hashes(hashFile);
    }
  }
 
  m_costROSData.initialize(m_rosToRob);
  
  ATH_CHECK( m_histSvc->regTree("/COSTSTREAM/metadata", std::make_unique<TTree>("metadata", "metadata")) );
  ATH_CHECK( m_histSvc->getTree("/COSTSTREAM/metadata", m_metadataTree) );
  
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

registerMonitors()

StatusCode TrigCostAnalysis::registerMonitors ( MonitoredRange *  range )

private

Populate a newly minted Range object with all configured Monitors.

Parameters

[in]

range

Mutable ptr to new Range object which is to be populated.

Definition at line 316 of file TrigCostAnalysis.cxx.

                                                                   {
  ATH_CHECK(range != nullptr);
  if (m_doMonitorAlgorithm) {
    ATH_CHECK( range->addMonitor(std::make_unique<MonitorAlgorithm>("Algorithm_HLT", range)) );
    ATH_MSG_DEBUG("Registering Algorithm_HLT Monitor for range " << range->getName() << ". Size:" << range->getMonitors().size());
  }
  if (m_doMonitorAlgorithmClass) {
    ATH_CHECK( range->addMonitor(std::make_unique<MonitorAlgorithmClass>("Algorithm_Class_HLT", range)) );
    ATH_MSG_DEBUG("Registering Algorithm_Class_HLT Monitor for range " << range->getName() << ". Size:" << range->getMonitors().size());
  }
  if (m_doMonitorGlobal) {
    ATH_CHECK( range->addMonitor(std::make_unique<MonitorGlobal>("Global_HLT", range)) );
    ATH_MSG_DEBUG("Registering Global_HLT Monitor for range " << range->getName() << ". Size:" << range->getMonitors().size());
  }
  if (m_doMonitorThreadOccupancy) {
    ATH_CHECK( range->addMonitor(std::make_unique<MonitorThreadOccupancy>("Thread_Occupancy_HLT", range)) );
    ATH_MSG_DEBUG("Registering Thread_Occupancy_HLT Monitor for range " << range->getName() << ". Size:" << range->getMonitors().size());
  }
  if (m_doMonitorROS) {
    ATH_CHECK( range->addMonitor(std::make_unique<MonitorROS>("ROS_HLT", range)) );
    ATH_MSG_DEBUG("Registering ROS_HLT Monitor for range " << range->getName() << ". Size:" << range->getMonitors().size());
  }
  if (m_doMonitorChain) {
    ATH_CHECK( range->addMonitor(std::make_unique<MonitorChain>("Chain_HLT", range)) );
    ATH_MSG_DEBUG("Registering Chain_HLT Monitor for range " << range->getName() << ". Size:" << range->getMonitors().size());
  }
  if (m_doMonitorChainAlgorithm) {
    ATH_CHECK( range->addMonitor(std::make_unique<MonitorChainAlgorithm>("Chain_Algorithm_HLT", range)) );
    ATH_MSG_DEBUG("Registering Chain_Algorihtm_HLT Monitor for range " << range->getName() << ". Size:" << range->getMonitors().size());
  }
  if (m_doMonitorSequence) {
    ATH_CHECK( range->addMonitor(std::make_unique<MonitorSequence>("Sequence_HLT", range)) );
    ATH_MSG_DEBUG("Registering Sequence_HLT Monitor for range " << range->getName() << ". Size:" << range->getMonitors().size());
  }
  // if (m_do...) {}
  
  // Set the verbosity for the monitors
  for (const std::unique_ptr<MonitorBase>& monitor : range->getMonitors()){
    monitor->msg().setLevel(msg().level());
  }
 
  return StatusCode::SUCCESS;
}

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

start()

StatusCode TrigCostAnalysis::start ( )

virtual

Retrieve menu handle.

Definition at line 74 of file TrigCostAnalysis.cxx.

                                   {
  SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
  ATH_CHECK( hltMenuHandle.isValid() );
  ATH_MSG_INFO("Configuring from " << m_HLTMenuKey << " with " << hltMenuHandle->size() << " chains");
  using boost::property_tree::ptree; 
 
  // Populate the reverse-hashing dictionary with all ALG NAMES.
  // Obtain a mapping from NAME to TYPE from the configuration JSON 
  m_storeIdentifiers.clear();
  const ptree& menuData =  hltMenuHandle->data();
  for (const auto& sequencer : menuData.get_child("sequencers")) {
    ATH_MSG_VERBOSE("Found Sequencer:" << sequencer.first);
    for (const auto& alg : sequencer.second) {
      // Data stored in Gaudi format of "AlgClassType/AlgInstanceName"
      size_t breakPoint = alg.second.data().find('/');
      std::string algType = alg.second.data().substr(0, breakPoint);
      std::string algName = alg.second.data().substr(breakPoint+1, alg.second.data().size());
      std::replace(algType.begin(), algType.end(), ':', '_');
      std::replace(algName.begin(), algName.end(), ':', '_');
      m_algTypeMap[ TrigConf::HLTUtils::string2hash(algName, "ALG") ] = algType;
      ATH_MSG_VERBOSE("AlgType:" << algType << ", AlgName:" << algName );
      if (algType.find("EventViewCreatorAlgorithm") != std::string::npos) {
        ATH_MSG_VERBOSE(algType << " is identified as a ViewCreator");
        m_storeIdentifiers.insert(algName);
      }
    }
  }
 
  // Call TrigConf::HLTUtils::string2hash(chain.name()) for all the chains to cache the hash to name mapping
  std::vector<TrigConf::Chain> chains;
  ATH_CHECK( m_algToChainTool->getAllChains(chains));
  for (const TrigConf::Chain& chain : chains) {
    HLT::Identifier(chain.name());
    TrigConf::HLTUtils::string2hash(chain.name());
 
    // Populate legs' names
    const size_t legsSize {chain.legMultiplicities().size()};
    for (size_t counter = 0; legsSize > 1 && counter < legsSize; ++counter){
      HLT::Identifier l = TrigCompositeUtils::createLegName(chain.namehash(), counter);
      TrigConf::HLTUtils::string2hash(l.name());
    }
  }
 
  // Save identifiers and classes for additional HLTJobOptions map
  if (not m_additionalHashList.empty()){
    for (const std::string& entry : m_additionalHashList){
      size_t breakPoint = entry.find('/');
      if (breakPoint != std::string::npos){
        std::string algType = entry.substr(0, breakPoint);
        const std::string algName = entry.substr(breakPoint+1, entry.size());
        std::replace(algType.begin(), algType.end(), ':', '_');
        m_algTypeMap[ TrigConf::HLTUtils::string2hash(algName, "ALG") ] = std::move(algType);
      } else {
        TrigConf::HLTUtils::string2hash(entry, "ALG");
      }
    }
  }
 
  // As an initial guess, 25 should be a good uper maximum for the number of expected View instances.
  ATH_CHECK( checkUpdateMaxView(60) );
  return StatusCode::SUCCESS;
}

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

writeMetadata()

void TrigCostAnalysis::writeMetadata ( )

private

Write to outpute tree (if any) the metadata needed downstream.

Definition at line 467 of file TrigCostAnalysis.cxx.

                                     {
  if (!m_metadataTree) {
    return;
  }
 
  auto runNumber = m_enhancedBiasTool->getRunNumber();
  m_metadataTree->Branch("runNumber", &runNumber);
 
  std::string hostnamesList = "";
  if (m_hostnames.size() > 1){
    ATH_MSG_DEBUG("Found many hostnames for this run");
    for (const auto& name : m_hostnames) hostnamesList += name + ",";
    hostnamesList.pop_back();
  } else if (m_hostnames.size() == 1) {
    hostnamesList = *m_hostnames.begin();
  }
  m_metadataTree->Branch("hostname", &hostnamesList);
 
  SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
  std::string menuStr;
  if ( hltMenuHandle.isValid() ){
    std::stringstream ss;
    boost::property_tree::json_parser::write_json(ss, hltMenuHandle->data());
    menuStr = ss.str();
    m_metadataTree->Branch("HLTMenu", &menuStr);
  }
 
  bool ChainMonitor = (const bool&) m_doMonitorChain;
  bool ChainAlgorithmMonitor = (const bool&) m_doMonitorChainAlgorithm;
  bool AlgorithmMonitor = (const bool&) m_doMonitorAlgorithm;
  bool AlgorithmClassMonitor = (const bool&) m_doMonitorAlgorithmClass;
  bool ROSMonitor = (const bool&) m_doMonitorROS;
  bool GlobalsMonitor = (const bool&) m_doMonitorGlobal;
  bool ThreadMonitor = (const bool&) m_doMonitorThreadOccupancy;
 
  m_metadataTree->Branch("ChainMonitor", &ChainMonitor);
  m_metadataTree->Branch("ChainAlgorithmMonitor", &ChainAlgorithmMonitor);
  m_metadataTree->Branch("AlgorithmMonitor", &AlgorithmMonitor);
  m_metadataTree->Branch("AlgorithmClassMonitor", &AlgorithmClassMonitor);
  m_metadataTree->Branch("ROSMonitor", &ROSMonitor);
  m_metadataTree->Branch("GlobalsMonitor", &GlobalsMonitor);
  m_metadataTree->Branch("ThreadMonitor", &ThreadMonitor);
 
  float BaseEventWeight = (const float&) m_baseEventWeight;
  std::string AdditionalHashMap = (const std::string&) m_additionalHashMap;
  bool DoEBWeighting = (const bool&) m_useEBWeights;
 
  m_metadataTree->Branch("AdditionalHashMap", &AdditionalHashMap);
  m_metadataTree->Branch("DoEBWeighting", &DoEBWeighting);
  m_metadataTree->Branch("BaseEventWeight", &BaseEventWeight);
 
  std::string atlasProject = std::getenv("AtlasProject");
  std::string atlasVersion = std::getenv("AtlasVersion");
  m_metadataTree->Branch("AtlasProject", &atlasProject);
  m_metadataTree->Branch("AtlasVersion", &atlasVersion);
 
 
  std::string processedRanges;
  if (m_singleTimeRange){
    processedRanges = m_singleTimeRangeName;
  }
  else {
    std::stringstream ss;
    for(const auto& rangePair : m_monitoredRanges){
      ss << rangePair.first << ": ";
      std::string lbrange = rangePair.first.substr(strlen("LumiBlock_"));
      ss << " Lumiblocks " <<  std::stoi(lbrange) << " to " << std::stoi(lbrange) + m_TimeRangeLengthLB << ", ";
    }
    processedRanges = ss.str();
    ATH_MSG_INFO("Processed ranges: " << processedRanges);
  }
 
  m_metadataTree->Branch("ProcessedRanges", &processedRanges);
 
  m_metadataTree->Fill();
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::set<std::string> m_hostnames TrigCostAnalysis::ATLAS_THREAD_SAFE

mutableprivate

Save unique hostnames for the run.

Definition at line 220 of file TrigCostAnalysis.h.

m_addHostnameMutex

std::mutex TrigCostAnalysis::m_addHostnameMutex

private

Mutex to update set below.

Definition at line 219 of file TrigCostAnalysis.h.

m_additionalHashList

Gaudi::Property<std::vector<std::string> > TrigCostAnalysis::m_additionalHashList

Initial value:

{ this, "AdditionalHashList", {},
      "Used to load strings corresponding to algorithms which are not explicitly scheduled by chains." }

Definition at line 90 of file TrigCostAnalysis.h.

m_additionalHashMap

Gaudi::Property<std::string> TrigCostAnalysis::m_additionalHashMap

Initial value:

{ this, "AdditionalHashMap", "TrigCostRootAnalysis/hashes2string_29042021.txt",
      "Used to load strings corresponding to algorithms which are not explicitly scheduled by chains. To be updated periodically." }

Definition at line 87 of file TrigCostAnalysis.h.

m_algToChainTool

ToolHandle<TrigCompositeUtils::AlgToChainTool> TrigCostAnalysis::m_algToChainTool

Initial value:

{this, "AlgToChainTool", "",
      "Tool to retrieve chains for algorithm."}

Definition at line 153 of file TrigCostAnalysis.h.

m_algTypeMap

std::unordered_map<uint32_t, std::string > TrigCostAnalysis::m_algTypeMap

private

Cache of algorithm's type, read from configuration data.

Definition at line 213 of file TrigCostAnalysis.h.

m_baseEventWeight

Gaudi::Property<float> TrigCostAnalysis::m_baseEventWeight

Initial value:

{ this, "BaseEventWeight", true,
      "Base events weight, other weights may be multiplied on top of this one." }

Definition at line 132 of file TrigCostAnalysis.h.

m_costDataKey

SG::ReadHandleKey<xAOD::TrigCompositeContainer> TrigCostAnalysis::m_costDataKey

Initial value:

{ this, "CostReadHandleKey", "HLT_TrigCostContainer",
      "Trigger cost payload container for algorithms" }

Definition at line 138 of file TrigCostAnalysis.h.

m_costROSData

CostROSData TrigCostAnalysis::m_costROSData

private

Cached CostROSData class with details needed for ROS monitoring.

Definition at line 222 of file TrigCostAnalysis.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doMonitorAlgorithm

Gaudi::Property<bool> TrigCostAnalysis::m_doMonitorAlgorithm

Initial value:

{ this, "DoMonitorAlgs", true,
      "Monitor individual algorithms by instance name" }

Definition at line 99 of file TrigCostAnalysis.h.

m_doMonitorAlgorithmClass

Gaudi::Property<bool> TrigCostAnalysis::m_doMonitorAlgorithmClass

Initial value:

{ this, "DoMonitorAlgClass", true,
      "Monitor individual algorithms by instance class type name" }

Definition at line 102 of file TrigCostAnalysis.h.

m_doMonitorChain

Gaudi::Property<bool> TrigCostAnalysis::m_doMonitorChain

Initial value:

{ this, "DoMonitorChain", true,
      "Monitor individual chains by instance name" }

Definition at line 114 of file TrigCostAnalysis.h.

m_doMonitorChainAlgorithm

Gaudi::Property<bool> TrigCostAnalysis::m_doMonitorChainAlgorithm

Initial value:

{ this, "DoMonitorChainAlgorithm", false,
      "Monitor algorithms associated with chains by instance name" }

Definition at line 117 of file TrigCostAnalysis.h.

m_doMonitorGlobal

Gaudi::Property<bool> TrigCostAnalysis::m_doMonitorGlobal

Initial value:

{ this, "DoMonitorGlobal", true,
      "Monitor global event properties" }

Definition at line 105 of file TrigCostAnalysis.h.

m_doMonitorROS

Gaudi::Property<bool> TrigCostAnalysis::m_doMonitorROS

Initial value:

{ this, "DoMonitorROS", true,
      "Monitor Read-Out System" }

Definition at line 111 of file TrigCostAnalysis.h.

m_doMonitorSequence

Gaudi::Property<bool> TrigCostAnalysis::m_doMonitorSequence

Initial value:

{ this, "DoMonitorSequence", true,
      "Monitor individual sequences by name" }

Definition at line 120 of file TrigCostAnalysis.h.

m_doMonitorThreadOccupancy

Gaudi::Property<bool> TrigCostAnalysis::m_doMonitorThreadOccupancy

Initial value:

{ this, "DoMonitorThreadOccupancy", true,
      "Monitor algorithm occupancy load of individual threads in an MT execution environment" }

Definition at line 108 of file TrigCostAnalysis.h.

m_enhancedBiasTool

ToolHandle<IEnhancedBiasWeighter> TrigCostAnalysis::m_enhancedBiasTool

Initial value:

{this, "EnhancedBiasTool", "",
      "Enhanced bias weighting tool."}

Definition at line 150 of file TrigCostAnalysis.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_fullEventDumpProbability

Gaudi::Property<uint64_t> TrigCostAnalysis::m_fullEventDumpProbability

Initial value:

{ this, "FullEventDumpProbability", 10,
      "Save a full record of one in every N events, up to MaxFullEventDumps." }

Definition at line 129 of file TrigCostAnalysis.h.

m_fullEventDumps

std::atomic<size_t> TrigCostAnalysis::m_fullEventDumps

mutableprivate

Counter to keep track of how many events have been full-dumped.

Definition at line 217 of file TrigCostAnalysis.h.

m_histSvc

ServiceHandle<ITHistSvc> TrigCostAnalysis::m_histSvc { this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" }

Definition at line 79 of file TrigCostAnalysis.h.

m_HLTMenuKey

SG::ReadHandleKey<TrigConf::HLTMenu> TrigCostAnalysis::m_HLTMenuKey

Initial value:

{this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu",
      "HLT Menu"}

Definition at line 147 of file TrigCostAnalysis.h.

m_maxFullEventDumps

Gaudi::Property<size_t> TrigCostAnalysis::m_maxFullEventDumps

Initial value:

{ this, "MaxFullEventDumps", 10,
      "Maximum number of full event summaries which will be dumped" }

Definition at line 126 of file TrigCostAnalysis.h.

m_maxTimeRange

Gaudi::Property<size_t> TrigCostAnalysis::m_maxTimeRange

Initial value:

{ this, "MaxTimeRanges", 5,
      "Maximum number of allowed time ranges" }

Definition at line 96 of file TrigCostAnalysis.h.

m_maxViewsNumber

std::atomic<size_t> TrigCostAnalysis::m_maxViewsNumber

mutableprivate

What is the maximum number of View instances we've so far cached string hashes to cover?

Definition at line 218 of file TrigCostAnalysis.h.

m_metadataDataKey

SG::ReadHandleKey<xAOD::TrigCompositeContainer> TrigCostAnalysis::m_metadataDataKey

Initial value:

{ this, "CostMetadataWriteHandleKey", "HLT_RuntimeMetadata",
      "TrigComposite collections with additional cost metadata" }

Definition at line 144 of file TrigCostAnalysis.h.

m_metadataTree

TTree* TrigCostAnalysis::m_metadataTree

private

Used to write out some metadata needed by post-processing (e.g.

bunchgroup, lumi)

Definition at line 215 of file TrigCostAnalysis.h.

m_monitoredRanges

std::unordered_map<std::string, std::unique_ptr<MonitoredRange> > TrigCostAnalysis::m_monitoredRanges

private

Owned storage of Ranges.

Keyed on Range name.

Definition at line 212 of file TrigCostAnalysis.h.

m_rosDataKey

SG::ReadHandleKey<xAOD::TrigCompositeContainer> TrigCostAnalysis::m_rosDataKey

Initial value:

{ this, "CostROSReadHandleKey", "HLT_TrigCostROSContainer",
      "Trigger ROS cost payload container for algorithms" }

Definition at line 141 of file TrigCostAnalysis.h.

m_rosToRob

Gaudi::Property<std::map<std::string, std::vector<uint32_t> > > TrigCostAnalysis::m_rosToRob

Initial value:

{
      this, "ROSToROBMap", {}, "ROS to ROB mapping" }

Definition at line 135 of file TrigCostAnalysis.h.

m_singleTimeRange

Gaudi::Property<bool> TrigCostAnalysis::m_singleTimeRange

Initial value:

{ this, "UseSingleTimeRange", false,
      "Use a single time range rather than splitting by LB" }

Definition at line 81 of file TrigCostAnalysis.h.

m_singleTimeRangeName

Gaudi::Property<std::string> TrigCostAnalysis::m_singleTimeRangeName

Initial value:

{ this, "SingleTimeRangeName", "All",
      "Name for single time range" }

Definition at line 84 of file TrigCostAnalysis.h.

m_storeIdentifiers

std::set<std::string> TrigCostAnalysis::m_storeIdentifiers

private

Identifiers of object stores, needed to cache STORE string-hash values.

Definition at line 214 of file TrigCostAnalysis.h.

m_TimeRangeLengthLB

Gaudi::Property<size_t> TrigCostAnalysis::m_TimeRangeLengthLB

Initial value:

{ this, "TimeRangeLengthLB", 50,
      "Length of each variable length Time Range in LB" }

Definition at line 93 of file TrigCostAnalysis.h.

m_useEBWeights

Gaudi::Property<bool> TrigCostAnalysis::m_useEBWeights

Initial value:

{ this, "UseEBWeights", true,
      "Apply Enhanced Bias weights" }

Definition at line 123 of file TrigCostAnalysis.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TrigCostAnalysis.h
• TrigCostAnalysis.cxx