Event/PyDumper/python/Dumpers.py

@@ -30,6 +30,7 @@ from math import \
 
 from AthenaPython import PyAthena
 from PyUtils.fprint import fprint, fprintln, fwrite
+from PyDumper import PDG
 import ROOT
 import cppyy
 
@@ -2796,7 +2797,7 @@ def _genvertex_particles_out_size(e):
     return e.particles_out().size()
 
 
-def barcodes (beg, end, sz, f):
+def barcodes (beg, end, sz):
     #out = [x.barcode() for x in toiter (beg, end)]
 
     # Work around pyroot iterator comparison breakage.
@@ -2808,9 +2809,25 @@ def barcodes (beg, end, sz, f):
         out.append (x.barcode())
 
     out.sort()
-    for i in out:
-        fprint (f, i)
-    return
+    return out
+def genvertex_in_barcodes(v):
+    if hasattr(v, 'particles_in_const_begin'):
+        parts = barcodes(v.particles_in_const_begin(),
+                         v.particles_in_const_end(),
+                         v.particles_in_size())
+    else:
+        parts = [_gen_barcode(p) for p in v.particles_in()]
+        parts.sort()
+    return parts
+def genvertex_out_barcodes(v):
+    if hasattr(v, 'particles_out_const_begin'):
+        parts = barcodes(v.particles_out_const_begin(),
+                         v.particles_out_const_end(),
+                         v.particles_out_size())
+    else:
+        parts = [_gen_barcode(p) for p in v.particles_out()]
+        parts.sort()
+    return parts
 def dump_GenVertex (v, f):
     fprint (f, "%d %d %d %d %d" %
             (v.status() if hasattr(v,'status') else v.id(),
@@ -2828,42 +2845,38 @@ def dump_GenVertex (v, f):
         ww = list(v.weights())
     fprintln (f, [w for w in ww])
     fprint (f, '     (')
-    if hasattr(v, 'particles_in_const_begin'):
-        barcodes(v.particles_in_const_begin(),
-                 v.particles_in_const_end(),
-                 v.particles_in_size(), f)
-    else:
-        parts = [_gen_barcode(p) for p in v.particles_in()]
-        parts.sort()
-        for bc in parts:
-            fprint (f, bc)
+    for bc in genvertex_in_barcodes(v):
+        fprint (f, bc)
     fprint (f, ')(')
-    if hasattr(v, 'particles_out_const_begin'):
-        barcodes(v.particles_out_const_begin(),
-                 v.particles_out_const_end(),
-                 v.particles_out_size(), f)
-    else:
-        parts = [_gen_barcode(p) for p in v.particles_out()]
-        parts.sort()
-        for bc in parts:
-            fprint (f, bc)
+    for bc in genvertex_out_barcodes(v):
+        fprint (f, bc)
     fprint (f, ')')
 
     return
 
 
 def dump_GenParticle (p, f):
-    fprint (f, "%d %d %d %d" %
+    fprint (f, "%d %5s %d %d" %
             (_gen_barcode(p),
-             p.pdg_id(),
+             PDG.pdgid_to_name(p.pdg_id()),
              p.parent_event().event_number(),
              p.status(),))
     if p.production_vertex():
-        fprint (f, _gen_barcode (p.production_vertex()))
+        s = str(_gen_barcode (p.production_vertex())) + '('
+        parts = genvertex_in_barcodes (p.production_vertex())
+        for bc in parts: s += '%d ' % bc
+        if len(parts) > 3: s += '...'
+        s += '->)'
+        fprint (f, s)
     else:
         fprint (f, None)
     if p.end_vertex():
-        fprint (f, _gen_barcode (p.end_vertex()))
+        s = str (_gen_barcode (p.end_vertex())) + '(->'
+        parts = genvertex_out_barcodes (p.end_vertex())
+        for bc in parts: s += '%d ' % bc
+        if len(parts) > 3: s += '...'
+        s += ')'
+        fprint (f, s)
     else:
         fprint (f, None)
     dump_HLV (p.momentum(), f)

InnerDetector/InDetDetDescr/TRT_GeoModel/src/TRTDetectorFactory_Full.cxx

@@ -663,28 +663,13 @@ void TRTDetectorFactory_Full::create(GeoPhysVol *world)
 
     pCoolingTube->add(pCoolingFluid);
 
-    double activeGasZPositionNormalStraws, activeGasZPositionStrawsWithLargeDeadRegion;
-	//AALONSO, create the Argon Straws
-    GeoNodePtr<GeoPhysVol> pHoleForMixedStrawAR;
-    GeoNodePtr<GeoPhysVol> pHoleForMixedStrawWithLargeDeadRegionAR;
-    if (m_doArgon)
-      {
-      pHoleForMixedStrawAR                    = makeStraw(activeGasZPositionNormalStraws, false, GM_ARGON);
-      pHoleForMixedStrawWithLargeDeadRegionAR = makeStraw(activeGasZPositionStrawsWithLargeDeadRegion,true, GM_ARGON);
-      }
-    // and krypton straws
-    GeoNodePtr<GeoPhysVol> pHoleForMixedStrawKR;
-    GeoNodePtr<GeoPhysVol> pHoleForMixedStrawWithLargeDeadRegionKR;
-    if (m_doKrypton)
-      {
-      pHoleForMixedStrawKR                    = makeStraw(activeGasZPositionNormalStraws, false, GM_KRYPTON);
-      pHoleForMixedStrawWithLargeDeadRegionKR = makeStraw(activeGasZPositionStrawsWithLargeDeadRegion,true, GM_KRYPTON);
-      }
+    double lengthOfInnerDeadRegion= m_data->lengthOfDeadRegion;
+    double lengthOfActiveGas = (m_data->barrelLengthOfStraw-m_data->barrelLengthOfTwister)/2.0 - m_data->lengthOfDeadRegion - lengthOfInnerDeadRegion;
+    double activeGasZPositionNormalStraws = (lengthOfActiveGas + m_data->barrelLengthOfTwister) / 2. + lengthOfInnerDeadRegion;
 
-    // The barrel straw (including the "hole" in the radiator around it):
-    GeoNodePtr<GeoPhysVol> pHoleForMixedStraw = makeStraw(activeGasZPositionNormalStraws);
-    // The straws in the inner layers of module A have a large dead region, and are thus different.
-    GeoNodePtr<GeoPhysVol> pHoleForMixedStrawWithLargeDeadRegion = makeStraw(activeGasZPositionStrawsWithLargeDeadRegion,true);
+    lengthOfInnerDeadRegion = m_data->barrelLengthOfLargeDeadRegion;
+    lengthOfActiveGas = (m_data->barrelLengthOfStraw-m_data->barrelLengthOfTwister)/2.0 - m_data->lengthOfDeadRegion - lengthOfInnerDeadRegion;
+    double activeGasZPositionStrawsWithLargeDeadRegion = (lengthOfActiveGas + m_data->barrelLengthOfTwister) / 2. + lengthOfInnerDeadRegion;
   
     // The modules themselves.
     for (size_t iABC=0;iABC<m_data->nBarrelRings;iABC++) {
@@ -737,37 +722,14 @@ void TRTDetectorFactory_Full::create(GeoPhysVol *world)
       if (!radMat) radMat = m_materialManager->getMaterial("trt::FibreRadiator");
 
       lRad = new GeoLogVol(radName, sRad, radMat);
-      GeoNodePtr<GeoPhysVol> pRad(new GeoPhysVol(lRad));
-      GeoNodePtr<GeoPhysVol> pRadAR(m_doArgon   ? new GeoPhysVol(lRad) : nullptr );
-      GeoNodePtr<GeoPhysVol> pRadKR(m_doKrypton ? new GeoPhysVol(lRad) : nullptr);
 
       //---------------------------------------------------------------------------------------------------------------
       // Place the cooling tubes in the Radiator
-
       GeoTransform  *xCool1 = new GeoTransform(shellPosition.inverse()
 					       *GeoTrf::Translate3D(m_data->barrelXOfCoolingTube[iABC][0],m_data->barrelYOfCoolingTube[iABC][0],0));
       GeoTransform  *xCool2 = new GeoTransform(shellPosition.inverse()
 					       *GeoTrf::Translate3D(m_data->barrelXOfCoolingTube[iABC][1],m_data->barrelYOfCoolingTube[iABC][1],0));
 
-      pRad->add(xCool1);
-      pRad->add(pCoolingTube);
-      pRad->add(xCool2);
-      pRad->add(pCoolingTube);
-      if (m_doArgon)
-        {
-        pRadAR->add(xCool1);
-        pRadAR->add(pCoolingTube);
-        pRadAR->add(xCool2);
-        pRadAR->add(pCoolingTube);
-        }
-      if (m_doKrypton)
-        {
-        pRadKR->add(xCool1);
-        pRadKR->add(pCoolingTube);
-        pRadKR->add(xCool2);
-        pRadKR->add(pCoolingTube);
-        }
-
       //----------------------------------------------------------------------------------------------------------------
       // Parameterize all of the straws and put them within the radiator.
 
@@ -840,46 +802,7 @@ void TRTDetectorFactory_Full::create(GeoPhysVol *world)
       } else {
 	m_detectorManager->setBarrelTransformField(iABC,tx2.clone());
       }
-	//AALONSO
-      GeoSerialTransformer *serialTransformer = nullptr;
-      GeoSerialTransformer *serialTransformerAR = nullptr;  //Ruslan
-      GeoSerialTransformer *serialTransformerKR = nullptr;  //Artem
-
-      serialTransformer     = new GeoSerialTransformer(pHoleForMixedStraw,   &tx2, m_data->barrelNumberOfStrawsInModule[iABC]-nStrawsWithLargeDeadRegion);
-      if (m_doArgon) {
-        serialTransformerAR = new GeoSerialTransformer(pHoleForMixedStrawAR, &tx2, m_data->barrelNumberOfStrawsInModule[iABC]-nStrawsWithLargeDeadRegion);
-      }
-      if (m_doKrypton) {
-        serialTransformerKR = new GeoSerialTransformer(pHoleForMixedStrawKR, &tx2, m_data->barrelNumberOfStrawsInModule[iABC]-nStrawsWithLargeDeadRegion);
-      }
-
-
-      GeoNodePtr<GeoSerialTransformer> serialTransformerDead;
-      GeoNodePtr<GeoSerialTransformer> serialTransformerDeadAR;
-      GeoNodePtr<GeoSerialTransformer> serialTransformerDeadKR;
-      serialTransformerDead     = new GeoSerialTransformer(pHoleForMixedStrawWithLargeDeadRegion  , &tx2Dead,
-								      nStrawsWithLargeDeadRegion);
-      if (m_doArgon)
-        serialTransformerDeadAR = new GeoSerialTransformer(pHoleForMixedStrawWithLargeDeadRegionAR, &tx2Dead,
-                      nStrawsWithLargeDeadRegion);
-      if (m_doKrypton)
-        serialTransformerDeadKR = new GeoSerialTransformer(pHoleForMixedStrawWithLargeDeadRegionKR, &tx2Dead,
-                      nStrawsWithLargeDeadRegion);
-
-     
       
-      pRad->add(new GeoSerialIdentifier(0));
-      if (m_doArgon  ) pRadAR->add(new GeoSerialIdentifier(0));
-      if (m_doKrypton) pRadKR->add(new GeoSerialIdentifier(0));
-      if (iABC==0) {
-        pRad->add(serialTransformerDead);
-        if (m_doArgon  ) pRadAR->add(serialTransformerDeadAR);
-        if (m_doKrypton) pRadKR->add(serialTransformerDeadKR);
-      }
-      pRad->add(serialTransformer);
-      if (m_doArgon  ) pRadAR->add(serialTransformerAR);
-      if (m_doKrypton) pRadKR->add(serialTransformerKR);
-
       // Adds one straw from each layer (reformulate..) (should be done via m_data from database)
       double oldx=-999*GeoModelKernelUnits::cm, oldz=-999*GeoModelKernelUnits::cm;
       unsigned int c=0;
@@ -961,24 +884,36 @@ void TRTDetectorFactory_Full::create(GeoPhysVol *world)
 	if (m_strawsvcavailable && (m_doArgon || m_doKrypton)) strawStatusHT = m_sumTool->getStatusHT(TRT_Identifier);
 	ActiveGasMixture agm = DecideGasMixture(strawStatusHT);
 
-	// Ruslan: insert radiators with Ar-straws
-	// Artem: same for Kr
+	// Make a radiator
+	GeoNodePtr<GeoPhysVol> pRad(new GeoPhysVol(lRad));
+	pRad->add(xCool1);
+        pRad->add(pCoolingTube);
+        pRad->add(xCool2);
+        pRad->add(pCoolingTube);
+	pRad->add(new GeoSerialIdentifier(0));
+
+	GeoNodePtr<GeoPhysVol> pHoleForMixedStraw;
+	GeoNodePtr<GeoPhysVol> pHoleForMixedStrawWithLargeDeadRegion;
+
 	switch (agm)
 	{
 	case GM_ARGON:
 	  ATH_MSG_DEBUG( "Marking Argon straws from /TRT/Cond/StatusHT:\t"
 			 << idHelper->print_to_string(TRT_Identifier));
-	  pShell->add(pRadAR);
+	  pHoleForMixedStraw                    = makeStraw(false, GM_ARGON);
+	  pHoleForMixedStrawWithLargeDeadRegion = makeStraw(true, GM_ARGON);
 	  break;
 	case GM_KRYPTON:
 	  ATH_MSG_DEBUG( "Marking Krypton straws from /TRT/Cond/StatusHT:\t"
 			 << idHelper->print_to_string(TRT_Identifier));
-	  pShell->add(pRadKR);
+	  pHoleForMixedStraw                    = makeStraw(false, GM_KRYPTON);
+	  pHoleForMixedStrawWithLargeDeadRegion = makeStraw(true, GM_KRYPTON);
 	  break;
 	case GM_XENON:
 	  ATH_MSG_DEBUG( "Marking Xenon straws from /TRT/Cond/StatusHT:\t"
 			 << idHelper->print_to_string(TRT_Identifier) );
-	  pShell->add(pRad);
+	  pHoleForMixedStraw = makeStraw();
+	  pHoleForMixedStrawWithLargeDeadRegion = makeStraw(true);
 	  break;
 	default:
 	  ATH_MSG_FATAL( "Unexpected gas mixture: " << agm );
@@ -986,6 +921,20 @@ void TRTDetectorFactory_Full::create(GeoPhysVol *world)
 	  return;
 	}
 
+	GeoNodePtr<GeoSerialTransformer> serialTransformer = new GeoSerialTransformer(pHoleForMixedStraw
+										      , &tx2
+										      , m_data->barrelNumberOfStrawsInModule[iABC]-nStrawsWithLargeDeadRegion);
+
+	if (iABC==0) {
+	  GeoNodePtr<GeoSerialTransformer> serialTransformerDead = new GeoSerialTransformer(pHoleForMixedStrawWithLargeDeadRegion
+											    , &tx2Dead
+											    , nStrawsWithLargeDeadRegion);
+	  pRad->add(serialTransformerDead);
+	}
+	pRad->add(serialTransformer);
+
+	pShell->add(pRad);
+
 	//-------------------------------------------------------------------//
 	//                                                                   //
 	// Barrel readout:                                                   //
@@ -2119,16 +2068,13 @@ const GeoShape * TRTDetectorFactory_Full::makeModule ( double length, const GeoT
 //////////////////////////////////// makeStraw ///////////////////////////////////
 
 //
-//GeoPhysVol * TRTDetectorFactory_Full::makeStraw( double& activeGasZPosition, bool hasLargeDeadRegion /*= false*/ ) const {
-GeoPhysVol * TRTDetectorFactory_Full::makeStraw( double& activeGasZPosition, bool hasLargeDeadRegion /*= false*/, ActiveGasMixture gasMixture) {
+GeoPhysVol * TRTDetectorFactory_Full::makeStraw(bool hasLargeDeadRegion, ActiveGasMixture gasMixture) {
 
   double lengthOfInnerDeadRegion= hasLargeDeadRegion ? m_data->barrelLengthOfLargeDeadRegion : m_data->lengthOfDeadRegion ;
   double lengthOfActiveGas = (m_data->barrelLengthOfStraw-m_data->barrelLengthOfTwister)/2.0 - m_data->lengthOfDeadRegion - lengthOfInnerDeadRegion;
   double posA   = (lengthOfActiveGas + m_data->barrelLengthOfTwister) / 2. + lengthOfInnerDeadRegion; // middle of lengthOfActiveGas
   double posInnerDeadRegion = ( m_data->barrelLengthOfTwister + lengthOfInnerDeadRegion ) / 2;
 
-  activeGasZPosition=posA;
-
   // Straws:
   GeoTube    *sHole      = new GeoTube(0,m_data->barrelOuterRadiusOfStrawHole, m_data->barrelLengthOfStraw/2.0);
   GeoLogVol  *lHole      = new GeoLogVol("Hole", sHole, m_materialManager->getMaterial("trt::CO2"));

InnerDetector/InDetDetDescr/TRT_GeoModel/src/TRTDetectorFactory_Full.h

@@ -73,12 +73,19 @@ class TRTDetectorFactory_Full : public InDetDD::DetectorFactoryBase  {
   ActiveGasMixture DecideGasMixture(int strawStatusHT);
 
   // private helper methods:
-  const GeoShape * makeModule ( double length, const GeoTrf::Vector2D& corner1 ,  const GeoTrf::Vector2D& corner2, const GeoTrf::Vector2D& corner3,
-				const GeoTrf::Vector2D& corner4, GeoTrf::Transform3D & absolutePosition, double shrinkDist=0 ) const;
-  //GeoPhysVol * makeStraw( double& activeGasZPosition, bool hasLargeDeadRegion=false ) const;
-  GeoPhysVol * makeStraw( double& activeGasZPosition, bool hasLargeDeadRegion=false, ActiveGasMixture gasMixture = GM_XENON);
-  //GeoFullPhysVol  *makeStrawPlane( size_t w ) const;
-  GeoFullPhysVol  *makeStrawPlane( size_t w , ActiveGasMixture gasMixture = GM_XENON);
+  const GeoShape* makeModule(double length
+			     , const GeoTrf::Vector2D& corner1
+			     , const GeoTrf::Vector2D& corner2
+			     , const GeoTrf::Vector2D& corner3
+			     , const GeoTrf::Vector2D& corner4
+			     , GeoTrf::Transform3D & absolutePosition
+			     , double shrinkDist=0) const;
+
+  GeoPhysVol* makeStraw(bool hasLargeDeadRegion=false
+			, ActiveGasMixture gasMixture = GM_XENON);
+
+  GeoFullPhysVol* makeStrawPlane(size_t w
+				 , ActiveGasMixture gasMixture = GM_XENON);
 
   // private member data:
   InDetDD::TRT_DetectorManager                  *m_detectorManager = nullptr; // ownership handed to calleer.

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/DerivationFramework/DerivationFrameworkTileCal/python/TCAL1.py

@@ -142,7 +142,7 @@ def TCAL1Cfg(flags):
     from xAODMetaDataCnv.InfileMetaDataConfig import SetupMetaDataForStreamCfg
     from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
     TCAL1SlimmingHelper = SlimmingHelper("TCAL1SlimmingHelper", NamesAndTypes = flags.Input.TypedCollections, flags = flags)
-    TCAL1SlimmingHelper.SmartCollections = ['EventInfo', 'Muons', 'AntiKt4EMTopoJets', 'AntiKt4EMPFlowJets', 'MET_Baseline_AntiKt4EMTopo', 'MET_Baseline_AntiKt4EMPFlow', 'PrimaryVertices']
+    TCAL1SlimmingHelper.SmartCollections = ['EventInfo', 'Muons', 'AntiKt4EMTopoJets', 'AntiKt4EMPFlowJets', 'MET_Baseline_AntiKt4EMTopo', 'MET_Baseline_AntiKt4EMPFlow', 'PrimaryVertices', 'BTagging_AntiKt4EMPFlow']
 
     TCAL1ExtraVariables = f'Muons.{TCAL1Prefix}etrkcone40'
 

PhysicsAnalysis/SUSYPhys/SUSYTools/Root/SUSYObjDef_xAOD.cxx

@@ -252,15 +252,16 @@ SUSYObjDef_xAOD::SUSYObjDef_xAOD( const std::string& name )
     m_jetJvt(-99.),
     m_JvtWP(""),
     m_JvtPtMax(-99.),
-    m_JvtConfig(""),
+    m_JvtConfigRun2(""),
+    m_JvtConfigRun3(""),
     m_trkJetPt(-99.),
     m_trkJetEta(-99.),
     m_doFwdJVT(false),
     m_fJvtWP(""),
     m_fJvtPtMax(-99.),
     m_fJvtEtaMin(-99.),
-    m_fJvtConfig(""),
-    m_fJvtRecalculate(false),
+    m_fJvtConfigRun2(""),
+    m_fJvtConfigRun3(""),
     m_JMScalib(false),
     //
     m_orDoTau(false),
@@ -1503,7 +1504,8 @@ StatusCode SUSYObjDef_xAOD::readConfig()
   configFromFile(m_jetEta, "Jet.Eta", rEnv, 2.8);
   configFromFile(m_JvtWP, "Jet.JvtWP", rEnv, "FixedEffPt"); // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/PileupJetRecommendations
   configFromFile(m_JvtPtMax, "Jet.JvtPtMax", rEnv, 60.0e3);
-  configFromFile(m_JvtConfig, "Jet.JvtConfig", rEnv, "", true); // empty string means dummy SF
+  configFromFile(m_JvtConfigRun2, "Jet.JvtConfigRun2", rEnv, "JetJvtEfficiency/May2024/NNJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
+  configFromFile(m_JvtConfigRun3, "Jet.JvtConfigRun3", rEnv, "JetJvtEfficiency/May2024/NNJvtSFFile_Run3_EMPFlow.root", true); // empty string means dummy SF
   configFromFile(m_jetUncertaintiesConfig, "Jet.UncertConfig", rEnv, "rel22/Summer2023_PreRec/R4_CategoryReduction_FullJER.config"); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22/
   configFromFile(m_jetUncertaintiesAnalysisFile, "Jet.AnalysisFile", rEnv, "default"); // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel21Summer2018SmallR
   configFromFile(m_jetUncertaintiesCalibArea, "Jet.UncertCalibArea", rEnv, "default"); // Defaults to default area set by tool
@@ -1535,10 +1537,10 @@ StatusCode SUSYObjDef_xAOD::readConfig()
   //
   configFromFile(m_doFwdJVT, "FwdJet.doJVT", rEnv, false); // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/PileupJetRecommendations
   configFromFile(m_fJvtWP, "FwdJet.JvtWP", rEnv, "Loose");
-  configFromFile(m_fJvtPtMax, "FwdJet.JvtPtMax", rEnv, 120e3);
+  configFromFile(m_fJvtPtMax, "FwdJet.JvtPtMax", rEnv, 60e3);
   configFromFile(m_fJvtEtaMin, "FwdJet.JvtEtaMin", rEnv, 2.5);
-  configFromFile(m_fJvtConfig, "FwdJet.JvtConfig", rEnv, "", true); // empty string means dummy SF
-  configFromFile(m_fJvtRecalculate, "FwdJet.JvtRecalculate", rEnv, false);
+  configFromFile(m_fJvtConfigRun2, "FwdJet.JvtConfigRun2", rEnv, "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
+  configFromFile(m_fJvtConfigRun3, "FwdJet.JvtConfigRun3", rEnv, "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root", true); // empty string means dummy SF
   configFromFile(m_JMScalib, "Jet.JMSCalib", rEnv, false);
   //
   configFromFile(m_useBtagging, "Btag.enable", rEnv, true);

PhysicsAnalysis/SUSYPhys/SUSYTools/Root/SUSYToolsInit.cxx

@@ -537,7 +537,7 @@ StatusCode SUSYObjDef_xAOD::SUSYToolsInit()
       ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );  
       ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("WorkingPoint", m_JvtWP) );
       ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
-      ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("SFFile", m_JvtConfig) );
+      ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_JvtConfigRun3 : m_JvtConfigRun2) );
       ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
     } else if (m_jetNNJvtEfficiencyTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
@@ -565,7 +565,7 @@ StatusCode SUSYObjDef_xAOD::SUSYToolsInit()
       ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );  
       ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("WorkingPoint", m_fJvtWP) );
       ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
-      ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("SFFile", m_fJvtConfig) );
+      ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_fJvtConfigRun3 : m_fJvtConfigRun2) );
       ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
       ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
     } else  ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );

