MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MuonReadoutElement.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONGEOMODELR4_MUONREADOUTELEMENT_H
#define MUONGEOMODELR4_MUONREADOUTELEMENT_H
 
#include <MuonReadoutGeometryR4/MuonDetectorDefs.h>
#include <AthenaBaseComps/AthMessaging.h>
#include <GaudiKernel/ServiceHandle.h>
#include <GeoModelKernel/GeoVDetectorElement.h>
#include <GeoModelKernel/GeoAlignableTransform.h>
#include <MuonIdHelpers/IMuonIdHelperSvc.h>
 
#include <ActsGeoUtils/Defs.h>
#include <ActsGeometryInterfaces/IDetectorElement.h>
#include <ActsGeoUtils/TransformCache.h>
#include <GeoModelUtilities/TransientConstSharedPtr.h>
 
namespace Acts{
    class Surface;
    class LineBounds;
    class PlanarBounds;
}
namespace MuonGMR4 {
 
class SpectrometerSector;
class Chamber;
class MuonReadoutElement : public GeoVDetectorElement, public AthMessaging, public ActsTrk::IDetectorElement {
 
   public:
    struct defineArgs {
        GeoIntrusivePtr<GeoVFullPhysVol> physVol{nullptr};
        const GeoAlignableTransform* alignTransform{nullptr};
        std::string chambDesign{""};
        Identifier detElId{0};        
    };
    
 
    MuonReadoutElement(const defineArgs& args);
    virtual ~MuonReadoutElement();
    
    MuonReadoutElement()=delete;
    MuonReadoutElement(const MuonReadoutElement&)=delete;
    MuonReadoutElement& operator=(const MuonReadoutElement&)=delete;
    virtual StatusCode initElement() = 0;
    const GeoAlignableTransform* alignableTransform() const;
    Identifier identify() const override final;
 
    IdentifierHash identHash() const;
    int stationName() const;
    int stationEta() const;
    int stationPhi() const;
    Muon::MuonStationIndex::ChIndex chamberIndex() const;
 
    virtual IdentifierHash measurementHash(const Identifier& measId) const = 0;
 
    virtual IdentifierHash layerHash(const Identifier& measId) const = 0;
    virtual Identifier measurementId(const IdentifierHash& measHash) const = 0;
 
 
    const std::string& chamberDesign() const;
 
    const Muon::IMuonIdHelperSvc* idHelperSvc() const;
 
    Amg::Vector3D center(const ActsGeometryContext& ctx) const;
    Amg::Vector3D center(const ActsGeometryContext& ctx,
                         const Identifier& id) const;
    Amg::Vector3D center(const ActsGeometryContext& ctx,
                         const IdentifierHash& hash) const;
 
    Amg::Transform3D globalToLocalTrans(const ActsGeometryContext& ctx) const;
    Amg::Transform3D globalToLocalTrans(const ActsGeometryContext& ctx,
                                        const Identifier& id) const;
    Amg::Transform3D globalToLocalTrans(const ActsGeometryContext& ctx, 
                                        const IdentifierHash& hash) const;
 
    const Amg::Transform3D& localToGlobalTrans(const ActsGeometryContext& ctx) const;
    const Amg::Transform3D& localToGlobalTrans(const ActsGeometryContext& ctx,
                                               const Identifier& id) const;
    const Amg::Transform3D& localToGlobalTrans(const ActsGeometryContext& ctx,
                                               const IdentifierHash& id) const;
 
#ifndef SIMULATIONBASE
    const Amg::Transform3D& transform(const Acts::GeometryContext& gctx) const override final;
    const Acts::Surface& surface() const override final;
    Acts::Surface& surface() override final;
 
    const Acts::Surface& surface(const IdentifierHash& hash) const;
    Acts::Surface& surface(const IdentifierHash& hash);
 
    std::shared_ptr<Acts::Surface> surfacePtr(const IdentifierHash& hash) const;
 
    void setChamberLink(const Chamber* chamber);
    void setSectorLink(const SpectrometerSector* envelope);
    const SpectrometerSector* msSector() const;
    const Chamber* chamber() const;
    std::vector<std::shared_ptr<Acts::Surface>> getSurfaces() const;
#else
    virtual double thickness() const = 0;
#endif
    void releaseUnAlignedTrfs() const;
 
    unsigned int storeAlignedTransforms(const ActsTrk::DetectorAlignStore& store) const override final;
 
     friend class ActsTrk::TransformCacheDetEle<MuonGMR4::MuonReadoutElement>;
   protected:
     const Amg::Transform3D& toStation(const ActsTrk::DetectorAlignStore* alignStore) const;
      
     template <class MuonDetImpl> StatusCode insertTransform(const IdentifierHash& hash);
 
     StatusCode createGeoTransform();
#ifndef SIMULATIONBASE
     //Creates a MuonSurfaceCache for straw surfaces using the given Bounds and Identifier Hash
     StatusCode strawSurfaceFactory(const IdentifierHash& hash, std::shared_ptr<Acts::LineBounds> lBounds);
 
     //Creates a MuonSurfaceCache for plane surface using the given Bounds and Identifier Hash
     StatusCode planeSurfaceFactory(const IdentifierHash& hash, std::shared_ptr<Acts::PlanarBounds> pBounds);
#endif     
     static IdentifierHash geoTransformHash();
   private:
    ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{"Muon::MuonIdHelperSvc/MuonIdHelperSvc", "MuonReadoutElement"};
 
    const defineArgs m_args{};
    IdentifierHash m_detElHash{};
    Muon::MuonStationIndex::ChIndex m_chIdx{Muon::MuonStationIndex::ChIndex::ChUnknown};
    int m_stName{-1};
    int m_stEta{-1};
    int m_stPhi{-1};
    using TransformCacheMap = std::unordered_map<IdentifierHash, std::unique_ptr<ActsTrk::TransformCache>>;
    TransformCacheMap m_localToGlobalCaches;
#ifndef SIMULATIONBASE
    ActsTrk::SurfaceCacheSet m_surfaces;
    const SpectrometerSector* m_msSectorLink{};
    const Chamber* m_chambLink{nullptr};
#endif
};
}  // namespace MuonGMR4
 
namespace ActsTrk{
    template <> Amg::Transform3D 
        TransformCacheDetEle<MuonGMR4::MuonReadoutElement>::fetchTransform(const DetectorAlignStore* store) const;
}
 
#include <MuonReadoutGeometryR4/MuonReadoutElement.icc>
#endif