AtlasGeometryCommon/BeamPipeGeoModel/BeamPipeGeoModel/BeamPipeDetectorManager.h

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
-#ifndef BeamPipeDetectorManager_h
-#define BeamPipeDetectorManager_h 1
+#ifndef BEAMPIPEGEOMODEL_BEAMPIPEDETECTORMANAGER_H
+#define BEAMPIPEGEOMODEL_BEAMPIPEDETECTORMANAGER_H
 
 #include "GeoModelKernel/GeoVPhysVol.h"
 #include "GeoModelKernel/GeoVDetectorManager.h"
@@ -27,7 +27,7 @@ class BeamPipeDetectorManager : public GeoVDetectorManager
   virtual PVConstLink getTreeTop(unsigned int i) const;
 
   // Add a Tree top:
-  void addTreeTop(PVConstLink);
+  void addTreeTop(const PVConstLink&);
 
  private:  
 
@@ -35,7 +35,6 @@ class BeamPipeDetectorManager : public GeoVDetectorManager
   BeamPipeDetectorManager(const BeamPipeDetectorManager &right);
   
   std::vector<PVConstLink> m_volume;  
-
 };
 
 #ifndef GAUDI_NEUTRAL

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorFactory.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
 */
 
 #include "BeamPipeDetectorFactory.h"
@@ -33,16 +33,15 @@
 
 BeamPipeDetectorFactory::BeamPipeDetectorFactory(StoreGateSvc *detStore,
 						 IRDBAccessSvc *pAccess)
-  :m_detectorManager(0),
-   m_materialManager(0),
+  :m_detectorManager(nullptr),
+   m_materialManager(nullptr),
    m_detectorStore(detStore),
    m_access(pAccess),
    m_centralRegionZMax(1500*Gaudi::Units::mm)
 {}
 
 BeamPipeDetectorFactory::~BeamPipeDetectorFactory()
-{
-}
+= default;
 
 void BeamPipeDetectorFactory::create(GeoPhysVol *world)
 {
@@ -163,7 +162,7 @@ void BeamPipeDetectorFactory::addSections(GeoPhysVol* parent, int region)
 
   // Sections 2 & 3 are placed in section 1. 
   // pvMotherSection will point to section 1.
-  GeoPhysVol* pvMotherSection = 0;
+  GeoPhysVol* pvMotherSection = nullptr;
   bool addToFirstSection = true;
   double rminSec1 = 0;
   double rmaxSec1 = 0;
@@ -234,7 +233,7 @@ void BeamPipeDetectorFactory::addSections(GeoPhysVol* parent, int region)
     }
 
     const GeoMaterial* mat = m_materialManager->getMaterial(material);
-    if (mat == 0) {
+    if (mat == nullptr) {
       // For backward compatibility - older geometry versions didn't specify the
       // material namespace
       // std::cout << "Material """ << material << """ not found. Trying  std::" << material << std::endl;
@@ -242,8 +241,7 @@ void BeamPipeDetectorFactory::addSections(GeoPhysVol* parent, int region)
     }
 
     GeoLogVol* lvSection = new GeoLogVol(name,shape,mat);
-    GeoPhysVol* pvSection = new GeoPhysVol(lvSection);
-    pvSection->ref();
+    GeoIntrusivePtr<GeoPhysVol> pvSection{new GeoPhysVol(lvSection)};
     
     // Determine if this is a geometry where the first section can act as the mother of the following
     // sections. The following sections are only added to this if their ave radius is within the radial
@@ -264,10 +262,9 @@ void BeamPipeDetectorFactory::addSections(GeoPhysVol* parent, int region)
     }
 	     
 
-    GeoTransform* tfSection = 0;
+    GeoTransform* tfSection = nullptr;
     if (znew != 0 && (secNum==1 || !addToFirstSection)) tfSection = new GeoTransform(GeoTrf::TranslateZ3D(znew));
-    GeoNameTag* ntSection = new GeoNameTag(name);
-    ntSection->ref();
+    GeoIntrusivePtr<GeoNameTag> ntSection{new GeoNameTag(name)};
 
     if (addToFirstSection && secNum!=1) {
       if (!pvMotherSection) {
@@ -289,7 +286,7 @@ void BeamPipeDetectorFactory::addSections(GeoPhysVol* parent, int region)
     // Not needed, but just in case in the future we have +/- sections in central region
     if(central && z!=0.) {
       // add rotated section as well
-      GeoTransform* tfSectionRot = 0;
+      GeoTransform* tfSectionRot = nullptr;
       if (isTube) { 
 	// No need for rotation.
 	tfSectionRot = new GeoTransform(GeoTrf::TranslateZ3D(-znew));
@@ -302,8 +299,6 @@ void BeamPipeDetectorFactory::addSections(GeoPhysVol* parent, int region)
       parent->add(pvSection);
     }
 
-    pvSection->unref();
-    ntSection->unref();
   }
 }
 
@@ -340,16 +335,16 @@ BeamPipeDetectorFactory::makeEnvelope(const IRDBRecordset_ptr& bpipeEnvelope)
   }
 
   double rFwd = 0;
