ChamberViewer.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef XAODMUONPREPDATA_CHAMBERVIEWER_H
#define XAODMUONPREPDATA_CHAMBERVIEWER_H
 
 
 
#include <xAODMeasurementBase/MeasurementDefs.h>
#include <MuonIdHelpers/IMuonIdHelperSvc.h>
 
#include "Acts/Utilities/PointerTraits.hpp"
 
#include <stdexcept>
#include <format>
#include <functional> //std::function
#include <algorithm>  //std::ranges::find_if
 
namespace xAOD{
    
    
    namespace ChamberViewConcepts{
        template <typename ObjType> concept identifyConcept = requires (const ObjType theObj) {
            theObj.identify(); 
        };

        template <typename ObjType> concept identifierHashConcept = requires(const ObjType theObj) {
            theObj.identifierHash();
        };
        template<class HitObjContainer> concept ContainerConcept =
            (identifyConcept<typename Acts::RemovePointer_t<typename HitObjContainer::value_type>> ||
             identifierHashConcept<typename  Acts::RemovePointer_t<typename HitObjContainer::value_type>>);
    }
 
    namespace ChamberView {
        enum class Mode: std::uint8_t{
            DetElement ,
            Chamber 
        };
    }
 
      
    template<ChamberViewConcepts::ContainerConcept HitObjContainer>
        class ChamberViewer {
            public:
                using value_type = typename HitObjContainer::value_type;
                using element_type = typename Acts::RemovePointer_t<value_type>;
               
                using const_iterator = typename HitObjContainer::const_iterator;
                using const_ref = typename const_iterator::reference;               
                using ViewMode = ChamberView::Mode;
                
                 ChamberViewer(const HitObjContainer& container) 
                    requires(ChamberViewConcepts::identifierHashConcept<element_type>):
                    m_container{container} {                   
                    next();
                }
 
                 ChamberViewer(const HitObjContainer& container, 
                             const Muon::IMuonIdHelperSvc* idHelperSvc,
                             const ViewMode mode = ViewMode::DetElement) 
                    requires(ChamberViewConcepts::identifyConcept<element_type>):
                    m_container{container},
                    m_idHelperSvc{idHelperSvc},
                    m_mode{mode} {                   
                    next();
                }

                ChamberViewer(const ChamberViewer& other) = delete;
                ChamberViewer& operator=(const ChamberViewer& other) = delete;
                ChamberViewer(ChamberViewer&& other) = default;
                ChamberViewer& operator=(ChamberViewer&& other) = default;
                const_iterator begin() const noexcept{
                    return m_begin;
                }

                const_iterator end() const noexcept {
                    return m_end;
                }

                std::size_t size() const noexcept {
                    return std::distance(m_begin, m_end);
                }

                const_ref at(const std::size_t idx) const {
                    if (idx >= size()) {
                        throw std::domain_error(std::format("Invalid index given {:}. size: {:}, requested:{:} ", 
                                                        typeid(const_ref).name(), size(), idx));
                    }
                    return *(m_begin +idx);
                }

                bool next() {
                    if (m_end == m_container.end()) {
                        return false;
                    }
                    m_begin = m_end;
                    if constexpr (ChamberViewConcepts::identifierHashConcept<element_type>) {
                         const IdentifierHash currentHash = (*m_end)->identifierHash();
                        m_end = std::find_if(m_begin, m_container.end(),
                                         [&currentHash](const_ref meas){
                                            return meas->identifierHash() != currentHash;
                                        });
                    } else {
                         const IdentifierHash currentHash = idHash((*m_end)->identify());
                         m_end = std::find_if(m_begin, m_container.end(),
                                         [this,&currentHash](const_ref meas){
                                            return idHash(meas->identify()) != currentHash;
                                        });                       
                    }
                    if (m_begin == m_end) {
                        return next(); // veto empty views
                    }
                    return true;
                }

                bool loadView(const Identifier& chamberId) 
                    requires(ChamberViewConcepts::identifyConcept<element_type>) {
 
                    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)
                    requires(ChamberViewConcepts::identifierHashConcept<element_type>) {                   
                    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;
                }
                bool next(std::function<bool(const_ref)> selector) {
                    if (m_end == m_container.end()) {
                        return false;
                    }
                    const_iterator nextBegin = std::ranges::find_if(m_end, m_container.end(), selector);
                    if (nextBegin == m_container.end()) {
                        return false;
                    }
                    m_begin = nextBegin;
                    m_end = std::find_if(m_begin, m_container.end(),
                                         [&selector](const_ref meas) {
                                            return !selector(meas);
                                        });
                    return true;
                }
 
            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};
                const_iterator m_end{m_container.begin()};
                const_iterator m_begin{m_container.begin()};
    };
}
#endif