AtlasGeometryCommon/CavernInfraGeoModel/ATLAS_CHECK_THREAD_SAFETY

+AtlasGeometryCommon/CavernInfraGeoModel

AtlasGeometryCommon/CavernInfraGeoModel/CMakeLists.txt

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 # Declare the package name:
 atlas_subdir( CavernInfraGeoModel )
 
 # External dependencies:
-find_package( GeoModelCore )
+find_package( GeoModel COMPONENTS GeoModelKernel )
 
 # Component(s) in the package:
-atlas_add_library( CavernInfraGeoModelLib
-                   CavernInfraGeoModel/*.h
-                   INTERFACE
-                   PUBLIC_HEADERS CavernInfraGeoModel
-                   INCLUDE_DIRS ${GEOMODELCORE_INCLUDE_DIRS}
-                   LINK_LIBRARIES ${GEOMODELCORE_LIBRARIES} AthenaKernel )
-
 atlas_add_component( CavernInfraGeoModel
                      src/*.cxx
                      src/components/*.cxx
-                     LINK_LIBRARIES CavernInfraGeoModelLib GaudiKernel GeoModelInterfaces GeoModelUtilities RDBAccessSvcLib StoreGateLib )
+                     INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS} 
+                     LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaKernel GaudiKernel GeoModelInterfaces GeoModelUtilities RDBAccessSvcLib StoreGateLib )

AtlasGeometryCommon/CavernInfraGeoModel/CavernInfraGeoModel/CavernInfraDetectorManager.h

-/*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef CavernInfraDetectorManager_h
-#define CavernInfraDetectorManager_h 1
-
-#include "GeoModelKernel/GeoVPhysVol.h"
-#include "GeoModelKernel/GeoVDetectorManager.h"
-#include <vector>
-
-class CavernInfraDetectorManager : public GeoVDetectorManager  
-{
- public:
-
-  // Constructor
-  CavernInfraDetectorManager();
-
-  // Destructor
-  ~CavernInfraDetectorManager();
-
-  // Access to raw geometry:
-  virtual unsigned int getNumTreeTops() const;
-  virtual PVConstLink getTreeTop(unsigned int i) const;
- 
-  void addTreeTop(PVLink);      // Add a Tree top:
-
- private:  
-
-  const CavernInfraDetectorManager & operator=(const CavernInfraDetectorManager &right);
-  CavernInfraDetectorManager(const CavernInfraDetectorManager &right);
-  
-  // Tree Tops
-  std::vector<PVLink> m_treeTops;
-};
-
-#ifndef GAUDI_NEUTRAL
-#include "AthenaKernel/CLASS_DEF.h" 
-CLASS_DEF(CavernInfraDetectorManager, 1500000300, 1)
-#endif
-
-#endif
-
-

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorFactory.h

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
-#ifndef CavernInfraDetectorFactory_h
-#define CavernInfraDetectorFactory_h 1
+#ifndef CAVERNINFRAGEOMODEL_CAVERNINFRADETECTORFACTORY_H
+#define CAVERNINFRAGEOMODEL_CAVERNINFRADETECTORFACTORY_H
 
+#include "CavernInfraDetectorManager.h"
 #include "GeoModelKernel/GeoVDetectorFactory.h"
-#include "CavernInfraGeoModel/CavernInfraDetectorManager.h"
+#include "StoreGate/StoreGateSvc.h"
 #include "RDBAccessSvc/IRDBAccessSvc.h"
-#include <string>
 
-class StoreGateSvc;
+#include <string>
 
-class CavernInfraDetectorFactory : public GeoVDetectorFactory  
+class CavernInfraDetectorFactory : public GeoVDetectorFactory
 {
  public:
-  
   // Constructor:
-  CavernInfraDetectorFactory(StoreGateSvc *pDetStore,
-			     IRDBAccessSvc *pAccess);
-  
+  CavernInfraDetectorFactory(ServiceHandle<StoreGateSvc> pDetStore,
+			     ServiceHandle<IRDBAccessSvc> pAccess);
+
+  // Illegal operations:
+  const CavernInfraDetectorFactory & operator=(const CavernInfraDetectorFactory &right) = delete;
+  CavernInfraDetectorFactory(const CavernInfraDetectorFactory &right) = delete;
+
   // Destructor:
-  ~CavernInfraDetectorFactory();
-  
+  ~CavernInfraDetectorFactory() = default;
+
   // Creation of geometry:
-  virtual void create(GeoPhysVol *world);
-  
+  virtual void create(GeoPhysVol *world) override;
+
   // Access to the results:
-  virtual const CavernInfraDetectorManager * getDetectorManager() const;
-  
+  virtual const CavernInfraDetectorManager* getDetectorManager() const override;
+
   // Set version Tag and Node
-  void setTagNode(std::string tag, std::string node);
+  void setTagNode(const std::string& tag, const std::string& node);
 
- private:  
-  // Illegal operations:
-  const CavernInfraDetectorFactory & operator=(const CavernInfraDetectorFactory &right);
-  CavernInfraDetectorFactory(const CavernInfraDetectorFactory &right);
-  
+ private:
   // The manager:
-  CavernInfraDetectorManager       *m_detectorManager;
-  
-  StoreGateSvc             *m_detectorStore;
-  IRDBAccessSvc            *m_access;
+  CavernInfraDetectorManager*  m_detectorManager{nullptr};
+
+  ServiceHandle<StoreGateSvc>  m_detectorStore;
+  ServiceHandle<IRDBAccessSvc> m_access;
   std::string              m_versionTag;
   std::string              m_versionNode;
 };
 
-// Class CavernInfraDetectorFactory 
+// Class CavernInfraDetectorFactory
 #endif
 
-

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorFactory01.h

-/*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef CavernInfraDetectorFactory01_h
-#define CavernInfraDetectorFactory01_h 1
-
-#include "GeoModelKernel/GeoVDetectorFactory.h"
-#include "CavernInfraGeoModel/CavernInfraDetectorManager.h"
-#include "RDBAccessSvc/IRDBAccessSvc.h"
-#include <string>
-
-class StoreGateSvc;
-
-class CavernInfraDetectorFactory01 : public GeoVDetectorFactory  
-{
- 
- public:
-  
-  // Constructor:
-  CavernInfraDetectorFactory01(StoreGateSvc *pDetStore,
-			  IRDBAccessSvc *pAccess);
-  
-  // Destructor:
-  ~CavernInfraDetectorFactory01();
-  
-  // Creation of geometry:
-  virtual void create(GeoPhysVol *world);
-  
-  // Access to the results:
-  virtual const CavernInfraDetectorManager * getDetectorManager() const;
-  
-  // Set version Tag and Node
-  void setTagNode(std::string tag, std::string node);
-
- 
- private:  
-  // Illegal operations:
-  const CavernInfraDetectorFactory01 & operator=(const CavernInfraDetectorFactory01 &right);
-  CavernInfraDetectorFactory01(const CavernInfraDetectorFactory01 &right);
-  
-  // The manager:
-  CavernInfraDetectorManager       *m_detectorManager;
-  
-  StoreGateSvc             *m_detectorStore;
-  IRDBAccessSvc            *m_access;
-  std::string              m_versionTag;
-  std::string              m_versionNode;
-};
-
-// Class CavernInfraDetectorFactory01 
-#endif
-
-

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorManager.cxx

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
-#include "CavernInfraGeoModel/CavernInfraDetectorManager.h"
+#include "CavernInfraDetectorManager.h"
 
 CavernInfraDetectorManager::CavernInfraDetectorManager()
 {
@@ -10,11 +10,7 @@ CavernInfraDetectorManager::CavernInfraDetectorManager()
 }
 
 
-CavernInfraDetectorManager::~CavernInfraDetectorManager()
-{
-  for(unsigned int i=0; i<m_treeTops.size(); i++)
-    m_treeTops[i]->unref();
-}
+CavernInfraDetectorManager::~CavernInfraDetectorManager() = default;
 
 
 unsigned int CavernInfraDetectorManager::getNumTreeTops() const
@@ -27,12 +23,11 @@ PVConstLink CavernInfraDetectorManager::getTreeTop(unsigned int i) const
   if(i<m_treeTops.size())
     return m_treeTops[i];
   else
-    return 0;
+    return nullptr;
 }
 
-void  CavernInfraDetectorManager::addTreeTop(PVLink link) 
+void  CavernInfraDetectorManager::addTreeTop(const PVLink& link)
 {
-  link->ref();
   m_treeTops.push_back(link);
 }
 

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorManager.h

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef CAVERNINFRAGEOMODEL_CAVERNINFRADETECTORMANAGER_H
+#define CAVERNINFRAGEOMODEL_CAVERNINFRADETECTORMANAGER_H
+
+#include "GeoModelKernel/GeoVPhysVol.h"
+#include "GeoModelKernel/GeoVDetectorManager.h"
+#include <vector>
+
+class CavernInfraDetectorManager : public GeoVDetectorManager
+{
+ public:
+  CavernInfraDetectorManager();
+
+  const CavernInfraDetectorManager & operator=(const CavernInfraDetectorManager &right) = delete;
+  CavernInfraDetectorManager(const CavernInfraDetectorManager &right) = delete;
+
+  ~CavernInfraDetectorManager();
+
+  // Access to raw geometry:
+  virtual unsigned int getNumTreeTops() const override;
+  virtual PVConstLink getTreeTop(unsigned int i) const override;
+
+  void addTreeTop(const PVLink&);      // Add a Tree top:
+
+ private:
+  // Tree Tops
+  std::vector<PVLink> m_treeTops;
+};
+
+#ifndef GAUDI_NEUTRAL
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF(CavernInfraDetectorManager, 1500000300, 1)
+#endif
+
+#endif
+
+

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorTool.cxx

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "CavernInfraDetectorTool.h"
-#include "CavernInfraDetectorFactory.h" 
-#include "CavernInfraDetectorFactory01.h" 
-#include "CavernInfraGeoModel/CavernInfraDetectorManager.h" 
+#include "CavernInfraDetectorFactory.h"
+#include "CavernInfraDetectorManager.h"
 
 #include "GeoModelInterfaces/IGeoDbTagSvc.h"
 #include "GeoModelUtilities/GeoModelExperiment.h"
 #include "RDBAccessSvc/IRDBAccessSvc.h"
 
-CavernInfraDetectorTool::CavernInfraDetectorTool( const std::string& type, 
+
+CavernInfraDetectorTool::CavernInfraDetectorTool( const std::string& type,
 						  const std::string& name,
 						  const IInterface* parent )
-  : GeoModelTool( type, name, parent ),
-    m_manager(0)
+  : GeoModelTool( type, name, parent )
 {
 }
 
-CavernInfraDetectorTool::~CavernInfraDetectorTool()
-{
-}
-  
-
 StatusCode CavernInfraDetectorTool::create()
-{ 
-  IGeoDbTagSvc *geoDbTag;
-  StatusCode sc = service ("GeoDbTagSvc",geoDbTag);
-  if(sc.isFailure()) {
-    msg(MSG::ERROR) << "Could not locate GeoDbTagSvc" << endmsg;
-    return sc;
-  }
+{
+  ServiceHandle<IGeoDbTagSvc> geoDbTag("GeoDbTagSvc", name());
+  ATH_CHECK(geoDbTag.retrieve());
 
   std::string cavernInfraVersion = geoDbTag->cavernInfraVersion();
-  msg(MSG::INFO) << "Building Cavern geometry version " << cavernInfraVersion << endmsg;
   if(cavernInfraVersion.empty()) {
-    msg(MSG::INFO) << "No Cavern Infra version for the given configuration. Skip building CavernInfraGeoModel" << endmsg;
+    ATH_MSG_INFO("No Cavern Infra version for the given configuration. Skip building CavernInfraGeoModel");
     return StatusCode::SUCCESS;
   }
+  else {
+    ATH_MSG_INFO("Building Cavern geometry version " << cavernInfraVersion);
+  }
 
   std::string versionNode = "CavernInfra";
 
   GeoModelExperiment* theExpt = nullptr;
-  if (StatusCode::SUCCESS != detStore()->retrieve(theExpt,"ATLAS")) { 
-    msg(MSG::ERROR) << "Could not find GeoModelExperiment ATLAS" << endmsg; 
-    return StatusCode::FAILURE; 
-  } 
- 
-  GeoPhysVol *world=&*theExpt->getPhysVol();
-  IRDBAccessSvc* raccess = 0;
-  sc = service("RDBAccessSvc",raccess);
-  if(sc.isFailure()) {
-    msg(MSG::ERROR) << "Could not locate RDBAccessSvc" << endmsg;
-    return sc;
-  }
+  ATH_CHECK(detStore()->retrieve(theExpt,"ATLAS"));
 
-  if(cavernInfraVersion.find("CavernInfra")==0) {
-    std::string geoVersion = cavernInfraVersion.substr(12,2);
-    if(geoVersion=="00" || geoVersion=="01") {
-      msg(MSG::ERROR) << "ERROR. Version " << cavernInfraVersion << " is obsolete and cannot be supported anymore" << endmsg;
-      return StatusCode::FAILURE;
-    }
-    else if(geoVersion=="02") {
-      // This factory is chosen by CavernInfra-02 tag, but in fact it uses data from CavernInfra-01
-      CavernInfraDetectorFactory01 theCavernInfraFactory01(detStore().operator->(),raccess);
-      theCavernInfraFactory01.setTagNode(cavernInfraVersion,versionNode);
-      theCavernInfraFactory01.create(world);
-      m_manager = theCavernInfraFactory01.getDetectorManager();
-    }
-  }
+  GeoPhysVol *world=theExpt->getPhysVol();
+  ServiceHandle<IRDBAccessSvc> raccess("RDBAccessSvc",name());
+  ATH_CHECK(raccess.retrieve());
 
   if(!m_manager) {
-    // If geometry has not been built yet fall back to the default factory
-    CavernInfraDetectorFactory theCavernInfraFactory(detStore().operator->(),raccess);
+    CavernInfraDetectorFactory theCavernInfraFactory(detStore(),raccess);
     theCavernInfraFactory.setTagNode(cavernInfraVersion,versionNode);
     theCavernInfraFactory.create(world);
     m_manager = theCavernInfraFactory.getDetectorManager();
@@ -81,15 +50,10 @@ StatusCode CavernInfraDetectorTool::create()
 
   if(m_manager) {
     theExpt->addManager(m_manager);
-    sc = detStore()->record(m_manager,
-			  m_manager->getName());
-    if(sc.isFailure()) {
-      msg(MSG::ERROR) << "Could not register CavernInfra detector manager" << endmsg;
-      return sc;
-    }
+    ATH_CHECK(detStore()->record(m_manager,m_manager->getName()));
   }
   else {
-    msg(MSG::ERROR) << "ERROR. Failed to build Cavern Version " << cavernInfraVersion << endmsg;
+    ATH_MSG_ERROR("ERROR. Failed to build Cavern Version " << cavernInfraVersion);
     return StatusCode::FAILURE;
   }
 
@@ -101,7 +65,7 @@ StatusCode CavernInfraDetectorTool::clear()
   SG::DataProxy* proxy = detStore()->proxy(ClassID_traits<CavernInfraDetectorManager>::ID(),m_manager->getName());
   if(proxy) {
     proxy->reset();
-    m_manager = 0;
+    m_manager = nullptr;
   }
   return StatusCode::SUCCESS;
 }

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorTool.h

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
-#ifndef CAVERNINFRADETECTORTOOL_H
-#define CAVERNINFRADETECTORTOOL_H
+#ifndef CAVERNINFRAGEOMODEL_CAVERNINFRADETECTORTOOL_H
+#define CAVERNINFRAGEOMODEL_CAVERNINFRADETECTORTOOL_H
 
 #include "GeoModelUtilities/GeoModelTool.h"
 class CavernInfraDetectorManager;
 
-class CavernInfraDetectorTool final : public GeoModelTool 
+class CavernInfraDetectorTool final : public GeoModelTool
 {
  public:
-
-  // Standard Constructor
   CavernInfraDetectorTool( const std::string& type, const std::string& name, const IInterface* parent );
+  ~CavernInfraDetectorTool() = default;
 
-  // Standard Destructor
-  virtual ~CavernInfraDetectorTool() override final;
+  virtual StatusCode create() override;
+  virtual StatusCode clear() override;
 
-  virtual StatusCode create() override final;
-  virtual StatusCode clear() override final;
-  
  private:
-  const CavernInfraDetectorManager* m_manager;
+  const CavernInfraDetectorManager* m_manager{nullptr};
 };
 
-#endif 
+#endif

AtlasGeometryCommon/CrackRegionGeoModel/CMakeLists.txt

+# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+
+# Declare the package name.
+atlas_subdir( CrackRegionGeoModel )
+
+find_package( GeoModel COMPONENTS GeoModelKernel GeoModelDBManager GeoModelRead)
+
+# Component(s) in the package.
+atlas_add_library( CrackRegionGeoModel
+		   src/*.cxx
+		   PUBLIC_HEADERS CrackRegionGeoModel
+		   INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS}
+		   LINK_LIBRARIES ${GEOMODEL_LIBRARIES}
+		   PRIVATE_LINK_LIBRARIES GaudiKernel GeoModelUtilities StoreGateLib RDBAccessSvcLib )
+

AtlasGeometryCommon/CrackRegionGeoModel/CrackRegionGeoModel/ATLAS_CHECK_THREAD_SAFETY

+AtlasGeometryCommon/CrackRegionGeoModel
\ No newline at end of file

AtlasGeometryCommon/CrackRegionGeoModel/CrackRegionGeoModel/CrackDMConstruction.h

+/*
+  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef CRACKREGIONGEOMODEL_CRACKDMCONSTRUCTION_H
+#define CRACKREGIONGEOMODEL_CRACKDMCONSTRUCTION_H
+
+#include "AthenaBaseComps/AthMessaging.h"
+
+class IRDBAccessSvc;
+class IGeoModelSvc;
+class StoredMaterialManager;
+class GeoFullPhysVol;
+
+class CrackDMConstruction : public AthMessaging
+{
+ public:
+  CrackDMConstruction() = delete;
+  CrackDMConstruction(IRDBAccessSvc* rdbAccess
+		      , IGeoModelSvc* geoModel
+		      , StoredMaterialManager* materialManager
+		      , bool activateFT);
+  
+  void create(GeoFullPhysVol* envelope);
+
+ private:
+  IRDBAccessSvc*         m_rdbAccess{nullptr};
+  IGeoModelSvc*          m_geoModel{nullptr};
+  StoredMaterialManager* m_materialManager{nullptr};
+  bool                   m_activateFT{false};
+
+};
+
+#endif

AtlasGeometryCommon/GeoModelEnvelopes/CMakeLists.txt

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
 # Declare the package name:
 atlas_subdir( GeoModelEnvelopes )
 
 # External dependencies:
-find_package( GeoModelCore )
+find_package( GeoModel COMPONENTS GeoModelKernel )
 
 # Component(s) in the package:
 atlas_add_component( GeoModelEnvelopes
                      src/*.cxx
                      src/components/*.cxx
-                     LINK_LIBRARIES ${GEOMODELCORE_LIBRARIES} AthenaKernel GaudiKernel GeoModelInterfaces GeoModelUtilities SGTools StoreGateLib )
+		     INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS}
+                     LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaKernel GaudiKernel GeoModelInterfaces GeoModelUtilities SGTools StoreGateLib )

AtlasGeometryCommon/GeoModelEnvelopes/GeoModelEnvelopes/ForDetEnvelopeManager.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef ForDetEnvelopeManager_h
@@ -10,7 +10,7 @@
 
 #include <vector>
 
-class ForDetEnvelopeManager : public GeoVDetectorManager  
+class ForDetEnvelopeManager : public GeoVDetectorManager
 {
  public:
 
@@ -22,19 +22,19 @@ class ForDetEnvelopeManager : public GeoVDetectorManager
 
   // Access to raw geometry:
   virtual unsigned int getNumTreeTops() const;
-  
+
   // Access to raw geometry:
   virtual PVConstLink getTreeTop(unsigned int i) const;
 
   // Add a Tree top:
-  void addTreeTop(PVLink);
+  void addTreeTop(const PVLink&);
 
- private:  
+ private:
 
   const ForDetEnvelopeManager & operator=(const ForDetEnvelopeManager &right);
   ForDetEnvelopeManager(const ForDetEnvelopeManager &right);
-  
-  std::vector<PVLink> m_volume;  
+
+  std::vector<PVLink> m_volume;
 
 };
 

AtlasGeometryCommon/GeoModelEnvelopes/src/ForDetEnvelopeFactory.cxx

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "ForDetEnvelopeFactory.h"
 
 #include "GeoModelInterfaces/StoredMaterialManager.h"
-#include "GeoModelKernel/GeoMaterial.h"  
-#include "GeoModelKernel/GeoTube.h"  
-#include "GeoModelKernel/GeoLogVol.h"  
-#include "GeoModelKernel/GeoNameTag.h"  
-#include "GeoModelKernel/GeoPhysVol.h"  
-#include "GeoModelKernel/GeoShapeShift.h"  
+#include "GeoModelKernel/GeoMaterial.h"
+#include "GeoModelKernel/GeoTube.h"
+#include "GeoModelKernel/GeoLogVol.h"
+#include "GeoModelKernel/GeoNameTag.h"
+#include "GeoModelKernel/GeoPhysVol.h"
+#include "GeoModelKernel/GeoShapeShift.h"
 #include "GeoModelKernel/GeoShapeUnion.h"
 
 #include "StoreGate/StoreGateSvc.h"
@@ -20,23 +20,20 @@
 
 
 ForDetEnvelopeFactory::ForDetEnvelopeFactory(StoreGateSvc *detStore)
-  : m_detectorManager(0),
-    m_materialManager(0),
+  : m_detectorManager(nullptr),
+    m_materialManager(nullptr),
     m_detectorStore(detStore)
 {
 }
 
-ForDetEnvelopeFactory::~ForDetEnvelopeFactory()
-{
-}
 
 void ForDetEnvelopeFactory::create(GeoPhysVol *world)
 {
   if (StatusCode::SUCCESS != m_detectorStore->retrieve(m_materialManager, std::string("MATERIALS"))) {
-    return; 
-  } 
-  
-  // Get the materials  
+    return;
+  }
+
+  // Get the materials
   const GeoMaterial* air = m_materialManager->getMaterial("std::Air");
 
   // Build boolean shape: union of two tubes
@@ -47,7 +44,7 @@ void ForDetEnvelopeFactory::create(GeoPhysVol *world)
 
   const GeoShapeShift& envShape1 = (*tube1)<<xfRelativeA;
   const GeoShapeUnion& envShape = envShape1.add((*tube2)<<xfRelativeC);
-  
+
   GeoLogVol* lvEnv = new GeoLogVol("ForDetEnvelope",&envShape,air);
   GeoPhysVol* pvEnv = new GeoPhysVol(lvEnv);
 

AtlasGeometryCommon/GeoModelEnvelopes/src/ForDetEnvelopeFactory.h

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef GEOMODELENVELOPES_FORDETENVELOPEFACTORY_H
@@ -12,36 +12,36 @@ class StoreGateSvc;
 class StoredMaterialManager;
 class GeoShape;
 
-class ForDetEnvelopeFactory final : public GeoVDetectorFactory  
+class ForDetEnvelopeFactory final : public GeoVDetectorFactory
 {
  public:
-  
+
   // Constructor:
   ForDetEnvelopeFactory(StoreGateSvc *pDetStore);
-  
+
   // Destructor:
-  ~ForDetEnvelopeFactory();
-  
+  ~ForDetEnvelopeFactory() = default;
+
   // Creation of geometry:
   virtual void create(GeoPhysVol *world) override;
-  
+
   // Access to the results:
   virtual const ForDetEnvelopeManager * getDetectorManager() const override;
-  
- private:  
+
+ private:
 
   // Illegal operations:
   const ForDetEnvelopeFactory & operator=(const ForDetEnvelopeFactory &right);
   ForDetEnvelopeFactory(const ForDetEnvelopeFactory &right);
-  
+
   // The manager:
   ForDetEnvelopeManager*   m_detectorManager;
-   
-  const StoredMaterialManager* m_materialManager;
+
+  StoredMaterialManager* m_materialManager;
   StoreGateSvc*             m_detectorStore;
 };
 
-// Class ForDetEnvelopeFactory 
+// Class ForDetEnvelopeFactory
 #endif
 
 

AtlasGeometryCommon/GeoModelEnvelopes/src/ForDetEnvelopeManager.cxx

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "GeoModelEnvelopes/ForDetEnvelopeManager.h"
@@ -10,12 +10,7 @@ ForDetEnvelopeManager::ForDetEnvelopeManager()
 }
 
 
-ForDetEnvelopeManager::~ForDetEnvelopeManager()
-{
-  for (unsigned int i = 0; i < m_volume.size(); i++) {
-    m_volume[i]->unref();
-  }
-}
+ForDetEnvelopeManager::~ForDetEnvelopeManager() = default;
 
 
 unsigned int ForDetEnvelopeManager::getNumTreeTops() const
@@ -28,9 +23,8 @@ PVConstLink ForDetEnvelopeManager::getTreeTop(unsigned int i) const
   return m_volume[i];
 }
 
-void  ForDetEnvelopeManager::addTreeTop(PVLink vol)
+void  ForDetEnvelopeManager::addTreeTop(const PVLink& vol)
 {
-  vol->ref();
   m_volume.push_back(vol);
 }