MuonClusterReadoutElement.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONREADOUTGEOMETRY_MUONCLUSTERREADOUTELEMENT_H
#define MUONREADOUTGEOMETRY_MUONCLUSTERREADOUTELEMENT_H
 
 
#include <stdexcept>
#include <string>
#include <vector>
 
#include "MuonReadoutGeometry/MuonReadoutElement.h"
#include "TrkSurfaces/PlaneSurface.h"
#include "TrkSurfaces/SurfaceBounds.h"
 
namespace MuonGM {
 
    class MuonDetectorManager;
 
    class MuonClusterReadoutElement : public MuonReadoutElement {
    public:
        struct SurfaceData {
            std::vector<Amg::Vector3D> m_layerNormals{};

            std::vector<std::unique_ptr<Trk::SurfaceBounds>> m_surfBounds{};

            std::vector<Amg::Transform3D> m_layerTransforms{};

            std::vector<std::unique_ptr<Trk::PlaneSurface>> m_layerSurfaces{};

            std::vector<Amg::Vector3D> m_layerCenters{};
 
            SurfaceData() = default;
            ~SurfaceData() = default;
        };
 
      
        ~MuonClusterReadoutElement();

        virtual double distanceToReadout(const Amg::Vector2D& pos, const Identifier& id) const = 0;

        virtual int stripNumber(const Amg::Vector2D& pos, const Identifier& id) const = 0;

        virtual bool stripPosition(const Identifier& id, Amg::Vector2D& pos) const = 0;

        virtual bool spacePointPosition(const Identifier& phiId, const Identifier& etaId, Amg::Vector2D& pos) const = 0;

        virtual bool spacePointPosition(const Identifier& phiId, const Identifier& etaId, Amg::Vector3D& pos) const = 0;

        virtual int numberOfLayers(bool measuresPhi) const = 0;

        virtual int numberOfStrips(const Identifier& layerId) const = 0;
        virtual int numberOfStrips(int layer, bool measuresPhi) const = 0;

        virtual void clearCache() override final;

        virtual const Trk::PlaneSurface& surface() const override;
        virtual const Trk::SurfaceBounds& bounds() const override;
        virtual const Amg::Vector3D& center() const override;
        virtual const Amg::Vector3D& normal() const override;
        virtual const Amg::Transform3D& transform() const override;

        virtual const Trk::PlaneSurface& surface(const Identifier& id) const override;
        virtual const Trk::SurfaceBounds& bounds(const Identifier& id) const override;
        virtual const Amg::Vector3D& center(const Identifier& id) const override;
        virtual const Amg::Vector3D& normal(const Identifier& id) const override;
        virtual const Amg::Transform3D& transform(const Identifier& id) const override;

        const Trk::PlaneSurface& surface(int surfHash) const;
        const Trk::SurfaceBounds& bounds(int boundHash) const;
        const Amg::Vector3D& center(int layHash) const;
        const Amg::Vector3D& normal(int layHash) const;
        const Amg::Transform3D& transform(int surfHash) const;

        virtual std::vector<const Trk::Surface*> surfaces() const;

        virtual int layerHash(const Identifier& id) const = 0;

        virtual int surfaceHash(const Identifier& id) const = 0;

        virtual int boundaryHash(const Identifier& id) const = 0;

        virtual bool measuresPhi(const Identifier& id) const = 0;
 
    protected:
        
        MuonClusterReadoutElement(GeoVFullPhysVol* pv, MuonDetectorManager* mgr, Trk::DetectorElemType detType);
 
        std::unique_ptr<SurfaceData> m_surfaceData{};
    };
 
    inline const Trk::PlaneSurface& MuonClusterReadoutElement::surface() const { return surface(0); }
    inline const Amg::Transform3D& MuonClusterReadoutElement::transform() const { return transform(0); }
    inline const Amg::Vector3D& MuonClusterReadoutElement::center() const { return center(0); }
    inline const Amg::Vector3D& MuonClusterReadoutElement::normal() const { return normal(0); }
    inline const Trk::SurfaceBounds& MuonClusterReadoutElement::bounds() const { return bounds(0); }
 
