TrigSignatureMoni Class Reference

#include <TrigSignatureMoni.h>

Inheritance diagram for TrigSignatureMoni:

Classes
class	RateHistogram

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	execute (const EventContext &context) const override
virtual StatusCode	stop () override
virtual void	handle (const Incident &incident) override

Private Member Functions
int	nBinsX (SG::ReadHandle< TrigConf::HLTMenu > &) const
int	nBinsX () const
int	nChains (SG::ReadHandle< TrigConf::HLTMenu > &) const
int	nSteps () const
StatusCode	initHist (LockedHandle< TH2 > &, SG::ReadHandle< TrigConf::HLTMenu > &, bool=true)
StatusCode	initSeqHist (LockedHandle< TH2 > &, std::set< std::string > &)
StatusCode	fillDecisionCount (const std::vector< TrigCompositeUtils::DecisionID > &, int) const
StatusCode	fillPassEvents (const TrigCompositeUtils::DecisionIDContainer &, int) const
StatusCode	fillRate (const TrigCompositeUtils::DecisionIDContainer &, int) const
StatusCode	fillHistogram (const TrigCompositeUtils::DecisionIDContainer &, int, LockedHandle< TH2 > &) const
StatusCode	fillSequences (const std::set< std::string > &) const
StatusCode	fillStreamsAndGroups (const std::map< std::string, TrigCompositeUtils::DecisionIDContainer > &, const TrigCompositeUtils::DecisionIDContainer &, int) const

