MMReadoutElement.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONREADOUTGEOMETRY_MMREADOUTELEMENT_H
#define MUONREADOUTGEOMETRY_MMREADOUTELEMENT_H
 
#include "MuonReadoutGeometry/MuonChannelDesign.h"
#include "MuonReadoutGeometry/MuonClusterReadoutElement.h"
#include "MuonReadoutGeometry/MuonDetectorManager.h"
#include "CxxUtils/ArrayHelper.h"
#include "MuonAlignmentData/NswPassivationDbData.h"
 
class BLinePar;
class MuonReadoutGeomCnvAlg;
 
namespace MuonGM {
    class MMReadoutElement final : public MuonClusterReadoutElement {
    public:
        friend class ::MuonReadoutGeomCnvAlg;
        MMReadoutElement(GeoVFullPhysVol* pv, const std::string& stName, int zi, int fi, int mL, 
                         MuonDetectorManager* mgr, const NswPassivationDbData*);
 
        ~MMReadoutElement();
 
        virtual bool containsId(const Identifier& id) const override final;
 
        virtual double distanceToReadout(const Amg::Vector2D& pos, const Identifier& id) const override final;
 
        virtual int stripNumber(const Amg::Vector2D& pos, const Identifier& id) const override final;
 
        virtual bool stripPosition(const Identifier& id, Amg::Vector2D& pos) const override final;
        bool stripGlobalPosition(const Identifier& id, Amg::Vector3D& gpos) const;
 
        double stereoAngle(const Identifier& id) const;
 
        double stripLength(const Identifier& id) const;
        double stripActiveLength(const Identifier& id) const;
        double stripActiveLengthLeft(const Identifier& id) const;
        double stripActiveLengthRight(const Identifier& id) const;
 
        bool insideActiveBounds(const Identifier& id, const Amg::Vector2D& locpos, double tol1 = 0., double tol2 = 0.) const;
 
        virtual int numberOfLayers(bool) const override;
 
        virtual int numberOfStrips(const Identifier& layerId) const override final;
        virtual int numberOfStrips(int, bool measuresPhi) const override final;
 
        int numberOfMissingTopStrips(const Identifier& layerId) const;
        int numberOfMissingBottomStrips(const Identifier& layerId) const;
 
        virtual bool spacePointPosition(const Identifier& phiId, const Identifier& etaId, Amg::Vector2D& pos) const override final;
 
        virtual bool spacePointPosition(const Identifier& phiId, const Identifier& etaId, Amg::Vector3D& pos) const override final;
        Amg::Vector3D localToGlobalCoords(const Amg::Vector3D& locPos, const Identifier& id) const;
 
        bool spacePointPosition(const Identifier& layerId, const Amg::Vector2D& localPos, Amg::Vector3D& pos) const;
        
        virtual void fillCache() override final;
 
        virtual int surfaceHash(const Identifier& id) const override final;
 
        int surfaceHash(int gasGap, int measPhi) const;
 
        virtual int layerHash(const Identifier& id) const override final;
        int layerHash(int gasGap) const;
 
        virtual int boundaryHash(const Identifier& id) const override final;
 
        virtual bool measuresPhi(const Identifier& id) const override final;
 
        void initDesign();
 
        const MuonChannelDesign* getDesign(const Identifier& id) const;
 
        void setChamberLayer(int ml) { m_ml = ml; }
 
        const Amg::Transform3D& getDelta() const { return m_delta; }
        void setDelta(const ALinePar& aline);
       
        void setBLinePar(const BLinePar& bLine);
       
        void posOnDefChamber(Amg::Vector3D& locPosML) const;
 
        bool  has_ALines() const { return (m_ALinePar != nullptr); }
        bool  has_BLines() const { return (m_BLinePar != nullptr); }
        const ALinePar* getALinePar() const { return m_ALinePar; }
        const BLinePar* getBLinePar() const { return m_BLinePar; }
        void  clearALinePar();
        void  clearBLinePar() { m_BLinePar = nullptr; }
        const std::array<int, 4> & getReadoutSide() const { return m_readoutSide; }
      
        // Amdb local (szt) to global coord
        virtual Amg::Vector3D AmdbLRSToGlobalCoords(const Amg::Vector3D& x) const override final { return AmdbLRSToGlobalTransform()*x; }
        virtual Amg::Transform3D AmdbLRSToGlobalTransform() const override final { return absTransform()*Amg::Translation3D(0, 0, m_offset)*getDelta(); }
        // Global to Amdb local (szt) coord
        virtual Amg::Vector3D GlobalToAmdbLRSCoords(const Amg::Vector3D& x) const override final { return GlobalToAmdbLRSTransform()*x; }
        virtual Amg::Transform3D GlobalToAmdbLRSTransform() const override final { return AmdbLRSToGlobalTransform().inverse(); }
 
