ChamberViewer.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef XAODMUONPREPDATA_CHAMBERVIEWER_H
#define XAODMUONPREPDATA_CHAMBERVIEWER_H
 
#include <type_traits>
 
#include <xAODMeasurementBase/MeasurementDefs.h>
#include <MuonIdHelpers/IMuonIdHelperSvc.h>
#include <GeoModelHelpers/throwExcept.h>
 
#define BUILD_TRAIT(traitName, conceptPass) \
    template <typename T> struct traitName{}; \
    template <conceptPass T> struct traitName<T>{static constexpr bool value = true;}; \
    template <typename T> requires (!conceptPass <T>) struct traitName<T>{static constexpr bool value = false;};
 
namespace xAOD{
    namespace ChamberViewConcepts{
        template <typename ObjType> concept hasIdentifyConcept = requires (const ObjType theObj) {
            theObj.identify(); 
        };
        template <typename ObjType> concept hasIdentifierHashConcept = requires(const ObjType theObj) {
            theObj.identifierHash();
        };
 
        BUILD_TRAIT(hasIdentify, hasIdentifyConcept)
        BUILD_TRAIT(hasIdentifyHash, hasIdentifierHashConcept)
        template<class HitObjContainer> concept ContainerConcept =
            (hasIdentify<typename std::remove_pointer_t<typename HitObjContainer::value_type>>::value ||
             hasIdentifyHash<typename  std::remove_pointer_t<typename HitObjContainer::value_type>>::value);
    }
 
    namespace ChamberView {
        enum class Mode{
            DetElement ,
            Chamber 
        };
    }
 
      
    template<ChamberViewConcepts::ContainerConcept HitObjContainer>
        class ChamberViewer {
            public:
                using value_type = typename HitObjContainer::value_type;
                using element_type = typename std::remove_pointer_t<value_type>;
                template <typename HitObjType> struct ref_trait{};
                template <typename HitObjType> requires (std::is_pointer_v<HitObjType>) struct ref_trait<HitObjType>{
                    using element_type = typename std::remove_pointer_t<HitObjType>;
                    using const_type = typename std::add_const_t<element_type>;
                    using type = std::add_pointer_t<const_type>; 
                };
                template <typename HitObjType> requires (!std::is_pointer_v<HitObjType>)struct ref_trait<HitObjType>{
                    using const_type = typename std::add_const_t<HitObjType>;
                    using type = typename std::add_lvalue_reference<const_type>::type;
                };
                using const_ref = ref_trait<value_type>::type;
                using ViewMode = ChamberView::Mode;
                
                ChamberViewer(const HitObjContainer& container) noexcept:
                    m_container{container} {
                    static_assert(ChamberViewConcepts::hasIdentifyHash<element_type>::value, "Object needs to provide identifierHash" );
                    next();
                }
                ChamberViewer(const HitObjContainer& container, 
                             const Muon::IMuonIdHelperSvc* idHelperSvc,
                             const ViewMode mode = ViewMode::DetElement) noexcept:
                    m_container{container},
                    m_idHelperSvc{idHelperSvc},
                    m_mode{mode} {
                    static_assert(ChamberViewConcepts::hasIdentify<element_type>::value, "Object needs to provide identify()" );
                    next();
                }
                ChamberViewer(const ChamberViewer& other) = delete;
                ChamberViewer& operator=(const ChamberViewer& other) = delete;
                ChamberViewer(ChamberViewer&& other) = default;
                ChamberViewer& operator=(ChamberViewer&& other) = default;
                HitObjContainer::const_iterator begin() const noexcept{
                    return m_begin;
                }
                HitObjContainer::const_iterator end() const noexcept {
                    return m_end;
                }
                std::size_t size() const noexcept{
                    return std::distance(m_begin, m_end);
                }
                HitObjContainer::const_iterator::reference at(const std::size_t idx) const {
                    if (idx >= size()) {
                        THROW_EXCEPTION("Invalid index given "<<typeid(value_type).name()<<" Size: "<<size()<<", requested: "<<idx);
                    }
                    return (*m_begin +idx);
                }
                bool next() noexcept {
                    if (m_end == m_container.end()) {
                        return false;
                    }
                    m_begin = m_end;
                    if constexpr (ChamberViewConcepts::hasIdentifyHash<element_type>::value) {
                        m_currentHash = (*m_end)->identifierHash();
                        m_end = std::find_if(m_begin, m_container.end(),
                                         [this](const_ref meas){
                                            return meas->identifierHash() != m_currentHash;
                                        });
                    } else {
                         m_currentHash = idHash((*m_end)->identify());
                         m_end = std::find_if(m_begin, m_container.end(),
                                         [this](const_ref meas){
                                            return idHash(meas->identify()) != m_currentHash;
                                        });                       
                    }
                    if (m_begin == m_end) return next(); // veto empty views
                    return true;
                }
 
                bool loadView(const Identifier& chamberId) {
                    static_assert(ChamberViewConcepts::hasIdentify<element_type>::value, "Object needs to provide identify()" );
                    const IdentifierHash detId = idHash(chamberId);
                    m_begin = std::ranges::find_if(m_container,[this,&detId](const_ref meas) {
                                                        return idHash(meas->identify()) == detId;
                                                   });
                    m_end = std::find_if(m_begin, m_container.end(),[this,&detId](const_ref meas) {
                                                        return idHash(meas->identify()) != detId;
                                                   });
                    return m_begin != m_end;
                }
                bool loadView(const IdentifierHash& idHash) {
                    static_assert(ChamberViewConcepts::hasIdentifyHash<element_type>::value, "Object needs to provide identify()" );
                    m_begin = std::ranges::find_if(m_container,[&idHash](const_ref meas) {
                                                        return meas->identifierHash() == idHash;
                                                   });
                    m_end = std::find_if(m_begin, m_container.end(),[&idHash](const_ref meas) {
                                                        return meas->identifierHash() != idHash;
                                                   });
                     return m_begin != m_end;
                }
 
                bool loadView(std::function<bool(const_ref)> selector) {
                    m_begin = std::ranges::find_if(m_container, selector);
                    m_end = std::find_if(m_begin, m_container.end(),
                                         [&selector](const_ref meas) {
                                            return !selector(meas);
                                        });
                    return m_begin != m_end;
                }
 
            private:
                IdentifierHash idHash(const Identifier& id) const {
                    return m_mode == ViewMode::DetElement ? m_idHelperSvc->detElementHash(id)
                                                          : m_idHelperSvc->moduleHash(id);
                }
                const HitObjContainer& m_container;
                const Muon::IMuonIdHelperSvc* m_idHelperSvc{nullptr};
                const ViewMode m_mode{ViewMode::DetElement};
                DetectorIDHashType m_currentHash{0};
                HitObjContainer::const_iterator m_end{m_container.begin()};
                HitObjContainer::const_iterator m_begin{m_container.begin()};
    };
}
#undef buildTrait
#endif