PhysicsAnalysis/AnalysisCommon/IsolationSelection/IsolationSelection/Defs.h

Go to the documentation of this file.

/*
 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef ISOLATIONSELECTION_DEFS_H
#define ISOLATIONSELECTION_DEFS_H
 
// EDM include(s):
#include <AthContainers/AuxElement.h>
#include <xAODCaloEvent/CaloCluster.h>
#include <xAODPFlow/FlowElement.h>
#include <xAODPrimitives/IsolationType.h>
#include <xAODTracking/TrackParticle.h>
 
#include <set>
#include <unordered_set>
namespace CP {
 
    using CharAccessor = SG::ConstAccessor<char>;
    using CharDecorator = SG::Decorator<char>;
 
    using FloatAccessor = SG::ConstAccessor<float>;
    using FloatDecorator = SG::Decorator<float>;
 
    using SelectionAccessor = std::unique_ptr<CharAccessor>;
    using SelectionDecorator = std::unique_ptr<CharDecorator>;
 
    using BoolDecorator = SG::Decorator<bool>;
    using BoolAccessor = SG::ConstAccessor<bool>;
 
    using IntDecorator = SG::Decorator<int>;
    using IntAccessor = SG::ConstAccessor<int>;
 
    using ShortDecorator = SG::Decorator<short>;
    using ShortAccessor = SG::ConstAccessor<short>;
 
    using IsoType = xAOD::Iso::IsolationType;
    using IsoVector = std::vector<IsoType>;

    template <class Obj> struct SortedObjPtr {
        SortedObjPtr() = default;
        SortedObjPtr(const Obj* ptr) : m_ptr{ptr} {}
 
        const Obj* get() const { return m_ptr; }
        const Obj* operator->() const { return m_ptr; }
        const Obj& operator*() const { return *m_ptr; }
        bool operator!() const { return !m_ptr; }
        operator bool() const { return m_ptr; }
        operator const Obj*() const { return m_ptr; }
        bool operator<(const SortedObjPtr<Obj>& other) const {
            return other.get() != get() && get() &&
                   (!other || other->pt() < get()->pt() || (other->pt() == get()->pt() && other.get() < get()));
        }
 
    private:
        const Obj* m_ptr{nullptr};
    };

    struct FlowElementPtr : public SortedObjPtr<xAOD::FlowElement> {
        FlowElementPtr(const xAOD::FlowElement* ele, float weight_) : SortedObjPtr<xAOD::FlowElement>{ele}, weight{weight_} {}
        FlowElementPtr() = default;
        bool operator<(const FlowElementPtr& other) const {
            if (other.weight != weight) return weight < other.weight;
            return SortedObjPtr<xAOD::FlowElement>::operator<(other);
        }
        float weight{1.f};
    };
 
    using CaloClusterPtr = SortedObjPtr<xAOD::CaloCluster>;
    using TrackPtr = SortedObjPtr<xAOD::TrackParticle>;
 
    using TrackSet = std::set<TrackPtr>;
    using ClusterSet = std::set<CaloClusterPtr>;
    using PflowSet = std::set<FlowElementPtr>;
 
    using UnorderedClusterSet = std::unordered_set<const xAOD::CaloCluster*>;
    using UnorderedContainerSet = std::unordered_set<const SG::AuxVectorData*>;
}  // namespace CP
 
#endif