-  if (fwdEntry.size()) {
+  if (!fwdEntry.empty()) {
     rFwd = fwdEntry[0].r();    
-  } else if (centralEntry.size()) {
+  } else if (!centralEntry.empty()) {
     rFwd = centralEntry[0].r();    
   } else {
     std::cout << "Unexpected condition when building beam pipe." << std::endl;
   }
  
   // central
-  if (centralEntry.size() == 0) {
+  if (centralEntry.empty()) {
     envelopes.centralShape  = new GeoTube(0, rFwd, m_centralRegionZMax);
   } else {
     // This case probably will never get used and is untested.
@@ -375,7 +370,7 @@ BeamPipeDetectorFactory::makeEnvelope(const IRDBRecordset_ptr& bpipeEnvelope)
   {
     GeoRef<GeoPcon> pcone (new GeoPcon(0, 360*Gaudi::Units::deg));
     pcone->addPlane(m_centralRegionZMax,0,rFwd);
-    if (fwdEntry.size() == 0) { 
+    if (fwdEntry.empty()) { 
       // Unlikely case but for completeness
       // we make small fwd region if everything is in central region.
       pcone->addPlane(m_centralRegionZMax+0.1*Gaudi::Units::mm,0,rFwd);

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorFactory.h

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef BEAMPIPEGEOMODEL_BEAMPIPEDETECTORFACTORY_H

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorFactory_Lite.h

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef BEAMPIPEGEOMODEL_BEAMPIPEDETECTORFACTORY_LITE_H
@@ -7,8 +7,6 @@
 
 #include "GeoModelKernel/GeoVDetectorFactory.h"
 #include "BeamPipeGeoModel/BeamPipeDetectorManager.h"
-#include <string>
-
 
 class BeamPipeDetectorFactory_Lite final : public GeoVDetectorFactory  
 {
@@ -23,16 +21,13 @@ class BeamPipeDetectorFactory_Lite final : public GeoVDetectorFactory
   // Access to the results:
   virtual const BeamPipeDetectorManager * getDetectorManager() const override;
   
+  // Illegal operations:
+  const BeamPipeDetectorFactory_Lite & operator=(const BeamPipeDetectorFactory_Lite &right) = delete;
+  BeamPipeDetectorFactory_Lite(const BeamPipeDetectorFactory_Lite &right) = delete;
 
  private:  
-
-  // Illegal operations:
-  const BeamPipeDetectorFactory_Lite & operator=(const BeamPipeDetectorFactory_Lite &right);
-  BeamPipeDetectorFactory_Lite(const BeamPipeDetectorFactory_Lite &right);
-  
   // The manager:
-  BeamPipeDetectorManager     * m_manager;
-
+  BeamPipeDetectorManager* m_manager{nullptr};
 };
 
 // Class BeamPipeDetectorFactory_Lite 

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorManager.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
 */
 
 #include "BeamPipeGeoModel/BeamPipeDetectorManager.h"
@@ -10,13 +10,7 @@ BeamPipeDetectorManager::BeamPipeDetectorManager()
 }
 
 
-BeamPipeDetectorManager::~BeamPipeDetectorManager()
-{
-  for (unsigned int i = 0; i < m_volume.size(); i++) {
-    m_volume[i]->unref();
-  }
-}
-
+BeamPipeDetectorManager::~BeamPipeDetectorManager() = default;
 
 unsigned int BeamPipeDetectorManager::getNumTreeTops() const
 {
@@ -28,9 +22,8 @@ PVConstLink BeamPipeDetectorManager::getTreeTop(unsigned int i) const
   return m_volume[i];
 }
 
-void  BeamPipeDetectorManager::addTreeTop(PVConstLink vol)
+void  BeamPipeDetectorManager::addTreeTop(const PVConstLink& vol)
 {
-  vol->ref();
   m_volume.push_back(vol);
 }
 

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorTool.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
 */
 
 #include "BeamPipeDetectorTool.h"
-#include "BeamPipeDetectorFactory.h" 
-#include "BeamPipeDetectorFactory_Lite.h" 
-#include "BeamPipeGeoModel/BeamPipeDetectorManager.h" 
+#include "BeamPipeDetectorFactory.h"
+#include "BeamPipeDetectorFactory_Lite.h"
+#include "BeamPipeGeoModel/BeamPipeDetectorManager.h"
 
 #include "GeoModelInterfaces/IGeoDbTagSvc.h"
 #include "GeoModelUtilities/GeoModelExperiment.h"
 #include "GaudiKernel/IService.h"
 #include "GaudiKernel/ISvcLocator.h"
-#include "GaudiKernel/MsgStream.h"
 
 #include "StoreGate/StoreGateSvc.h"
 
@@ -21,95 +20,65 @@
 
 #include "GeoModelKernel/GeoVolumeCursor.h"
 
-BeamPipeDetectorTool::BeamPipeDetectorTool( const std::string& type, 
-					    const std::string& name, 
-					    const IInterface* parent ): 
-  GeoModelTool(type,name,parent),
-  m_manager(0),
-  m_mode("BeamPipe")
+BeamPipeDetectorTool::BeamPipeDetectorTool( const std::string& type,
+					    const std::string& name,
+					    const IInterface* parent ):
+  GeoModelTool(type,name,parent)
 {
-    declareProperty("BeamPipeMode",            m_mode); //m_mode="BeamPipe" by default, setting m_mode="AssemblyBeamPipe" will trigger optimised implementation using assembly volume
 }
 
-BeamPipeDetectorTool::~BeamPipeDetectorTool()
-{
-}
+BeamPipeDetectorTool::~BeamPipeDetectorTool() = default;
 
 
 StatusCode BeamPipeDetectorTool::create()
-{ 
-  MsgStream log(msgSvc(), name()); 
-
-  log << MSG::INFO << "Building Beam Pipe" << endmsg;
+{
+  ATH_MSG_INFO("Building Beam Pipe");
 
-  IGeoDbTagSvc *geoDbTag;
-  StatusCode sc = service ("GeoDbTagSvc",geoDbTag);
-  if (sc.isFailure()) {
-    log << MSG::FATAL << "Could not locate GeoDbTagSvc" << endmsg;
-    return StatusCode::FAILURE;
-  }
-    
+  SmartIF<IGeoDbTagSvc> geoDbTag{Gaudi::svcLocator()->service("GeoDbTagSvc")};
+  ATH_CHECK(geoDbTag.isValid());
 
   std::string atlasVersion = geoDbTag->atlasVersion();
-  if(atlasVersion == "AUTO")
-    atlasVersion = "ATLAS-00";
   std::string versionNode = "ATLAS";
 
-  GeoModelExperiment * theExpt; 
-  if (StatusCode::SUCCESS != detStore()->retrieve( theExpt, "ATLAS" )) { 
-    log << MSG::ERROR 
-	<< "Could not find GeoModelExperiment ATLAS" 
-	<< endmsg; 
-    return (StatusCode::FAILURE); 
-  } 
-
-  if ( 0 == m_detector ) 
-    {
-      GeoPhysVol *world=&*theExpt->getPhysVol();
-      
-      
-      ServiceHandle<IRDBAccessSvc> accessSvc(geoDbTag->getParamSvcName(),name());
-      ATH_CHECK( accessSvc.retrieve());
+  GeoModelExperiment* theExpt{nullptr};
+  ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
+
+  GeoPhysVol* world=theExpt->getPhysVol();
 
+  ServiceHandle<IRDBAccessSvc> accessSvc(geoDbTag->getParamSvcName(),name());
+  ATH_CHECK(accessSvc.retrieve());
+
+  GeoModelIO::ReadGeoModel* sqliteReader  = geoDbTag->getSqliteReader();
+  if (sqliteReader) {
+    BeamPipeDetectorFactory_Lite theBeamPipeFactory;
+    theBeamPipeFactory.create(world);
+    m_manager = theBeamPipeFactory.getDetectorManager();
+  }
+  else {
+    // Check we have the beampipe and print its version
+    // Print the  version tag:
+    std::string beampipeVersionTag;
+    beampipeVersionTag = accessSvc->getChildTag("BeamPipe", atlasVersion,versionNode);
+    ATH_MSG_DEBUG("Beampipe Version: " << beampipeVersionTag);
+
+    if (beampipeVersionTag.empty()) {
+      ATH_MSG_INFO("No BeamPipe Version. Beam pipe will not be built.");
+    }
+    else {
+      BeamPipeDetectorFactory theBeamPipeFactory(detStore().operator->(),accessSvc.operator->());
+      theBeamPipeFactory.setTagNode(atlasVersion,versionNode,m_mode);
+      theBeamPipeFactory.create(world);
       
-      GeoModelIO::ReadGeoModel* sqliteReader  = geoDbTag->getSqliteReader();
-      if (sqliteReader) {
-	BeamPipeDetectorFactory_Lite theBeamPipeFactory;
-	theBeamPipeFactory.create(world);
-	m_manager = theBeamPipeFactory.getDetectorManager();
-	
-      }
-      else {
-	
-	
-	// Check we have the beampipe and print its version
-	// Print the  version tag:
-	std::string beampipeVersionTag;
-	beampipeVersionTag = accessSvc->getChildTag("BeamPipe", atlasVersion,versionNode);
-	log << MSG::DEBUG << "Beampipe Version: " << beampipeVersionTag << endmsg;
-	
-	if (beampipeVersionTag.empty()) { 
-	  log << MSG::INFO << "No BeamPipe Version. Beam pipe will not be built." << endmsg;
-	}	
-	else {
-	  BeamPipeDetectorFactory theBeamPipeFactory(detStore().operator->(),accessSvc.operator->());
-	  theBeamPipeFactory.setTagNode(atlasVersion,versionNode,m_mode);
-	  theBeamPipeFactory.create(world);
-	  
-	  m_manager = theBeamPipeFactory.getDetectorManager();
-	}
-      }
-
-      if (m_manager) {    
-	theExpt->addManager(m_manager);
-	sc = detStore()->record(m_manager,m_manager->getName());
-	if (sc.isFailure()) {
-	  log << MSG::ERROR << "Could not register BeamPipe detector manager" << endmsg;
-	  return (StatusCode::FAILURE); 
-	}
-	return StatusCode::SUCCESS;
-      }
+      m_manager = theBeamPipeFactory.getDetectorManager();
     }
+  }
+
+  if (m_manager) {
+    theExpt->addManager(m_manager);
+    ATH_CHECK(detStore()->record(m_manager,m_manager->getName()));
+    return StatusCode::SUCCESS;
+  }
+
   return StatusCode::FAILURE;
 }
 
@@ -118,7 +87,7 @@ StatusCode BeamPipeDetectorTool::clear()
   SG::DataProxy* proxy = detStore()->proxy(ClassID_traits<BeamPipeDetectorManager>::ID(),m_manager->getName());
   if(proxy) {
     proxy->reset();
-    m_manager = 0;
+    m_manager = nullptr;
   }
   return StatusCode::SUCCESS;
 }

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorTool.h

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
-#ifndef BEAMPIPEDETECTORTOOL_H
-#define BEAMPIPEDETECTORTOOL_H
+#ifndef BEAMPIPEGEOMODEL_BEAMPIPEDETECTORTOOL_H
+#define BEAMPIPEGEOMODEL_BEAMPIPEDETECTORTOOL_H
 
 #include "GeoModelUtilities/GeoModelTool.h"
 class BeamPipeDetectorManager;
@@ -20,9 +20,13 @@ class BeamPipeDetectorTool final : public GeoModelTool
 
   virtual StatusCode create() override final;
   virtual StatusCode clear() override final;
+
  private:
-  const BeamPipeDetectorManager* m_manager;
-  std::string m_mode;
+  const BeamPipeDetectorManager* m_manager{nullptr};
+  StringProperty m_mode{this
+      , "BeamPipeMode"
+      , "BeamPipe"
+      , "Two modes: 'BeamPipe' default, 'AssemblyBeamPipe' activates implementation based on assembly volume"};
 };
 
 #endif 

AtlasGeometryCommon/CavernInfraGeoModel/CMakeLists.txt

-# Copyright (C) 2002-, 20222022 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 )

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorFactory.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
 */
 
 #include "CavernInfraDetectorFactory.h"
 
 #include "GeoModelInterfaces/StoredMaterialManager.h"
 
-#include "GeoModelKernel/GeoMaterial.h"  
-#include "GeoModelKernel/GeoTube.h"  
+#include "GeoModelKernel/GeoMaterial.h"
+#include "GeoModelKernel/GeoTube.h"
 #include "GeoModelKernel/GeoBox.h"
-#include "GeoModelKernel/GeoTubs.h"  
-#include "GeoModelKernel/GeoLogVol.h"  
-#include "GeoModelKernel/GeoNameTag.h"  
+#include "GeoModelKernel/GeoTubs.h"
+#include "GeoModelKernel/GeoLogVol.h"
+#include "GeoModelKernel/GeoNameTag.h"
 #include "GeoModelKernel/GeoPhysVol.h"
 #include "GeoModelKernel/GeoShape.h"
 #include "GeoModelKernel/GeoShapeShift.h"
@@ -21,34 +21,30 @@
 #include "GaudiKernel/SystemOfUnits.h"
 #include "StoreGate/StoreGateSvc.h"
 
+#include "RDBAccessSvc/IRDBAccessSvc.h"
 #include "RDBAccessSvc/IRDBRecord.h"
 #include "RDBAccessSvc/IRDBRecordset.h"
-#include "RDBAccessSvc/IRDBAccessSvc.h"
-#include <string>
 #include <map>
+#include <string>
+#include <utility>
 
-CavernInfraDetectorFactory::CavernInfraDetectorFactory(StoreGateSvc *detStore,
-						       IRDBAccessSvc *pAccess)
-  :m_detectorManager(NULL),
-   m_detectorStore(detStore),
-   m_access(pAccess)
-{
-}
-
-CavernInfraDetectorFactory::~CavernInfraDetectorFactory()
+CavernInfraDetectorFactory::CavernInfraDetectorFactory(ServiceHandle<StoreGateSvc> detStore,
+						       ServiceHandle<IRDBAccessSvc> pAccess)
+  : m_detectorStore(std::move(detStore))
+  , m_access(std::move(pAccess))
 {
 }
 
 void CavernInfraDetectorFactory::create(GeoPhysVol *world)
-{ 
+{
   m_detectorManager=new CavernInfraDetectorManager();
 
   StoredMaterialManager* materialManager = nullptr;
   if (StatusCode::SUCCESS != m_detectorStore->retrieve(materialManager, std::string("MATERIALS"))) {
-    return; 
-  } 
+    return;
+  }
 
-   // Get the materials  
+   // Get the materials
   const GeoMaterial *air        = materialManager->getMaterial("std::Air");
   const GeoMaterial *rock       = materialManager->getMaterial("std::Rock");
   const GeoMaterial *conc       = materialManager->getMaterial("std::Concrete");
@@ -56,14 +52,14 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
 
   // Get Recordset CavernElements.
   IRDBRecordset_ptr cavernElements = m_access->getRecordsetPtr("CavernElements",m_versionTag,m_versionNode);
- 
+
   std::map<std::string, unsigned int> elementMap;
- 
+
   for (unsigned int i=0; i<cavernElements->size(); i++) {
     std::string key = (*cavernElements)[i]->getString("ELEMENT");
     elementMap[key] = i;
   }
- 
+
   unsigned int recordIndex;
  //// -------------------------Build mother volume Point1--------------------------------
 
@@ -71,13 +67,13 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
  // -- first get index of the record in cavernElements recordset
  // which corresponds to Point1 element
  // -- get numbers from record
-  
-  recordIndex = elementMap["Point1"]; 
+
+  recordIndex = elementMap["Point1"];
 
   GeoNameTag *tag = new GeoNameTag("CavernInfra");
 
  //// -----------------------------------Build SX1------------------------------------------
- 
+
   recordIndex = elementMap["SX1"];
   double SX1Xpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
   double SX1Ypos = (*cavernElements)[recordIndex]->getDouble("YPOS")*Gaudi::Units::m;
@@ -85,11 +81,11 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
   double SX1HalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
   double SX1HalfWidth  = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double SX1HalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  
+
   recordIndex = elementMap["SX1Air"];
   double SX1AirYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*Gaudi::Units::m;
-  double SX1AirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;  
-  double SX1AirHalfWidth  = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;   
+  double SX1AirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
+  double SX1AirHalfWidth  = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double SX1AirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
 
   GeoTransform *s1XYZt = new GeoTransform(GeoTrf::Translate3D(SX1Xpos,SX1Ypos,SX1Zpos)); //1.7  -8.7
@@ -97,9 +93,9 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
   GeoBox     *SX1        = new GeoBox(SX1HalfWidth ,SX1HalfHeight, SX1HalfLength); //  11.7, 6.5, 42.3
   GeoLogVol  *lvsx1s     = new GeoLogVol("SX1Steel",SX1,shieldSteel);
   GeoPhysVol *sx1        = new GeoPhysVol(lvsx1s);
-  world->add(tag);                                                                             
+  world->add(tag);
   world->add(sx1);
-   
+
 
   GeoTransform *s1z = new GeoTransform(GeoTrf::TranslateY3D(SX1AirYpos));
   sx1->add(s1z);
@@ -107,59 +103,59 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
   GeoLogVol  *lvsx1a     = new GeoLogVol("SX1Air",SX1Air,air);
   GeoPhysVol *sx1a       = new GeoPhysVol(lvsx1a);
   sx1->add(sx1a);
- 
- 
+
+
  //// ------------------First: Build cavern with concrete-----------------------------
 
   recordIndex = elementMap["WallACConc"];
   double WallACConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double WallACConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double WallACConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double WallACConcMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
   double WallACConcSphi= (*cavernElements)[recordIndex]->getDouble("SPHI");
-  double WallACConcDphi= (*cavernElements)[recordIndex]->getDouble("DPHI"); 
+  double WallACConcDphi= (*cavernElements)[recordIndex]->getDouble("DPHI");
 
   recordIndex = elementMap["BoxConc"];
-  double BoxConcHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m; 
-  double BoxConcHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;  
+  double BoxConcHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
+  double BoxConcHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double BoxConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
 
   recordIndex = elementMap["VaultConc"];
-  double VaultConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double VaultConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double VaultConcYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
   double VaultConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double VaultConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double VaultConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double VaultConcMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
   double VaultConcSphi= (*cavernElements)[recordIndex]->getDouble("SPHI");
   double VaultConcDphi= (*cavernElements)[recordIndex]->getDouble("DPHI");
 
   recordIndex = elementMap["HallConc"];
-  double HallConcHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m; 
-  double HallConcHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;  
+  double HallConcHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
+  double HallConcHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double HallConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
 
   recordIndex = elementMap["BoxConcW"];
-  double BoxConcWZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double BoxConcWZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double BoxConcWYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
 
   recordIndex = elementMap["BoxConcVleft"];
-  double BoxConcVleftZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double BoxConcVleftZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double BoxConcVleftYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
 
   recordIndex = elementMap["BoxConcVright"];
-  double BoxConcVrightZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double BoxConcVrightZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double BoxConcVrightYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
 
   recordIndex = elementMap["SurfaceFloor"];
   double SurfaceFloorXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
-  double SurfaceFloorZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
-  double SurfaceFloorHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m; 
-  double SurfaceFloorHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;  
+  double SurfaceFloorZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
+  double SurfaceFloorHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
+  double SurfaceFloorHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double SurfaceFloorHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
 
-   
-  GeoTubs *WallACConcrete      = new GeoTubs(WallACConcMinR, WallACConcMaxR, WallACConcHalfHeight, WallACConcSphi, WallACConcDphi);    
+
+  GeoTubs *WallACConcrete      = new GeoTubs(WallACConcMinR, WallACConcMaxR, WallACConcHalfHeight, WallACConcSphi, WallACConcDphi);
   GeoBox  *BoxConc             = new GeoBox(BoxConcHalfLength, BoxConcHalfWidth, BoxConcHalfHeight);
-  GeoTubs *VaultConcrete       = new GeoTubs(VaultConcMinR, VaultConcMaxR, VaultConcHalfHeight , VaultConcSphi, VaultConcDphi);        
+  GeoTubs *VaultConcrete       = new GeoTubs(VaultConcMinR, VaultConcMaxR, VaultConcHalfHeight , VaultConcSphi, VaultConcDphi);
   GeoBox  *HallConcrete        = new GeoBox(HallConcHalfLength, HallConcHalfWidth, HallConcHalfHeight);
   GeoBox  *SurfaceFloor        = new GeoBox(SurfaceFloorHalfLength, SurfaceFloorHalfWidth, SurfaceFloorHalfHeight);
 
@@ -187,46 +183,46 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
         subtract((*HoleJN) << GeoTrf::RotateY3D(M_PI*0.5) << GeoTrf::TranslateZ3D(-0.5*WallAAirZpos)*GeoTrf::TranslateY3D(-WallCAirXpos*1.0) );
   const GeoShape & CutVaultConc  = (*VaultConcrete).subtract((*BoxConc) << GeoTrf::Transform3D(BoxCutVaultLeftConc)).
                                                     subtract((*BoxConc) << GeoTrf::Transform3D(BoxCutVaulRightConc));
- 
+
   recordIndex = elementMap["ShaftCut"];
-  double ShaftCutZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double ShaftCutZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double ShaftCutYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
   double ShaftCutHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double ShaftCutMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double ShaftCutMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double ShaftCutMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
 
   recordIndex = elementMap["PX14Conc"];
-  double PX14ConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m; 
+  double PX14ConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
   double PX14ConcYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*Gaudi::Units::m;
   double PX14ConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double PX14ConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double PX14ConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double PX14ConcMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
 
   recordIndex = elementMap["PX16Conc"];
-  double PX16ConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m; 
+  double PX16ConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
   double PX16ConcYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*Gaudi::Units::m;
   double PX16ConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double PX16ConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double PX16ConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double PX16ConcMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
 
   //--------------- Build concrete shafts------------------------------.
   GeoTube     *ShaftCut  = new GeoTube(ShaftCutMinR, ShaftCutMaxR, ShaftCutHalfHeight);
   GeoTube     *PX14Conc  = new GeoTube(PX14ConcMinR, PX14ConcMaxR, PX14ConcHalfHeight);
   GeoTube     *PX16Conc  = new GeoTube(PX16ConcMinR, PX16ConcMaxR, PX16ConcHalfHeight);
-      
+
   const GeoShape & ShaftsConc=
 	((*PX14Conc)           << GeoTrf::TranslateX3D(PX14ConcXpos)*GeoTrf::TranslateY3D(PX14ConcYpos)).
 	add((*PX16Conc)        << GeoTrf::TranslateX3D(PX16ConcXpos)*GeoTrf::TranslateY3D(PX16ConcYpos)).
 	subtract((*ShaftCut)   << GeoTrf::TranslateZ3D(ShaftCutZpos)*GeoTrf::RotateY3D(ShaftCutYrotate));
- 
+
   recordIndex = elementMap["WallCConc"];
   double WallCConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
-  double WallCConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m; 
+  double WallCConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
   double WallCConcZrotate = (*cavernElements)[recordIndex]->getDouble("ZROTATE");
 
   recordIndex = elementMap["WallAConc"];
   double WallAConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
-  double WallAConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m; 
+  double WallAConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
 
   recordIndex = elementMap["ShaftsConc"];
   double ShaftsConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
@@ -283,57 +279,57 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
 //        subtract((*HoleJN) << GeoTrf::RotateY3D(M_PI*0.5) << GeoTrf::TranslateZ3D(-0.5*WallAAirZpos+CavernAirZpos)*GeoTrf::TranslateY3D(-WallCAirXpos*1.0) );
 //        subtract((*HoleJN) << GeoTrf::RotateY3D(M_PI*0.5) << GeoTrf::TranslateZ3D(-0.5*WallAAirZpos)*GeoTrf::TranslateY3D(-WallCAirXpos*1.0) );
 
-	
+
  //// -----------------------Second: Build cavern with air-------------------------------
 
   // Create variables for Concrete Cavern and get index of the record in cavernElements
    recordIndex = elementMap["WallACAir"];
   double WallACAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double WallACAirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double WallACAirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double WallACAirMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
   double WallACAirSphi= (*cavernElements)[recordIndex]->getDouble("SPHI");
-  double WallACAirDphi= (*cavernElements)[recordIndex]->getDouble("DPHI"); 
- 
+  double WallACAirDphi= (*cavernElements)[recordIndex]->getDouble("DPHI");
+
   recordIndex = elementMap["BoxAir"];
-  double BoxAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m; 
-  double BoxAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;  
+  double BoxAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
+  double BoxAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double BoxAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
- 
+
   recordIndex = elementMap["VaultAir"];
-  double VaultAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double VaultAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double VaultAirYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
   double VaultAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double VaultAirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double VaultAirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double VaultAirMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
   double VaultAirSphi= (*cavernElements)[recordIndex]->getDouble("SPHI");
   double VaultAirDphi= (*cavernElements)[recordIndex]->getDouble("DPHI");
- 
+
   recordIndex = elementMap["HallAir"];
-  double HallAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m; 
-  double HallAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;  
+  double HallAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
+  double HallAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double HallAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
- 
+
   recordIndex = elementMap["BaseAir"];
-  double BaseAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
-  double BaseAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m; 
-  double BaseAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;  
+  double BaseAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
+  double BaseAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
+  double BaseAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double BaseAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
- 
+
   recordIndex = elementMap["BoxAirW"];
-  double BoxAirWZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double BoxAirWZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double BoxAirWYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
 
   recordIndex = elementMap["BoxAirVleft"];
-  double BoxAirVleftZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double BoxAirVleftZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double BoxAirVleftYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
- 
+
   recordIndex = elementMap["BoxAirVright"];
-  double BoxAirVrightZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m; 
+  double BoxAirVrightZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*Gaudi::Units::m;
   double BoxAirVrightYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
 
-  GeoTubs *WallACAir         = new GeoTubs(WallACAirMinR, WallACAirMaxR, WallACAirHalfHeight, WallACAirSphi, WallACAirDphi);        
+  GeoTubs *WallACAir         = new GeoTubs(WallACAirMinR, WallACAirMaxR, WallACAirHalfHeight, WallACAirSphi, WallACAirDphi);
   GeoBox  *BoxAir            = new GeoBox(BoxAirHalfLength, BoxAirHalfWidth, BoxAirHalfHeight);
-  GeoTubs *VaultAir          = new GeoTubs(VaultAirMinR, VaultAirMaxR, VaultAirHalfHeight, VaultAirSphi, VaultAirDphi);      
+  GeoTubs *VaultAir          = new GeoTubs(VaultAirMinR, VaultAirMaxR, VaultAirHalfHeight, VaultAirSphi, VaultAirDphi);
   GeoBox  *HallAir           = new GeoBox(HallAirHalfLength, HallAirHalfWidth, HallAirHalfHeight);
   GeoBox  *BaseAir           = new GeoBox(BaseAirHalfLength, BaseAirHalfWidth, BaseAirHalfHeight);
   GeoTrf::Transform3D BoxCutWallAir      = GeoTrf::TranslateZ3D(BoxAirWZpos)*GeoTrf::RotateY3D(BoxAirWYrotate);
@@ -347,20 +343,20 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
 
   //--------------- Build air shafts------------------------------.
   recordIndex = elementMap["PX14Air"];
-  double PX14AirXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m; 
+  double PX14AirXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
   double PX14AirYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*Gaudi::Units::m;
   double PX14AirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double PX14AirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double PX14AirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double PX14AirMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
- 
+
   recordIndex = elementMap["PX16Air"];
-  double PX16AirXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m; 
+  double PX16AirXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
   double PX16AirYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*Gaudi::Units::m;
   double PX16AirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
-  double PX16AirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;     
+  double PX16AirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*Gaudi::Units::m;
   double PX16AirMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*Gaudi::Units::m;
 
-  GeoTube     *PX14Air   = new GeoTube(PX14AirMinR, PX14AirMaxR, PX14AirHalfHeight);  
+  GeoTube     *PX14Air   = new GeoTube(PX14AirMinR, PX14AirMaxR, PX14AirHalfHeight);
   GeoTube     *PX16Air   = new GeoTube(PX16AirMinR, PX16AirMaxR, PX16AirHalfHeight);
 
   recordIndex = elementMap["CavShaftsConc"];
@@ -368,10 +364,10 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
   double CavShaftsXrotate = (*cavernElements)[recordIndex]->getDouble("XROTATE");
   double CavShaftsYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
 
-  const GeoShape & ShaftsAir= 
+  const GeoShape & ShaftsAir=
 	  ((*PX14Air)     << GeoTrf::TranslateX3D(PX14AirXpos)*GeoTrf::TranslateY3D(PX14AirYpos)).
 	  add((*PX16Air)  << GeoTrf::TranslateX3D(PX16AirXpos)*GeoTrf::TranslateY3D(PX16AirYpos));
- 
+
   //----------------Assemble everything--------------------------------.
   const GeoShape & CavernAir = (*HallAir).
 //      add((*AirJN) << GeoTrf::RotateY3D(M_PI*0.5) << GeoTrf::TranslateZ3D(-0.5*WallAAirZpos)*GeoTrf::TranslateY3D(-WallCAirXpos*1.0) ).
@@ -400,16 +396,16 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
   const GeoShape & AirHall=
           ((CavernAir     << GeoTrf::TranslateZ3D(CavernAirZpos))).
           add((ShaftsAir  << GeoTrf::TranslateZ3D(ShaftsAirZpos)));     //allows for a built-in 2m thick plugs for both PX14 & PX16
- 
+
  //// -----------------------Build BedRock for Shafts and Cavern-------------------------------
- 
+
   recordIndex = elementMap["Rock"];
-  double RockHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m; 
-  double RockHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;  
+  double RockHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*Gaudi::Units::m;
+  double RockHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*Gaudi::Units::m;
   double RockHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*Gaudi::Units::m;
   double RockXPos = (*cavernElements)[recordIndex]->getDouble("XPOS")*Gaudi::Units::m;
   double RockYPos = (*cavernElements)[recordIndex]->getDouble("YPOS")*Gaudi::Units::m;
-  
+
   GeoBox     *Rockbox     = new GeoBox( RockHalfWidth, RockHalfHeight, RockHalfLength); // 300, 50.75, 300
   const GeoShape & BedRock = ((*Rockbox) .
 			      subtract((AirHall) <<GeoTrf::TranslateY3D(CavShaftsYPos)*GeoTrf::RotateY3D(CavShaftsYrotate)*GeoTrf::RotateX3D(CavShaftsXrotate))).
@@ -426,18 +422,18 @@ void CavernInfraDetectorFactory::create(GeoPhysVol *world)
   const GeoShape & CavConcrete = ((Concrete).
 //        add((*HoleJN) << GeoTrf::RotateY3D(M_PI*0.5) << GeoTrf::TranslateZ3D(-0.5*WallAAirZpos+CavernAirZpos)*GeoTrf::TranslateY3D(-WallCAirXpos*1.0) ).
         subtract(AirHall));
-  
-  GeoTransform* xfTop = new GeoTransform(GeoTrf::TranslateY3D(CavShaftsYPos)*GeoTrf::RotateY3D(CavShaftsYrotate)*GeoTrf::RotateX3D(CavShaftsXrotate)); 
+
+  GeoTransform* xfTop = new GeoTransform(GeoTrf::TranslateY3D(CavShaftsYPos)*GeoTrf::RotateY3D(CavShaftsYrotate)*GeoTrf::RotateX3D(CavShaftsXrotate));
   bedrock->add(xfTop);
   GeoLogVol  *lvcsc              = new GeoLogVol("CAV_SHAFTS_CONC",&CavConcrete,conc);
   GeoPhysVol *CavShaftsConc      = new GeoPhysVol(lvcsc);
   bedrock->add(CavShaftsConc);
-  
+
 
   //// NOW INSERT ALL OF THIS INTO THE WORLD.
   m_detectorManager->addTreeTop(sx1);
-  m_detectorManager->addTreeTop(bedrock);  
-  
+  m_detectorManager->addTreeTop(bedrock);
+
 }
 
 const CavernInfraDetectorManager * CavernInfraDetectorFactory::getDetectorManager() const

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorFactory.h

 /*
-  Copyright (C) 2002-2022 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 "GeoModelKernel/GeoVDetectorFactory.h"
 #include "CavernInfraDetectorManager.h"
+#include "GeoModelKernel/GeoVDetectorFactory.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(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.cxx

-/*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "CavernInfraDetectorFactory01.h"
-
-
-#include "GeoModelKernel/GeoMaterial.h"  
-#include "GeoModelKernel/GeoPcon.h"  
-#include "GeoModelKernel/GeoTube.h"  
-#include "GeoModelKernel/GeoBox.h"
-#include "GeoModelKernel/GeoTubs.h"  
-#include "GeoModelKernel/GeoCons.h"
-#include "GeoModelKernel/GeoLogVol.h"  
-#include "GeoModelKernel/GeoNameTag.h"  
-#include "GeoModelKernel/GeoPhysVol.h"
-#include "GeoModelKernel/GeoShape.h"
-#include "GeoModelKernel/GeoShapeShift.h"
-#include "GeoModelKernel/GeoShapeUnion.h"
-#include "GeoModelKernel/GeoShapeSubtraction.h"
-#include "GeoModelKernel/GeoFullPhysVol.h"  
-#include "GeoModelKernel/GeoTransform.h"
-#include "GeoModelKernel/GeoAlignableTransform.h"
-#include "GeoModelKernel/GeoSerialDenominator.h"  
-#include "GeoModelKernel/GeoSerialTransformer.h"
-#include "GeoGenericFunctions/AbsFunction.h"
-#include "GeoGenericFunctions/Variable.h"
-#include "GeoGenericFunctions/Sin.h"
-#include "GeoGenericFunctions/Cos.h"
-#include "StoreGate/StoreGateSvc.h"
-
-
-#include "GeoModelInterfaces/StoredMaterialManager.h"
-
-#include "RDBAccessSvc/IRDBRecord.h"
-#include "RDBAccessSvc/IRDBRecordset.h"
-#include "RDBAccessSvc/IRDBAccessSvc.h"
-#include <string>
-#include <map>
-using namespace GeoGenfun;
-using namespace GeoXF;
-
-CavernInfraDetectorFactory01::CavernInfraDetectorFactory01(StoreGateSvc *detStore,
-				       IRDBAccessSvc *pAccess)
-  :m_detectorManager(NULL),
-   m_detectorStore(detStore),
-   m_access(pAccess)
- 
-{
-}
-
-CavernInfraDetectorFactory01::~CavernInfraDetectorFactory01()
-{
-}
-
-void CavernInfraDetectorFactory01::create(GeoPhysVol *world)
-{ 
-  m_detectorManager=new CavernInfraDetectorManager();
-
-  StoredMaterialManager* materialManager = nullptr;
-  if (StatusCode::SUCCESS != m_detectorStore->retrieve(materialManager, std::string("MATERIALS"))) {
-    return; 
-  } 
-
-   // Get the materials  
-  const GeoMaterial *air        = materialManager->getMaterial("std::Air");
-  const GeoMaterial *rock       = materialManager->getMaterial("std::Rock");
-  const GeoMaterial *conc       = materialManager->getMaterial("std::Concrete");
-  const GeoMaterial *shieldSteel      = materialManager->getMaterial("shield::ShieldSteel");
- 
-  // Get Recordset CavernElements.
-  IRDBRecordset_ptr cavernElements = m_access->getRecordsetPtr("CavernElements", "CavernElements-02");  
- 
-  std::map<std::string, unsigned int> elementMap;
- 
-  for (unsigned int i=0; i<cavernElements->size(); i++) {
-    std::string key = (*cavernElements)[i]->getString("ELEMENT");
-    elementMap[key] = i;
-  }
-  
-  unsigned int recordIndex;
- //// -------------------------Build mother volume Point1--------------------------------
-
- // Create variables for Point1
- // -- first get index of the record in cavernElements recordset
- // which corresponds to Point1 element
- // -- get numbers from record
-  
-  recordIndex = elementMap["Point1"]; 
-
-  GeoNameTag *tag = new GeoNameTag("CavernInfra");
-
- //// -----------------------------------Build SX1------------------------------------------
- 
-  recordIndex = elementMap["SX1"];
-  double SX1Xpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m;
-  double SX1Ypos = (*cavernElements)[recordIndex]->getDouble("YPOS")*GeoModelKernelUnits::m;
-  double SX1HalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m;
-  double SX1HalfWidth  = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;
-  double SX1HalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  
-  recordIndex = elementMap["SX1Air"];
-  double SX1AirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m;  
-  double SX1AirHalfWidth  = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;   
-  double SX1AirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-
-  GeoTransform *s1XYZt = new GeoTransform(GeoTrf::Translate3D(SX1Ypos,91.75*GeoModelKernelUnits::m, SX1Xpos)); //1.7  -8.7
-  world->add(s1XYZt);
-  GeoBox     *SX1        = new GeoBox(SX1HalfWidth ,SX1HalfHeight, SX1HalfLength); //  11.7, 6.5, 42.3
-  GeoLogVol  *lvsx1s     = new GeoLogVol("SX1Steel",SX1,shieldSteel);
-  GeoPhysVol *sx1        = new GeoPhysVol(lvsx1s);
-  world->add(tag);                                                                             
-  world->add(sx1);
-   
-  GeoTransform *s1z = new GeoTransform(GeoTrf::TranslateY3D(-.005*GeoModelKernelUnits::m));
-  sx1->add(s1z);
-  GeoBox     *SX1Air     = new GeoBox( SX1AirHalfWidth, SX1AirHalfHeight, SX1AirHalfLength);
-  GeoLogVol  *lvsx1a     = new GeoLogVol("SX1Air",SX1Air,air);
-  GeoPhysVol *sx1a       = new GeoPhysVol(lvsx1a);
-  sx1->add(sx1a);
- 
- 
- //// ------------------First: Build cavern with concrete-----------------------------
-
-  recordIndex = elementMap["WallACConc"];
-  double WallACConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double WallACConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double WallACConcMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
-  double WallACConcSphi= (*cavernElements)[recordIndex]->getDouble("SPHI");
-  double WallACConcDphi= (*cavernElements)[recordIndex]->getDouble("DPHI"); 
-
-  recordIndex = elementMap["BoxConc"];
-  double BoxConcHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m; 
-  double BoxConcHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;  
-  double BoxConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-
-  recordIndex = elementMap["VaultConc"];
-  double VaultConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double VaultConcYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
-  double VaultConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double VaultConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double VaultConcMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
-  double VaultConcSphi= (*cavernElements)[recordIndex]->getDouble("SPHI");
-  double VaultConcDphi= (*cavernElements)[recordIndex]->getDouble("DPHI");
-
-  recordIndex = elementMap["HallConc"];
-  double HallConcHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m; 
-  double HallConcHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;  
-  double HallConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-
-  recordIndex = elementMap["BoxConcW"];
-  double BoxConcWZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double BoxConcWYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
-
-  recordIndex = elementMap["BoxConcVleft"];
-  double BoxConcVleftZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double BoxConcVleftYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
-
-  recordIndex = elementMap["BoxConcVright"];
-  double BoxConcVrightZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double BoxConcVrightYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
-
-  recordIndex = elementMap["SurfaceFloor"];
-  double SurfaceFloorXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m;
-  double SurfaceFloorZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double SurfaceFloorHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m; 
-  double SurfaceFloorHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;  
-  double SurfaceFloorHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-
-   
-  GeoTubs *WallACConcrete      = new GeoTubs(WallACConcMinR, WallACConcMaxR, WallACConcHalfHeight, WallACConcSphi, WallACConcDphi);    
-  GeoBox  *BoxConc             = new GeoBox(BoxConcHalfLength, BoxConcHalfWidth, BoxConcHalfHeight);
-  GeoTubs *VaultConcrete       = new GeoTubs(VaultConcMinR, VaultConcMaxR, VaultConcHalfHeight , VaultConcSphi, VaultConcDphi);        
-  GeoBox  *HallConcrete        = new GeoBox(HallConcHalfLength, HallConcHalfWidth, HallConcHalfHeight);
-  GeoBox  *SurfaceFloor        = new GeoBox(SurfaceFloorHalfLength, SurfaceFloorHalfWidth, SurfaceFloorHalfHeight);
-
-  GeoTrf::Transform3D BoxCutWallConc          = GeoTrf::TranslateZ3D(BoxConcWZpos)*GeoTrf::RotateY3D(BoxConcWYrotate);
-  GeoTrf::Transform3D BoxCutVaultLeftConc     = GeoTrf::TranslateZ3D(BoxConcVleftZpos)*GeoTrf::RotateY3D(BoxConcVleftYrotate);
-  GeoTrf::Transform3D BoxCutVaulRightConc     = GeoTrf::TranslateZ3D(BoxConcVrightZpos)*GeoTrf::RotateY3D(BoxConcVrightYrotate);
-
-  //---------------- Cut the vault and side walls----------------------------
-  const GeoShape & CutWallConc   = (*WallACConcrete).subtract((*BoxConc) << GeoTrf::Transform3D(BoxCutWallConc));
-  const GeoShape & CutVaultConc  = (*VaultConcrete).subtract((*BoxConc) << GeoTrf::Transform3D(BoxCutVaultLeftConc)).
-                                                    subtract((*BoxConc) << GeoTrf::Transform3D(BoxCutVaulRightConc));
- 
-  recordIndex = elementMap["ShaftCut"];
-  double ShaftCutZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double ShaftCutYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
-  double ShaftCutHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double ShaftCutMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double ShaftCutMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
-
-  recordIndex = elementMap["PX14Conc"];
-  double PX14ConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m; 
-  double PX14ConcYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*GeoModelKernelUnits::m;
-  double PX14ConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double PX14ConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double PX14ConcMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
-
-  recordIndex = elementMap["PX16Conc"];
-  double PX16ConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m; 
-  double PX16ConcYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*GeoModelKernelUnits::m;
-  double PX16ConcHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double PX16ConcMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double PX16ConcMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
-
-  //--------------- Build concrete shafts------------------------------.
-  GeoTube     *ShaftCut  = new GeoTube(ShaftCutMinR, ShaftCutMaxR, ShaftCutHalfHeight);
-  GeoTube     *PX14Conc  = new GeoTube(PX14ConcMinR, PX14ConcMaxR, PX14ConcHalfHeight);
-  GeoTube     *PX16Conc  = new GeoTube(PX16ConcMinR, PX16ConcMaxR, PX16ConcHalfHeight);
-      
-  const GeoShape & ShaftsConc=
-	((*PX14Conc)           << GeoTrf::TranslateX3D(PX14ConcXpos)*GeoTrf::TranslateY3D(PX14ConcYpos)).
-	add((*PX16Conc)        << GeoTrf::TranslateX3D(PX16ConcXpos)*GeoTrf::TranslateY3D(PX16ConcYpos)).
-	subtract((*ShaftCut)   << GeoTrf::TranslateZ3D(ShaftCutZpos)*GeoTrf::RotateY3D(ShaftCutYrotate));
- 
-  recordIndex = elementMap["WallCConc"];
-  double WallCConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m;
-  double WallCConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m; 
-  double WallCConcZrotate = (*cavernElements)[recordIndex]->getDouble("ZROTATE");
-
-  recordIndex = elementMap["WallAConc"];
-  double WallAConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m;
-  double WallAConcXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m; 
-
-  recordIndex = elementMap["ShaftsConc"];
-  double ShaftsConcZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m;
-
-  //----------------Assemble everything--------------------------------.
-  const GeoShape & Concrete= (*HallConcrete).
-	add((CutWallConc     << GeoTrf::TranslateZ3D(WallCConcZpos)*GeoTrf::TranslateX3D(WallCConcXpos)*GeoTrf::RotateZ3D(WallCConcZrotate))).
-        add((ShaftsConc      << GeoTrf::TranslateZ3D(ShaftsConcZpos))).
-	add((CutVaultConc    << GeoTrf::TranslateZ3D(VaultConcZpos)*GeoTrf::RotateY3D(VaultConcYrotate))).
-        add((*SurfaceFloor)  << GeoTrf::TranslateZ3D(SurfaceFloorZpos)*GeoTrf::TranslateX3D(SurfaceFloorXpos)).
-    add((CutWallConc     << GeoTrf::TranslateZ3D(WallAConcZpos)*GeoTrf::TranslateX3D(WallAConcXpos)));
-	
- //// -----------------------Second: Build cavern with air-------------------------------
-
-  // Create variables for Concrete Cavern and get index of the record in cavernElements
-   recordIndex = elementMap["WallACAir"];
-  double WallACAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double WallACAirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double WallACAirMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
-  double WallACAirSphi= (*cavernElements)[recordIndex]->getDouble("SPHI");
-  double WallACAirDphi= (*cavernElements)[recordIndex]->getDouble("DPHI"); 
- 
-  recordIndex = elementMap["BoxAir"];
-  double BoxAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m; 
-  double BoxAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;  
-  double BoxAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
- 
-  recordIndex = elementMap["VaultAir"];
-  double VaultAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double VaultAirYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
-  double VaultAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double VaultAirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double VaultAirMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
-  double VaultAirSphi= (*cavernElements)[recordIndex]->getDouble("SPHI");
-  double VaultAirDphi= (*cavernElements)[recordIndex]->getDouble("DPHI");
- 
-  recordIndex = elementMap["HallAir"];
-  double HallAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m; 
-  double HallAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;  
-  double HallAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
- 
-  recordIndex = elementMap["BaseAir"];
-  double BaseAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double BaseAirHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m; 
-  double BaseAirHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;  
-  double BaseAirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
- 
-  recordIndex = elementMap["BoxAirW"];
-  double BoxAirWZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double BoxAirWYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
-
-  recordIndex = elementMap["BoxAirVleft"];
-  double BoxAirVleftZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double BoxAirVleftYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
- 
-  recordIndex = elementMap["BoxAirVright"];
-  double BoxAirVrightZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m; 
-  double BoxAirVrightYrotate = (*cavernElements)[recordIndex]->getDouble("YROTATE");
-
-  GeoTubs *WallACAir         = new GeoTubs(WallACAirMinR, WallACAirMaxR, WallACAirHalfHeight, WallACAirSphi, WallACAirDphi);        
-  GeoBox  *BoxAir            = new GeoBox(BoxAirHalfLength, BoxAirHalfWidth, BoxAirHalfHeight);
-  GeoTubs *VaultAir          = new GeoTubs(VaultAirMinR, VaultAirMaxR, VaultAirHalfHeight, VaultAirSphi, VaultAirDphi);      
-  GeoBox  *HallAir           = new GeoBox(HallAirHalfLength, HallAirHalfWidth, HallAirHalfHeight);
-  GeoBox  *BaseAir           = new GeoBox(BaseAirHalfLength, BaseAirHalfWidth, BaseAirHalfHeight);
-  GeoTrf::Transform3D BoxCutWallAir      = GeoTrf::TranslateZ3D(BoxAirWZpos)*GeoTrf::RotateY3D(BoxAirWYrotate);
-  GeoTrf::Transform3D BoxCutVaultLeftAir = GeoTrf::TranslateZ3D(BoxAirVleftZpos)*GeoTrf::RotateY3D(BoxAirVleftYrotate);
-  GeoTrf::Transform3D BoxCutVaulRightAir = GeoTrf::TranslateZ3D(BoxAirVrightZpos)*GeoTrf::RotateY3D(BoxAirVrightYrotate);
-
-  //------------------Cut the vault and side walls----------------------------
-  const GeoShape & CutWallAir   = (*WallACAir).subtract((*BoxAir) << GeoTrf::Transform3D(BoxCutWallAir));
-  const GeoShape & CutVaultAir  = (*VaultAir).subtract((*BoxAir) << GeoTrf::Transform3D(BoxCutVaultLeftAir)).
-                                              subtract((*BoxAir) << GeoTrf::Transform3D(BoxCutVaulRightAir));
-
-  //--------------- Build air shafts------------------------------.
-  recordIndex = elementMap["PX14Air"];
-  double PX14AirXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m; 
-  double PX14AirYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*GeoModelKernelUnits::m;
-  double PX14AirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double PX14AirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double PX14AirMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
- 
-  recordIndex = elementMap["PX16Air"];
-  double PX16AirXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m; 
-  double PX16AirYpos = (*cavernElements)[recordIndex]->getDouble("YPOS")*GeoModelKernelUnits::m;
-  double PX16AirHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-  double PX16AirMinR = (*cavernElements)[recordIndex]->getDouble("MINR")*GeoModelKernelUnits::m;     
-  double PX16AirMaxR = (*cavernElements)[recordIndex]->getDouble("MAXR")*GeoModelKernelUnits::m;
-
-  GeoTube     *PX14Air   = new GeoTube(PX14AirMinR, PX14AirMaxR, PX14AirHalfHeight);  
-  GeoTube     *PX16Air   = new GeoTube(PX16AirMinR, PX16AirMaxR, PX16AirHalfHeight);
-
-  const GeoShape & ShaftsAir= 
-	  ((*PX14Air)     << GeoTrf::TranslateX3D(PX14AirXpos)*GeoTrf::TranslateY3D(PX14AirYpos)).
-	  add((*PX16Air)  << GeoTrf::TranslateX3D(PX16AirXpos)*GeoTrf::TranslateY3D(PX16AirYpos));
- 
-  //----------------Assemble everything--------------------------------.
-  recordIndex = elementMap["WallAAir"];
-  double WallAAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m;
-  double WallAAirXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m; 
- 
-  recordIndex = elementMap["WallCAir"];
-  double WallCAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m;
-  double WallCAirXpos = (*cavernElements)[recordIndex]->getDouble("XPOS")*GeoModelKernelUnits::m; 
-  double WallCAirZrotate = (*cavernElements)[recordIndex]->getDouble("ZROTATE");
-
-  const GeoShape & CavernAir = (*HallAir).
-	  add(CutWallAir     << GeoTrf::TranslateZ3D(WallAAirZpos)*GeoTrf::TranslateX3D(WallAAirXpos)).
-	  add(CutWallAir     << GeoTrf::TranslateZ3D(WallCAirZpos)*GeoTrf::TranslateX3D(WallCAirXpos)*GeoTrf::RotateZ3D(WallCAirZrotate)).
-	  add(CutVaultAir    << GeoTrf::TranslateZ3D(VaultAirZpos)*GeoTrf::RotateY3D(VaultAirYrotate)).
-	  add((*BaseAir)     << GeoTrf::TranslateZ3D(BaseAirZpos));
- 
-  recordIndex = elementMap["ShaftsAir"];
-  double ShaftsAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m;
- 
-  recordIndex = elementMap["CavernAir"];
-  double CavernAirZpos = (*cavernElements)[recordIndex]->getDouble("ZPOS")*GeoModelKernelUnits::m;
-
-  const GeoShape & AirHall=
-	  ((CavernAir     << GeoTrf::TranslateZ3D(CavernAirZpos))).
-          add((ShaftsAir  << GeoTrf::TranslateZ3D(ShaftsAirZpos)));     //allows for a built-in 2m thick plugs for both PX14 & PX16
-
-
- 
- //// -----------------------Build BedRock for Shafts and Cavern-------------------------------
- 
-  recordIndex = elementMap["Rock"];
-  double RockHalfLength = (*cavernElements)[recordIndex]->getDouble("HALFLENGTH")*GeoModelKernelUnits::m; 
-  double RockHalfWidth = (*cavernElements)[recordIndex]->getDouble("HALFWIDTH")*GeoModelKernelUnits::m;  
-  double RockHalfHeight = (*cavernElements)[recordIndex]->getDouble("HALFHEIGHT")*GeoModelKernelUnits::m;
-
-  
-  GeoBox     *Rockbox     = new GeoBox( RockHalfWidth, RockHalfHeight, RockHalfLength); // 300, 50.75, 300
-  const GeoShape & BedRock = ((*Rockbox) .
-			      subtract((AirHall) <<GeoTrf::TranslateY3D(-34.5*GeoModelKernelUnits::m)*GeoTrf::RotateY3D(-1.57)*GeoTrf::RotateX3D(-1.57)));
-
-  GeoTransform *rZt  = new GeoTransform(GeoTrf::TranslateY3D(34.5*GeoModelKernelUnits::m)*GeoTrf::TranslateX3D(-1.7*GeoModelKernelUnits::m));
-  world->add(rZt);
-  GeoLogVol  *lvr        = new GeoLogVol("BEDROCK",&BedRock,rock);
-  GeoPhysVol *bedrock    = new GeoPhysVol(lvr);
-  world->add(tag);
-  world->add(bedrock);
-
-
-  const GeoShape & CavConcrete = ((Concrete).subtract(AirHall));
-  
-  GeoTransform* xfTop = new GeoTransform(GeoTrf::TranslateY3D(-34.5*GeoModelKernelUnits::m)*GeoTrf::RotateY3D(-1.57)*GeoTrf::RotateX3D(-1.57)); 
-  bedrock->add(xfTop);
-  GeoLogVol  *lvcsc              = new GeoLogVol("CAV_SHAFTS_CONC",&CavConcrete,conc);
-  GeoPhysVol *CavShaftsConc      = new GeoPhysVol(lvcsc);
-  bedrock->add(CavShaftsConc);
-  
-
-  //// NOW INSERT ALL OF THIS INTO THE WORLD.
-  m_detectorManager->addTreeTop(sx1);
-  m_detectorManager->addTreeTop(bedrock);  
-
-  
-}
-
-const CavernInfraDetectorManager * CavernInfraDetectorFactory01::getDetectorManager() const
-{
-  return m_detectorManager;
-}
-
-void CavernInfraDetectorFactory01::setTagNode(const std::string& tag,
-                                              const std::string& node)
-{
-  m_versionTag = tag;
-  m_versionNode = node;
-}
-

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorFactory01.h

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

AtlasGeometryCommon/CavernInfraGeoModel/src/CavernInfraDetectorTool.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
 */
 
 #include "CavernInfraDetectorTool.h"
-#include "CavernInfraDetectorFactory.h" 
-#include "CavernInfraDetectorFactory01.h" 
-#include "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.rfind("CavernInfra",0) == 0) { //starts with "CavernInfra"
-    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();
@@ -82,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;
   }
 
@@ -102,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

@@ -9,6 +9,7 @@ find_package( GeoModel COMPONENTS GeoModelKernel GeoModelDBManager GeoModelRead)
 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/GeoModelEnvelopes/CMakeLists.txt

@@ -10,4 +10,5 @@ find_package( GeoModel COMPONENTS GeoModelKernel )
 atlas_add_component( GeoModelEnvelopes
                      src/*.cxx
                      src/components/*.cxx
+		     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);