    inline const Trk::PlaneSurface& MuonClusterReadoutElement::surface(const Identifier& id) const { return surface(surfaceHash(id)); }
    inline const Amg::Transform3D& MuonClusterReadoutElement::transform(const Identifier& id) const { return transform(surfaceHash(id)); }
    inline const Amg::Vector3D& MuonClusterReadoutElement::center(const Identifier& id) const { return center(layerHash(id)); }
    inline const Amg::Vector3D& MuonClusterReadoutElement::normal(const Identifier& id) const { return normal(layerHash(id)); }
    inline const Trk::SurfaceBounds& MuonClusterReadoutElement::bounds(const Identifier& id) const { return bounds(boundaryHash(id)); }
 
    inline const Trk::PlaneSurface& MuonClusterReadoutElement::surface(int hash) const {
        if (!m_surfaceData) {
            ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" "<<__func__<<" Requesting surface but cache is empty");
            throw std::runtime_error("Empty surface cache");
        }
        if (hash == -1 || hash >= (int)m_surfaceData->m_layerSurfaces.size()) {
            ATH_MSG_WARNING(" surface hash out of range: " << hash << " elements "
                            << m_surfaceData->m_layerSurfaces.size());
            return *m_surfaceData->m_layerSurfaces.front();
        }
        return *m_surfaceData->m_layerSurfaces[hash];
    }
 
    inline const Amg::Transform3D& MuonClusterReadoutElement::transform(int hash) const {
        if (!m_surfaceData) {
            ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" "<<__func__<<" Requesting transform but cache is empty");
            throw std::runtime_error("Empty transform cache");
        }
        if (hash == -1 || hash >= (int)m_surfaceData->m_layerTransforms.size()) {
            ATH_MSG_WARNING("transform hash out of range: " << hash << " elements "
                    << m_surfaceData->m_layerTransforms.size());
            return m_surfaceData->m_layerTransforms.front();
        }
        return m_surfaceData->m_layerTransforms[hash];
    }
 
    inline const Amg::Vector3D& MuonClusterReadoutElement::center(int hash) const {
        if (!m_surfaceData) {
           ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" "<<__func__<<" Requesting center but cache is empty");
           throw std::runtime_error("Empty center cache");
        }
        if (hash == -1 || hash >= (int)m_surfaceData->m_layerCenters.size()) {
            ATH_MSG_WARNING("center hash out of range: " << hash << " elements " << m_surfaceData->m_layerCenters.size());
            return m_surfaceData->m_layerCenters.front();
        }
        return m_surfaceData->m_layerCenters[hash];
    }
 
    inline const Amg::Vector3D& MuonClusterReadoutElement::normal(int hash) const {
        if (!m_surfaceData) {
           ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" "<<__func__<<" Requesting normal but cache is empty");
           throw std::runtime_error("Empty normal cache");
        }
        if (hash == -1 || hash >= (int)m_surfaceData->m_layerNormals.size()) {
            ATH_MSG_WARNING("normal hash out of range: " << hash << " elements " << m_surfaceData->m_layerNormals.size());
            return m_surfaceData->m_layerNormals.front();
        }
        return m_surfaceData->m_layerNormals[hash];
    }
 
    inline const Trk::SurfaceBounds& MuonClusterReadoutElement::bounds(int hash) const {
        if (!m_surfaceData) {
            ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" "<<__func__<<" Requesting bounds but cache is empty");
            throw std::runtime_error("Empty bounds cache");
        }
        if (hash == -1 || hash >= (int)m_surfaceData->m_surfBounds.size()) {
            ATH_MSG_WARNING("normal hash out of range: " << hash << " elements " << m_surfaceData->m_surfBounds.size());
            return *m_surfaceData->m_surfBounds.front();
        }
        return *m_surfaceData->m_surfBounds[hash];
    }
 
    inline std::vector<const Trk::Surface*> MuonClusterReadoutElement::surfaces() const {
        std::vector<const Trk::Surface*> elementSurfaces;
 
        // create when first time requested and when possible
        if (m_surfaceData) {
            elementSurfaces.reserve(m_surfaceData->m_layerSurfaces.size());
            for (const std::unique_ptr<Trk::PlaneSurface>& ptr : m_surfaceData->m_layerSurfaces) {
                elementSurfaces.emplace_back(ptr.get());
            }
        }
        // return the element surfaces
        return elementSurfaces;
    }
 
}  // namespace MuonGM
#endif  // MUONREADOUTGEOMETRY_MUONCLUSTERREADOUTELEMENT_H