MmReadoutElement.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONREADOUTGEOMETRYR4_MMREADOUTELEMENT_ICC
#define MUONREADOUTGEOMETRYR4_MMREADOUTELEMENT_ICC
 
namespace ActsTrk{
    template <>  inline Amg::Transform3D 
        TransformCacheDetEle<MuonGMR4::MmReadoutElement>::fetchTransform(const DetectorAlignStore* store) const {
            return m_parent->toStation(store) * m_parent->fromGapToChamOrigin(hash());
        }
    template <> inline Identifier
        TransformCacheDetEle<MuonGMR4::MmReadoutElement>::identify() const {
            using RE = MuonGMR4::MmReadoutElement;
            return m_parent->measurementId(RE::createHash(RE::gasGapNumber(hash()), 1));
        }
 
}
namespace MuonGMR4 {
 
inline double MmReadoutElement::thickness() const { return 2.* m_pars.halfThickness; }
inline int MmReadoutElement::multilayer() const{ return m_multilayer; }
inline double MmReadoutElement::moduleHeight() const { return 2.*m_pars.halfHeight; }
inline double MmReadoutElement::moduleWidthS() const { return 2.*m_pars.halfShortWidth; }
inline double MmReadoutElement::moduleWidthL() const { return 2.*m_pars.halfLongWidth; }
inline double MmReadoutElement::moduleThickness() const { return 2.*m_pars.halfThickness; }
inline double MmReadoutElement::gapLengthS(const IdentifierHash& hash) const { return 2.*stripLayer(hash).design().shortHalfHeight(); }
inline double MmReadoutElement::gapLengthL(const IdentifierHash& hash) const { return 2.*stripLayer(hash).design().longHalfHeight();}
inline double MmReadoutElement::gapHeight(const IdentifierHash& hash) const { return 2.*stripLayer(hash).design().halfWidth();}
inline int MmReadoutElement::readoutSide(const IdentifierHash& measHash) const {
    return m_pars.readoutSide[static_cast<unsigned>(layerHash(measHash))];
}
inline unsigned int MmReadoutElement::nGasGaps() const { return m_pars.layers.size(); }
inline unsigned int MmReadoutElement::numStrips(const IdentifierHash& hash) const { 
    return stripLayer(hash).design().numStrips();
  }
inline unsigned int MmReadoutElement::firstStrip(const IdentifierHash& hash) const { 
    return stripLayer(hash).design().firstStripNumber();
  }
inline double MmReadoutElement::stripLength(const IdentifierHash& hash) const { 
    return stripLayer(hash).design().stripLength(stripNumber(hash));
}
 
 
inline IdentifierHash MmReadoutElement::createHash(const int gasGap, const int strip) {
    /*gasGap can be 1 to 4. So we make sure it contributes to the lower 4 bits. (Bit shifting begins from left to right).
      Then we shift the bit position to the left by 4 positions and allocate the strip binary expression.
      (gasGap-1) --> is the binary representation of the gasGap.
      strip --> is the binary representation of the strip.
    */
    IdentifierHash hash = strip  << 4 | (gasGap - 1);
    return hash;
}
 
inline IdentifierHash MmReadoutElement::measurementHash(const Identifier& measId) const {
    if (m_idHelper.elementID(measId) != m_idHelper.elementID(identify()) ) {
        ATH_MSG_WARNING("The measurement " << idHelperSvc()->toString(measId)
                        << " picks the wrong readout element " << idHelperSvc()->toStringDetEl(identify()));
    }
    return createHash(m_idHelper.gasGap(measId), m_idHelper.channel(measId));
}
 
inline IdentifierHash MmReadoutElement::layerHash(const Identifier& measId) const {
    if (m_idHelper.elementID(measId) != m_idHelper.elementID(identify()) ) {
        ATH_MSG_WARNING("The measurement " << idHelperSvc()->toString(measId)
                        << " picks the wrong readout element " << idHelperSvc()->toStringDetEl(identify()));
    }
    return createHash(m_idHelper.gasGap(measId), 0);
}
 
inline IdentifierHash MmReadoutElement::layerHash(const IdentifierHash& measHash) const {
    //measHash & 0xF will extract the gasGap number from 0 to 3, which is what you need based on
    // the fact that you createHash through :
    //IdentifierHash hash = (gasGap - 1) | strip << 4;
    return IdentifierHash{static_cast<unsigned int>((measHash & 0xF))};
}
 
 
inline Identifier MmReadoutElement::measurementId(const IdentifierHash& measHash) const {
    return m_idHelper.channelID(identify(),multilayer(), gasGapNumber(measHash), stripNumber(measHash));  
}
 
// Extract the gas gap number from the lower 4 bits of the hash
inline unsigned int MmReadoutElement::gasGapNumber(const IdentifierHash& measHash) {
    return (measHash & 0xF) + 1;
}
 
// Extract the strip number from the remaining bits after removing the gas gap bits
inline unsigned int MmReadoutElement::stripNumber(const IdentifierHash& measHash) {
    // Right shift by 4 to get rid of the lower 4 bits (gas gap bits).
    return (measHash >> 4);
}
 
inline const StripLayer& MmReadoutElement::stripLayer(const IdentifierHash& measHash) const {
    return *m_pars.layers.at(static_cast<unsigned int>(layerHash(measHash)));
}
 
inline const StripLayer& MmReadoutElement::stripLayer(const Identifier& measId) const {
   return stripLayer(measurementHash(measId));
}
 
 
 
inline Amg::Vector3D MmReadoutElement::stripPosition(const ActsTrk::GeometryContext& ctx, const Identifier& measId) const {
    return stripPosition(ctx, measurementHash(measId));
} 
 
inline Amg::Vector3D MmReadoutElement::leftStripEdge(const ActsTrk::GeometryContext& ctx, const Identifier& measId) const{
    return leftStripEdge(ctx, measurementHash(measId));
}
 
inline Amg::Vector3D MmReadoutElement::rightStripEdge(const ActsTrk::GeometryContext& ctx, const Identifier& measId) const{
    return rightStripEdge(ctx, measurementHash(measId));
}
 
 
}  // namespace MuonGMR4
#endif