Calorimeter/CaloRec/src/CaloTopoTmpHashClusterBase.h

@@ -56,13 +56,11 @@ public:
 
     reference operator*()
     {
-      // cppcheck-suppress returnTempReference; false positive
       return reinterpret_cast<reference> (pointer_list::iterator::operator*());
     }
 
     reference operator->()
     {
-      // cppcheck-suppress returnTempReference; false positive
       return reinterpret_cast<reference> (pointer_list::iterator::operator*());
     }
   };

Calorimeter/CaloRec/src/CaloTopoTowerBuilderTool.cxx

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 
@@ -309,19 +309,6 @@ StatusCode CaloTopoTowerBuilderTool::execute(const EventContext& ctx,
 }
 
 
-
-
-void CaloTopoTowerBuilderTool::handle(const Incident&) {
- 
-}
-
-StatusCode CaloTopoTowerBuilderTool::LoadCalibration(IOVSVC_CALLBACK_ARGS)
-{
-  return StatusCode::SUCCESS;
-}
-
-
-
 const CaloCell2ClusterMap*
 CaloTopoTowerBuilderTool::CreateCaloCell2ClusterMap(const CaloClusterContainer* clusColl) const
 {

Calorimeter/CaloRec/src/CaloTopoTowerBuilderTool.h

 /*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef CALOREC_CALOTOPOTOWERBUILDERTOOL_H
@@ -49,10 +49,6 @@ class CaloTopoTowerBuilderTool : public CaloTopoTowerBuilderToolBase
 
   virtual StatusCode initializeTool() override;
 
-  virtual void handle(const Incident&) override;
-
-  virtual StatusCode LoadCalibration(IOVSVC_CALLBACK_ARGS) override;
-
  protected:
 
   /////////////////////////////

Calorimeter/CaloRec/src/CaloTowerMonitor.cxx

-/*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-*/
-
-
-#include "GaudiKernel/Algorithm.h"
-#include "GaudiKernel/MsgStream.h"
-
-#include "StoreGate/ReadHandle.h"
-
-#include "CLHEP/Units/SystemOfUnits.h"
-
-#include "CaloGeoHelpers/CaloPhiRange.h"
-
-#include "CaloGeoHelpers/CaloSampling.h"
-#include "CaloEvent/CaloCell.h"
-#include "CaloEvent/CaloTower.h"
-#include "CaloEvent/CaloTowerContainer.h"
-
-#include "CaloTowerMonitor.h"
-
-#include <string>
-#include <cmath>
-
-using CLHEP::GeV;
-using CLHEP::deg;
-
-
-StatusCode CaloTowerMonitor::initialize()
-{
-  ATH_CHECK( m_histSvc.retrieve() );
-  ////////////////////////
-  // Book Distributions //
-  ////////////////////////
-
-  auto book1 = [&] (const std::string& name,
-                    const std::string& title,
-                    int nx,
-                    float xlo,
-                    float xhi,
-                    TH1*& hptr) -> StatusCode
-  {
-    return m_histSvc->regHist ("/" + m_streamName + "/CaloTowerMonitor/" + name,
-                               std::make_unique<TH1F> (name.c_str(), title.c_str(),
-                                                       nx, xlo, xhi),
-                               hptr);
-  };
-  auto book2 = [&] (const std::string& name,
-                    const std::string& title,
-                    int nx,
-                    float xlo,
-                    float xhi,
-                    int ny,
-                    float ylo,
-                    float yhi,
-                    TH2*& hptr) -> StatusCode
-  {
-    return m_histSvc->regHist ("/" + m_streamName + "/CaloTowerMonitor/" + name,
-                               std::make_unique<TH2F> (name.c_str(), title.c_str(),
-                                                       nx, xlo, xhi,
-                                                       ny, ylo, yhi),
-                               hptr);
-  };
-
-  // number of towers
-  ATH_CHECK( book1 ("nTowersVsEta", "Number of CaloTowers vs Eta",
-                    100, -5., 5.,
-                    m_nTowersVsEta) );
-  ATH_CHECK( book1 ("nTowersVsPhi", "Number of CaloTowers vs Phi [deg]",
-                    100, -200., 200.,
-                    m_nTowersVsPhi) );
-
-  // tower energies
-  ATH_CHECK( book1 ("eTowers", "CaloTower E [GeV]",
-                    100, 0., 100.,
-                    m_eTowers) );
-  ATH_CHECK( book2 ("eTowersVsEta", "CaloTower E [GeV] vs Eta",
-                    100, -5., 5.,
-                    100, 0., 100.,
-                    m_eTowersVsEta) );
-  ATH_CHECK( book2 ("eTowersVsPhi", "CaloTower E [Gev] vs Phi [deg]",
-                    100, -200., 200.,
-                    100, 0., 100.,
-                    m_eTowersVsPhi) );
-  ATH_CHECK( book1 ("eLogTowers", "CaloTower log(E/GeV)",
-                    100, -7., 3.,
-                    m_eLogTowers) );
-
-  // tower et's
-  ATH_CHECK( book1 ("etTowers", "CaloTower Et [GeV]",
-                    100, 0., 100.,
-                    m_etTowers) );
-  ATH_CHECK( book2 ("etTowersVsEta", "CaloTower Et [GeV] vs Eta",
-                    100, -5., 5.,
-                    100, 0., 100.,
-                    m_etTowersVsEta) );
-  ATH_CHECK( book2 ("etTowersVsPhi", "CaloTower Et [Gev] vs Phi [deg]",
-                    100, -200., 200.,
-                    100, 0., 100.,
-                    m_etTowersVsPhi) );
-  ATH_CHECK( book1 ("etLogTowers", "CaloTower log(Et/GeV)",
-                    100, -7., 3.,
-                    m_etLogTowers) );
-
-  // tower shapes
-  ATH_CHECK( book2 ("cellsInEtaVsPhi", "CaloTower Shape",
-                    100, -0.5, 0.5,
-                    100, -0.5, 0.5,
-                    m_cellsInEtaVsPhi) );
-  ATH_CHECK( book1 ("nCellsInTower", "Number of Cells in CaloTower",
-                    100, 0., 100.,
-                    m_nCellsInTower) );
-  ATH_CHECK( book2 ("nCellsInTowerVsEta", "Number of Cells vs Eta",
-                    100, -5., 5.,
-                    100, 0., 100.,
-                    m_nCellsInTowerVsEta) );
-  ATH_CHECK( book2 ("nCellsInTowerVsPhi", "Number of Cells vs Phi [deg]",
-                    100, -200., 200.,
-                    100, 0., 100.,
-                    m_nCellsInTowerVsPhi) );
-
-  // eta direction matches
-  ATH_CHECK( book2 ("etaTowerVsCell", "Cell Eta vs TowerEta",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCell) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosPreSamplerB",
-                    "Cell Eta vs Tower Eta PreSampB",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::PreSamplerB]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosEMB1",
-                    "Cell Eta vs Tower Eta EMB1",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::EMB1]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosPreSamplerE",
-                    "Cell Eta vs Tower Eta PreSampE",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::PreSamplerE]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosEME1",
-                    "Cell Eta vs Tower Eta EME1",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::EME1]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosHEC0",
-                    "Cell Eta vs Tower Eta HEC0",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::HEC0]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosTileBar0",
-                    "Cell Eta vs Tower Eta TileBar0",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::TileBar0]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosTileExt0",
-                    "Cell Eta vs Tower Eta TileExt0",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::TileExt0]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosFCAL0",
-                    "Cell Eta vs Tower Eta FCAL0",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::FCAL0]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosFCAL1",
-                    "Cell Eta vs Tower Eta FCAL1",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::FCAL1]) );
-  ATH_CHECK( book2 ("etaTowerVsCellCalosFCAL2",
-                    "Cell Eta vs Tower Eta FCAL2",
-                    100, -5., 5.,
-                    100, -5., 5.,
-                    m_etaTowerVsCellCalos[CaloSampling::FCAL2]) );
-
-  // phi direction matches
-  ATH_CHECK( book2 ("phiTowerVsCell", "Cell Phi vs TowerPhi",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCell) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosPreSamplerB",
-                    "Cell Phi vs Tower Phi PreSampB",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::PreSamplerB]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosEMB1",
-                    "Cell Phi vs Tower Phi EMB1",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::EMB1]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosPreSamplerE",
-                    "Cell Phi vs Tower Phi PreSampE",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::PreSamplerE]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosEME1",
-                    "Cell Phi vs Tower Phi EME1",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::EME1]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosHEC0",
-                    "Cell Phi vs Tower Phi HEC0",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::HEC0]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosTileBar0",
-                    "Cell Phi vs Tower Phi TileBar0",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::TileBar0]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosTileExt0",
-                    "Cell Phi vs Tower Phi TileExt0",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::TileExt0]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosFCAL0",
-                    "Cell Phi vs Tower Phi FCAL0",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::FCAL0]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosFCAL1",
-                    "Cell Phi vs Tower Phi FCAL1",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::FCAL1]) );
-  ATH_CHECK( book2 ("phiTowerVsCellCalosFCAL2",
-                    "Cell Phi vs Tower Phi FCAL2",
-                    100, -200., 200.,
-                    100, -200., 200.,
-                    m_phiTowerVsCellCalos[CaloSampling::FCAL2]) );
-
-  ATH_CHECK( m_collectionNames.initialize() );
-
-  return StatusCode::SUCCESS;
-}
-
-
-StatusCode CaloTowerMonitor::execute()
-{
-  const EventContext& ctx = getContext();
-  // retrieve data container
-  for (const SG::ReadHandleKey<CaloTowerContainer>& k : m_collectionNames) {
-    // pointer to tower container
-    SG::ReadHandle<CaloTowerContainer> theTowers (k, ctx);
-    for (const CaloTower* aTower : *theTowers) {
-      // check tower properties
-      //	      if ( aTower->eta() == 0 || aTower->getNumberOfCells() == 0 )
-      //		{
-      //		  log << MSG::WARNING
-      //		      << "CaloTower @ "
-      //		      << aTower
-      //		      << " with (eta/phi) = ("
-      //		      << aTower->eta()
-      //		      << "/"
-      //		      << aTower->phi()
-      //		      << ") has e = "
-      //		      << aTower->e() / GeV
-      //		      << " GeV and #cells = "
-      //		      << aTower->getNumberOfCells()
-      //		      << endmsg;
-      //		}
-      //	      else
-      if ( aTower->getNumberOfCells() != 0 )
-      {
-        // variables
-        double e     = aTower->e()  * (1./GeV);
-        double et    = aTower->et() * (1./GeV);
-        double eta   = aTower->eta();
-        double phi   = aTower->phi();
-        //		  if ( phi > mathPi ) phi -= 2. * mathPi;
-        double cells = (double) aTower->getNumberOfCells();
-        ATH_MSG_DEBUG( "Tower @"
-                       << aTower
-                       << " E = "
-                       << e << " GeV (eta,phi) = ("
-                       << eta << "," << phi << ")"  );
-        // fill distributions
-        m_nTowersVsEta->Fill(eta,1.);
-        m_nTowersVsPhi->Fill(phi*(1/deg),1.);
-        // ATH_MSG_INFO( "fill tower e   " << e  );
-        m_eTowers->Fill(e,1.);
-        m_eTowersVsEta->Fill(eta,e,1.);
-        m_eTowersVsPhi->Fill(phi*(1./deg),e,1.);
-        if ( e > 0. )
-        {
-          m_eLogTowers->Fill(log10(e),1.);
-        }
-        // ATH_MSG_INFO( "fill tower et  " << et  );
-        m_etTowers->Fill(et,1.);
-        m_etTowersVsEta->Fill(eta,et,1.);
-        m_etTowersVsPhi->Fill(phi*(1./deg),et,1.);
-        if ( et > 0. )
-        {
-          m_etLogTowers->Fill(log10(et),1.);
-        }
-        // tower shape
-        // ATH_MSG_INFO( "fill tower cls " << cells  );
-        m_nCellsInTower->Fill(cells,1.);
-        m_nCellsInTowerVsEta->Fill(eta,cells,1.);
-        m_nCellsInTowerVsPhi->Fill(phi*(1./deg),cells,1.);
-        for (const CaloCell* aCell : *aTower)
-        {
-          // calculate distance
-          double cellEta  = aCell->eta();
-          double cellPhi  = aCell->phi();
-          //  if ( cellPhi > mathPi ) cellPhi -= 2. * mathPi;
-          double deltaEta = eta - aCell->eta();
-          double deltaPhi = CaloPhiRange::diff(phi, aCell->phi());
-          // log << MSG::INFO << "fill cell deta,dphi " 
-          //  << deltaEta << "," << deltaPhi << endmsg;
-          m_cellsInEtaVsPhi->Fill(deltaEta,deltaPhi,1.);
-          // direction matches
-          //log << MSG::INFO << "fill cell eta " 
-          //	  << cellEta << endmsg;
-          m_etaTowerVsCell->Fill(cellEta,eta,1.);
-          //log << MSG::INFO << "fill tower phi " 
-          //		  << cellPhi/deg << endmsg;
-          m_phiTowerVsCell->Fill(cellPhi*(1./deg),phi*(1./deg),1.);
-          CaloSampling::CaloSample theSample = aCell->caloDDE()->getSampling();
-          CaloSampling::CaloSample takeSample = theSample;
-          switch ( theSample )
-          {
-          case CaloSampling::EMB2:
-          case CaloSampling::EMB3:
-            takeSample = CaloSampling::EMB1;
-            break;
-          case CaloSampling::EME2:
-          case CaloSampling::EME3:
-            takeSample = CaloSampling::EME1;
-            break;
-          case CaloSampling::HEC1:
-          case CaloSampling::HEC2:
-          case CaloSampling::HEC3:
-            takeSample = CaloSampling::HEC0;
-            break;
-          case CaloSampling::TileBar1:
-          case CaloSampling::TileBar2:
-          case CaloSampling::TileGap1:
-          case CaloSampling::TileGap2:
-          case CaloSampling::TileGap3:
-            takeSample = CaloSampling::TileBar0;
-            break;
-          case CaloSampling::TileExt1:
-          case CaloSampling::TileExt2:
-            takeSample = CaloSampling::TileExt0;
-            break;
-          default:
-            break;
-          }
-          m_etaTowerVsCellCalos[takeSample]->Fill(cellEta,eta,1.);
-          m_phiTowerVsCellCalos[takeSample]->Fill(cellPhi*(1./deg),
-                                                  phi*(1./deg),1.);
-        } // cell loop
-      } // tower kinematics ok
-    } // tower loop
-  } // collection loop
-  return StatusCode::SUCCESS;
-}		    
-

