Calorimeter/CaloExample/CaloRecEx/share/CaloRecOutputItemList_jobOptions.py

@@ -110,7 +110,8 @@ AODMoments=[#"LATERAL"
             ,"EM_PROBABILITY"
             #,"PTD"
             ,"BadChannelList"
-            ,#"LATERAL"
+            #,"LATERAL"
+            ,"SECOND_TIME"
             ]
 
 if jobproperties.CaloRecFlags.doExtendedClusterMoments.get_Value():
@@ -215,8 +216,6 @@ if jobproperties.CaloRecFlags.doCaloFwdTopoTower.get_Value():
          AuxListItem+="."+moment
     CaloClusterItemList+=[AuxListItem]
 
-
-
 CaloAODList+=CaloClusterItemList
 
 # E4' cells

Calorimeter/CaloLocalHadCalib/share/GetH6LCSinglePionsPerf_cbt.py

@@ -126,17 +126,6 @@ if doTopoClusterAgain:
                                                              "TileExt0", "TileExt1", "TileExt2",
                                                              "TileGap1", "TileGap2", "TileGap3",
                                                              "FCAL0", "FCAL1"] 
-  # simple noise tool
-  SimpleNoiseFile = "sigmas_all.dat"
-  from CaloTools.CaloToolsConf import SimpleNoiseToolFromTextFile
-  SimpleNoiseTool = SimpleNoiseToolFromTextFile("SimpleNoiseTool")
-  SimpleNoiseTool.CellNoiseFileName = SimpleNoiseFile
-  ToolSvc += SimpleNoiseTool
-
-  topSequence.CaloTopoCluster.TopoMaker.CaloNoiseTool           = SimpleNoiseTool
-  topSequence.CaloTopoCluster.LocalCalib.LCWeight.CaloNoiseTool = SimpleNoiseTool
-  topSequence.CaloTopoCluster.DMCalib.LCDeadMaterial.CaloNoiseTool = SimpleNoiseTool
-
   # remove annoying BadChannel tool
   tlist=[]
   for x in topSequence.CaloTopoCluster.ClusterCorrectionTools:

Calorimeter/CaloLocalHadCalib/share/cl_w_ooc_H6.py

@@ -142,16 +142,6 @@ if doTopoClusterAgain:
                                                              "TileExt0", "TileExt1", "TileExt2",
                                                              "TileGap1", "TileGap2", "TileGap3",
                                                              "FCAL0", "FCAL1"] 
-  # simple noise tool
-  SimpleNoiseFile = "sigmas_ave.dat"
-  from CaloTools.CaloToolsConf import SimpleNoiseToolFromTextFile
-  SimpleNoiseTool = SimpleNoiseToolFromTextFile("SimpleNoiseTool")
-  SimpleNoiseTool.CellNoiseFileName = SimpleNoiseFile
-  ToolSvc += SimpleNoiseTool
-
-  topSequence.CaloTopoCluster.TopoMaker.CaloNoiseTool           = SimpleNoiseTool
-  topSequence.CaloTopoCluster.LocalCalib.LCWeight.CaloNoiseTool = SimpleNoiseTool
-  topSequence.CaloTopoCluster.DMCalib.LCDeadMaterial.CaloNoiseTool = SimpleNoiseTool
 
   # remove annoying BadChannel tool
   tlist=[]

Calorimeter/CaloLocalHadCalib/share/deadmaterialtree_ctb.py

@@ -137,16 +137,6 @@ if doTopoClusterAgain:
                                                              "TileExt0", "TileExt1", "TileExt2",
                                                              "TileGap1", "TileGap2", "TileGap3",
                                                              "FCAL0", "FCAL1"] 
-  # simple noise tool
-  SimpleNoiseFile = "sigmas_ave.dat"
-  from CaloTools.CaloToolsConf import SimpleNoiseToolFromTextFile
-  SimpleNoiseTool = SimpleNoiseToolFromTextFile("SimpleNoiseTool")
-  SimpleNoiseTool.CellNoiseFileName = SimpleNoiseFile
-  ToolSvc += SimpleNoiseTool
-
-  topSequence.CaloTopoCluster.TopoMaker.CaloNoiseTool           = SimpleNoiseTool
-  topSequence.CaloTopoCluster.LocalCalib.LCWeight.CaloNoiseTool = SimpleNoiseTool
-  topSequence.CaloTopoCluster.DMCalib.LCDeadMaterial.CaloNoiseTool = SimpleNoiseTool
 
   # remove annoying BadChannel tool
   tlist=[]

Calorimeter/CaloRec/python/CaloClusterTopoGetter.py

@@ -234,7 +234,7 @@ class CaloClusterTopoGetter ( Configured )  :
                                     ,"AVG_TILE_Q"
                                     ,"PTD"
                                     ,"MASS"
-                                    ,"EM_PROBABILITY"
+                                    ,"SECOND_TIME"
                                     ]
 
         doDigiTruthFlag = False

Calorimeter/CaloRec/python/CaloTopoClusterConfig.py

-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
 from AthenaConfiguration.ComponentFactory import CompFactory
@@ -135,6 +135,7 @@ def getTopoMoments(configFlags):
                                 ,"AVG_TILE_Q"
                                 ,"PTD"
                                 ,"MASS"
+                                , "SECOND_TIME"
                                 ]
 
     # Disable for now, as broken on MC

Calorimeter/CaloRec/python/MakeTowersFromClusters.py

@@ -24,6 +24,7 @@ def TowersFromClustersDict(clusterBuilderName       = 'TowerFromClusterTool',
                            cellEnergyThreshold      = 0.,
                            applyLCW                 = False,
                            buildCombinedSignal      = False,
+                           removeSamplingData       = True,
                            clusterRange             = 5.):
     ''' Configuration dictionary for tower-to-cluster converter 
     '''
@@ -38,7 +39,8 @@ def TowersFromClustersDict(clusterBuilderName       = 'TowerFromClusterTool',
                    'PrepareLCW'                  : applyLCW,                   ### (control) prepare (and apply) LCW
                    'DoCellIndexCheck'            : doCellIndexCheck,           ### (control) check cell hash indices
                    'BuildCombinedTopoSignal'     : buildCombinedSignal,        ### (control) build combined topo-cluster/topo-tower container
-                   'TopoClusterRange'            : clusterRange,               ### (control) range for topo-cluster in combined mode 
+                   'TopoClusterRange'            : clusterRange,               ### (control) range for topo-cluster in combined mode
+                   'RemoveSamplingData'          : removeSamplingData,         ### (control) remove all sampling data from tower
                    }
     return configDict
 