    private:
 
        void initDesignSqLite();
 
        const MmIdHelper& m_idHelper{idHelperSvc()->mmIdHelper()};
        
        using PCBPassivation = NswPassivationDbData::PCBPassivation;
        static constexpr PCBPassivation s_dummy_passiv{};
        // MuonChannelDesign m_phiDesign;
        std::array<MuonChannelDesign, 4> m_etaDesign{};
 
        int m_nlayers{0};  // #of gas gaps
 
        const NswPassivationDbData* m_passivData{nullptr};
 
        int m_ml{0};  // multilayer (values: 1,2)
 
        // surface dimensions
        double m_halfX{100.};       // 0.5*radial_size (active area)
        double m_minHalfY{1900.};   // 0.5*bottom length (active area)
        double m_maxHalfY{2000.};   // 0.5*top length (active area)
        double m_offset{0.};        // radial dist. of active area center w.r.t. chamber center
 
        double m_sWidthChamber{0.}; // bottom base length (full chamber)
        double m_lWidthChamber{0.}; // top base length (full chamber)
        double m_lengthChamber{0.}; // radial size (full chamber)
        double m_tckChamber{0.};    // thickness (full chamber)
        Amg::Transform3D m_delta{Amg::Transform3D::Identity()};
        const ALinePar*  m_ALinePar{nullptr};
        const BLinePar*  m_BLinePar{nullptr};
        std::array<int, 4> m_readoutSide{};
        // transforms (RE->layer)
        std::array<Amg::Transform3D, 4> m_Xlg{make_array<Amg::Transform3D,4>(Amg::Transform3D::Identity())};
    };
 
    inline int MMReadoutElement::surfaceHash(const Identifier& id) const { return surfaceHash(m_idHelper.gasGap(id), 0); }
 
    inline int MMReadoutElement::surfaceHash(int gasGap, int /*measPhi*/) const { return gasGap - 1; } // measPhi not used
 
    inline int MMReadoutElement::layerHash(const Identifier& id) const { return layerHash(m_idHelper.gasGap(id)); }
 
    inline int MMReadoutElement::layerHash(int gasGap) const { return gasGap - 1; }
 
    inline int MMReadoutElement::boundaryHash(const Identifier& id) const { return layerHash(m_idHelper.gasGap(id)); }
 
    inline bool MMReadoutElement::measuresPhi(const Identifier& /*id*/) const { return false; }
 
    inline const MuonChannelDesign* MMReadoutElement::getDesign(const Identifier& id) const {
        return &(m_etaDesign[layerHash(id)]);
    }
    inline double MMReadoutElement::distanceToReadout(const Amg::Vector2D& pos, const Identifier& id) const {
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return -1.;
        return design->distanceToReadout(pos);
    }
 
    inline int MMReadoutElement::stripNumber(const Amg::Vector2D& pos, const Identifier& id) const {
        // returns the position of the strip at pos, assuming the nominal geometry (no as-built conditions)
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return -1;
        return design->channelNumber(pos);
    }
 
    inline bool MMReadoutElement::stripPosition(const Identifier& id, Amg::Vector2D& pos) const {
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return false;
        return design->center(m_idHelper.channel(id), pos);
    }
 
    inline double MMReadoutElement::stereoAngle(const Identifier& id) const {
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return 0;
        return design->stereoAngle();
    }
 
    inline double MMReadoutElement::stripLength(const Identifier& id) const {
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return -1;
        return design->channelLength(m_idHelper.channel(id));
    }
 
    inline double MMReadoutElement::stripActiveLength(const Identifier& id) const {
        return stripActiveLengthLeft(id) + stripActiveLengthRight(id); 
    }
 
    inline double MMReadoutElement::stripActiveLengthLeft(const Identifier& id) const {
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return -1;
 
        const PCBPassivation& passiv = m_passivData ? m_passivData->getPassivation(id) : s_dummy_passiv;
        // Let's keep it for the moment as we have to think about proper treatmeant of the non-passivated stuff
        // if (m_passivData && !passiv.valid) return -1;
 
        double l = design->channelHalfLength(m_idHelper.channel(id), true);
        if (l < 0) return -1;
        return std::max(0., l - design->passivatedLength(passiv.left, true));
    }
        
