LinkerBranch.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#include <MuonTesterTree/LinkerBranch.h>
#include <format>
namespace MuonVal{
    LinkerBranch::LinkerBranch(IParticleFourMomBranch& parent,
                               ParticleBranch_ptr linkColl,
                               Linker_t  linker,
                               const std::string& altName):
        VectorBranch<unsigned short>{parent.tree(), 
                                     std::format("{:}_{:}Link", parent.name(), altName.empty() ? linkColl->name() : altName)},
        m_linkColl{linkColl.get()},
        m_linkerFunc{std::move(linker)} {
            parent.getTree().addBranch(linkColl); 
        }
 
    void LinkerBranch::operator+=(const xAOD::IParticle* p) {
        push_back(p);
    }
    void LinkerBranch::operator+=(const xAOD::IParticle& p) {
        push_back(p);
    }
    void LinkerBranch::push_back(const xAOD::IParticle& p) {
        push_back(&p);
    }
    void LinkerBranch::push_back(const xAOD::IParticle* p) {
        const xAOD::IParticle* related = m_linkerFunc(p);
        m_linkColl->push_back(related);
        VectorBranch<unsigned short>::push_back(m_linkColl->find(related));
    }
 
    
    bool BilateralLinkerBranch::connectCollections(ParticleBranch_ptr primColl,
                                                   ParticleBranch_ptr secondColl,
                                                   Linker_t fromPrimToSec,
                                                   const std::string& altPrimName,
                                                   const std::string& altSecName) {
        return connectCollections(primColl, secondColl, fromPrimToSec, 
                                  [](const xAOD::IParticle* a, const xAOD::IParticle* b){
                                        return a == b;
                                  }, altPrimName, altSecName);
    }
    bool BilateralLinkerBranch::connectCollections(ParticleBranch_ptr primColl,
                                                   ParticleBranch_ptr secondColl,
                                                   Linker_t fromPrimToSec,
                                                   BiLinker_t fromSecToPrim,
                                                   const std::string& altPrimName,
                                                   const std::string& altSecName) {
        return primColl->addVariable(std::make_unique<LinkerBranch>(*primColl, secondColl, fromPrimToSec, altPrimName)) &&
               secondColl->addVariable(std::unique_ptr<IParticleDecorationBranch>{new BilateralLinkerBranch(*secondColl, std::move(primColl), std::move(fromPrimToSec), std::move(fromSecToPrim), altSecName)});
    }
 
                     
    BilateralLinkerBranch::BilateralLinkerBranch(IParticleFourMomBranch& parent,
                                                 ParticleBranch_ptr primColl,
                                                 Linker_t linker,
                                                 BiLinker_t fromSecToPrim,
                                                 const std::string& altName):
        VectorBranch<unsigned short>{parent.tree(), 
                                     std::format("{:}_{:}Link", parent.name(), altName.empty() ? primColl->name() : altName)},
        m_parent{parent},
        m_linkColl{primColl.get()},
        m_linkPrimToSec{std::move(linker)},
        m_linkSecToPrim{std::move(fromSecToPrim)} {
        setDefault(-1);
        parent.getTree().addBranch(primColl);
    }
 
    void BilateralLinkerBranch::push_back(const xAOD::IParticle* /* p*/) {
    }
    void BilateralLinkerBranch::push_back(const xAOD::IParticle& p) {
        push_back(&p);
    }
    void BilateralLinkerBranch::operator+=(const xAOD::IParticle* p){
        push_back(p);
    }
    void BilateralLinkerBranch::operator+=(const xAOD::IParticle& p){
        push_back(p);
    }          
    bool BilateralLinkerBranch::fill(const EventContext& ctx) {
        if (m_parent.size()) {
            get(m_parent.size() -1);
            const std::vector<const xAOD::IParticle*>& linkMe = m_linkColl->getCached();
            for (std::size_t primToSec = 0 ; primToSec < linkMe.size(); ++primToSec) {
                const xAOD::IParticle* primP = m_linkPrimToSec(linkMe[primToSec]);
                const size_t linkIdx = m_parent.find([&](const xAOD::IParticle* inBilat){
                    return m_linkSecToPrim(primP, inBilat);
                });
                if (linkIdx < size()) {
                    get(linkIdx) = primToSec;
                }
            }
        }
        ATH_MSG_VERBOSE("Fill "<<name()<<", size: "<<m_parent.size()<<"/"<<size()<<", "<<m_parent.name());
        return VectorBranch<unsigned short>::fill(ctx);
    }
}