@@ -146,15 +148,15 @@ def MakeTowersFromClusters(towerMakerName      = 'CaloTowerBuilderAlg',        #
     clusterMoments.TwoGaussianNoise = jobproperties.CaloTopoClusterFlags.doTwoGaussianNoise()
     clusterMoments.MinBadLArQuality = 4000
     clusterMoments.MomentsNames     = [
-        "CENTER_LAMBDA", 
-        #"CENTER_MAG",
+        # "CENTER_LAMBDA", 
+        # "CENTER_MAG",
         "LONGITUDINAL",
-        #"FIRST_ENG_DENS",
-        #"ENG_FRAC_MAX",
+        # "FIRST_ENG_DENS",
+        # "ENG_FRAC_MAX",
         "ENG_FRAC_EM",
-        #"PTD",
+        # "PTD",
         "SIGNIFICANCE",
-        "ENG_POS"
+        # "ENG_POS",
     ]
 
     from IOVDbSvc.CondDB import conddb

Calorimeter/CaloRec/share/CaloTopoSignalFragment.py

@@ -58,7 +58,7 @@ caloTowerMerger.TopoClusterRange        = caloTowerDict['TopoClusterRange']
 caloTowerMerger.TopoClusterContainerKey = caloTowerDict['CaloTopoClusterContainerKey']             #### caloTowerAlgo.CaloFwdTopoTowerBuilder.CaloTopoClusterContainerKey
 caloTowerMerger.TopoTowerContainerKey   = caloTowerAlgo.TowersOutputName
 caloTowerMerger.TopoSignalContainerKey  = 'CaloCalTopoSignals'
-caloTowerMerger.OutputLevel             = Lvl.DEBUG
+## caloTowerMerger.OutputLevel             = Lvl.DEBUG
 
 topSequence+=caloTowerAlgo
 topSequence+=caloTowerMerger

Calorimeter/CaloRec/src/CaloClusterMomentsMaker.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 //-----------------------------------------------------------------------
@@ -12,6 +12,7 @@
 //
 // Author List:
 //      Sven Menke
+//      Peter Loch
 //
 //-----------------------------------------------------------------------
 
@@ -39,78 +40,98 @@
 #include <limits>
 #include <sstream>
 
+#include <map>
+#include <string>
+#include <cstdio>
+
 using CLHEP::deg;
 using CLHEP::cm;
 
 
+// Known moments
 namespace {
-
-
-  //FIXME, somehow make sure these names are in sync with the xAOD variable names
-struct MomentName
-{
-  const char* name;
-  xAOD::CaloCluster::MomentType mom;
-};
-
-
-// Must be sorted by name.
-MomentName moment_names[] = {
-  { "AVG_LAR_Q",         xAOD::CaloCluster::AVG_LAR_Q },
-  { "AVG_TILE_Q",        xAOD::CaloCluster::AVG_TILE_Q },
-  { "BADLARQ_FRAC",      xAOD::CaloCluster::BADLARQ_FRAC },
-  { "BAD_CELLS_CORR_E",  xAOD::CaloCluster::BAD_CELLS_CORR_E },
-  { "CELL_SIGNIFICANCE", xAOD::CaloCluster::CELL_SIGNIFICANCE },
-  { "CELL_SIG_SAMPLING", xAOD::CaloCluster::CELL_SIG_SAMPLING },
-  { "CENTER_LAMBDA",     xAOD::CaloCluster::CENTER_LAMBDA },
-  { "CENTER_MAG",        xAOD::CaloCluster::CENTER_MAG },
-  { "CENTER_X",          xAOD::CaloCluster::CENTER_X },
-  { "CENTER_Y",          xAOD::CaloCluster::CENTER_Y },
-  { "CENTER_Z",          xAOD::CaloCluster::CENTER_Z },
-  { "DELTA_ALPHA",       xAOD::CaloCluster::DELTA_ALPHA },
-  { "DELTA_PHI",         xAOD::CaloCluster::DELTA_PHI },
-  { "DELTA_THETA",       xAOD::CaloCluster::DELTA_THETA },
-  { "ENG_BAD_CELLS",     xAOD::CaloCluster::ENG_BAD_CELLS },
-  { "ENG_BAD_HV_CELLS",  xAOD::CaloCluster::ENG_BAD_HV_CELLS },
-  { "ENG_FRAC_CORE",     xAOD::CaloCluster::ENG_FRAC_CORE },
-  { "ENG_FRAC_EM",       xAOD::CaloCluster::ENG_FRAC_EM },
-  { "ENG_FRAC_MAX",      xAOD::CaloCluster::ENG_FRAC_MAX },
-  { "ENG_POS",           xAOD::CaloCluster::ENG_POS },
-  { "FIRST_ENG_DENS",    xAOD::CaloCluster::FIRST_ENG_DENS },
-  { "FIRST_ETA",         xAOD::CaloCluster::FIRST_ETA },
-  { "FIRST_PHI",         xAOD::CaloCluster::FIRST_PHI },
-  { "ISOLATION",         xAOD::CaloCluster::ISOLATION },
-  { "LATERAL",           xAOD::CaloCluster::LATERAL },
-  { "LONGITUDINAL",      xAOD::CaloCluster::LONGITUDINAL },
-  { "MASS",              xAOD::CaloCluster::MASS },
-  { "N_BAD_CELLS",       xAOD::CaloCluster::N_BAD_CELLS },
-  { "N_BAD_HV_CELLS",    xAOD::CaloCluster::N_BAD_HV_CELLS },
-  { "N_BAD_CELLS_CORR",  xAOD::CaloCluster::N_BAD_CELLS_CORR },
-  { "PTD",               xAOD::CaloCluster::PTD },
-  { "SECOND_ENG_DENS",   xAOD::CaloCluster::SECOND_ENG_DENS },
-  { "SECOND_LAMBDA",     xAOD::CaloCluster::SECOND_LAMBDA },
-  { "SECOND_R",          xAOD::CaloCluster::SECOND_R },
-  { "SIGNIFICANCE",      xAOD::CaloCluster::SIGNIFICANCE },
-};
-
-MomentName* moment_names_end =
-  moment_names + sizeof(moment_names)/sizeof(moment_names[0]);
-
-#if 0
-bool operator< (const std::string& v, const MomentName& m)
-{
-  return strcmp (v.c_str(), m.name) < 0;
-}
-#endif
-bool operator< (const MomentName& m, const std::string& v)
-{
-  return strcmp (m.name, v.c_str()) < 0;
-}
-
-
+  // name -> enum translator
+  std::map<std::string,xAOD::CaloCluster::MomentType> momentNameToEnumMap = { 
+    { "AVG_LAR_Q",         xAOD::CaloCluster::AVG_LAR_Q },
+    { "AVG_TILE_Q",        xAOD::CaloCluster::AVG_TILE_Q },
+    { "BADLARQ_FRAC",      xAOD::CaloCluster::BADLARQ_FRAC },
+    { "BAD_CELLS_CORR_E",  xAOD::CaloCluster::BAD_CELLS_CORR_E },
+    { "CELL_SIGNIFICANCE", xAOD::CaloCluster::CELL_SIGNIFICANCE },
+    { "CELL_SIG_SAMPLING", xAOD::CaloCluster::CELL_SIG_SAMPLING },
+    { "CENTER_LAMBDA",     xAOD::CaloCluster::CENTER_LAMBDA },
+    { "CENTER_MAG",        xAOD::CaloCluster::CENTER_MAG },
+    { "CENTER_X",          xAOD::CaloCluster::CENTER_X },
+    { "CENTER_Y",          xAOD::CaloCluster::CENTER_Y },
+    { "CENTER_Z",          xAOD::CaloCluster::CENTER_Z },
+    { "DELTA_ALPHA",       xAOD::CaloCluster::DELTA_ALPHA },
+    { "DELTA_PHI",         xAOD::CaloCluster::DELTA_PHI },
+    { "DELTA_THETA",       xAOD::CaloCluster::DELTA_THETA },
+    { "ENG_BAD_CELLS",     xAOD::CaloCluster::ENG_BAD_CELLS },
+    { "ENG_BAD_HV_CELLS",  xAOD::CaloCluster::ENG_BAD_HV_CELLS },
+    { "ENG_FRAC_CORE",     xAOD::CaloCluster::ENG_FRAC_CORE },
+    { "ENG_FRAC_EM",       xAOD::CaloCluster::ENG_FRAC_EM },
+    { "ENG_FRAC_MAX",      xAOD::CaloCluster::ENG_FRAC_MAX },
+    { "ENG_POS",           xAOD::CaloCluster::ENG_POS },
+    { "FIRST_ENG_DENS",    xAOD::CaloCluster::FIRST_ENG_DENS },
+    { "FIRST_ETA",         xAOD::CaloCluster::FIRST_ETA },
+    { "FIRST_PHI",         xAOD::CaloCluster::FIRST_PHI },
+    { "ISOLATION",         xAOD::CaloCluster::ISOLATION },
+    { "LATERAL",           xAOD::CaloCluster::LATERAL },
+    { "LONGITUDINAL",      xAOD::CaloCluster::LONGITUDINAL },
+    { "MASS",              xAOD::CaloCluster::MASS },
+    { "N_BAD_CELLS",       xAOD::CaloCluster::N_BAD_CELLS },
+    { "N_BAD_HV_CELLS",    xAOD::CaloCluster::N_BAD_HV_CELLS },
+    { "N_BAD_CELLS_CORR",  xAOD::CaloCluster::N_BAD_CELLS_CORR },
+    { "PTD",               xAOD::CaloCluster::PTD },
+    { "SECOND_ENG_DENS",   xAOD::CaloCluster::SECOND_ENG_DENS },
+    { "SECOND_LAMBDA",     xAOD::CaloCluster::SECOND_LAMBDA },
+    { "SECOND_R",          xAOD::CaloCluster::SECOND_R },
+    { "SECOND_TIME",       xAOD::CaloCluster::SECOND_TIME },
+    { "SIGNIFICANCE",      xAOD::CaloCluster::SIGNIFICANCE },
+    { "EM_PROBABILITY",    xAOD::CaloCluster::EM_PROBABILITY }
+  };
+  // enum -> name translator
+  std::map<xAOD::CaloCluster::MomentType,std::string> momentEnumToNameMap = { 
+    { xAOD::CaloCluster::AVG_LAR_Q,          "AVG_LAR_Q"        },
+    { xAOD::CaloCluster::AVG_TILE_Q,         "AVG_TILE_Q"       },
+    { xAOD::CaloCluster::BADLARQ_FRAC,       "BADLARQ_FRAC"     },
+    { xAOD::CaloCluster::BAD_CELLS_CORR_E,   "BAD_CELLS_CORR_E" },
+    { xAOD::CaloCluster::CELL_SIGNIFICANCE,  "CELL_SIGNIFICANCE"},
+    { xAOD::CaloCluster::CELL_SIG_SAMPLING,  "CELL_SIG_SAMPLING"},
+    { xAOD::CaloCluster::CENTER_LAMBDA,      "CENTER_LAMBDA"    },
+    { xAOD::CaloCluster::CENTER_MAG,         "CENTER_MAG"       },
+    { xAOD::CaloCluster::CENTER_X,           "CENTER_X"         },
+    { xAOD::CaloCluster::CENTER_Y,           "CENTER_Y"         },
+    { xAOD::CaloCluster::CENTER_Z,           "CENTER_Z"         },
+    { xAOD::CaloCluster::DELTA_ALPHA,        "DELTA_ALPHA"      },
+    { xAOD::CaloCluster::DELTA_PHI,          "DELTA_PHI"        },
+    { xAOD::CaloCluster::DELTA_THETA,        "DELTA_THETA"      },
+    { xAOD::CaloCluster::ENG_BAD_CELLS,      "ENG_BAD_CELLS"    },
+    { xAOD::CaloCluster::ENG_BAD_HV_CELLS,   "ENG_BAD_HV_CELLS" },
+    { xAOD::CaloCluster::ENG_FRAC_CORE,      "ENG_FRAC_CORE"    },
+    { xAOD::CaloCluster::ENG_FRAC_EM,        "ENG_FRAC_EM"      },
+    { xAOD::CaloCluster::ENG_FRAC_MAX,       "ENG_FRAC_MAX"     },
+    { xAOD::CaloCluster::ENG_POS,            "ENG_POS"          },
+    { xAOD::CaloCluster::FIRST_ENG_DENS,     "FIRST_ENG_DENS"   },
+    { xAOD::CaloCluster::FIRST_ETA,          "FIRST_ETA"        },
+    { xAOD::CaloCluster::FIRST_PHI,          "FIRST_PHI"        },
+    { xAOD::CaloCluster::ISOLATION,          "ISOLATION"        },
+    { xAOD::CaloCluster::LATERAL,            "LATERAL"          },
+    { xAOD::CaloCluster::LONGITUDINAL,       "LONGITUDINAL"     },
+    { xAOD::CaloCluster::MASS,               "MASS"             },
+    { xAOD::CaloCluster::N_BAD_CELLS,        "N_BAD_CELLS"      },
+    { xAOD::CaloCluster::N_BAD_HV_CELLS,     "N_BAD_HV_CELLS"   },
+    { xAOD::CaloCluster::N_BAD_CELLS_CORR,   "N_BAD_CELLS_CORR" },
+    { xAOD::CaloCluster::PTD,                "PTD"              },
+    { xAOD::CaloCluster::SECOND_ENG_DENS,    "SECOND_ENG_DENS"  },
+    { xAOD::CaloCluster::SECOND_LAMBDA,      "SECOND_LAMBDA"    },
+    { xAOD::CaloCluster::SECOND_R,           "SECOND_R"         },
+    { xAOD::CaloCluster::SECOND_TIME,        "SECOND_TIME"      },
+    { xAOD::CaloCluster::SIGNIFICANCE,       "SIGNIFICANCE"     },
+    { xAOD::CaloCluster::EM_PROBABILITY,     "EM_PROBABILITY"   }
+  };
 }
 
-
 //###############################################################################
 
 CaloClusterMomentsMaker::CaloClusterMomentsMaker(const std::string& type, 
@@ -134,117 +155,102 @@ CaloClusterMomentsMaker::CaloClusterMomentsMaker(const std::string& type,
   // Name(s) of Moments to calculate
   declareProperty("MomentsNames",m_momentsNames);
 
-  // Name(s) of Moments which can be stored on the AOD - all others go to ESD
-  // m_momentsNamesAOD.push_back(std::string("FIRST_PHI"));
-  // m_momentsNamesAOD.push_back(std::string("FIRST_ETA"));
-  // m_momentsNamesAOD.push_back(std::string("SECOND_R"));
-  // m_momentsNamesAOD.push_back(std::string("SECOND_LAMBDA"));
-  // m_momentsNamesAOD.push_back(std::string("CENTER_LAMBDA"));
-  // m_momentsNamesAOD.push_back(std::string("FIRST_ENG_DENS"));
-  // m_momentsNamesAOD.push_back(std::string("ENG_BAD_CELLS"));
-  // m_momentsNamesAOD.push_back(std::string("N_BAD_CELLS"));
-
-  //declareProperty("AODMomentsNames",m_momentsNamesAOD);
-  // maximum allowed angle between shower axis and the vector pointing
-  // to the shower center from the IP in degrees. This property is need
+  // Maximum allowed angle between shower axis and the vector pointing
+  // to the shower center from the IP in degrees. This property is needed
   // to protect against cases where all significant cells are in one sampling
-  // and the shower axis can not be defined from them
+  // and the shower axis can thus not be defined.
   declareProperty("MaxAxisAngle",m_maxAxisAngle);
   declareProperty("MinRLateral",m_minRLateral);
   declareProperty("MinLLongitudinal",m_minLLongitudinal);
   declareProperty("MinBadLArQuality",m_minBadLArQuality);
-  // use 2-gaussian noise for Tile
+  // Use 2-gaussian noise for Tile
   declareProperty("TwoGaussianNoise",m_twoGaussianNoise);
   declareProperty("LArHVFraction",m_larHVFraction,"Tool Handle for LArHVFraction");
-
-  /// Not used anymore (with xAOD), but required when configured from  COOL.
+  // Not used anymore (with xAOD), but required when configured from  COOL.
   declareProperty("AODMomentsNames",m_momentsNamesAOD);
   // Use weighting of neg. clusters option?
   declareProperty("WeightingOfNegClusters", m_absOpt);
-
 }
 
 //###############################################################################
 
 StatusCode CaloClusterMomentsMaker::initialize()
 {
-  m_calculateSignificance = false;
-  m_calculateIsolation = false;
-
-  // translate all moment names specified in MomentsNames property to moment enums,
-  // check that they are all valid and there are no repeating names
-  for(const auto& name: m_momentsNames) {
-    const MomentName* it =
-      std::lower_bound (moment_names, moment_names_end, name);
-    if (it != moment_names_end) {
-      m_validMoments.push_back (it->mom);
-      switch (it->mom) {
-      case xAOD::CaloCluster::SIGNIFICANCE:
-      case xAOD::CaloCluster::CELL_SIGNIFICANCE:
-        m_calculateSignificance = true;
-        break;
-      case xAOD::CaloCluster::ISOLATION:
-        m_calculateIsolation = true;
-        break;
-      case xAOD::CaloCluster::ENG_BAD_HV_CELLS:
-        m_calculateLArHVFraction = true;
-      default:
-        break;
-      }
-    }
-    else {
-      msg(MSG::ERROR) << "Moment " << name
-		      << " is not a valid Moment name and will be ignored! "
-		      << "Valid names are:";
-      int count = 0;
-      for (const MomentName& m : moment_names)
-	msg() << ((count++)==0?" ":", ") << m.name;
-      msg() << endmsg;
-    }
-  }
-
+  // loop list of requested moments
+  std::string::size_type nstr(0); int nmom(0); 
+  for ( const auto& mom : m_momentsNames ) {
+    // check if moment is known (enumerator available)
+    auto fmap(momentNameToEnumMap.find(mom)); 
+    if ( fmap != momentNameToEnumMap.end() ) {
+      // valid moment found 
+      nstr = std::max(nstr,mom.length()); ++nmom;
+      if ( fmap->second == xAOD::CaloCluster::SECOND_TIME ) {
+	// special flag for second moment of cell times - this moment is not 
+	// calculated in this tool! Do not add to internal (!) valid moments list. 
+	// Its value is available from xAOD::CaloCluster::secondTime()!
+	m_secondTime = true;
+      } else if ( fmap->second == xAOD::CaloCluster::EM_PROBABILITY ) {
+	ATH_MSG_WARNING( mom << " not calculated in this tool - misconfiguration?" );
+      } else {  
+	// all other valid moments
+	m_validMoments.push_back(fmap->second);
+	// flag some special requests 
+	switch (fmap->second) { 
+	case xAOD::CaloCluster::SIGNIFICANCE:
+	case xAOD::CaloCluster::CELL_SIGNIFICANCE:
+	  m_calculateSignificance = true; 
+	  break;
+	case xAOD::CaloCluster::ISOLATION:
+	  m_calculateIsolation = true;
+	  break;
+	case xAOD::CaloCluster::ENG_BAD_HV_CELLS:
+	  m_calculateLArHVFraction = true;
+	default:
+	  break;
+	} // set special processing flags
+      } // moment calculated with this tool
+    } else { 
+      ATH_MSG_ERROR( "Moment name " << mom << " not known; known moments are:" );
+      char buffer[128]; std::string::size_type lstr(nstr); 
+      // determine field size
+      for ( auto fmom : momentNameToEnumMap ) { lstr = std::max(lstr,fmom.first.length()); } 
+      // print available moments
+      for ( auto fmom : momentNameToEnumMap ) { 
+	sprintf(buffer,"moment name: %-*.*s - enumerator: %i",(int)lstr,(int)lstr,fmom.first.c_str(),(int)fmom.second); 
+	ATH_MSG_INFO(buffer);
+      } 
+      return StatusCode::FAILURE;
+    } // found unknown moment name
+  } // loop configured moment names
   
-  // sort and remove duplicates, order is not required for any of the code below
-  // but still may be useful property
+  // sort and remove duplicates
   std::sort(m_validMoments.begin(), m_validMoments.end());
-  m_validMoments.erase(std::unique(m_validMoments.begin(),
-                                   m_validMoments.end()),
-                       m_validMoments.end());
-
-  
-  /*
-  // translate moment names in AODMomentsNames property into set of enums,
-  // only take valid names which are also in MomentsNames property
-  m_momentsAOD.reserve(m_momentsNamesAOD.size());
-  for(const auto& name: m_momentsNamesAOD) {
-    const MomentName* it =
-      std::lower_bound (moment_names, moment_names_end, name);
-    if (it != moment_names_end) {
-      if (std::find(m_validMoments.begin(), m_validMoments.end(), it->mom)
-          != m_validMoments.end())
-      {
-        m_momentsAOD.push_back(it->mom);
-      }
-    }
+  m_validMoments.erase(std::unique(m_validMoments.begin(),m_validMoments.end()),m_validMoments.end());
+   
+  // print configured moments
+  ATH_MSG_INFO( "Construct and save " << nmom << " cluster moments: " );
+  char buffer[128];
+  for ( auto menum : m_validMoments ) { 
+    sprintf(buffer,"moment name: %-*.*s - enumerator: %i",(int)nstr,(int)nstr,momentEnumToNameMap.at(menum).c_str(),(int)menum); 
+    ATH_MSG_INFO( buffer );
   }
-  */
-  
+  if ( m_secondTime ) { 
+    auto fmom(momentNameToEnumMap.find("SECOND_TIME"));
+    sprintf(buffer,"moment name: %-*.*s - enumerator: %i (save only)",(int)nstr,(int)nstr,fmom->first.c_str(),(int)fmom->second);
+    ATH_MSG_INFO( buffer );
+  }
+
+  // retrieve CaloCell ID server  
   CHECK(detStore()->retrieve(m_calo_id,"CaloCell_ID"));
   
+  // retrieve the calo depth tool
   CHECK(m_caloDepthTool.retrieve());
 
-  if (m_calculateSignificance) { 
-    ATH_CHECK(m_noiseCDOKey.initialize());
-  }
+  // retrieve specific servers and tools for selected processes
+  if (m_calculateSignificance)  { ATH_CHECK(m_noiseCDOKey.initialize()); }
+  if (m_calculateLArHVFraction) { ATH_CHECK(m_larHVFraction.retrieve()); } else { m_larHVFraction.disable(); }
 
-  if (m_calculateLArHVFraction) { 
-    ATH_CHECK(m_larHVFraction.retrieve());
-  }
-  else {
-    m_larHVFraction.disable();
-  }
   return StatusCode::SUCCESS;
-  
 }
 
 StatusCode CaloClusterMomentsMaker::finalize()
@@ -256,6 +262,7 @@ StatusCode CaloClusterMomentsMaker::finalize()
 
 namespace CaloClusterMomentsMaker_detail {
 
+
 struct cellinfo {
   double x;
   double y;
@@ -903,7 +910,7 @@ CaloClusterMomentsMaker::execute(const EventContext& ctx,
 	  }
 	}
       }
-      
+
       // normalize moments and copy to Cluster Moment Store
       size_t size= m_validMoments.size();
       for (size_t iMoment = 0; iMoment != size; ++iMoment) {
@@ -913,9 +920,11 @@ CaloClusterMomentsMaker::execute(const EventContext& ctx,
 	if ( moment == xAOD::CaloCluster::FIRST_PHI ) 
 	  myMoments[iMoment] = CaloPhiRange::fix(myMoments[iMoment]);
 	theCluster->insertMoment(moment,myMoments[iMoment]);
-      }
-    }
-  }
+      } // loop on moments for cluster
+    } // check on requested moments
+    // check on second moment of time if requested
+    if ( m_secondTime ) { theCluster->insertMoment(xAOD::CaloCluster::SECOND_TIME,theCluster->secondTime()); }
+  } // loop on clusters
 
   return StatusCode::SUCCESS;
 }