Calorimeter/CaloRec/src/CaloTowerMonitor.h

-/*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef CALOREC_CALOTOWERMONITOR_H
-#define CALOREC_CALOTOWERMONITOR_H
-///////////////////////////////////////////////////////////////////////////////
-/// \brief simple monitor for CaloTower objects
-///
-/// The CaloTowerMonitor is an algorithm to produce a few histograms from 
-/// CaloTowers to check the performance of the CaloTower algorithm.
-///
-/// \author Peter Loch <loch@physics.arizona.edu>
-/// \date May 05, 2004 - first implementation
-///
-///////////////////////////////////////////////////////////////////////////////
-
-#include "CaloGeoHelpers/CaloSampling.h"
-#include "CaloEvent/CaloTowerContainer.h"
-#include "StoreGate/ReadHandleKeyArray.h"
-#include "AthenaBaseComps/AthAlgorithm.h"
-#include "GaudiKernel/ITHistSvc.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "TH1.h"
-#include "TH2.h"
-
-#include <string>
-#include <vector>
-#include <map>
-
-
-class CaloTowerMonitor : public AthAlgorithm
-{
-public:
-  using AthAlgorithm::AthAlgorithm;
-
-  virtual StatusCode initialize() override;
-  virtual StatusCode execute() override;
-
- protected:
-
-  SG::ReadHandleKeyArray<CaloTowerContainer> m_collectionNames
-  { this, "InputTowerCollections", {} };
-
-  ////////////////
-  // Histograms //
-  ////////////////
-
-  // number of towers
-  TH1* m_nTowersVsEta = nullptr;
-  TH1* m_nTowersVsPhi = nullptr;
-
-  // tower shape
-  TH2* m_cellsInEtaVsPhi = nullptr;
-  TH1* m_nCellsInTower = nullptr;
-  TH2* m_nCellsInTowerVsEta = nullptr;
-  TH2* m_nCellsInTowerVsPhi = nullptr;
-
-  // tower energies
-  TH1* m_eTowers = nullptr;
-  TH2* m_eTowersVsEta = nullptr;
-  TH2* m_eTowersVsPhi = nullptr;
-  TH1* m_eLogTowers = nullptr;
-
-  // tower transversal energies
-  TH1* m_etTowers = nullptr;
-  TH2* m_etTowersVsEta = nullptr;
-  TH2* m_etTowersVsPhi = nullptr;
-  TH1* m_etLogTowers = nullptr;
-
-  // eta/phi matches
-  TH2* m_etaTowerVsCell = nullptr;
-  TH2* m_phiTowerVsCell = nullptr;
-  std::map<CaloSampling::CaloSample,TH2*> m_etaTowerVsCellCalos;
-  std::map<CaloSampling::CaloSample,TH2*> m_phiTowerVsCellCalos;
-
-  ServiceHandle<ITHistSvc> m_histSvc
-    { this, "THistSvc", "THistSvc" };
-
-  StringProperty m_streamName
-    { this, "StreamName", "ESD", "Histogram stream name" };
-};
-#endif

Calorimeter/CaloRec/src/components/CaloRec_entries.cxx

-#include "../CaloTowerMonitor.h"
 #include "../CaloTowerAlgorithm.h"
 #include "../CaloTopoTowerAlgorithm.h"
 #include "../CaloClusterMaker.h"
@@ -32,7 +31,6 @@
 #include "../CaloCellContainerAliasAlg.h"
 #include "../ToolConstantsCondAlg.h"
 #include "../CaloNoiseSigmaDiffCondAlg.h"
-#include "../CaloCellWeightCorrection.h"
 
 //Includes for CaloTopoTowers
 #include "../CaloTopoClusterTowerMerger.h"
@@ -44,7 +42,6 @@
 #include "../CaloTowerStoreTestAlg.h"
 
 
-DECLARE_COMPONENT( CaloTowerMonitor )
 DECLARE_COMPONENT( CaloTowerAlgorithm )
 DECLARE_COMPONENT( CaloTopoTowerAlgorithm )
 DECLARE_COMPONENT( CaloClusterMaker )
@@ -90,7 +87,6 @@ DECLARE_COMPONENT( CaloTopoClusterTowerMerger )
 DECLARE_COMPONENT( CaloTopoTowerFromClusterMaker )
 DECLARE_COMPONENT( CaloTopoTowerFromClusterCalibrator )
 DECLARE_COMPONENT( CaloTopoTowerMaker )
-DECLARE_COMPONENT( CaloCellWeightCorrection )
 
 DECLARE_COMPONENT ( CaloTopoTowerBuilderTool )
 

Calorimeter/CaloRec/test/CaloRec.xml

-<?xml version="1.0"?>
-<atn>
-   <TEST name="CaloRecTests" type="makecheck">
-      <package>Calorimeter/CaloRec</package>
-      <author> scott snyder </author>
-      <mailto> snyder@bnl.gov </mailto>
-      <expectations>
-         <errorMessage>Athena exited abnormally</errorMessage>
-         <errorMessage>differ</errorMessage>
-         <warningMessage> # WARNING_MESSAGE : post.sh> ERROR</warningMessage>
-         <successMessage>check ok</successMessage>
-         <returnValue>0</returnValue>
-      </expectations>
-   </TEST>
-</atn>

Calorimeter/CaloRecGPU/CMakeLists.txt

-# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
-
-
-# This package needs CUDA to be handled as a "first class language" by CMake.
-cmake_minimum_required(VERSION 3.11)
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 # Set the name of the package.
 atlas_subdir( CaloRecGPU )
@@ -20,9 +16,14 @@ find_package( Boost COMPONENTS chrono )
 atlas_add_library( CaloRecGPULib
    CaloRecGPU/*.h src/*.cxx src/*.cu src/*.h
    PUBLIC_HEADERS CaloRecGPU
-   LINK_LIBRARIES AthenaBaseComps CaloEvent CaloInterfaceLib CxxUtils GaudiKernel TileEvent TrigT2CaloCommonLib
+   LINK_LIBRARIES AthenaBaseComps AthenaInterprocess CaloEvent CaloInterfaceLib CxxUtils GaudiKernel TileEvent TrigT2CaloCommonLib xAODTrigCalo
    PRIVATE_INCLUDE_DIRS ${Boost_INCLUDE_DIRS} )
 
+# Suppress spurious warnings seen in the LTO build originating 
+# in the boost parser code.
+set_target_properties( CaloRecGPULib
+                       PROPERTIES LINK_FLAGS " -Wno-maybe-uninitialized "  )
+
 atlas_add_component( CaloRecGPU
    src/components/*.cxx
    LINK_LIBRARIES CaloRecGPULib )

Calorimeter/CaloRecGPU/CaloRecGPU/CaloGPUCUDAInitialization.h

+//
+// Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+//
+// Dear emacs, this is -*- c++ -*-
+//
+
+#ifndef CALORECGPU_CALOGPUCUDAINITIALIZATION_H
+#define CALORECGPU_CALOGPUCUDAINITIALIZATION_H
+
+#include "GaudiKernel/IProperty.h"
+
+#include "GaudiKernel/IIncidentListener.h"
+#include "GaudiKernel/IIncidentSvc.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/ConcurrencyFlags.h"
+
+#include "AthenaInterprocess/Incidents.h"
+
+
+/**
+ * @class CaloGPUCUDAInitialization
+ * @author Nuno Fernandes <nuno.dos.santos.fernandes@cern.ch>
+ * @date 15 March 2024
+ * @brief Base class to provide some basic common infrastructure 
+ *        for initializing CUDA only at the right place to work fine with multiprocessing... */
+
+class CaloGPUCUDAInitialization : virtual public IIncidentListener
+{
+ protected:
+  
+
+  ///Initialization that does not invoke CUDA functions.
+  virtual StatusCode initialize_non_CUDA()
+  {
+    return StatusCode::SUCCESS;
+  }
+
+  ///Initialization that invokes CUDA functions.
+  virtual StatusCode initialize_CUDA()
+  {
+    return StatusCode::SUCCESS;
+  }
+
+  virtual StatusCode initialize()
+  {
+    ATH_CHECK(this->initialize_non_CUDA());
+
+    const bool is_multiprocess = (Gaudi::Concurrency::ConcurrencyFlags::numProcs() > 0);
+
+    if (is_multiprocess)
+      {
+        ServiceHandle<IIncidentSvc> incidentSvc("IncidentSvc","CaloGPUCUDAInitialization");
+        
+        incidentSvc->addListener(this, AthenaInterprocess::UpdateAfterFork::type());
+      }
+    else
+      {
+        ATH_CHECK(this->initialize_CUDA());
+      }
+
+    return StatusCode::SUCCESS;
+  }
+
+ public:
+
+  void handle(const Incident & incident) override
+  {
+    const bool is_multiprocess = (Gaudi::Concurrency::ConcurrencyFlags::numProcs() > 0);
+    if (is_multiprocess && incident.type() == AthenaInterprocess::UpdateAfterFork::type())
+      {
+        if (!this->initialize_CUDA().isSuccess())
+        {
+          throw GaudiException("Failed to perform the CUDA initialization!",
+                               "CaloGPUCUDAInitialization::handle",
+                               StatusCode::FAILURE);
+        }
+      }
+  }
+  
+  virtual ~CaloGPUCUDAInitialization() = default;
+
+};
+
+#endif //CALORECGPU_CALOGPUTIMED_H

Calorimeter/CaloRecGPU/CaloRecGPU/CaloGPUTimed.h

 //
-// Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+// Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 //
 // Dear emacs, this is -*- c++ -*-
 //
@@ -8,7 +8,7 @@
 #define CALORECGPU_CALOGPUTIMED_H
 
 #include <vector>
-#include <mutex>
+#include <shared_mutex>
 #include <string>
 #include <fstream>
 #include "CxxUtils/checker_macros.h"
@@ -29,7 +29,7 @@ class CaloGPUTimed
 
   /** @brief Mutex that is locked when recording times.
    */
-  mutable std::mutex m_timeMutex;
+  mutable std::shared_mutex m_timeMutex;
   /** @brief Vector to hold execution times to be recorded if necessary.
    */
   mutable std::vector<size_t> m_times ATLAS_THREAD_SAFE;
@@ -50,33 +50,35 @@ class CaloGPUTimed
   Gaudi::Property<std::string> m_timeFileName;
 
   //Use CaloGPUTimed(this) in the derived classes for everything to work.
-  
+
   template <class T>
   CaloGPUTimed(T * ptr):
-  m_measureTimes(ptr, "MeasureTimes", false, "Save time measurements"),
-  m_timeFileName(ptr, "TimeFileOutput", "times.txt", "File to which time measurements should be saved")
+    m_measureTimes(ptr, "MeasureTimes", false, "Save time measurements"),
+    m_timeFileName(ptr, "TimeFileOutput", "times.txt", "File to which time measurements should be saved")
   {
   }
-  
-  
+
+
  private:
 
-  inline void record_times_helper(size_t) const
+  inline void record_times_helper(const size_t) const
   {
     //Do nothing
   }
 
-
-  inline void record_times_helper(size_t index, size_t t) const
+  template <class Arg>
+  inline void record_times_helper(const size_t index, Arg && arg) const
   {
-    m_times[index] = t;
+    // coverity[missing_lock]
+    m_times[index] = std::forward<Arg>(arg);
+    
+    //This is called within a function that holds the lock itself.
   }
 
   template <class ... Args>
