LArCalorimeter/LArCalibUtils/LArCalibUtils/LArOFPhaseFill.h

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef LARCALIBUTILS_LArOFPhaseFill_H
@@ -16,10 +16,8 @@ Use a Tshaper raw conditions - reusing existing class instead of writing new
 ********************************************************************/
 
 #include "AthenaBaseComps/AthAlgorithm.h" 
-#include "LArIdentifier/LArOnlineID_Base.h"
-#include "LArRawConditions/LArOFCBinComplete.h"
-#include "AthenaKernel/IOVSvcDefs.h"
 
+class LArOnlineID_Base;
 
 class LArOFPhaseFill : public AthAlgorithm
 {

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArRampFCalCorr.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 //***************************************************************************
@@ -18,9 +18,9 @@
 #include "AthenaBaseComps/AthAlgorithm.h"
 
 #include "LArRawConditions/LArRampComplete.h"
-#include "LArIdentifier/LArOnlineID.h"
 
 #include "CxxUtils/checker_macros.h"
+class LArOnlineID;
 
 class ATLAS_NOT_THREAD_SAFE LArRampFCalCorr : public AthAlgorithm
 {
@@ -39,9 +39,9 @@ class ATLAS_NOT_THREAD_SAFE LArRampFCalCorr : public AthAlgorithm
 
   static int toMod(int& slot);
 
-  const LArOnlineID* m_onlineHelper;
+  const LArOnlineID* m_onlineHelper{};
 
-  float m_threshold;
+  float m_threshold{};
 };
 
 #endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArStripsCrossTalkCorrector.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 //Dear emacs, this is -*-c++-*-
@@ -11,8 +11,6 @@
 #include "StoreGate/ReadCondHandleKey.h"
 #include "LArRecConditions/LArBadChannelCont.h"
 #include "LArCabling/LArOnOffIdMapping.h"
-#include "CaloIdentifier/LArEM_ID.h"
-#include "LArIdentifier/LArOnlineID.h"
 #include "LArElecCalib/ILArPedestal.h"
 #include "LArRawEvent/LArAccumulatedCalibDigit.h"
 #include "LArRecConditions/LArBadChannelMask.h"
@@ -21,6 +19,11 @@
 #include <vector>
 #include <string>
 #include <bitset>
+#include <array>
+
+class LArEM_ID;
+class LArOnlineID;
+class LArAccumulatedCalibDigit;
 
 //Poor man's histogramming class to monitor difference introduced by xtalk corr
 class XtalkCorrHisto {
@@ -111,10 +114,10 @@ class ATLAS_NOT_THREAD_SAFE LArStripsCrossTalkCorrector : public AthAlgorithm
   std::set<HWIdentifier> m_uncorrectedIds;
 
   struct neighbour_t{
-   int dist;
-   const LArAccumulatedCalibDigit* dig;
-   double ped;
-   double weight;
+   int dist{};
+   const LArAccumulatedCalibDigit* dig{};
+   double ped{};
+   double weight{};
  };
 
 

LArCalorimeter/LArCalibUtils/src/LArConditionsMergerAlg.icc

@@ -24,7 +24,7 @@ StatusCode LArConditionsMergerAlg<T,T1>::execute() {
      ATH_CHECK(out->setGroupingType(m_groupingType,msg()));
      ATH_CHECK(out->initialize());
   
-     for (auto key : m_detStoreKeys){
+     for (const auto & key : m_detStoreKeys){
          //SG::ReadHandle<T1> calContainer(key);
          const T1* t1Container = nullptr;
          StatusCode sc = detStore()->retrieve(t1Container,key);
@@ -47,7 +47,7 @@ StatusCode LArConditionsMergerAlg<T,T1>::execute() {
      ATH_CHECK(out->setGroupingType(m_groupingType,msg()));
      ATH_CHECK(out->initialize());
   
-     for (auto& key : m_readKeys) {
+     for (const auto & key : m_readKeys) {
        SG::ReadCondHandle<T> handle{key};
        const T* obj=*handle;
        bool stat=out->merge(*obj);

LArCalorimeter/LArCalibUtils/src/LArMasterWaveBuilder.cxx

 /*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "LArCalibUtils/LArMasterWaveBuilder.h"
+#include "LArRawConditions/LArWave.h"
+#include "LArRawConditions/LArWaveHelper.h"
+#include "LArRawConditions/LArCaliWave.h"
+#include "LArRawConditions/LArCaliWaveContainer.h"
+
+#include "LArIdentifier/LArOnlineID.h"
+#include "CaloIdentifier/LArEM_ID.h"
 
 #include "GaudiKernel/ToolHandle.h"
-#include "LArRawConditions/LArCaliWaveContainer.h"
 #include "CaloIdentifier/CaloCell_ID.h"
 #include "CaloIdentifier/CaloGain.h"
 
 #include <cstdio>
 #include <fstream>
 #include <iostream>
+#include <memory>
 
 using CaliCellIt = LArCaliWaveContainer::ConstConditionsMapIterator;
 using CaliWaveIt = LArCaliWaveContainer::LArCaliWaves::const_iterator;
 
 inline std::string ChanDacGain(HWIdentifier ch,int DAC,int gain) {
-  char compact[25] ;
+  char compact[25]{} ;
   int ich = ch.get_identifier32().get_compact() ;
   sprintf(compact,"[%10d;%5d,%1d]",ich,DAC,gain) ;
   return std::string(compact) ;
@@ -202,7 +209,7 @@ StatusCode LArMasterWaveBuilder::stop()
   ATH_MSG_INFO ( "Processing LArCaliWaveContainer from StoreGate, key = " << m_keyinput );
 
   // create new LArCaliWaveContainer for master waveforms and dac0 waveforms
-  LArCaliWaveContainer* mwContainer = new LArCaliWaveContainer();
+  auto mwContainer = std::make_unique<LArCaliWaveContainer>();
 
   ATH_CHECK( mwContainer->setGroupingType(m_groupingType,msg()) );
   ATH_CHECK( mwContainer->initialize() );
@@ -459,7 +466,7 @@ StatusCode LArMasterWaveBuilder::stop()
   }  // end loop over gains
 
   // register MW/DAC0 container into detStore
-  ATH_CHECK( detStore()->record(mwContainer,m_keyoutput) );
+  ATH_CHECK( detStore()->record(std::move(mwContainer),m_keyoutput) );
   ATH_MSG_INFO ( "Master waveforms' container recorded into StoreGate, key = " << m_keyoutput );
 
   ATH_MSG_INFO ( "List of DACs rejected" );

LArCalorimeter/LArCalibUtils/src/LArOFCAlg.cxx

@@ -11,6 +11,13 @@
 #include "LArRawConditions/LArOFCComplete.h"
 #include "LArRawConditions/LArOFCBinComplete.h"
 #include "LArRawConditions/LArPhysCaliTdiffComplete.h"
+#include "LArRawConditions/LArCaliWaveContainer.h"
+#include "LArRawConditions/LArPhysWaveContainer.h"
+#include "LArRawConditions/LArOFCComplete.h"
+#include "LArRawConditions/LArOFCBinComplete.h"
+#include "LArRawConditions/LArShapeComplete.h"
+#include "LArRawConditions/LArWaveCumul.h"
+
 #include "CoralBase/Blob.h"
 #include "AthenaPoolUtilities/AthenaAttributeList.h"
 
@@ -20,8 +27,10 @@
 #include "CaloDetDescr/CaloDetDescrElement.h"
 #include "CaloIdentifier/CaloCell_ID.h"
 #include "CaloIdentifier/CaloCell_SuperCell_ID.h"
+#include "CaloIdentifier/CaloGain.h"
 
 #include <cassert>
+#include <tuple> //std::ignore
 
 #include "tbb/parallel_for.h"
 
@@ -239,7 +248,7 @@ StatusCode LArOFCAlg::stop()
       m_calo_dd_man->get_element(id);
     }
 
-    m_onlineID->isFCALchannel(chanData.chid);
+    std::ignore = m_onlineID->isFCALchannel(chanData.chid);
 
 
     if (!m_larPhysWaveBinKey.empty()) {

LArCalorimeter/LArCalibUtils/src/LArOFPhaseFill.cxx

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "LArCalibUtils/LArOFPhaseFill.h"
 #include "CaloIdentifier/CaloGain.h"
 #include "LArIdentifier/LArOnline_SuperCellID.h"
 #include "LArIdentifier/LArOnlineID.h"
+#include "LArIdentifier/LArOnlineID_Base.h"
+#include "LArRawConditions/LArOFCBinComplete.h"
 
 #include "GaudiKernel/ISvcLocator.h"
 #include "GaudiKernel/IToolSvc.h"
+#include "AthenaKernel/IOVSvcDefs.h"
 
 #include <fstream>
 #include <map>
@@ -95,8 +98,6 @@ StatusCode LArOFPhaseFill::stop()
            else{
               if(m_isSC)
                  iss>>std::dec>>b_ec>>p_n>>ft>>sl>>ch>>g>>phase;
-              else   
-                 iss>>std::dec>>b_ec>>p_n>>ft>>sl>>ch>>g>>phase;
               if(!iss.good()) {
                  ATH_MSG_WARNING("Wrong line: "<<line);
                  continue;

LArCalorimeter/LArCalibUtils/src/LArRampFCalCorr.cxx

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 //***************************************************************************
@@ -54,7 +54,7 @@ StatusCode LArRampFCalCorr::stop(){
 
   HWIdentifier chid;
   std::vector<int> badChan;
-  int channel, module;
+  int channel{}, module{};
   int slot = 0;
   double avg[3];
   int numChan[3];

LArCalorimeter/LArCalibUtils/src/LArStripsCrossTalkCorrector.cxx

 /*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "LArCalibUtils/LArStripsCrossTalkCorrector.h"
+#include "CaloIdentifier/LArEM_ID.h"
+#include "LArIdentifier/LArOnlineID.h"
+#include "LArRawEvent/LArAccumulatedCalibDigit.h"
 
 #include "CaloIdentifier/CaloGain.h"
 #include "LArBadChannelTool/LArBadChannelDBTools.h"
@@ -216,7 +219,7 @@ StatusCode LArStripsCrossTalkCorrector::execute()
     //only half the signal of the next-to-next neihbor is summed 
     //A more correct approach would be to check if the 'mirrored' neighbor is pulsed as well and compute this weights on-the-fly
     //const float weight[4]={0.5,1,1,0.5};
-    neighbour_t neighbours[4]; //Keep pointers for the four neightbors
+    neighbour_t neighbours[4]={}; //Keep pointers for the four neightbors
     neighbours[0].dist=-2;
     neighbours[1].dist=-1;
     neighbours[2].dist=1;

MuonSpectrometer/MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MMReadoutElement.h

@@ -154,7 +154,6 @@ namespace MuonGM {
         // MuonChannelDesign m_phiDesign;
         std::array<MuonChannelDesign, 4> m_etaDesign{};
 
-        std::array<int, 4> m_nStrips{};     // #of active strips
         int m_nlayers{0};  // #of gas gaps
 
         const NswPassivationDbData* m_passivData{nullptr};
@@ -289,11 +288,11 @@ namespace MuonGM {
 
     inline int MMReadoutElement::numberOfLayers(bool) const { return m_nlayers; }
 
-    inline int MMReadoutElement::numberOfStrips(const Identifier& layerId) const { return m_nStrips[layerHash(layerId)]; }
+    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 < (int)m_nStrips.size())
-            return m_nStrips[lay];
+        if (lay > -1 && lay < static_cast<int>(m_etaDesign.size()))
+            return m_etaDesign[lay].totalStrips;
         else
             return -1;
     }

MuonSpectrometer/MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonChannelDesign.h

@@ -193,14 +193,13 @@ namespace MuonGM {
 
     //============================================================================
     inline int MuonChannelDesign::channelNumber(const Amg::Vector2D& pos) const {
-        static const Amg::Vector2D x_axis{1.,0.};
            
         int chNum{-1};
         if (type == ChannelType::etaStrip && detType == DetType::MM) {
             // ** MM strips: keeping cases outside the active area, but within the envelope, 
             // to avoid warnings from MuonPRDTest. Those channels are removed from digitization.
             const Amg::Vector2D posInEta = m_rotMat.inverse()*pos;
-            const double xMid = (posInEta - firstPos()*x_axis).dot(m_stereoNormal) / m_stereoNormal.x();
+            const double xMid = (posInEta - firstPos()*Amg::Vector2D::UnitX()).dot(m_stereoNormal) / m_stereoNormal.x();
             const int missedBottom =  numberOfMissingBottomStrips();
 
             // first position is always 1/2 pitch above the center of the first active strip
@@ -356,8 +355,7 @@ namespace MuonGM {
             if (st <= nMissedBottom || st > nMissedBottom + nch) return false;
             
             // firstPos is 1/2 pitch above the center of the first active strip.
-            static const Amg::Vector2D x_axis{1.,0.};
-            pos = (firstPos()  + inputPitch* (st - nMissedBottom - 1.5)) * x_axis;
+            pos = (firstPos()  + inputPitch* (st - nMissedBottom - 1.5)) * Amg::Vector2D::UnitX();
         } else {
 
             /// sTGC and default case for eta strips

MuonSpectrometer/MuonDetDescr/MuonReadoutGeometry/src/MMReadoutElement.cxx

@@ -200,7 +200,6 @@ namespace MuonGM {
                 /// Input width is defined as the distance between two channels
                 design.inputWidth = stripPitch * std::cos(design.stereoAngle());
           
-                m_nStrips[il] = design.totalStrips;
                 if (!design.hasStereoAngle()) {  // eta layers
                     design.nch  = design.totalStrips - design.nMissedBottomEta - design.nMissedTopEta;
                     design.setFirstPos(-0.5 * design.xSize() + stripPitch);
@@ -275,7 +274,6 @@ namespace MuonGM {
             /// Input width is defined as the distance between two channels
             design.inputWidth          = pitch * std::cos(design.stereoAngle());
         
-            m_nStrips[il] =  design.totalStrips;
             if (!design.hasStereoAngle()) {  // eta layers
                 design.nch = design.totalStrips - design.nMissedBottomEta - design.nMissedTopEta;
                 design.setFirstPos(-0.5 * design.xSize() + pitch);
@@ -337,7 +335,7 @@ namespace MuonGM {
         if (gasgap < 1 || gasgap > m_nlayers) return false;
 
         int strip = m_idHelper.channel(id);
-        return strip >= 1 && strip <= m_nStrips[gasgap - 1];
+        return strip >= 1 && strip <= m_etaDesign[gasgap - 1].totalStrips;
     }
 
 

MuonSpectrometer/MuonPhaseII/MuonCnv/MuonGeometryCnv/src/MuonReadoutGeomCnvAlg.cxx

@@ -10,15 +10,25 @@
 #include <GeoModelKernel/GeoFullPhysVol.h>
 
 #include <MuonReadoutGeometryR4/MdtReadoutElement.h>
+#include <MuonReadoutGeometryR4/RpcReadoutElement.h>
+#include <MuonReadoutGeometryR4/TgcReadoutElement.h>
+#include <MuonReadoutGeometryR4/MmReadoutElement.h>
+#include <MuonReadoutGeometryR4/sTgcReadoutElement.h>
+
+
 #include <MuonReadoutGeometryR4/MuonChamber.h>
 
 #include <MuonAlignmentDataR4/MdtAlignmentStore.h>
 #include <MuonAlignmentDataR4/sTgcAlignmentStore.h>
+#include <MuonAlignmentDataR4/MmAlignmentStore.h>
+
 
 #include <MuonReadoutGeometry/MuonStation.h>
 #include <MuonReadoutGeometry/MdtReadoutElement.h>
 #include <MuonReadoutGeometry/RpcReadoutElement.h>
 #include <MuonReadoutGeometry/sTgcReadoutElement.h>
+#include <MuonReadoutGeometry/MMReadoutElement.h>
+
 #include <MuonReadoutGeometry/MuonChannelDesign.h>
 
 #include <AthenaKernel/IOVInfiniteRange.h>
@@ -38,6 +48,7 @@ namespace {
         return  readOutVol->getAbsoluteTransform().inverse() *
                 readOutVol->getParent()->getX();
     }
+    using SubDetAlignment = ActsGeometryContext::AlignmentStorePtr;
 }
 
 MuonReadoutGeomCnvAlg::MuonReadoutGeomCnvAlg(const std::string& name, ISvcLocator* pSvcLocator):
@@ -90,8 +101,10 @@ StatusCode MuonReadoutGeomCnvAlg::execute(const EventContext& ctx) const {
     PVLink world{createGeoWorld()};
     detMgr->addTreeTop(world);
     ATH_CHECK(buildMdt(geoContext, detMgr.get(), world));
-    ATH_CHECK(buildRpc(geoContext, detMgr.get(), world));
     ATH_CHECK(buildSTGC(geoContext, detMgr.get(), world));
+    ATH_CHECK(buildMM(geoContext, detMgr.get(), world));
+
+    ATH_CHECK(buildRpc(geoContext, detMgr.get(), world));
 
     ATH_CHECK(writeHandle.record(std::move(detMgr)));
     return StatusCode::SUCCESS;
@@ -249,10 +262,55 @@ StatusCode MuonReadoutGeomCnvAlg::buildRpc(const ActsGeometryContext& gctx,
     return StatusCode::SUCCESS;
 }
 
+StatusCode MuonReadoutGeomCnvAlg::dumpAndCompare(const ActsGeometryContext& gctx,
+                                                 const MuonGMR4::MmReadoutElement& refEle,
+                                                 const MuonGM::MMReadoutElement& testEle) const {
+    if (!m_checkGeo) {
+        return StatusCode::SUCCESS;
+    }
+    ATH_MSG_VERBOSE("Compare basic readout transforms"<<std::endl
+                <<GeoTrf::toString(testEle.absTransform(),true)<<std::endl
+                <<GeoTrf::toString(refEle.localToGlobalTrans(gctx), true));
+    const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
+    for (unsigned int gasGap = 1; gasGap <= refEle.nGasGaps(); ++ gasGap) {
+        const Identifier gapId = idHelper.channelID(refEle.identify(), refEle.multilayer(),  gasGap, 1);
+        
+        const Amg::Transform3D& refTrf{refEle.localToGlobalTrans(gctx, gapId)};
+        const Amg::Transform3D& testTrf{testEle.transform(gapId)};
+        if (!Amg::doesNotDeform(refTrf.inverse()*testTrf)) {
+            ATH_MSG_FATAL("The layer "<<m_idHelperSvc->toStringGasGap(gapId)<<" does not transform equally"
+                         <<GeoTrf::toString(refTrf, true) <<" vs. "<<GeoTrf::toString(testTrf, true));
+            return StatusCode::FAILURE;
+        }
+        const MuonGMR4::StripDesign& stripDesign{refEle.stripLayer(gapId).design()};
+        
+        for (int strip = stripDesign.firstStripNumber(); strip <= stripDesign.numStrips(); ++strip) {
+            const Identifier stripId = idHelper.channelID(refEle.identify(), refEle.multilayer(), gasGap, strip);
+            const Amg::Vector3D refStripPos{refEle.stripPosition(gctx, stripId)};
+            const Amg::Vector3D refStripDir{refEle.localToGlobalTrans(gctx, refEle.layerHash(stripId)).linear() * Amg::Vector3D::UnitX()};
+
+            Amg::Vector3D testStripPos{Amg::Vector3D::Zero()};
+            if (!testEle.stripGlobalPosition(stripId, testStripPos)) {
+                ATH_MSG_FATAL("Failed to retrieve strip position "<<m_idHelperSvc->toString(stripId));
+                return StatusCode::FAILURE;
+            }
+            const double dist = refStripDir.dot(refStripPos - testStripPos);
+            if (std::abs(dist) > 10. * Gaudi::Units::micrometer) {
+                ATH_MSG_FATAL("The strip "<<Amg::toString(testStripPos)<<" is not describing the same strip as "
+                            <<Amg::toString(refStripPos)<<". Channel "<<m_idHelperSvc->toString(stripId)
+                            <<" distance: "<<dist<<" "<<(dist / testEle.m_etaDesign[gasGap -1].inputWidth));
+                return StatusCode::FAILURE;
+            }
+            ATH_MSG_VERBOSE("Channel postion "<<m_idHelperSvc->toString(stripId)<<" match between legacy & new");
+        }
+    }
+    return StatusCode::SUCCESS;
+}
+
 StatusCode MuonReadoutGeomCnvAlg::dumpAndCompare(const ActsGeometryContext& gctx,
                                                  const MuonGMR4::RpcReadoutElement& refEle,
                                                  const MuonGM::RpcReadoutElement& testEle) const {
-    if (!msgLvl(MSG::VERBOSE)) {
+    if (!m_checkGeo) {
         return StatusCode::SUCCESS;
     }
     ATH_MSG_VERBOSE("Compare basic readout transforms"<<std::endl
@@ -292,10 +350,70 @@ StatusCode MuonReadoutGeomCnvAlg::dumpAndCompare(const ActsGeometryContext& gctx
     }
     return StatusCode::SUCCESS;
 }
+
+StatusCode MuonReadoutGeomCnvAlg::buildMM(const ActsGeometryContext& gctx,
+                                          MuonGM::MuonDetectorManager* mgr,
+                                          PVLink world) const {
+
+    SubDetAlignment alignItr = gctx.getStore(ActsTrk::DetectorType::Mm);
+    const auto alignStore = alignItr ?
+                            static_cast<const MmAlignmentStore*>(alignItr->internalAlignment.get()) : nullptr;
+
+    const std::vector<const MuonGMR4::MmReadoutElement*> mmReadouts{m_detMgr->getAllMmReadoutElements()};
+    for (const MuonGMR4::MmReadoutElement* copyMe : mmReadouts) {
+        const Identifier reId = copyMe->identify();
+        GeoIntrusivePtr<const GeoVFullPhysVol> readOutVol{copyMe->getMaterialGeom()};
+        PVLink clonedVol{cloneVolume(const_pointer_cast<GeoVFullPhysVol>(readOutVol))};
+        GeoIntrusivePtr<GeoFullPhysVol> physVol{dynamic_pointer_cast<GeoFullPhysVol>(clonedVol)};
+        world->add(make_intrusive<GeoTransform>(copyMe->localToGlobalTrans(gctx)));
+        world->add(physVol);
+
+        auto newRE = std::make_unique<MuonGM::MMReadoutElement>(physVol, 
+                                                                m_idHelperSvc->stationNameString(reId),
+                                                                copyMe->stationEta(),
+                                                                copyMe->stationPhi(),
+                                                                copyMe->multilayer(), mgr,
+                                                                alignStore ? alignStore->passivation : nullptr);
+        /// Loop over the gas gaps & efine the 
+        for (unsigned int gasGap = 0; gasGap < copyMe->nGasGaps(); ++gasGap) {
+            const MuonGMR4::StripLayer& stripLayer{copyMe->stripLayer(copyMe->createHash(0, gasGap +1))};
+            const MuonGMR4::StripDesign& designFrom{stripLayer.design()};
+            
+            newRE->m_Xlg[gasGap] = stripLayer.toOrigin() * 
+                                   Amg::getRotateZ3D(-designFrom.stereoAngle()) * 
+                                   Amg::getRotateY3D(90. * Gaudi::Units::deg);
+            ATH_MSG_VERBOSE("Layer transform "<<gasGap<<" "<<GeoTrf::toString(newRE->m_Xlg[gasGap], true));
+            
+            MuonGM::MuonChannelDesign& designTo{newRE->m_etaDesign[gasGap]};
+            designTo.defineTrapezoid(designFrom.shortHalfHeight(),
+                                     designFrom.longHalfHeight(),
+                                     designFrom.halfWidth(), 
+                                     designFrom.stereoAngle());
+            designTo.type = MuonGM::MuonChannelDesign::ChannelType::etaStrip;
+            designTo.detType = MuonGM::MuonChannelDesign::DetType::MM;
+            designTo.inputPitch = designFrom.stripPitch();
+            designTo.inputWidth = designTo.inputPitch * std::cos(designTo.stereoAngle());
+            designTo.nMissedBottomEta  = designTo.nMissedBottomStereo = designFrom.firstStripNumber() - 1;
+            designTo.totalStrips = designFrom.numStrips();
+            designTo.nch = designFrom.numStrips();
+            
+            designTo.setFirstPos(designFrom.firstStripPos().x() + 0.5*designTo.inputPitch);
+        }
+
+        newRE->fillCache();
+        if (alignStore && alignStore->getBLine(reId)) {
+            newRE->setBLinePar(*alignStore->getBLine(reId));
+        }
+        ATH_CHECK(dumpAndCompare(gctx, *copyMe, *newRE));
+        mgr->addMMReadoutElement(std::move(newRE));
+
+    }
+    return StatusCode::SUCCESS;
+}
+
 StatusCode  MuonReadoutGeomCnvAlg::buildSTGC(const ActsGeometryContext& gctx,
                                              MuonGM::MuonDetectorManager* mgr,
                                              PVLink world) const{
-    using SubDetAlignment = ActsGeometryContext::AlignmentStorePtr;
     SubDetAlignment alignItr = gctx.getStore(ActsTrk::DetectorType::sTgc);
     auto alignStore = alignItr ? static_cast<const sTgcAlignmentStore*>(alignItr->internalAlignment.get()) : nullptr;
 
@@ -309,7 +427,7 @@ StatusCode  MuonReadoutGeomCnvAlg::buildSTGC(const ActsGeometryContext& gctx,
         world->add(physVol);
 
         auto newRE = std::make_unique<MuonGM::sTgcReadoutElement>(physVol, 
-                                                                  m_idHelperSvc->stationNameString(reId),
+                                                                  m_idHelperSvc->stationNameString(reId).substr(1),
                                                                   copyMe->stationEta(),
                                                                   copyMe->stationPhi(),
                                                                   copyMe->multilayer(), mgr);
@@ -342,7 +460,7 @@ StatusCode  MuonReadoutGeomCnvAlg::buildSTGC(const ActsGeometryContext& gctx,
             etaDesign.inputPitch  = copyEtaDesign.stripPitch();
             etaDesign.inputWidth  = copyEtaDesign.stripWidth();
             etaDesign.nch = copyEtaDesign.numStrips();
-            etaDesign.setFirstPos( (*copyEtaDesign.center(1)).x());
+            etaDesign.setFirstPos(copyEtaDesign.firstStripPos().x());
             /// Initialize the phi design
 
             const MuonGMR4::WireGroupDesign& copyPhiDesign{copyMe->wireDesign(layerHash)};
@@ -362,7 +480,7 @@ StatusCode  MuonReadoutGeomCnvAlg::buildSTGC(const ActsGeometryContext& gctx,
               }
               phiDesign.inputPitch  = copyPhiDesign.stripPitch();
               phiDesign.inputWidth  = 0.015;
-              phiDesign.setFirstPos((*copyPhiDesign.center(1)).x()); // Position of 1st wire, accounts for staggering
+              phiDesign.setFirstPos(copyPhiDesign.firstStripPos().x()); // Position of 1st wire, accounts for staggering
             //   phiDesign.firstPitch = firstWireGroup[il];             // Number of Wires in 1st group, group staggering
               //phiDesign.groupWidth  = wireGroupWidth;                // Number of Wires normal group
               phiDesign.nGroups = copyPhiDesign.numStrips();                           // Number of Wire Groups
@@ -380,7 +498,6 @@ StatusCode MuonReadoutGeomCnvAlg::buildMdt(const ActsGeometryContext& gctx,
                                            MuonGM::MuonDetectorManager* mgr,
                                            PVLink world) const {    
     /// Access the B-Line and As-built parameters
-    using SubDetAlignment = ActsGeometryContext::AlignmentStorePtr;
     SubDetAlignment alignItr = gctx.getStore(ActsTrk::DetectorType::Mdt);
     const MdtAlignmentStore* alignStore = alignItr ?
                                  static_cast<const MdtAlignmentStore*>(alignItr->internalAlignment.get()) : nullptr;
@@ -474,7 +591,7 @@ StatusCode MuonReadoutGeomCnvAlg::buildMdt(const ActsGeometryContext& gctx,
 StatusCode MuonReadoutGeomCnvAlg::dumpAndCompare(const ActsGeometryContext& gctx,
                                                  const MuonGMR4::MdtReadoutElement& refEle,
                                                  const MuonGM::MdtReadoutElement& testEle) const {
-    if (!msgLvl(MSG::VERBOSE)) {
+    if (!m_checkGeo) {
         return StatusCode::SUCCESS;
     }
     

MuonSpectrometer/MuonPhaseII/MuonCnv/MuonGeometryCnv/src/MuonReadoutGeomCnvAlg.h

@@ -48,6 +48,11 @@ class MuonReadoutGeomCnvAlg : public AthReentrantAlgorithm {
                              MuonGM::MuonDetectorManager* mgr,
                              PVLink world) const;
 
+        StatusCode buildMM(const ActsGeometryContext& gctx,
+                           MuonGM::MuonDetectorManager* mgr,
+                           PVLink world) const;
+
+
         
         StatusCode dumpAndCompare(const ActsGeometryContext& gctx,
                                   const MuonGMR4::RpcReadoutElement& refEle,
@@ -56,13 +61,19 @@ class MuonReadoutGeomCnvAlg : public AthReentrantAlgorithm {
         StatusCode dumpAndCompare(const ActsGeometryContext& gctx,
                                   const MuonGMR4::MdtReadoutElement& refEle,
                                   const MuonGM::MdtReadoutElement& testEle) const;
-                                  
+
+        StatusCode dumpAndCompare(const ActsGeometryContext& gctx,
+                                  const MuonGMR4::MmReadoutElement& refEle,
+                                  const MuonGM::MMReadoutElement& testEle) const;
+        
+
         ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
 
         SG::WriteCondHandleKey<MuonGM::MuonDetectorManager> m_writeKey{this, "WriteKey", "MuonDetectorManager"};
         
         SG::ReadCondHandleKeyArray<ActsTrk::DetectorAlignStore> m_alignStoreKeys{this, "AlignmentKeys", {}, "Alignment key"};
         
+        Gaudi::Property<bool> m_checkGeo{this, "checkGeo", false, "Checks the positions of the sensors"};
         const MuonGMR4::MuonDetectorManager* m_detMgr{nullptr};
 
 

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonGeoModelTestR4/python/testGeoModel.py

@@ -172,21 +172,28 @@ if __name__=="__main__":
     cfg.merge(setupHistSvcCfg(flags, out_file = args.outRootFile))
     chambToTest =  args.chambers if len([x for x in args.chambers if x =="all"]) ==0 else []
     
+    cfg.getCondAlgo("MuonDetectorManagerCondAlg").checkGeo = False
+    
     if flags.Detector.GeometryMDT:
         cfg.merge(GeoModelMdtTestCfg(flags, 
                                      TestStations = [ch for ch in chambToTest if ch[0] == "B" or ch[0] == "E"],
-                                     ReadoutSideXML="ReadoutSides.xml"))
+                                     ReadoutSideXML="ReadoutSides.xml",
+                                     ExtraInputs=[( 'MuonGM::MuonDetectorManager' , 'ConditionStore+MuonDetectorManager' )]))
 
     if flags.Detector.GeometryRPC: 
-        cfg.merge(GeoModelRpcTestCfg(flags, TestStations = [ch for ch in chambToTest if ch[0] == "B"]))
+        cfg.merge(GeoModelRpcTestCfg(flags, TestStations = [ch for ch in chambToTest if ch[0] == "B"],
+                                             ExtraInputs=[( 'MuonGM::MuonDetectorManager' , 'ConditionStore+MuonDetectorManager' )]))
 
     if flags.Detector.GeometryTGC: 
-        cfg.merge(GeoModelTgcTestCfg(flags, TestStations = [ch for ch in chambToTest if ch[0] == "T"]))
+        cfg.merge(GeoModelTgcTestCfg(flags, TestStations = [ch for ch in chambToTest if ch[0] == "T"],
+                                            ExtraInputs=[( 'MuonGM::MuonDetectorManager' , 'ConditionStore+MuonDetectorManager' )]))
 
     if flags.Detector.GeometryMM: 
-        cfg.merge(GeoModelMmTestCfg(flags, TestStations = [ch for ch in chambToTest if ch[0] == "M"]))
+        cfg.merge(GeoModelMmTestCfg(flags, TestStations = [ch for ch in chambToTest if ch[0] == "M"],
+                                           ExtraInputs=[( 'MuonGM::MuonDetectorManager' , 'ConditionStore+MuonDetectorManager' )]))
     
     if flags.Detector.GeometrysTGC: 
-        cfg.merge(GeoModelsTgcTestCfg(flags, TestStations = [ch for ch in chambToTest if ch[0] == "S"]))
+        cfg.merge(GeoModelsTgcTestCfg(flags, TestStations = [ch for ch in chambToTest if ch[0] == "S"],
+                                             ExtraInputs=[( 'MuonGM::MuonDetectorManager' , 'ConditionStore+MuonDetectorManager' )]))
     
     executeTest(cfg, num_events = args.nEvents)

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/StripDesign.h

@@ -140,6 +140,8 @@ namespace MuonGMR4 {
             const Amg::Vector2D& stripNormal() const;
             /// Vector pointing along the strip
             const Amg::Vector2D& stripDir() const;
+            /// Vector indicating the first strip position
+            const Amg::Vector2D& firstStripPos() const;
         private:
             void setStereoAngle(double stereo);
             /// Resets the cache of the directions

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/StripDesign.icc

@@ -20,7 +20,7 @@ namespace MuonGMR4 {
     inline const Amg::Vector2D& StripDesign::cornerTopRight() const { return m_topRight; }
     inline const Amg::Vector2D& StripDesign::stripNormal() const { return m_stripNormal; }
     inline const Amg::Vector2D& StripDesign::stripDir() const { return m_stripDir; }
-
+    inline const Amg::Vector2D& StripDesign::firstStripPos() const { return m_firstStripPos; }
 
     SET_DIRECTION(edgeDirTop, m_dirTopEdge, m_topLeft, m_topRight)
     SET_DIRECTION(edgeDirBottom, m_dirBotEdge, m_bottomLeft, m_bottomRight)

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/WireGroupDesign.icc

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 #ifndef MUONREADOUTGEOMETRYR4_WIREGROUPDESIGN_ICC
 #define MUONREADOUTGEOMETRYR4_WIREGROUPDESIGN_ICC
@@ -15,7 +15,7 @@ namespace MuonGMR4 {
             return Amg::Vector2D::Zero();
         }
         const wireGroup& wireGrp = m_groups[groupNum];
-        return StripDesign::stripPosition(0) + 
+        return firstStripPos() + 
                (wireGrp.accumlWires + wireGrp.numWires/2)*stripPitch() * stripNormal();
     }
     inline CheckVector2D WireGroupDesign::wirePosition(unsigned int groupNum, 
@@ -33,7 +33,7 @@ namespace MuonGMR4 {
                         " [1-"<<wireGrp.numWires<<"] wires.");
             return std::nullopt;
         }
-        return std::make_optional<Amg::Vector2D>(StripDesign::stripPosition(0) +  
+        return std::make_optional<Amg::Vector2D>(firstStripPos() +  
                                                  (wireGrp.accumlWires + (wireNum - 1))*stripPitch() * stripNormal());
     }
     inline CheckVector2D WireGroupDesign::leftWireEdge(unsigned int groupNum,
@@ -61,7 +61,7 @@ namespace MuonGMR4 {
     }
 
     inline int WireGroupDesign::stripNumber(const Amg::Vector2D& extPos) const {
-        std::optional<double> wirePitches = Amg::intersect<2>(StripDesign::stripPosition(0), stripDir(),
+        std::optional<double> wirePitches = Amg::intersect<2>(firstStripPos(), stripDir(),
                                                                extPos, - Amg::Vector2D::UnitX());
         if (!wirePitches) {
             return -1;

PhysicsAnalysis/Algorithms/JetAnalysisAlgorithms/python/JetAnalysisConfig.py

@@ -127,6 +127,10 @@ class SmallRJetAnalysisConfig (ConfigBlock) :
             info="whether to run JVT selection. The default is True.")
         self.addOption ('runFJvtSelection', False, type=bool,
             info="whether to run forward JVT selection. The default is False.")
+        self.addOption ('jvtWP', "FixedEffPt", type=str,
+            info="which Jvt WP to apply. The default is FixedEffPt.")
+        self.addOption ('fJvtWP', "Loose", type=str,
+            info="which fJvt WP to apply. The default is Loose.")
         self.addOption ('runJvtEfficiency', True, type=bool,
             info="whether to calculate the JVT efficiency. The default is True.")
         self.addOption ('runFJvtEfficiency', False, type=bool,
@@ -266,6 +270,14 @@ class SmallRJetAnalysisConfig (ConfigBlock) :
             raise ValueError(
                 "Unsupported input type '{0}' for R=0.4 jets!".format(self.jetInput) )
 
+        if self.jvtWP not in ["FixedEffPt"]:
+            raise ValueError(
+                "Unsupported NNJvt WP '{0}'".format(self.jvtWP) )
+
+        if self.fJvtWP not in ["Loose", "Tight", "Tighter"]:
+            raise ValueError(
+                "Unsupported fJvt WP '{0}'".format(self.fJvtWP) )
+
         if not config.isPhyslite() or self.recalibratePhyslite:
             # Prepare the jet calibration algorithm
             alg = config.createAlgorithm( 'CP::JetCalibrationAlg', 'JetCalibrationAlg'+postfix )
@@ -343,11 +355,12 @@ class SmallRJetAnalysisConfig (ConfigBlock) :
         # Set up the jet efficiency scale factor calculation algorithm
         # Change the truthJetCollection property to AntiKt4TruthWZJets if preferred
         if self.runJvtSelection :
+            assert self.jetInput=="EMPFlow", "NNJvt WPs and SFs only valid for PFlow jets"
             alg = config.createAlgorithm('CP::AsgSelectionAlg', f'JvtSelectionAlg{postfix}')
             config.addPrivateTool('selectionTool', 'CP::NNJvtSelectionTool')
             alg.selectionTool.JetContainer = config.readName(self.containerName)
-            alg.selectionTool.WorkingPoint = "FixedEffPt"
-            alg.selectionTool.MaxPtForJvt = 60e3 if self.jetInput == "EMPFlow" else 120e3
+            alg.selectionTool.WorkingPoint = self.jvtWP
+            alg.selectionTool.MaxPtForJvt = 60e3
             alg.selectionDecoration = "jvt_selection,as_char"
             alg.particles = config.readName(self.containerName)
 
@@ -355,8 +368,12 @@ class SmallRJetAnalysisConfig (ConfigBlock) :
                 alg = config.createAlgorithm( 'CP::JvtEfficiencyAlg', 'JvtEfficiencyAlg'+postfix )
                 config.addPrivateTool( 'efficiencyTool', 'CP::NNJvtEfficiencyTool' )
                 alg.efficiencyTool.JetContainer = config.readName(self.containerName)
-                alg.efficiencyTool.MaxPtForJvt = 60e3 if self.jetInput == "EMPFlow" else 120e3
-                alg.efficiencyTool.WorkingPoint = 'FixedEffPt'
+                alg.efficiencyTool.MaxPtForJvt = 60e3
+                alg.efficiencyTool.WorkingPoint = self.jvtWP
+                if config.geometry() is LHCPeriod.Run2:
+                    alg.efficiencyTool.SFFile = "JetJvtEfficiency/May2024/NNJvtSFFile_Run2_EMPFlow.root"
+                else:
+                    alg.efficiencyTool.SFFile = "JetJvtEfficiency/May2024/NNJvtSFFile_Run3_EMPFlow.root"
                 alg.selection = 'jvt_selection,as_char'
                 alg.scaleFactorDecoration = 'jvt_effSF_%SYS%'
                 alg.outOfValidity = 2
@@ -368,20 +385,23 @@ class SmallRJetAnalysisConfig (ConfigBlock) :
             config.addSelection (self.containerName, 'baselineJvt', 'jvt_selection,as_char', preselection=False)
 
         if self.runFJvtSelection :
+            assert self.jetInput=="EMPFlow", "fJvt WPs and SFs only valid for PFlow jets"
             alg = config.createAlgorithm('CP::AsgSelectionAlg', f'FJvtSelectionAlg{postfix}')
             config.addPrivateTool('selectionTool', 'CP::FJvtSelectionTool')
             alg.selectionTool.JetContainer = config.readName(self.containerName)
-            alg.selectionTool.WorkingPoint = "Loose"
+            alg.selectionTool.WorkingPoint = self.fJvtWP
             alg.selectionDecoration = "fjvt_selection,as_char"
             alg.particles = config.readName(self.containerName)
-            alg = config.createAlgorithm( 'CP::JvtEfficiencyAlg', 'ForwardJvtEfficiencyAlg' )
-            config.addSelection (self.containerName, 'baselineFJvt', 'fjvt_selection,as_char', preselection=False)
 
             if self.runFJvtEfficiency and config.dataType() is not DataType.Data:
                 alg = config.createAlgorithm( 'CP::JvtEfficiencyAlg', 'FJvtEfficiencyAlg'+postfix )
                 config.addPrivateTool( 'efficiencyTool', 'CP::FJvtEfficiencyTool' )
                 alg.efficiencyTool.JetContainer = config.readName(self.containerName)
-                alg.efficiencyTool.WorkingPoint = 'Loose'
+                alg.efficiencyTool.WorkingPoint = self.fJvtWP
+                if config.geometry() is LHCPeriod.Run2:
+                    alg.efficiencyTool.SFFile = "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root"
+                else:
+                    alg.efficiencyTool.SFFile = "JetJvtEfficiency/May2024/fvtSFFile_Run3_EMPFlow.root"
                 alg.selection = 'fjvt_selection,as_char'
                 alg.scaleFactorDecoration = 'fjvt_effSF_%SYS%'
                 alg.outOfValidity = 2
@@ -389,7 +409,8 @@ class SmallRJetAnalysisConfig (ConfigBlock) :
                 alg.skipBadEfficiency = False
                 alg.jets = config.readName (self.containerName)
                 alg.preselection = config.getPreselection (self.containerName, '')
-                config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'jvtEfficiency')
+                config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'fjvtEfficiency')
+            config.addSelection (self.containerName, 'baselineFJvt', 'fjvt_selection,as_char', preselection=False)
 
 
 
@@ -669,6 +690,7 @@ def makeSmallRJetAnalysisConfig( seq, containerName, jetCollection,
                                  jetInput, postfix = None,
                                  runJvtUpdate = None, runNNJvtUpdate = None, runFJvtUpdate = None,
                                  runJvtSelection = None, runFJvtSelection = None,
+                                 jvtWP = None, fJvtWP = None,
                                  runJvtEfficiency = None, runFJvtEfficiency = None,
                                  systematicsModelJES = None, systematicsModelJER = None):
     """Add algorithms for the R=0.4 jets.
@@ -683,6 +705,8 @@ def makeSmallRJetAnalysisConfig( seq, containerName, jetCollection,
         runFJvtUpdate -- Determines whether or not to update forward JVT on the jets
         runJvtSelection -- Determines whether or not to run JVT selection on the jets
         runFJvtSelection -- Determines whether or not to run forward JVT selection on the jets
+        jvtWP -- Defines the NNJvt WP to apply on the jets
+        fJvtWP -- Defines the fJvt WP to apply on the jets
         runJvtEfficiency -- Determines whether or not to calculate the JVT efficiency
         runFJvtEfficiency -- Determines whether or not to calculate the forward JVT efficiency
         systematicsModelJES -- Which NP systematicsModelJES scheme should be used (All, Global, Category, Scenario)
@@ -693,7 +717,6 @@ def makeSmallRJetAnalysisConfig( seq, containerName, jetCollection,
         raise ValueError(
             "Unsupported input type '{0}' for R=0.4 jets!".format(jetInput) )
 
-
     config = SmallRJetAnalysisConfig (containerName, jetCollection, jetInput)
     config.setOptionValue ('postfix', postfix)
     config.setOptionValue ('runJvtUpdate', runJvtUpdate)
@@ -701,6 +724,8 @@ def makeSmallRJetAnalysisConfig( seq, containerName, jetCollection,
     config.setOptionValue ('runFJvtUpdate', runFJvtUpdate)
     config.setOptionValue ('runJvtSelection', runJvtSelection)
     config.setOptionValue ('runFJvtSelection', runFJvtSelection)
+    config.setOptionValue ('jvtWP', jvtWP)
+    config.setOptionValue ('fJvtWP', fJvtWP)
     config.setOptionValue ('runJvtEfficiency', runJvtEfficiency)
     config.setOptionValue ('runFJvtEfficiency', runFJvtEfficiency)
     config.setOptionValue ('systematicsModelJES', systematicsModelJES)

PhysicsAnalysis/AnalysisCommon/ParticleJetTools/ParticleJetTools/JetTruthLabelingTool.h

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef PARTICLEJETTOOLS_JETTRUTHLABELINGTOOL_H
@@ -39,7 +39,7 @@ public:
   void print() const override;
   
   /// returns the name of large-R jet truth label
-  std::string getLargeRJetTruthLabelName() const {
+  const std::string& getLargeRJetTruthLabelName() const {
     return m_truthLabelName;
   };