Calorimeter/CaloRec/src/CaloClusterMomentsMaker.h

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 //Dear emacs, this is -*-c++-*-
@@ -8,7 +8,8 @@
 /**
  * @class CaloClusterMomentsMaker
  * @author Sven Menke <menke@mppmu.mpg.de>
- * @date 28-February-2005
+ * @author Peter Loch <loch@physics.arizona.edu>
+ * @date 23-March-2021
  * @brief Calculate moments for CaloCluster objects
  *
  * This is a CaloClusterCollectionProcessor which can be plugged into a
@@ -25,7 +26,10 @@
  * Note that only cells with positive energy are used in this definition.
  * Common variables to calculate first and second moments of are
  * \f$\phi\f$, \f$\eta\f$, and radial and longitudinal distances from
- * the shower axis and the shower center, respectively.  */
+ * the shower axis and the shower center, respectively. 
+ * 
+ * @since 23-March-2021: second moment of cell time distribution is calculated
+ */
 
 #include "GaudiKernel/ToolHandle.h"
 
@@ -133,6 +137,10 @@ class CaloClusterMomentsMaker: public AthAlgTool, virtual public CaloClusterColl
    * @brief if set to true use abs E value of cells to calculate 
    * cluster moments */
    bool m_absOpt;
+
+   /**
+    * @brief Retreive second moment of cell times */
+   bool m_secondTime = { false };
 };
 
 #endif // CALOCLUSTERMOMENTSMAKER_H