Private Attributes
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer >	m_l1DecisionsKey { this, "L1Decisions", "HLTSeedingSummary", "Chains activated after the L1" }
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer >	m_finalDecisionKey { this, "FinalDecisionKey", "HLTNav_Summary", "Final stage of all decisions" }
SG::ReadHandleKey< TrigConf::HLTMenu >	m_HLTMenuKey { this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu" }
SG::ReadHandleKey< TrigConf::L1Menu >	m_L1MenuKey { this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" }
ServiceHandle< IIncidentSvc >	m_incidentSvc { this, "IncidentSvc", "IncidentSvc", "Incident service"}
ServiceHandle< ITHistSvc >	m_histSvc { this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" }
Gaudi::Property< std::string >	m_bookingPath { this, "HistPath", "/EXPERT/HLTFramework", "Booking path for the histogram"}
Gaudi::Property< bool >	m_countLegFeatures { this, "CountLegFeatures", false, "Save features per leg as well as per chain"}
Gaudi::Property< unsigned int >	m_duration {this, "RateIntegrationDuration", 10, "Integration time for the rate histogram in seconds"}
Gaudi::Property< unsigned int >	m_intervals {this, "RateIntegrationIntervals", 6, "Number of the rate histogram publications"}
ToolHandleArray< DecisionCollectorTool >	m_decisionCollectorTools { this, "DecisionCollectorTools", {}, "Tools that collect decisions (yes/no) for steps" }
ToolHandleArray< DecisionCollectorTool >	m_featureCollectorTools { this, "FeatureCollectorTools", {}, "Tools that collect decision counts for specific features for steps" }
LockedHandle< TH2 > m_passHistogram	ATLAS_THREAD_SAFE
LockedHandle< TH2 > m_countHistogram	ATLAS_THREAD_SAFE
RateHistogram	m_rateHistogram
RateHistogram	m_sequenceHistogram
std::unordered_map< unsigned int, int >	m_chainIDToBinMap
	Chain id to histogram bin map.
std::unordered_map< std::string, int >	m_nameToBinMap
	Sequence/group/bunchgroup name to bin map.
std::unordered_map< std::string, int >	m_sequenceToBinMap
	Sequence to bin map for sequence histogram.
std::map< std::string, TrigCompositeUtils::DecisionIDContainer >	m_groupToChainMap
	Group name to chain objects map.
std::map< std::string, TrigCompositeUtils::DecisionIDContainer >	m_streamToChainMap
	Stream name to chain objects map, excluding express.
std::map< std::string, TrigCompositeUtils::DecisionIDContainer >	m_expressChainMap
	Stream name to chain objects map, including only express.

Detailed Description

Definition at line 37 of file TrigSignatureMoni.h.

Member Function Documentation

execute()

StatusCode TrigSignatureMoni::execute ( const EventContext & context ) const

overridevirtual

Definition at line 324 of file TrigSignatureMoni.cxx.

                                                                         {
 
  SG::ReadHandle<TrigCompositeUtils::DecisionContainer> l1Decisions = SG::makeHandle(m_l1DecisionsKey, context);
 
  [[maybe_unused]] static const bool sanityCheckDone = [&] {
    if (l1Decisions->at(INPUT-1)->name() == "l1seeded" &&
        l1Decisions->at(AFTER_PS-1)->name() == "unprescaled") {
      return true;
    }
    throw GaudiException(m_l1DecisionsKey.key() + " does not contain the expected entries",
                         name(), StatusCode::FAILURE);
  }();
 
  auto fillL1 = [&](int index) -> StatusCode {    
    TrigCompositeUtils::DecisionIDContainer ids;    
    TrigCompositeUtils::decisionIDs(l1Decisions->at(index-1), ids);
    ATH_MSG_DEBUG( "L1 " << index-1 << " N positive decisions " << ids.size()  );
    ATH_CHECK(fillStreamsAndGroups(m_groupToChainMap, ids, index));
    ATH_CHECK(fillPassEvents(ids, index));
    ATH_CHECK(fillRate(ids, index));
    if (!ids.empty()){
      m_passHistogram->Fill(1, static_cast<double>(index));
      m_rateHistogram.fill(1, static_cast<double>(index));
    }
    return StatusCode::SUCCESS;
  };
 
  // Fill histograms with L1 decisions in and after prescale
  ATH_CHECK(fillL1(INPUT));
  ATH_CHECK(fillL1(AFTER_PS));
 
  // Fill HLT steps
  int step = 0;
  std::vector<TrigCompositeUtils::DecisionID> stepSum;
  std::set<std::string> stepSequences;
  for ( auto& ctool: m_decisionCollectorTools ) {
    ctool->getDecisions( stepSum, stepSequences, context );
    ATH_MSG_DEBUG( " Step " << step << " decisions (for decisions): " << stepSum.size() );
    TrigCompositeUtils::DecisionIDContainer stepUniqueSum( stepSum.begin(), stepSum.end() );
    ATH_CHECK( fillPassEvents( stepUniqueSum, 3+step ) );
    ATH_CHECK( fillSequences( stepSequences ) );
    ++step;
    stepSum.clear();
    stepSequences.clear();
  }
 
  step = 0;
  for ( auto& ctool: m_featureCollectorTools ) {
    stepSum.clear();
    ctool->getDecisions( stepSum, context );
    ATH_MSG_DEBUG( " Step " << step << " decisions (for features): " << stepSum.size() );
    ATH_CHECK( fillDecisionCount( stepSum, 3+step ) );
    ++step;
  }
 
  // Collect the final decisions
  SG::ReadHandle<TrigCompositeUtils::DecisionContainer> finalDecisionsHandle = SG::makeHandle( m_finalDecisionKey, context );
  ATH_CHECK( finalDecisionsHandle.isValid() );
  TrigCompositeUtils::DecisionIDContainer finalIDs;
  const TrigCompositeUtils::Decision* decisionObject = TrigCompositeUtils::getTerminusNode(*finalDecisionsHandle);
  if (!decisionObject) {
    ATH_MSG_WARNING("Unable to locate trigger navigation terminus node. Cannot tell which chains passed the event.");
  } else {
    TrigCompositeUtils::decisionIDs(decisionObject, finalIDs);
  }
 
  // Collect the express stream decisions
  TrigCompositeUtils::DecisionIDContainer expressFinalIDs;
  const TrigCompositeUtils::Decision* expressDecisionObject = TrigCompositeUtils::getExpressTerminusNode(*finalDecisionsHandle);
  if (!expressDecisionObject) {
    ATH_MSG_WARNING("Unable to locate trigger navigation express terminus node. Cannot tell which chains passed the express stream in this event.");
  } else {
    TrigCompositeUtils::decisionIDs(expressDecisionObject, expressFinalIDs);
  }
 
  // Fill the histograms with output counts/rate
  const int countOutputRow {nSteps() + OUTPUT};
  ATH_CHECK( fillStreamsAndGroups(m_streamToChainMap, finalIDs, OUTPUT));
  ATH_CHECK( fillStreamsAndGroups(m_groupToChainMap, finalIDs, OUTPUT));
  ATH_CHECK( fillPassEvents(finalIDs, countOutputRow));
  ATH_CHECK( fillRate(finalIDs, OUTPUT));
 
  // Fill the histograms with express counts/rate
  const int countExpressRow {nSteps() + EXPRESS};
  // express stream rate is filled into OUTPUT bin on purpose
  ATH_CHECK( fillStreamsAndGroups(m_expressChainMap, expressFinalIDs, OUTPUT));
  ATH_CHECK( fillStreamsAndGroups(m_groupToChainMap, expressFinalIDs, EXPRESS));
  ATH_CHECK( fillPassEvents(expressFinalIDs, countExpressRow));
  ATH_CHECK( fillRate(expressFinalIDs, EXPRESS));
 
  // Fill the "All" column in counts/rate histograms
  if (!finalIDs.empty()) {
    m_passHistogram->Fill(1, static_cast<double>(countOutputRow));
    m_rateHistogram.fill(1, static_cast<double>(OUTPUT));
  }
  if (!expressFinalIDs.empty()) {
    m_passHistogram->Fill(1, static_cast<double>(countExpressRow));
    m_rateHistogram.fill(1, static_cast<double>(EXPRESS));
  }
 
  return StatusCode::SUCCESS;
}

fillDecisionCount()

StatusCode TrigSignatureMoni::fillDecisionCount ( const std::vector< TrigCompositeUtils::DecisionID > & dc, int row ) const

private

Definition at line 260 of file TrigSignatureMoni.cxx.

                                                                                                                {
  for (TrigCompositeUtils::DecisionID id : dc)  {
    if (!m_countLegFeatures && TrigCompositeUtils::isLegId(HLT::Identifier(id)))  {continue;}
    auto id2bin = m_chainIDToBinMap.find( id );
    if ( id2bin == m_chainIDToBinMap.end()) {    
      ATH_MSG_WARNING("HLT chain " << HLT::Identifier(id) << " not configured to be monitored");
    } else {
      ATH_MSG_VERBOSE( "Filling histogram for " << HLT::Identifier(id).name() << " ==> bin " << id2bin->second);
      m_countHistogram->Fill(id2bin->second, static_cast<double>(row));
    }
  }
 
  return StatusCode::SUCCESS;
}

fillHistogram()

StatusCode TrigSignatureMoni::fillHistogram ( const TrigCompositeUtils::DecisionIDContainer & dc, int row, LockedHandle< TH2 > & histogram ) const

private

Definition at line 231 of file TrigSignatureMoni.cxx.

                                                                                                                                        {
 
  // This locks the histogram handle for the entire duration of the function,
  // which is faster than (un)locking the handle many times during the loop.
  auto lockedHist = *histogram;
 
  for (TrigCompositeUtils::DecisionID id : dc)  {
    auto id2bin = m_chainIDToBinMap.find( id );
    // Can ignore leg IDs if we are not explicitly saving their counts
    if ( id2bin == m_chainIDToBinMap.end() ) {
      if (!(!m_countLegFeatures && TrigCompositeUtils::isLegId(HLT::Identifier(id)))) {
        ATH_MSG_WARNING( "HLT chain " << HLT::Identifier(id) << " not configured to be monitored" );
      }
    } else {
      ATH_MSG_VERBOSE( "Filling histogram for " << HLT::Identifier(id).name() << " ==> bin " << id2bin->second );
      lockedHist->Fill( id2bin->second, static_cast<double>(row) );
    }
  }
  return StatusCode::SUCCESS;
}

fillPassEvents()

StatusCode TrigSignatureMoni::fillPassEvents ( const TrigCompositeUtils::DecisionIDContainer & dc, int row ) const

private

Definition at line 256 of file TrigSignatureMoni.cxx.

                                                                                                           {
  return fillHistogram(dc, row, m_passHistogram);
}

fillRate()

StatusCode TrigSignatureMoni::fillRate ( const TrigCompositeUtils::DecisionIDContainer & dc, int row ) const

private

Definition at line 252 of file TrigSignatureMoni.cxx.

                                                                                                     {
  return fillHistogram(dc, row, m_rateHistogram.getBuffer());
}

fillSequences()

StatusCode TrigSignatureMoni::fillSequences ( const std::set< std::string > & sequences ) const

private

Definition at line 275 of file TrigSignatureMoni.cxx.

                                                                                    {
  for (const std::string& seq : sequences) {
    m_sequenceHistogram.fill(m_sequenceToBinMap.at(seq), 1);
  }
 
  return StatusCode::SUCCESS;
}

fillStreamsAndGroups()

StatusCode TrigSignatureMoni::fillStreamsAndGroups ( const std::map< std::string, TrigCompositeUtils::DecisionIDContainer > & nameToChainsMap, const TrigCompositeUtils::DecisionIDContainer & dc, int row ) const

private

Definition at line 283 of file TrigSignatureMoni.cxx.

                                                                                                                                                                                                  {
 
  // Adjust bin index for those histograms that monitor all steps
  int rowWithSteps = row;
  if (row==OUTPUT || row==EXPRESS) rowWithSteps += m_decisionCollectorTools.size();
 
  for (const auto& [name, decisions] : nameToChainsMap) {
    for (TrigCompositeUtils::DecisionID id : dc) {
      if (decisions.contains(id)) {
        const double bin = m_nameToBinMap.at(name);
        m_rateHistogram.fill(bin, row);
        m_countHistogram->Fill(bin, rowWithSteps);
        m_passHistogram->Fill(bin, rowWithSteps);
        break;
      }
    }
  }
  return StatusCode::SUCCESS;
}

handle()

void TrigSignatureMoni::handle ( const Incident & incident )

overridevirtual

Definition at line 303 of file TrigSignatureMoni.cxx.

                                                         {
  // Create and start timer after fork
  if (incident.type() == AthenaInterprocess::UpdateAfterFork::type()) {
    if (m_rateHistogram.getTimer() || m_sequenceHistogram.getTimer()) {
      ATH_MSG_WARNING("Timer is already running. UpdateAfterFork incident called more than once?");
      return;
    }
 
    // Prevent from publishing empty histograms
    if (nBinsX() > 0) {
      m_rateHistogram.startTimer(m_duration, m_intervals);
    }
    
    if (!m_sequenceToBinMap.empty()) {
      m_sequenceHistogram.startTimer(m_duration, m_intervals);
    }    
    
    ATH_MSG_DEBUG("Started rate timer");
  }
}

initHist()

StatusCode TrigSignatureMoni::initHist ( LockedHandle< TH2 > & hist, SG::ReadHandle< TrigConf::HLTMenu > & hltMenuHandle, bool steps = true )

private

Definition at line 451 of file TrigSignatureMoni.cxx.

                                                                                                                        {
  TAxis* x = hist->GetXaxis();
  x->SetBinLabel(1, "All");
  int bin = 2; // 1 is for total count, (remember bin numbering in ROOT starts from 1)
 
  std::set<std::string> sortedChainsList;
  std::map<unsigned int,size_t> chainMultiplicities;
  for ( const TrigConf::Chain& chain: *hltMenuHandle ) {
    sortedChainsList.insert( chain.name() );
    // if counting features, record the number of legs for later
    if(m_countLegFeatures) {
      std::vector<size_t> legs = chain.legMultiplicities();
      chainMultiplicities.emplace( HLT::Identifier(chain.name()).numeric() ,legs.size());
      if(legs.size()>1) {
        ATH_MSG_DEBUG("For chain " << chain.name() << ", also recording feature counts for " << legs.size() << " legs.");
      }
    }
  }
  
  for ( const std::string& chainName: sortedChainsList ) {
    x->SetBinLabel( bin, chainName.c_str() );
    unsigned int chainID = HLT::Identifier( chainName ).numeric();
    m_chainIDToBinMap[ chainID ] = bin;
    ATH_MSG_VERBOSE(chainName << " --> bin " << bin );
    ++bin;
    if(m_countLegFeatures && chainMultiplicities[chainID]>1) {
      size_t nlegs = chainMultiplicities[chainID];
      // n.b. we don't care about the content of this vector (the required multiplicity per leg), just its size
      for (size_t legID = 0; legID < nlegs; ++ legID) {
        const std::string legName = ( TrigCompositeUtils::createLegName(HLT::Identifier(chainName), legID).name() );
        ATH_MSG_VERBOSE("  " << legName << " --> bin " << bin );
        x->SetBinLabel( bin, legName.c_str() );
        m_chainIDToBinMap[ HLT::Identifier( legName ).numeric() ] = bin;
        ++bin;
      }
    }
  }
 
 
  for ( const auto& stream : m_streamToChainMap){
    x->SetBinLabel( bin, ("str_"+stream.first).c_str());
    m_nameToBinMap[ stream.first ] = bin;
    bin++;
  }
 
  for ( const auto& stream : m_expressChainMap){
    x->SetBinLabel( bin, ("str_"+stream.first).c_str());
    m_nameToBinMap[ stream.first ] = bin;
    bin++;
  }
 
  for ( const auto& group : m_groupToChainMap){
    x->SetBinLabel( bin, ("grp_"+group.first.substr(group.first.find(':')+1)).c_str() );
    m_nameToBinMap[ group.first ] = bin;
    bin++;
  }
 
 
  TAxis* y = hist->GetYaxis();
  y->SetBinLabel(INPUT, steps ? "L1" : "Input");
  y->SetBinLabel(AFTER_PS, "AfterPS");
  for ( size_t i = 0; steps && i < m_decisionCollectorTools.size(); ++i) {
    y->SetBinLabel(3 + i, std::format("Step {:d}", i).c_str());
  }
  y->SetBinLabel(y->GetNbins()-1, "Output"); // Second to last bin
  y->SetBinLabel(y->GetNbins(), "Express"); // Last bin
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TrigSignatureMoni::initialize ( )

overridevirtual

Definition at line 25 of file TrigSignatureMoni.cxx.

                                         {
  ATH_CHECK(m_l1DecisionsKey.initialize());
  ATH_CHECK(m_finalDecisionKey.initialize());
  ATH_CHECK(m_HLTMenuKey.initialize());
  ATH_CHECK(m_L1MenuKey.initialize());
  ATH_CHECK(m_decisionCollectorTools.retrieve());
  ATH_CHECK(m_featureCollectorTools.retrieve());
  ATH_CHECK(m_histSvc.retrieve());
 
  ATH_CHECK(m_incidentSvc.retrieve());
  m_incidentSvc->addListener(this, AthenaInterprocess::UpdateAfterFork::type());
 
  return StatusCode::SUCCESS;
}

initSeqHist()

StatusCode TrigSignatureMoni::initSeqHist ( LockedHandle< TH2 > & hist, std::set< std::string > & sequenceSet )

private

Definition at line 521 of file TrigSignatureMoni.cxx.

                                                                                                 {
  TAxis* x = hist->GetXaxis();
  int bin = 1;
 
  // Set bin labels
  for (const std::string& seqName : sequenceSet) {
    x->SetBinLabel(bin, seqName.c_str());
    m_sequenceToBinMap[seqName] = bin;
    ++bin;
  }
 
  TAxis* y = hist->GetYaxis();
  y->SetBinLabel(1, "Rate");
 
  return StatusCode::SUCCESS;
}

nBinsX() [1/2]

int TrigSignatureMoni::nBinsX ( ) const

private

Definition at line 431 of file TrigSignatureMoni.cxx.

                                    {
  return m_chainIDToBinMap.size() + m_groupToChainMap.size() + m_streamToChainMap.size() + m_expressChainMap.size() + 1;
}

nBinsX() [2/2]

int TrigSignatureMoni::nBinsX ( SG::ReadHandle< TrigConf::HLTMenu > & hltMenuHandle ) const

private

Definition at line 427 of file TrigSignatureMoni.cxx.

                                                                                {
  return nChains(hltMenuHandle) + m_groupToChainMap.size() + m_streamToChainMap.size() + m_expressChainMap.size();
}

nChains()

int TrigSignatureMoni::nChains ( SG::ReadHandle< TrigConf::HLTMenu > & hltMenuHandle ) const

private

Definition at line 435 of file TrigSignatureMoni.cxx.

                                                                                 {
  int nchains = hltMenuHandle->size();
  // If we want the leg counts, need to accumulate the multiplicities from each chain
  if(m_countLegFeatures) {
    for (const TrigConf::Chain& chain : *hltMenuHandle){
      std::vector<size_t> legs = chain.legMultiplicities();
      if(legs.size()>1) {nchains += legs.size();}
    }
  }
  return nchains + 1; // Chains + "All"
}

nSteps()

int TrigSignatureMoni::nSteps ( ) const

private

Definition at line 447 of file TrigSignatureMoni.cxx.

                                    {
  return m_decisionCollectorTools.size();
}

start()

StatusCode TrigSignatureMoni::start ( )

overridevirtual

Definition at line 40 of file TrigSignatureMoni.cxx.

                                    {
  SG::ReadHandle<TrigConf::L1Menu> l1MenuHandle = SG::makeHandle(m_L1MenuKey);
  SG::ReadHandle<TrigConf::HLTMenu> hltMenuHandle = SG::makeHandle(m_HLTMenuKey);
  ATH_CHECK(hltMenuHandle.isValid());
 
  // Retrieve chain information from menus
  m_groupToChainMap.clear();
  m_streamToChainMap.clear();
  m_expressChainMap.clear();
 
  std::unordered_map<std::string,std::string> mapStrNameToTypeName; // e.g. {Main -> physics_Main}
  try {
    const std::string nameStr{"name"};
    const std::string typeStr{"type"};
    for (const TrigConf::DataStructure& stream : hltMenuHandle->streams()) {
      mapStrNameToTypeName.insert({stream.getAttribute(nameStr), stream.getAttribute(typeStr)+"_"+stream.getAttribute(nameStr)});
    }
  } catch (const std::exception& ex) {
    ATH_MSG_ERROR("Exception reading stream tag configuration from the HLT menu: " << ex.what());
    return StatusCode::FAILURE;
  }
 
  for (const TrigConf::Chain& chain : *hltMenuHandle) {
    for (const std::string& group : chain.groups()) {
      // Save chains per RATE group
      if (group.starts_with( "RATE")){
        m_groupToChainMap[group].insert(HLT::Identifier(chain.name()));
      }
    }
 
    // Save chain to stream map
    for (const std::string& streamName : chain.streams()){
      const auto it = mapStrNameToTypeName.find(streamName);
      if (it==mapStrNameToTypeName.cend()) {
        ATH_MSG_ERROR("Stream name " << streamName << " assigned to chain " << chain.name()
                      << " is missing from menu streams definition");
        return StatusCode::FAILURE;
      }
      if (it->second == "express_express") {
        m_expressChainMap[it->second].insert(HLT::Identifier(chain.name()));
      } else {
        m_streamToChainMap[it->second].insert(HLT::Identifier(chain.name()));
      }
    }
  }
 
  // Prepare the histograms
 
  // Initialize SignatureAcceptance and DecisionCount histograms that will monitor 
  //    chains, groups and sequences per each step
  const int x {nBinsX(hltMenuHandle)};
  const int y {nSteps() + N_BINS};
  ATH_MSG_DEBUG( "Histogram " << x << " x " << y << " bins");
  std::unique_ptr<TH2> hSA = std::make_unique<TH2I>("SignatureAcceptance", "Raw acceptance of signatures in;chain;step", x, 1, x + 1, y, 1, y + 1);  
  std::unique_ptr<TH2> hDC = std::make_unique<TH2I>("DecisionCount", "Positive decisions count per step;chain;step", x, 1, x + 1, y, 1, y + 1);
 
  ATH_CHECK(m_histSvc->regShared(m_bookingPath + "/" + name() + "/SignatureAcceptance", std::move(hSA), m_passHistogram));
  ATH_CHECK(m_histSvc->regShared(m_bookingPath + "/" + name() + "/DecisionCount", std::move(hDC), m_countHistogram));
 
  ATH_CHECK(initHist(m_passHistogram, hltMenuHandle));
  ATH_CHECK(initHist(m_countHistogram, hltMenuHandle));
 
  // Initialize Rate histogram to save the rates of positive decisions in given interval 
  //  per chain/group/sequence per in, after ps, out steps
  if ( x > 0 ){
    const std::string outputRateName = std::format("Rate{:d}s", m_duration.value());
    m_rateHistogram.init(outputRateName, "Rate of positive decisions;chain;step", x, N_BINS,
                         std::format("{}/{}/{}", m_bookingPath.value(), name(), outputRateName), m_histSvc).ignore();
    ATH_CHECK(initHist(m_rateHistogram.getHistogram(), hltMenuHandle, false));
    ATH_CHECK(initHist(m_rateHistogram.getBuffer(), hltMenuHandle, false));
  }
 
  // Initialize SequencesExecutionRate histogram to save the rates of sequences execution
  // Save sequences names to be monitored
  std::set<std::string> sequencesSet;
  for (auto& ctool: m_decisionCollectorTools){
    ctool->getSequencesNames(sequencesSet);
  }
  const int xc = sequencesSet.size();
  const int yc {1}; // Only rate, this histogram is really 1 D
  if (xc > 0){
    const std::string outputSequenceName = std::format("SequencesExecutionRate{:d}s", m_duration.value());
    m_sequenceHistogram.init(outputSequenceName, "Rate of sequences execution;sequence;rate", xc, yc,
                             std::format("{}/{}/{}", m_bookingPath.value(), name(), outputSequenceName), m_histSvc).ignore();
 
    ATH_CHECK(initSeqHist(m_sequenceHistogram.getHistogram(), sequencesSet));
    ATH_CHECK(initSeqHist(m_sequenceHistogram.getBuffer(), sequencesSet));
  }
 
  return StatusCode::SUCCESS;
}

stop()

StatusCode TrigSignatureMoni::stop ( )

overridevirtual

Definition at line 132 of file TrigSignatureMoni.cxx.

                                   {
  m_rateHistogram.stopTimer();
  m_sequenceHistogram.stopTimer();
 
  if (m_chainIDToBinMap.empty()) {
    ATH_MSG_INFO( "No chains configured, no counts to print" );
    return StatusCode::SUCCESS;
  }
  
  SG::ReadHandle<TrigConf::HLTMenu> hltMenuHandle = SG::makeHandle(m_HLTMenuKey);
  ATH_CHECK(hltMenuHandle.isValid());
 
  // Retrieve information whether chain was active in Step
  std::unordered_map<std::string, std::set<int>> chainToStepsId;
  for (const TrigConf::Chain& chain : *hltMenuHandle){
    int nstep {1}; // Start from step=1
    for (const std::string& seqName : chain.sequencers()){
      // Example sequencer name is "Step1_FastCalo_electron", we need only information about Step + number
      std::smatch stepNameMatch;
      std::regex_search(seqName.begin(), seqName.end(), stepNameMatch, std::regex("[Ss]tep[0-9]+"));
 
      std::string stepName = stepNameMatch[0];
      stepName[0] = std::toupper(stepName[0]); // Fix "stepX" -> "StepX"
      // Check that the step name is set with the same position in the execution (empty steps support)
      if (std::format("Step{:d}", nstep) == stepName) {
        chainToStepsId[chain.name()].insert(nstep);
        if(m_countLegFeatures && chain.legMultiplicities().size()>1) {
          for (size_t legID = 0; legID < chain.legMultiplicities().size(); ++ legID) {
            const std::string legName = ( TrigCompositeUtils::createLegName(HLT::Identifier(chain.name()), legID).name() );
            chainToStepsId[legName].insert(nstep);
          }
        }
      } else {
        ATH_MSG_DEBUG("Missing counts for step" << nstep << " in chain " << chain.name());
      }
      nstep++;
    }
  }
 
  auto collToString = [&](int xbin, const LockedHandle<TH2>& hist, int startOfset=0, int endOffset=0){ 
    std::string v;
    const int stepsSize = hist->GetYaxis()->GetNbins() - N_BINS;
    for (int ybin = 1; ybin <= hist->GetYaxis()->GetNbins()-endOffset; ++ybin) {
      if (ybin > startOfset) {
        // Skip steps where chain wasn't active
        // ybins are for all axis labes, steps are in bins from 3 to stepsSize + 2
        const std::string chainName = m_passHistogram->GetXaxis()->GetBinLabel(xbin);
 
        if (ybin < 3 || ybin > stepsSize + 2 || chainToStepsId[chainName].contains(ybin - 2)) {
          v += std::format("{:<11d}", static_cast<int>(hist->GetBinContent(xbin, ybin)));
        } else {
          v += std::format("{:<11s}", "-");
        }
      } else {
        v += std::format("{:<11s}", " ");
      }
    }
    return v;
  };
  
  std::string v;
  v += std::format("{:<11s}", "L1");
  v += std::format("{:<11s}", "AfterPS");
  for (int bin = 1; bin <= m_passHistogram->GetYaxis()->GetNbins()-N_BINS; ++bin) {
    v += std::format("Step{:<7d}", bin);
  }
  v += std::format("{:<11s}", "Output");
  v += std::format("{:<11s}", "Express");
  
  ATH_MSG_INFO("Chains passing step (1st row events & 2nd row decision counts):");  
  ATH_MSG_INFO("    Feature counts reflect the number of unique objects contributing to a positive chain decision (0 if step fails), including L1RoI for empty steps.");
  if(m_countLegFeatures) {
    ATH_MSG_INFO("    Leg feature counts indicate the number of unique objects that pass the leg's step selection (regardless of multiplicity), which may overlap with other legs.");
    ATH_MSG_INFO("    'PROBE' L1 RoIs are counted separately.");
  }
 
  ATH_MSG_INFO(std::format("{:<30s}", "ChainName") << v);
 
  
  for (int bin = 1; bin <= (*m_passHistogram)->GetXaxis()->GetNbins(); ++bin) {
    const std::string chainName = m_passHistogram->GetXaxis()->GetBinLabel(bin);
    const std::string chainID = std::to_string(HLT::Identifier(chainName));
    if (chainName.starts_with( "HLT")) { // print only for chains
      ATH_MSG_INFO( std::format("{:s} #{:s}", chainName, chainID) );
      ATH_MSG_INFO( std::format("{:<30s}", std::format("-- #{} Events", chainID)) << collToString( bin, m_passHistogram) );
      ATH_MSG_INFO( std::format("{:<30s}", std::format("-- #{} Features", chainID)) << collToString( bin, m_countHistogram , 2, 1 ) );
    }
    if (chainName.starts_with( "All")){
      ATH_MSG_INFO( std::format("{:<30s}", chainName) << collToString( bin, m_passHistogram) );
    }
    if (chainName.starts_with("leg")) { // print features only for legs
      const std::string legID = chainName.substr(0,6);
      ATH_MSG_INFO( std::format("{:<30s}", std::format("-- #{} Features", legID)) << collToString( bin, m_countHistogram , 2, 1 ) );
    }
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

LockedHandle<TH2> m_countHistogram TrigSignatureMoni::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 112 of file TrigSignatureMoni.h.

ATLAS_THREAD_SAFE [2/2]

LockedHandle<TH2> m_passHistogram TrigSignatureMoni::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 111 of file TrigSignatureMoni.h.

m_bookingPath

Gaudi::Property<std::string> TrigSignatureMoni::m_bookingPath { this, "HistPath", "/EXPERT/HLTFramework", "Booking path for the histogram"}

private

Definition at line 99 of file TrigSignatureMoni.h.

{ this, "HistPath", "/EXPERT/HLTFramework", "Booking path for the histogram"};

m_chainIDToBinMap

std::unordered_map<unsigned int, int> TrigSignatureMoni::m_chainIDToBinMap

private

Chain id to histogram bin map.

Definition at line 117 of file TrigSignatureMoni.h.

m_countLegFeatures

Gaudi::Property<bool> TrigSignatureMoni::m_countLegFeatures { this, "CountLegFeatures", false, "Save features per leg as well as per chain"}

private

Definition at line 101 of file TrigSignatureMoni.h.

{ this, "CountLegFeatures", false, "Save features per leg as well as per chain"};

m_decisionCollectorTools

ToolHandleArray<DecisionCollectorTool> TrigSignatureMoni::m_decisionCollectorTools { this, "DecisionCollectorTools", {}, "Tools that collect decisions (yes/no) for steps" }

private

Definition at line 107 of file TrigSignatureMoni.h.

{ this, "DecisionCollectorTools", {}, "Tools that collect decisions (yes/no) for steps" };

m_duration

Gaudi::Property<unsigned int> TrigSignatureMoni::m_duration {this, "RateIntegrationDuration", 10, "Integration time for the rate histogram in seconds"}

private

Definition at line 104 of file TrigSignatureMoni.h.

{this, "RateIntegrationDuration", 10, "Integration time for the rate histogram in seconds"};

m_expressChainMap

std::map<std::string, TrigCompositeUtils::DecisionIDContainer> TrigSignatureMoni::m_expressChainMap

private

Stream name to chain objects map, including only express.

Definition at line 124 of file TrigSignatureMoni.h.

m_featureCollectorTools

ToolHandleArray<DecisionCollectorTool> TrigSignatureMoni::m_featureCollectorTools { this, "FeatureCollectorTools", {}, "Tools that collect decision counts for specific features for steps" }

private

Definition at line 108 of file TrigSignatureMoni.h.

{ this, "FeatureCollectorTools", {}, "Tools that collect decision counts for specific features for steps" };

m_finalDecisionKey

SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer> TrigSignatureMoni::m_finalDecisionKey { this, "FinalDecisionKey", "HLTNav_Summary", "Final stage of all decisions" }

private

Definition at line 93 of file TrigSignatureMoni.h.

{ this, "FinalDecisionKey", "HLTNav_Summary", "Final stage of all decisions" };

m_groupToChainMap

std::map<std::string, TrigCompositeUtils::DecisionIDContainer> TrigSignatureMoni::m_groupToChainMap

private

Group name to chain objects map.

Definition at line 122 of file TrigSignatureMoni.h.

m_histSvc

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

private

Definition at line 98 of file TrigSignatureMoni.h.

{ this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" };

m_HLTMenuKey

SG::ReadHandleKey<TrigConf::HLTMenu> TrigSignatureMoni::m_HLTMenuKey { this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu" }

private

Definition at line 94 of file TrigSignatureMoni.h.

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

m_incidentSvc

ServiceHandle<IIncidentSvc> TrigSignatureMoni::m_incidentSvc { this, "IncidentSvc", "IncidentSvc", "Incident service"}

private

Definition at line 97 of file TrigSignatureMoni.h.

{ this, "IncidentSvc", "IncidentSvc", "Incident service"};

m_intervals

Gaudi::Property<unsigned int> TrigSignatureMoni::m_intervals {this, "RateIntegrationIntervals", 6, "Number of the rate histogram publications"}

private

Definition at line 105 of file TrigSignatureMoni.h.

{this, "RateIntegrationIntervals", 6, "Number of the rate histogram publications"};

m_l1DecisionsKey

SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer> TrigSignatureMoni::m_l1DecisionsKey { this, "L1Decisions", "HLTSeedingSummary", "Chains activated after the L1" }

private

Definition at line 92 of file TrigSignatureMoni.h.

{ this, "L1Decisions", "HLTSeedingSummary", "Chains activated after the L1" };

m_L1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> TrigSignatureMoni::m_L1MenuKey { this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" }

private

Definition at line 95 of file TrigSignatureMoni.h.

{ this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" };

m_nameToBinMap

std::unordered_map<std::string, int> TrigSignatureMoni::m_nameToBinMap

private

Sequence/group/bunchgroup name to bin map.

Definition at line 118 of file TrigSignatureMoni.h.

m_rateHistogram

RateHistogram TrigSignatureMoni::m_rateHistogram

private

Definition at line 113 of file TrigSignatureMoni.h.

m_sequenceHistogram

RateHistogram TrigSignatureMoni::m_sequenceHistogram

private

Definition at line 114 of file TrigSignatureMoni.h.

m_sequenceToBinMap

std::unordered_map<std::string, int> TrigSignatureMoni::m_sequenceToBinMap

private

Sequence to bin map for sequence histogram.

Definition at line 119 of file TrigSignatureMoni.h.

m_streamToChainMap

std::map<std::string, TrigCompositeUtils::DecisionIDContainer> TrigSignatureMoni::m_streamToChainMap

private

Stream name to chain objects map, excluding express.

Definition at line 123 of file TrigSignatureMoni.h.

---

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

• TrigSignatureMoni.h
• TrigSignatureMoni.cxx