PhysicsAnalysis/SUSYPhys/SUSYTools/SUSYTools/SUSYObjDef_xAOD.h

@@ -716,8 +716,8 @@ namespace ST {
     double m_jetJvt;
     std::string m_JvtWP;
     double m_JvtPtMax;
-    std::string m_JvtConfig;
-    std::string m_JvtConfig_SFFile;
+    std::string m_JvtConfigRun2;
+    std::string m_JvtConfigRun3;
 
     double m_trkJetPt;
     double m_trkJetEta;
@@ -726,10 +726,8 @@ namespace ST {
     std::string m_fJvtWP;
     double m_fJvtPtMax;
     double m_fJvtEtaMin;
-    std::string m_fJvtConfig;
-    std::string m_fJvtConfig_SFFile;
-    bool m_fJvtRecalculate;
-    bool m_fJvt_useTightOP;
+    std::string m_fJvtConfigRun2;
+    std::string m_fJvtConfigRun3;
 
     bool m_JMScalib;
 

PhysicsAnalysis/SUSYPhys/SUSYTools/data/SUSYTools_Default.conf

@@ -82,7 +82,7 @@ Jet.UncertPDsmearing: false # set this to true for pseudo-data smearing for Full
 #
 FwdJet.doJVT: false
 FwdJet.JvtEtaMin: 2.5
-FwdJet.JvtWP: Loose #  R22 prerec
+FwdJet.JvtWP: Loose
 FwdJet.JvtPtMax: 60.0e3
 #
 Jet.LargeRuncConfig: #rec are missing for UFO jets

PhysicsAnalysis/SUSYPhys/SUSYTools/data/SUSYTools_Default_LITE.conf

@@ -82,7 +82,7 @@ Jet.UncertPDsmearing: false # set this to true for pseudo-data smearing for Full
 #
 FwdJet.doJVT: false
 FwdJet.JvtEtaMin: 2.5 
-FwdJet.JvtWP: Loose #  R22 prerec
+FwdJet.JvtWP: Loose
 FwdJet.JvtPtMax: 60.0e3
 #
 Jet.LargeRuncConfig: #rec are missing for UFO jets