Calorimeter/CaloRec/src/CaloTopoTowerFromClusterMaker.cxx

@@ -76,6 +76,7 @@ CaloTopoTowerFromClusterMaker::CaloTopoTowerFromClusterMaker(const std::string&
   declareProperty("DoCellIndexCheck",            m_doCellIndexCheck,                                                                  "Check cell hash indices for consistency");
   declareProperty("BuildCombinedTopoSignal",     m_buildCombinedSignal,                                                               "Build topo-clusters and topo-towers");
   declareProperty("TopoClusterRange",            m_clusterRange,                                                                      "Rapidity range for using topo-clusters in combined signal mode");
+  declareProperty("RemoveSamplingData",          m_removeSamplingData,                                                                "Remove the associated sampling data");
 }
 
 StatusCode CaloTopoTowerFromClusterMaker::initialize()
@@ -183,6 +184,7 @@ StatusCode CaloTopoTowerFromClusterMaker::initialize()
   ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("BuildCombinedTopoSignal .... %s",             blu[m_buildCombinedSignal].c_str())      );
   ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("TopoClusterRange ........... %.2f",           m_clusterRange)                          );
   ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("ExcludedSamplings .......... %zu (number of)",m_excludedSamplingsName.size())          );
+  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("RemoveSamplingData ......... %s",             blu[m_removeSamplingData].c_str())       );
 
   return StatusCode::SUCCESS;
 }
@@ -268,8 +270,11 @@ StatusCode CaloTopoTowerFromClusterMaker::execute(const EventContext& ctx,
       clptr->addCellLink(lptr);                                         // transfer cell links to CaloCluster
       clptr->setClusterSize(csize);                                     // set the cluster size spec
       CaloRec::Helpers::calculateKine(clptr,false);                     // calculate kinematics and other signals from cells
-      clptr->setEta0(m_towerGeometrySvc->towerEta(ipc));                // save the tower center eta
-      clptr->setPhi0(m_towerGeometrySvc->towerPhi(ipc));                // save the tower center phi
+      if ( m_removeSamplingData ) {                                     // remove sampling data and invalidate tower center 
+	clptr->clearSamplingData(); clptr->setEta0(0.);	clptr->setPhi0(0.); 
+      } else {                                                          // keep sampling data and valid tower center
+	clptr->setEta0(m_towerGeometrySvc->towerEta(ipc)); clptr->setPhi0(m_towerGeometrySvc->towerPhi(ipc));              
+      }
     } else {
       delete lptr;
     }

Calorimeter/CaloRec/src/CaloTopoTowerFromClusterMaker.h

@@ -69,6 +69,7 @@ private:
   bool                                          m_buildCombinedSignal = { false  };         ///< Build topo-clusters within given @f$ y @f$ range, else topo-towers
   double                                        m_energyThreshold;                          ///< Cell energy threshold, default is set in @c m_energyThresholdDef
   double                                        m_clusterRange;                             ///< Range where topo-clusters are used when <tt>m_buildCombinedSignal = true</tt>
