Calorimeter/CaloMonitoring/src/LArCellMonTool.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 // NAME:     LArCellMonTool.cxx
@@ -22,6 +22,8 @@
 #include "AthenaMonitoring/DQAtlasReadyFilterTool.h"
 
 #include "CaloEvent/CaloCellContainer.h"
+#include "StoreGate/ReadCondHandle.h"
+#include "GaudiKernel/ThreadLocalContext.h"
 #include "AthenaKernel/Units.h"
 
 #include "TProfile2D.h"
@@ -38,8 +40,6 @@ using Athena::Units::GeV;
 ////////////////////////////////////////////
 LArCellMonTool::LArCellMonTool(const std::string& type, const std::string& name,const IInterface* parent) 
   :CaloMonToolBase(type, name, parent),
-   m_useElectronicNoiseOnly(false),
-   m_noiseTool("CaloNoiseTool"),
    m_trigDec("Trig::TrigDecisionTool/TrigDecisionTool"),
    m_badChannelMask("BadLArRawChannelMask",this),
    m_LArOnlineIDHelper(nullptr),
@@ -51,10 +51,6 @@ LArCellMonTool::LArCellMonTool(const std::string& type, const std::string& name,
 
   declareProperty("DoSaveTempHists",m_doSaveTempHists=false,"Store temporary, intermediate histograms in a /Temp/ directory (for debugging");
 
-  // tools 
-  declareProperty("useElectronicNoiseOnly",m_useElectronicNoiseOnly=false,"Consider only electronic noise and ignore pile-up contributiuon)");
-  declareProperty("CaloNoiseTool",m_noiseTool,"Tool Handle for noise Tool");
-
   // Trigger Awareness:
   declareProperty("useTrigger",m_useTrigger=true);
   declareProperty("rndmTriggerNames", m_triggerNames[RNDM]);
@@ -169,9 +165,7 @@ StatusCode LArCellMonTool::initialize() {
     ATH_CHECK(m_BCKey.initialize());
   }
 
-  //Calonoise tool
-  ATH_CHECK(m_noiseTool.retrieve());
-
+  ATH_CHECK(m_noiseKey.initialize());
 
   //JobO consistency check:
   if (m_useTrigger && std::all_of(m_triggerNames.begin(),m_triggerNames.end(),[](const std::string& trigName){return trigName.empty();})) {
@@ -192,12 +186,6 @@ StatusCode LArCellMonTool::initialize() {
     m_trigDec.disable();
   }
 
-  //Choose noise type
-  if (m_useElectronicNoiseOnly) 
-    m_noiseType = ICalorimeterNoiseTool::ELECTRONICNOISE;
-  else
-    m_noiseType=ICalorimeterNoiseTool::TOTALNOISE; 
-
   // Sets the threshold value arrays
   ATH_CHECK(initThreshHists());
 
@@ -653,19 +641,23 @@ StatusCode LArCellMonTool::fillHistograms(){
 
   ATH_MSG_DEBUG("LArCellMonTool::fillHistograms() starts");
 
-  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
+  const EventContext& ctx = Gaudi::Hive::currentContext();
+
+  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl (m_cablingKey, ctx);
   const LArOnOffIdMapping* cabling{*cablingHdl};
   if(!cabling) {
      ATH_MSG_ERROR( "Do not have cabling");
      return StatusCode::FAILURE;
   }
 
-  SG::ReadHandle<CaloCellContainer> cellContHandle{m_cellContainerName};
+  SG::ReadCondHandle<CaloNoise> noise (m_noiseKey, ctx);
+
+  SG::ReadHandle<CaloCellContainer> cellContHandle (m_cellContainerName, ctx);
   if (! cellContHandle.isValid()) { return StatusCode::FAILURE; }
   const CaloCellContainer* cellCont = cellContHandle.get();
 	    
   if (!m_oncePerJobHistosDone) {
-    ATH_CHECK(createPerJobHistograms(cellCont));
+    ATH_CHECK(createPerJobHistograms(ctx, cellCont));
     m_oncePerJobHistosDone=true;
   }
 
@@ -725,7 +717,7 @@ StatusCode LArCellMonTool::fillHistograms(){
 	ATH_MSG_WARNING("Got threshold 0 for type '" << thr.m_threshName  << "'for cell in layer " << m_layerNames[iLyr]);
       }
 
-      if (thr.m_inSigNoise) thresholdVal*=m_noiseTool->getNoise(cell,m_noiseType);
+      if (thr.m_inSigNoise) thresholdVal*=noise->getNoise(id, gain);
         
       if (thr.m_threshDirection==OVER && cellen <= thresholdVal) continue;
       if (thr.m_threshDirection==UNDER && cellen > thresholdVal) continue;
@@ -933,7 +925,8 @@ TH2F* LArCellMonTool::newEtaPhiHist(const std::string& hName, const std::string&
 
 
 
-StatusCode LArCellMonTool::createPerJobHistograms(const CaloCellContainer* cellCont) {
+StatusCode LArCellMonTool::createPerJobHistograms(const EventContext& ctx,
+                                                  const CaloCellContainer* cellCont) {
 
   ATH_MSG_INFO("Creating the once-per-job histograms");
   //The following histograms can be considered constants for one job
@@ -942,7 +935,7 @@ StatusCode LArCellMonTool::createPerJobHistograms(const CaloCellContainer* cellC
   //BadChannel word
   //Database noise
   
-  
+ 
   //1. Bad Channel word
   if (m_doKnownBadChannelsVsEtaPhi) {
     MonGroup knownBadChannelGroup(this,m_lArPath+"KnownBadChannels", run, ATTRIB_MANAGED,"","weightedAverage"); //Merging this info makes no sense at all! 
@@ -1010,12 +1003,14 @@ StatusCode LArCellMonTool::createPerJobHistograms(const CaloCellContainer* cellC
   }//end loop over thresholds
   
 
-  SG::ReadCondHandle<LArBadChannelCont> readHandle{m_BCKey};
+  SG::ReadCondHandle<LArBadChannelCont> readHandle (m_BCKey, ctx);
   const LArBadChannelCont *bcCont {*readHandle};
   if(m_doKnownBadChannelsVsEtaPhi && !bcCont) {
      ATH_MSG_WARNING( "Do not have Bad chan container !!!" );
      return StatusCode::FAILURE;
   }
+
+  SG::ReadCondHandle<CaloNoise> noise (m_noiseKey, ctx);
   
   //filling:
   CaloCellContainer::const_iterator it = cellCont->begin(); 
@@ -1039,7 +1034,7 @@ StatusCode LArCellMonTool::createPerJobHistograms(const CaloCellContainer* cellC
     } 
   
     if ( m_doDatabaseNoiseVsEtaPhi ) {
-      const float cellnoisedb = m_noiseTool->getNoise(cell,m_noiseType);
+      const float cellnoisedb = noise->getNoise(id, cell->gain());
       m_h_dbnoise_etaphi[iLyr]->Fill(celleta,cellphi,cellnoisedb);
     }      
     

Calorimeter/CaloMonitoring/src/LArCellMonTool.h

 //Dear emacs, this is -*-c++-*-
 
 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 
@@ -14,7 +14,7 @@
 #include "GaudiKernel/ToolHandle.h"
 
 #include "LArRecConditions/ILArBadChannelMasker.h"
-#include "CaloInterface/ICalorimeterNoiseTool.h"
+#include "CaloConditions/CaloNoise.h"
 
 #include "LArIdentifier/LArOnlineID.h"
 #include "Identifier/IdentifierHash.h"
@@ -25,6 +25,8 @@
 
 #include "TrigDecisionTool/TrigDecisionTool.h"
 
+#include "StoreGate/ReadCondHandleKey.h"
+
 #include "LArCellBinning.h"
           
 #include <vector>
@@ -54,14 +56,14 @@ class LArCellMonTool : public CaloMonToolBase {
 
   LArCellMonTool(const std::string & type, const std::string& name, 
 		 const IInterface* parent);
-  ~LArCellMonTool();
+  virtual ~LArCellMonTool();
   
   //Methods implementing the ManagedMonitorToolBase interface
-  virtual StatusCode initialize();
-  virtual StatusCode finalize();
-  virtual StatusCode bookHistograms();
-  virtual StatusCode procHistograms();
-  virtual StatusCode fillHistograms();
+  virtual StatusCode initialize() override;
+  virtual StatusCode finalize() override;
+  virtual StatusCode bookHistograms() override;
+  virtual StatusCode procHistograms() override;
+  virtual StatusCode fillHistograms() override;
 
 private:
 
@@ -144,7 +146,8 @@ private:
   void regTempHist(TH1* h, MonGroup& mg);
 
   //Private methods: Histogram filling
-  StatusCode createPerJobHistograms(const CaloCellContainer* cellcont);
+  StatusCode createPerJobHistograms(const EventContext& ctx,
+                                    const CaloCellContainer* cellcont);
   void checkTriggerAndBeamBackground();
   void sporadicNoiseCandidate(const CaloCell* cell, const LArCellMonTool::LayerEnum iLyr,const float threshold, const LArOnOffIdMapping* cabling);
 
@@ -157,9 +160,8 @@ private:
   bool m_oncePerJobHistosDone=false;
   SG::ReadHandleKey<CaloCellContainer> m_cellContainerName { this, "CaloCellContainer", "AllCalo", "SG key of the input cell container" };
 
-  bool m_useElectronicNoiseOnly;
-  ICalorimeterNoiseTool::CalorimeterNoiseType m_noiseType=ICalorimeterNoiseTool::TOTALNOISE;
-  ToolHandle<ICalorimeterNoiseTool> m_noiseTool;
+  SG::ReadCondHandleKey<CaloNoise> m_noiseKey
+    { this, "NoiseKey", "totalNoise", "SG key for noise" };
 
 
   // Trigger Awareness:

Calorimeter/CaloMonitoring/src/TileCalCellMonTool.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 // NAME:     TileCalCellMonTool.cxx
@@ -12,6 +12,8 @@
 #include "AthenaMonitoring/DQAtlasReadyFilterTool.h"
 
 #include "CaloEvent/CaloCellContainer.h"
+#include "StoreGate/ReadCondHandle.h"
+#include "GaudiKernel/ThreadLocalContext.h"
 #include "AthenaKernel/Units.h"
 
 #include "TProfile2D.h"
@@ -26,17 +28,12 @@ using Athena::Units::GeV;
 ////////////////////////////////////////////
 TileCalCellMonTool::TileCalCellMonTool(const std::string& type, const std::string& name,const IInterface* parent) 
   :CaloMonToolBase(type, name, parent),
-   m_useElectronicNoiseOnly(false),
    m_useTwoGaus(true),
-   m_noiseTool("CaloNoiseTool"),
    m_tile_id(nullptr)
 {
   declareInterface<IMonitorToolBase>(this);
 
-  // tools 
-  declareProperty("useElectronicNoiseOnly",m_useElectronicNoiseOnly=false,"Consider only electronic noise and ignore pile-up contributiuon)");
   declareProperty("useTwoGaus", m_useTwoGaus=true,"Use double-gaussian noise description for Tile-cells");
-  declareProperty("CaloNoiseTool",m_noiseTool,"Tool Handle for noise Tool");
 
   // min energy for tilecal cells 
   declareProperty("energyThreshold",m_tileThreshold=300.); //Threshold in GeV
@@ -56,15 +53,7 @@ StatusCode TileCalCellMonTool::initialize() {
 
   ATH_CHECK( detStore()->retrieve(m_tile_id) );
 
-  //Calonoise tool
-  ATH_CHECK(m_noiseTool.retrieve());
-
-
-  //Choose noise type
-  if (m_useElectronicNoiseOnly) 
-    m_noiseType = ICalorimeterNoiseTool::ELECTRONICNOISE;
-  else
-    m_noiseType=ICalorimeterNoiseTool::TOTALNOISE; 
+  ATH_CHECK(m_noiseKey.initialize());
 
   initParam();
 
@@ -286,19 +275,22 @@ StatusCode TileCalCellMonTool::bookHistograms() {
 ////////////////////////////////////////////////////////////////////////////
 StatusCode TileCalCellMonTool::fillHistograms(){  
 
-//  ATH_MSG_INFO("TileCalCellMonTool::fillHistograms() starts");
+  const EventContext& ctx = Gaudi::Hive::currentContext();
+
+  //  ATH_MSG_INFO("TileCalCellMonTool::fillHistograms() starts");
   StatusCode sc = StatusCode::SUCCESS;
 
   bool ifPass = 1;
   sc = checkFilters(ifPass);
   if(sc.isFailure() || !ifPass) return StatusCode::SUCCESS;
 
+  SG::ReadCondHandle<CaloNoise> noise (m_noiseKey, ctx);
 
   //=====================
   // CaloCell info
   //============================
 
-  SG::ReadHandle<CaloCellContainer> cellContHandle{m_cellContainerName};
+  SG::ReadHandle<CaloCellContainer> cellContHandle (m_cellContainerName, ctx);
   if (! cellContHandle.isValid()) { ATH_MSG_WARNING("No CaloCell container found in TDS"); return StatusCode::FAILURE; }
   const CaloCellContainer* cellCont = cellContHandle.get();
 
@@ -325,9 +317,9 @@ StatusCode TileCalCellMonTool::fillHistograms(){
 
 
     if (m_useTwoGaus==false)
-      cellnoisedb = m_noiseTool->getNoise(cell,m_noiseType);
+      cellnoisedb = noise->getNoise(id, cell->gain());
     else
-      cellnoisedb = m_noiseTool->getEffectiveSigma(cell,ICalorimeterNoiseTool::MAXSYMMETRYHANDLING,m_noiseType);
+      cellnoisedb = noise->getEffectiveSigma(id, cell->gain(), cell->energy());
 
     double rs=999;
     if (std::isfinite(cellnoisedb) && cellnoisedb > 0 &&  cellen != 0 && badc == false) rs= cellen / cellnoisedb;

Calorimeter/CaloMonitoring/src/TileCalCellMonTool.h

 //Dear emacs, this is -*-c++-*-
 
 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef TILEMONTOOL_H
@@ -13,7 +13,8 @@
 
 #include "AthenaMonitoring/IDQFilterTool.h"
 #include "TrigDecisionTool/TrigDecisionTool.h"
-#include "CaloInterface/ICalorimeterNoiseTool.h"
+#include "CaloConditions/CaloNoise.h"
+#include "StoreGate/ReadCondHandleKey.h"
 
 class CaloCell;
 class TileID;
@@ -31,12 +32,12 @@ class TileCalCellMonTool : public CaloMonToolBase {
 
   TileCalCellMonTool(const std::string & type, const std::string& name, 
 		 const IInterface* parent);
-  ~TileCalCellMonTool();
+  virtual ~TileCalCellMonTool();
   
-  virtual StatusCode initialize();
-  virtual StatusCode bookHistograms();
-  virtual StatusCode procHistograms();
-  virtual StatusCode fillHistograms();
+  virtual StatusCode initialize() override;
+  virtual StatusCode bookHistograms() override;
+  virtual StatusCode procHistograms() override;
+  virtual StatusCode fillHistograms() override;
 
 
 private:
@@ -49,10 +50,9 @@ private:
   //Job Properties and other private variables
   SG::ReadHandleKey<CaloCellContainer> m_cellContainerName { this, "CaloCellContainer", "AllCalo", "SG key of the input cell container" };
 
-  bool m_useElectronicNoiseOnly;
   bool m_useTwoGaus;
-  ICalorimeterNoiseTool::CalorimeterNoiseType m_noiseType=ICalorimeterNoiseTool::TOTALNOISE;
-  ToolHandle<ICalorimeterNoiseTool> m_noiseTool;
+  SG::ReadCondHandleKey<CaloNoise> m_noiseKey
+    { this, "NoiseKey", "totalNoise", "SG key for noise" };
 
   // tile energy threshold
   float m_tileThreshold;

Calorimeter/CaloRec/python/CaloRecoConfig.py

@@ -3,7 +3,7 @@
 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
 from AthenaConfiguration.ComponentFactory import CompFactory
 
-def CaloRecoCfg(configFlags):
+def CaloRecoCfg(configFlags, clustersname="CaloTopoClusters"):
     
     result=ComponentAccumulator()
     if not configFlags.Input.isMC:
@@ -33,7 +33,7 @@ def CaloRecoCfg(configFlags):
     
     #Configure topo-cluster builder
     from CaloRec.CaloTopoClusterConfig import CaloTopoClusterCfg
-    result.merge(CaloTopoClusterCfg(configFlags))
+    result.merge(CaloTopoClusterCfg(configFlags, clustersname=clustersname))
 
     return result
 

Calorimeter/CaloRec/python/CaloTopoClusterConfig.py

@@ -301,11 +301,9 @@ def CaloTopoClusterSplitterToolCfg(configFlags):
 
 # Steering options for trigger
 # Maybe offline reco options should be extracted from flags elsewhere
-def CaloTopoClusterCfg(configFlags,cellsname="AllCalo",clustersname="",doLCCalib=None):
+def CaloTopoClusterCfg(configFlags,cellsname="AllCalo",clustersname="CaloTopoClusters",doLCCalib=None):
     result=ComponentAccumulator()
 
-    if not clustersname:
-        clustersname = "CaloTopoClusters"
 
     from LArGeoAlgsNV.LArGMConfig import LArGMCfg
     from TileGeoModel.TileGMConfig import TileGMCfg
@@ -340,7 +338,7 @@ def CaloTopoClusterCfg(configFlags,cellsname="AllCalo",clustersname="",doLCCalib
     # EnergyCut                     = 500*MeV,
 
 
-    CaloTopoCluster=CaloClusterMaker(clustersname)
+    CaloTopoCluster=CaloClusterMaker(clustersname+"Maker")
     CaloTopoCluster.ClustersOutputName=clustersname
 
     CaloTopoCluster.ClusterMakerTools = [TopoMaker, TopoSplitter]

Calorimeter/CaloTestBeam/CaloTBRec/share/CaloTBRec_H8_Cell_jobOptions.py

@@ -12,15 +12,10 @@
 #CaloCellGetter()
 include ("CaloRec/CaloRec_jobOptions.py")
 
-#Apply identical settings for caonoisetool (do not know, who is using it) and CaloNoiseToolDefault
-include ( "CaloTools/CaloNoiseTool_TB_jobOptions.py" )
 if not doSim:
-    ToolSvc.calonoisetool.UseSymmetry=FALSE
     ToolSvc.LArAutoCorrTotalTool.NMinBias=0 
-    ToolSvc.calonoisetool.WithOF=FALSE
 
 if doLArOFC:
-    ToolSvc.calonoisetool.WithOF=TRUE
     if not doSim:
         ToolSvc.LArOFCTool.FromDatabase=TRUE
 

Calorimeter/CaloTestBeam/CaloTBRec/share/CaloTBRec_H8_ClusterOnly_jobOptions.py

@@ -18,7 +18,6 @@ CaloTopoClusterEMMaker.TopoCluster.CalorimeterNames=[
 CaloTopoClusterEMMaker.TopoCluster.SeedSamplingNames = [
 	  "PreSamplerB", "EMB1", "EMB2", "EMB3",
 	  "PreSamplerE", "EME1", "EME2", "EME3"]
-CaloTopoClusterEMMaker.TopoCluster.UseCaloNoiseTool=FALSE
 CaloTopoClusterEMMaker.TopoCluster.UsePileUpNoise=FALSE
 CaloTopoClusterEMMaker.TopoCluster.NeighborOption                 = "all3D"
 CaloTopoClusterEMMaker.TopoCluster.NoiseSigma                     = 200.0*MeV

Calorimeter/CaloTestBeam/CaloTBRec/share/CaloTBRec_H8_Cluster_jobOptions.py

@@ -32,12 +32,9 @@ if doCaloTopoCluster:
      "ENG_FRAC_CORE" ,
      "SECOND_ENG_DENS" ,
   ]
-  #Apply identical settings for calonoisetool (do not know, who is using it) and CaloNoiseToolDefault 
+
   if not doSim:
-     ToolSvc.CaloNoiseToolDefault.UseSymmetry=FALSE
      ToolSvc.LArAutoCorrTotalToolDefault.NMinBias=0
-     ToolSvc.CaloNoiseToolDefault.WithOF=FALSE
   if doLArOFC:
-     ToolSvc.CaloNoiseToolDefault.WithOF=TRUE
      if not doSim:
          ToolSvc.LArOFCToolDefault.FromDatabase=TRUE  

Calorimeter/CaloUtils/CaloUtils/CaloLCWeightTool.h

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef CALOUTILS_CALOLCWEIGHTTOOL_H
@@ -29,7 +29,6 @@
 #include "GaudiKernel/EventContext.h"
 
 class CaloCell_ID;
-class ICalorimeterNoiseTool;
 class CaloCluster;
 
 class CaloLCWeightTool : public AthAlgTool, virtual public IClusterCellWeightTool

Calorimeter/CaloUtils/src/CaloLCDeadMaterialTool.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #undef DEBUG_DMTHINGS
@@ -558,7 +558,6 @@ CaloLCDeadMaterialTool::prepare_for_cluster
 
     float energy = thisCell->e();
     float weight = itrCell.weight();
-    //float sigma =  m_noiseTool->getNoise(thisCell,ICalorimeterNoiseTool::ELECTRONICNOISE);
     cls_unweighted_energy += energy;
 
     Cell cell;

Calorimeter/CaloUtils/src/CaloTopoTowerBuilderTool.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 
@@ -106,24 +106,11 @@ StatusCode CaloTopoTowerBuilderTool::execute(const EventContext& ctx,
 
   ATH_MSG_DEBUG("Energy cuts " << minimumCellEnergy << " " << minimumClusterEnergy << " " << useCellWeights);
 
-  // Noise tool stuff
-  bool useNoiseTool = theTowers->GetUseNoiseTool();
-  bool usePileUpNoise = theTowers->GetUsePileUpNoise();
   float noiseSigma0 = theTowers->GetNoiseSigma();
   float cellESignificanceThreshold = theTowers->GetCellESignificanceThreshold();
 
 
-  if (useNoiseTool) {
-    ATH_MSG_WARNING( " Using noise tool in CaloTopoTowerBuilderTool no supported. give up => No CaloTopoTowers are made"  );
-    if(delete_cellToClusterMap){
-      ATH_MSG_DEBUG("Deleting cellToClusterMap Pointer");
-      delete cellToClusterMap;
-      ATH_MSG_DEBUG("Deleting cellToClusterMap Pointer Finished");
-    }
-    
-    return StatusCode::SUCCESS;
-  }
-  ATH_MSG_DEBUG("Noise cuts "<< noiseSigma0 << " " <<  cellESignificanceThreshold << " " << useNoiseTool << " " << usePileUpNoise);
+  ATH_MSG_DEBUG("Noise cuts "<< noiseSigma0 << " " <<  cellESignificanceThreshold);
 
   // List of calorimeters from which to use cells
   std::vector<CaloCell_ID::SUBCALO> caloIndices = theTowers->GetCaloIndices();

Control/AthToolSupport/AsgExampleTools/AsgExampleTools/AsgExampleToolsDict.h

@@ -11,5 +11,6 @@
 #include "AsgExampleTools/UnitTestTool3.h"
 #include "AsgExampleTools/UnitTestTool2.h"
 #include "AsgExampleTools/UnitTestTool1A.h"
+#include "AsgExampleTools/UnitTestService1.h"
 
 #endif // not ASGTOOLS_ASGTOOLSDICT_H

Control/AthToolSupport/AsgExampleTools/AsgExampleTools/IUnitTestService1.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Nils Krumnack
+
+
+
+#ifndef ASG_TOOLS__I_UNIT_TEST_SERVICE1_H
+#define ASG_TOOLS__I_UNIT_TEST_SERVICE1_H
+
+#include <AsgServices/IAsgService.h>
+
+namespace asg
+{
+  /// \brief the interface for \ref UnitTestService1
+
+  class IUnitTestService1 : virtual public IAsgService
+  {
+    // Declare the interface that this class provides
+    ASG_SERVICE_INTERFACE( CP::IUnitTestService1 )
+
+    /// \brief get the integer property
+  public:
+    virtual std::string getPropertyString () const = 0;
+
+    /// \brief get the integer property
+  public:
+    virtual int getPropertyInt () const = 0;
+
+    /// \brief get the integer property
+  public:
+    virtual void setPropertyInt (int val_property) = 0;
+
+    /// \brief get whether we have been initialized
+  public:
+    virtual bool isInitialized () const = 0;
+  };
+}
+
+#endif

Control/AthToolSupport/AsgExampleTools/AsgExampleTools/UnitTestService1.h

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Nils Krumnack
+
+
+
+#ifndef ASG_TOOLS__UNIT_TEST_SERVICE1_H
+#define ASG_TOOLS__UNIT_TEST_SERVICE1_H
+
+#include <AsgServices/AsgService.h>
+#include <AsgExampleTools/IUnitTestService1.h>
+
+namespace asg
+{
+  /// \brief a service used to unit test AnaToolHandle
+  ///
+  /// This allows to unit test the various capabilities of
+  /// AnaToolHandle in a controlled fashion.
+
+  struct UnitTestService1 : virtual public IUnitTestService1,
+                            public AsgService
+  {
+    /// \brief standard constructor
+  public:
+    UnitTestService1 (const std::string& name, ISvcLocator* pSvcLocator);
+
+    /// \brief standard destructor
+  public:
+    ~UnitTestService1 ();
+
+  public:
+    StatusCode initialize () override;
+
+    ASG_SERVICE_CLASS1 (UnitTestService1, IUnitTestService1)
+
+  public:
+    virtual std::string getPropertyString () const override;
+
+  public:
+    virtual int getPropertyInt () const override;
+
+  public:
+    virtual void setPropertyInt (int val_property) override;
+
+  public:
+    virtual bool isInitialized () const override;
+
+    /// \brief whether initialize has been called
+  public:
+    bool m_isInitialized = false;
+
+    /// \brief the string property
+  public:
+    std::string m_propertyString;
+
+    /// \brief the integer property
+  public:
+    int m_propertyInt = -7;
+
+    /// \brief whether initialize should fail
+  public:
+    bool m_initializeFail = false;
+
+    /// \brief the number of times the service of the given name has been
+    /// instantiated
+  public:
+    static int& instance_counts (const std::string& name);
+  };
+}
+
+#endif

Control/AthToolSupport/AsgExampleTools/AsgExampleTools/selection.xml

@@ -6,5 +6,6 @@
    <class name="asg::UnitTestTool3" />
    <class name="asg::UnitTestTool2" />
    <class name="asg::UnitTestTool1A" />
+   <class name="asg::UnitTestService1" />
    
 </lcgdict>

Control/AthToolSupport/AsgExampleTools/CMakeLists.txt

@@ -21,7 +21,7 @@ atlas_add_root_dictionary( AsgExampleToolsLib AsgExampleToolsCintDict
 atlas_add_library( AsgExampleToolsLib
    AsgExampleTools/*.h Root/*.cxx ${AsgExampleToolsCintDict}
    PUBLIC_HEADERS AsgExampleTools
-   LINK_LIBRARIES AsgTools AsgDataHandlesLib AsgTestingLib ${extra_lib} )
+   LINK_LIBRARIES AsgTools AsgServicesLib AsgDataHandlesLib AsgTestingLib ${extra_lib} )
 
 if( NOT XAOD_STANDALONE )
    atlas_add_component( AsgExampleTools
@@ -62,6 +62,12 @@ atlas_add_test( gt_AsgToolConfig
    LINK_LIBRARIES ${GTEST_LIBRARIES} AsgTools AsgExampleToolsLib AsgTestingLib )
 set_tests_properties (AsgExampleTools_gt_AsgToolConfig_ctest PROPERTIES LABELS "AsgTools;AsgExampleTools" )
 
+atlas_add_test( gt_AsgServiceConfig
+   SOURCES test/gt_AsgServiceConfig.cxx
+   INCLUDE_DIRS ${GTEST_INCLUDE_DIRS}
+   LINK_LIBRARIES ${GTEST_LIBRARIES} AsgExampleToolsLib AsgTestingLib )
+set_tests_properties (AsgExampleTools_gt_AsgServiceConfig_ctest PROPERTIES LABELS "AsgServices;AsgExampleTools" )
+
 
 if( XAOD_STANDALONE )
 

Control/AthToolSupport/AsgExampleTools/Root/UnitTestService1.cxx

+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Nils Krumnack
+
+
+
+//
+// includes
+//
+
+#include <AsgExampleTools/UnitTestService1.h>
+
+#include <AsgMessaging/MessageCheck.h>
+#include <gtest/gtest.h>
+#include <map>
+
+//
+// method implementations
+//
+
+namespace asg
+{
+  UnitTestService1 ::
+  UnitTestService1 (const std::string& name, ISvcLocator* pSvcLocator)
+    : AsgService (name, pSvcLocator)
+  {
+    // declareInterface<IUnitTestService1>();
+
+    declareProperty ("propertyInt", m_propertyInt, "the integer property");
+    declareProperty ("propertyString", m_propertyString, "the string property");
+    declareProperty ("initializeFail", m_initializeFail, "whether initialize should fail");
+
+    ++ instance_counts (name);
+
+    ANA_MSG_INFO ("create UnitTestService1 " << this);
+  }
+
+
+
+  UnitTestService1 ::
+  ~UnitTestService1 ()
+  {
+    ANA_MSG_INFO ("destroy UnitTestService1 " << this);
+
+    -- instance_counts (name());
+  }
+
+
+
+  StatusCode UnitTestService1 ::
+  initialize ()
+  {
+    ANA_MSG_INFO ("initialize UnitTestService1 " << this);
+    ANA_MSG_INFO ("  propertyString: " << m_propertyString);
+    ANA_MSG_INFO ("  propertyInt: " << m_propertyInt);
+
+    if (m_initializeFail)
+    {
+      ATH_MSG_ERROR ("service configured to fail initialize");
+      return StatusCode::FAILURE;
+    }
+    if (m_isInitialized)
+    {
+      ATH_MSG_ERROR ("initialize called twice");
+      return StatusCode::FAILURE;
+    }
+    m_isInitialized = true;
+    return StatusCode::SUCCESS;
+  }
+
+
+
+  std::string UnitTestService1 ::
+  getPropertyString () const
+  {
+    return m_propertyString;
+  }
+
+
+
+  int UnitTestService1 ::
+  getPropertyInt () const
+  {
+    return m_propertyInt;
+  }
+
+
+
+  void UnitTestService1 ::
+  setPropertyInt (int val_property)
+  {
+    m_propertyInt = val_property;
+  }
+
+
+
+  bool UnitTestService1 ::
+  isInitialized () const
+  {
+    return m_isInitialized;
+  }
+
+
+
+  int& UnitTestService1 ::
+  instance_counts (const std::string& name)
+  {
+    static std::map<std::string,int> counts;
+    auto iter = counts.find (name);
+    if (iter == counts.end())
+      iter = counts.insert (std::make_pair (name, 0)).first;
+    assert (iter != counts.end());
+    return iter->second;
+  }
+}

Control/AthToolSupport/AsgExampleTools/src/components/AsgExampleTools_entries.cxx

@@ -4,6 +4,7 @@
 #include "AsgExampleTools/AsgHelloTool.h"
 
 #include <AsgExampleTools/DataHandleTestTool.h>
+#include <AsgExampleTools/UnitTestService1.h>
 #include <AsgExampleTools/UnitTestTool1.h>
 #include <AsgExampleTools/UnitTestTool1A.h>
 #include <AsgExampleTools/UnitTestTool2.h>
@@ -14,6 +15,7 @@ DECLARE_COMPONENT( AsgHelloTool )
 DECLARE_COMPONENT( AsgExampleAlgorithm )
 
 DECLARE_COMPONENT( asg::DataHandleTestTool )
+DECLARE_COMPONENT( asg::UnitTestService1 )
 DECLARE_COMPONENT( asg::UnitTestTool1 )
 DECLARE_COMPONENT( asg::UnitTestTool1A )
 DECLARE_COMPONENT( asg::UnitTestTool2 )

Control/AthToolSupport/AsgExampleTools/test/gt_AsgServiceConfig.cxx

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/// @author Nils Krumnack
+
+
+
+//
+// includes
+//
+
+#include <AsgServices/AsgServiceConfig.h>
+#include <AsgMessaging/MessageCheck.h>
+#include <AsgTesting/UnitTest.h>
+#include <AsgExampleTools/UnitTestService1.h>
+#include <cmath>
+#include <gtest/gtest.h>
+#include <sstream>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+//
+// method implementations
+//
+
+using namespace asg::msgUserCode;
+
+namespace asg
+{
+  namespace
+  {
+    /// \brief make a unique service name to be used in unit tests
+    std::string makeUniqueName ()
+    {
+      static unsigned index = 0;
+      std::ostringstream str;
+      str << "unique" << ++ index;
+      return str.str();
+    }
+  }
+
+
+
+  TEST (AsgServiceConfigTest, basic)
+  {
+    const std::string name = makeUniqueName();
+    AsgServiceConfig config ("asg::UnitTestService1/" + name);
+    std::shared_ptr<IUnitTestService1> service;
+    ASSERT_SUCCESS (config.makeService (service));
+    EXPECT_EQ (name, service->name());
+    EXPECT_TRUE (service->isInitialized());
+    EXPECT_EQ (-7, service->getPropertyInt());
+    EXPECT_EQ ("", service->getPropertyString());
+  }
+
+
+
+  TEST (AsgServiceConfigTest, basic_properties)
+  {
+    const std::string name = makeUniqueName();
+    AsgServiceConfig config ("asg::UnitTestService1/" + name);
+    EXPECT_SUCCESS (config.setProperty ("propertyInt", 17));
+    EXPECT_SUCCESS (config.setProperty ("propertyString", "alpha"));
+    std::shared_ptr<IUnitTestService1> service;
+    ASSERT_SUCCESS (config.makeService (service));
+    EXPECT_EQ (name, service->name());
+    EXPECT_TRUE (service->isInitialized());
+    EXPECT_EQ (17, service->getPropertyInt());
+    EXPECT_EQ ("alpha", service->getPropertyString());
+  }
+
+
+
+  TEST (AsgServiceConfigTest, basic_propertyFromString)
+  {
+    const std::string name = makeUniqueName();
+    AsgServiceConfig config ("asg::UnitTestService1/" + name);
+    config.setPropertyFromString ("propertyInt", "17");
+    config.setPropertyFromString ("propertyString", "'alpha'");
+    std::shared_ptr<IUnitTestService1> service;
+    ASSERT_SUCCESS (config.makeService (service));
+    EXPECT_EQ (name, service->name());
+    EXPECT_TRUE (service->isInitialized());
+    EXPECT_EQ (17, service->getPropertyInt());
+    EXPECT_EQ ("alpha", service->getPropertyString());
+  }
+
+
+
+#ifdef XAOD_STANDALONE
+  TEST (AsgServiceConfigTest, basic_delete)
+  {
+    const std::string name = makeUniqueName();
+    {
+      AsgServiceConfig config ("asg::UnitTestService1/" + name);
+      std::shared_ptr<IUnitTestService1> service;
+      ASSERT_SUCCESS (config.makeService (service));
+      ASSERT_EQ (service, ServiceStore::get (name, true));
+    }
+    ASSERT_EQ (nullptr, ServiceStore::get (name, true));
+  }
+#endif
+
+
+
+  TEST (AsgServiceConfigTest, serviceHandle)
+  {
+    const std::string name = makeUniqueName();
+    AsgServiceConfig config1 ("asg::UnitTestService1/" + name);
+    ServiceHandle<IUnitTestService1> service1 ("", "AsgServiceConfigTest");
+    ASSERT_SUCCESS (config1.makeService (service1));
+    EXPECT_EQ (name, service1->name());
+
+    ServiceHandle<IUnitTestService1> service2 ("asg::UnitTestService1/" + name, "UnitTest");
+    ASSERT_SUCCESS (service2.retrieve ());
+    EXPECT_EQ (name, service2->name());
+    EXPECT_EQ (&*service1, &*service2);
+  }
+}
+
+ATLAS_GOOGLE_TEST_MAIN