-  inline void record_times_helper(size_t index, size_t t, Args && ... args) const
+  inline void record_times_helper(size_t index, Args && ... args) const
   {
-    record_times_helper(index, t);
-    record_times_helper(index + 1, std::forward<Args>(args)...);
+    (record_times_helper(index++, std::forward<Args>(args)), ...);
   }
 
  protected:
@@ -84,18 +86,19 @@ class CaloGPUTimed
   inline void record_times(const size_t event_num, const std::vector<size_t> & times) const
   {
     size_t old_size;
-    //Scope just for the lock_guard.
     {
-      std::lock_guard<std::mutex> lock_guard(m_timeMutex);
+      std::unique_lock<std::shared_mutex> lock(m_timeMutex);
       old_size = m_times.size();
       m_times.resize(old_size + times.size());
       m_eventNumbers.push_back(event_num);
     }
-
-    for (size_t i = 0; i < times.size(); ++i)
-      {
-        m_times[old_size + i] = times[i];
-      }
+    {
+      std::shared_lock<std::shared_mutex> lock(m_timeMutex);
+      for (size_t i = 0; i < times.size(); ++i)
+        {
+          m_times[old_size + i] = times[i];
+        }
+    }
   }
 
   template <class ... Args>
@@ -105,17 +108,18 @@ class CaloGPUTimed
 
     size_t old_size;
 
-    //Scope just for the lock_guard.
     {
-      std::lock_guard<std::mutex> lock_guard(m_timeMutex);
+      std::unique_lock<std::shared_mutex> lock(m_timeMutex);
       old_size = m_times.size();
       m_times.resize(old_size + time_size);
       m_eventNumbers.push_back(event_num);
     }
-
-    record_times_helper(old_size, value);
+    {
+      std::shared_lock<std::shared_mutex> lock(m_timeMutex);
+      record_times_helper(old_size, value);
+    }
   }
