Trig::NavigationDAODTesterAlgv2 Class Reference

#include <NavigationDAODTesterAlgv2.h>

Inheritance diagram for Trig::NavigationDAODTesterAlgv2:

Collaboration diagram for Trig::NavigationDAODTesterAlgv2:

Public Member Functions
	NavigationDAODTesterAlgv2 (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~NavigationDAODTesterAlgv2 () override=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &context) const override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::size_t	numberOfLegs (const std::string &chain) const
	Number of legs of a chain, derived from ChainNameParser::multiplicities().
void	dumpFeaturesPerLeg (const std::string &chain, std::size_t nLegs, MSG::Level level, const std::string &linkName="") const
	Dump the per-leg R3 features of a chain at the given message level.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static bool	matchesAnyPattern (const std::string &chain, const std::vector< std::string > &patterns)
	True if the chain name contains any of the patterns (substring match).
static const xAOD::IParticle *	resolveOriginal (const xAOD::IParticle *p)
	Resolve a possible shallow copy to its original object via the "originalObjectLink" decoration (mirrors the MatchShallow behaviour of MatchFromCompositeTool::areTheSame, plus a defensive validity check on the link).
static bool	matchLinearisedR2 (std::vector< const xAOD::IParticle * > pool, const std::vector< const xAOD::IParticle * > &particles)
	R2 verdict for chains with linearised TrigMatch layout (e.g.

Private Attributes
PublicToolHandle< Trig::TrigDecisionTool >	m_tdt
PublicToolHandle< Trig::R3MatchingTool >	m_matchingTool
PublicToolHandle< Trig::MatchFromCompositeTool >	m_matchFromCompositeTool
Gaudi::Property< std::vector< std::string > >	m_chains
Gaudi::Property< std::vector< std::string > >	m_chainsToExclude
Gaudi::Property< std::vector< std::string > >	m_linearisedR2Chains
Gaudi::Property< bool >	m_failOnDifference
Gaudi::Property< bool >	m_verifyCombinationsSize
Gaudi::Property< bool >	m_verifyCombinations
Gaudi::Property< std::string >	m_inputPrefix
Gaudi::Property< bool >	m_printSubfeatures
Gaudi::Property< bool >	m_r3MatchingRerun
Gaudi::Property< bool >	m_drFromRun2Lists
Gaudi::Property< bool >	m_dumpFeaturesWithoutR2
std::map< std::string, int > m_failingChains	ATLAS_THREAD_SAFE
std::map< std::string, int > m_emptyR2Chains	ATLAS_THREAD_SAFE
	Events where the chain passed and R3 matched, but the R2 TrigMatch reference container is EMPTY.
std::map< std::string, int > m_rerunOnlyChains	ATLAS_THREAD_SAFE
	Events with a TrigMatch reference in which the chain passed only in rerun (resurrected decision, not after prescale).
std::mutex	m_failingChainsMutex
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 36 of file NavigationDAODTesterAlgv2.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

NavigationDAODTesterAlgv2()

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

Definition at line 20 of file NavigationDAODTesterAlgv2.cxx.

                                                                                                    :
    AthReentrantAlgorithm(name, pSvcLocator)
{}

~NavigationDAODTesterAlgv2()

virtual Trig::NavigationDAODTesterAlgv2::~NavigationDAODTesterAlgv2 ( )

overridevirtualdefault

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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< Gaudi::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; }

dumpFeaturesPerLeg()

void Trig::NavigationDAODTesterAlgv2::dumpFeaturesPerLeg ( const std::string & chain, std::size_t nLegs, MSG::Level level, const std::string & linkName = "" ) const

private

Dump the per-leg R3 features of a chain at the given message level.

Used both for diagnostics on failing chains and for the optional subfeature printout. The linkName selects "feature" (default) or "subfeature".

Definition at line 76 of file NavigationDAODTesterAlgv2.cxx.

                                                                                    {
    const bool isSub = !linkName.empty();
    const char* tag = isSub ? "[subfeature]" : "[feature]";
    for (std::size_t leg = 0; leg < nLegs; ++leg) {
        Trig::FeatureRequestDescriptor frd;
        frd.setChainGroup(chain);
        frd.setRestrictRequestToLeg(static_cast<int>(leg));
        if (isSub) {
            frd.setLinkName(linkName);
        }
        // Default feature collection mode (lastFeatureOfType) is correct for
        // DAOD - only the final feature is kept after slimming.
        auto features = m_tdt->features<xAOD::IParticleContainer>(frd);
        msg() << level << "  Leg " << leg << " "
              << (isSub ? "subfeatures" : "features") << " (" << features.size() << "):" << endmsg;
        for (const auto& feature : features) {
            if (feature.isValid()) {
                msg() << level << "    " << tag << " pt=" << (*feature.link)->pt()
                      << " eta=" << (*feature.link)->eta()
                      << " phi=" << (*feature.link)->phi()
                      << " [" << feature.link.dataID() << ":" << feature.link.index() << "]" << endmsg;
            }
        }
    }
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::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; }

execute()

StatusCode Trig::NavigationDAODTesterAlgv2::execute ( const EventContext & context ) const

overridevirtual