+  bool                                          m_removeSamplingData = { true };            ///< Remove sampling data for towers
   /// @}
 
   /// @name Constants and parameters

Control/AthenaCommon/python/AtlasThreadedJob.py

@@ -48,15 +48,16 @@ def _setupAtlasThreadedJob():
     topSequence += SGInputLoader (FailIfNoProxy = False)
     AlgScheduler.setDataLoaderAlg ('SGInputLoader' )
 
-    if theApp._opts.mtes :
-        # Multi-threaded Event Service
+    if (theApp._opts.mtes or jps.ConcurrencyFlags.NumProcs()>0):
+        # Either multi-threaded Event Service or hybrid MP+MT
         from AthenaServices.AthenaServicesConf import AthenaMtesEventLoopMgr
         
         svcMgr += AthenaMtesEventLoopMgr()
         svcMgr.AthenaMtesEventLoopMgr.WhiteboardSvc = "EventDataSvc"
         svcMgr.AthenaMtesEventLoopMgr.SchedulerSvc = AlgScheduler.getScheduler().getName()
+
+    if theApp._opts.mtes:
         svcMgr.AthenaMtesEventLoopMgr.EventRangeChannel = theApp._opts.mtes_channel
-        
         theApp.EventLoop = "AthenaMtesEventLoopMgr"
     else:
         from AthenaServices.AthenaServicesConf import AthenaHiveEventLoopMgr

Control/AthenaKernel/AthenaKernel/IHybridProcessorHelper.h

+/*
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ATHENAKERNEL_IHYBRIDPROCESSORHELPER_H
+#define ATHENAKERNEL_IHYBRIDPROCESSORHELPER_H
+
+/**
+ * @file  IHybridProcessorHelper.h
+ * @class IHybridProcessorHelper
+ * @brief Helper interface for implementing hybrid MP+MT.
+          Used by the Hybrid Shared Event Queue Consumer MP tool
+ **/
+
+class IHybridProcessorHelper {
+ public: 
+  virtual void resetAppReturnCode() = 0;
+  virtual void setCurrentEventNum(int num) = 0;
+  virtual bool terminateLoop() = 0;
+  virtual int drainScheduler(int& finishedEvts, bool report) = 0;
+};
+
+#endif

Control/AthenaMP/python/PyComps.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
 #-----Python imports---#
 import os, sys, shutil
@@ -118,12 +118,10 @@ class MpEvtLoopMgr(AthMpEvtLoopMgr):
                                                    ChunkSize=chunk_size) ]
 
             if (self.nThreads >= 1):
+                if(pileup):
+                    raise Exception('Running pileup digitization in mixed MP+MT currently not supported')
                 from AthenaMPTools.AthenaMPToolsConf import SharedHiveEvtQueueConsumer