-  
+
   template <class ... Args>
   inline void record_times(const size_t event_num, const size_t & value, Args && ... args) const
   {
@@ -123,26 +127,30 @@ class CaloGPUTimed
 
     size_t old_size;
 
-    //Scope just for the lock_guard.
     {
-      std::lock_guard<std::mutex> lock_guard(m_timeMutex);
+      std::unique_lock<std::shared_mutex> lock(m_timeMutex);
       old_size = m_times.size();
       m_times.resize(old_size + time_size);
       m_eventNumbers.push_back(event_num);
     }
-
-    record_times_helper(old_size, value, std::forward<Args>(args)...);
+    {
+      std::shared_lock<std::shared_mutex> lock(m_timeMutex);
+      record_times_helper(old_size, value, std::forward<Args>(args)...);
+    }
 
   }
 
   inline void print_times(const std::string & header, const size_t time_size) const
   {
+    std::shared_lock<std::shared_mutex> lock(m_timeMutex);
+    
     if (m_timeFileName.size() == 0)
-    {
-      return;
-    }
-
+      {
+        return;
+      }
+    
     std::vector<size_t> indices(m_eventNumbers.size());
+    
     std::iota(indices.begin(), indices.end(), 0);
     std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b)
     {
@@ -156,16 +164,16 @@ class CaloGPUTimed
     for (const size_t idx : indices)
       {
         out << m_eventNumbers[idx] << " ";
-        
+
         size_t total = 0;
-        
+
         for (size_t i = 0; i < time_size; ++i)
           {
             total += m_times[idx * time_size + i];
           }
-        
+
         out << total << " ";
-        
+
         for (size_t i = 0; i < time_size; ++i)
           {
             out << m_times[idx * time_size + i] << " ";

Calorimeter/CaloRecGPU/CaloRecGPU/EtaPhiMap.h

@@ -32,7 +32,7 @@ namespace CaloRecGPU
   template <int eta_grid, int phi_grid, bool respect_deltas>
   struct EtaPhiMapEntry<eta_grid, phi_grid, respect_deltas, true>
   {
-    friend class EtaPhiMapEntry<eta_grid, phi_grid, respect_deltas, false>;
+    friend struct EtaPhiMapEntry<eta_grid, phi_grid, respect_deltas, false>;
 
     static constexpr int s_max_overlap_cells = 10;
     //We could/should try to refine things
@@ -1151,4 +1151,4 @@ namespace CaloRecGPU
   
 }
 
-#endif //CALORECGPU_ETAPHIMAP_H
\ No newline at end of file
+#endif //CALORECGPU_ETAPHIMAP_H

Calorimeter/CaloRecGPU/CaloRecGPU/EventInfoDefinitions.h

@@ -275,7 +275,7 @@ namespace CaloRecGPU
           if (qp.provenance() & mask)
             {
               const float this_time = time[cell];
-              if (fabsf(this_time) < threshold)
+              if (fabsf(this_time) >= threshold)
                 {
                   if (use_crosstalk)
                     {

Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h

 //
-// Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+// Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 //
 // Dear emacs, this is -*- c++ -*-
 //
@@ -16,6 +16,7 @@
 #include <iostream>
 #include <thread>
 #include <mutex>
+#include <shared_mutex>
 #include <memory>
 #include <vector>
 #include <climits>
@@ -62,7 +63,7 @@ namespace CaloRecGPU
   {
     if (code != cudaSuccess)
       {
-        printf("GPU Error: %s (%s %d)\n", cudaGetErrorString(code), file, line);
+        printf("CUDA error: %s (%s %d)\n", cudaGetErrorString(code), file, line);
         if (abort)
           {
 #ifdef __CUDA_ARCH__
@@ -109,16 +110,15 @@ namespace CaloRecGPU
     {
       void * ptr = nullptr;
 
-
-      operator void * () const
+      template <class T = const void>
+      constexpr operator T * () const
       {
-        return ptr;
+        return (T *) ptr;
       }
 
-      template <class T>
-      operator T * () const
+      constexpr operator bool() const
       {
-        return (T *) ptr;
+        return ptr != nullptr;
       }
 
       template <class T>
@@ -189,21 +189,21 @@ namespace CaloRecGPU
       \brief Synchronizes the \p stream. If called with no value, synchronizes with @c cudaStreamPerThread.
     */
     void GPU_synchronize(CUDAStreamPtrHolder stream = {});
-    
+
     /*!
       \brief Optimizes block and grid size according to @c cudaOccupancyMaxPotentialBlockSize.
     */
     void optimize_block_and_grid_size(void * func, int & block_size, int & grid_size, const int dynamic_memory = 0, const int block_size_limit = 0);
-    
+
     /*!
       \brief Optimizes block and grid size for a cooperative launch.
     */
     void optimize_block_and_grid_size_for_cooperative_launch(void * func, int & block_size, int & grid_size, const int dynamic_memory = 0, const int block_size_limit = 0);
-    
+
     bool supports_cooperative_launches();
-    
+
     bool supports_dynamic_parallelism();
-    
+
     std::string GPU_name();
   }
 
@@ -310,7 +310,7 @@ namespace CaloRecGPU
   inline constexpr T pi = std::numbers::pi_v<T>;
 
   template <class T>
-  inline constexpr T sqrt2 = std::numbers::sqrt2_v<T>
+  inline constexpr T sqrt2 = std::numbers::sqrt2_v<T>;
 #else
   template <class T>
   inline constexpr T pi = T(3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624L);
@@ -751,49 +751,46 @@ namespace CaloRecGPU
       {
       }
 
-      SimpleContainer(const indexer sz)
+      SimpleContainer(const indexer sz) : m_size(sz)
       {
         m_array = Manager::template allocate<Context>(sz);
-        m_size = sz;
       }
 
       /*!
         \warning We assume the pointer is in a valid memory location!
       */
-      SimpleContainer(T * other_array, const indexer sz)
+      SimpleContainer(T * other_array, const indexer sz) : m_size(sz)
       {
         m_array = Manager::template allocate<Context>(sz);
         Manager::template copy<Context, Context>(m_array, other_array, sz);
-        m_size = sz;
       }
 
-      SimpleContainer(const SimpleContainer & other)
+      SimpleContainer(const SimpleContainer & other) : m_size(other.m_size)
       {
-        m_size = other.m_size;
         m_array = Manager::template allocate<Context>(m_size);
         Manager::template copy<Context, Context>(m_array, other.m_array, m_size);
       }
 
-      SimpleContainer(SimpleContainer && other)
+      SimpleContainer(SimpleContainer && other) : m_size(other.m_size)
       {
-        m_size = other.m_size;
         m_array = nullptr;
         Manager::template move<Context, Context>(m_array, other.m_array, m_size);
         other.m_size = 0;
       }
 
       template <class other_indexer, class other_context, bool other_hold>
-      SimpleContainer(const SimpleContainer<T, other_indexer, other_context, other_hold> & other)
+      SimpleContainer(const SimpleContainer<T, other_indexer, other_context, other_hold> & other) :
+        m_size(other.m_size)
       {
-        m_size = other.m_size;
+
         m_array = Manager::template allocate<Context>(m_size);
         Manager::template copy<Context, other_context>(m_array, other.m_array, m_size);
       }
 
       template <class other_indexer, class other_context>
-      SimpleContainer(SimpleContainer<T, other_indexer, other_context, true> && other)
+      SimpleContainer(SimpleContainer<T, other_indexer, other_context, true> && other) :
+        m_size(other.m_size)
       {
-        m_size = other.m_size;
         m_array = nullptr;
         Manager::template move<Context, other_context>(m_array, other.m_array, m_size);
         other.m_size = 0;
@@ -1005,10 +1002,10 @@ namespace CaloRecGPU
       template <class other_indexer, bool other_hold>
       // cppcheck-suppress  uninitMemberVar
       //Try to suppress the uninitialized member thing that is probably being thrown off by the CUDA_HOS_DEV macro...
-      CUDA_HOS_DEV SimpleContainer(const SimpleContainer<T, other_indexer, Context, other_hold> & other)
+      CUDA_HOS_DEV SimpleContainer(const SimpleContainer<T, other_indexer, Context, other_hold> & other) :
+        m_size(other.m_size),
+        m_array(other.m_array)
       {
-        m_size = other.m_size;
-        m_array = other.m_array;
       }
 
       // cppcheck-suppress  operatorEqVarError
@@ -1488,30 +1485,39 @@ namespace CaloRecGPU
       //pushing and popping instead of linear searching.
       //(But with constant memory -> no (de)allocations.)
 
-      std::mutex m_mutex;
+      mutable std::shared_mutex m_mutex;
 
-     public:
-      T & get_one()
+      T & add_one_and_return()
       {
-        std::lock_guard<std::mutex> lock_guard(m_mutex);
-        std::thread::id this_id = std::this_thread::get_id();
-        const std::thread::id invalid_id{};
-        for (size_t i = 0; i < m_thread_equivs.size(); ++i)
-          {
-            if (m_thread_equivs[i] == invalid_id)
-              {
-                m_thread_equivs[i] = this_id;
-                return *(m_held[i]);
-              }
-          }
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         m_held.emplace_back(std::make_unique<T>());
-        m_thread_equivs.emplace_back(this_id);
+        m_thread_equivs.emplace_back(std::this_thread::get_id());
         return *(m_held.back());
       }
 
+     public:
+      T & get_one()
+      {
+        {
+          std::shared_lock<std::shared_mutex> lock(m_mutex);
+          std::thread::id this_id = std::this_thread::get_id();
+          const std::thread::id invalid_id{};
+          for (size_t i = 0; i < m_thread_equivs.size(); ++i)
+            {
+              if (m_thread_equivs[i] == invalid_id)
+                {
+                  m_thread_equivs[i] = this_id;
+                  return *(m_held[i]);
+                }
+            }
+        }
+        return add_one_and_return();
+      }
+
       ///\pre Assumes the thread already has an allocated object (through @p get_one).
       T & get_for_thread() const
       {
+        std::shared_lock<std::shared_mutex> lock(m_mutex);
         std::thread::id this_id = std::this_thread::get_id();
         for (size_t i = 0; i < m_thread_equivs.size(); ++i)
           {
@@ -1527,7 +1533,7 @@ namespace CaloRecGPU
 
       void release_one()
       {
-        std::lock_guard<std::mutex> lock_guard(m_mutex);
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         std::thread::id this_id = std::this_thread::get_id();
         const std::thread::id invalid_id{};
         for (size_t i = 0; i < m_thread_equivs.size(); ++i)
@@ -1541,7 +1547,7 @@ namespace CaloRecGPU
 
       void resize(const size_t new_size)
       {
-        std::lock_guard<std::mutex> lock_guard(m_mutex);
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         if (new_size < m_held.size())
           {
             m_held.resize(new_size);
@@ -1562,7 +1568,7 @@ namespace CaloRecGPU
       template <class F, class ... Args>
       void operate_on_all(F && f, Args && ... args)
       {
-        std::lock_guard<std::mutex> lock_guard(m_mutex);
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         for (std::unique_ptr<T> & obj : m_held)
           {
             f(*obj, std::forward<Args>(args)...);
@@ -1571,11 +1577,13 @@ namespace CaloRecGPU
 
       size_t held_size() const
       {
+        std::shared_lock<std::shared_mutex> lock(m_mutex);
         return m_held.size();
       }
 
       size_t available_size() const
       {
+        std::shared_lock<std::shared_mutex> lock(m_mutex);
         size_t count = 0;
         const std::thread::id invalid_id{};
         for (const auto & id : m_thread_equivs)
@@ -1590,7 +1598,17 @@ namespace CaloRecGPU
 
       size_t filled_size() const
       {
-        return this->held_size() - this->available_size();
+        std::shared_lock<std::shared_mutex> lock(m_mutex);
+        size_t count = 0;
+        const std::thread::id invalid_id{};
+        for (const auto & id : m_thread_equivs)
+          {
+            if (id == invalid_id)
+              {
+                ++count;
+              }
+          }
+        return m_held.size() - count;
       }
     };
 
@@ -1776,4 +1794,4 @@ namespace CaloRecGPU
 
 }
 
-#endif  // CALORECGPU_HELPERS_H
\ No newline at end of file
+#endif  // CALORECGPU_HELPERS_H

Calorimeter/CaloRecGPU/CaloRecGPU/NeighArr.h

 //
-// Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+// Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 //
 // Dear emacs, this is -*- c++ -*-
 //
@@ -121,8 +121,8 @@ namespace CaloRecGPU
         }
       else
         {*/
-          return get_number(option);
-        /*}*/
+      return get_number(option);
+      /*}*/
     }
 
     constexpr int get_total_number() const
@@ -146,13 +146,22 @@ namespace CaloRecGPU
       carrier mask = 0xFFFFFFFFFFFFFFFFULL;
       if (i >= s_more_bits_begin)
         {
+          // coverity[overflow_const]
           mask = mask << (s_bits_per_offset * s_more_bits_begin);
+          // coverity[overflow_const]
           mask = mask << (s_bits_per_last_offset * (i - s_more_bits_begin));
         }
       else
         {
+          // coverity[overflow_const]
           mask = mask << (s_bits_per_offset * i);
         }
+
+      //Suppressing coverity errors here since
+      //adding zeros to the beginning of the mask
+      //and ignoring the higher level bits
+      //is precisely the desired behaviour.
+
       mask &= s_only_numbers_mask;
       return s_offset_delta_pattern & mask;
     }
@@ -228,7 +237,7 @@ namespace CaloRecGPU
       return ret;
     }
   };
-  
+
   struct NeighPairsArr
   {
     int cell_A[NExactPairs];
@@ -277,7 +286,7 @@ namespace CaloRecGPU
       //we could consider some sort of code generation...
       constexpr int s_PS_start[NumNeighOptions] = {173888, 358016, 541056, 723584, 1432784, 1954480, 2364410, 2438696, 2439336, 2500008, 2529160, 2559756};
       constexpr int s_HECIW_FCal_start[NumNeighOptions] = {183232, 367360, 550272, 732672, 1469392, 1954480, 2435450, 2438824, 2439720, 2500008, 2529160, 2559756};
-      
+
       if (limited_PS && opt_idx != limited_option)
         {
           if (pair >= s_PS_start[opt_idx] && pair < s_HECIW_FCal_start[opt_idx])
@@ -301,4 +310,4 @@ namespace CaloRecGPU
   };
 
 }
-#endif //CALORECGPU_NEIGHARR_H
\ No newline at end of file
+#endif //CALORECGPU_NEIGHARR_H

Calorimeter/CaloRecGPU/CaloRecGPU/StandaloneDataIO.h

@@ -40,7 +40,7 @@ struct StandaloneDataIO
 
   struct ConstantInformation
   {
-    friend class StandaloneDataIO;
+    friend struct StandaloneDataIO;
 
    public:
 
@@ -109,7 +109,7 @@ struct StandaloneDataIO
 
   struct EventInformation
   {
-    friend class StandaloneDataIO;
+    friend struct StandaloneDataIO;
 
    public:
     inline static ErrorState read_cluster_info(const std::filesystem::path & file,

Calorimeter/CaloRecGPU/python/CaloRecGPUConfig.py

-# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
 from AthenaConfiguration.ComponentFactory import CompFactory
@@ -12,508 +12,677 @@ def ComparedToolsToPlot(tool_ref, tool_test, prefix, match_in_energy = False, ma
 def MatchingOptions(min_similarity = 0.50, terminal_weight = 250., grow_weight = 500., seed_weight = 1000.):
     return (min_similarity, terminal_weight, grow_weight, seed_weight)
 
-def BasicConstantDataExporterToolCfg(flags, name = "ConstantDataExporter"):
+def BasicConstantDataExporterToolCfg(flags, name = "ConstantDataExporter", **kwargs):
     result=ComponentAccumulator()
-    ConstantDataExporter = CompFactory.BasicConstantGPUDataExporter(name)
-    ConstantDataExporter.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
-    ConstantDataExporter.TimeFileOutput = "ConstantDataExporterTimes.txt"
+    
+    kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
+    kwargs.setdefault("TimeFileOutput", name + "Times.txt")
+        
+    ConstantDataExporter = CompFactory.BasicConstantGPUDataExporter(name, **kwargs)
+    
     result.setPrivateTools(ConstantDataExporter)
     return result
 
-def BasicEventDataExporterToolCfg(flags, name = "EventDataExporter"):
+def BasicEventDataExporterToolCfg(flags, cellsname, name = "EventDataExporter", **kwargs):
     result=ComponentAccumulator()
-    EventDataExporter = CompFactory.BasicEventDataGPUExporter(name)
-    EventDataExporter.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
-    EventDataExporter.TimeFileOutput = "EventDataExporterTimes.txt"
-    EventDataExporter.CellsName = flags.CaloRecGPU.ActiveConfig.CellsName
+    
+    kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
+    kwargs.setdefault("TimeFileOutput", name + "Times.txt")
+    
+    kwargs.setdefault("CellsName", cellsname)
+      
     if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
-        EventDataExporter.MissingCellsToFill = flags.CaloRecGPU.ActiveConfig.MissingCellsToFill
+        kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
+                
+    EventDataExporter = CompFactory.BasicEventDataGPUExporter(name, **kwargs)
+    
     result.setPrivateTools(EventDataExporter)
     return result
 
-def BasicAthenaClusterImporterToolCfg(flags, name = "AthenaClusterImporter"):
+def BasicAthenaClusterImporterToolCfg(flags, cellsname, name = "ClusterImporter", **kwargs):
     result=ComponentAccumulator()
-    AthenaClusterImporter = CompFactory.BasicGPUToAthenaImporter(name)
-    AthenaClusterImporter.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
-    AthenaClusterImporter.TimeFileOutput = "ClusterImporterTimes.txt"
-    AthenaClusterImporter.CellsName = flags.CaloRecGPU.ActiveConfig.CellsName
-    AthenaClusterImporter.ClusterSize = flags.CaloRecGPU.ActiveConfig.ClusterSize
+    kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
+    kwargs.setdefault("TimeFileOutput", name + "Times.txt")
+    kwargs.setdefault("CellsName", cellsname)
+    kwargs.setdefault("ClusterSize", flags.CaloRecGPU.ActiveConfig.ClusterSize)
     if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
-        AthenaClusterImporter.MissingCellsToFill = flags.CaloRecGPU.ActiveConfig.MissingCellsToFill
+        kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
+                
+    AthenaClusterImporter = CompFactory.BasicGPUToAthenaImporter(name, **kwargs)
     result.setPrivateTools(AthenaClusterImporter)
     return result
 
-def CaloClusterDeleterToolCfg(flags, name = "ClusterDeleter"):
+def CPUOutputToolCfg(flags, cellsname, name = "CPUOutput", **kwargs):
     result=ComponentAccumulator()
-    ClusterDeleter = CompFactory.CaloClusterDeleter(name)
-    result.setPrivateTools(ClusterDeleter)
-    return result
-
-def CPUOutputToolCfg(flags, name = "CPUOutput",  folder = "output", prefix = "", suffix = ""):
-    result=ComponentAccumulator()
-    CPUOutput = CompFactory.CaloCPUOutput(name)
-    CPUOutput.SavePath = folder
-    CPUOutput.FilePrefix = prefix
-    CPUOutput.FileSuffix = suffix
-    CPUOutput.CellsName = flags.CaloRecGPU.ActiveConfig.CellsName
+    kwargs.setdefault("CellsName", cellsname)
+    kwargs.setdefault("SavePath", "output")
+    
+    CPUOutput = CompFactory.CaloCPUOutput(name, **kwargs)
     result.setPrivateTools(CPUOutput)
     return result
 
-def GPUOutputToolCfg(flags, name = "GPUOutput",  folder = "output", prefix = "", suffix = "", OnlyOutputCells = None):
+def GPUOutputToolCfg(flags, name = "GPUOutput", **kwargs):
     result=ComponentAccumulator()
-    GPUOutput = CompFactory.CaloGPUOutput(name)
-    GPUOutput.SavePath = folder
-    GPUOutput.FilePrefix = prefix
-    GPUOutput.FileSuffix = suffix
-    GPUOutput.UseSortedAndCutClusters = True
-    if OnlyOutputCells is not None:
-        GPUOutput.OnlyOutputCellInfo = OnlyOutputCells
+    kwargs.setdefault("UseSortedAndCutClusters", True)
+    kwargs.setdefault("SavePath", "output")
+        
+    GPUOutput = CompFactory.CaloGPUOutput(name, **kwargs)
     result.setPrivateTools(GPUOutput)
     return result
 
-def ClusterInfoCalcToolCfg(flags, name = "GPUClusterInfoCalculator", do_cut = True):
+def ClusterInfoCalcToolCfg(flags, name = "GPUClusterInfoCalculator", do_cut = True, **kwargs):
     result=ComponentAccumulator()
-    CalcTool = CompFactory.BasicGPUClusterInfoCalculator(name)
-    CalcTool.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
-    CalcTool.TimeFileOutput = name + "Times.txt"
+    kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
+    kwargs.setdefault("TimeFileOutput", name + "Times.txt")
     if do_cut:
-        if not flags.hasFlag('CaloRecGPU.ActiveConfig.CutClustersInAbsEt') :
-            CalcTool.ClusterCutsInAbsEt = flags.CaloRecGPU.ActiveConfig.TopoClusterSeedCutsInAbsE
-        else:
-            CalcTool.ClusterCutsInAbsEt = flags.CaloRecGPU.ActiveConfig.CutClustersInAbsEt
-        CalcTool.ClusterEtorAbsEtCut = flags.CaloRecGPU.ActiveConfig.ClusterEtorAbsEtCut
+        kwargs.setdefault("ClusterCutsInAbsEt", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterCutClustersInAbsEt)
+        kwargs.setdefault("ClusterEtorAbsEtCut", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterEnergyCut)
     else:
-        CalcTool.ClusterCutsInAbsEt = True
-        CalcTool.ClusterEtorAbsEtCut = -1
+        kwargs.setdefault("ClusterCutsInAbsEt", True)
+        kwargs.setdefault("ClusterEtorAbsEtCut", -1)
         #Cutting on absolute value with a negative value => not cutting at all.
 
+    CalcTool = CompFactory.BasicGPUClusterInfoCalculator(name, **kwargs)
     result.setPrivateTools(CalcTool)
     return result
 
-def TopoAutomatonClusteringToolCfg(flags, name = "TAClusterMaker"):
+def TopoAutomatonClusteringToolCfg(flags, name = "TopoAutomatonClustering", **kwargs):
     result=ComponentAccumulator()
-    # maker tools
-    TAClusterMaker = CompFactory.TopoAutomatonClustering(name)
 
-    TAClusterMaker.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
-    TAClusterMaker.TimeFileOutput = "TopoAutomatonClusteringTimes.txt"
+    kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
+    kwargs.setdefault("TimeFileOutput", name + "Times.txt")
 
-    TAClusterMaker.CalorimeterNames= flags.CaloRecGPU.ActiveConfig.CalorimeterNames
+    kwargs.setdefault("CalorimeterNames", flags.CaloRecGPU.ActiveConfig.GrowingCalorimeterNames)
 
-    TAClusterMaker.SeedSamplingNames = flags.CaloRecGPU.ActiveConfig.TopoClusterSeedSamplingNames
+    kwargs.setdefault("SeedSamplingNames", flags.CaloRecGPU.ActiveConfig.GrowingSeedSamplingNames)
 
-    TAClusterMaker.CellThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRCellThreshold
-    TAClusterMaker.NeighborThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRGrowThreshold
-    TAClusterMaker.SeedThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRSeedThreshold
+    kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
+    kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
+    kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
 
-    TAClusterMaker.SeedCutsInAbsE = flags.CaloRecGPU.ActiveConfig.TopoClusterSeedCutsInAbsE
-    TAClusterMaker.NeighborCutsInAbsE = flags.CaloRecGPU.ActiveConfig.TopoClusterNeighborCutsInAbsE
-    TAClusterMaker.CellCutsInAbsE = flags.CaloRecGPU.ActiveConfig.TopoClusterCellCutsInAbsE
+    kwargs.setdefault("SeedCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsSeedThreshold)
+    kwargs.setdefault("NeighborCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsGrowThreshold)
+    kwargs.setdefault("CellCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsTermThreshold)
 
-    TAClusterMaker.TwoGaussianNoise = flags.CaloRecGPU.ActiveConfig.TwoGaussianNoise
+    kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
 
+    kwargs.setdefault("SeedCutsInT", flags.CaloRecGPU.ActiveConfig.doTimeCut)
+    kwargs.setdefault("CutOOTseed", flags.CaloRecGPU.ActiveConfig.doTimeCut and flags.CaloRecGPU.ActiveConfig.extendTimeCut)
+    kwargs.setdefault("UseTimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.useUpperLimitForTimeCut)
+    kwargs.setdefault("TimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.timeCutUpperLimit)
+    
+    kwargs.setdefault("SeedThresholdOnTAbs", flags.CaloRecGPU.ActiveConfig.GrowingTimeCutSeedThreshold)
+    
+    kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.GrowingTreatL1PredictedCellsAsGood)
 
-    TAClusterMaker.SeedCutsInT = flags.CaloRecGPU.ActiveConfig.SeedCutsInT
-    TAClusterMaker.CutOOTseed = flags.CaloRecGPU.ActiveConfig.CutOOTseed
-    TAClusterMaker.UseTimeCutUpperLimit = flags.CaloRecGPU.ActiveConfig.UseTimeCutUpperLimit
-    TAClusterMaker.TimeCutUpperLimit = flags.CaloRecGPU.ActiveConfig.TimeCutUpperLimit
-    TAClusterMaker.SeedThresholdOnTAbs = flags.CaloRecGPU.ActiveConfig.SeedThresholdOnTAbs
-    TAClusterMaker.TreatL1PredictedCellsAsGood = flags.CaloRecGPU.ActiveConfig.TreatL1PredictedCellsAsGood
+    kwargs.setdefault("XTalkEM2", flags.CaloRecGPU.ActiveConfig.xtalkEM2)
+    kwargs.setdefault("XTalkDeltaT", flags.CaloRecGPU.ActiveConfig.xtalkDeltaT)
+    
+    #The other cross-talk options are not supported yet.
 
-    TAClusterMaker.XTalkEM2 = flags.CaloRecGPU.ActiveConfig.UseEM2CrossTalk
-    TAClusterMaker.XTalkDeltaT = flags.CaloRecGPU.ActiveConfig.CrossTalkDeltaT
-
-    TAClusterMaker.NeighborOption = flags.CaloRecGPU.ActiveConfig.NeighborOption
-    TAClusterMaker.RestrictHECIWandFCalNeighbors  = flags.CaloRecGPU.ActiveConfig.RestrictHECIWandFCalNeighbors
-    TAClusterMaker.RestrictPSNeighbors  = flags.CaloRecGPU.ActiveConfig.RestrictPSNeighbors
+    kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.GrowingNeighborOption)
+    
+    kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictHECIWandFCalNeighbors)
+    
+    kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictPSNeighbors)
 
+    TAClusterMaker = CompFactory.TopoAutomatonClustering(name, **kwargs)
     result.setPrivateTools(TAClusterMaker)
     return result
 
-def DefaultTopologicalClusteringToolCfg(flags, name = "TopoMaker"):
+def DefaultTopologicalClusteringToolCfg(flags, cellsname, name = "TopoClusterMaker", **kwargs):
     result=ComponentAccumulator()
-    # maker tools
-    TopoMaker = CompFactory.CaloTopoClusterMaker(name)
-
-    TopoMaker.CellsName = flags.CaloRecGPU.ActiveConfig.CellsName
-    TopoMaker.CalorimeterNames= flags.CaloRecGPU.ActiveConfig.CalorimeterNames
-    TopoMaker.SeedSamplingNames = flags.CaloRecGPU.ActiveConfig.TopoClusterSeedSamplingNames
-    TopoMaker.NeighborOption = flags.CaloRecGPU.ActiveConfig.NeighborOption
-    TopoMaker.RestrictHECIWandFCalNeighbors  = flags.CaloRecGPU.ActiveConfig.RestrictHECIWandFCalNeighbors
-    TopoMaker.RestrictPSNeighbors  = flags.CaloRecGPU.ActiveConfig.RestrictPSNeighbors
-    TopoMaker.CellThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRCellThreshold
-    TopoMaker.NeighborThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRGrowThreshold
-    TopoMaker.SeedThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRSeedThreshold
-
-    TopoMaker.SeedCutsInT = flags.CaloRecGPU.ActiveConfig.SeedCutsInT
-    TopoMaker.CutOOTseed = flags.CaloRecGPU.ActiveConfig.CutOOTseed
-    TopoMaker.UseTimeCutUpperLimit = flags.CaloRecGPU.ActiveConfig.UseTimeCutUpperLimit
-    TopoMaker.TimeCutUpperLimit = flags.CaloRecGPU.ActiveConfig.TimeCutUpperLimit
-
-    TopoMaker.ClusterEtorAbsEtCut  = flags.CaloRecGPU.ActiveConfig.ClusterEtorAbsEtCut
-    TopoMaker.TwoGaussianNoise = flags.CaloRecGPU.ActiveConfig.TwoGaussianNoise
-    TopoMaker.SeedCutsInAbsE = flags.CaloRecGPU.ActiveConfig.TopoClusterSeedCutsInAbsE
-    TopoMaker.NeighborCutsInAbsE = flags.CaloRecGPU.ActiveConfig.TopoClusterNeighborCutsInAbsE
-    TopoMaker.CellCutsInAbsE = flags.CaloRecGPU.ActiveConfig.TopoClusterCellCutsInAbsE
-    TopoMaker.SeedThresholdOnTAbs = flags.CaloRecGPU.ActiveConfig.SeedThresholdOnTAbs
-
-    TopoMaker.TreatL1PredictedCellsAsGood = flags.CaloRecGPU.ActiveConfig.TreatL1PredictedCellsAsGood
-
-    TopoMaker.UseGPUCriteria = not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria
-
-    TopoMaker.XTalkEM2 = flags.CaloRecGPU.ActiveConfig.UseEM2CrossTalk
-    TopoMaker.XTalkDeltaT = flags.CaloRecGPU.ActiveConfig.CrossTalkDeltaT
 
+    kwargs.setdefault("CellsName", cellsname)
+    
+    kwargs.setdefault("CalorimeterNames", flags.CaloRecGPU.ActiveConfig.GrowingCalorimeterNames)
+    kwargs.setdefault("SeedSamplingNames", flags.CaloRecGPU.ActiveConfig.GrowingSeedSamplingNames)
+    
+    kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.GrowingNeighborOption)
+    kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictHECIWandFCalNeighbors)
+    kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictPSNeighbors)
+    
+    kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
+    kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
+    kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
+    
+    kwargs.setdefault("SeedCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsSeedThreshold)
+    kwargs.setdefault("NeighborCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsGrowThreshold)
+    kwargs.setdefault("CellCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsTermThreshold)
+
+    kwargs.setdefault("SeedCutsInT", flags.CaloRecGPU.ActiveConfig.doTimeCut)
+    kwargs.setdefault("CutOOTseed", flags.CaloRecGPU.ActiveConfig.doTimeCut and flags.CaloRecGPU.ActiveConfig.extendTimeCut)
+    kwargs.setdefault("UseTimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.useUpperLimitForTimeCut)
+    kwargs.setdefault("TimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.timeCutUpperLimit)
+    kwargs.setdefault("XTalkEM2", flags.CaloRecGPU.ActiveConfig.xtalkEM2)
+    kwargs.setdefault("XTalkEM2D", flags.CaloRecGPU.ActiveConfig.xtalkEM2D)
+    kwargs.setdefault("XTalkEM2n", flags.CaloRecGPU.ActiveConfig.xtalkEM2n)
+    kwargs.setdefault("XTalkEM3", flags.CaloRecGPU.ActiveConfig.xtalkEM3)
+    kwargs.setdefault("XTalkEMEta", flags.CaloRecGPU.ActiveConfig.xtalkEMEta)
+    kwargs.setdefault("XTalkDeltaT", flags.CaloRecGPU.ActiveConfig.xtalkDeltaT)
+    kwargs.setdefault("XTalk2Eratio1", flags.CaloRecGPU.ActiveConfig.xtalk2Eratio1)
+    kwargs.setdefault("XTalk2Eratio2", flags.CaloRecGPU.ActiveConfig.xtalk2Eratio2)
+    kwargs.setdefault("XTalk3Eratio", flags.CaloRecGPU.ActiveConfig.xtalk3Eratio)
+    kwargs.setdefault("XTalkEtaEratio", flags.CaloRecGPU.ActiveConfig.xtalkEtaEratio)
+    kwargs.setdefault("XTalk2DEratio", flags.CaloRecGPU.ActiveConfig.xtalk2DEratio)
+    
+    kwargs.setdefault("ClusterCutsInAbsEt", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterCutClustersInAbsEt)
+    kwargs.setdefault("ClusterEtorAbsEtCut", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterEnergyCut)
+    
+    kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
+    
+    kwargs.setdefault("SeedThresholdOnTAbs", flags.CaloRecGPU.ActiveConfig.GrowingTimeCutSeedThreshold)
+
+    kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.GrowingTreatL1PredictedCellsAsGood)
+
+    kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
+
+    TopoMaker = CompFactory.CaloTopoClusterMaker(name, **kwargs)
     result.setPrivateTools(TopoMaker)
     return result
 
-def TopoAutomatonSplitterToolCfg(flags, name = "TopoAutomatonSplitter"):
+def TopoAutomatonSplitterToolCfg(flags, name = "ClusterSplitter", **kwargs):
     result=ComponentAccumulator()
-    # maker tools
-    Splitter = CompFactory.TopoAutomatonSplitting(name)
-
-    Splitter.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
-    Splitter.TimeFileOutput = "ClusterSplitterTimes.txt"
-
-    Splitter.NumberOfCellsCut = flags.CaloRecGPU.ActiveConfig.SplitterNumberOfCellsCut
-    Splitter.EnergyCut = flags.CaloRecGPU.ActiveConfig.SplitterEnergyCut
-    Splitter.SamplingNames = flags.CaloRecGPU.ActiveConfig.SplitterSamplingNames
-    Splitter.SecondarySamplingNames = flags.CaloRecGPU.ActiveConfig.SplitterSecondarySamplingNames
-    Splitter.ShareBorderCells = flags.CaloRecGPU.ActiveConfig.SplitterShareBorderCells
-    Splitter.EMShowerScale = flags.CaloRecGPU.ActiveConfig.EMShowerScale
-    Splitter.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.SplitterUseNegativeClusters
-
-    Splitter.TreatL1PredictedCellsAsGood = flags.CaloRecGPU.ActiveConfig.TreatL1PredictedCellsAsGood
-
-    Splitter.NeighborOption = flags.CaloRecGPU.ActiveConfig.NeighborOption
-    Splitter.RestrictHECIWandFCalNeighbors  = flags.CaloRecGPU.ActiveConfig.RestrictHECIWandFCalNeighbors
-    Splitter.RestrictPSNeighbors = flags.CaloRecGPU.ActiveConfig.RestrictPSNeighbors and flags.CaloRecGPU.ActiveConfig.AlsoRestrictPSOnGPUSplitter
+    
+    kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
+    kwargs.setdefault("TimeFileOutput", name + "Times.txt")
+
+    kwargs.setdefault("NumberOfCellsCut", flags.CaloRecGPU.ActiveConfig.SplittingNumberOfCellsCut)
+    kwargs.setdefault("EnergyCut", flags.CaloRecGPU.ActiveConfig.SplittingEnergyCut)
+    kwargs.setdefault("SamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSamplingNames)
+    kwargs.setdefault("SecondarySamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSecondarySamplingNames)
+    kwargs.setdefault("ShareBorderCells", flags.CaloRecGPU.ActiveConfig.SplittingShareBorderCells)
+    kwargs.setdefault("EMShowerScale", flags.CaloRecGPU.ActiveConfig.SplittingEMShowerScale)
+    kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.SplittingUseNegativeClusters)
+
+    kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.SplittingTreatL1PredictedCellsAsGood)
+
+    kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.SplittingNeighborOption)
+    kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.SplittingRestrictHECIWandFCalNeighbors)
+    kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GPUSplittingRestrictPSNeighbors)
     #Since the CPU version does not restrict this!
 
+    Splitter = CompFactory.TopoAutomatonSplitting(name, **kwargs)
     result.setPrivateTools(Splitter)
     return result
 
-def GPUClusterSplitterToolCfg(flags, name = "GPUClusterSplitter"):
+def DefaultClusterSplittingToolCfg(flags, name = "TopoSplitter", **kwargs):
     result=ComponentAccumulator()
-    # maker tools
-    Splitter = CompFactory.CaloTopoClusterSplitterGPU(name)
-
-    Splitter.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
-    Splitter.TimeFileOutput = "ClusterSplitterTimes.txt"
-
-    Splitter.NumberOfCellsCut = flags.CaloRecGPU.ActiveConfig.SplitterNumberOfCellsCut
-    Splitter.EnergyCut = flags.CaloRecGPU.ActiveConfig.SplitterEnergyCut
-    Splitter.SamplingNames = flags.CaloRecGPU.ActiveConfig.SplitterSamplingNames
-    Splitter.SecondarySamplingNames = flags.CaloRecGPU.ActiveConfig.SplitterSecondarySamplingNames
-    Splitter.ShareBorderCells = flags.CaloRecGPU.ActiveConfig.SplitterShareBorderCells
-    Splitter.EMShowerScale = flags.CaloRecGPU.ActiveConfig.EMShowerScale
-    Splitter.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.SplitterUseNegativeClusters
-
-    Splitter.TreatL1PredictedCellsAsGood = flags.CaloRecGPU.ActiveConfig.TreatL1PredictedCellsAsGood
+    
+    kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.SplittingNeighborOption)
+    kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.SplittingRestrictHECIWandFCalNeighbors)
 
-    result.setPrivateTools(Splitter)
-    return result
-
-def DefaultClusterSplittingToolCfg(flags, name = "TopoSplitter"):
-    result=ComponentAccumulator()
-    # maker tools
-    TopoSplitter = CompFactory.CaloTopoClusterSplitter(name)
+    kwargs.setdefault("NumberOfCellsCut", flags.CaloRecGPU.ActiveConfig.SplittingNumberOfCellsCut)
+    kwargs.setdefault("EnergyCut", flags.CaloRecGPU.ActiveConfig.SplittingEnergyCut)
 
+    kwargs.setdefault("SamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSamplingNames)
+    kwargs.setdefault("SecondarySamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSecondarySamplingNames)
 
-    TopoSplitter.NeighborOption = flags.CaloRecGPU.ActiveConfig.NeighborOption
-    TopoSplitter.RestrictHECIWandFCalNeighbors  = flags.CaloRecGPU.ActiveConfig.RestrictHECIWandFCalNeighbors
+    kwargs.setdefault("ShareBorderCells", flags.CaloRecGPU.ActiveConfig.SplittingShareBorderCells)
+    kwargs.setdefault("EMShowerScale", flags.CaloRecGPU.ActiveConfig.SplittingEMShowerScale)
 
-    TopoSplitter.NumberOfCellsCut = flags.CaloRecGPU.ActiveConfig.SplitterNumberOfCellsCut
-    TopoSplitter.EnergyCut = flags.CaloRecGPU.ActiveConfig.SplitterEnergyCut
+    kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.SplittingTreatL1PredictedCellsAsGood)
 
-    TopoSplitter.SamplingNames = flags.CaloRecGPU.ActiveConfig.SplitterSamplingNames
-    TopoSplitter.SecondarySamplingNames = flags.CaloRecGPU.ActiveConfig.SplitterSecondarySamplingNames
+    kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.SplittingUseNegativeClusters)
 
-    TopoSplitter.ShareBorderCells = flags.CaloRecGPU.ActiveConfig.SplitterShareBorderCells
-    TopoSplitter.EMShowerScale = flags.CaloRecGPU.ActiveConfig.EMShowerScale
-
-    TopoSplitter.TreatL1PredictedCellsAsGood = flags.CaloRecGPU.ActiveConfig.TreatL1PredictedCellsAsGood
-
-    TopoSplitter.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.SplitterUseNegativeClusters
-
-    TopoSplitter.UseGPUCriteria = not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria
+    kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
 
+    TopoSplitter = CompFactory.CaloTopoClusterSplitter(name, **kwargs)
     result.setPrivateTools(TopoSplitter)
     return result
 
-def GPUClusterMomentsCalculatorToolCfg(flags, name = "GPUTopoMoments"):
-
+def GPUClusterMomentsCalculatorToolCfg(flags, name = "GPUTopoMoments", **kwargs):
     result=ComponentAccumulator()
-    GPUTopoMoments = CompFactory.GPUClusterInfoAndMomentsCalculator(name)
 
-    GPUTopoMoments.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
+    kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
 
-    if flags.CaloRecGPU.ActiveConfig.UseAbsEnergyMoments is None:
-        GPUTopoMoments.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.TopoClusterSeedCutsInAbsE
-    else:
-        GPUTopoMoments.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.UseAbsEnergyMoments
+    kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.MomentsUseAbsEnergy)
 
-    GPUTopoMoments.MaxAxisAngle = flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle
+    kwargs.setdefault("MaxAxisAngle", flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle)
 
-    GPUTopoMoments.TwoGaussianNoise = flags.CaloRecGPU.ActiveConfig.TwoGaussianNoise
+    kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
 
-    GPUTopoMoments.MinBadLArQuality = flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality
+    kwargs.setdefault("MinBadLArQuality", flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality)
 
-    GPUTopoMoments.MinRLateral = flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral
-    GPUTopoMoments.MinLLongitudinal = flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal
+    kwargs.setdefault("MinRLateral", flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral)
+    kwargs.setdefault("MinLLongitudinal", flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal)
 
+    GPUTopoMoments = CompFactory.GPUClusterInfoAndMomentsCalculator(name, **kwargs)
     result.setPrivateTools(GPUTopoMoments)
     return result
 
-def DefaultClusterMomentsCalculatorToolCfg(flags, name = "TopoMoments"):
+def DefaultClusterMomentsCalculatorToolCfg(flags, instantiateForTrigger, name = "TopoMoments", **kwargs):
     result=ComponentAccumulator()
-    TopoMoments = CompFactory.CaloClusterMomentsMaker(name)
 
-    if flags.CaloRecGPU.ActiveConfig.UseAbsEnergyMoments is None:
-        TopoMoments.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.TopoClusterSeedCutsInAbsE
-    else:
-        TopoMoments.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.UseAbsEnergyMoments
+    kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.MomentsUseAbsEnergy)
 
-    TopoMoments.MaxAxisAngle = flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle
+    kwargs.setdefault("MaxAxisAngle", flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle)
 
-    TopoMoments.TwoGaussianNoise = flags.CaloRecGPU.ActiveConfig.TwoGaussianNoise
+    kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
 
-    TopoMoments.MinBadLArQuality = flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality
+    kwargs.setdefault("MinBadLArQuality", flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality)
 
-    TopoMoments.MomentsNames = flags.CaloRecGPU.ActiveConfig.MomentsToCalculate
+    kwargs.setdefault("MomentsNames", flags.CaloRecGPU.ActiveConfig.MomentsToCalculate)
 
-    TopoMoments.MinRLateral = flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral
-    TopoMoments.MinLLongitudinal = flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal
+    kwargs.setdefault("MinRLateral", flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral)
+    kwargs.setdefault("MinLLongitudinal", flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal)
 
-    if not flags.Common.isOnline:
+    kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
+        
+    TopoMoments = CompFactory.CaloClusterMomentsMaker(name, **kwargs)
+    
+    if not flags.Common.isOnline and not instantiateForTrigger and "LArHVFraction" not in kwargs:
+        #If it's already in kwargs, don't override
+        #(extra flexibility for the user, not that it's needed...)
+        from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBCfg
+        result.merge(LArElecCalibDBCfg(flags,["HVScaleCorr"]))
         if flags.Input.isMC:
             TopoMoments.LArHVFraction=CompFactory.LArHVFraction(HVScaleCorrKey="LArHVScaleCorr")
         else:
             TopoMoments.LArHVFraction=CompFactory.LArHVFraction(HVScaleCorrKey="LArHVScaleCorrRecomputed")
-
-    TopoMoments.UseGPUCriteria = not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria
-
+    
     result.setPrivateTools(TopoMoments)
     return result
 
-def AthenaClusterAndMomentsImporterToolCfg(flags, name = "AthenaClusterImporter"):
+def AthenaClusterAndMomentsImporterToolCfg(flags, cellsname, instantiateForTrigger, name = "ClusterAndMomentsImporter", **kwargs):
     result=ComponentAccumulator()
-    AthenaClusterImporter = CompFactory.GPUToAthenaImporterWithMoments(name)
-    AthenaClusterImporter.CellsName = flags.CaloRecGPU.ActiveConfig.CellsName
-    AthenaClusterImporter.ClusterSize = flags.CaloRecGPU.ActiveConfig.ClusterSize
+    kwargs.setdefault("CellsName", cellsname)
+    
+    kwargs.setdefault("ClusterSize", flags.CaloRecGPU.ActiveConfig.ClusterSize)
 
-    AthenaClusterImporter.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
-    AthenaClusterImporter.TimeFileOutput = "ClusterAndMomentsImporterTimes.txt"
+    kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
+    kwargs.setdefault("TimeFileOutput", name + "Times.txt")
 
-    #from LArCellRec.LArCellBuilderConfig import LArHVCellContCorrCfg
-    #theLArHVCellContCorr=LArHVCellContCorrCfg(flags)
-    #result.merge(theLArHVCellContCorr)
-    #from LArCalibUtils.LArHVScaleConfig import LArHVScaleCfg
-    #result.merge(LArHVScaleCfg(flags))
-
-
-
-    if not flags.Common.isOnline:
+    if not flags.Common.isOnline and not instantiateForTrigger:
+        kwargs.setdefault("FillHVMoments", True)
         if flags.Input.isMC:
-            AthenaClusterImporter.HVScaleCorrKey = "LArHVScaleCorr"
+            kwargs.setdefault("HVScaleCorrKey", "LArHVScaleCorr")
         else:
-            AthenaClusterImporter.HVScaleCorrKey = "LArHVScaleCorrRecomputed"
+            kwargs.setdefault("HVScaleCorrKey", "LArHVScaleCorrRecomputed")
+    else:
+        kwargs.setdefault("FillHVMoments", False)
 
-    AthenaClusterImporter.MomentsNames = flags.CaloRecGPU.ActiveConfig.MomentsToCalculate
+    kwargs.setdefault("MomentsNames", flags.CaloRecGPU.ActiveConfig.MomentsToCalculate)
 
     if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
-        AthenaClusterImporter.MissingCellsToFill = flags.CaloRecGPU.ActiveConfig.MissingCellsToFill
+        kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
 
+    AthenaClusterImporter = CompFactory.GPUToAthenaImporterWithMoments(name, **kwargs)
     result.setPrivateTools(AthenaClusterImporter)
     return result
 
-def CellsCounterCPUToolCfg(flags, name = "CPUCounts", folder = "counts", prefix = "CPU", suffix = ""):
+def CellsCounterCPUToolCfg(flags, cellsname, name = "CPUCounts", **kwargs):
     result=ComponentAccumulator()
-    CPUCount = CompFactory.CaloCellsCounterCPU(name)
-    CPUCount.SavePath = folder
-    CPUCount.FilePrefix = prefix
-    CPUCount.FileSuffix = suffix
-    CPUCount.CellsName = flags.CaloRecGPU.ActiveConfig.CellsName
+    kwargs.setdefault("SavePath", "counts")
+    kwargs.setdefault("FilePrefix", "CPU")
+    kwargs.setdefault("CellsName", cellsname)
 
-    CPUCount.CellThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRCellThreshold
-    CPUCount.NeighborThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRGrowThreshold
-    CPUCount.SeedThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRSeedThreshold
+    kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
+    kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
+    kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
 
+    CPUCount = CompFactory.CaloCellsCounterCPU(name, **kwargs)
     result.setPrivateTools(CPUCount)
     return result
 
-def CellsCounterGPUToolCfg(flags, name = "GPUCounts", folder = "counts", prefix = "GPU", suffix = ""):
+def CellsCounterGPUToolCfg(flags, name = "GPUCounts", **kwargs):
     result=ComponentAccumulator()
-    GPUCount = CompFactory.CaloCellsCounterGPU(name)
-    GPUCount.SavePath = folder
-    GPUCount.FilePrefix = prefix
-    GPUCount.FileSuffix = suffix
+    kwargs.setdefault("SavePath", "counts")
+    kwargs.setdefault("FilePrefix", "GPU")
 
-    GPUCount.CellThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRCellThreshold
-    GPUCount.NeighborThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRGrowThreshold
-    GPUCount.SeedThresholdOnEorAbsEinSigma = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRSeedThreshold
+    kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
+    kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
+    kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
 
+    GPUCount = CompFactory.CaloCellsCounterGPU(name, **kwargs)
     result.setPrivateTools(GPUCount)
     return result
 
-def MomentsDumperToolCfg(flags, folder = "moments", name = "MomentsDumper", prefix = "", suffix = ""):
+def MomentsDumperToolCfg(flags, name = "MomentsDumper", **kwargs):
     result=ComponentAccumulator()
-    GPUCount = CompFactory.CaloMomentsDumper(name)
-    GPUCount.SavePath = folder
-    GPUCount.FilePrefix = prefix
-    GPUCount.FileSuffix = suffix
+    kwargs.setdefault("SavePath", "moments")
 
-    result.setPrivateTools(GPUCount)
+    MomentsDumper = CompFactory.CaloMomentsDumper(name, **kwargs)
+    result.setPrivateTools(MomentsDumper)
     return result
 
-def PlotterMonitoringToolCfg(flags, name = "PlotterMonitoring"):
+def PlotterToolCfg(flags, cellsname, name = "PlotterMonitoring", **kwargs):
     result=ComponentAccumulator()
-    PloTool = CompFactory.CaloGPUClusterAndCellDataMonitor(name)
 
-    PloTool.CellThreshold = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRCellThreshold
-    PloTool.NeighborThreshold = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRGrowThreshold
-    PloTool.SeedThreshold = flags.CaloRecGPU.ActiveConfig.TopoClusterSNRSeedThreshold
+    kwargs.setdefault("SeedThreshold", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
+    kwargs.setdefault("NeighborThreshold", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
+    kwargs.setdefault("CellThreshold", flags.CaloRecGPU.ActiveConfig.TermThreshold)
 
-    PloTool.CellsName = flags.CaloRecGPU.ActiveConfig.CellsName
+    kwargs.setdefault("CellsName", cellsname)
 
-    PloTool.ClusterMatchingParameters = MatchingOptions()
+    kwargs.setdefault("ClusterMatchingParameters", MatchingOptions())
 
     #Tools and Combinations to plot
     #should be set by the end user.
 
-    from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
-
-    PloTool.MonitoringTool = GenericMonitoringTool(flags, "PlotterMonitoringTool")
-
+    PloTool = CompFactory.CaloGPUClusterAndCellDataMonitor(name, **kwargs)
+    
+    if "MonitoringTool" not in kwargs:
+        from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
+        PloTool.MonitoringTool = GenericMonitoringTool(flags, "PlotterMonitoringTool")
+    
     result.setPrivateTools(PloTool)
     return result
 
-def MonitorizationTool(flags, name = "MonTool"):
-    from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
-
-    monTool = GenericMonitoringTool(flags, name)
-
-    maxNumberOfClusters=2500.0
-
-    monTool.defineHistogram('container_size', path='EXPERT', type='TH1F',  title="Container Size; Number of Clusters; Number of Events", xbins=50, xmin=0.0, xmax=maxNumberOfClusters)
-    monTool.defineHistogram('Et', path='EXPERT', type='TH1F',  title="Cluster E_T; E_T [ MeV ] ; Number of Clusters", xbins=135, xmin=-200.0, xmax=2500.0)
-    monTool.defineHistogram('Eta', path='EXPERT', type='TH1F', title="Cluster #eta; #eta ; Number of Clusters", xbins=100, xmin=-2.5, xmax=2.5)
-    monTool.defineHistogram('Phi', path='EXPERT', type='TH1F', title="Cluster #phi; #phi ; Number of Clusters", xbins=64, xmin=-3.2, xmax=3.2)
-    monTool.defineHistogram('Eta,Phi', path='EXPERT', type='TH2F', title="Number of Clusters; #eta ; #phi ; Number of Clusters", xbins=100, xmin=-2.5, xmax=2.5, ybins=128, ymin=-3.2, ymax=3.2)
-    monTool.defineHistogram('clusterSize', path='EXPERT', type='TH1F', title="Cluster Type; Type ; Number of Clusters", xbins=13, xmin=0.5, xmax=13.5)
-    monTool.defineHistogram('signalState', path='EXPERT', type='TH1F', title="Signal State; Signal State ; Number of Clusters", xbins=4, xmin=-1.5, xmax=2.5)
-    monTool.defineHistogram('size', path='EXPERT', type='TH1F', title="Cluster Size; Size [Cells] ; Number of Clusters", xbins=125, xmin=0.0, xmax=250.0)
-    monTool.defineHistogram('N_BAD_CELLS', path='EXPERT', type='TH1F', title="N_BAD_CELLS; N_BAD_CELLS ; Number of Clusters", xbins=250, xmin=0.5, xmax=250.5)
-    monTool.defineHistogram('ENG_FRAC_MAX', path='EXPERT', type='TH1F', title="ENG_FRAC_MAX; ENG_FRAC_MAX ; Number of Clusters", xbins=50, xmin=0.0, xmax=1.1)
-    monTool.defineHistogram('mu', path='EXPERT', type='TH1F',  title="mu; mu; Number of Events", xbins=50, xmin=0.0, xmax=100)
-    monTool.defineHistogram('mu,container_size', path='EXPERT', type='TH2F',  title="Container Size versus #mu; #mu; cluster container size", xbins=50, xmin=20.0, xmax=70, ybins=50, ymin=0.0, ymax=maxNumberOfClusters)
-    return monTool
-
-#This simply uses the GPU versions.
-#For the tests, we will build our own
-#depending on what we want to compare against.
-def HybridClusterProcessorCfg(flags, name="HybridClusterProcessor"):
+def DefaultCalibMomentsToolCfg(flags, name = "TopoCalibMoments", **kwargs):
+    result=ComponentAccumulator()
+    
+    kwargs.setdefault("MomentsNames", ["ENG_CALIB_TOT"
+                                       ,"ENG_CALIB_OUT_L"
+                                       ,"ENG_CALIB_OUT_T"
+                                       ,"ENG_CALIB_EMB0"
+                                       ,"ENG_CALIB_EME0"
+                                       ,"ENG_CALIB_TILEG3"
+                                       ,"ENG_CALIB_DEAD_TOT"
+                                       ,"ENG_CALIB_DEAD_EMB0"
+                                       ,"ENG_CALIB_DEAD_TILE0"
+                                       ,"ENG_CALIB_DEAD_TILEG3"
+                                       ,"ENG_CALIB_DEAD_EME0"
+                                       ,"ENG_CALIB_DEAD_HEC0"
+                                       ,"ENG_CALIB_DEAD_FCAL"
+                                       ,"ENG_CALIB_DEAD_LEAKAGE"
+                                       ,"ENG_CALIB_DEAD_UNCLASS"
+                                       ,"ENG_CALIB_FRAC_EM"
+                                       ,"ENG_CALIB_FRAC_HAD"
+                                       ,"ENG_CALIB_FRAC_REST"])
+
+    kwargs.setdefault("CalibrationHitContainerNames", ["LArCalibrationHitInactive"
+                                                       ,"LArCalibrationHitActive"
+                                                       ,"TileCalibHitActiveCell"
+                                                       ,"TileCalibHitInactiveCell"])
+                                                       
+    kwargs.setdefault("DMCalibrationHitContainerNames", ["LArCalibrationHitDeadMaterial"
+                                                         ,"TileCalibHitDeadMaterial"])
+    
+    TopoCalibMoments = CompFactory.CaloCalibClusterMomentsMaker2(name, **kwargs)
+    result.setPrivateTools(TopoCalibMoments)
+    return result
+
+def DefaultTopoClusterLocalCalibToolsCfg(flags, instantiateForTrigger, prefix = ''):
+    result=ComponentAccumulator()
+        
+    CaloClusterLocalCalib=CompFactory.CaloClusterLocalCalib
+    
+    # Local cell weights    
+    LCClassify   = CompFactory.CaloLCClassificationTool(prefix + "LCClassify")
+    LCClassify.ClassificationKey   = "EMFracClassify"
+    LCClassify.UseSpread = False
+    LCClassify.MaxProbability = 0.85 if flags.GeoModel.AtlasVersion.startswith("Rome") and instantiateForTrigger else 0.5
+    LCClassify.StoreClassificationProbabilityInAOD = True
+    if instantiateForTrigger:
+        LCClassify.UseNormalizedEnergyDensity = not flags.GeoModel.AtlasVersion.startswith("Rome")
+    if not instantiateForTrigger:
+        LCClassify.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
+
+    LCWeight = CompFactory.CaloLCWeightTool(prefix + "LCWeight")
+    LCWeight.CorrectionKey       = "H1ClusterCellWeights"
+    LCWeight.SignalOverNoiseCut  = 2.0
+    LCWeight.UseHadProbability   = True
+
+    LocalCalib = CaloClusterLocalCalib (prefix + "LocalCalib")
+    LocalCalib.ClusterClassificationTool     = [LCClassify]
+    LocalCalib.ClusterRecoStatus             = [1,2]
+    LocalCalib.LocalCalibTools               = [LCWeight]
+    if not instantiateForTrigger:
+        LocalCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
+
+    # Out-of-cluster corrections
+    LCOut     = CompFactory.CaloLCOutOfClusterTool(prefix + "LCOut")
+    LCOut.CorrectionKey       = "OOCCorrection"
+    LCOut.UseEmProbability    = False
+    LCOut.UseHadProbability   = True
+
+    OOCCalib   = CaloClusterLocalCalib (prefix + "OOCCalib")
+    OOCCalib.ClusterRecoStatus   = [1,2]
+    OOCCalib.LocalCalibTools     = [LCOut]
+    if not instantiateForTrigger:
+        OOCCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
+
+    LCOutPi0  = CompFactory.CaloLCOutOfClusterTool(prefix + "LCOutPi0")
+    LCOutPi0.CorrectionKey    = "OOCPi0Correction"
+    LCOutPi0.UseEmProbability  = True
+    LCOutPi0.UseHadProbability = False
+
+    OOCPi0Calib   = CaloClusterLocalCalib (prefix + "OOCPi0Calib")
+    OOCPi0Calib.ClusterRecoStatus   = [1,2]
+    OOCPi0Calib.LocalCalibTools     = [LCOutPi0]
+    if not instantiateForTrigger:
+        OOCPi0Calib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
+
+    # Dead material corrections
+    LCDeadMaterial   = CompFactory.CaloLCDeadMaterialTool(prefix + "LCDeadMaterial")
+    LCDeadMaterial.HadDMCoeffKey       = "HadDMCoeff2"
+    LCDeadMaterial.ClusterRecoStatus   = 0
+    LCDeadMaterial.WeightModeDM        = 2
+    LCDeadMaterial.UseHadProbability   = True
+    if not instantiateForTrigger:
+        LCDeadMaterial.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
+
+    DMCalib    = CaloClusterLocalCalib (prefix + "DMCalib")
+    DMCalib.ClusterRecoStatus   = [1,2]
+    DMCalib.LocalCalibTools      = [LCDeadMaterial]
+    if not instantiateForTrigger:
+      DMCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
+
+    lccalibtools = [
+        LocalCalib,
+        OOCCalib,
+        OOCPi0Calib,
+        DMCalib]
+    
+    result.setPrivateTools(lccalibtools)
+    
+    return result
+    
+#Depending on ReallyUseGPUTools,
+#instantiates GPU or CPU tools with consistent options...
+def GPUCaloTopoClusterCfg(flags, instantiateForTrigger, cellsname,
+                          clustersname = None, clustersnapname="CaloTopoClusters", name="HybridClusterProcessor",
+                          MonitorTool = None, MonitorCells = False, PlotterTool = None,
+                          addAsPrimary = True, ReallyUseGPUTools = True):
+
+    doLCCalib = flags.CaloRecGPU.ActiveConfig.doTopoClusterLocalCalib
+
+    if clustersname is None:
+        clustersname = "CaloCalTopoClusters" if doLCCalib else "CaloTopoClusters"
+
+    if clustersname == "CaloTopoClusters" and doLCCalib:
+        raise RuntimeError("Inconsistent arguments: clustersname must not be 'CaloTopoClusters' if doTopoClusterLocalCalib is True")
+    
     result = ComponentAccumulator()
+    
+    if not instantiateForTrigger:
+    
+      from LArGeoAlgsNV.LArGMConfig import LArGMCfg
+      from TileGeoModel.TileGMConfig import TileGMCfg
+      from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
+    
+      result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
+      result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
+    
+      result.merge(LArGMCfg(flags))
+      result.merge(TileGMCfg(flags))
+    
 
     HybridClusterProcessor = CompFactory.CaloGPUHybridClusterProcessor(name)
-    HybridClusterProcessor.ClustersOutputName = flags.CaloRecGPU.ActiveConfig.ClustersOutputName
+    HybridClusterProcessor.ClustersOutputName = clustersname
+    
+    HybridClusterProcessor.WriteTriggerSpecificInfo = instantiateForTrigger
+    
     HybridClusterProcessor.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
+    
     HybridClusterProcessor.TimeFileOutput = "GlobalTimes.txt"
+        
     HybridClusterProcessor.DeferConstantDataPreparationToFirstEvent = True
-    HybridClusterProcessor.DoPlots = False
-    HybridClusterProcessor.PlotterTool = None
-    HybridClusterProcessor.DoMonitoring = flags.CaloRecGPU.ActiveConfig.DoMonitoring
-
-    if flags.CaloRecGPU.ActiveConfig.DoMonitoring:
-        histSvc = CompFactory.THistSvc(Output = ["EXPERT DATAFILE='expert-monitoring.root', OPT='RECREATE'"])
-        result.addService(histSvc)
-        HybridClusterProcessor.MonitoringTool = MonitorizationTool(flags)
-
+    HybridClusterProcessor.DoPlots = PlotterTool is not None
+    HybridClusterProcessor.PlotterTool = PlotterTool
+    HybridClusterProcessor.DoMonitoring = MonitorTool is not None
+    HybridClusterProcessor.MonitoringTool = MonitorTool
+    HybridClusterProcessor.MonitorCells = MonitorCells
+    HybridClusterProcessor.CellsName = cellsname
+    
     HybridClusterProcessor.NumPreAllocatedDataHolders = flags.CaloRecGPU.ActiveConfig.NumPreAllocatedDataHolders
 
+    if ReallyUseGPUTools:
+    
+      HybridClusterProcessor.ConstantDataToGPUTool = result.popToolsAndMerge( BasicConstantDataExporterToolCfg(flags) )
+      HybridClusterProcessor.EventDataToGPUTool = result.popToolsAndMerge( BasicEventDataExporterToolCfg(flags, cellsname) )
+      HybridClusterProcessor.GPUToEventDataTool = result.popToolsAndMerge( AthenaClusterAndMomentsImporterToolCfg(flags, cellsname, instantiateForTrigger) )
+      
+      
+      HybridClusterProcessor.BeforeGPUTools = []
 
-    HybridClusterProcessor.ConstantDataToGPUTool = result.popToolsAndMerge( BasicConstantDataExporterToolCfg(flags) )
-    HybridClusterProcessor.EventDataToGPUTool = result.popToolsAndMerge( BasicEventDataExporterToolCfg(flags) )
-    HybridClusterProcessor.GPUToEventDataTool = result.popToolsAndMerge( AthenaClusterAndMomentsImporterToolCfg(flags) )
-
-    HybridClusterProcessor.BeforeGPUTools = []
+      HybridClusterProcessor.GPUTools = []
 
-    HybridClusterProcessor.GPUTools = []
+      HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( TopoAutomatonClusteringToolCfg(flags,"GPUGrowing"))]
 
-    HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( TopoAutomatonClusteringToolCfg(flags,"TopoAutomatonClustering"))]
+      HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( ClusterInfoCalcToolCfg(flags,"PostGPUGrowingClusterPropertiesCalculator", True))]
 
-    HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( ClusterInfoCalcToolCfg(flags,"PostGrowGPUClusterPropertiesCalculator", True))]
+      HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( TopoAutomatonSplitterToolCfg(flags,"GPUSplitting") )]
 
-    HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( TopoAutomatonSplitterToolCfg(flags,"GPUSplitter") )]
-
-    HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( GPUClusterMomentsCalculatorToolCfg(flags,"GPUTopoMoments") )]
+      HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( GPUClusterMomentsCalculatorToolCfg(flags,"GPUTopoMoments") )]
+      
+    else:
+      
+      HybridClusterProcessor.ConstantDataToGPUTool = None
+      HybridClusterProcessor.EventDataToGPUTool = None
+      HybridClusterProcessor.GPUToEventDataTool = None
+      HybridClusterProcessor.SkipConversions = True
+      
+      HybridClusterProcessor.GPUTools = []
+      
+      HybridClusterProcessor.BeforeGPUTools = [] 
+      
+      HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultTopologicalClusteringToolCfg(flags, cellsname,"CPUGrowing"))]
+
+      HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultClusterSplittingToolCfg(flags,"CPUSplitting") )]
+
+      HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultClusterMomentsCalculatorToolCfg(flags, instantiateForTrigger, "CPUTopoMoments") )]
+      
+      HybridClusterProcessor.BeforeGPUTools += [ CompFactory.CaloClusterStoreRawProperties("RawPropertiesStorer") ]
+      
+      
 
     HybridClusterProcessor.AfterGPUTools = []
 
