Cleanup Run 4 InDetDD classes

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/BCMPrimeGeoModelXml/BCMPrimeDetectorFactory.h

-/*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef BCMPRIMEGEOMODELXML_BCMPRIMEDETECTORFACTORY_H 
-#define BCMPRIMEGEOMODELXML_BCMPRIMEDETECTORFACTORY_H 
-
-#include "InDetGeoModelUtils/InDetDetectorFactoryBase.h" 
-#include "BCMPrimeReadoutGeometry/BCMPrimeDetectorManager.h"
-
-namespace InDetDD {class AthenaComps;}
-class GeoPhysVol;
-
-namespace InDetDDSLHC {
-  class BCMPrimeOptions;
-
-  //
-  //    Main routine to build the GeoModel geometry, and handle the GeometryManager and 
-  //    DetectorManager.
-  // 
-  class BCMPrimeDetectorFactory : public InDetDD::DetectorFactoryBase {   
-  public: 
-
-    BCMPrimeDetectorFactory(InDetDD::AthenaComps *athenaComps, 
-                            BCMPrimeOptions &options);
-    virtual ~BCMPrimeDetectorFactory(); 
-
-    /** Creation of geometry */
-    virtual void create(GeoPhysVol *world);
-  
-    /** Access to the results */
-    virtual InDetDD::BCMPrimeDetectorManager * getDetectorManager() const;
-
-  private: 
-
-    // Copy and assignments operations illegal and so are made private
-    BCMPrimeDetectorFactory(BCMPrimeDetectorFactory &right); 
-    BCMPrimeDetectorFactory & operator=(BCMPrimeDetectorFactory &right); 
-
-    InDetDD::BCMPrimeDetectorManager *m_detectorManager;
-    InDetDD::AthenaComps *m_athenaComps;
-    BCMPrimeOptions *m_options;
-  }; 
-}  
-#endif 

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/BCMPrimeGeoModelXml/BCMPrimeGmxInterface.h

-/*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef BCMPRIMEGEOMODELXML_BCMPRIMEGMXINTERFACE_H
-#define BCMPRIMEGEOMODELXML_BCMPRIMEGMXINTERFACE_H
-
-#include "GeoModelXml/GmxInterface.h"
-
-#include <map>
-#include <memory>
-#include <sstream>
-#include <string>
-
-class MsgStream;
-namespace InDetDD {class BCMPrimeDetectorManager;}
-
-namespace ITk {
-
-  class BCMPrimeGmxInterface: public GmxInterface {
-  public:
-    BCMPrimeGmxInterface(InDetDD::BCMPrimeDetectorManager *detectorManager);
-    ~BCMPrimeGmxInterface();
-    virtual int sensorId(std::map<std::string, int> &index) const override final;
-    virtual void addAlignable(int /*level*/, std::map<std::string, int> &index,
-                              GeoVFullPhysVol *fpv, GeoAlignableTransform *transform) override final;
-
-  private:
-    InDetDD::BCMPrimeDetectorManager *m_detectorManager;
-    std::unique_ptr<MsgStream> m_log;
-  };
-
-} // namespace ITk
-
-#endif // BCMPRIMEGEOMODELXML_BCMPRIMEGMXINTERFACE_H

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/CMakeLists.txt

@@ -7,16 +7,12 @@ atlas_subdir( BCMPrimeGeoModelXml )
 find_package( GeoModel COMPONENTS GeoModelKernel )
 
 # Component(s) in the package:
-atlas_add_library( BCMPrimeGeoModelXmlLib
-                   src/*.cxx
-                   PUBLIC_HEADERS BCMPrimeGeoModelXml
-                   PRIVATE_INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS}
-                   LINK_LIBRARIES GaudiKernel GeoModelUtilities GeoModelXml InDetGeoModelUtils BCMPrimeReadoutGeometry
-                   PRIVATE_LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaPoolUtilities DetDescrConditions GeoModelInterfaces InDetSimEvent PathResolver RDBAccessSvcLib SGTools StoreGateLib )
-
 atlas_add_component( BCMPrimeGeoModelXml
+                     src/*.cxx
                      src/components/*.cxx
-                     LINK_LIBRARIES BCMPrimeGeoModelXmlLib )
+                     PRIVATE_INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS}
+                     LINK_LIBRARIES GaudiKernel GeoModelUtilities GeoModelXml InDetGeoModelUtils BCMPrimeReadoutGeometry
+                     PRIVATE_LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaPoolUtilities DetDescrConditions GeoModelInterfaces InDetSimEvent PathResolver RDBAccessSvcLib SGTools StoreGateLib )
                      
 # Install files from the package:
 atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} )

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/src/BCMPrimeDetectorFactory.cxx

@@ -2,101 +2,75 @@
   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
-#include "BCMPrimeGeoModelXml/BCMPrimeDetectorFactory.h"
-#include "BCMPrimeReadoutGeometry/BCMPrimeDetectorManager.h"
-
-#include <string>
-#include <sstream>
-
-#include "StoreGate/StoreGateSvc.h" // For alignment getAlignableFolderType()
-#include "AthenaPoolUtilities/CondAttrListCollection.h"
-#include "DetDescrConditions/AlignableTransformContainer.h"
-
-#include "InDetGeoModelUtils/InDetDDAthenaComps.h"
-#include "GeoModelKernel/GeoPhysVol.h"
-#include "GeoModelInterfaces/IGeoModelSvc.h"
-
-#include "RDBAccessSvc/IRDBAccessSvc.h"
-#include "RDBAccessSvc/IRDBRecordset.h"
-#include "RDBAccessSvc/IRDBRecord.h"
-
-#include "BCMPrimeGeoModelXml/BCMPrimeOptions.h"
-#include "GeoModelXml/Gmx2Geo.h"
-#include "BCMPrimeGeoModelXml/BCMPrimeGmxInterface.h"
-#include "GeoModelXml/GmxInterface.h"
-
-#include "PathResolver/PathResolver.h"
-
-using namespace std;
-
-namespace InDetDDSLHC {
-
-  BCMPrimeDetectorFactory::BCMPrimeDetectorFactory(InDetDD::AthenaComps *athenaComps,
-                                                   BCMPrimeOptions &options) :
-    InDetDD::DetectorFactoryBase(athenaComps),
-    m_athenaComps(athenaComps),
-    m_options(&options) 
-  {
-  
-    // Create the detector manager
-    m_detectorManager = new InDetDD::BCMPrimeDetectorManager(detStore(),m_options->detectorName());
-  }
+#include "BCMPrimeOptions.h"
+#include "BCMPrimeGmxInterface.h"
+#include "BCMPrimeDetectorFactory.h"
+
+#include <BCMPrimeReadoutGeometry/BCMPrimeDetectorManager.h>
+#include <GeoModelKernel/GeoPhysVol.h>
+#include <GeoModelXml/Gmx2Geo.h>
+#include <PathResolver/PathResolver.h>
+
+
+namespace InDetDD
+{
+
+BCMPrimeDetectorFactory::BCMPrimeDetectorFactory(AthenaComps *athenaComps,
+                                                 const BCMPrimeOptions &options)
+ : DetectorFactoryBase(athenaComps),
+   m_options(options)
+{
+  // Create the detector manager
+  m_detectorManager = new InDetDD::BCMPrimeDetectorManager(detStore(), m_options.detectorName());
+}
 
-  BCMPrimeDetectorFactory::~BCMPrimeDetectorFactory() {
-    // NB the detector manager (m_detectorManager) is stored in the detector store by the Tool and so we don't delete it.
+void BCMPrimeDetectorFactory::create(GeoPhysVol *world)
+{
+  ATH_MSG_INFO( "C R E A T E   W O R L D" );
+
+  BCMPrimeGmxInterface gmxInterface(m_detectorManager);
+  // To set up solid geometry only, without having to worry about sensitive detectors etc., and get loads of debug output,
+  // comment out above line and uncomment the following line; also, switch header files above.
+  // GmxInterface gmxInterface;
+
+  int flags{};
+  std::string gmxInput;
+
+  if (m_options.gmxFilename().empty()) {
+    ATH_MSG_ERROR( "gmxFilename not set; getting .gmx from Geometry database Blob not supported");
+    // gmxInput = getBlob();
+  } else {
+    flags = 0;
+    gmxInput = PathResolver::find_file(m_options.gmxFilename(), "DATAPATH");
+    if (gmxInput.empty()) { // File not found
+      std::string errMessage("BCMPrimeDetectorFactory::create: Unable to find file " + m_options.gmxFilename() +
+                             " with PathResolver; check filename and DATAPATH environment variable");
+      throw std::runtime_error(errMessage);
+    }
   }
 
-  void BCMPrimeDetectorFactory::create(GeoPhysVol *world) {
-    ATH_MSG_INFO( "C R E A T E   W O R L D" );
-   
-    ITk::BCMPrimeGmxInterface gmxInterface(m_detectorManager);
-    //    To set up solid geometry only, without having to worry about sensitive detectors etc., and get loads of debug output,
-    //    comment out above line and uncomment the following line; also, switch header files above.
-    //    GmxInterface gmxInterface;
-    
-    int flags(0);
-    string gmxInput;
-    
-    if (m_options->gmxFilename().empty()) {
-      ATH_MSG_ERROR( "gmxFilename not set; getting .gmx from Geometry database Blob not supported");
-      // gmxInput = getBlob();
-    }
-    else {
-      flags = 0;
-      gmxInput = PathResolver::find_file(m_options->gmxFilename(), "DATAPATH");
-      if (gmxInput.empty()) { // File not found
-        string errMessage("BCMPrimeDetectorFactory::create: Unable to find file " + m_options->gmxFilename() +
-                            " with PathResolver; check filename and DATAPATH environment variable");
-        throw runtime_error(errMessage);
-      }
-    }
-    
-    Gmx2Geo gmx2Geo(gmxInput, world, gmxInterface, flags);
+  Gmx2Geo gmx2Geo(gmxInput, world, gmxInterface, flags);
 
-    //
-    //   Add the tree-top to the detector manager.
-    //
-    unsigned int nChildren = world->getNChildVols();
-    bool foundVolume = false;
+  // Add the tree-top to the detector manager.
+  unsigned int nChildren = world->getNChildVols();
+  bool foundVolume = false;
 
-    for (int iChild = nChildren - 1; iChild>=0; --iChild) {
-      if (world->getNameOfChildVol(iChild) == "BCMPrime") {
-        // The * converts from a ConstPVLink to a reference to a GeoVPhysVol;
-        // the & takes its address.
-        foundVolume  = true;
-        m_detectorManager->addTreeTop(&*world->getChildVol(iChild));
-        break;
-      }
+  for (int iChild = nChildren - 1; iChild>=0; --iChild) {
+    if (world->getNameOfChildVol(iChild) == "BCMPrime") {
+      // The * converts from a ConstPVLink to a reference to a GeoVPhysVol;
+      // the & takes its address.
+      foundVolume = true;
+      m_detectorManager->addTreeTop(&*world->getChildVol(iChild));
+      break;
     }
-    
-    if(!foundVolume) ATH_MSG_ERROR("Could not find a logicalVolume named \"BCMPrime\" - this is required to provide the Envelope!");
-
-  }
-  
-  InDetDD::BCMPrimeDetectorManager * BCMPrimeDetectorFactory::getDetectorManager() const {
-    return m_detectorManager;
   }
 
+  if (!foundVolume) ATH_MSG_ERROR("Could not find a logicalVolume named \"BCMPrime\" - this is required to provide the Envelope!");
+}
 
+BCMPrimeDetectorManager * BCMPrimeDetectorFactory::getDetectorManager() const
+{
+  return m_detectorManager;
 }
 
+} // namespace InDetDD

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/src/BCMPrimeDetectorFactory.h

+/*
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef BCMPRIMEGEOMODELXML_BCMPRIMEDETECTORFACTORY_H
+#define BCMPRIMEGEOMODELXML_BCMPRIMEDETECTORFACTORY_H
+
+#include <BCMPrimeReadoutGeometry/BCMPrimeDetectorManager.h>
+#include <InDetGeoModelUtils/InDetDDAthenaComps.h>
+#include <InDetGeoModelUtils/InDetDetectorFactoryBase.h>
+
+
+namespace InDetDD
+{
+
+class BCMPrimeOptions;
+
+//
+//    Main routine to build the GeoModel geometry, and handle the GeometryManager and
+//    DetectorManager.
+//
+class BCMPrimeDetectorFactory : public DetectorFactoryBase
+{
+public:
+
+  BCMPrimeDetectorFactory(AthenaComps *athenaComps,
+                          const BCMPrimeOptions &options);
+
+  /** Creation of geometry */
+  virtual void create(GeoPhysVol *world) override final;
+
+  /** Access to the results */
+  virtual BCMPrimeDetectorManager * getDetectorManager() const override final;
+
+private:
+
+  // Copy and assignments operations illegal and so are made private
+  BCMPrimeDetectorFactory(BCMPrimeDetectorFactory &right);
+  BCMPrimeDetectorFactory & operator=(BCMPrimeDetectorFactory &right);
+
+  BCMPrimeDetectorManager *m_detectorManager{};
+  const BCMPrimeOptions &m_options;
+};
+
+} // namespace InDetDD
+
+#endif

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/src/BCMPrimeDetectorTool.cxx

