MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MdtReadoutElement.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONREADOUTGEOMETRYR4_MDTREADOUTELEMENT_ICC
#define MUONREADOUTGEOMETRYR4_MDTREADOUTELEMENT_ICC
 
#include <GaudiKernel/SystemOfUnits.h>
#include <cassert>
namespace ActsTrk{
    template <> inline Amg::Transform3D 
        TransformCacheDetEle<MuonGMR4::MdtReadoutElement>::fetchTransform(const DetectorAlignStore* store) const {
            using RE = MuonGMR4::MdtReadoutElement;
            const unsigned layerTube = m_parent->tubeNumber(RE::measurementHash(1, 0));
            /// Check whether the hash represents a tube or the central layer
            const unsigned tubeNum = m_parent->tubeNumber(hash());
            if (tubeNum == layerTube) {
                const Amg::Translation3D toCenter{0.5*m_parent->moduleHeight() * Amg::Vector3D::UnitY()};
                return m_parent->toStation(store) * m_parent->toChamberLayer(hash()) *
                        toCenter * Amg::getRotateY3D(90*Gaudi::Units::deg); 
            }
            return m_parent->toStation(store) * 
                   m_parent->fromIdealToDeformed(hash(), store) * m_parent->toTubeFrame(hash());
        }
     template <> inline Identifier
        TransformCacheDetEle<MuonGMR4::MdtReadoutElement>::identify() const {
            using RE = MuonGMR4::MdtReadoutElement;
            const unsigned layerTube = m_parent->tubeNumber(RE::measurementHash(1, 0));
            /// Check whether the hash represents a tube or the central layer
            const unsigned tubeNum = m_parent->tubeNumber(hash());
            if (tubeNum == layerTube) {
                return m_parent->measurementId(RE::measurementHash(RE::layerNumber(hash()) +1,
                                                                    m_parent->numTubesInLay() +1));
            }
            return m_parent->measurementId(hash());
        }
}
 
namespace MuonGMR4 {
inline unsigned MdtReadoutElement::multilayer() const { return m_stML; }
inline unsigned MdtReadoutElement::numLayers() const { return m_pars.tubeLayers.size(); }
inline unsigned MdtReadoutElement::numTubesInLay() const { return m_pars.tubeLayers.empty() ? 0 : m_pars.tubeLayers[0]->nTubes(); }
inline double MdtReadoutElement::innerTubeRadius() const {return m_pars.tubeInnerRad;}
inline double MdtReadoutElement::tubeRadius() const {return innerTubeRadius() + m_pars.tubeWall;}
inline double MdtReadoutElement::tubePitch() const { return m_pars.tubePitch;}
inline double MdtReadoutElement::thickness() const {return 2.* m_pars.halfHeight;}
inline double MdtReadoutElement::moduleWidthS() const{ return 2.*m_pars.shortHalfX; }
inline double MdtReadoutElement::moduleWidthL() const{ return 2.*m_pars.longHalfX; }
inline double MdtReadoutElement::moduleHeight() const{ return 2.*m_pars.halfY; }
inline double MdtReadoutElement::moduleThickness() const{ return 2.*m_pars.halfHeight; }
inline const MdtReadoutElement* MdtReadoutElement::complementaryRE() const { return m_reOtherMl; }
inline bool MdtReadoutElement::isValid(const IdentifierHash& measHash) const {
    return  layerNumber(measHash) < numLayers() && 
            tubeNumber(measHash) < numTubesInLay() && 
            !m_pars.removedTubes.count(measHash);
}
inline IdentifierHash MdtReadoutElement::measurementHash(const Identifier& measId) const {
    if (idHelperSvc()->detElId(measId) != identify()) {
        ATH_MSG_WARNING("The measurement "
                        << idHelperSvc()->toString(measId)
                        << " picks the wrong readout element "
                        << idHelperSvc()->toStringDetEl(identify()));
    }
    IdentifierHash hash = measurementHash(m_idHelper.tubeLayer(measId), 
                                         m_idHelper.tube(measId));
    ATH_MSG_VERBOSE("Translate measurement identifier "
                    << idHelperSvc()->toString(measId)
                    << " to measurement hash " << static_cast<int>(hash));
    return hash;
}
inline IdentifierHash MdtReadoutElement::layerHash(const Identifier& measId) const {
    return layerHash(measurementHash(measId));
}
inline unsigned MdtReadoutElement::tubeNumber(const IdentifierHash& hash) {
    return (static_cast<unsigned>(hash) >> 3) - 1u;
}
/// Transforms the identifier hash into a layer number ranging from
/// (0-numLayers()-1)
inline unsigned MdtReadoutElement::layerNumber(const IdentifierHash& hash) {
    constexpr unsigned layMask = 0b111;
    return static_cast<unsigned>(hash) & layMask;
}
inline IdentifierHash MdtReadoutElement::measurementHash(unsigned layer, unsigned tube) {
    assert(layer<=4);
    return IdentifierHash{( tube << 3) | (layer-1)};
}
inline IdentifierHash MdtReadoutElement::layerHash(const IdentifierHash& measHash) {
    return measurementHash(layerNumber(measHash) + 1 , 0);
}
inline bool MdtReadoutElement::isBarrel() const { return m_isBarrel; }
 
 
inline Amg::Vector3D MdtReadoutElement::globalTubePos(const ActsTrk::GeometryContext& ctx, 
                                                      const Identifier& measId) const {
    return globalTubePos(ctx, measurementHash(measId));
}
inline Amg::Vector3D MdtReadoutElement::readOutPos(const ActsTrk::GeometryContext& ctx,
                                                   const Identifier& measId) const{
    return readOutPos(ctx, measurementHash(measId));
}
inline  Amg::Vector3D MdtReadoutElement::highVoltPos(const ActsTrk::GeometryContext& ctx,
                                                     const Identifier& measId) const {
    return highVoltPos(ctx, measurementHash(measId));
}
inline double MdtReadoutElement::distanceToReadout(const ActsTrk::GeometryContext& ctx,
                                                   const Identifier& measId,
                                                   const Amg::Vector3D& globPoint) const {
    return distanceToReadout(ctx,measurementHash(measId), globPoint);
}
 
   
}  // namespace MuonGMR4
#endif