NavigationDAODTesterAlgv2.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIG_NAVTOOLS_NAVIGATIONDAODTESTERALGV2_H
#define TRIG_NAVTOOLS_NAVIGATIONDAODTESTERALGV2_H

 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
#include "Gaudi/Property.h"
#include "TrigDecisionTool/TrigDecisionTool.h"
#include "TriggerMatchingTool/R3MatchingTool.h"
#include "TriggerMatchingTool/MatchFromCompositeTool.h"
#include "TriggerMatchingTool/IIParticleRetrievalTool.h"
#include "xAODBase/IParticleContainer.h"
 
#include "CxxUtils/checker_macros.h"
 
#include <vector>
#include <map>
#include <string>
#include <mutex>
 
 
namespace Trig {
 
class NavigationDAODTesterAlgv2 : public AthReentrantAlgorithm
{
public:
    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;
 
private:
 
    // Tool handles
    PublicToolHandle<Trig::TrigDecisionTool> m_tdt{
        this, "TrigDecisionTool", "", "Read R3 navigation data from TDT"};
 
    PublicToolHandle<Trig::R3MatchingTool> m_matchingTool{
        this, "R3MatchingTool", "Trig::R3MatchingTool", "R3 matching tool for converted navigation"};
 
    PublicToolHandle<Trig::MatchFromCompositeTool> m_matchFromCompositeTool{
        this, "MatchFromCompositeTool", "Trig::MatchFromCompositeTool", "R2 matching from pre-stored TrigComposite containers"};
 
    // Properties
    Gaudi::Property<std::vector<std::string>> m_chains{
        this, "Chains", {}, "The trigger chains to test"};
 
    Gaudi::Property<std::vector<std::string>> m_chainsToExclude{
        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)."};
 
    Gaudi::Property<std::vector<std::string>> m_linearisedR2Chains{
        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."};
 
 
    Gaudi::Property<bool> m_failOnDifference{
        this, "FailOnDifference", false,
        "Return FAILURE if the navigation does not compare equal"};
 
    Gaudi::Property<bool> m_verifyCombinationsSize{
        this, "VerifyCombinationsSize", true,
        "Check if combinations have matching size (that is Run2 >= Run3)"};
 
    Gaudi::Property<bool> m_verifyCombinations{
        this, "VerifyCombinationsContent", true,
        "Check if combinations are compatible (point to same objects)"};
 
    Gaudi::Property<std::string> m_inputPrefix{
        this, "InputPrefix", "TrigMatch_",
        "Prefix used for pre-matched trigger combinations branches"};
 
    Gaudi::Property<bool> m_printSubfeatures{
        this, "PrintSubfeatures", false,
        "When true, print subfeatures (lower-pT objects from Run2->Run3 conversion) for each passing chain"};
 
    Gaudi::Property<bool> m_r3MatchingRerun{
        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."};
 
    Gaudi::Property<bool> m_drFromRun2Lists{
        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)."};
 
    Gaudi::Property<bool> m_dumpFeaturesWithoutR2{
        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)."};
 
    // Mutable counters for statistics (thread-safe)
    mutable std::map<std::string, int> m_failingChains ATLAS_THREAD_SAFE;
    mutable std::map<std::string, int> m_emptyR2Chains ATLAS_THREAD_SAFE;
    mutable std::map<std::string, int> m_rerunOnlyChains ATLAS_THREAD_SAFE;
    mutable std::mutex m_failingChainsMutex;
 
    // Helper methods

    std::size_t numberOfLegs(const std::string& chain) const;

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

    static bool matchesAnyPattern(const std::string& chain,
                                  const std::vector<std::string>& patterns);

    static const xAOD::IParticle* resolveOriginal(const xAOD::IParticle* p);

    static bool matchLinearisedR2(std::vector<const xAOD::IParticle*> pool,
                                  const std::vector<const xAOD::IParticle*>& particles);
 
}; // end class NavigationDAODTesterAlgv2
 
 
} // end namespace Trig
 
#endif // TRIG_NAVTOOLS_NAVIGATIONDAODTESTERALGV2_H