Definition at line 105 of file NavigationDAODTesterAlgv2.cxx.

                                                                           {
 
    // Get offline particle containers
    SG::ReadHandle<xAOD::IParticleContainer> particles_muons{"Muons", ctx};
    SG::ReadHandle<xAOD::IParticleContainer> particles_electrons{"Electrons", ctx};
    SG::ReadHandle<xAOD::IParticleContainer> particles_taus{"TauJets", ctx};
    SG::ReadHandle<xAOD::IParticleContainer> particles_photons{"Photons", ctx};
 
    std::map<std::string, SG::ReadHandle<xAOD::IParticleContainer>*> read_handles;
    read_handles["e"] = &particles_electrons;
    read_handles["mu"] = &particles_muons;
    read_handles["tau"] = &particles_taus;
    read_handles["g"] = &particles_photons;
 
    if (!particles_muons.isValid() || !particles_electrons.isValid() ||
        !particles_taus.isValid() || !particles_photons.isValid()) {
        ATH_MSG_ERROR("Couldn't retrieve IParticles containers");
        return StatusCode::FAILURE;
    }
 
    for (const std::string& chain : m_chains) {
        if (!m_tdt->isPassed(chain, TrigDefs::Physics | TrigDefs::allowResurrectedDecision)) continue;
 
        // Skip chains on the exception list (substring match). These are
        // pathological chain families whose TrigMatch layout does not support
        // the generic R2/R3 comparison and have no dedicated handling (yet).
        if (matchesAnyPattern(chain, m_chainsToExclude)) {
            ATH_MSG_DEBUG("Chain " << chain << " is on the exclusion list, skipping");
            continue;
        }
 
        // Get the chain structure using ChainNameParser
        auto ChainMultiplicity = ChainNameParser::multiplicities(chain);
        auto ChainNameParseSignature = ChainNameParser::signatures(chain);
 
        // Filter to only process chains with supported signatures (e, mu, g, tau)
        bool hasSupported = false;
        for (const std::string& sig : ChainNameParseSignature) {
            if (read_handles.find(sig) != read_handles.end()) {
                hasSupported = true;
                break;
            }
        }
        if (!hasSupported) {
            ATH_MSG_DEBUG("Chain " << chain << " has no supported signatures, skipping");
            continue;
        }
        ATH_MSG_DEBUG("Passing " << chain);
 
        // dR of the R3 matching. The TrigMatch_<chain> reference was produced
        // per trigger list (DerivationFrameworkPhys/PhysCommonConfig.py): 0.2
        // for the Tau list (tau, di-tau, tau+xe), 0.1 for the NoTau list,
        // which also holds the e+tau and mu+tau chains. By default
        // (DRThresholdFromRun2Lists) the same rule is used here: a chain is in
        // the Tau list iff it has a tau leg and no e/mu/g leg. Otherwise the
        // previous rule: 0.2 for any chain with a tau leg. With that rule the
        // R3 matching accepts, for lepton+tau chains, objects in the 0.1-0.2
        // annulus that the Run 2 reference never considered: mostly "R3
        // matched, R2 reference EMPTY" warnings, and "R3 found at least one
        // match but R2 found none" errors when the reference holds only
        // thinned objects.
        const bool hasTau = std::find(ChainNameParseSignature.begin(),
                                      ChainNameParseSignature.end(),
                                      "tau") != ChainNameParseSignature.end();
        const bool hasEMuG = std::any_of(ChainNameParseSignature.begin(),
                                         ChainNameParseSignature.end(),
                                         [](const std::string& s) { return s == "e" || s == "mu" || s == "g"; });
        const bool tauListChain = hasTau && !hasEMuG;
        const double drThreshold = (m_drFromRun2Lists ? tauListChain : hasTau) ? 0.2 : 0.1;
 
        // Retrieve the TrigMatch container (used for the R2 match and for the
        // DEBUG dump below).
        std::string containerName = m_inputPrefix + chain;
        std::replace(containerName.begin(), containerName.end(), '.', '_');
        const xAOD::TrigCompositeContainer* composites(nullptr);
        if (!evtStore()->retrieve(composites, containerName).isSuccess()) {
            ATH_MSG_DEBUG("No branch in this DAOD for " << chain);
            if (m_dumpFeaturesWithoutR2) {
                // Converter-debugging mode (e.g. directly after conversion at
                // AOD level): no R2 reference exists, but the per-leg feature
                // assignment - where the cross-leg pooling defect shows up -
                // can still be inspected.
                const std::size_t nLegs = numberOfLegs(chain);
                if (nLegs > 0) {
                    ATH_MSG_INFO("Per-leg features of " << chain << " (no R2 reference):");
                    dumpFeaturesPerLeg(chain, nLegs, MSG::INFO);
                    dumpFeaturesPerLeg(chain, nLegs, MSG::INFO, "subfeature");
                }
            }
            continue;
        }
 
        // Rerun-only event: the chain passed only in rerun (resurrected
        // decision, accepted above) and has a TrigMatch reference to compare
        // with. Counted for the summary.
        if (!m_tdt->isPassed(chain, TrigDefs::Physics)) {
            std::lock_guard<std::mutex> lock(m_failingChainsMutex);
            m_rerunOnlyChains[chain] += 1;
        }
 
        // nomucomb-family chains: the derivation stored the R2 matches
        // linearised - one TrigComposite entry of vector size 1 per
        // individually matched offline muon (e.g. HLT_2mu10_nomucomb with 3
        // matched muons -> 3 entries of size 1) instead of one entry of size
        // = sum of leg multiplicities per matched combination.
        // MatchFromCompositeTool requires the full combination within a single
        // entry, so it can never match there. Rebuild the R2 reference instead:
        // the pool of individually matched offline objects, gathered once per
        // chain/event.
        const bool useLinearisedR2 = matchesAnyPattern(chain, m_linearisedR2Chains);
        std::vector<const xAOD::IParticle*> r2MatchedPool;
        if (useLinearisedR2) {
            static const SG::ConstAccessor<std::vector<ElementLink<xAOD::IParticleContainer>>> accMatched("TrigMatchedObjects");
            for (const xAOD::TrigComposite* entry : *composites) {
                for (const ElementLink<xAOD::IParticleContainer>& link : accMatched(*entry)) {
                    if (!link.isValid()) continue;  // e.g. removed by thinning
                    const xAOD::IParticle* orig = resolveOriginal(*link);
                    if (std::find(r2MatchedPool.begin(), r2MatchedPool.end(), orig) == r2MatchedPool.end()) {
                        r2MatchedPool.push_back(orig);
                    }
                }
            }
            ATH_MSG_DEBUG("Chain " << chain << " uses linearised R2 matching: "
                          << composites->size() << " TrigMatch entries -> pool of "
                          << r2MatchedPool.size() << " individually matched objects");
        }
 
        bool isR2R3different = false;
        size_t nCombinationsTested = 0;
        bool anyPassR2 = false;
        bool anyPassR3 = false;
 
        if (useLinearisedR2) {
            // Per-object comparison. The linearised reference holds individually
            // matched objects with no combination structure and no online-object
            // identity, so combination-level R2 verdicts cannot be reconstructed
            // faithfully. Two benign cases would otherwise be flagged as ERRORs
            // (both observed with HLT_2mu10_nomucomb, run 284500):
            //  - a collimated offline pair matched to the SAME single online
            //    muon: per-object R2 stores both, while R3 correctly demands
            //    distinct online objects per combination;
            //  - the converter demotes the lower-pT online muon of a shared RoI
            //    to a "subfeature", which the baseline comparison excludes
            //    (IncludeSubfeatures=False).
            // Comparing per object keeps the genuine-defect signature visible:
            // an object the R2 derivation matched but whose feature the
            // converted navigation lost entirely still gives R2:1 R3:0.
            std::vector<const SG::ReadHandle<xAOD::IParticleContainer>*> doneContainers;
            for (const std::string& sig : ChainNameParseSignature) {
                auto handleItr = read_handles.find(sig);
                if (handleItr == read_handles.end()) continue;
                // Legs may share an offline container (e.g. mu6 + 2mu4):
                // process each container once.
                if (std::find(doneContainers.begin(), doneContainers.end(), handleItr->second) != doneContainers.end()) continue;
                doneContainers.push_back(handleItr->second);
 
                for (const xAOD::IParticle* p : **(handleItr->second)) {
                    const bool passR2 = matchLinearisedR2(r2MatchedPool, {p});
                    const bool passR3 = m_matchingTool->match(*p, chain, drThreshold, m_r3MatchingRerun);
 
                    anyPassR2 |= passR2;
                    anyPassR3 |= passR3;
 
                    if (passR2 && !passR3) {
                        ATH_MSG_ERROR("R2 passes but R3 fails for chain " << chain
                                      << " (per-object linearised check) - converted navigation may have lost this object");
                        ATH_MSG_ERROR("  Particle pT=" << p->pt() << " eta=" << p->eta() << " phi=" << p->phi()
                                      << " R2:1 R3:0");
                        isR2R3different = true;
 
                        {
                            std::lock_guard<std::mutex> lock(m_failingChainsMutex);
                            m_failingChains[chain] += 1;
                        }
                    }
                    else if (!passR2 && passR3) {
                        ATH_MSG_DEBUG("R3 passes but R2 fails (expected) for chain " << chain
                                      << " (per-object linearised check)");
                        ATH_MSG_DEBUG("  Particle pT=" << p->pt() << " eta=" << p->eta() << " phi=" << p->phi()
                                      << " R2:0 R3:1");
                    }
                    else {
                        ++nCombinationsTested;
                        if (passR2 && msgLvl(MSG::DEBUG)) {
                            ATH_MSG_DEBUG("R2/R3 match for chain " << chain
                                          << " (per-object linearised check) passR2: " << passR2 << " passR3: " << passR3);
                            ATH_MSG_DEBUG("  Particle pT=" << p->pt() << " eta=" << p->eta() << " phi=" << p->phi());
                        }
                    }
                }
            }
        }
        else {
 
        // Setup combination generator based on multiplicities of offline physics objects for each leg
        HLT::NestedUniqueCombinationGenerator nucg;
        ATH_MSG_DEBUG("NestedUniqueCombinationGenerator: " << ChainMultiplicity.size() << " legs, " << ChainNameParseSignature.size() << " signatures");
 
        bool tooFewOffline = false;
        for (size_t readhandlesIndex = 0; readhandlesIndex < ChainNameParseSignature.size(); readhandlesIndex++) {
            const std::string& sig = ChainNameParseSignature[readhandlesIndex];
            if (read_handles.find(sig) == read_handles.end()) {
                ATH_MSG_DEBUG("Signature " << sig << " not supported, skipping chain " << chain);
                continue;
            }
            const size_t nOffline = (*read_handles[sig])->size();
            const size_t nRequired = static_cast<size_t>(ChainMultiplicity[readhandlesIndex]);
            ATH_MSG_DEBUG("Signature \"" << sig << "\": " << nOffline
                          << " offline objects, chain requires " << nRequired);
            // If a leg has fewer offline objects than required, no valid combination
            // can be formed. Skip to avoid out-of-range access in the generator loop.
            if (nOffline < nRequired) {
                tooFewOffline = true;
                break;
            }
            nucg.add({nOffline, nRequired});
        }
        if (tooFewOffline) {
            ATH_MSG_DEBUG("Not enough offline objects to form any combination for chain " << chain << ", skipping");
            continue;
        }
 
        // Loop over all possible combinations of offline physics objects
        do {
            const std::vector<size_t> combination = nucg();
            ++nucg;
 
            std::vector<const xAOD::IParticle *> particles;
            size_t location_in_combination = 0;
 
            for (size_t ChainNameIndex = 0; ChainNameIndex < ChainNameParseSignature.size(); ++ChainNameIndex) {
                const std::string& sig = ChainNameParseSignature[ChainNameIndex];
                if (read_handles.find(sig) == read_handles.end()) continue;
 
                for (size_t ChainMultipIndex = 0; ChainMultipIndex < static_cast<size_t>(ChainMultiplicity[ChainNameIndex]); ++ChainMultipIndex) {
                    const xAOD::IParticle* p = (*read_handles[sig])->at(combination[location_in_combination]);
                    ATH_MSG_VERBOSE("objectIndex --> " << sig << " " << combination[location_in_combination]
                                    << " pT: " << p->pt() << " eta: " << p->eta() << " phi: " << p->phi());
                    particles.push_back(p);
                    location_in_combination++;
                }
            }
 
            // Combination hygiene: legs sharing an offline container can draw
            // the SAME offline object into two slots (the per-leg generators
            // are independent). Such degenerate combinations are not physical
            // trigger combinations - the R2 reference never contains them -
            // while R3 can accept them through duplicated online copies (the
            // same muon reconstructed in overlapping RoIs appears several
            // times in the converted navigation). Skip them.
            bool duplicateOffline = false;
            for (size_t i = 0; i < particles.size() && !duplicateOffline; ++i) {
                for (size_t j = i + 1; j < particles.size(); ++j) {
                    if (particles[i] == particles[j]) {
                        duplicateOffline = true;
                        break;
                    }
                }
            }
            if (duplicateOffline) {
                ATH_MSG_VERBOSE("Skipping combination with a repeated offline object for chain " << chain);
                continue;
            }
 
            // R3: full combination matching via buildCombinations (DR-based,
            //     drThreshold chosen above per DRThresholdFromRun2Lists).
            // R2: single full-combination match against the pre-stored TrigMatch
            //     container using pointer/shallow equality (configured on the
            //     MatchFromCompositeTool; its DR/rerun arguments are ignored).
            bool passR3 = m_matchingTool->match(particles, chain, drThreshold, m_r3MatchingRerun);
            bool passR2 = m_matchFromCompositeTool->match(particles, chain);
 
            anyPassR2 |= passR2;
            anyPassR3 |= passR3;
 
            // ERROR: R2 says pass but R3 doesn't - this indicates missing trigger information in R3
            if (passR2 && !passR3) {
                ATH_MSG_ERROR("R2 passes but R3 fails for chain " << chain
                              << " - R3 conversion may be missing trigger information");
                for (const auto& p : particles) {
                    bool r3 = m_matchingTool->match(*p, chain, drThreshold, m_r3MatchingRerun);
                    bool r2 = m_matchFromCompositeTool->match(*p, chain);
                    ATH_MSG_ERROR("  Particle pT=" << p->pt() << " eta=" << p->eta() << " phi=" << p->phi()
                                  << " R2:" << r2 << " R3:" << r3);
                }
                isR2R3different = true;
 
                {
                    std::lock_guard<std::mutex> lock(m_failingChainsMutex);
                    m_failingChains[chain] += 1;
                }
            }
            // EXPECTED (but rare): R3 passes but R2 doesn't - R3 can form more combinations
            else if (!passR2 && passR3) {
                ATH_MSG_DEBUG("R3 passes but R2 fails (expected) for chain " << chain);
                if (msgLvl(MSG::DEBUG)) {
                    for (const auto& p : particles) {
                        bool r3 = m_matchingTool->match(*p, chain, drThreshold, m_r3MatchingRerun);
                        bool r2 = m_matchFromCompositeTool->match(*p, chain);
                        ATH_MSG_DEBUG("  Particle pT=" << p->pt() << " eta=" << p->eta() << " phi=" << p->phi()
                                      << " R2:" << r2 << " R3:" << r3);
                    }
                }
            }
            // OK: both agree
            else {
                ++nCombinationsTested;
                if (msgLvl(MSG::DEBUG)) {
                    ATH_MSG_DEBUG("R2/R3 match for chain " << chain << " passR2: " << passR2 << " passR3: " << passR3);
                    for (const auto& p : particles) {
                        bool r3 = m_matchingTool->match(*p, chain, drThreshold, m_r3MatchingRerun);
                        bool r2 = m_matchFromCompositeTool->match(*p, chain);
                        ATH_MSG_DEBUG("  Particle pT=" << p->pt() << " eta=" << p->eta() << " phi=" << p->phi()
                                      << " R2:" << r2 << " R3:" << r3);
                    }
                }
            }
        } while (nucg);
 
        } // end generic combination path
 
        // Chain-level sanity check: if R3 found at least one matching combination
        // then R2 should also have found at least one.
        if (anyPassR3 && !anyPassR2) {
            if (composites->empty()) {
                // The chain passed and R3 matched, but the derivation wrote NO
                // R2 reference entries at all. TrigMatch production reads the
                // original Run-2 navigation and is independent of the
                // conversion, so an empty reference cannot indicate a
                // conversion defect - the event is simply unverifiable by this
                // comparison. Verified on independent derivations of the same
                // events (e.g. HLT_g35_loose_g25_loose, HLT_e2x_..._mu8noL1).
                ATH_MSG_WARNING("Chain " << chain << ": chain passed and R3 matched, "
                                << "but the R2 TrigMatch reference is EMPTY - unverifiable event");
                std::lock_guard<std::mutex> lock(m_failingChainsMutex);
                m_emptyR2Chains[chain] += 1;
            }
            else {
                ATH_MSG_ERROR("Chain " << chain << ": R3 found at least one match but R2 found none "
                              << "- possible inconsistency between converted navigation and TrigMatch container");
                isR2R3different = true;
                // Count this in the finalize() summary as well. Chains that fail
                // only this chain-level check would otherwise be missing from
                // the "Failing chains count" deliverable of a full sweep. The two
                // increments cannot double-count within one event: the
                // per-combination one requires passR2, this one requires !anyPassR2.
                std::lock_guard<std::mutex> lock(m_failingChainsMutex);
                m_failingChains[chain] += 1;
            }
        }
 
        if (!isR2R3different && nCombinationsTested > 0) {
            ATH_MSG_INFO("Chain " << chain << ": R2/R3 agreement verified (" << nCombinationsTested
                         << (useLinearisedR2 ? " objects)" : " combinations)"));
        }
 
        // Dump TrigMatch container content at DEBUG level (composites already retrieved above)
        if (msgLvl(MSG::DEBUG)) {
            ATH_MSG_DEBUG("################################### TrigMatch container for " << chain << " (" << composites->size() << " combinations)");
            int comboIdx = 0;
            for (const xAOD::TrigComposite* combination : *composites) {
                //coverity[UNNECESSARY_STRING_COPY:FALSE]
                static const SG::ConstAccessor<std::vector<ElementLink<xAOD::IParticleContainer>>> accMatched("TrigMatchedObjects");
                const std::vector<ElementLink<xAOD::IParticleContainer>> featuresInCombination = accMatched(*combination);
                ATH_MSG_DEBUG("  Combo[" << comboIdx++ << "] (size=" << featuresInCombination.size() << "):");
                for (const ElementLink<xAOD::IParticleContainer>& f : featuresInCombination) {
                    if (f.isValid()) {
                        const xAOD::IParticle* iParticleR2 = resolveOriginal(*f);
                        ATH_MSG_DEBUG("    pt=" << iParticleR2->pt() << " eta=" << iParticleR2->eta() << " phi=" << iParticleR2->phi()
                                      << " [" << f.dataID() << ":" << f.index() << "]");
                    } else {
                        ATH_MSG_WARNING("    INVALID LINK in TrigMatch container for " << chain);
                    }
                }
            }
        }
 
        // Optional: print primary features and subfeatures per leg for inspection
        // (subfeatures are lower-pT objects from the Run2->Run3 conversion).
        if (m_printSubfeatures && msgLvl(MSG::DEBUG)) {
            const std::size_t nLegs = numberOfLegs(chain);
            if (nLegs == 0) {
                ATH_MSG_ERROR("Could not determine number of legs for chain " << chain);
                return StatusCode::FAILURE;
            }
            ATH_MSG_DEBUG("Subfeature inspection for " << chain);
            dumpFeaturesPerLeg(chain, nLegs, MSG::DEBUG);                 // primary features
            dumpFeaturesPerLeg(chain, nLegs, MSG::DEBUG, "subfeature");   // subfeatures
        }
 
        // Diagnostics dump on a failing chain
        if (isR2R3different) {
            const std::size_t nLegs = numberOfLegs(chain);
            if (nLegs == 0) {
                ATH_MSG_ERROR("Could not determine number of legs for chain " << chain);
                return StatusCode::FAILURE;
            }
 
            // Dump R2 pre-matched objects
            ATH_MSG_ERROR("R2 pre-matched objects for " << chain << ":");
            for (const xAOD::TrigComposite* combination : *composites) {
                static const SG::ConstAccessor<std::vector<ElementLink<xAOD::IParticleContainer>>> accMatched("TrigMatchedObjects");
                const std::vector<ElementLink<xAOD::IParticleContainer>> featuresInCombination = accMatched(*combination);
                for (const ElementLink<xAOD::IParticleContainer>& f : featuresInCombination) {
                    if (!f.isValid()) continue;
                    const xAOD::IParticle* iParticleR2 = resolveOriginal(*f);
                    ATH_MSG_ERROR("  R2 object: pT=" << iParticleR2->pt() << " eta=" << iParticleR2->eta() << " phi=" << iParticleR2->phi());
                }
            }
 
            // Dump R3 features and subfeatures per leg
            ATH_MSG_ERROR("R3 features per leg for " << chain << ":");
            dumpFeaturesPerLeg(chain, nLegs, MSG::ERROR);
            dumpFeaturesPerLeg(chain, nLegs, MSG::ERROR, "subfeature");
        }
    }
 
    return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.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 BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode Trig::NavigationDAODTesterAlgv2::finalize ( )

overridevirtual

Definition at line 525 of file NavigationDAODTesterAlgv2.cxx.

                                               {
    ATH_MSG_INFO("Failing chains count: " << m_failingChains.size());
 
    std::vector<std::pair<std::string, int>> sortedChains(m_failingChains.begin(), m_failingChains.end());
    std::sort(sortedChains.begin(), sortedChains.end(), [](const auto& a, const auto& b) {
        return a.second > b.second;
    });
 
    for (const auto& chain : sortedChains) {
        ATH_MSG_INFO("Failing chain: " << chain.first << " count: " << chain.second);
    }
 
    // Chains with events that cannot be verified: the chain passed and the
    // converted navigation matched, but the R2 TrigMatch reference container
    // was empty (a derivation-side property, independent of the conversion).
    ATH_MSG_INFO("Chains with unverifiable events (empty R2 reference): " << m_emptyR2Chains.size());
    std::vector<std::pair<std::string, int>> sortedEmpty(m_emptyR2Chains.begin(), m_emptyR2Chains.end());
    std::sort(sortedEmpty.begin(), sortedEmpty.end(), [](const auto& a, const auto& b) {
        return a.second > b.second;
    });
    for (const auto& chain : sortedEmpty) {
        ATH_MSG_INFO("Unverifiable (empty R2) chain: " << chain.first << " count: " << chain.second);
    }
 
    // Chains tested in events where they passed only in rerun (prescaled or
    // disabled chains). Informational; these events are compared with the R3
    // matching in rerun mode when R3MatchingRerun is true.
    ATH_MSG_INFO("Chains with rerun-only events (R3MatchingRerun=" << (m_r3MatchingRerun ? "true" : "false")
                 << "): " << m_rerunOnlyChains.size());
    std::vector<std::pair<std::string, int>> sortedRerun(m_rerunOnlyChains.begin(), m_rerunOnlyChains.end());
    std::sort(sortedRerun.begin(), sortedRerun.end(), [](const auto& a, const auto& b) {
        return a.second > b.second;
    });
    for (const auto& chain : sortedRerun) {
        ATH_MSG_INFO("Rerun-only chain: " << chain.first << " events: " << chain.second);
    }
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode Trig::NavigationDAODTesterAlgv2::initialize ( )

overridevirtual

Definition at line 24 of file NavigationDAODTesterAlgv2.cxx.

                                                 {
    ATH_CHECK(m_tdt.retrieve());
    ATH_CHECK(m_matchingTool.retrieve());
    ATH_CHECK(m_matchFromCompositeTool.retrieve());
 
    if (m_chains.empty()) {
        ATH_MSG_WARNING("No chains provided, algorithm will be no-op");
    }
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

matchesAnyPattern()

bool Trig::NavigationDAODTesterAlgv2::matchesAnyPattern ( const std::string & chain, const std::vector< std::string > & patterns )

staticprivate

True if the chain name contains any of the patterns (substring match).

Definition at line 44 of file NavigationDAODTesterAlgv2.cxx.

                                                                                        {
    for (const std::string& pattern : patterns) {
        if (chain.find(pattern) != std::string::npos) return true;
    }
    return false;
}

matchLinearisedR2()

bool Trig::NavigationDAODTesterAlgv2::matchLinearisedR2 ( std::vector< const xAOD::IParticle * > pool, const std::vector< const xAOD::IParticle * > & particles )

staticprivate

R2 verdict for chains with linearised TrigMatch layout (e.g.

nomucomb): true if every given particle consumes a distinct object from the pool of individually matched offline objects (the pool is taken by value and consumed during the test). Used with a single particle in the per-object comparison path.

Definition at line 61 of file NavigationDAODTesterAlgv2.cxx.

                                                          {
    // Consume-once semantics, mirroring MatchFromCompositeTool::testCombination:
    // each given particle must find its own entry in the pool of individually
    // matched objects. For the single-particle calls of the per-object
    // comparison path this reduces to a plain membership test.
    for (const xAOD::IParticle* p : particles) {
        auto itr = std::find(pool.begin(), pool.end(), resolveOriginal(p));
        if (itr == pool.end()) return false;
        pool.erase(itr);
    }
    return true;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

numberOfLegs()

std::size_t Trig::NavigationDAODTesterAlgv2::numberOfLegs ( const std::string & chain ) const

private

Number of legs of a chain, derived from ChainNameParser::multiplicities().

Returns 0 if the multiplicities could not be determined (caller should treat this as an error).

Definition at line 36 of file NavigationDAODTesterAlgv2.cxx.

                                                                              {
    // The number of legs is the number of distinct signature blocks in the
    // chain name, i.e. the size of the multiplicities vector. Note this is NOT
    // the sum of the multiplicities (that would be the total number of physics
    // objects required by the chain over all legs).
    return ChainNameParser::multiplicities(chain).size();
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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.

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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

resolveOriginal()

const xAOD::IParticle * Trig::NavigationDAODTesterAlgv2::resolveOriginal ( const xAOD::IParticle * p )

staticprivate

Resolve a possible shallow copy to its original object via the "originalObjectLink" decoration (mirrors the MatchShallow behaviour of MatchFromCompositeTool::areTheSame, plus a defensive validity check on the link).

Definition at line 52 of file NavigationDAODTesterAlgv2.cxx.

                                                                                      {
    static const SG::ConstAccessor<ElementLink<xAOD::IParticleContainer>>
        accOOL("originalObjectLink");
    if (accOOL.isAvailable(*p) && accOOL(*p).isValid()) {
        return *accOOL(*p);
    }
    return p;
}

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::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< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::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< Gaudi::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< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/3]

std::map<std::string, int> m_rerunOnlyChains Trig::NavigationDAODTesterAlgv2::ATLAS_THREAD_SAFE

mutableprivate

Events with a TrigMatch reference in which the chain passed only in rerun (resurrected decision, not after prescale).

Informational: shows how much of the comparison relies on rerun decisions.

Definition at line 142 of file NavigationDAODTesterAlgv2.h.

ATLAS_THREAD_SAFE [2/3]

std::map<std::string, int> m_emptyR2Chains Trig::NavigationDAODTesterAlgv2::ATLAS_THREAD_SAFE

mutableprivate

Events where the chain passed and R3 matched, but the R2 TrigMatch reference container is EMPTY.

TrigMatch production is independent of the navigation conversion, so such events cannot indicate a conversion defect - there is nothing to compare against. Counted separately.

Definition at line 138 of file NavigationDAODTesterAlgv2.h.

ATLAS_THREAD_SAFE [3/3]

std::map<std::string, int> m_failingChains Trig::NavigationDAODTesterAlgv2::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 133 of file NavigationDAODTesterAlgv2.h.

m_chains

Gaudi::Property<std::vector<std::string> > Trig::NavigationDAODTesterAlgv2::m_chains

private

Initial value:

{
        this, "Chains", {}, "The trigger chains to test"}

Definition at line 59 of file NavigationDAODTesterAlgv2.h.

                                                {
        this, "Chains", {}, "The trigger chains to test"};

m_chainsToExclude

Gaudi::Property<std::vector<std::string> > Trig::NavigationDAODTesterAlgv2::m_chainsToExclude

private

Initial value:

{
        this, "ChainsToExclude", {},
        "Chain name patterns to skip (substring match), e.g. 'noL1'. "
        "DAOD-tester-local exception list for pathological chain families whose "
        "TrigMatch layout does not support the generic R2/R3 comparison. "
        "Note: nomucomb chains no longer need excluding - they are handled by "
        "the dedicated linearised path (see ChainsWithLinearisedR2Matching)."}

Definition at line 62 of file NavigationDAODTesterAlgv2.h.

                                                         {
        this, "ChainsToExclude", {},
        "Chain name patterns to skip (substring match), e.g. 'noL1'. "
        "DAOD-tester-local exception list for pathological chain families whose "
        "TrigMatch layout does not support the generic R2/R3 comparison. "
        "Note: nomucomb chains no longer need excluding - they are handled by "
        "the dedicated linearised path (see ChainsWithLinearisedR2Matching)."};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_drFromRun2Lists

Gaudi::Property<bool> Trig::NavigationDAODTesterAlgv2::m_drFromRun2Lists

private

Initial value:

{
        this, "DRThresholdFromRun2Lists", true,
        "Choose the R3 matching dR as the Run 2 TrigMatch production did, per "
        "trigger list (DerivationFrameworkPhys/PhysCommonConfig.py): 0.2 only "
        "for chains of the Tau list, i.e. chains with a tau leg and no e/mu/g "
        "leg (tau, di-tau, tau+xe), 0.1 for every chain of the NoTau list, "
        "which includes the e+tau and mu+tau chains. Exact for the TriggerAPI "
        "lists and the run2ExtraMatching*.txt files; chains added through "
        "flags.Trigger.derivationsExtraChains are routed by the substring 'tau' "
        "in their name instead. With false: 0.2 for any chain with a tau leg, "
        "0.1 otherwise (the previous rule, which lets the R3 matching accept "
        "lepton+tau objects the Run 2 reference never considered)."}

Definition at line 111 of file NavigationDAODTesterAlgv2.h.

                                         {
        this, "DRThresholdFromRun2Lists", true,
        "Choose the R3 matching dR as the Run 2 TrigMatch production did, per "
        "trigger list (DerivationFrameworkPhys/PhysCommonConfig.py): 0.2 only "
        "for chains of the Tau list, i.e. chains with a tau leg and no e/mu/g "
        "leg (tau, di-tau, tau+xe), 0.1 for every chain of the NoTau list, "
        "which includes the e+tau and mu+tau chains. Exact for the TriggerAPI "
        "lists and the run2ExtraMatching*.txt files; chains added through "
        "flags.Trigger.derivationsExtraChains are routed by the substring 'tau' "
        "in their name instead. With false: 0.2 for any chain with a tau leg, "
        "0.1 otherwise (the previous rule, which lets the R3 matching accept "
        "lepton+tau objects the Run 2 reference never considered)."};

m_dumpFeaturesWithoutR2

Gaudi::Property<bool> Trig::NavigationDAODTesterAlgv2::m_dumpFeaturesWithoutR2

private

Initial value:

{
        this, "DumpFeaturesWithoutR2", false,
        "Diagnostic: when the TrigMatch_<chain> container is absent (e.g. when "
        "running directly on the conversion output at AOD level, where no R2 "
        "matching reference exists), still print the per-leg R3 features of "
        "passed chains. The cross-leg feature pooling converter defect shows "
        "up directly in this dump (identical pooled lists on every leg)."}

Definition at line 124 of file NavigationDAODTesterAlgv2.h.

                                               {
        this, "DumpFeaturesWithoutR2", false,
        "Diagnostic: when the TrigMatch_<chain> container is absent (e.g. when "
        "running directly on the conversion output at AOD level, where no R2 "
        "matching reference exists), still print the per-leg R3 features of "
        "passed chains. The cross-leg feature pooling converter defect shows "
        "up directly in this dump (identical pooled lists on every leg)."};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_failingChainsMutex

std::mutex Trig::NavigationDAODTesterAlgv2::m_failingChainsMutex

mutableprivate

Definition at line 143 of file NavigationDAODTesterAlgv2.h.

m_failOnDifference

Gaudi::Property<bool> Trig::NavigationDAODTesterAlgv2::m_failOnDifference

private

Initial value:

{
        this, "FailOnDifference", false,
        "Return FAILURE if the navigation does not compare equal"}

Definition at line 81 of file NavigationDAODTesterAlgv2.h.

                                          {
        this, "FailOnDifference", false,
        "Return FAILURE if the navigation does not compare equal"};

m_inputPrefix

Gaudi::Property<std::string> Trig::NavigationDAODTesterAlgv2::m_inputPrefix

private

Initial value:

{
        this, "InputPrefix", "TrigMatch_",
        "Prefix used for pre-matched trigger combinations branches"}

Definition at line 93 of file NavigationDAODTesterAlgv2.h.

                                          {
        this, "InputPrefix", "TrigMatch_",
        "Prefix used for pre-matched trigger combinations branches"};

m_linearisedR2Chains

Gaudi::Property<std::vector<std::string> > Trig::NavigationDAODTesterAlgv2::m_linearisedR2Chains

private

Initial value:

{
        this, "ChainsWithLinearisedR2Matching", {"nomucomb"},
        "Chain name patterns (substring match) whose TrigMatch container uses "
        "the linearised layout: N entries of vector size 1, one per "
        "individually matched offline object, instead of one entry of size "
        "= sum of leg multiplicities per matched combination. These chains "
        "are compared PER OBJECT (pool of individually matched objects vs "
        "single-object R3 matching) instead of per combination, since the "
        "reference carries no combination structure."}

Definition at line 70 of file NavigationDAODTesterAlgv2.h.

                                                            {
        this, "ChainsWithLinearisedR2Matching", {"nomucomb"},
        "Chain name patterns (substring match) whose TrigMatch container uses "
        "the linearised layout: N entries of vector size 1, one per "
        "individually matched offline object, instead of one entry of size "
        "= sum of leg multiplicities per matched combination. These chains "
        "are compared PER OBJECT (pool of individually matched objects vs "
        "single-object R3 matching) instead of per combination, since the "
        "reference carries no combination structure."};

m_matchFromCompositeTool

PublicToolHandle<Trig::MatchFromCompositeTool> Trig::NavigationDAODTesterAlgv2::m_matchFromCompositeTool

private

Initial value:

{
        this, "MatchFromCompositeTool", "Trig::MatchFromCompositeTool", "R2 matching from pre-stored TrigComposite containers"}

Definition at line 55 of file NavigationDAODTesterAlgv2.h.

                                                                         {
        this, "MatchFromCompositeTool", "Trig::MatchFromCompositeTool", "R2 matching from pre-stored TrigComposite containers"};

m_matchingTool

PublicToolHandle<Trig::R3MatchingTool> Trig::NavigationDAODTesterAlgv2::m_matchingTool

private

Initial value:

{
        this, "R3MatchingTool", "Trig::R3MatchingTool", "R3 matching tool for converted navigation"}

Definition at line 52 of file NavigationDAODTesterAlgv2.h.

                                                       {
        this, "R3MatchingTool", "Trig::R3MatchingTool", "R3 matching tool for converted navigation"};

m_printSubfeatures

Gaudi::Property<bool> Trig::NavigationDAODTesterAlgv2::m_printSubfeatures

private

Initial value:

{
        this, "PrintSubfeatures", false,
        "When true, print subfeatures (lower-pT objects from Run2->Run3 conversion) for each passing chain"}

Definition at line 97 of file NavigationDAODTesterAlgv2.h.

                                          {
        this, "PrintSubfeatures", false,
        "When true, print subfeatures (lower-pT objects from Run2->Run3 conversion) for each passing chain"};

m_r3MatchingRerun

Gaudi::Property<bool> Trig::NavigationDAODTesterAlgv2::m_r3MatchingRerun

private

Initial value:

{
        this, "R3MatchingRerun", true,
        "Pass rerun=true to the R3 matching, i.e. also accept chains whose "
        "decision is only resurrected (prescaled or disabled chains evaluated "
        "in rerun). This must match how the R2 reference was produced: the "
        "DerivationFramework TriggerMatchingTool writes the TrigMatch_<chain> "
        "containers with Rerun=true. With false, every rerun-only event of a "
        "prescaled chain shows up as 'R2 passes, R3 fails' although the "
        "converted navigation holds the matching objects."}

Definition at line 101 of file NavigationDAODTesterAlgv2.h.

                                         {
        this, "R3MatchingRerun", true,
        "Pass rerun=true to the R3 matching, i.e. also accept chains whose "
        "decision is only resurrected (prescaled or disabled chains evaluated "
        "in rerun). This must match how the R2 reference was produced: the "
        "DerivationFramework TriggerMatchingTool writes the TrigMatch_<chain> "
        "containers with Rerun=true. With false, every rerun-only event of a "
        "prescaled chain shows up as 'R2 passes, R3 fails' although the "
        "converted navigation holds the matching objects."};

m_tdt

PublicToolHandle<Trig::TrigDecisionTool> Trig::NavigationDAODTesterAlgv2::m_tdt

private

Initial value:

{
        this, "TrigDecisionTool", "", "Read R3 navigation data from TDT"}

Definition at line 49 of file NavigationDAODTesterAlgv2.h.

                                                {
        this, "TrigDecisionTool", "", "Read R3 navigation data from TDT"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_verifyCombinations

Gaudi::Property<bool> Trig::NavigationDAODTesterAlgv2::m_verifyCombinations

private

Initial value:

{
        this, "VerifyCombinationsContent", true,
        "Check if combinations are compatible (point to same objects)"}

Definition at line 89 of file NavigationDAODTesterAlgv2.h.

                                            {
        this, "VerifyCombinationsContent", true,
        "Check if combinations are compatible (point to same objects)"};

m_verifyCombinationsSize

Gaudi::Property<bool> Trig::NavigationDAODTesterAlgv2::m_verifyCombinationsSize

private

Initial value:

{
        this, "VerifyCombinationsSize", true,
        "Check if combinations have matching size (that is Run2 >= Run3)"}

Definition at line 85 of file NavigationDAODTesterAlgv2.h.

                                                {
        this, "VerifyCombinationsSize", true,
        "Check if combinations have matching size (that is Run2 >= Run3)"};

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

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

• NavigationDAODTesterAlgv2.h
• NavigationDAODTesterAlgv2.cxx