    inline double MMReadoutElement::stripActiveLengthRight(const Identifier& id) const {
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return -1;
 
        const PCBPassivation& passiv = m_passivData ? m_passivData->getPassivation(id) : s_dummy_passiv;
        // Let's keep it for the moment as we have to think about proper treatmeant of the non-passivated stuff
        // if (m_passivData && !passiv.valid) return -1;
 
        double l = design->channelHalfLength(m_idHelper.channel(id), false);
        if (l < 0) return -1;
        return std::max(0., l - design->passivatedLength(passiv.right, false));
    }
 
    inline bool MMReadoutElement::insideActiveBounds(const Identifier& id, const Amg::Vector2D& locpos, double tol1, double tol2) const {
        const MuonChannelDesign* design = getDesign(id);
        if(!design) return false;
        // Get the nearest strip number; not the time yet to check boundaries (in case of tolerance) 
        int stripNo = stripNumber(locpos, id);
        if (stripNo < 0) stripNo = (locpos.x()<0) ? 1 : design->totalStrips;
        Identifier channelId = m_idHelper.channelID(id, m_ml, m_idHelper.gasGap(id), stripNo);
 
        // ** Horizontal passivation: mask entire strips
        //==============================================
        int pcb      = (stripNo-1)/1024 + 1; // starts from 1
        int pcbStrip = stripNo % 1024;// - 1024*(pcb - 1);
        const PCBPassivation& pcbPassiv = m_passivData ? m_passivData->getPassivation(channelId) : s_dummy_passiv;
        // if(m_passivData && !pcbPassiv.valid) return false;
        // the passivated width is constant along the PCB edge (not along y for stereo strips)
        bool topPcb{pcb == 5 || (std::abs(getStationEta()) == 2 && pcb == 3)};
        int pcbStripMin =    1 + (int)std::floor((design->passivatedHeight(pcbPassiv.bottom, pcb ==1) + 0.5*design->inputPitch - tol1)/design->inputPitch); // first pcb strip surviving passivation
        int pcbStripMax = 1024 - (int)std::floor((design->passivatedHeight(pcbPassiv.top, topPcb)    + 0.5*design->inputPitch - tol1)/design->inputPitch); //  last pcb strip surviving passivation
        if(pcbStrip < pcbStripMin || pcbStrip > pcbStripMax) return false;
 
        // ** Vertical passivation: cut strips from left and right
        //=======================================
        return bounds(id).inside(locpos, tol1, tol2  - design->passivatedLength(locpos[1]<0 ? pcbPassiv.left : pcbPassiv.right , locpos[1] < 0));
    }
 
    inline bool MMReadoutElement::stripGlobalPosition(const Identifier& id, Amg::Vector3D& gpos) const {
        Amg::Vector2D lpos{Amg::Vector2D::Zero()};
        if (!stripPosition(id, lpos)) return false;
        surface(id).localToGlobal(lpos, Amg::Vector3D::Zero(), gpos);
        return true;
    }
 
    inline int MMReadoutElement::numberOfLayers(bool) const { return m_nlayers; }
 
    inline int MMReadoutElement::numberOfStrips(const Identifier& layerId) const { return m_etaDesign[layerHash(layerId)].totalStrips; }
 
    inline int MMReadoutElement::numberOfStrips(int lay, bool /*measPhi*/) const {
        if (lay > -1 && lay < static_cast<int>(m_etaDesign.size()))
            return m_etaDesign[lay].totalStrips;
        else
            return -1;
    }
 
    inline int MMReadoutElement::numberOfMissingTopStrips(const Identifier& id) const {
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return -1;
        return design->numberOfMissingTopStrips();
    }
 
    inline int MMReadoutElement::numberOfMissingBottomStrips(const Identifier& id) const {
        const MuonChannelDesign* design = getDesign(id);
        if (!design) return -1;
        return design->numberOfMissingBottomStrips();
    }
 
    inline bool MMReadoutElement::spacePointPosition(const Identifier& phiId, const Identifier& etaId, Amg::Vector2D& pos) const {
        if (!stripPosition(etaId, pos)) return false;
        const MuonChannelDesign* phi_design = getDesign(phiId);
        const MuonChannelDesign* eta_design = getDesign(etaId);
        if (!phi_design || !eta_design) return false;
        pos = phi_design->rotation() * eta_design->rotation().inverse()*pos;
        return true;
    }
    
    inline bool MMReadoutElement::spacePointPosition(const Identifier& phiId, const Identifier& etaId, Amg::Vector3D& pos) const {
        Amg::Vector2D lpos{Amg::Vector2D::Zero()};
        spacePointPosition(phiId, etaId, lpos);
        surface(phiId).localToGlobal(lpos, pos, pos);
        return true;
    }
   
}  // namespace MuonGM
 
#endif  // MUONREADOUTGEOMETRY_MMREADOUTELEMENT_H