Do not use GaudiAlg

RecCalorimeter/CMakeLists.txt

@@ -8,7 +8,6 @@ gaudi_add_module(k4RecCalorimeterPlugins
                  SOURCES ${_module_sources}
                  LINK k4FWCore::k4FWCore
                       k4FWCore::k4Interface
-                      Gaudi::GaudiAlgLib
                       Gaudi::GaudiKernel
                       DD4hep::DDCore
                       DD4hep::DDG4

RecCalorimeter/src/components/CalibrateBenchmarkMethod.cpp

@@ -26,7 +26,7 @@ DECLARE_COMPONENT(CalibrateBenchmarkMethod)
 
 
 CalibrateBenchmarkMethod::CalibrateBenchmarkMethod(const std::string& aName, ISvcLocator* aSvcLoc)
-    : GaudiAlgorithm(aName, aSvcLoc), 
+    : Gaudi::Algorithm(aName, aSvcLoc), 
     m_geoSvc("GeoSvc", aName), 
     m_histSvc("THistSvc", aName),
     m_totalEnergyECal(nullptr),
@@ -43,7 +43,7 @@ CalibrateBenchmarkMethod::~CalibrateBenchmarkMethod() {}
 
 
 StatusCode CalibrateBenchmarkMethod::initialize() {
-  if (GaudiAlgorithm::initialize().isFailure()) return StatusCode::FAILURE;
+  if (Gaudi::Algorithm::initialize().isFailure()) return StatusCode::FAILURE;
 
   // Check geometry service
   if (!m_geoSvc) {
@@ -102,7 +102,7 @@ StatusCode CalibrateBenchmarkMethod::initialize() {
 }
 
 
-StatusCode CalibrateBenchmarkMethod::execute() {
+StatusCode CalibrateBenchmarkMethod::execute(const EventContext&) const {
   double totalEnergyInECal = 0.;
   double totalEnergyInHCal = 0.;
   double energyInFirstLayerECal = 0; 
@@ -253,7 +253,7 @@ StatusCode CalibrateBenchmarkMethod::finalize() {
 
   runMinimization(n_param, variable, steps, m_fixedParameters);
 
-  return GaudiAlgorithm::finalize();
+  return Gaudi::Algorithm::finalize();
 }
 
 void CalibrateBenchmarkMethod::registerHistogram(const std::string& path, TH1F*& histogramName) {

RecCalorimeter/src/components/CalibrateBenchmarkMethod.h

@@ -2,7 +2,7 @@
 #define RECCALORIMETER_CALIBRATEBENCHMARKMETHOD_H
 
 // GAUDI
-#include "GaudiAlg/GaudiAlgorithm.h"
+#include "Gaudi/Algorithm.h"
 
 // Key4HEP
 #include "k4FWCore/DataHandle.h"
@@ -39,7 +39,7 @@ class ITHistSvc;
  *  @author Michaela Mlynarikova
  */
 
-class CalibrateBenchmarkMethod : public GaudiAlgorithm {
+class CalibrateBenchmarkMethod : public Gaudi::Algorithm {
 public:
   explicit CalibrateBenchmarkMethod(const std::string&, ISvcLocator*);
   virtual ~CalibrateBenchmarkMethod();
@@ -50,7 +50,7 @@ class CalibrateBenchmarkMethod : public GaudiAlgorithm {
   /**  Fills the histograms.
    *   @return status code
    */
-  virtual StatusCode execute() final;
+  virtual StatusCode execute(const EventContext&) const final;
   /**  Finalize.
    *   @return status code
    */
@@ -68,9 +68,9 @@ class CalibrateBenchmarkMethod : public GaudiAlgorithm {
   void runMinimization(int n_param, const std::vector<double>& variable, const std::vector<double>& steps, const std::vector<int>& fixedParameters) const;
 
   /// Handle for electromagnetic barrel cells (input collection)
-  DataHandle<edm4hep::CalorimeterHitCollection> m_ecalBarrelCells{"ecalBarrelCells", Gaudi::DataHandle::Reader, this};
+  mutable DataHandle<edm4hep::CalorimeterHitCollection> m_ecalBarrelCells{"ecalBarrelCells", Gaudi::DataHandle::Reader, this};
   /// Handle for hadronic barrel cells (input collection)
-  DataHandle<edm4hep::CalorimeterHitCollection> m_hcalBarrelCells{"hcalBarrelCells", Gaudi::DataHandle::Reader, this};
+  mutable DataHandle<edm4hep::CalorimeterHitCollection> m_hcalBarrelCells{"hcalBarrelCells", Gaudi::DataHandle::Reader, this};
 
   /// Histogram of total deposited energy in the calorimeters 
   TH1F* m_totalEnergyECal;
@@ -81,8 +81,8 @@ class CalibrateBenchmarkMethod : public GaudiAlgorithm {
   TH1F* m_parameters; 
 
   /// vectors to store the energy in each ECal/HCal layer 
-  std::vector<double> m_energyInLayerECal;
-  std::vector<double> m_energyInLayerHCal;
+  mutable std::vector<double> m_energyInLayerECal;
+  mutable std::vector<double> m_energyInLayerHCal;
 
 
   /// Maximum energy for the x-axis range
@@ -103,17 +103,17 @@ class CalibrateBenchmarkMethod : public GaudiAlgorithm {
   Gaudi::Property<uint> m_systemIDHCal{this, "HCalSystemID", 8, "ID of the HCal system"};
 
   /// vectors containing the energy deposits to be used for minimization
-  std::vector<double> m_vecGeneratedEnergy;
-  std::vector<double> m_vecTotalEnergyinECal;
-  std::vector<double> m_vecTotalEnergyinHCal;
-  std::vector<double> m_vecEnergyInFirstLayerECal; 
-  std::vector<double> m_vecEnergyInLastLayerECal;
-  std::vector<double> m_vecEnergyInFirstLayerHCal;
+  mutable std::vector<double> m_vecGeneratedEnergy;
+  mutable std::vector<double> m_vecTotalEnergyinECal;
+  mutable std::vector<double> m_vecTotalEnergyinHCal;
+  mutable std::vector<double> m_vecEnergyInFirstLayerECal; 
+  mutable std::vector<double> m_vecEnergyInLastLayerECal;
+  mutable std::vector<double> m_vecEnergyInFirstLayerHCal;
 
   // benchmark parameters which should be fixed
   // p[1] because HCal is already calibrated to HAD scale
   // p[5] is the constant term and was not bringing large improvement, hence not minimized for the moment (might be tried again in the future)  
   Gaudi::Property<std::vector<int>> m_fixedParameters = {this, "fixedParameters", {1,5},"Fixed parameters that will not be minimized"};
 
 };
-#endif /* RECCALORIMETER_CALIBRATEBENCHMARKMETHOD_H */
+#endif /* RECCALORIMETER_CALIBRATEBENCHMARKMETHOD_H */

RecCalorimeter/src/components/CalibrateCaloHitsTool.cpp

@@ -3,12 +3,12 @@
 DECLARE_COMPONENT(CalibrateCaloHitsTool)
 
 CalibrateCaloHitsTool::CalibrateCaloHitsTool(const std::string& type, const std::string& name, const IInterface* parent)
-    : GaudiTool(type, name, parent) {
+    : AlgTool(type, name, parent) {
   declareInterface<ICalibrateCaloHitsTool>(this);
 }
 
 StatusCode CalibrateCaloHitsTool::initialize() {
-  StatusCode sc = GaudiTool::initialize();
+  StatusCode sc = AlgTool::initialize();
   if (sc.isFailure()) {
     return sc;
   }
@@ -22,4 +22,4 @@ void CalibrateCaloHitsTool::calibrate(std::unordered_map<uint64_t, double>& aHit
                 [this](std::pair<const uint64_t, double>& p) { p.second *= m_invSamplingFraction; });
 }
 
-StatusCode CalibrateCaloHitsTool::finalize() { return GaudiTool::finalize(); }
+StatusCode CalibrateCaloHitsTool::finalize() { return AlgTool::finalize(); }

RecCalorimeter/src/components/CalibrateCaloHitsTool.h

@@ -2,7 +2,7 @@
 #define RECCALORIMETER_CALIBRATECALOHITSTOOL_H
 
 // from Gaudi
-#include "GaudiAlg/GaudiTool.h"
+#include "GaudiKernel/AlgTool.h"
 
 // k4FWCore
 #include "k4Interface/ICalibrateCaloHitsTool.h"
@@ -21,7 +21,7 @@
  *  @date   2016-09
  */
 
-class CalibrateCaloHitsTool : public GaudiTool, virtual public ICalibrateCaloHitsTool {
+class CalibrateCaloHitsTool : public AlgTool, virtual public ICalibrateCaloHitsTool {
 public:
   CalibrateCaloHitsTool(const std::string& type, const std::string& name, const IInterface* parent);
   ~CalibrateCaloHitsTool() = default;

RecCalorimeter/src/components/CalibrateInLayersTool.cpp

@@ -10,12 +10,12 @@
 DECLARE_COMPONENT(CalibrateInLayersTool)
 
 CalibrateInLayersTool::CalibrateInLayersTool(const std::string& type, const std::string& name, const IInterface* parent)
-    : GaudiTool(type, name, parent), m_geoSvc("GeoSvc", "CalibrateInLayers") {
+    : AlgTool(type, name, parent), m_geoSvc("GeoSvc", "CalibrateInLayers") {
   declareInterface<ICalibrateCaloHitsTool>(this);
 }
 
 StatusCode CalibrateInLayersTool::initialize() {
-  if (GaudiTool::initialize().isFailure()) {
+  if (AlgTool::initialize().isFailure()) {
     return StatusCode::FAILURE;
   }
   // check if readout exists
@@ -44,4 +44,4 @@ void CalibrateInLayersTool::calibrate(std::unordered_map<uint64_t, double>& aHit
   });
 }
 
-StatusCode CalibrateInLayersTool::finalize() { return GaudiTool::finalize(); }
+StatusCode CalibrateInLayersTool::finalize() { return AlgTool::finalize(); }

RecCalorimeter/src/components/CalibrateInLayersTool.h

@@ -2,7 +2,7 @@
 #define RECCALORIMETER_CALIBRATEINLAYERSTOOL_H
 
 // from Gaudi
-#include "GaudiAlg/GaudiTool.h"
+#include "GaudiKernel/AlgTool.h"
 #include "GaudiKernel/ServiceHandle.h"
 
 // k4FWCore
@@ -26,7 +26,7 @@ class IGeoSvc;
  *  @author Anna Zaborowska
  */
 
-class CalibrateInLayersTool : public GaudiTool, virtual public ICalibrateCaloHitsTool {
+class CalibrateInLayersTool : public AlgTool, virtual public ICalibrateCaloHitsTool {
 public:
   CalibrateInLayersTool(const std::string& type, const std::string& name, const IInterface* parent);
   ~CalibrateInLayersTool() = default;

RecCalorimeter/src/components/CaloTopoCluster.cpp

@@ -27,7 +27,7 @@
 
 DECLARE_COMPONENT(CaloTopoCluster)
 
-CaloTopoCluster::CaloTopoCluster(const std::string& name, ISvcLocator* svcLoc) : GaudiAlgorithm(name, svcLoc) {
+CaloTopoCluster::CaloTopoCluster(const std::string& name, ISvcLocator* svcLoc) : Gaudi::Algorithm(name, svcLoc) {
   declareProperty("TopoClusterInput", m_inputTool, "Handle for input map of cells");
   declareProperty("noiseTool", m_noiseTool, "Handle for the cells noise tool");
   declareProperty("neigboursTool", m_neighboursTool, "Handle for tool to retrieve cell neighbours");
@@ -47,7 +47,7 @@ CaloTopoCluster::CaloTopoCluster(const std::string& name, ISvcLocator* svcLoc) :
   declareProperty("clusterCells", m_clusterCellsCollection, "Handle for clusters (output collection)");
 }
 StatusCode CaloTopoCluster::initialize() {
-  if (GaudiAlgorithm::initialize().isFailure()) return StatusCode::FAILURE;
+  if (Gaudi::Algorithm::initialize().isFailure()) return StatusCode::FAILURE;
   m_geoSvc = service("GeoSvc");
   if (!m_geoSvc) {
     error() << "Unable to locate Geometry Service. "
@@ -82,7 +82,7 @@ StatusCode CaloTopoCluster::initialize() {
   return StatusCode::SUCCESS;
 }
 
-StatusCode CaloTopoCluster::execute() {
+StatusCode CaloTopoCluster::execute(const EventContext&) const {
 
   std::unordered_map<uint64_t, double> allCells;
   std::vector<std::pair<uint64_t, double>> firstSeeds;
@@ -110,11 +110,11 @@ StatusCode CaloTopoCluster::execute() {
             });
 
   std::map<uint, std::vector<std::pair<uint64_t, int>>> preClusterCollection;
-  StatusCode sc = CaloTopoCluster::buildingProtoCluster(m_neighbourSigma,
-                                                        m_lastNeighbourSigma,
-                                                        firstSeeds,
-                                                        allCells,
-                                                        preClusterCollection);
+  StatusCode sc = buildingProtoCluster(m_neighbourSigma,
+                                       m_lastNeighbourSigma,
+                                       firstSeeds,
+                                       allCells,
+                                       preClusterCollection);
   if (sc.isFailure()) {
     error() << "Unable to build protocluster!" << endmsg;
     return sc;
@@ -223,7 +223,7 @@ StatusCode CaloTopoCluster::execute() {
 
 void CaloTopoCluster::findingSeeds(const std::unordered_map<uint64_t, double>& aCells,
                                    int aNumSigma,
-                                   std::vector<std::pair<uint64_t, double>>& aSeeds) {
+                                   std::vector<std::pair<uint64_t, double>>& aSeeds) const {
   for (const auto& cell : aCells) {
     // retrieve the noise const and offset assigned to cell
     double threshold = m_noiseTool->noiseOffset(cell.first) + ( m_noiseTool->noiseRMS(cell.first) * aNumSigma);
@@ -243,7 +243,7 @@ StatusCode CaloTopoCluster::buildingProtoCluster(
     int aLastNumSigma,
     std::vector<std::pair<uint64_t, double>>& aSeeds,
     const std::unordered_map<uint64_t, double>& aCells,
-    std::map<uint, std::vector< std::pair<uint64_t, int>>>& aPreClusterCollection) {
+    std::map<uint, std::vector< std::pair<uint64_t, int>>>& aPreClusterCollection) const {
   // Map of cellIDs to clusterIds
   std::map<uint64_t, uint> clusterOfCell;
 
@@ -309,7 +309,7 @@ CaloTopoCluster::searchForNeighbours(const uint64_t aCellId,
                                      const std::unordered_map<uint64_t, double>& aCells,
                                      std::map<uint64_t, uint>& aClusterOfCell,
                                      std::map<uint, std::vector<std::pair<uint64_t, int>>>& aPreClusterCollection,
-				     bool aAllowClusterMerge) {
+				     bool aAllowClusterMerge) const {
   // Fill vector to be returned, next cell ids and cluster id for which neighbours are found
   std::vector<std::pair<uint64_t, uint>> addedNeighbourIds;
   // Retrieve cellIDs of neighbours
@@ -396,4 +396,4 @@ CaloTopoCluster::searchForNeighbours(const uint64_t aCellId,
   return addedNeighbourIds;
 }
 
-StatusCode CaloTopoCluster::finalize() { return GaudiAlgorithm::finalize(); }
+StatusCode CaloTopoCluster::finalize() { return Gaudi::Algorithm::finalize(); }

RecCalorimeter/src/components/CaloTopoCluster.h

@@ -2,7 +2,7 @@
 #define RECCALORIMETER_CALOTOPOCLUSTER_H
 
 // Gaudi
-#include "GaudiAlg/GaudiAlgorithm.h"
+#include "Gaudi/Algorithm.h"
 #include "GaudiKernel/ToolHandle.h"
 
 // k4FWCore
@@ -42,7 +42,7 @@ class Segmentation;
  *  @author Coralie Neubueser
  */
 
-class CaloTopoCluster : public GaudiAlgorithm {
+class CaloTopoCluster : public Gaudi::Algorithm {
 public:
   CaloTopoCluster(const std::string& name, ISvcLocator* svcLoc);
 
@@ -54,7 +54,7 @@ class CaloTopoCluster : public GaudiAlgorithm {
    *   @param[in] aSeeds, the vector of seed cell ids anf their energy to build proto-clusters.
    */
   virtual void findingSeeds(const std::unordered_map<uint64_t, double>& aCells, int aNumSigma,
-                            std::vector<std::pair<uint64_t, double>>& aSeeds);
+                            std::vector<std::pair<uint64_t, double>>& aSeeds) const;
 
   /** Building proto-clusters from the found seeds.
    * First the function initialises a cluster in the preClusterCollection for the seed cells,
@@ -69,7 +69,7 @@ class CaloTopoCluster : public GaudiAlgorithm {
                                     int aLastNumSigma,
                                     std::vector<std::pair<uint64_t, double>>& aSeeds,
                                     const std::unordered_map<uint64_t, double>& aCells,
-                                    std::map<uint, std::vector<std::pair<uint64_t, int>>>& aPreClusterCollection);
+                                    std::map<uint, std::vector<std::pair<uint64_t, int>>>& aPreClusterCollection) const;
 
   /** Search for neighbours and add them to preClusterCollection
    * The 
@@ -86,41 +86,41 @@ class CaloTopoCluster : public GaudiAlgorithm {
   searchForNeighbours(const uint64_t aCellId, uint& aClusterID, int aNumSigma, const std::unordered_map<uint64_t, double>& aCells,
                       std::map<uint64_t, uint>& aClusterOfCell,
                       std::map<uint, std::vector<std::pair<uint64_t, int>>>& aPreClusterCollection,
-		      bool aAllowClusterMerge);
+		      bool aAllowClusterMerge) const;
 
-  StatusCode execute();
+  StatusCode execute(const EventContext&) const;
 
   StatusCode finalize();
 
 private:
   // Cluster collection
-  DataHandle<edm4hep::ClusterCollection> m_clusterCollection{"calo/clusters", Gaudi::DataHandle::Writer, this};
+  mutable DataHandle<edm4hep::ClusterCollection> m_clusterCollection{"calo/clusters", Gaudi::DataHandle::Writer, this};
   // Cluster cells in collection
-  DataHandle<edm4hep::CalorimeterHitCollection> m_clusterCellsCollection{"calo/clusterCells", Gaudi::DataHandle::Writer, this};
+  mutable DataHandle<edm4hep::CalorimeterHitCollection> m_clusterCellsCollection{"calo/clusterCells", Gaudi::DataHandle::Writer, this};
   /// Pointer to the geometry service
   SmartIF<IGeoSvc> m_geoSvc;
   /// Handle for the input tool
-  ToolHandle<ITopoClusterInputTool> m_inputTool{"TopoClusterInput", this};
+  mutable ToolHandle<ITopoClusterInputTool> m_inputTool{"TopoClusterInput", this};
   /// Handle for the cells noise tool
-  ToolHandle<ICaloReadCellNoiseMap> m_noiseTool{"TopoCaloNoisyCells", this};
+  mutable ToolHandle<ICaloReadCellNoiseMap> m_noiseTool{"TopoCaloNoisyCells", this};
   /// Handle for neighbours tool
-  ToolHandle<ICaloReadNeighboursMap> m_neighboursTool{"TopoCaloNeighbours", this};
+  mutable ToolHandle<ICaloReadNeighboursMap> m_neighboursTool{"TopoCaloNeighbours", this};
   /// Handle for tool to get positions in ECal Barrel
-  ToolHandle<ICellPositionsTool> m_cellPositionsECalBarrelTool{"CellPositionsECalBarrelTool", this};
+  mutable ToolHandle<ICellPositionsTool> m_cellPositionsECalBarrelTool{"CellPositionsECalBarrelTool", this};
   /// Handle for tool to get positions in HCal Barrel
-  ToolHandle<ICellPositionsTool> m_cellPositionsHCalBarrelNoSegTool{"CellPositionsHCalBarrelNoSegTool", this};
+  mutable ToolHandle<ICellPositionsTool> m_cellPositionsHCalBarrelNoSegTool{"CellPositionsHCalBarrelNoSegTool", this};
   /// Handle for tool to get positions in HCal Barrel 
-  ToolHandle<ICellPositionsTool> m_cellPositionsHCalBarrelTool{"CellPositionsHCalBarrelTool", this};
+  mutable ToolHandle<ICellPositionsTool> m_cellPositionsHCalBarrelTool{"CellPositionsHCalBarrelTool", this};
   /// Handle for tool to get positions in HCal Barrel and Ext Barrel, no Segmentation
-  ToolHandle<ICellPositionsTool> m_cellPositionsHCalExtBarrelTool{"CellPositionsHCalBarrelNoSegTool", this};
+  mutable ToolHandle<ICellPositionsTool> m_cellPositionsHCalExtBarrelTool{"CellPositionsHCalBarrelNoSegTool", this};
   /// Handle for tool to get positions in Calo Discs
-  ToolHandle<ICellPositionsTool> m_cellPositionsEMECTool{"CellPositionsCaloDiscsTool", this};
+  mutable ToolHandle<ICellPositionsTool> m_cellPositionsEMECTool{"CellPositionsCaloDiscsTool", this};
   /// Handle for tool to get positions in Calo Discs
-  ToolHandle<ICellPositionsTool> m_cellPositionsHECTool{"CellPositionsCaloDiscsTool", this};
+  mutable ToolHandle<ICellPositionsTool> m_cellPositionsHECTool{"CellPositionsCaloDiscsTool", this};
   /// Handle for tool to get positions in Calo Discs
-  ToolHandle<ICellPositionsTool> m_cellPositionsEMFwdTool{"CellPositionsCaloDiscsTool", this};
+  mutable ToolHandle<ICellPositionsTool> m_cellPositionsEMFwdTool{"CellPositionsCaloDiscsTool", this};
   /// Handle for tool to get positions in Calo Discs
-  ToolHandle<ICellPositionsTool> m_cellPositionsHFwdTool{"CellPositionsCaloDiscsTool", this};
+  mutable ToolHandle<ICellPositionsTool> m_cellPositionsHFwdTool{"CellPositionsCaloDiscsTool", this};
 
   /// no segmentation used in HCal
   Gaudi::Property<bool> m_noSegmentationHCalUsed{this, "noSegmentationHCal", true, "HCal Barrel readout without DD4hep eta-phi segmentation used."};

RecCalorimeter/src/components/CaloTopoClusterInputTool.cpp

@@ -14,7 +14,7 @@
 DECLARE_COMPONENT(CaloTopoClusterInputTool)
 
 CaloTopoClusterInputTool::CaloTopoClusterInputTool(const std::string& type, const std::string& name, const IInterface* parent)
-    : GaudiTool(type, name, parent) {
+    : AlgTool(type, name, parent) {
   declareProperty("ecalBarrelCells", m_ecalBarrelCells, "");
   declareProperty("ecalEndcapCells", m_ecalEndcapCells, "");
   declareProperty("ecalFwdCells", m_ecalFwdCells, "");
@@ -26,7 +26,7 @@ CaloTopoClusterInputTool::CaloTopoClusterInputTool(const std::string& type, cons
 }
 
 StatusCode CaloTopoClusterInputTool::initialize() {
-  if (GaudiTool::initialize().isFailure()) {
+  if (AlgTool::initialize().isFailure()) {
     return StatusCode::FAILURE;
   }
   m_geoSvc = service("GeoSvc");
@@ -39,7 +39,7 @@ StatusCode CaloTopoClusterInputTool::initialize() {
   return StatusCode::SUCCESS;
 }
 
-StatusCode CaloTopoClusterInputTool::finalize() { return GaudiTool::finalize(); }
+StatusCode CaloTopoClusterInputTool::finalize() { return AlgTool::finalize(); }
 
 StatusCode CaloTopoClusterInputTool::cellIDMap(std::unordered_map<uint64_t, double>& aCells) {
   uint totalNumberOfCells = 0;