-                self.Tools += [ SharedHiveEvtQueueConsumer(UseSharedReader=use_shared_reader,
-                                                           UseSharedWriter=use_shared_writer,
-                                                           IsPileup=pileup,
-                                                           IsRoundRobin=(strategy=='RoundRobin'),
-                                                           EventsBeforeFork=events_before_fork,
+                self.Tools += [ SharedHiveEvtQueueConsumer(EventsBeforeFork=events_before_fork,
                                                            Debug=debug_worker)   ]
             else:
                 from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueConsumer

Control/AthenaMPTools/src/SharedHiveEvtQueueConsumer.cxx

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "SharedHiveEvtQueueConsumer.h"
@@ -7,10 +7,8 @@
 #include "AthenaInterprocess/ProcessGroup.h"
 #include "AthenaInterprocess/Incidents.h"
 
-#include "AthenaKernel/IEventSeek.h"
 #include "AthenaKernel/IEvtSelectorSeek.h"
-#include "AthenaKernel/IEventShare.h"
-#include "AthenaKernel/IDataShare.h"
+#include "AthenaKernel/IHybridProcessorHelper.h"
 #include "GaudiKernel/IEvtSelector.h"
 #include "GaudiKernel/IIoComponentMgr.h"
 #include "GaudiKernel/IFileMgr.h"
@@ -40,31 +38,20 @@ namespace SharedHiveEvtQueueConsumer_d {
 }
 
 SharedHiveEvtQueueConsumer::SharedHiveEvtQueueConsumer(const std::string& type
-					       , const std::string& name
-					       , const IInterface* parent)
+						       , const std::string& name
+						       , const IInterface* parent)
   : AthenaMPToolBase(type,name,parent)
-  , m_useSharedReader(false)
-  , m_useSharedWriter(false)
-  , m_isPileup(false)
-  , m_isRoundRobin(false)
   , m_nEventsBeforeFork(0)
   , m_debug(false)
   , m_rankId(-1)
   , m_chronoStatSvc("ChronoStatSvc", name)
-  , m_evtSeek(0)
   , m_evtSelSeek(0)
   , m_evtContext(0)
-  , m_evtShare(0)
-  , m_dataShare(0)
   , m_sharedEventQueue(0)
   , m_sharedRankQueue(0)
 {
   declareInterface<IAthenaMPTool>(this);
 
-  declareProperty("UseSharedReader",m_useSharedReader);
-  declareProperty("UseSharedWriter",m_useSharedWriter);
-  declareProperty("IsPileup",m_isPileup);
-  declareProperty("IsRoundRobin",m_isRoundRobin);
   declareProperty("EventsBeforeFork",m_nEventsBeforeFork);
   declareProperty("Debug", m_debug);
 
@@ -82,60 +69,19 @@ SharedHiveEvtQueueConsumer::~SharedHiveEvtQueueConsumer()
 StatusCode SharedHiveEvtQueueConsumer::initialize()
 {
   ATH_MSG_DEBUG("In initialize");
-  if(m_isPileup) {
-    m_evtProcessor = ServiceHandle<IEventProcessor>("PileUpEventLoopMgr",name());
-    ATH_MSG_INFO("The job running in pileup mode");
-  }
-  else {
-    ATH_MSG_INFO("The job running in non-pileup mode");
-  }
 
   StatusCode sc = AthenaMPToolBase::initialize();
   if(!sc.isSuccess())
     return sc;
 
-  // For pile-up jobs use event loop manager for seeking
-  // otherwise use event selector
-  if(m_isPileup) {
-    m_evtSeek = dynamic_cast<IEventSeek*>(m_evtProcessor.operator->());
-    if(!m_evtSeek) {
-      ATH_MSG_ERROR("Unable to dyn-cast PileUpEventLoopMgr to IEventSeek");
-      return StatusCode::FAILURE;
-    }
-  }
-  else {
-    sc = serviceLocator()->service(m_evtSelName,m_evtSelSeek);
-    if(sc.isFailure() || m_evtSelSeek==0) {
-      ATH_MSG_ERROR("Error retrieving IEvtSelectorSeek");
-      return StatusCode::FAILURE;
-    }
-    ATH_CHECK( evtSelector()->createContext (m_evtContext) );
-  }
-
-  sc = serviceLocator()->service(m_evtSelName,m_evtShare);
-  if(sc.isFailure() || m_evtShare==0) {
-    if(m_useSharedReader) {
-      ATH_MSG_ERROR("Error retrieving IEventShare");
-      return StatusCode::FAILURE;
-    }
-    msg(MSG::INFO) << "Could not retrieve IEventShare" << endmsg;
-  }
-
-  IConversionSvc* cnvSvc = 0;
-  sc = serviceLocator()->service("AthenaPoolCnvSvc",cnvSvc);
-  m_dataShare = dynamic_cast<IDataShare*>(cnvSvc);
-  if(sc.isFailure() || m_dataShare==0) {
-    if(m_useSharedWriter) {
-      msg(MSG::ERROR) << "Error retrieving AthenaPoolCnvSvc " << cnvSvc << endmsg;
-      return StatusCode::FAILURE;
-    }
-  }
-
-  sc = m_chronoStatSvc.retrieve();
-  if (!sc.isSuccess()) {
-    ATH_MSG_ERROR("Cannot get ChronoStatSvc.");
+  sc = serviceLocator()->service(m_evtSelName,m_evtSelSeek);
+  if(sc.isFailure() || m_evtSelSeek==0) {
+    ATH_MSG_ERROR("Error retrieving IEvtSelectorSeek");
     return StatusCode::FAILURE;
   }
+  ATH_CHECK( evtSelector()->createContext (m_evtContext) );
+
+  ATH_CHECK(m_chronoStatSvc.retrieve());
   
   return StatusCode::SUCCESS;
 }
@@ -285,7 +231,6 @@ SharedHiveEvtQueueConsumer::subProcessLogs(std::vector<std::string>& filenames)
 std::unique_ptr<AthenaInterprocess::ScheduledWork>
 SharedHiveEvtQueueConsumer::bootstrap_func()
 {
-
   if (m_debug) {
     ATH_MSG_INFO("Bootstrap worker PID " << getpid() << " - waiting for SIGUSR1");
     sigset_t mask, oldmask;
@@ -369,28 +314,7 @@ SharedHiveEvtQueueConsumer::bootstrap_func()
     return outwork;
 
   ATH_MSG_INFO("File descriptors re-opened in the AthenaMP event worker PID=" << getpid());
-
   
-  // ________________________ Make Shared Reader/Writer Client ________________________
-  if(m_useSharedReader && m_evtShare) {
-    if(!m_evtShare->makeClient(m_rankId).isSuccess()) {
-      ATH_MSG_ERROR("Failed to make the event selector a share client");
-      return outwork;
-    } else {
-      ATH_MSG_DEBUG("Successfully made the event selector a share client");
-    }
-  }
-
-  if(m_useSharedWriter && m_dataShare) {
-    IProperty* propertyServer = dynamic_cast<IProperty*>(m_dataShare);
-    if (propertyServer==0 || propertyServer->setProperty("MakeStreamingToolClient", m_rankId + 1).isFailure()) {
-      ATH_MSG_ERROR("Could not change AthenaPoolCnvSvc MakeClient Property");
-      return outwork;
-    } else {
-      ATH_MSG_DEBUG("Successfully made the conversion service a share client");
-    }
-  }
-
   // ________________________ I/O reinit ________________________
   if(!m_ioMgr->io_reinitialize().isSuccess()) {
     ATH_MSG_ERROR("Failed to reinitialize I/O");
@@ -412,24 +336,6 @@ SharedHiveEvtQueueConsumer::bootstrap_func()
     ATH_MSG_DEBUG("Successfully restarted the event selector");
   }
 
-  // ________________________ Restart background event selectors in pileup jobs ________________________
-  if(m_isPileup) {
-    const std::list<IService*>& service_list = serviceLocator()->getServices();
-    std::list<IService*>::const_iterator itSvc = service_list.begin(),
-      itSvcLast = service_list.end();
-    for(;itSvc!=itSvcLast;++itSvc) {
-      IEvtSelector* evtsel = dynamic_cast<IEvtSelector*>(*itSvc);
-      if(evtsel && (evtsel != m_evtSelector)) {
-	if((*itSvc)->start().isSuccess())
-	  ATH_MSG_DEBUG("Restarted event selector " << (*itSvc)->name());
-	else {
-	  ATH_MSG_ERROR("Failed to restart event selector " << (*itSvc)->name());
-	  return outwork;
-	}
-      }
-    }
-  }
-
   // ________________________ Worker dir: chdir ________________________
   if(chdir(worker_rundir.string().c_str())==-1) {
     ATH_MSG_ERROR("Failed to chdir to " << worker_rundir.string());
@@ -446,14 +352,13 @@ SharedHiveEvtQueueConsumer::bootstrap_func()
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-std::unique_ptr<AthenaInterprocess::ScheduledWork> 
-SharedHiveEvtQueueConsumer::exec_func()
+std::unique_ptr<AthenaInterprocess::ScheduledWork> SharedHiveEvtQueueConsumer::exec_func()
 {
   ATH_MSG_INFO("Exec function in the AthenaMP worker PID=" << getpid());
 
   bool all_ok(true);
 
-  if (! initHive().isSuccess()) {
+  if (!initHive().isSuccess()) {
     ATH_MSG_FATAL("unable to initialize Hive");
     all_ok = false;
   }
@@ -476,141 +381,118 @@ SharedHiveEvtQueueConsumer::exec_func()
     }
   }
 
-
-  // ________________________ This is needed only for PileUp jobs __________________________________
-  // **
-  // If either EventsBeforeFork or SkipEvents is nonzero, first we need to advance the event selector
-  // by EventsBeforeFork+SkipEvents and only after that start seeking on the PileUpEventLoopMgr
-  // **
-  if(m_isPileup && all_ok) {
-    if (!m_evtSelSeek) {
-      StatusCode sc = serviceLocator()->service(m_evtSelName,m_evtSelSeek);
-      if(sc.isFailure() || m_evtSelSeek==0) {
-        ATH_MSG_ERROR("Error retrieving Event Selector with IEvtSelectorSeek interface for PileUp job");
-        all_ok = false;
-      }
-      if (evtSelector()->createContext (m_evtContext).isFailure()) {
-        ATH_MSG_ERROR("Error creating IEventSelector context.");
-        all_ok = false;
-      }
-    }
-    if (all_ok) {
-      if((m_nEventsBeforeFork+skipEvents)
-	 && m_evtSelSeek->seek(*m_evtContext, m_nEventsBeforeFork+skipEvents).isFailure()) {
-	ATH_MSG_ERROR("Unable to seek to " << m_nEventsBeforeFork+skipEvents);    
-	all_ok = false;
-      }
-    }
+  IHybridProcessorHelper* hybridHelper = dynamic_cast<IHybridProcessorHelper*>(m_evtProcessor.get());
+  if(!hybridHelper) {
+    ATH_MSG_FATAL("Failed to acquire IHybridProcessorHelper interface");
+    all_ok = false;
   }
-  // ________________________ This is needed only for PileUp jobs __________________________________
-
+  // Reset the application return code.
+  hybridHelper->resetAppReturnCode();
 
+  int finishedEvts =0;
+  int createdEvts =0;
   long intmask = pow(0x100,sizeof(int))-1; // Mask for decoding event number from the value posted to the queue
-  int nEvt(m_nEventsBeforeFork);
-  int nEventsProcessed(0);
   long evtnumAndChunk(0);
-
-  unsigned evtCounter(0);
+//  unsigned evtCounter(0);
   int evtnum(0), chunkSize(1);
 
-  // For the round robin we need to know the maximum number of events for this job
-  if(m_isRoundRobin) {
-    evtnumAndChunk = 1;
-    while(evtnumAndChunk>0) {
-      if(!m_sharedEventQueue->try_receive_basic<long>(evtnumAndChunk)) {
-        usleep(1000);
-      }
-    }
-    evtnumAndChunk *= -1;
+  ATH_MSG_INFO("Starting loop on events");
+
+  StatusCode sc(StatusCode::SUCCESS,true);
+
+  while(!m_sharedEventQueue->try_receive_basic<long>(evtnumAndChunk)) {
+    ATH_MSG_DEBUG("Event queue is empty");
+    usleep(1000);
   }
-  
-  if(all_ok) {
-    while(true) {
-      if(m_isRoundRobin) {
-	evtnum = skipEvents + m_nprocs*evtCounter + m_rankId; 
-	if(evtnum>=evtnumAndChunk+skipEvents) {
-          break;
-        }
-	evtCounter++;
+  bool loop_ended = (evtnumAndChunk<0);
+  if(!loop_ended) {
+    ATH_MSG_DEBUG("Received value from the queue 0x" << std::hex << evtnumAndChunk << std::dec);
+    chunkSize = evtnumAndChunk >> (sizeof(int)*8);
+    evtnum = evtnumAndChunk & intmask;
+    ATH_MSG_INFO("Received from the queue: event num=" << evtnum << " chunk size=" << chunkSize);
+    hybridHelper->setCurrentEventNum(++evtnum);
+  }
+
+  bool no_more_events = false;
+
+  while(!loop_ended) {
+    ATH_MSG_DEBUG(" -> createdEvts: " << createdEvts);
+
+    if(!hybridHelper->terminateLoop()         // No scheduled loop termination
+       && !no_more_events                     // We are not yet done getting events
+       && m_schedulerSvc->freeSlots()>0) {    // There are still free slots in the scheduler
+      ATH_MSG_DEBUG("createdEvts: " << createdEvts << ", freeslots: " << m_schedulerSvc->freeSlots());
+
+      auto ctx = m_evtProcessor->createEventContext();
+      if(!ctx.valid()) {
+        sc = StatusCode::FAILURE;
       }
       else {
-	if(!m_sharedEventQueue->try_receive_basic<long>(evtnumAndChunk)) {
-	  // The event queue is empty, but we should check whether there are more events to come or not
-	  ATH_MSG_DEBUG("Event queue is empty"); 
-	  usleep(1000);
-	  continue;
-	}
-	if(evtnumAndChunk<=0) {
-	  evtnumAndChunk *= -1;
-	  ATH_MSG_DEBUG("No more events are expected. The total number of events for this job = " << evtnumAndChunk);
-	  break;
-	}
-	while (m_schedulerSvc->freeSlots() < 1) {
-	  ATH_MSG_DEBUG("waiting for a free scheduler slot");
-	  usleep(1000000);
-	}
+        sc = m_evtProcessor->executeEvent(std::move(ctx));
+      }
 
-	ATH_MSG_DEBUG("Received value from the queue 0x" << std::hex << evtnumAndChunk << std::dec);
-	chunkSize = evtnumAndChunk >> (sizeof(int)*8);
-	evtnum = evtnumAndChunk & intmask;
-	ATH_MSG_INFO("Received from the queue: event num=" << evtnum << " chunk size=" << chunkSize);
+      if (sc.isFailure()) {
+        ATH_MSG_ERROR("Terminating event processing loop due to errors");
+        loop_ended = true;
       }
-      nEvt+=chunkSize;
-      StatusCode sc;
-      if(m_useSharedReader) {
-	sc = m_evtShare->share(evtnum);
-	if(sc.isFailure()){
-	  ATH_MSG_ERROR("Unable to share " << evtnum);
-	  all_ok=false;
-	  break;
-	} else {
-	  ATH_MSG_INFO("Share of " << evtnum << " succeeded");
+      else {
+	++createdEvts;
+	if(--chunkSize==0) {
+	  // Fetch next chunk
+	  while(!m_sharedEventQueue->try_receive_basic<long>(evtnumAndChunk)) {
+	    ATH_MSG_DEBUG("Event queue is empty");
+	    usleep(1000);
+	  }
+	  if(evtnumAndChunk<0) {
+	    no_more_events = true;
+	    evtnumAndChunk *= -1;
+	    ATH_MSG_DEBUG("No more events are expected. The total number of events for this job = " << evtnumAndChunk);
+	  }
+	  else {
+	    ATH_MSG_DEBUG("Received value from the queue 0x" << std::hex << evtnumAndChunk << std::dec);
+	    chunkSize = evtnumAndChunk >> (sizeof(int)*8);
+	    evtnum = evtnumAndChunk & intmask;
+	    ATH_MSG_INFO("Received from the queue: event num=" << evtnum << " chunk size=" << chunkSize);
+	  }
 	}
-      } else {
-	m_chronoStatSvc->chronoStart("AthenaMP_seek");
-        if (m_evtSeek) {
-          sc=m_evtSeek->seek(evtnum);
-        }
-        else {
-          sc=m_evtSelSeek->seek(*m_evtContext, evtnum);
-        }
-	if(sc.isFailure()){
-	  ATH_MSG_ERROR("Unable to seek to " << evtnum);
-	  all_ok=false;
-	  break;
-	} else {
-	  ATH_MSG_INFO("Seek to " << evtnum << " succeeded");
+	// Advance to the next event
+	if(!no_more_events) {
+	  hybridHelper->setCurrentEventNum(++evtnum);
 	}
-	m_chronoStatSvc->chronoStop("AthenaMP_seek");
       }
-      m_chronoStatSvc->chronoStart("AthenaMP_nextEvent");
-      sc = m_evtProcessor->nextEvent(chunkSize);
-      nEventsProcessed += chunkSize;
-      if(sc.isFailure()){
-	if(chunkSize==1)
-	  ATH_MSG_ERROR("Unable to process event " << evtnum);
-	else
-	  ATH_MSG_ERROR("Unable to process the chunk (" << evtnum << "," << evtnum+chunkSize-1 << ")");
-	all_ok=false;
-	break;
+    }
+    else {
+      // all the events were created but not all finished or the slots were
+      // all busy: the scheduler should finish its job
+      ATH_MSG_DEBUG("Draining the scheduler");
+
+      // Pull out of the scheduler the finished events
+      int ir = hybridHelper->drainScheduler(finishedEvts,true);
+      if(ir < 0) {
+        // some sort of error draining scheduler;
+        loop_ended = true;
+        sc = StatusCode::FAILURE;
+      }
+      else if(ir == 0) {
+	// no more events in scheduler
+        if(no_more_events) {
+          // We are done
+          loop_ended = true;
+          sc = StatusCode::SUCCESS;
+        }
+      }
+      else {
+        // keep going!
       }
-      m_chronoStatSvc->chronoStop("AthenaMP_nextEvent"); 
     }
-  }
+  } // end main loop on finished events
 
   if(all_ok) {
     if(m_evtProcessor->executeRun(0).isFailure()) {
       ATH_MSG_ERROR("Could not finalize the Run");
       all_ok=false;
     } else {
-      StatusCode sc;
-      if (m_evtSeek) {
-        sc = m_evtSeek->seek(evtnumAndChunk+skipEvents);
-      }
-      else {
-        sc = m_evtSelSeek->seek(*m_evtContext, evtnumAndChunk+skipEvents);
-      }
-      if(sc.isFailure()) { 
+      if(m_evtSelSeek->seek(*m_evtContext, evtnumAndChunk+skipEvents).isFailure()) { 
 	ATH_MSG_DEBUG("Seek past maxevt to " << evtnumAndChunk+skipEvents << " returned failure. As expected...");
       }
     }
@@ -624,7 +506,7 @@ SharedHiveEvtQueueConsumer::exec_func()
   *(int*)(outdata) = (all_ok?0:1); // Error code: for now use 0 success, 1 failure
   AthenaMPToolBase::Func_Flag func = AthenaMPToolBase::FUNC_EXEC;
   memcpy((char*)outdata+sizeof(int),&func,sizeof(func));
-  memcpy((char*)outdata+sizeof(int)+sizeof(func),&nEventsProcessed,sizeof(int));
+  memcpy((char*)outdata+sizeof(int)+sizeof(func),&createdEvts,sizeof(int));
 
   outwork->data = outdata;
   outwork->size = outsize;
@@ -753,7 +635,7 @@ SharedHiveEvtQueueConsumer::initHive() {
       }
     }      
 
-    m_evtProcessor = ServiceHandle<IEventProcessor>("AthenaHiveEventLoopMgr",name());
+    m_evtProcessor = ServiceHandle<IEventProcessor>("AthenaMtesEventLoopMgr",name());
 
     if (m_evtProcessor.retrieve().isFailure()) {
       ATH_MSG_ERROR("could not setup " << m_evtProcessor.typeAndName());

Control/AthenaMPTools/src/SharedHiveEvtQueueConsumer.h

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef ATHENAMPTOOLS_SHAREDHIVEEVTQUEUECONSUMER_H
@@ -12,10 +12,7 @@
 #include "GaudiKernel/IScheduler.h"
 #include "GaudiKernel/IEvtSelector.h"
 
-class IEventSeek;
 class IEvtSelectorSeek;
-class IEventShare;
-class IDataShare;
 class IChronoStatSvc;
 
 class SharedHiveEvtQueueConsumer final : public AthenaMPToolBase
@@ -56,21 +53,14 @@ class SharedHiveEvtQueueConsumer final : public AthenaMPToolBase
   int decodeProcessResult(const AthenaInterprocess::ProcessResult* presult, bool doFinalize);
 
   // Properties
-  bool m_useSharedReader; // Work in pair with a SharedReader
-  bool m_useSharedWriter; // Work in pair with a SharedWriter
-  bool m_isPileup;        // Are we doing pile-up digitization?
-  bool m_isRoundRobin;    // Are we running in the "reproducible mode"?
   int  m_nEventsBeforeFork;
   bool m_debug;
 
   int  m_rankId;          // Each worker has its own unique RankID from the range (0,...,m_nprocs-1) 
 
   ServiceHandle<IChronoStatSvc>  m_chronoStatSvc;
-  IEventSeek*                    m_evtSeek;
   IEvtSelectorSeek*              m_evtSelSeek;
   IEvtSelector::Context*         m_evtContext;
-  IEventShare*                   m_evtShare;
-  IDataShare*                    m_dataShare;
 
   AthenaInterprocess::SharedQueue*  m_sharedEventQueue;          
   AthenaInterprocess::SharedQueue*  m_sharedRankQueue;          

Control/AthenaServices/src/AthenaMtesEventLoopMgr.cxx

@@ -717,14 +717,16 @@ StatusCode AthenaMtesEventLoopMgr::stop()
 }
 
 
-StatusCode AthenaMtesEventLoopMgr::nextEvent(int /*maxevt*/)
+StatusCode AthenaMtesEventLoopMgr::nextEvent(int maxevt)
 {
+  if(maxevt==0) return StatusCode::SUCCESS;
+
   yampl::ISocketFactory* socketFactory = new yampl::SocketFactory();
   // Create a socket to communicate with the Pilot
-  yampl::ISocket* socket2Pilot = socketFactory->createClientSocket(yampl::Channel(m_eventRangeChannel.value(),yampl::LOCAL),yampl::MOVE_DATA);
+  m_socket = socketFactory->createClientSocket(yampl::Channel(m_eventRangeChannel.value(),yampl::LOCAL),yampl::MOVE_DATA);
 
   // Reset the application return code.
-  Gaudi::setAppReturnCode(m_appMgrProperty, Gaudi::ReturnCode::Success, true).ignore();  
+  resetAppReturnCode();
 
   int finishedEvts =0;
   int createdEvts =0;
@@ -740,7 +742,7 @@ StatusCode AthenaMtesEventLoopMgr::nextEvent(int /*maxevt*/)
 
   std::unique_ptr<RangeStruct> range;
   while(!range) {
-    range = getNextRange(socket2Pilot);
+    range = getNextRange(m_socket);
     usleep(1000);
   }
 
@@ -782,7 +784,7 @@ StatusCode AthenaMtesEventLoopMgr::nextEvent(int /*maxevt*/)
 	  // Fetch next event range
 	  range.reset();
 	  while(!range) {
-	    range = getNextRange(socket2Pilot);
+	    range = getNextRange(m_socket);
 	    usleep(1000);
 	  }
 	  if(range->eventRangeID.empty()) {
@@ -803,7 +805,7 @@ StatusCode AthenaMtesEventLoopMgr::nextEvent(int /*maxevt*/)
       debug() << "Draining the scheduler" << endmsg;
 
       // Pull out of the scheduler the finished events
-      int ir = drainScheduler(finishedEvts,socket2Pilot);
+      int ir = drainScheduler(finishedEvts,true);
       if(ir < 0) {
 	// some sort of error draining scheduler;
 	loop_ended = true;
@@ -825,7 +827,8 @@ StatusCode AthenaMtesEventLoopMgr::nextEvent(int /*maxevt*/)
 
   info() << "---> Loop Finished (seconds): " << secsFromStart() <<endmsg;
 
-  delete socket2Pilot;
+  delete m_socket;
+  m_socket=nullptr;
   delete socketFactory;
   return sc;
 }
@@ -1204,10 +1207,22 @@ EventContext AthenaMtesEventLoopMgr::createEventContext() {
   return ctx;
 }
 
+void AthenaMtesEventLoopMgr::resetAppReturnCode()
+{
+  Gaudi::setAppReturnCode(m_appMgrProperty, Gaudi::ReturnCode::Success, true).ignore();
+}
+
+void AthenaMtesEventLoopMgr::setCurrentEventNum(int num) {
+  m_currentEvntNum = num;
+}
+
+bool AthenaMtesEventLoopMgr::terminateLoop() {
+  return m_terminateLoop;
+}
 //---------------------------------------------------------------------------
 
 int 
-AthenaMtesEventLoopMgr::drainScheduler(int& finishedEvts,yampl::ISocket* socket){
+AthenaMtesEventLoopMgr::drainScheduler(int& finishedEvts,bool report){
 
   StatusCode sc(StatusCode::SUCCESS);
     
@@ -1273,20 +1288,23 @@ AthenaMtesEventLoopMgr::drainScheduler(int& finishedEvts,yampl::ISocket* socket)
     
     // Some code still needs global context in addition to that passed in the incident
     Gaudi::Hive::setCurrentContext( *thisFinishedEvtContext );
+    info() << "Firing EndProcessing" << endmsg;
     m_incidentSvc->fireIncident(Incident(name(), IncidentType::EndProcessing, *thisFinishedEvtContext ));
 
-    // If we completed an event range, then report it to the pilot
-    OutputStreamSequencerSvc::RangeReport_ptr rangeReport = m_outSeqSvc->getRangeReport();
-    if(rangeReport) {
-      std::string outputFileReport = rangeReport->second + std::string(",ID:")
-	+ rangeReport->first + std::string(",CPU:N/A,WALL:N/A");
-      if( not m_inTestMode ) {
-         // In standalone test mode there is no pilot to talk to
-         void* message2pilot = malloc(outputFileReport.size());
-         memcpy(message2pilot,outputFileReport.data(),outputFileReport.size());
-         socket->send(message2pilot,outputFileReport.size());
+    if(report) {
+      // If we completed an event range, then report it to the pilot
+      OutputStreamSequencerSvc::RangeReport_ptr rangeReport = m_outSeqSvc->getRangeReport();
+      if(rangeReport) {
+	std::string outputFileReport = rangeReport->second + std::string(",ID:")
+	  + rangeReport->first + std::string(",CPU:N/A,WALL:N/A");
+	if( not m_inTestMode ) {
+	  // In standalone test mode there is no pilot to talk to
+	  void* message2pilot = malloc(outputFileReport.size());
+	  memcpy(message2pilot,outputFileReport.data(),outputFileReport.size());
+	  m_socket->send(message2pilot,outputFileReport.size());
+	}
+	info() << "Reported the output " << outputFileReport << endmsg;
       }
-      info() << "Reported the output " << outputFileReport << endmsg;
     }
 
     debug() << "Clearing slot " << thisFinishedEvtContext->slot() 

Control/AthenaServices/src/AthenaMtesEventLoopMgr.h

 // -*- C++ -*-
 
 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef ATHENASERVICES_ATHENAMTESEVENTLOOPMGR_H
@@ -23,6 +23,7 @@
 #include "AthenaKernel/IEventSeek.h"
 #include "AthenaKernel/ICollectionSize.h"
 #include "AthenaKernel/IConditionsCleanerSvc.h"
+#include "AthenaKernel/IHybridProcessorHelper.h"
 #include "StoreGate/ActiveStoreSvc.h"
 
 #include <memory>
@@ -52,6 +53,7 @@ class AthenaMtesEventLoopMgr
   : virtual public IEventSeek,
     virtual public ICollectionSize,
     virtual public IIncidentListener,
+    virtual public IHybridProcessorHelper,
             public MinimalEventLoopMgr,
             public Athena::TimeoutMaster
 {
@@ -167,10 +169,6 @@ protected:
   StatusCode clearWBSlot(int evtSlot);
   /// Declare the root address of the event
   int declareEventRootAddress(EventContext&);
-  /// Create event context
-  virtual EventContext createEventContext() override;
-  /// Drain the scheduler from all actions that may be queued
-  int drainScheduler(int& finishedEvents,yampl::ISocket* socket);
   /// Instance of the incident listener waiting for AbortEvent. 
   SmartIF< IIncidentListener >  m_abortEventListener;
   /// Name of the scheduler to be used
@@ -201,6 +199,8 @@ public:
   virtual StatusCode finalize() override;
   /// implementation of IAppMgrUI::nextEvent. maxevt==0 returns immediately
   virtual StatusCode nextEvent(int maxevt) override;
+  /// implementation of IEventProcessor::createEventContext()
+  virtual EventContext createEventContext() override;
   /// implementation of IEventProcessor::executeEvent(void* par)
   virtual StatusCode executeEvent( EventContext&& ctx ) override;
   /// implementation of IEventProcessor::executeRun(int maxevt)
@@ -220,6 +220,15 @@ public:
   /// IIncidentListenet interfaces
   virtual void handle(const Incident& inc) override;
 
+  /// Reset the application return code
+  virtual void resetAppReturnCode() override;
+  
+  virtual void setCurrentEventNum(int num) override;
+  virtual bool terminateLoop() override;
+
+  /// Drain the scheduler from all actions that may be queued
+  virtual int drainScheduler(int& finishedEvents, bool report) override;
+
   /// interface dispatcher
   virtual StatusCode queryInterface( const InterfaceID& riid, 
                                      void** ppvInterface ) override;
@@ -294,6 +303,9 @@ private:
   // Hopefully a temporary measurement. For the time being we cannot
   // support event ranges from different input files.
   std::string m_pfn{""};
+
+  // For the event service running:
+  yampl::ISocket* m_socket{nullptr};
 };
 
 #endif // ATHENASERVICES_ATHENAHIVEEVENTLOOPMGR_H

Control/CxxUtils/CxxUtils/SealDebug.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -27,6 +27,7 @@
 //# include "SealBase/Macros.h"                   wlav
 //# include "SealBase/sysapi/IOTypes.h"           wlav
 # include <cstddef>
+# include <atomic>
 
 // wlav copied from SealBase/sysapi/DebugAids.h
 // Windows doesn't have this, so fake a suitable substitute
@@ -60,7 +61,7 @@ class DebugAids
 {
 public:
     // Miscellaneous functions
-    static IOFD			stacktraceFd ATLAS_NOT_THREAD_SAFE (IOFD fd = IOFD_INVALID);
+    static IOFD			stacktraceFd (IOFD fd = IOFD_INVALID);
     static void			stacktrace ATLAS_NOT_THREAD_SAFE (IOFD fd = IOFD_INVALID);
     static void			coredump (int sig, ...);
     // sss
@@ -69,7 +70,7 @@ public:
     static void                 setStackTraceAddr2Line ATLAS_NOT_THREAD_SAFE (const char* path);
 
 private:
-    static IOFD			s_stackTraceFd;
+    static std::atomic<IOFD>	 s_stackTraceFd;
 };
 
 //<<<<<< PUBLIC FUNCTIONS                                               >>>>>>