@@ -2,157 +2,128 @@
   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
-#include "BCMPrimeGeoModelXml/BCMPrimeDetectorTool.h"
-#include "BCMPrimeGeoModelXml/BCMPrimeDetectorFactory.h"
-#include "BCMPrimeGeoModelXml/BCMPrimeOptions.h"
-#include "InDetGeoModelUtils/InDetDDAthenaComps.h"
-#include "GeoModelUtilities/GeoModelExperiment.h"
-#include "GeoModelInterfaces/IGeoModelSvc.h"
-#include "StoreGate/StoreGateSvc.h"
-#include "RDBAccessSvc/IRDBAccessSvc.h"
-#include "RDBAccessSvc/IRDBRecord.h"
-#include "RDBAccessSvc/IRDBRecordset.h"
-#include "DetDescrConditions/AlignableTransformContainer.h"
-#include "SGTools/DataProxy.h"
+#include "BCMPrimeDetectorFactory.h"
+#include "BCMPrimeDetectorTool.h"
+#include "BCMPrimeOptions.h"
+
+#include <DetDescrConditions/AlignableTransformContainer.h>
+#include <GeoModelUtilities/GeoModelExperiment.h>
+#include <SGTools/DataProxy.h>
+#include <StoreGate/StoreGateSvc.h>
+
 
 BCMPrimeDetectorTool::BCMPrimeDetectorTool(const std::string &type,
                                            const std::string &name,
-                                           const IInterface *parent) :
-    GeoModelTool(type, name, parent),
-    m_detectorName("BCMPrime"),
-    m_alignable(false),
-    m_gmxFilename(""),
-    m_manager(nullptr),
-    m_athenaComps(nullptr),
-    m_rdbAccessSvc("RDBAccessSvc", name),
-    m_geoDbTagSvc{"GeoDbTagSvc", name}
-
-    {
-
-    //
-    // Get parameter values from jobOptions file
-    //
-    declareProperty("DetectorName", m_detectorName);
-    declareProperty("Alignable", m_alignable);
-    declareProperty("GmxFilename", m_gmxFilename);
-    declareProperty("RDBAccessSvc", m_rdbAccessSvc);
-    declareProperty("GeoDbTagSvc", m_geoDbTagSvc);
-
+                                           const IInterface *parent)
+  : GeoModelTool(type, name, parent)
+{
 }
 
-BCMPrimeDetectorTool::~BCMPrimeDetectorTool() {
-    delete m_athenaComps;
-}
 