-    from CaloBadChannelTool.CaloBadChanToolConfig import CaloBadChanToolCfg
-    caloBadChanTool = result.popToolsAndMerge( CaloBadChanToolCfg(flags) )
-    HybridClusterProcessor.AfterGPUTools += [CompFactory.CaloClusterBadChannelList(badChannelTool = caloBadChanTool)]
-
-    # add the total Noise
-    from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
-    result.merge(CaloNoiseCondAlgCfg(flags))
-
-    #if self.ConfigFlags.Calo.TopoCluster.doTopoClusterLocalCalib:
-        #Took out CaloClusterSnapshot that wanted to be a part of a CaloClusterMaker.
-        #Possibly change in the future?
-    #    from CaloRec.CaloTopoClusterConfig import getTopoClusterLocalCalibTools
-    #    HybridClusterProcessor.AfterGPUTools += getTopoClusterLocalCalibTools(flags)
-
-    #    from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
-    #    result.merge(caloTopoCoolFolderCfg(self.ConfigFlags))
-
-    result.addEventAlgo(HybridClusterProcessor)
-
-    return result
-
-def DefaultCaloCellMakerCfg(flags):
-        from LArCellRec.LArCellBuilderConfig import LArCellBuilderCfg,LArCellCorrectorCfg
-        from TileRecUtils.TileCellBuilderConfig import TileCellBuilderCfg
-        from CaloCellCorrection.CaloCellCorrectionConfig import CaloCellPedestalCorrCfg, CaloCellNeighborsAverageCorrCfg, CaloCellTimeCorrCfg, CaloEnergyRescalerCfg
-        result=ComponentAccumulator()
-
-        from LArGeoAlgsNV.LArGMConfig import LArGMCfg
-        from TileGeoModel.TileGMConfig import TileGMCfg
-
-        result.merge(LArGMCfg(flags))
-        result.merge(TileGMCfg(flags))
-
-        larCellBuilder     = result.popToolsAndMerge(LArCellBuilderCfg(flags))
-        larCellCorrectors  = result.popToolsAndMerge(LArCellCorrectorCfg(flags))
-        tileCellBuilder = result.popToolsAndMerge(TileCellBuilderCfg(flags))
-        cellFinalizer  = CompFactory.CaloCellContainerFinalizerTool()
-
-        if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
-            tileCellBuilder.fakeCrackCells = True
-
-        cellMakerTools=[larCellBuilder,tileCellBuilder,cellFinalizer]+larCellCorrectors
-
-        #Add corrections tools that are not LAr or Tile specific:
-        if flags.Calo.Cell.doPileupOffsetBCIDCorr or flags.Cell.doPedestalCorr:
-            theCaloCellPedestalCorr=CaloCellPedestalCorrCfg(flags)
-            cellMakerTools.append(result.popToolsAndMerge(theCaloCellPedestalCorr))
-
-        #LAr HV scale corr must come after pedestal corr
-        if flags.LAr.doHVCorr:
-            from LArCellRec.LArCellBuilderConfig import LArHVCellContCorrCfg
-            cellMakerTools.append(result.popToolsAndMerge(LArHVCellContCorrCfg(flags)))
-
-
-        if flags.Calo.Cell.doDeadCellCorr:
-            cellMakerTools.append(result.popToolsAndMerge(CaloCellNeighborsAverageCorrCfg(flags)))
-
-        if flags.Calo.Cell.doEnergyCorr:
-            cellMakerTools.append(result.popToolsAndMerge(CaloEnergyRescalerCfg(flags)))
-        if flags.Calo.Cell.doTimeCorr:
-            cellMakerTools.append(result.popToolsAndMerge(CaloCellTimeCorrCfg(flags)))
-
-        cellAlgo=CompFactory.CaloCellMaker(CaloCellMakerToolNames = cellMakerTools,
-                                           CaloCellsOutputName = flags.CaloRecGPU.ActiveConfig.CellsName)
-        result.addEventAlgo(cellAlgo)
+    if not instantiateForTrigger:
+      from CaloBadChannelTool.CaloBadChanToolConfig import CaloBadChanToolCfg
+      caloBadChanTool = result.popToolsAndMerge( CaloBadChanToolCfg(flags) )
+      HybridClusterProcessor.AfterGPUTools += [CompFactory.CaloClusterBadChannelList(badChannelTool = caloBadChanTool)]
+
+    if not instantiateForTrigger and flags.CaloRecGPU.ActiveConfig.doCalibHitMoments:
+    
+        calibHitsMomentsMaker = result.popToolsAndMerge(DefaultCalibMomentsToolCfg(flags))
+        HybridClusterProcessor.AfterGPUTools += [calibHitsMomentsMaker]
+    
+    if doLCCalib:
+        if not instantiateForTrigger:
+            HybridClusterProcessor.AfterGPUTools += [CompFactory.CaloClusterSnapshot(OutputName=clustersnapname,
+                                                                                     SetCrossLinks=True,
+                                                                                     FinalClusterContainerName=clustersname)]
+        else:
+          from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
+          from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
+          result.merge(CaloNoiseCondAlgCfg(flags, noisetype="electronicNoise"))
+          result.merge(caloTopoCoolFolderCfg(flags))
+        
+        calibTools = result.popToolsAndMerge(DefaultTopoClusterLocalCalibToolsCfg(flags, instantiateForTrigger, 'Trig' if instantiateForTrigger else ''))
+        
+        HybridClusterProcessor.AfterGPUTools += calibTools
+        #This is already a tool array.
+        
+        if not instantiateForTrigger:
+          from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
+          result.merge(caloTopoCoolFolderCfg(flags))
+    
+    if instantiateForTrigger:
+      from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
+      result.merge(CaloNoiseCondAlgCfg(flags))
+    
+    result.addEventAlgo(HybridClusterProcessor, primary=addAsPrimary)
+
+    if instantiateForTrigger or clustersname in flags.CaloRecGPU.ActiveConfig.skipWriteList:
+        # don't add these clusters to ESD and AOD
         return result
