Control/AthenaMonitoring/python/AthMonitorCfgHelper.py

@@ -146,7 +146,7 @@ class AthMonitorCfgHelper(object):
         Finalize the creation of the set of monitoring algorithms.
 
         Returns:
-        (resobj, monSeq) -- a tuple with a ComponentAccumulator and an AthSequencer
+        resobj -- a ComponentAccumulator 
         '''
         self.resobj.addSequence(self.monSeq)
         return self.resobj

Control/AthenaMonitoringKernel/AthenaMonitoringKernel/GenericMonitoringTool.h

@@ -72,7 +72,8 @@ public:
   virtual uint32_t lumiBlock();
 
 private:
-
+  void invokeFillersDebug(const std::shared_ptr<Monitored::HistogramFiller>& filler,
+                          const std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>& monitoredVariables) const;
   
   /// THistSvc (do NOT fix the service type (only the name) to allow for a different implementation online
   ServiceHandle<ITHistSvc> m_histSvc { this, "THistSvc", "THistSvc", "Histogramming svc" };
@@ -83,9 +84,9 @@ private:
   BooleanProperty m_useCache { this, "UseCache", true, "Cache filler lookups" };
 
   std::vector<std::shared_ptr<Monitored::HistogramFiller>> m_fillers; //!< plain list of fillers
-  mutable std::mutex m_fillMutex;
-  mutable Monitored::HistogramFiller::VariablesPack m_vars ATLAS_THREAD_SAFE;
-  mutable std::map<std::vector<std::string>,std::vector<std::shared_ptr<Monitored::HistogramFiller>>,std::less<>> m_fillerCacheMap ATLAS_THREAD_SAFE; //!< lookup map to speed up filler searches
+  mutable std::map<std::vector<std::string>,std::unique_ptr<std::vector<std::shared_ptr<Monitored::HistogramFiller>>>,std::less<>> m_fillerCacheMap ATLAS_THREAD_SAFE; //!< lookup map to speed up filler searches
+  mutable std::mutex m_cacheMutex;
+
 };
 
 /**

Control/AthenaMonitoringKernel/AthenaMonitoringKernel/HistogramFiller.h

@@ -129,6 +129,10 @@ namespace Monitored {
       return m_histDef->cutMask;
     }
 
+    const std::unique_lock<std::mutex> getLock() const {
+      return std::unique_lock(m_lock);
+    }
+
   protected:
     template <class H>
     H* histogram() const {
@@ -179,6 +183,7 @@ namespace Monitored {
 
     std::shared_ptr<HistogramDef> m_histDef;
     std::shared_ptr<IHistogramProvider> m_histogramProvider;
+    mutable std::mutex m_lock;
 
   private:
     HistogramFiller& operator=(HistogramFiller const&) = delete;

Control/AthenaMonitoringKernel/src/GenericMonitoringTool.cxx

@@ -125,37 +125,48 @@ namespace std {
   }
 }
 
+namespace {
+  // this exists to avoid reallocating memory on every invokeFillers call
+  thread_local Monitored::HistogramFiller::VariablesPack tl_vars ATLAS_THREAD_SAFE;
+}
+
 void GenericMonitoringTool::invokeFillers(const std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>& monitoredVariables) const {
-  std::scoped_lock guard(m_fillMutex);
   // This is the list of fillers to consider in the invocation.
   // If we are using the cache then this may be a proper subset of m_fillers; otherwise will just be m_fillers
   const std::vector<std::shared_ptr<Monitored::HistogramFiller>>* fillerList{nullptr};
   // do we need to update the cache?
   bool makeCache = false;
-  // list of matched fillers, if we need to update the cache
-  std::vector<std::shared_ptr<Monitored::HistogramFiller>> matchedFillerList;
+  // pointer to list of matched fillers, if we need to update the cache (default doesn't create the vector)
+  std::unique_ptr<std::vector<std::shared_ptr<Monitored::HistogramFiller>>> matchedFillerList;
   if (m_useCache) {
+    // lock the cache during lookup
+    std::scoped_lock cacheguard(m_cacheMutex);
     const auto match = m_fillerCacheMap.find(monitoredVariables);
     if (match != m_fillerCacheMap.end()) {
-      fillerList = &(match->second);
+      fillerList = match->second.get();
     } else {
       fillerList = &m_fillers;
+      matchedFillerList = std::make_unique<std::vector<std::shared_ptr<Monitored::HistogramFiller>>>();
       makeCache = true;
     }
   } else {
     fillerList = &m_fillers;
   }
+
   for ( auto filler: *fillerList ) {
-    m_vars.reset();
+    tl_vars.reset();
     const int fillerCardinality = filler->histogramVariablesNames().size() + (filler->histogramWeightName().empty() ? 0: 1) + (filler->histogramCutMaskName().empty() ? 0 : 1);
 
     if ( fillerCardinality == 1 ) { // simplest case, optimising this to be super fast
       for ( auto& var: monitoredVariables ) {
         if ( var.get().name().compare( filler->histogramVariablesNames()[0] ) == 0 )  {
-          m_vars.var[0] = &var.get();
-          filler->fill( m_vars );
+          tl_vars.var[0] = &var.get();
+          {
+            auto guard{filler->getLock()};
+            filler->fill( tl_vars );
+          }
           if (makeCache) { 
-            matchedFillerList.push_back(filler); 
+            matchedFillerList->push_back(filler); 
           }
           break;
         }
@@ -166,7 +177,7 @@ void GenericMonitoringTool::invokeFillers(const std::vector<std::reference_wrapp
         bool matched = false;
         for ( unsigned fillerVarIndex = 0; fillerVarIndex < filler->histogramVariablesNames().size(); ++fillerVarIndex ) {
           if ( var.get().name().compare( filler->histogramVariablesNames()[fillerVarIndex] ) == 0 ) {
-            m_vars.set(fillerVarIndex, &var.get());
+            tl_vars.set(fillerVarIndex, &var.get());
             matched = true;
             matchesCount++;
             break;
@@ -175,51 +186,65 @@ void GenericMonitoringTool::invokeFillers(const std::vector<std::reference_wrapp
         if ( matchesCount == fillerCardinality ) break;
         if ( not matched ) { // may be a weight or cut variable still
           if ( var.get().name().compare( filler->histogramWeightName() ) == 0 )  {
-            m_vars.weight = &var.get();
+            tl_vars.weight = &var.get();
             matchesCount ++;
           } else if ( var.get().name().compare( filler->histogramCutMaskName() ) == 0 )  {
-            m_vars.cut = &var.get();
+            tl_vars.cut = &var.get();
             matchesCount++;
          }
         }
         if ( matchesCount == fillerCardinality ) break;
       }
       if ( matchesCount == fillerCardinality ) {
-        filler->fill( m_vars );
+        {
+          auto guard{filler->getLock()};
+          filler->fill( tl_vars );
+        }
         if (makeCache) { 
-          matchedFillerList.push_back(filler); 
+          matchedFillerList->push_back(filler); 
         }
       } else if ( ATH_UNLIKELY( matchesCount != 0 ) ) { // something has matched, but not all, worth informing user
-        bool reasonFound = false;
-        if (ATH_UNLIKELY(!filler->histogramWeightName().empty() && !m_vars.weight)) {
-          reasonFound = true;
-          ATH_MSG_DEBUG("Filler weight not found in monitoredVariables:"
-            << "\n  Filler weight               : " << filler->histogramWeightName()
-            << "\n  Asked to fill from mon. vars: " << monitoredVariables);
-        }
-        if (ATH_UNLIKELY(!filler->histogramCutMaskName().empty() && !m_vars.cut)) {
-          reasonFound = true;
-          ATH_MSG_DEBUG("Filler cut mask not found in monitoredVariables:"
-            << "\n  Filler cut mask             : " << filler->histogramCutMaskName()
-            << "\n  Asked to fill from mon. vars: " << monitoredVariables);
-        }
-        if ( not reasonFound ) {
-          ATH_MSG_DEBUG("Filler has different variables than monitoredVariables:"
-            << "\n  Filler variables            : " << filler->histogramVariablesNames()
-            << "\n  Asked to fill from mon. vars: " << monitoredVariables
-            << "\n  Selected monitored variables: " << m_vars.names() );
-        }
+        invokeFillersDebug(filler, monitoredVariables);
       }
     }
   }
 
   if (makeCache) {
-    std::vector<std::string> key;
-    key.reserve(monitoredVariables.size());
-    for (const auto& mv : monitoredVariables) {
-      key.push_back(mv.get().name());
+    // we may hit this multiple times. If another thread has updated the cache in the meanwhile, don't update
+    // (or we might delete the fillerList under another thread)
+    std::scoped_lock cacheguard(m_cacheMutex);
+    const auto match = m_fillerCacheMap.find(monitoredVariables);
+    if (match == m_fillerCacheMap.end()) {
+      std::vector<std::string> key;
+      key.reserve(monitoredVariables.size());
+      for (const auto& mv : monitoredVariables) {
+        key.push_back(mv.get().name());
+      }
+      m_fillerCacheMap[key].swap(matchedFillerList);
     }
-    m_fillerCacheMap[key] = matchedFillerList;
+  }
+}
+
+void GenericMonitoringTool::invokeFillersDebug(const std::shared_ptr<Monitored::HistogramFiller>& filler,
+                                               const std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>& monitoredVariables) const {
+  bool reasonFound = false;
+  if (ATH_UNLIKELY(!filler->histogramWeightName().empty() && !tl_vars.weight)) {
+    reasonFound = true;
+    ATH_MSG_DEBUG("Filler weight not found in monitoredVariables:"
+      << "\n  Filler weight               : " << filler->histogramWeightName()
+      << "\n  Asked to fill from mon. tl_vars: " << monitoredVariables);
+  }
+  if (ATH_UNLIKELY(!filler->histogramCutMaskName().empty() && !tl_vars.cut)) {
+    reasonFound = true;
+    ATH_MSG_DEBUG("Filler cut mask not found in monitoredVariables:"
+      << "\n  Filler cut mask             : " << filler->histogramCutMaskName()
+      << "\n  Asked to fill from mon. tl_vars: " << monitoredVariables);
+  }
+  if ( not reasonFound ) {
+    ATH_MSG_DEBUG("Filler has different variables than monitoredVariables:"
+      << "\n  Filler variables            : " << filler->histogramVariablesNames()
+      << "\n  Asked to fill from mon. tl_vars: " << monitoredVariables
+      << "\n  Selected monitored variables: " << tl_vars.names() );
   }
 }
 

Database/IOVDbSvc/python/CondDB.py

@@ -314,6 +314,9 @@ This allows the possibility of later adding a new IOV using IOVSvc::setRange."""
                 if (ix2!=-1):
                     xmltag=(folderstr[ix+1:ix2]).strip()
                     ix=ix2+1
+                    if xmltag[-1] == '/':
+                        xmltag=""
+                        ix=ix+1
             elif (folderstr[ix:ix+2]=='</' and xmltag!=""):
                 ix2=folderstr.find('>',ix)
                 if (ix2!=-1):

Event/xAOD/xAODMissingET/Root/MissingETAssociationMap_v1.cxx

@@ -5,6 +5,7 @@
 #include "xAODMissingET/versions/MissingETAssociationMap_v1.h"
 
 #include "xAODTracking/TrackParticle.h"
+#include "xAODPFlow/FlowElement.h"
 #include "xAODJet/JetAttributes.h"
 
 #include "xAODBase/IParticleContainer.h"
@@ -222,6 +223,7 @@ const xAOD::IParticleContainer* MissingETAssociationMap_v1::getUniqueSignals(con
       else {continue;}
     case MissingETBase::UsageHandler::ParticleFlow:
       if((*iSig)->type()==xAOD::Type::ParticleFlow) {break;}
+      else if((*iSig)->type()==xAOD::Type::FlowElement && ((static_cast<const xAOD::FlowElement*>(*iSig))->signalType() & xAOD::FlowElement::PFlow)) {break;}
       else {continue;}
     case MissingETBase::UsageHandler::TruthParticle:
       if((*iSig)->type()==xAOD::Type::TruthParticle) {break;}
@@ -229,7 +231,7 @@ const xAOD::IParticleContainer* MissingETAssociationMap_v1::getUniqueSignals(con
     case MissingETBase::UsageHandler::AllCalo:
       if((*iSig)->type()!=xAOD::Type::TrackParticle) {break;}
       else {continue;}
-    default: continue;
+    default: {continue;}
     }
 
     size_t assocIndex = findIndexByJetConst(*iSig);

Event/xAOD/xAODMissingET/Root/MissingETAssociation_v1.cxx

@@ -7,6 +7,7 @@
 #include "xAODJet/JetContainer.h"
 #include "xAODTruth/TruthParticle.h"
 #include "xAODPFlow/PFO.h"
+#include "xAODPFlow/FlowElement.h"
 
 #include <iterator>
 #include <cstdio>
@@ -138,32 +139,32 @@ namespace xAOD {
     // found - add const vectors
     if ( idx != MissingETBase::Numerical::invalidIndex() )
       { 
-	m_objConstLinks[idx].clear();
-	m_objConstLinks[idx].reserve(constlist.size());
-	for(const auto& signal : constlist) {
-	  const IParticleContainer* pCont = static_cast<const IParticleContainer*>(signal->container());
-	  MissingETBase::Types::objlink_t el(*pCont,signal->index());
-	  m_objConstLinks[idx].push_back(el);
-	}
-	return false; }
+        m_objConstLinks[idx].clear();
+        m_objConstLinks[idx].reserve(constlist.size());
+        for(const auto& signal : constlist) {
+          const IParticleContainer* pCont = static_cast<const IParticleContainer*>(signal->container());
+          MissingETBase::Types::objlink_t el(*pCont,signal->index());
+          m_objConstLinks[idx].push_back(el);
+        }
+        return false; }
     // new object
     else
       {
-	MissingETBase::Types::objlink_t oLnk; f_setObject<IParticle,MissingETBase::Types::objlink_t>(pPart,oLnk); 
-	// add to stores
-	this->f_objectLinks().push_back(oLnk);
-	vector<MissingETBase::Types::objlink_t > linklist;
-	linklist.reserve(constlist.size());
-	for(const auto& signal : constlist) {
-	  const IParticleContainer* pCont = static_cast<const IParticleContainer*>(signal->container());
-	  MissingETBase::Types::objlink_t el(*pCont,signal->index());
-	  linklist.push_back(el);
-	}
-	m_objConstLinks.push_back(linklist);
-	this->f_overlapIndices().push_back(vector<size_t>(0));
-	this->f_overlapTypes().push_back(vector<unsigned char>(0));
-	bool linkset = f_setLink<MissingETBase::Types::objlink_t>(oLnk);
-	return linkset;
+        MissingETBase::Types::objlink_t oLnk; f_setObject<IParticle,MissingETBase::Types::objlink_t>(pPart,oLnk); 
+        // add to stores
+        this->f_objectLinks().push_back(oLnk);
+        vector<MissingETBase::Types::objlink_t > linklist;
+        linklist.reserve(constlist.size());
+        for(const auto& signal : constlist) {
+          const IParticleContainer* pCont = static_cast<const IParticleContainer*>(signal->container());
+          MissingETBase::Types::objlink_t el(*pCont,signal->index());
+          linklist.push_back(el);
+        }
+        m_objConstLinks.push_back(linklist);
+        this->f_overlapIndices().push_back(vector<size_t>(0));
+        this->f_overlapTypes().push_back(vector<unsigned char>(0));
+        bool linkset = f_setLink<MissingETBase::Types::objlink_t>(oLnk);
+        return linkset;
       }
   }
 
@@ -173,7 +174,7 @@ namespace xAOD {
   //   static SG::AuxElement::Accessor<MissingETBase::Types::objlink_vector_t> acc("objectLinks");
   //   if(acc.isAvailableWritable(*this)) {
   //     for ( auto& link : this->f_objectLinks() ) { 
-  // 	link.toPersistent();
+  //         link.toPersistent();
   //     } 
   //   }
   // }
@@ -182,9 +183,9 @@ namespace xAOD {
   //   if(!this->isMisc()) {
   //     static SG::AuxElement::Accessor<MissingETBase::Types::jetlink_t> acc("jetLink");
   //     if(acc.isAvailableWritable(*this)) {
-  // 	if(f_setLink<MissingETBase::Types::jetlink_t>(this->f_jetLink())) {
-  // 	  this->f_jetLink().toPersistent();
-  // 	}
+  //         if(f_setLink<MissingETBase::Types::jetlink_t>(this->f_jetLink())) {
+  //           this->f_jetLink().toPersistent();
+  //         }
   //     }
   //   }
   // }
@@ -499,13 +500,13 @@ namespace xAOD {
     for ( size_t idx(0); idx < this->sizeTrk(); idx++) trkVecs[idx] = constvec_t(this->trkpx(idx),this->trkpy(idx),this->trkpz(idx),this->trke(idx),this->trksumpt(idx));
     return pVec;
   }
-										   
+                                                                                   
   std::vector<const IParticle*> MissingETAssociation_v1::objects(const std::vector<double>*& calpxPtr,const std::vector<double>*& calpyPtr,
-								 const std::vector<double>*& calpzPtr,const std::vector<double>*& calePtr,
-								 const std::vector<double>*& calsumptPtr,
-								 const std::vector<double>*& trkpxPtr,const std::vector<double>*& trkpyPtr,
-								 const std::vector<double>*& trkpzPtr,const std::vector<double>*& trkePtr,
-								 const std::vector<double>*& trksumptPtr) const
+                                                                 const std::vector<double>*& calpzPtr,const std::vector<double>*& calePtr,
+                                                                 const std::vector<double>*& calsumptPtr,
+                                                                 const std::vector<double>*& trkpxPtr,const std::vector<double>*& trkpyPtr,
+                                                                 const std::vector<double>*& trkpzPtr,const std::vector<double>*& trkePtr,
+                                                                 const std::vector<double>*& trksumptPtr) const
   {
     calpxPtr = &(this->calpx()); calpyPtr = &(this->calpy()); calpzPtr = &(this->calpz()); calePtr = &(this->cale()); calsumptPtr = &(this->calsumpt());
     trkpxPtr = &(this->trkpx()); trkpyPtr = &(this->trkpy()); trkpzPtr = &(this->trkpz()); trkePtr = &(this->trke()); trksumptPtr = &(this->trksumpt());
@@ -521,7 +522,7 @@ namespace xAOD {
     MissingETBase::Types::constvec_t totalvec;
     for (size_t iKey = 0; iKey < this->sizeCal(); iKey++) {
       if (this->calkey(iKey) & getObjMask(this->findIndex(pPart)))
-	totalvec+=this->calVec(iKey);
+        totalvec+=this->calVec(iKey);
     }
     return totalvec;
   }
@@ -531,7 +532,7 @@ namespace xAOD {
     MissingETBase::Types::constvec_t totalvec;
     for (size_t iKey = 0; iKey < this->sizeTrk(); iKey++) {
       if (this->trkkey(iKey) & getObjMask(this->findIndex(pPart)))
-	totalvec+=this->trkVec(iKey);
+        totalvec+=this->trkVec(iKey);
     }
     return totalvec;
   }
@@ -590,29 +591,48 @@ namespace xAOD {
       const IParticle* obj = *objpair.first;
       MissingETBase::Types::bitmask_t bm = objpair.second;
       if (obj->type()==xAOD::Type::TrackParticle) trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+      else if (obj->type()==xAOD::Type::FlowElement) {
+        const xAOD::FlowElement* fe = static_cast<const xAOD::FlowElement*>(obj);
+        // Assume this FlowElement represents a PFO
+        if(fe->isCharged()) {
+          // apply cPFO weight if present, only for the inclusive PFO sum
+          if (m_override.find(obj)!=m_override.end()) {
+            calOverlaps[bm] += m_override[obj];
+          } else {
+            calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+          }
+          trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+        } else {
+          if (m_override.find(obj)!=m_override.end()) {
+            calOverlaps[bm] += m_override[obj];
+          } else {
+            calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+          } // gets ignored otherwise?
+        }
+      }
       else if (obj->type()==xAOD::Type::ParticleFlow) {
-	const PFO* pfo = static_cast<const PFO*>(obj);
-	if(pfo->isCharged()) {
-	  // apply cPFO weight if present, only for the inclusive PFO sum
-	  if (m_override.find(obj)!=m_override.end()) {
-	    calOverlaps[bm] += m_override[obj];
-	  } else {
-	    calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
-	  }
-	  trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
-	} else {
-	  if (m_override.find(obj)!=m_override.end()) {
-	    calOverlaps[bm] += m_override[obj];
-	  } else {
-	    calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
-	  } // gets ignored otherwise?
-	}
+        const PFO* pfo = static_cast<const PFO*>(obj);
+        if(pfo->isCharged()) {
+          // apply cPFO weight if present, only for the inclusive PFO sum
+          if (m_override.find(obj)!=m_override.end()) {
+            calOverlaps[bm] += m_override[obj];
+          } else {
+            calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+          }
+          trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+        } else {
+          if (m_override.find(obj)!=m_override.end()) {
+            calOverlaps[bm] += m_override[obj];
+          } else {
+            calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+          } // gets ignored otherwise?
+        }
       } else if(obj->type()==xAOD::Type::TruthParticle) {
-	const TruthParticle* tp = static_cast<const TruthParticle*>(obj);
-	if(fabs(tp->charge())>0.)
-	  trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
-	if(!tp->isMuon())
-	  calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+        const TruthParticle* tp = static_cast<const TruthParticle*>(obj);
+        if(fabs(tp->charge())>0.)
+          trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
+        if(!tp->isMuon())
+          calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
       }
       else calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
     }
@@ -648,25 +668,25 @@ namespace xAOD {
       unsigned char overlapTypes(0);
       // if we somehow already recorded an overlap for this one, skip
       for(vector<size_t>::const_iterator iOverlap=myOverlaps.begin();
-	  iOverlap!=myOverlaps.end() && !overlapFound; ++iOverlap) {
-	overlapFound = (*iOverlap) == iTargetObj;
+          iOverlap!=myOverlaps.end() && !overlapFound; ++iOverlap) {
+        overlapFound = (*iOverlap) == iTargetObj;
       }
       if(overlapFound) continue;
       // otherwise, compare constituents to check if any match
       for(const auto& mine : myConst) {
-	for(const auto& target : checkConst) {
-	  overlapFound |= ( mine == target );
-	  if(mine == target) {
-	    if((*mine)->type()==xAOD::Type::TruthParticle) overlapTypes |= 1;
-	    else if((*mine)->type()==xAOD::Type::Other) overlapTypes |= 1 << xAOD::Type::NeutralParticle;
-	    else overlapTypes |= 1 << (*mine)->type();
-	  }
-	}
+        for(const auto& target : checkConst) {
+          overlapFound |= ( mine == target );
+          if(mine == target) {
+            if((*mine)->type()==xAOD::Type::TruthParticle) overlapTypes |= 1;
+            else if((*mine)->type()==xAOD::Type::Other) overlapTypes |= 1 << xAOD::Type::NeutralParticle;
+            else overlapTypes |= 1 << (*mine)->type();
+          }
+        }
       }
       // record the overlap
       if(overlapFound) {
-	this->addOverlap(objIdx,iTargetObj,overlapTypes);
-	this->addOverlap(iTargetObj,objIdx,overlapTypes);
+        this->addOverlap(objIdx,iTargetObj,overlapTypes);
+        this->addOverlap(iTargetObj,objIdx,overlapTypes);
       }
     }
     return overlapIndices(objIdx).size()>0;
@@ -680,29 +700,31 @@ namespace xAOD {
     vector<unsigned char> types = this->overlapTypes(objIdx);
     for(size_t iOL=0; iOL<indices.size(); ++iOL) {
       if(helper->objSelected(this, indices[iOL])) {
-	// printf("Test object %lu for overlaps: OL type %i\n",indices[iOL],(int)types[iOL]);
-	switch(p) {
-	case MissingETBase::UsageHandler::TrackCluster:      
-	  if((types[iOL] & 1<<xAOD::Type::CaloCluster) || (types[iOL] & 1<<xAOD::Type::TrackParticle)) {break;}
-	  else {continue;}
-	case MissingETBase::UsageHandler::OnlyCluster:
-	  if(types[iOL] & 1<<xAOD::Type::CaloCluster) {break;}
-	  else {continue;}
-	case MissingETBase::UsageHandler::OnlyTrack:
-	  if(types[iOL] & 1<<xAOD::Type::TrackParticle) {break;}
-	  else {continue;}
-	case MissingETBase::UsageHandler::ParticleFlow:
-	  if(types[iOL] & 1<<xAOD::Type::ParticleFlow) {break;}
-	  else {continue;}
-	case MissingETBase::UsageHandler::TruthParticle:
-	  if(types[iOL] & 1) {break;}
-	  else {continue;}
-	case MissingETBase::UsageHandler::AllCalo:
-	  if(types[iOL] & ~(1<<xAOD::Type::TrackParticle)) {break;}
-	  else {continue;}
-	default: continue;
-	}
-	return true;
+        // printf("Test object %lu for overlaps: OL type %i\n",indices[iOL],(int)types[iOL]);
+        switch(p) {
+        case MissingETBase::UsageHandler::TrackCluster:      
+          if((types[iOL] & 1<<xAOD::Type::CaloCluster) || (types[iOL] & 1<<xAOD::Type::TrackParticle)) {break;}
+          else {continue;}
+        case MissingETBase::UsageHandler::OnlyCluster:
+          if(types[iOL] & 1<<xAOD::Type::CaloCluster) {break;}
+          else {continue;}
+        case MissingETBase::UsageHandler::OnlyTrack:
+          if(types[iOL] & 1<<xAOD::Type::TrackParticle) {break;}
+          else {continue;}
+        case MissingETBase::UsageHandler::ParticleFlow:
+          if(types[iOL] & 1<<xAOD::Type::ParticleFlow) {break;}
+          //TODO: Check with TJ that this is OK
+          if(types[iOL] & 1<<xAOD::Type::FlowElement) {break;}
+          else {continue;}
+        case MissingETBase::UsageHandler::TruthParticle:
+          if(types[iOL] & 1) {break;}
+          else {continue;}
+        case MissingETBase::UsageHandler::AllCalo:
+          if(types[iOL] & ~(1<<xAOD::Type::TrackParticle)) {break;}
+          else {continue;}
+        default: continue;
+        }
+        return true;
       }
     }
     return false;
@@ -752,9 +774,9 @@ namespace xAOD {
   {
     for(const auto& link : this->objectLinks()) {
       if(link.isValid()) {
-	if(pPhys == *link) {
-	  return true;
-	}
+        if(pPhys == *link) {
+          return true;
+        }
       }
     }
     return false;
@@ -764,11 +786,11 @@ namespace xAOD {
   {
     for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
       for(const auto& link : m_objConstLinks[iObj]) {
-	if(link.isValid()) {
-	  if(pSig == *link) {
-	    return true;
-	  }
-	}
+        if(link.isValid()) {
+          if(pSig == *link) {
+            return true;
+          }
+        }
       }
     }
     return false;
@@ -836,7 +858,7 @@ namespace xAOD {
     switch(p) {
     case MissingETBase::UsageHandler::TrackCluster:      
       if(type==xAOD::Type::CaloCluster
-	 || type==xAOD::Type::TrackParticle) {return true;}
+         || type==xAOD::Type::TrackParticle) {return true;}
       else {return false;}
     case MissingETBase::UsageHandler::OnlyCluster:
       if(type==xAOD::Type::CaloCluster) {return true;}
@@ -846,6 +868,7 @@ namespace xAOD {
       else {return false;}
     case MissingETBase::UsageHandler::ParticleFlow:
       if(type==xAOD::Type::ParticleFlow) {return true;}
+      if(type==xAOD::Type::FlowElement) {return true;}
       else {return false;}
     case MissingETBase::UsageHandler::AllCalo:
       if(type!=xAOD::Type::TrackParticle) {return true;}

InnerDetector/InDetConditions/PixelConditionsTools/src/PixelConditionsSummaryTool.cxx

@@ -87,7 +87,7 @@ PixelConditionsSummaryTool::IDCCacheEntry* PixelConditionsSummaryTool::getCacheE
 uint64_t PixelConditionsSummaryTool::getBSErrorWord(const IdentifierHash& moduleHash, const EventContext& ctx) const {
   if (!m_useByteStream) { return 0; }
 
-  std::lock_guard<std::mutex> lock{m_cacheMutex};
+  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
   auto idcCachePtr = getCacheEntry(ctx)->IDCCache;
   if (idcCachePtr==nullptr) {
     ATH_MSG_ERROR("PixelConditionsSummaryTool No cache! " );

InnerDetector/InDetConditions/PixelConditionsTools/src/PixelConditionsSummaryTool.h

@@ -102,7 +102,7 @@ class PixelConditionsSummaryTool: public AthAlgTool, public IInDetConditionsTool
 
     const uint64_t m_missingErrorInfo{std::numeric_limits<uint64_t>::max()-3000000000};
 
-    mutable std::mutex m_cacheMutex{};
+    mutable SG::SlotSpecificObj<std::mutex> m_cacheMutex ATLAS_THREAD_SAFE;
 
     struct IDCCacheEntry {
       EventContext::ContextEvt_t eventId = EventContext::INVALID_CONTEXT_EVT; // invalid event ID for the start

InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx

@@ -102,7 +102,7 @@ SCT_ByteStreamErrorsTool::IDCCacheEntry* SCT_ByteStreamErrorsTool::getCacheEntry
 bool
 SCT_ByteStreamErrorsTool::isGood(const IdentifierHash& elementIdHash, const EventContext& ctx) const {
   {
-    std::lock_guard<std::mutex> lock{m_cacheMutex};
+    std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
     ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool isGood called for " << elementIdHash);
     auto idcCachePtr{getCacheEntry(ctx)->IDCCache};
     if (idcCachePtr == nullptr) {
@@ -351,7 +351,7 @@ SCT_ByteStreamErrorsTool::fillData(const EventContext& ctx) const {
 
 unsigned int SCT_ByteStreamErrorsTool::tempMaskedChips(const Identifier& moduleId, const EventContext& ctx) const {
   ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool tempMaskedChips");
-  std::lock_guard<std::mutex> lock{m_cacheMutex};
+  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
   auto cacheEntry{getCacheEntry(ctx)};
   if (cacheEntry->IDCCache == nullptr) return 0;
 
@@ -370,7 +370,7 @@ unsigned int SCT_ByteStreamErrorsTool::tempMaskedChips(const Identifier& moduleI
 
 unsigned int SCT_ByteStreamErrorsTool::abcdErrorChips(const Identifier& moduleId, const EventContext& ctx) const {
   ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool abcdErrorChips");
-  std::lock_guard<std::mutex> lock{m_cacheMutex};
+  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
   auto cacheEntry{getCacheEntry(ctx)};
   if (cacheEntry->IDCCache == nullptr) return 0;
 

InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.h

@@ -37,7 +37,6 @@
 #include <atomic>
 #include <functional>
 #include <unordered_map>
-#include <mutex>
 #include <vector>
 
 /** forward declarations */
@@ -101,7 +100,7 @@ private:
   const SCT_ID* m_sct_id{nullptr};
   IdContext m_cntx_sct;
 
-  mutable std::mutex m_cacheMutex{};
+  mutable SG::SlotSpecificObj<std::mutex> m_cacheMutex ATLAS_THREAD_SAFE;
   struct IDCCacheEntry {
     EventContext::ContextEvt_t eventId{EventContext::INVALID_CONTEXT_EVT}; // invalid event ID for the start
     const IDCInDetBSErrContainer_Cache* IDCCache{nullptr};
@@ -125,7 +124,7 @@ private:
     }
     
   };
-  mutable SG::SlotSpecificObj<IDCCacheEntry> m_eventCache ATLAS_THREAD_SAFE; // Guarded by m_cacheMutex
+  mutable SG::SlotSpecificObj<IDCCacheEntry> m_eventCache ATLAS_THREAD_SAFE;
 
   /**
    * Obtains container form the SG, if it is missing it will complain (hard-coded 3 times per job) and return nullptr

InnerDetector/InDetExample/InDetRecExample/share/InDetRec_jobOptions.py

@@ -1066,7 +1066,7 @@ else:
                                                               OutputTracksLocation    = InDetKeys.UnslimmedTracks(),
                                                               AssociationTool         = getInDetPRDtoTrackMapToolGangedPixels(),
                                                               AssociationMapName      = "PRDtoTrackMap" + InDetKeys.UnslimmedTracks(),
-                                                              UpdateSharedHitsOnly    = False,
+                                                              UpdateSharedHits        = True,
                                                               UpdateAdditionalInfo    = True,
                                                               SummaryTool             = merger_track_summary_tool)
         topSequence += TrkTrackCollectionMerger
@@ -1113,7 +1113,7 @@ else:
                                                                  TracksLocation          = DummyCollection,
                                                                  OutputTracksLocation    = InDetKeys.DisappearingTracks(),
                                                                  AssociationTool         = getInDetPRDtoTrackMapToolGangedPixels(),
-                                                                 UpdateSharedHitsOnly    = False,
+                                                                 UpdateSharedHits        = True,
                                                                  UpdateAdditionalInfo    = True,
                                                                  SummaryTool             = merger_track_summary_tool)
        #TrkTrackCollectionMerger_pix.OutputLevel = VERBOSE

InnerDetector/InDetMonitoring/TRTMonitoringRun3/CMakeLists.txt

@@ -5,26 +5,13 @@
 
 # Declare the package name:
 atlas_subdir( TRTMonitoringRun3 )
-
-# External dependencies:
-find_package( Eigen )
-find_package( GeoModelCore )
-find_package( CORAL COMPONENTS CoralBase CoralKernel RelationalAccess )
-find_package( ROOT COMPONENTS Tree Hist RIO pthread MathCore Core Graf Graf3d Gpad Html Postscript Gui GX11TTF GX11)
-
-atlas_add_library( TRTMonitoringRun3Lib
-                   src/*.cxx
-                   PUBLIC_HEADERS TRTMonitoringRun3
-                   INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS} ${GEOMODELCORE_INCLUDE_DIRS}
-                   PRIVATE_INCLUDE_DIRS ${CORAL_INCLUDE_DIRS}
-                   LINK_LIBRARIES ${ROOT_LIBRARIES} ${EIGEN_LIBRARIES} ${GEOMODELCORE_LIBRARIES} AthenaBaseComps xAODEventInfo InDetPrepRawData GaudiKernel TRT_ConditionsServicesLib InDetReadoutGeometry TRT_ReadoutGeometry InDetRawData TrkTrack TrkToolInterfaces AthenaMonitoringLib CommissionEvent TrkSpacePoint MagFieldInterfaces InDetByteStreamErrors
-                   PRIVATE_LINK_LIBRARIES ${CORAL_LIBRARIES} AthenaKernel SGTools SGAudCore AthenaPoolUtilities LumiBlockCompsLib EventInfo LWHists TrkTrackSummary InDetRIO_OnTrack InDetIdentifier TrkRIO_OnTrack TrkParameters TrkMeasurementBase TrkEventUtils TrkSurfaces PathResolver EventPrimitives Identifier AtlasDetDescr AthContainers TRT_DriftFunctionToolLib )
-                   
+                  
 atlas_add_component( TRTMonitoringRun3
                      src/*.cxx
                      src/components/*.cxx
                      INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${CORAL_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS} ${GEOMODELCORE_INCLUDE_DIRS}
-                     LINK_LIBRARIES ${ROOT_LIBRARIES} ${EIGEN_LIBRARIES} ${GEOMODELCORE_LIBRARIES} TRTMonitoringRun3Lib AthenaMonitoringLib SGAudCore SGTools AthenaPoolUtilities GaudiKernel EventInfo InDetRawData InDetPrepRawData LumiBlockCompsLib CommissionEvent AthContainers AtlasDetDescr Identifier xAODEventInfo EventPrimitives TRT_ConditionsServicesLib InDetReadoutGeometry TRT_ReadoutGeometry InDetRIO_OnTrack LWHists TrkTrack TrkTrackSummary TrkToolInterfaces AthenaKernel InDetIdentifier MagFieldInterfaces PathResolver TrkSurfaces TrkEventUtils TrkMeasurementBase TrkParameters TrkRIO_OnTrack TrkSpacePoint TRT_DriftFunctionToolLib )
+                     LINK_LIBRARIES AthenaMonitoringLib TrkToolInterfaces CommissionEvent TRT_DriftFunctionToolLib TRT_ConditionsServicesLib MagFieldInterfaces InDetByteStreamErrors InDetRIO_OnTrack
+                     )
                    
 # Install files from the package:
 atlas_install_python_modules( python/*.py )

InnerDetector/InDetMonitoring/TRTMonitoringRun3/TRTMonitoringRun3/TRTMonitoringRun3RAW_Alg.h

@@ -27,6 +27,7 @@
 #include "TrkToolInterfaces/ITrackHoleSearchTool.h"
 #include "TRT_DriftFunctionTool/ITRT_DriftFunctionTool.h"
 #include "TRT_ConditionsServices/ITRT_CalDbTool.h"
+#include "TRT_ConditionsServices/ITRT_StrawNeighbourSvc.h"
 
 #include "MagFieldInterfaces/IMagFieldSvc.h"
 
@@ -113,6 +114,7 @@ private:
 
     // Services
     ToolHandle<ITRT_StrawStatusSummaryTool> m_sumTool;
+    ServiceHandle<ITRT_StrawNeighbourSvc> m_TRTStrawNeighbourSvc;
 
     // Data handles
     SG::ReadHandleKey<TRT_RDO_Container>   m_rdoContainerKey{this,       "TRTRawDataObjectName",   "TRT_RDOs",      "Name of TRT RDOs container"};

InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3RAW_Alg.py

@@ -55,33 +55,33 @@ def TRTMonitoringRun3RAW_AlgConfig(inputFlags):
                 elif i >= numberOfStacks[ibe]:
                     oss = 'TRT/EndcapC/Sector' + str(i + 1 - 32)
 
-            rdoStackGroup.defineHistogram('HitWMapS_passed,HitWMapS;hHitWMapS',type='TEfficiency',title='Leading Edge in Time Window: Straws;Straw Number in Stack;Probability per Event',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoStackGroup.defineHistogram('HitTrWMapS_x,HitTrWMapS_y;hHitTrWMapS',type='TProfile',title='Mean Trailing Edge in Time Window: Straws;Straw Number in Stack;Time (ns)',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoStackGroup.defineHistogram('HitTrMapS_x,HitTrMapS_y;hHitTrMapS',type='TProfile',title='Mean Trailing Edge: Straws;Straw Number in Stack;Time (ns)',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoStackGroup.defineHistogram('HitAWMapS_passed,HitAWMapS;hHitAWMapS',type='TEfficiency',title='LL in Time Window: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoStackGroup.defineHistogram('HitAMapS_passed,HitAMapS;hHitAMapS',type='TEfficiency',title='Any LL Bit: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('HitWMapS_passed,strawNumber;hHitWMapS',type='TEfficiency',title='Leading Edge in Time Window: Straws;Straw Number in Stack;Probability per Event',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('strawNumber,HitTrMapS_y;hHitTrWMapS',cutmask='HitTrWMapS_cut',type='TProfile',title='Mean Trailing Edge in Time Window: Straws;Straw Number in Stack;Time (ns)',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('strawNumber,HitTrMapS_y;hHitTrMapS',type='TProfile',title='Mean Trailing Edge: Straws;Straw Number in Stack;Time (ns)',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('HitAWMapS_passed,strawNumber;hHitAWMapS',type='TEfficiency',title='LL in Time Window: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('HitAMapS_passed,strawNumber;hHitAMapS',type='TEfficiency',title='Any LL Bit: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
             rdoStackGroup.defineHistogram('StrawOcc_passed,StrawOcc;hOccupancyS',type='TEfficiency',title='Straw Occupancy Distribution: Straws;Occupancy;Number of Straws',path=oss,xbins=201,xmin=0,xmax=1.005)
-            rdoStackGroup.defineHistogram('HitToTMapS_x,HitToTMapS_y;hHitToTMapS',type='TProfile',title='Mean ToT: Straws;Straw Number in Stack;Time (ns)',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoStackGroup.defineHistogram('HitToTLongMapS_x,HitToTLongMapS_y;hHitToTLongMapS',type='TProfile',title='Mean ToT for Straws with ToT > LongToTCut: Straws;Straw Number in Stack;Time (ns)',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoStackGroup.defineHistogram('HitToTLongTrMapS_x,HitToTLongTrMapS_y;hHitToTLongTrMapS',type='TProfile',title='Mean Trailing Edge for Straws with ToT > LongToTCut: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoStackGroup.defineHistogram('HitHMapS_passed,HitHMapS;hHitHMapS',type='TEfficiency',title='Any HL Bit: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoStackGroup.defineHistogram('HitHWMapS_passed,HitHWMapS;hHitHWMapS',type='TEfficiency',title='HL in Time Window: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('strawNumber,HitToTMapS_y;hHitToTMapS',type='TProfile',title='Mean ToT: Straws;Straw Number in Stack;Time (ns)',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('strawNumber,HitToTMapS_y;hHitToTLongMapS',cutmask='HitToTLong_cut',type='TProfile',title='Mean ToT for Straws with ToT > LongToTCut: Straws;Straw Number in Stack;Time (ns)',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('strawNumber,HitTrMapS_y;hHitToTLongTrMapS',cutmask='HitToTLong_cut',type='TProfile',title='Mean Trailing Edge for Straws with ToT > LongToTCut: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('HitHMapS_passed,strawNumber;hHitHMapS',type='TEfficiency',title='Any HL Bit: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoStackGroup.defineHistogram('HitHWMapS_passed,strawNumber;hHitHWMapS',type='TEfficiency',title='HL in Time Window: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
             rdoStackGroup.defineHistogram('HtoLMapS_passed,HtoLMapS;hHtoLMapS',type='TEfficiency',title='HL/LL Ratio: Straws;Straw Number in Stack;Probability',path=oss,xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
 
-            rdoStackGroup.defineHistogram('HitWMapC_passed,HitWMapC;hHitWMapC',type='TEfficiency',title='Leading Edge in Time Window: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
-            rdoStackGroup.defineHistogram('HitTrMapC_x,HitTrMapC_y;hHitTrMapC',type='TProfile',title='Mean Trailing Edge: Chips;Chip Number in Stack;Time (ns)',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
-            rdoStackGroup.defineHistogram('HitTrWMapC_x,HitTrWMapC_y;hHitTrWMapC',type='TProfile',title='Mean Trailing Edge in Time Window: Chips;Chip Number in Stack;Time (ns)',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
-            rdoStackGroup.defineHistogram('HitAWMapC_passed,HitAWMapC;hHitAWMapC',type='TEfficiency',title='LL in Time Window: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
-            rdoStackGroup.defineHistogram('HitAMapC_passed,HitAMapC;hHitAMapC',type='TEfficiency',title='Any LL Bit: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('HitWMapC_passed,chipNumber;hHitWMapC',type='TEfficiency',title='Leading Edge in Time Window: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('chipNumber,HitTrMapC_y;hHitTrMapC',type='TProfile',title='Mean Trailing Edge: Chips;Chip Number in Stack;Time (ns)',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('chipNumber,HitTrMapC_y;hHitTrWMapC',cutmask='HitTrWMapC_cut',type='TProfile',title='Mean Trailing Edge in Time Window: Chips;Chip Number in Stack;Time (ns)',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('HitAWMapC_passed,chipNumber;hHitAWMapC',type='TEfficiency',title='LL in Time Window: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('HitAMapC_passed,chipNumber;hHitAMapC',type='TEfficiency',title='Any LL Bit: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
             rdoStackGroup.defineHistogram('OccupancyC_passed,OccupancyC;hChipOcc',type='TEfficiency',title='Chip Occupancy Distribution;Occupancy;Number of Chips',path=oss,xbins=201,xmin=0,xmax=1.005)
-            rdoStackGroup.defineHistogram('HitToTMapC_x,HitToTMapC_y;hHitToTMapC',type='TProfile',title='Mean ToT: Chips;Chip Number in Stack;Time (ns)',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
-            rdoStackGroup.defineHistogram('HitHMapC_passed,HitHMapC;hHitHMapC',type='TEfficiency',title='Any HL Bit: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
-            rdoStackGroup.defineHistogram('HitHWMapC_passed,HitHWMapC;hHitHWMapC',type='TEfficiency',title='HL in Time Window: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('chipNumber,HitToTMapC_y;hHitToTMapC',type='TProfile',title='Mean ToT: Chips;Chip Number in Stack;Time (ns)',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('HitHMapC_passed,chipNumber;hHitHMapC',type='TEfficiency',title='Any HL Bit: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('HitHWMapC_passed,chipNumber;hHitHWMapC',type='TEfficiency',title='HL in Time Window: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
             rdoStackGroup.defineHistogram('HtoLMapC_passed,HtoLMapC;hHtoLMapC',type='TEfficiency',title='HL/LL Ratio: Chips;Chip Number in Stack;Probability',path=oss,xbins=iChipMax[ibe],xmin=0,xmax=iChipMax[ibe])
-            rdoStackGroup.defineHistogram('HtoBCMapC_x,HtoBCMapC_y;hHtoBCMapC',type='TH2F',title='HL in BC: Chips;Bunch Crossing ID;Chip Number in Stack',path=oss,xbins=3,xmin=0,xmax=3,ybins=iChipMax[ibe],ymin=0,ymax=iChipMax[ibe])
+            rdoStackGroup.defineHistogram('HtoBCMapC_x,chipNumber;hHtoBCMapC',cutmask='HtoBCMap_cut',type='TH2F',title='HL in BC: Chips;Bunch Crossing ID;Chip Number in Stack',path=oss,xbins=3,xmin=0,xmax=3,ybins=iChipMax[ibe],ymin=0,ymax=iChipMax[ibe])
 
-            if   ibe == 0: rdoStackGroup.defineHistogram('HtoBCMapB_x,HtoBCMapB_y;hHtoBCMapB',type='TH2F',title='HL in BC: Boards;Bunch Crossing ID;Board Number in Stack',path=oss,xbins=3,xmin=0,xmax=3,ybins=9,ymin=0,ymax=9)
-            elif ibe == 1: rdoStackGroup.defineHistogram('HtoBCMapB_x,HtoBCMapB_y;hHtoBCMapB',type='TH2F',title='HL in BC: Boards;Bunch Crossing ID;Board Number in Stack',path=oss,xbins=3,xmin=0,xmax=3,ybins=20,ymin=-0.5,ymax=19.5)
+            if   ibe == 0: rdoStackGroup.defineHistogram('HtoBCMapB_x,HtoBCMapB_y;hHtoBCMapB',cutmask='HtoBCMap_cut',type='TH2F',title='HL in BC: Boards;Bunch Crossing ID;Board Number in Stack',path=oss,xbins=3,xmin=0,xmax=3,ybins=9,ymin=0,ymax=9)
+            elif ibe == 1: rdoStackGroup.defineHistogram('HtoBCMapB_x,HtoBCMapB_y;hHtoBCMapB',cutmask='HtoBCMap_cut',type='TH2F',title='HL in BC: Boards;Bunch Crossing ID;Board Number in Stack',path=oss,xbins=3,xmin=0,xmax=3,ybins=20,ymin=-0.5,ymax=19.5)
 
     ### Registering Collisions Histograms ###
     rdoShiftSmryGroup = helper.addGroup(algTRTMonitoringRun3RAW,'RDOShiftSmryHistograms')
@@ -109,15 +109,15 @@ def TRTMonitoringRun3RAW_AlgConfig(inputFlags):
         rdoGroup = helper.addGroup(algTRTMonitoringRun3RAW,'RDOHistograms{0}'.format(ibe))
         rdoGroup.defineHistogram('BCIDvsOcc_x,BCIDvsOcc_y;hBCIDvsOcc',type='TProfile',title='Avg. Occupancy vs BCID{0};Bunch Crossing ID;Occupancy'.format(regionTag),path='TRT/{0}/Expert'.format(barrelOrEndcap[ibe]),xbins=3564,xmin=0,xmax=3564)
         if ibe == 0:
-            rdoGroup.defineHistogram('HitWMap_passed,HitWMap;hHitWMap',type='TEfficiency',title='Leading Edge in Time Window: Xenon Straws (Barrel);Straw Number in Stack;Probability',path='TRT/Shift/{0}'.format(str(barrelOrEndcap[ibe])),xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-            rdoGroup.defineHistogram('HitWMap_Ar_passed,HitWMap_Ar;hHitWMap_Ar',type='TEfficiency',title='Leading Edge in Time Window: Argon Straws (Barrel);Straw Number in Stack;Probability',path='TRT/Shift/{0}'.format(barrelOrEndcap[ibe]),xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoGroup.defineHistogram('HitWMap_passed,strawNumber;hHitWMap',cutmask='isNotAr',type='TEfficiency',title='Leading Edge in Time Window: Xenon Straws (Barrel);Straw Number in Stack;Probability',path='TRT/Shift/{0}'.format(str(barrelOrEndcap[ibe])),xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+            rdoGroup.defineHistogram('HitWMap_passed,strawNumber;hHitWMap_Ar',cutmask='isAr',type='TEfficiency',title='Leading Edge in Time Window: Argon Straws (Barrel);Straw Number in Stack;Probability',path='TRT/Shift/{0}'.format(barrelOrEndcap[ibe]),xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
             rdoGroup.defineHistogram('OccAll;hOccAll',type='TH1F',title='Occupancy per Event;Occupancy;Events',path='TRT/Shift/{0}'.format(barrelOrEndcap[ibe]),xbins=400,xmin=0.0,xmax=1.0)
         elif ibe == 1:
             for iside in range(2):
                 side = ('A', 'C')
                 rdoEndcapGroup = helper.addGroup(algTRTMonitoringRun3RAW,'RDOHistograms1{0}'.format(iside))
-                rdoEndcapGroup.defineHistogram('HitWMap_passed,HitWMap;hHitWMap_{0}'.format(side[iside]),type='TEfficiency',title='Leading Edge in Time Window: Xenon Straws (E{0});Straw Number in Stack;Probability'.format(side[iside]),path='TRT/Shift/{0}'.format(barrelOrEndcap[ibe]),xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
-                rdoEndcapGroup.defineHistogram('HitWMap_Ar_passed,HitWMap_Ar;hHitWMap_Ar_{0}'.format(side[iside]),type='TEfficiency',title='Leading Edge in Time Window: Argon Straws (E{0});Straw Number in Stack;Probability'.format(side[iside]),path='TRT/Shift/{0}'.format(barrelOrEndcap[ibe]),xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])   
+                rdoEndcapGroup.defineHistogram('HitWMap_passed,strawNumber;hHitWMap_{0}'.format(side[iside]),cutmask='isNotAr',type='TEfficiency',title='Leading Edge in Time Window: Xenon Straws (E{0});Straw Number in Stack;Probability'.format(side[iside]),path='TRT/Shift/{0}'.format(barrelOrEndcap[ibe]),xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])
+                rdoEndcapGroup.defineHistogram('HitWMap_passed,strawNumber;hHitWMap_Ar_{0}'.format(side[iside]),cutmask='isAr',type='TEfficiency',title='Leading Edge in Time Window: Argon Straws (E{0});Straw Number in Stack;Probability'.format(side[iside]),path='TRT/Shift/{0}'.format(barrelOrEndcap[ibe]),xbins=strawMax[ibe],xmin=0,xmax=strawMax[ibe])   
         for iside in range(2):
             regionTag = ' (' + beId[ibe] + sideId[iside] + ')'
             regionMarker = (beId[ibe] + sideId[iside]) if isOnline is True else (sideId[iside])

MuonSpectrometer/MuonReconstruction/MuonRecExample/CMakeLists.txt

@@ -6,6 +6,6 @@
 atlas_subdir( MuonRecExample )
 
 # Install files from the package:
-atlas_install_python_modules( python/*.py )
+atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} )
 atlas_install_joboptions( share/*.py )
 

MuonSpectrometer/MuonReconstruction/MuonRecExample/python/ConfiguredMuonRec.py

@@ -6,7 +6,6 @@ __all__ = [ 'ConfiguredMuonRec', 'GetMuonRec', 'CompositeMuonRec' ]
 import os
 
 from AthenaCommon.AlgSequence import AlgSequence
-from AthenaCommon.AppMgr import ToolSvc
 from AthenaCommon.ConfigurableDb import getConfigurable
 from AthenaCommon.Logging import logging
 
@@ -172,7 +171,7 @@ class ConfiguredMuonRec(object):
         if gaudiType != 'Algorithm':        
             raise TypeError( '%r is not an Algorithm, but an %s' % (alg,gaudiType) )
         # add to local dictionary
-        if not alg in self._algs:
+        if alg not in self._algs:
             self._algs.append( alg )
             # add to own dict for direct access: self.AlgName
             self.__dict__[ alg.getName() ] = alg
@@ -309,14 +308,14 @@ class ConfiguredMuonRec(object):
 
     def outputKey(self,name):
         """Return value of output key"""
-        return self_.outputKeys[name]
+        return self._outputKeys[name]
 
     def hasOutputKey(self,name):
         return name in self._outputKeys
 
     def inputKey(self,name):
         """Return value of output key"""
-        return self_.inputKeys[name]
+        return self._inputKeys[name]
 
     def hasInputKey(self,name):
         return name in self._inputKeys
@@ -389,6 +388,7 @@ class ConfiguredMuonRec(object):
         """Add all algorithms to topSequence, if not already in.
         Only needs to be called if it was disabled in the first place, but want to use anyway.
         BEWARE: as this adds to the end of topSequence, total order in topSequence may not be correct!!!"""
+        global topSequence
         self._enabled = True
         for alg in self._algs:
             if not hasattr(topSequence,alg.getName()):
@@ -568,7 +568,7 @@ class CompositeMuonRec(ConfiguredMuonRec):
     def propagateDataKeys(self,keys=None):
         """Propagate the date keys to the registered properties"""
         if keys is None: keys = self.dataKeys()
-        ConfigurableMuonRec.propagateDataKeys(self,keys)
+        ConfiguredMuonRec.propagateDataKeys(self,keys)
         for c in self.allConfigs():
             c.propagateDataKeys(keys)
 
@@ -707,7 +707,7 @@ class ParallelMuonRec(CompositeMuonRec):
         for c in self.allConfigs():
             try:
                 c.configure(keys)
-            except:
+            except Exception:
                 if self._applyResilience:
                    import traceback
                    traceback.print_exc()
@@ -781,7 +781,7 @@ def GetMuonRec(configTag,doConfigure=True,applyResilience=False, **kwargs):
             # store for later reference ('singleton')
             _muonRecInstances[configInfo.fullTag] = theInstance
             return theInstance
-        except:
+        except Exception:
             if applyResilience:
                 import traceback
                 traceback.print_exc()

MuonSpectrometer/MuonReconstruction/MuonRecExample/python/CscTools.py

-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 
 __doc__ = """Configuration of tools for CSC reconstruction"""
 
@@ -10,29 +10,14 @@ __doc__ = """Configuration of tools for CSC reconstruction"""
 from AthenaCommon.Logging import logging
 logging.getLogger().info("Importing %s", __name__)
 
-import copy
-
-from AthenaCommon.AppMgr import ServiceMgr,ToolSvc
 from AthenaCommon.GlobalFlags import globalflags
 from AthenaCommon.BeamFlags import jobproperties
 beamFlags = jobproperties.Beam
 from AthenaCommon import CfgMgr
+from AthenaCommon.CfgGetter import getPublicTool, getPrivateTool
 
-from RecExConfig.RecFlags import rec
-
-from AthenaCommon.CfgGetter import getPrivateTool,getPrivateToolClone,getPublicTool,getPublicToolClone,getService,getServiceClone
-
-from AthenaCommon.ConfiguredFactory import getProperty
-
-from MuonRecExample.MuonRecUtils import logMuon,ConfiguredBase,ExtraFlags
 from MuonRecExample.MuonAlignFlags import muonAlignFlags
 
-from AthenaCommon.CfgGetter import addTool, addToolClone, addService, addAlgorithm, \
-     addTypesToExcludeIfDefaultValue, addNamesToExcludeIfDefaultValue, addFullNamesToExcludeIfDefaultValue, \
-     addPropertiesToExcludeIfDefault, \
-     addTypesToSkipIfNotAvailable, addNamesToSkipIfNotAvailable, addFullNamesToSkipIfNotAvailable, \
-     addTypesOnlyToSkip
-
 
 def CscAlignmentTool(name="CscAlignmentTool",extraFlags=None,**kwargs):
     etaposAlignConsts = [ # 1st, 2nd, 3rd, 4th layer 

MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MooreTools.py

-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 
 __doc__ = """Configuration of tools for Moore muon reconstruction"""
 
@@ -10,9 +10,7 @@ __doc__ = """Configuration of tools for Moore muon reconstruction"""
 from AthenaCommon.Logging import logging
 logging.getLogger().info("Importing %s", __name__)
 
-import copy
-
-from AthenaCommon.AppMgr import ServiceMgr,ToolSvc
+from AthenaCommon.AppMgr import ServiceMgr
 from AthenaCommon.GlobalFlags import globalflags
 from AthenaCommon.BeamFlags import jobproperties
 beamFlags = jobproperties.Beam
@@ -20,17 +18,15 @@ from AthenaCommon.BFieldFlags import jobproperties
 from AthenaCommon import CfgMgr
 from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
 
-from RecExConfig.RecFlags import rec
-
-from AthenaCommon.CfgGetter import getPrivateTool,getPrivateToolClone,getPublicTool,getPublicToolClone,getService,getServiceClone
+from AthenaCommon.CfgGetter import getPublicTool, getPublicToolClone, getPrivateTool
 
 from AthenaCommon.ConfiguredFactory import getProperty
 from IOVDbSvc.CondDB import conddb
 
 from MuonCnvExample.MuonCnvUtils import mdtCalibWindowNumber
 
-from .MuonRecTools import MuonExtrapolator, MuonChi2TrackFitter, MdtDriftCircleOnTrackCreator, MuonRK_Propagator
-from .MuonRecUtils import logMuon,ConfiguredBase,ExtraFlags
+from .MuonRecTools import MuonExtrapolator, MuonChi2TrackFitter
+from .MuonRecUtils import ConfiguredBase,ExtraFlags
 
 
 from .MuonRecFlags import muonRecFlags
@@ -258,7 +254,7 @@ def MooTrackBuilder(name="MooTrackBuilderTemplate",
         newMatchingToolName = namePrefix+oldMatchingToolName+namePostfix
         builder.CandidateMatchingTool = getPublicToolClone(newMatchingToolName,oldMatchingToolName,extraFlags=extraFlags)
 
-    import MuonCombinedRecExample.CombinedMuonTrackSummary
+    import MuonCombinedRecExample.CombinedMuonTrackSummary  # noqa: F401
     from AthenaCommon.AppMgr import ToolSvc
     kwargs.setdefault("TrackSummaryTool", ToolSvc.CombinedMuonTrackSummary)