-StatusCode BCMPrimeDetectorTool::create() {
-
-    //
-    //   Retrieve all services
-    //
-    // Get the detector configuration.
-    ATH_CHECK(m_geoDbTagSvc.retrieve());
-    ATH_CHECK(m_rdbAccessSvc.retrieve());
-    GeoModelExperiment *theExpt;
-    ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
-
-    //
-    //    Get their interfaces to pass to the DetectorFactory
-    //
-    m_athenaComps = new InDetDD::AthenaComps("BCMPrimeGeoModelXml");
-    m_athenaComps->setDetStore(&*(detStore()));
-    m_athenaComps->setRDBAccessSvc(&*m_rdbAccessSvc);
-    m_athenaComps->setGeoDbTagSvc(&*m_geoDbTagSvc);
-
-    //
-    //    Get options from python
-    //
-    InDetDDSLHC::BCMPrimeOptions options;
-    options.setAlignable(m_alignable);
-    options.setGmxFilename(m_gmxFilename);
-    options.setDetectorName(m_detectorName);
-
-    //
-    // Create the BCMPrimeDetectorFactory
-    //
-    // The * converts a ConstPVLink to a ref to a GeoVPhysVol
-    // The & takes the address of the GeoVPhysVol
-    GeoPhysVol *world = &*theExpt->getPhysVol();
-    InDetDDSLHC::BCMPrimeDetectorFactory bcmPrime(m_athenaComps, options);
-    bcmPrime.create(world);
-
-    //
-    // Get the manager from the factory and store it in the detector store.
-    //
-    m_manager = bcmPrime.getDetectorManager();
-
-    if (!m_manager) {
-        ATH_MSG_ERROR( "PixelDetectorManager not found; not created in BCMPrimeDetectorFactory?" );
-        return(StatusCode::FAILURE);
-    }
+StatusCode BCMPrimeDetectorTool::create()
+{
+  //
+  //   Retrieve all services
+  //
+  // Get the detector configuration.
+  ATH_CHECK(m_geoDbTagSvc.retrieve());
+  ATH_CHECK(m_rdbAccessSvc.retrieve());
+  GeoModelExperiment *theExpt;
+  ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
+
+  //
+  //  Get their interfaces to pass to the DetectorFactory
+  //
+  auto athenaComps = std::make_unique<InDetDD::AthenaComps>("BCMPrimeGeoModelXml");
+  athenaComps->setDetStore(&*(detStore()));
+  athenaComps->setRDBAccessSvc(&*m_rdbAccessSvc);
+  athenaComps->setGeoDbTagSvc(&*m_geoDbTagSvc);
+
+  //
+  //  Get options from python
+  //
+  InDetDD::BCMPrimeOptions options;
+  options.setAlignable(m_alignable);
+  options.setGmxFilename(m_gmxFilename);
+  options.setDetectorName(m_detectorName);
+
+  //
+  // Create the BCMPrimeDetectorFactory
+  //
+  // The * converts a ConstPVLink to a ref to a GeoVPhysVol
+  // The & takes the address of the GeoVPhysVol
+  GeoPhysVol *world = &*theExpt->getPhysVol();
+  InDetDD::BCMPrimeDetectorFactory bcmPrime(athenaComps.get(), options);
+  bcmPrime.create(world);
+
+  //
+  // Get the manager from the factory and store it in the detector store.
+  //
+  m_manager = bcmPrime.getDetectorManager();
+
+  if (!m_manager) {
+    ATH_MSG_ERROR( "PixelDetectorManager not found; not created in BCMPrimeDetectorFactory?" );
+    return StatusCode::FAILURE;
+  }
+
+  ATH_CHECK(detStore()->record(m_manager, m_manager->getName()));
+  theExpt->addManager(m_manager);
+
+  return StatusCode::SUCCESS;
+}
 
-    StatusCode sc;
-    sc = detStore()->record(m_manager, m_manager->getName());
-    if (sc.isFailure() ) {
-        ATH_MSG_ERROR( "Could not register BCMPrimeDetectorManager" );
-        return StatusCode::FAILURE;
-    }
-    theExpt->addManager(m_manager);
 
-    return StatusCode::SUCCESS;
+StatusCode BCMPrimeDetectorTool::clear()
+{
+  SG::DataProxy* proxy = detStore()->proxy(ClassID_traits<InDetDD::BCMPrimeDetectorManager>::ID(),m_manager->getName());
+  if (proxy) {
+    proxy->reset();
+    m_manager = nullptr;
+  }
+  return StatusCode::SUCCESS;
 }
 
-StatusCode BCMPrimeDetectorTool::clear() {
-    SG::DataProxy* proxy = detStore()->proxy(ClassID_traits<InDetDD::BCMPrimeDetectorManager>::ID(),m_manager->getName());
-    if(proxy) {
-        proxy->reset();
-        m_manager = nullptr;
-    }
-    return StatusCode::SUCCESS;
-}
 
-StatusCode BCMPrimeDetectorTool::registerCallback() {
-
-    // 
-    //    Register call-back for software alignment
-    //
-    StatusCode sc = StatusCode::FAILURE;
-    if (m_alignable) {
-        std::string folderName = "/ITk/Align";
-        if (detStore()->contains<AlignableTransformContainer>(folderName)) {
-            ATH_MSG_DEBUG( "Registering callback on AlignableTransformContainer with folder " << folderName );
-            const DataHandle<AlignableTransformContainer> atc;
-            sc =  detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool *>(this), atc, folderName);
-            if(sc.isFailure()) {
-                ATH_MSG_ERROR( "Could not register callback on AlignableTransformContainer with folder " << 
-                                    folderName );
-            } 
-        } 
-        else {
-            ATH_MSG_WARNING( "Unable to register callback on AlignableTransformContainer with folder " <<
-                                 folderName << ", Alignment disabled (only if no Run2 scheme is loaded)!" );
-        }
-    } 
-    else {
-        ATH_MSG_INFO( "Alignment disabled. No callback registered" );
-        // We return failure otherwise it will try and register a GeoModelSvc callback associated with this callback.
+StatusCode BCMPrimeDetectorTool::registerCallback()
+{
+  //
+  //  Register call-back for software alignment
+  //
+  if (m_alignable) {
+    std::string folderName = "/ITk/Align";
+    if (detStore()->contains<AlignableTransformContainer>(folderName)) {
+      ATH_MSG_DEBUG( "Registering callback on AlignableTransformContainer with folder " << folderName );
+      const DataHandle<AlignableTransformContainer> atc;
+      StatusCode sc = detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool *>(this), atc, folderName);
+      if (sc.isFailure()) {
+        ATH_MSG_ERROR( "Could not register callback on AlignableTransformContainer with folder " <<
+                  folderName );
+      }
+      return StatusCode::FAILURE;
+    } else {
+      ATH_MSG_WARNING( "Unable to register callback on AlignableTransformContainer with folder " <<
+                 folderName << ", Alignment disabled (only if no Run2 scheme is loaded)!" );
     }
-    return sc;
+  } else {
+    ATH_MSG_INFO( "Alignment disabled. No callback registered" );
+    // We return failure otherwise it will try and register a GeoModelSvc callback associated with this callback.
+  }
+  return StatusCode::SUCCESS;
 }
 
-StatusCode BCMPrimeDetectorTool::align(IOVSVC_CALLBACK_ARGS_P(I, keys)) {
-
-    //
-    //    The call-back routine, which just calls the real call-back routine from the manager.
-    //
-    if (!m_manager) {
-        ATH_MSG_WARNING( "Manager does not exist" );
-        return StatusCode::FAILURE;
-    }
-    if (m_alignable) {
-        return m_manager->align(I, keys);
-    } 
-    else {
-        ATH_MSG_DEBUG( "Alignment disabled. No alignments applied" );
-        return StatusCode::SUCCESS;
-    }
+StatusCode BCMPrimeDetectorTool::align(IOVSVC_CALLBACK_ARGS_P(I, keys))
+{
+  //
+  //  The call-back routine, which just calls the real call-back routine from the manager.
+  //
+  if (!m_manager) {
+    ATH_MSG_WARNING( "Manager does not exist" );
+    return StatusCode::FAILURE;
+  }
+  if (m_alignable) {
+    return m_manager->align(I, keys);
+  } else {
+    ATH_MSG_DEBUG( "Alignment disabled. No alignments applied" );
+    return StatusCode::SUCCESS;
+  }
 }

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/BCMPrimeGeoModelXml/BCMPrimeDetectorTool.h → InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/src/BCMPrimeDetectorTool.h

@@ -5,48 +5,45 @@
 #ifndef BCMPRIMEGEOMODELXML_BCMPRIMEDETECTORTOOL_H
 #define BCMPRIMEGEOMODELXML_BCMPRIMEDETECTORTOOL_H
 
-#include "GeoModelUtilities/GeoModelTool.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "GaudiKernel/ToolHandle.h"
+#include <GaudiKernel/ServiceHandle.h>
+#include <GeoModelInterfaces/IGeoDbTagSvc.h>
+#include <GeoModelUtilities/GeoModelTool.h>
+#include <RDBAccessSvc/IRDBAccessSvc.h>
 
-#include <string>
-
-class IGeoModelSvc;
 class IRDBAccessSvc;
 class IGeoDbTagSvc;
-class IGeometryDBSvc;
 
-namespace InDetDD {
-  class AthenaComps;
+namespace InDetDD
+{
   class BCMPrimeDetectorManager;
 }
 
 /** @class BCMPrimeDetectorTool
 
-    Create an Athena Tool; handle Athena services and Tools needed for
-    building the BCM' geometry. Then create the geometry using the BCMPrimeDetectorFactory.
-
-    @author  Jakob Novak <jakob.novak@cern.ch>
+  Create an Athena Tool; handle Athena services and Tools needed for
+  building the BCM' geometry. Then create the geometry using the BCMPrimeDetectorFactory.
 
-    */
+  @author  Jakob Novak <jakob.novak@cern.ch>
+*/
 
-class BCMPrimeDetectorTool : public GeoModelTool {
- public: 
+class BCMPrimeDetectorTool : public GeoModelTool
+{
+public:
   BCMPrimeDetectorTool(const std::string &type, const std::string &name, const IInterface *parent);
-  virtual ~BCMPrimeDetectorTool();
-  StatusCode create() override final;
-  StatusCode clear() override final;
-  StatusCode registerCallback() override final;
-  virtual StatusCode align(IOVSVC_CALLBACK_ARGS_P(I,keys)) override;
-  
- private:
-  std::string m_detectorName;
-  bool m_alignable;
-  std::string m_gmxFilename;
-  const InDetDD::BCMPrimeDetectorManager *m_manager;
-  InDetDD::AthenaComps *m_athenaComps;
-  ServiceHandle<IRDBAccessSvc> m_rdbAccessSvc;
-  ServiceHandle< IGeoDbTagSvc > m_geoDbTagSvc;
+  virtual ~BCMPrimeDetectorTool() = default;
+  virtual StatusCode create() override final;
+  virtual StatusCode clear() override final;
+  virtual StatusCode registerCallback() override final;
+  virtual StatusCode align(IOVSVC_CALLBACK_ARGS_P(I,keys)) override final;
+
+private:
+  const InDetDD::BCMPrimeDetectorManager *m_manager{};
+
+  Gaudi::Property<std::string> m_detectorName{this, "DetectorName", "BCMPrime", ""};
+  Gaudi::Property<bool> m_alignable{this, "Alignable", false, ""};
+  Gaudi::Property<std::string> m_gmxFilename{this, "GmxFilename", "", ""};
+  ServiceHandle<IRDBAccessSvc> m_rdbAccessSvc{this, "RDBAccessSvc", "RDBAccessSvc", ""};
+  ServiceHandle<IGeoDbTagSvc> m_geoDbTagSvc{this, "GeoDbTagSvc", "GeoDbTagSvc", ""};
 };
 
 #endif // BCMPRIMEGEOMODELXML_BCMPRIMEDETECTORTOOL_H

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/src/BCMPrimeGmxInterface.cxx

@@ -2,61 +2,41 @@
   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
-#include "BCMPrimeGeoModelXml/BCMPrimeGmxInterface.h"
+#include "BCMPrimeGmxInterface.h"
 
-#include <cstdlib>
-#include <sstream>
+#include <BCMPrimeReadoutGeometry/BCMPrimeDetectorManager.h>
+#include <InDetSimEvent/SiHitIdHelper.h>
 
-#include "InDetSimEvent/SiHitIdHelper.h" 
+namespace InDetDD
+{
 
-#include "GaudiKernel/ServiceHandle.h"
-#include "GaudiKernel/IMessageSvc.h" 
-#include "GaudiKernel/MsgStream.h"
+BCMPrimeGmxInterface::BCMPrimeGmxInterface(InDetDD::BCMPrimeDetectorManager *detectorManager)
+  : AthMessaging(Athena::getMessageSvc(), "BCMPrimeGmxInterface"),
+    m_detectorManager(detectorManager)
+{}
 
-#include "BCMPrimeReadoutGeometry/BCMPrimeDetectorManager.h"
+int BCMPrimeGmxInterface::sensorId(std::map<std::string, int> &index) const
+{
+  // Return the Simulation HitID (nothing to do with "ATLAS Identifiers" aka "Offline Identifiers")
+  int hitIdOfModule = SiHitIdHelper::GetHelper()->buildHitId(0, 0, index["diamond_number"],
+                index["module_number"], 0, 0);
 
-using namespace std;
+  ATH_MSG_DEBUG("Index list: " << index["diamond_number"] << " " << index["module_number"]);
+  ATH_MSG_DEBUG("hitIdOfModule = " << std::hex << hitIdOfModule << std::dec);
+  ATH_MSG_DEBUG(" dia = " << SiHitIdHelper::GetHelper()->getLayerDisk(hitIdOfModule) <<
+                " mod = " << SiHitIdHelper::GetHelper()->getEtaModule(hitIdOfModule));
+  return hitIdOfModule;
+}
 
-namespace ITk {
+void BCMPrimeGmxInterface::addAlignable(int /*level*/, std::map<std::string, int> &index,
+                                        GeoVFullPhysVol *fpv, GeoAlignableTransform *transform)
+{
+  ATH_MSG_DEBUG("alignable transform added for indices: " << index["diamond_number"] << " " << index["module_number"]);
 
-  BCMPrimeGmxInterface::BCMPrimeGmxInterface(InDetDD::BCMPrimeDetectorManager *detectorManager):
-    m_detectorManager(detectorManager)
-  {
-    // Logging: ref https://wiki.bnl.gov/dayabay/index.php?title=Logging
-    // Turn on logging in job-options with: MessageSvc.setDebug += {"BCMPrimeGmxInterface"}
-    ServiceHandle<IMessageSvc> msgh("MessageSvc", "BCMPrimeGmxInterface");
-    
-    m_log = std::make_unique<MsgStream>(&(*msgh), "BCMPrimeGmxInterface");
-
-  }
-
-  BCMPrimeGmxInterface::~BCMPrimeGmxInterface() {
-  }
-
-  int BCMPrimeGmxInterface::sensorId(map<string, int> &index) const {
-    //
-    //    Return the Simulation HitID (nothing to do with "ATLAS Identifiers" aka "Offline Identifiers")
-    //
-    
-    int hitIdOfModule = SiHitIdHelper::GetHelper()->buildHitId(0, 0, index["diamond_number"], 
-                  index["module_number"], 0, 0);
-
-    *m_log << MSG::DEBUG  << "Index list: " << index["diamond_number"] << " " << index["module_number"] << endmsg;
-    *m_log << MSG::DEBUG << "hitIdOfModule = " << std::hex << hitIdOfModule << std::dec << endmsg;
-    *m_log << MSG::DEBUG << " dia = " << SiHitIdHelper::GetHelper()->getLayerDisk(hitIdOfModule) <<
-                            " mod = " << SiHitIdHelper::GetHelper()->getEtaModule(hitIdOfModule) << endmsg;
-    return hitIdOfModule;
-  }
-
-  void BCMPrimeGmxInterface::addAlignable(int /*level*/, std::map<std::string, int> &index,
-                                          GeoVFullPhysVol *fpv, GeoAlignableTransform *transform)
-  {
-    *m_log << MSG::DEBUG  << "alignable transform added for indices: " << index["diamond_number"] << " " << index["module_number"] << endmsg;
-
-    // A preliminary id scheme
-    int id = index["diamond_number"] + 8*index["module_number"];
-
-    m_detectorManager->addAlignableTransform(id, transform, fpv);
-  }
-
-} // namespace ITk
+  // A preliminary id scheme
+  int id = index["diamond_number"] + 8*index["module_number"];
+
+  m_detectorManager->addAlignableTransform(id, transform, fpv);
+}
+
+} // namespace InDetDD

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/src/BCMPrimeGmxInterface.h

+/*
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef BCMPRIMEGEOMODELXML_BCMPRIMEGMXINTERFACE_H
+#define BCMPRIMEGEOMODELXML_BCMPRIMEGMXINTERFACE_H
+
+#include <AthenaBaseComps/AthMessaging.h>
+#include <GeoModelXml/GmxInterface.h>
+
+#include <map>
+
+namespace InDetDD
+{
+
+class BCMPrimeDetectorManager;
+
+class BCMPrimeGmxInterface: public GmxInterface, public AthMessaging
+{
+public:
+  BCMPrimeGmxInterface(InDetDD::BCMPrimeDetectorManager *detectorManager);
+
+  virtual int sensorId(std::map<std::string, int> &index) const override final;
+  virtual void addAlignable(int /*level*/, std::map<std::string, int> &index,
+                            GeoVFullPhysVol *fpv, GeoAlignableTransform *transform) override final;
+
+private:
+  InDetDD::BCMPrimeDetectorManager *m_detectorManager{};
+};
+
+} // namespace InDetDD
+
+#endif // BCMPRIMEGEOMODELXML_BCMPRIMEGMXINTERFACE_H

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/BCMPrimeGeoModelXml/BCMPrimeOptions.h → InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/src/BCMPrimeOptions.h

@@ -6,7 +6,8 @@
 #define BCMPRIMEGEOMODELXML_BCMPRIMEOPTIONS_H
 #include <string>
 
-namespace InDetDDSLHC {
+namespace InDetDD
+{
 
   //
   //    Class to store run time options.
@@ -20,7 +21,7 @@ namespace InDetDDSLHC {
     std::string detectorName() const;
     void setAlignable(bool flag = true);
     void setAlignAtModuleLevel(bool flag = true);
-    void setGmxFilename(std::string filename); 
+    void setGmxFilename(std::string filename);
     void setDetectorName(std::string detectorname);
 
   private:
@@ -35,7 +36,7 @@ namespace InDetDDSLHC {
   //
   inline BCMPrimeOptions::BCMPrimeOptions() :
     m_alignable(true),
-    m_alignModule(true), 
+    m_alignModule(true),
     m_gmxFilename(""),
     m_detectorName("BCMPrime")
       {}
@@ -72,5 +73,6 @@ namespace InDetDDSLHC {
     m_detectorName = detectorname;
   }
 
-}
+} // namespace InDetDD
+
 #endif // BCMPRIMEGEOMODELXML_BCMPRIMEOPTIONS_H

InnerDetector/InDetDetDescr/BCMPrimeGeoModelXml/src/components/BCMPrimeGeoModelXml_entries.cxx

-#include "BCMPrimeGeoModelXml/BCMPrimeDetectorTool.h"
+#include "src/BCMPrimeDetectorTool.h"
 
 DECLARE_COMPONENT( BCMPrimeDetectorTool )

InnerDetector/InDetDetDescr/PLRGeoModelXml/CMakeLists.txt

@@ -7,17 +7,12 @@ atlas_subdir( PLRGeoModelXml )
 find_package( GeoModel COMPONENTS GeoModelKernel )
 
 # Component(s) in the package:
-atlas_add_library( PLRGeoModelXmlLib
-                   src/*.cxx
-                   PUBLIC_HEADERS PLRGeoModelXml
-                   PRIVATE_INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS}
-                   LINK_LIBRARIES GaudiKernel GeoModelUtilities GeoModelXml InDetGeoModelUtils PixelReadoutGeometryLib PixelGeoModelXmlLib
-                   PRIVATE_LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaBaseComps AthenaPoolUtilities DetDescrConditions GeoModelInterfaces ReadoutGeometryBase InDetReadoutGeometry InDetSimEvent PathResolver RDBAccessSvcLib SGTools StoreGateLib )
-
 atlas_add_component( PLRGeoModelXml
+                     src/*.cxx
                      src/components/*.cxx
-                     LINK_LIBRARIES PLRGeoModelXmlLib )
+                     PRIVATE_INCLUDE_DIRS ${GEOMODEL_INCLUDE_DIRS}
+                     LINK_LIBRARIES GaudiKernel GeoModelUtilities GeoModelXml InDetGeoModelUtils PixelReadoutGeometryLib PixelGeoModelXmlLib
+                     PRIVATE_LINK_LIBRARIES ${GEOMODEL_LIBRARIES} AthenaBaseComps AthenaPoolUtilities DetDescrConditions GeoModelInterfaces ReadoutGeometryBase InDetReadoutGeometry InDetSimEvent PathResolver RDBAccessSvcLib SGTools StoreGateLib )
 
 # Install files from the package:
 atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} )
-

InnerDetector/InDetDetDescr/PLRGeoModelXml/PLRGeoModelXml/PLRDetectorFactory.h

-/*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef PLRGeoModelXml_PLRDETECTORFACTORY_H
-#define PLRGeoModelXml_PLRDETECTORFACTORY_H
-//
-//    Main routine to build the GeoModel geometry, and handle the GeometryManager and
-//    DetectorManager.
-// 
-#include "InDetGeoModelUtils/InDetDetectorFactoryBase.h"
-#include "PixelReadoutGeometry/PixelDetectorManager.h"
-#include "InDetGeoModelUtils/WaferTree.h"
-
-namespace InDetDD {class AthenaComps; class SiCommonItems;}
-class GeoPhysVol;
-
-namespace InDetDDSLHC {
-  class PLROptions;
-
-  class PLRDetectorFactory : public InDetDD::DetectorFactoryBase {
-  public:
-    PLRDetectorFactory(InDetDD::AthenaComps *athenaComps,
-			 InDetDD::SiCommonItems *commonItems,
-			 PLROptions &options);
-    virtual ~PLRDetectorFactory();
-    // Creation of geometry:
-    virtual void create(GeoPhysVol *world);
-    // Access to the results:
-    virtual InDetDD::PixelDetectorManager * getDetectorManager() const;
-    // Print out how many of each layer/eta/phi etc. have been set up.
-    void doNumerology();
-
-  private:
-    // Copy and assignments operations illegal and so are made private
-    PLRDetectorFactory(PLRDetectorFactory &right);
-    PLRDetectorFactory & operator=(PLRDetectorFactory &right);
-
-    InDetDD::PixelDetectorManager *m_detectorManager;
-    InDetDD::AthenaComps *m_athenaComps;
-    InDetDD::SiCommonItems *m_commonItems;
-    PLROptions *m_options;
-    WaferTree m_moduleTree;
-  };
-}
-#endif

InnerDetector/InDetDetDescr/PLRGeoModelXml/PLRGeoModelXml/PLRDetectorTool.h

-/*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef PLRGeoModelXml_PLRDETECTORTOOL_H
-#define PLRGeoModelXml_PLRDETECTORTOOL_H
-//
-//    Create an Athena Tool; handle Athena services and Tools needed for
-//    building the Pixel geometry. Then create the geometry using the PixelDetectorFactory.
-//    This is the entry to the PixelGeoModelXml package.
-//
-#include "GeoModelUtilities/GeoModelTool.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "GaudiKernel/ToolHandle.h"
-
-#include <string>
-
-class IGeoModelSvc;
-class IRDBAccessSvc;
-class IGeoDbTagSvc;
-
-namespace InDetDD {
-  class PixelDetectorManager;
-  class AthenaComps;
-  class SiCommonItems;
-}
-
-class PLRDetectorTool : public GeoModelTool {
- public: 
-  PLRDetectorTool(const std::string &type, const std::string &name, const IInterface *parent);
-  virtual ~PLRDetectorTool();
-  StatusCode create() override final;
-  StatusCode clear() override final;
-  StatusCode registerCallback() override final;
-  virtual StatusCode align(IOVSVC_CALLBACK_ARGS_P(I,keys)) override;
-  
- private:
-  std::string m_detectorName;
-  bool m_alignable;
-  std::string m_gmxFilename;
-  const InDetDD::PixelDetectorManager *m_manager;
-  InDetDD::AthenaComps *m_athenaComps;
-  InDetDD::SiCommonItems *m_commonItems;
-  ServiceHandle<IGeoModelSvc> m_geoModelSvc;
-  ServiceHandle<IRDBAccessSvc> m_rdbAccessSvc;
-  ServiceHandle< IGeoDbTagSvc > m_geoDbTagSvc;
-};
-
-#endif // PLRGEOMODELXML_PLRDETECTORTOOL_H

InnerDetector/InDetDetDescr/PLRGeoModelXml/src/PLRDetectorFactory.cxx

@@ -2,118 +2,97 @@
   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
-#include "PLRGeoModelXml/PLRDetectorFactory.h"
-
-#include <string>
-#include <sstream>
-
-#include "StoreGate/StoreGateSvc.h" // For alignment getAlignableFolderType()
-#include "AthenaPoolUtilities/CondAttrListCollection.h"
-#include "DetDescrConditions/AlignableTransformContainer.h"
-
-#include "InDetGeoModelUtils/InDetDDAthenaComps.h"
-#include "GeoModelKernel/GeoPhysVol.h"
-#include "GeoModelInterfaces/IGeoModelSvc.h"
-#include "GeoModelUtilities/DecodeVersionKey.h"
-
-#include "ReadoutGeometryBase/SiCommonItems.h"
-#include "PixelReadoutGeometry/PixelDetectorManager.h"
-#include "InDetReadoutGeometry/Version.h"
-#include "PixelReadoutGeometry/PixelModuleDesign.h"
-
-#include "RDBAccessSvc/IRDBAccessSvc.h"
-#include "RDBAccessSvc/IRDBRecordset.h"
-#include "RDBAccessSvc/IRDBRecord.h"
-
-#include "PLRGeoModelXml/PLROptions.h"
-#include "GeoModelXml/Gmx2Geo.h"
-#include "PLRGeoModelXml/PLRGmxInterface.h"
-#include "GeoModelXml/GmxInterface.h"
-
-#include "PathResolver/PathResolver.h"
-
-using namespace std;
-
-namespace InDetDDSLHC {
-
-  PLRDetectorFactory::PLRDetectorFactory(InDetDD::AthenaComps *athenaComps,
-					     InDetDD::SiCommonItems *commonItems,
-					     PLROptions &options) :
-    InDetDD::DetectorFactoryBase(athenaComps),
-    m_athenaComps(athenaComps),
-    m_commonItems(commonItems),
-    m_options(&options) {
-    //
-    //    Create the detector manager... should allow the name to be set
-    //
-    m_detectorManager = new InDetDD::PixelDetectorManager(detStore(),m_options->detectorName());
-  }
+#include "PLRDetectorFactory.h"
+#include "PLRGmxInterface.h"
+#include "PLROptions.h"
+
+#include <AthenaPoolUtilities/CondAttrListCollection.h>
+#include <DetDescrConditions/AlignableTransformContainer.h>
+#include <GeoModelKernel/GeoPhysVol.h>
+#include <GeoModelUtilities/DecodeVersionKey.h>
+#include <GeoModelXml/Gmx2Geo.h>
+#include <InDetReadoutGeometry/Version.h>
+#include <PathResolver/PathResolver.h>
+#include <PixelReadoutGeometry/PixelModuleDesign.h>
+#include <RDBAccessSvc/IRDBAccessSvc.h>
+#include <RDBAccessSvc/IRDBRecord.h>
+#include <RDBAccessSvc/IRDBRecordset.h>
+#include <ReadoutGeometryBase/SiCommonItems.h>
+#include <StoreGate/StoreGateSvc.h>
+
+
+namespace InDetDD
+{
+
+PLRDetectorFactory::PLRDetectorFactory(AthenaComps *athenaComps,
+                                       SiCommonItems *commonItems,
+                                       const PLROptions &options)
+ : DetectorFactoryBase(athenaComps),
+   m_commonItems(commonItems),
+   m_options(options)
+{
+  // Create the detector manager... should allow the name to be set
+  m_detectorManager = new PixelDetectorManager(detStore(), m_options.detectorName());
+}
 
-  PLRDetectorFactory::~PLRDetectorFactory() {
-    // NB the detector manager (m_detectorManager) is stored in the detector store by the Tool and so we don't delete it.
-  }
 
-  void PLRDetectorFactory::create(GeoPhysVol *world) {
-    ATH_MSG_INFO( "C R E A T E   W O R L D" );
-   
-    ITk::PLRGmxInterface gmxInterface(m_detectorManager, m_commonItems, &m_moduleTree);
-    //    To set up solid geometry only, without having to worry about sensitive detectors etc., and get loads of debug output,
-    //    comment out above line and uncomment the following line; also, switch header files above.
-    //    GmxInterface gmxInterface;
-    
-    int flags(0);
-    string gmxInput;
-    
-    if (m_options->gmxFilename().empty()) {
-      ATH_MSG_INFO( "gmxFilename not set; getting .gmx from Geometry database Blob not supported"
-		     );
-    }
-    else {
-      flags = 0;
-      gmxInput = PathResolver::find_file(m_options->gmxFilename(), "DATAPATH");
-      if (gmxInput.empty()) { // File not found
-	string errMessage("PLRDetectorFactory::create: Unable to find file " + m_options->gmxFilename() +
-                                   " with PathResolver; check filename and DATAPATH environment variable");
-	throw runtime_error(errMessage);
-      }
-    }
-    
-    Gmx2Geo gmx2Geo(gmxInput, world, gmxInterface, flags);
-
-    //
-    //   Add the tree-top to the detector manager.
-    //    
-    unsigned int nChildren = world->getNChildVols();
-    bool foundVolume = false;
-
-    for (int iChild = nChildren - 1; iChild>=0; --iChild) {
-      if( world->getNameOfChildVol(iChild) == "PLR") {
-	      // The * converts from a ConstPVLink to a reference to a GeoVPhysVol;
-	      // the & takes its address.
-	      foundVolume  = true;
-	      m_detectorManager->addTreeTop(&*world->getChildVol(iChild));
-	      break;
-      }
-    }
-  
-    if(!foundVolume) ATH_MSG_ERROR("Could not find a logicalVolume named \"PLR\"- this is required to provide the Envelope!");
+void PLRDetectorFactory::create(GeoPhysVol *world)
+{
+  ATH_MSG_INFO("C R E A T E   W O R L D");
 
-    doNumerology();
+  PLRGmxInterface gmxInterface(m_detectorManager, m_commonItems, &m_moduleTree);
+  // To set up solid geometry only, without having to worry about sensitive detectors etc., and get loads of debug output,
+  // comment out above line and uncomment the following line; also, switch header files above.
+  // GmxInterface gmxInterface;
 
-    m_detectorManager->initNeighbours();
+  int flags{};
+  std::string gmxInput;
 
+  if (m_options.gmxFilename().empty()) {
+    ATH_MSG_INFO("gmxFilename not set; getting .gmx from Geometry database Blob not supported");
+  } else {
+    flags = 0;
+    gmxInput = PathResolver::find_file(m_options.gmxFilename(), "DATAPATH");
+    if (gmxInput.empty()) { // File not found
+      std::string errMessage("PLRDetectorFactory::create: Unable to find file " + m_options.gmxFilename() +
+                             " with PathResolver; check filename and DATAPATH environment variable");
+      throw std::runtime_error(errMessage);
+    }
   }
-  
-  InDetDD::PixelDetectorManager * PLRDetectorFactory::getDetectorManager() const {
-    return m_detectorManager;
-  }
 
-  void PLRDetectorFactory::doNumerology() {
-    InDetDD::SiNumerology n;
-    
-    ATH_MSG_INFO( "\n\nPLR Numerology:\n===============\n\nNumber of parts is " << m_moduleTree.nParts() );
-    
+  Gmx2Geo gmx2Geo(gmxInput, world, gmxInterface, flags);
+
+  // Add the tree-top to the detector manager.
+  unsigned int nChildren = world->getNChildVols();
+  bool foundVolume = false;
+
+  for (int iChild = nChildren - 1; iChild>=0; --iChild) {
+    if( world->getNameOfChildVol(iChild) == "PLR") {
+      // The * converts from a ConstPVLink to a reference to a GeoVPhysVol;
+      // the & takes its address.
+      foundVolume = true;
+      m_detectorManager->addTreeTop(&*world->getChildVol(iChild));
+      break;
+    }
   }
 
+  if (!foundVolume) ATH_MSG_ERROR("Could not find a logicalVolume named \"PLR\"- this is required to provide the Envelope!");
+
+  doNumerology();
+
+  m_detectorManager->initNeighbours();
+}
+
+PixelDetectorManager * PLRDetectorFactory::getDetectorManager() const
+{
+  return m_detectorManager;
+}
+
+void PLRDetectorFactory::doNumerology()
+{
+  InDetDD::SiNumerology n;
+
+  ATH_MSG_INFO("\n\nPLR Numerology:\n===============\n\nNumber of parts is " << m_moduleTree.nParts());
 }
 
+} // namespace InDetDD

InnerDetector/InDetDetDescr/PLRGeoModelXml/src/PLRDetectorFactory.h

+/*
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PLRGeoModelXml_PLRDETECTORFACTORY_H
+#define PLRGeoModelXml_PLRDETECTORFACTORY_H
+//
+//    Main routine to build the GeoModel geometry, and handle the GeometryManager and
+//    DetectorManager.
+//
+#include <InDetGeoModelUtils/InDetDetectorFactoryBase.h>
+#include <InDetGeoModelUtils/WaferTree.h>
+#include <PixelReadoutGeometry/PixelDetectorManager.h>
+
+class GeoPhysVol;
+
+namespace InDetDD
+{
+
+class AthenaComps;
+class SiCommonItems;
+class PLROptions;
+
+class PLRDetectorFactory : public DetectorFactoryBase
+{
+public:
+  PLRDetectorFactory(AthenaComps *athenaComps,
+                     SiCommonItems *commonItems,
+                     const PLROptions &options);
+
+  // Creation of geometry:
+  virtual void create(GeoPhysVol *world) override final;
+  // Access to the results:
+  virtual InDetDD::PixelDetectorManager * getDetectorManager() const override final;
+
+private:
+  // Print out how many of each layer/eta/phi etc. have been set up.
+  void doNumerology();
+
+  // Copy and assignments operations illegal and so are made private
+  PLRDetectorFactory(PLRDetectorFactory &right);
+  PLRDetectorFactory & operator=(PLRDetectorFactory &right);
+
+  PixelDetectorManager *m_detectorManager{};
+  SiCommonItems *m_commonItems{};
+  const PLROptions &m_options;
+  WaferTree m_moduleTree;
+};
+
+} // namespace InDetDD
+
+#endif

InnerDetector/InDetDetDescr/PLRGeoModelXml/src/PLRDetectorTool.cxx

@@ -2,176 +2,137 @@
   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
-#include "PLRGeoModelXml/PLRDetectorTool.h"
-#include "PLRGeoModelXml/PLRDetectorFactory.h"
-#include "PLRGeoModelXml/PLROptions.h"
-#include "PixelReadoutGeometry/PixelDetectorManager.h"
-#include "InDetGeoModelUtils/InDetDDAthenaComps.h"
-#include "ReadoutGeometryBase/SiCommonItems.h"
-#include "GeoModelUtilities/GeoModelExperiment.h"
-#include "GeoModelInterfaces/IGeoModelSvc.h"
-#include "GeoModelUtilities/DecodeVersionKey.h"
-#include "StoreGate/StoreGateSvc.h"
-#include "RDBAccessSvc/IRDBAccessSvc.h"
-#include "RDBAccessSvc/IRDBRecord.h"
-#include "RDBAccessSvc/IRDBRecordset.h"
-#include "DetDescrConditions/AlignableTransformContainer.h"
-#include "SGTools/DataProxy.h"
-
-using InDetDD::PixelDetectorManager;
-using InDetDD::SiDetectorManager;
+#include "PLRDetectorFactory.h"
+#include "PLRDetectorTool.h"
+#include "PLROptions.h"
 
-PLRDetectorTool::PLRDetectorTool(const std::string &type,
-                                             const std::string &name,
-                                             const IInterface *parent) :
-    GeoModelTool(type, name, parent),
-    m_detectorName("PLR"),
-    m_alignable(false),
-    m_gmxFilename(""),
-    m_manager(nullptr),
-    m_athenaComps(nullptr),
-    m_commonItems(nullptr),
-    m_geoModelSvc("GeoModelSvc", name),
-    m_rdbAccessSvc("RDBAccessSvc", name), 
-    m_geoDbTagSvc{"GeoDbTagSvc", name}
-
-    {
-//
-// Get parameter values from jobOptions file
-//
-    declareProperty("DetectorName", m_detectorName);
-    declareProperty("Alignable", m_alignable);
-    declareProperty("GmxFilename", m_gmxFilename);
-    declareProperty("RDBAccessSvc", m_rdbAccessSvc);
-    declareProperty("GeoModelSvc", m_geoModelSvc);
-    declareProperty("GeoDbTagSvc", m_geoDbTagSvc);
+#include <DetDescrConditions/AlignableTransformContainer.h>
+#include <GeoModelUtilities/GeoModelExperiment.h>
+#include <SGTools/DataProxy.h>
+#include <StoreGate/StoreGateSvc.h>
 
-}
 
-PLRDetectorTool::~PLRDetectorTool() {
-    delete m_athenaComps;
-    delete m_commonItems;
+PLRDetectorTool::PLRDetectorTool(const std::string &type,
+                                 const std::string &name,
+                                 const IInterface *parent)
+ : GeoModelTool(type, name, parent)
+{
 }
 
-StatusCode PLRDetectorTool::create() {
-//
-//   Retrieve all services except LorentzAngleSvc, which has to be done later
-//
-
-    // Get the detector configuration.
-    ATH_CHECK(m_geoDbTagSvc.retrieve());
-    ATH_CHECK(m_rdbAccessSvc.retrieve());
-    GeoModelExperiment *theExpt;
-    ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
-    const PixelID *idHelper; //DEF?
-    ATH_CHECK(detStore()->retrieve(idHelper, "PixelID")); //DEF?
-
-//
-//    Get their interfaces to pass to the DetectorFactory
-//
-    m_athenaComps = new InDetDD::AthenaComps("PLRGeoModelXml");
-    m_athenaComps->setDetStore(&*(detStore()));
-    m_athenaComps->setRDBAccessSvc(&*m_rdbAccessSvc);
-    m_athenaComps->setGeoDbTagSvc(&*m_geoDbTagSvc);
-
-
-    m_commonItems = new InDetDD::SiCommonItems(idHelper);
-//
-//    Get options from python
-//
-    InDetDDSLHC::PLROptions options;
-    options.setAlignable(m_alignable);
-    options.setGmxFilename(m_gmxFilename);
-    options.setDetectorName(m_detectorName);
-
-//
-// Create the PLRDetectorFactory
-//
-    // The * converts a ConstPVLink to a ref to a GeoVPhysVol
-    // The & takes the address of the GeoVPhysVol
-    GeoPhysVol *world = &*theExpt->getPhysVol();
-    InDetDDSLHC::PLRDetectorFactory thePLR(m_athenaComps, m_commonItems, options);
-    thePLR.create(world);
-//
-// Get the manager from the factory and store it in the detector store.
-//
-    m_manager = thePLR.getDetectorManager();
-
-    if (!m_manager) {
-        ATH_MSG_ERROR( "PixelDetectorManager not found; not created in PLRDetectorFactory? (PLR uses PixelDetectorManager)" );
-        return(StatusCode::FAILURE);
-    }
-
-    StatusCode sc;
-    sc = detStore()->record(m_manager, m_manager->getName());
-    if (sc.isFailure() ) {
-        ATH_MSG_ERROR( "Could not register PixelDetectorManager" );
-        return StatusCode::FAILURE;
-    }
-    theExpt->addManager(m_manager);
-
-    // Create a symLink to the SiDetectorManager base class so it can be accessed as either SiDetectorManager or 
-    // PixelDetectorManager
-    const SiDetectorManager *siDetManager = m_manager;
-    sc = detStore()->symLink(m_manager, siDetManager);
-    if(sc.isFailure()){
-        ATH_MSG_ERROR( "Could not make link between PixelDetectorManager and SiDetectorManager" );
-        return StatusCode::FAILURE;
-    }
 
-    return StatusCode::SUCCESS;
+StatusCode PLRDetectorTool::create()
+{
+  //
+  // Retrieve all services except LorentzAngleSvc, which has to be done later
+  //
+
+  // Get the detector configuration.
+  ATH_CHECK(m_geoDbTagSvc.retrieve());
+  ATH_CHECK(m_rdbAccessSvc.retrieve());
+
+  GeoModelExperiment *theExpt;
+  ATH_CHECK(detStore()->retrieve(theExpt, "ATLAS"));
+  const PixelID *idHelper;
+  ATH_CHECK(detStore()->retrieve(idHelper, "PixelID"));
+
+  //
+  // Get their interfaces to pass to the DetectorFactory
+  //
+  auto athenaComps = std::make_unique<InDetDD::AthenaComps>("PLRGeoModelXml");
+  athenaComps->setDetStore(&*(detStore()));
+  athenaComps->setRDBAccessSvc(&*m_rdbAccessSvc);
+  athenaComps->setGeoDbTagSvc(&*m_geoDbTagSvc);
+
+  m_commonItems = std::make_unique<InDetDD::SiCommonItems>(idHelper);
+  //
+  // Get options from python
+  //
+  InDetDD::PLROptions options;
+  options.setAlignable(m_alignable);
+  options.setGmxFilename(m_gmxFilename);
+  options.setDetectorName(m_detectorName);
+
+  //
+  // Create the PLRDetectorFactory
+  //
+  // The * converts a ConstPVLink to a ref to a GeoVPhysVol
+  // The & takes the address of the GeoVPhysVol
+  GeoPhysVol *world = &*theExpt->getPhysVol();
+  InDetDD::PLRDetectorFactory thePLR(athenaComps.get(), m_commonItems.get(), options);
+  thePLR.create(world);
+  //
+  // Get the manager from the factory and store it in the detector store.
+  //
+  m_manager = thePLR.getDetectorManager();
+
+  if (!m_manager) {
+    ATH_MSG_ERROR("PixelDetectorManager not found; not created in PLRDetectorFactory? (PLR uses PixelDetectorManager)");
+    return(StatusCode::FAILURE);
+  }
+
+  ATH_CHECK(detStore()->record(m_manager, m_manager->getName()));
+  theExpt->addManager(m_manager);
+
+  // Create a symLink to the SiDetectorManager base class so it can be accessed as either SiDetectorManager or
+  // PixelDetectorManager
+  const InDetDD::SiDetectorManager *siDetManager = m_manager;
+  ATH_CHECK(detStore()->symLink(m_manager, siDetManager));
+
+  return StatusCode::SUCCESS;
 }
 
-StatusCode PLRDetectorTool::clear() {
-    SG::DataProxy* proxy = detStore()->proxy(ClassID_traits<InDetDD::PixelDetectorManager>::ID(),m_manager->getName());
-    if(proxy) {
-        proxy->reset();
-        m_manager = nullptr;
-    }
-    return StatusCode::SUCCESS;
-}
 
-StatusCode PLRDetectorTool::registerCallback() {
-// 
-//    Register call-back for software alignment
-//
-    StatusCode sc = StatusCode::FAILURE;
-    if (m_alignable) {
-        std::string folderName = "/Indet/Align"; //DEF? BCM has: folderName = "/ITk/Align"
-        if (detStore()->contains<AlignableTransformContainer>(folderName)) {
-            ATH_MSG_DEBUG( "Registering callback on AlignableTransformContainer with folder " << folderName );
-            const DataHandle<AlignableTransformContainer> atc;
-            sc =  detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool *>(this), atc, folderName);
-            if(sc.isFailure()) {
-                ATH_MSG_ERROR( "Could not register callback on AlignableTransformContainer with folder " << 
-                                    folderName );
-            } 
-        } 
-        else {
-            ATH_MSG_WARNING( "Unable to register callback on AlignableTransformContainer with folder " <<
-                                 folderName << ", Alignment disabled (only if no Run2 scheme is loaded)!" );
-        }
-    } 
-    else {
-        ATH_MSG_INFO( "Alignment disabled. No callback registered" );
-        // We return failure otherwise it will try and register a GeoModelSvc callback associated with this callback.
-    }
-    return sc;
+StatusCode PLRDetectorTool::clear()
+{
+  SG::DataProxy* proxy = detStore()->proxy(ClassID_traits<InDetDD::PixelDetectorManager>::ID(),m_manager->getName());
+  if (proxy) {
+    proxy->reset();
+    m_manager = nullptr;
+  }
+  return StatusCode::SUCCESS;
 }
 
-StatusCode PLRDetectorTool::align(IOVSVC_CALLBACK_ARGS_P(I, keys)) {
-//
-//    The call-back routine, which just calls the real call-back routine from the manager.
-//
-    if (!m_manager) {
-        ATH_MSG_WARNING( "Manager does not exist" );
+
+StatusCode PLRDetectorTool::registerCallback()
+{
+  //
+  // Register call-back for software alignment
+  //
+  if (m_alignable) {
+    std::string folderName = "/Indet/Align"; //DEF? BCM has: folderName = "/ITk/Align"
+    if (detStore()->contains<AlignableTransformContainer>(folderName)) {
+      ATH_MSG_DEBUG("Registering callback on AlignableTransformContainer with folder " << folderName);
+      const DataHandle<AlignableTransformContainer> atc;
+      StatusCode sc = detStore()->regFcn(&IGeoModelTool::align, dynamic_cast<IGeoModelTool *>(this), atc, folderName);
+      if (sc.isFailure()) {
+        ATH_MSG_ERROR("Could not register callback on AlignableTransformContainer with folder "
+                      << folderName);
         return StatusCode::FAILURE;
+      }
+    } else {
+      ATH_MSG_WARNING("Unable to register callback on AlignableTransformContainer with folder "
+                      << folderName << ", Alignment disabled (only if no Run2 scheme is loaded)!");
     }
-    if (m_alignable) {
-        return m_manager->align(I, keys);
-    } 
-    else {
-        ATH_MSG_DEBUG( "Alignment disabled. No alignments applied" );
-        return StatusCode::SUCCESS;
-    }
+  } else {
+    ATH_MSG_INFO("Alignment disabled. No callback registered");
+    // We return failure otherwise it will try and register a GeoModelSvc callback associated with this callback.
+  }
+  return StatusCode::SUCCESS;
+}
+
+StatusCode PLRDetectorTool::align(IOVSVC_CALLBACK_ARGS_P(I, keys))
+{
+  //
+  // The call-back routine, which just calls the real call-back routine from the manager.
+  //
+  if (!m_manager) {
+    ATH_MSG_WARNING("Manager does not exist");
+    return StatusCode::FAILURE;
+  }
+  if (m_alignable) {
+    return m_manager->align(I, keys);
+  } else {
+    ATH_MSG_DEBUG("Alignment disabled. No alignments applied");
+    return StatusCode::SUCCESS;
+  }
 }

InnerDetector/InDetDetDescr/PLRGeoModelXml/src/PLRDetectorTool.h

+/*
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PLRGeoModelXml_PLRDETECTORTOOL_H
+#define PLRGeoModelXml_PLRDETECTORTOOL_H
+//
+// Create an Athena Tool; handle Athena services and Tools needed for
+// building the Pixel geometry. Then create the geometry using the PixelDetectorFactory.
+// This is the entry to the PixelGeoModelXml package.
+//
+#include <GaudiKernel/ServiceHandle.h>
+#include <GeoModelInterfaces/IGeoDbTagSvc.h>
+#include <GeoModelInterfaces/IGeoModelSvc.h>
+#include <GeoModelUtilities/GeoModelTool.h>
+#include <RDBAccessSvc/IRDBAccessSvc.h>
+#include <ReadoutGeometryBase/SiCommonItems.h>
+
+#include <memory>
+
+
+namespace InDetDD
+{
+  class PixelDetectorManager;
+  class AthenaComps;
+  class SiCommonItems;
+}
+
+class PLRDetectorTool : public GeoModelTool
+{
+public: 
+  PLRDetectorTool(const std::string &type, const std::string &name, const IInterface *parent);
+  virtual ~PLRDetectorTool() = default;
+  virtual StatusCode create() override final;
+  virtual StatusCode clear() override final;
+  virtual StatusCode registerCallback() override final;
+  virtual StatusCode align(IOVSVC_CALLBACK_ARGS_P(I,keys)) override final;
+  
+private:
+  const InDetDD::PixelDetectorManager *m_manager{};
+  std::unique_ptr<InDetDD::SiCommonItems> m_commonItems{};
+
+  Gaudi::Property<std::string> m_detectorName{this, "DetectorName", "PLR", ""};
+  Gaudi::Property<bool> m_alignable{this, "Alignable", false, ""};
+  Gaudi::Property<std::string> m_gmxFilename{this, "GmxFilename", "", ""};
+  ServiceHandle<IGeoModelSvc> m_geoModelSvc{this, "GeoModelSvc", "GeoModelSvc", ""};
+  ServiceHandle<IRDBAccessSvc> m_rdbAccessSvc{this, "RDBAccessSvc", "RDBAccessSvc", ""};
+  ServiceHandle<IGeoDbTagSvc> m_geoDbTagSvc{this, "GeoDbTagSvc", "GeoDbTagSvc", ""};
+};
+
+#endif // PLRGEOMODELXML_PLRDETECTORTOOL_H

InnerDetector/InDetDetDescr/PLRGeoModelXml/src/PLRGmxInterface.cxx

@@ -2,7 +2,7 @@
   Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
-#include "PLRGeoModelXml/PLRGmxInterface.h"
+#include "PLRGmxInterface.h"
 
 #include <InDetReadoutGeometry/SiDetectorDesign.h>
 #include <InDetReadoutGeometry/SiDetectorElement.h>
@@ -13,19 +13,20 @@
 #include <ReadoutGeometryBase/SiCommonItems.h>
 
 
-namespace ITk
+namespace InDetDD
 {
 
-PLRGmxInterface::PLRGmxInterface(InDetDD::PixelDetectorManager *detectorManager,
-                                     InDetDD::SiCommonItems *commonItems,
-                                     WaferTree *moduleTree)
+PLRGmxInterface::PLRGmxInterface(PixelDetectorManager *detectorManager,
+                                 SiCommonItems *commonItems,
+                                 WaferTree *moduleTree)
   : PixelGmxInterface(detectorManager, commonItems, moduleTree),
     m_detectorManager(detectorManager)
 {}
 
+
 void PLRGmxInterface::addSensorType(std::string clas,
-                                      std::string typeName,
-                                      std::map<std::string, std::string> parameters)
+                                    std::string typeName,
+                                    std::map<std::string, std::string> parameters)
 {
   ATH_MSG_DEBUG("addSensorType called for class " << clas << ", typeName " << typeName);
   // only load the sensor type that the PLR will use
@@ -36,7 +37,7 @@ void PLRGmxInterface::addSensorType(std::string clas,
 
 
 void PLRGmxInterface::makePLRModule(const std::string &typeName,
-                                        const std::map<std::string, std::string> &parameters)
+                                    const std::map<std::string, std::string> &parameters)
 {
   int circuitsPerEta{1}; // row
   int circuitsPerPhi{1}; // column
@@ -80,13 +81,13 @@ void PLRGmxInterface::makePLRModule(const std::string &typeName,
   //
   // Make Module Design and add to DetectorManager
   //
-  std::shared_ptr<const InDetDD::PixelDiodeMatrix> fullMatrix = buildMatrix(pitchPhi, pitchEta,
-                                                                            pitchPhiLong, pitchPhiEnd,
-                                                                            pitchEtaLong, pitchEtaEnd,
-                                                                            nPhiLongPerSide, nPhiEndPerSide,
-                                                                            nEtaLongPerSide, nEtaEndPerSide,
-                                                                            circuitsPerPhi, circuitsPerEta,
-                                                                            columnsPerChip, rowsPerChip);
+  std::shared_ptr<const PixelDiodeMatrix> fullMatrix = buildMatrix(pitchPhi, pitchEta,
+                                                                   pitchPhiLong, pitchPhiEnd,
+                                                                   pitchEtaLong, pitchEtaEnd,
+                                                                   nPhiLongPerSide, nPhiEndPerSide,
+                                                                   nEtaLongPerSide, nEtaEndPerSide,
+                                                                   circuitsPerPhi, circuitsPerEta,
+                                                                   columnsPerChip, rowsPerChip);
 
   ATH_MSG_DEBUG("fullMatrix = buildMatrix(" << pitchPhi << ", " << pitchEta << ", "
                                             << pitchPhiLong << ", " << pitchPhiEnd << ", "
@@ -105,12 +106,12 @@ void PLRGmxInterface::makePLRModule(const std::string &typeName,
   // (so far) primarily useful to avoid orientation warnings
   InDetDD::DetectorType detectorType{InDetDD::PLR};
 
-  auto design = std::make_unique<InDetDD::PixelModuleDesign>(thickness,
-                                                            circuitsPerPhi, circuitsPerEta,
-                                                            columnsPerChip, rowsPerChip,
-                                                            columnsPerChip, rowsPerChip,
-                                                            fullMatrix, carrier,
-                                                            readoutSide, is3D, detectorType);
+  auto design = std::make_unique<PixelModuleDesign>(thickness,
+                                                    circuitsPerPhi, circuitsPerEta,
+                                                    columnsPerChip, rowsPerChip,
+                                                    columnsPerChip, rowsPerChip,
+                                                    fullMatrix, carrier,
+                                                    readoutSide, is3D, detectorType);
   
 
   ATH_MSG_DEBUG("readout geo - design : " << design->width() << " " << design->length() << " " << design->thickness() << " " <<design->rows() << " " << design->columns());
@@ -121,5 +122,4 @@ void PLRGmxInterface::makePLRModule(const std::string &typeName,
   m_geometryMap[typeName] = m_detectorManager->numDesigns() - 1;
 }
 
-
-} // namespace ITk
+} // namespace InDetDD

InnerDetector/InDetDetDescr/PLRGeoModelXml/PLRGeoModelXml/PLRGmxInterface.h → InnerDetector/InDetDetDescr/PLRGeoModelXml/src/PLRGmxInterface.h

@@ -8,7 +8,6 @@
 #include <PixelGeoModelXml/PixelGmxInterface.h>
 
 #include <map>
-#include <memory>
 #include <sstream>
 #include <string>
 
@@ -16,15 +15,17 @@
 // The functions here are similar functions to that of Pixel, but have a few PLR specific differences
 // such as only loading the correct PLR sensor type and identifying the modules as InDetDD::PLR
 
-namespace InDetDD {class PixelDetectorManager; class SiCommonItems;}
-
-namespace ITk
+namespace InDetDD
 {
-class PLRGmxInterface : public PixelGmxInterface
+
+class PixelDetectorManager;
+class SiCommonItems;
+
+class PLRGmxInterface : public ITk::PixelGmxInterface
 {
 public:
-  PLRGmxInterface(InDetDD::PixelDetectorManager *detectorManager,
-                  InDetDD::SiCommonItems *commonItems,
+  PLRGmxInterface(PixelDetectorManager *detectorManager,
+                  SiCommonItems *commonItems,
                   WaferTree *moduleTree);
 
   virtual void addSensorType(std::string clas,
@@ -35,11 +36,9 @@ private:
   void makePLRModule(const std::string& typeName,
                      const std::map<std::string, std::string> &parameters);
 
-  InDetDD::PixelDetectorManager *m_detectorManager{};
+  PixelDetectorManager *m_detectorManager{};
 };
 
-} // namespace ITk
+} // namespace InDetDD
 
 #endif // PLRGEOMODELXML_PLRGMXINTERFACE_H
-
-