-
+    
+    #Output config:
+    AODMoments=[ "SECOND_R" 
+                 ,"SECOND_LAMBDA"
+                 ,"CENTER_MAG"
+                 ,"CENTER_LAMBDA"
+                 ,"FIRST_ENG_DENS"
+                 ,"ENG_FRAC_MAX" 
+                 ,"ISOLATION"
+                 ,"ENG_BAD_CELLS"
+                 ,"N_BAD_CELLS"
+                 ,"BADLARQ_FRAC"
+                 ,"ENG_POS"
+                 ,"SIGNIFICANCE"
+                 ,"AVG_LAR_Q"
+                 ,"AVG_TILE_Q"
+                 ,"EM_PROBABILITY"
+                 ,"BadChannelList"
+                 ,"SECOND_TIME"
+                 ,"NCELL_SAMPLING"]
+
+    if flags.CaloRecGPU.ActiveConfig.writeExtendedClusterMoments:
+        AODMoments += ["LATERAL"
+                       ,"LONGITUDINAL"
+                       ,"CELL_SIGNIFICANCE"
+                       ,"PTD"
+                       ,"MASS"]
+
+    if flags.Reco.EnableHI:
+        AODMoments += ["CELL_SIG_SAMPLING"]
+
+    if flags.CaloRecGPU.ActiveConfig.writeCalibHitClusterMoments:
+        AODMoments += ["ENG_CALIB_TOT"
+                       ,"ENG_CALIB_OUT_L"
+                       ,"ENG_CALIB_OUT_T"
+                       ,"ENG_CALIB_EMB0"
+                       ,"ENG_CALIB_EME0"
+                       ,"ENG_CALIB_TILEG3"
+                       ,"ENG_CALIB_DEAD_TOT"
+                       ,"ENG_CALIB_DEAD_EMB0"
+                       ,"ENG_CALIB_DEAD_TILE0"
+                       ,"ENG_CALIB_DEAD_TILEG3"
+                       ,"ENG_CALIB_DEAD_EME0"
+                       ,"ENG_CALIB_DEAD_HEC0"
+                       ,"ENG_CALIB_DEAD_FCAL"
+                       ,"ENG_CALIB_DEAD_LEAKAGE"
+                       ,"ENG_CALIB_DEAD_UNCLASS"
+                       ,"ENG_CALIB_FRAC_EM"
+                       ,"ENG_CALIB_FRAC_HAD"
+                       ,"ENG_CALIB_FRAC_REST"]
+
+
+    from OutputStreamAthenaPool.OutputStreamConfig import addToAOD, addToESD
+    toESD = [f"xAOD::CaloClusterContainer#{clustersname}",
+             f"xAOD::CaloClusterAuxContainer#{clustersname}Aux.",
+             f"CaloClusterCellLinkContainer#{clustersname}_links"]
+    toAOD = [f"xAOD::CaloClusterContainer#{clustersname}",
+             f"CaloClusterCellLinkContainer#{clustersname}_links"]
+
+    AODMoments.append("CellLink") #Add data-link to cell-link container
+    if flags.CaloRecGPU.ActiveConfig.addCalibrationHitDecoration: #Add calib hit deco if requried 
+        AODMoments.append(flags.CaloRecGPU.ActiveConfig.CalibrationHitDecorationName)
+
+    if flags.CaloRecGPU.ActiveConfig.addCPData:
+        AODMoments += ["ClusterWidthEta","ClusterWidthPhi"]
+
+    auxItems = f"xAOD::CaloClusterAuxContainer#{clustersname}Aux."
+    auxItems+= ".".join(AODMoments)    
+
+    toAOD.append(auxItems)
+ 
+    result.merge(addToESD(flags, toESD))
+    result.merge(addToAOD(flags, toAOD))
+    
+    
+    return result
+