StripDesign.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONREADOUTGEOMETRYR4_STRIPDESIGN_H
#define MUONREADOUTGEOMETRYR4_STRIPDESIGN_H
 
#include <MuonReadoutGeometryR4/MuonDetectorDefs.h>
#include <GeoModelUtilities/TransientConstSharedPtr.h>
#include <AthenaBaseComps/AthMessaging.h>
#include <optional>
#include <CxxUtils/CachedUniquePtr.h>
 
namespace MuonGMR4 {
    /* 
     * Generic class describing the layout of a Muon strip detector (E.g. the Rpcs, Micromegas, Tgc, sTgc)
     * The local coordinate system is defined such that the strip lanes are parallel to the y-axis and the
     * positive x-axis points to the next adjacent strip. The StripDesign also describes the stereo layers of the
     * Micromega detectors. There, the strips are rotated around their nominal strip center. The center position is then
     * adapted accordingly to always return the geometrical bisect of each strip lane
     * 
     * In terms of geometrical layout it is assumed that the strips are mounted onto a trapezoid where the two parallel edges are
     * parallel to the strip lanes. Its center is the origin of the local coordinate system. Further it's assumed that there is no
     * passivation w.r.t. to the slopy edges. i.e. the strips end with the edge of the panel. 
     * By specifing the position of the first strip center w.r.t. trapezoid center, the strip pitch, the number of all strips and
     * the global number of the first strip w.r.t. the global strip numbering scheme, the layout of the strip detector is completely
     * determined.
    */ 
    class StripDesign;
    using StripDesignPtr = GeoModel::TransientConstSharedPtr<StripDesign>;
    class StripDesign: public AthMessaging {
        public:
            StripDesign();
            virtual ~StripDesign() = default;
 
            double stripPitch() const;
            double stripWidth() const;
            virtual int numStrips() const;
            void defineStripLayout(Amg::Vector2D&& posFirst,
                                   const double stripPitch,
                                   const double stripWidth,
                                   const int numStrips,
                                   const int numFirst = 1);
       
            double halfWidth() const;
            double shortHalfHeight() const;
            double longHalfHeight() const;
            
            bool hasStereoAngle() const;
            double stereoAngle() const;
            bool isFlipped() const;
 
            void defineTrapezoid(double HalfShortY, double HalfLongY, double HalfHeight);
            void defineTrapezoid(double HalfShortY, double HalfLongY, double HalfHeight, double sAngle);
            void flipTrapezoid();
   
            double distanceToStrip(const Amg::Vector2D& pos, int strip) const;
 
            virtual int stripNumber(const Amg::Vector2D& pos) const;
 
            int firstStripNumber() const;
 
            using CheckVector2D = std::optional<Amg::Vector2D>;
            CheckVector2D leftEdge(int stripNumb) const;
            CheckVector2D rightEdge(int stripNumb) const;
            CheckVector2D center(int stripNumb) const;
            bool operator<(const StripDesign& other) const;
            virtual double stripLength(int stripNumb) const;
            virtual void print(std::ostream&ostr) const;
            bool insideTrapezoid(const Amg::Vector2D& extPos) const;
        protected:
            bool insideBoundaries(const Amg::Vector2D& pos) const;
            virtual Amg::Vector2D stripPosition(int stripNum) const;
            virtual CheckVector2D leftInterSect(int stripNum, bool uncapped = false) const;
            virtual CheckVector2D rightInterSect(int stripNum, bool uncapped = false) const;
            
            CheckVector2D leftInterSect(const Amg::Vector2D& stripPos, bool uncapped = false) const;
            CheckVector2D rightInterSect(const Amg::Vector2D& stripPos, bool uncapped = false) const;
            CheckVector2D stripCenter(int stripNum) const;
        public:
 
            const Amg::Vector2D& cornerBotLeft() const;
            const Amg::Vector2D& cornerBotRight() const;
            const Amg::Vector2D& cornerTopLeft() const;
            const Amg::Vector2D& cornerTopRight() const;
 
            const Amg::Vector2D& edgeDirBottom() const;
            const Amg::Vector2D& edgeDirTop() const;
            const Amg::Vector2D& edgeDirLeft() const;
            const Amg::Vector2D& edgeDirRight() const;
 
            double lenTopEdge() const;
            double lenLeftEdge() const ;
            double lenBottomEdge() const;
            double lenRightEdge() const;
 
            const Amg::Vector2D& stripNormal() const;
            const Amg::Vector2D& stripDir() const;
            const Amg::Vector2D& firstStripPos() const;
        private:
            void setStereoAngle(double stereo);
            void resetDirCache();
            int m_channelShift{1};
            int m_numStrips{0};
            double m_stripPitch{0.};
            double m_stripWidth{0.};
            Amg::Vector2D m_firstStripPos{Amg::Vector2D::Zero()};
  
            Amg::Vector2D m_stripDir{Amg::Vector2D::UnitY()};
            Amg::Vector2D m_stripNormal{Amg::Vector2D::UnitX()};
            
            bool m_isFlipped{false};
            bool m_hasStereo{false};
            double m_stereoAngle{0.};
 
            AmgSymMatrix(2) m_etaToStereo{AmgSymMatrix(2)::Identity()};
            AmgSymMatrix(2) m_stereoToEta{AmgSymMatrix(2)::Identity()};
            Amg::Vector2D m_bottomLeft{Amg::Vector2D::Zero()};
            Amg::Vector2D m_topLeft{Amg::Vector2D::Zero()};
            Amg::Vector2D m_topRight{Amg::Vector2D::Zero()};
            Amg::Vector2D m_bottomRight{Amg::Vector2D::Zero()};
            
            CxxUtils::CachedUniquePtr<Amg::Vector2D> m_dirTopEdge{};
            CxxUtils::CachedUniquePtr<Amg::Vector2D> m_dirBotEdge{};
            CxxUtils::CachedUniquePtr<Amg::Vector2D> m_dirLeftEdge{};
            CxxUtils::CachedUniquePtr<Amg::Vector2D> m_dirRightEdge{};
            double m_lenSlopEdge{0.};            
            double m_shortHalfY{0.};
            double m_longHalfY{0.};
            double m_halfX{0.};
            
            double m_yCutout{0.}; 
            double m_cutLongEdge{0.};        
        
        public:
            void defineDiamond(double HalfShortY, double HalfLongY, double HalfHeight, double yCutout);
            double yCutout() const;
    };
    
    struct StripDesignSorter{
        bool operator()(const StripDesignPtr&a, const StripDesignPtr& b) const {
             return (*a) < (*b);
        }
        bool operator()(const StripDesign&a ,const StripDesign& b) const {
            return a < b;
        }
    };
  
    std::ostream& operator<<(std::ostream& ostr, const StripDesign& design);
}
#include <MuonReadoutGeometryR4/StripDesign.icc>
#endif