Merge branch 'ILayerBuilderCond_factory_non_const_return' into 'master'

ILayerBuilderCond does not need to return the  new Layers it creates as const

See merge request atlas/athena!47499

HighGranularityTimingDetector/HGTD_Reconstruction/HGTD_TrackingGeometry/HGTD_TrackingGeometry/HGTD_LayerBuilderCond.h

@@ -64,31 +64,36 @@ namespace HGTDet {
       virtual ~HGTD_LayerBuilderCond();
       
       /** AlgTool initialize method */
-      StatusCode initialize();
+      virtual StatusCode initialize() override;
       /** AlgTool finalize method */
-      StatusCode finalize();
-       
+      virtual StatusCode finalize() override;
+
       /** LayerBuilder interface method - returning Barrel-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::CylinderLayer* >* > cylindricalLayers(const EventContext& ctx) const; 
-      
+      virtual std::pair<EventIDRange, const std::vector<Trk::CylinderLayer*>*>
+      cylindricalLayers(const EventContext& ctx) const override final;
+
       /** LayerBuilder interface method - returning Endcap-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::DiscLayer* >* >    discLayers(const EventContext& ctx) const; 
-      
+      virtual std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*>
+      discLayers(const EventContext& ctx) const override final;
+
       /** LayerBuilder interface method - returning Planar-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* >   planarLayers(const EventContext& ctx) const; 
-             
+      virtual std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>
+      planarLayers(const EventContext& ctx) const override final;
+
       /** Name identification */
-      const std::string& identification() const;      
+      virtual const std::string& identification() const override final;      
         
     private:
       SG::ReadCondHandle<InDetDD::HGTD_DetectorElementCollection> retrieveHGTDdetElements(const EventContext& ctx) const;
-      
-      const Trk::BinnedLayerMaterial discLayerMaterial(double rMin, double rMax) const; //!< helper method to construct HGTD material
-        
-      void registerSurfacesToLayer(const std::vector<const Trk::Surface*>& surfaces, const Trk::Layer& layer) const; //!< layer association
-      
+      //!< helper method to construct HGTD materia 
+      const Trk::BinnedLayerMaterial discLayerMaterial(double rMin, double rMax) const; 
+
+      //!< layer association
+      void registerSurfacesToLayer( const std::vector<const Trk::Surface*>& surfaces,const Trk::Layer& layer) const; 
+
       void evaluateBestBinning(std::vector<Trk::SurfaceOrderPosition>& surfaces,
-                               std::vector<float>& rBins, float& maxRadius,
+                               std::vector<float>& rBins,
+                               float& maxRadius,
                                std::vector<std::vector<float>>& phiBins) const;
 
       const HGTD_DetectorManager*           m_hgtdMgr;                        //!< the HGTD Detector Manager
@@ -105,25 +110,34 @@ namespace HGTDet {
       float                                 m_discThickness;                  //!< set disc thickness
       
       bool                                  m_runGeometryValidation;          //!< run geometry validation
-      
-      SG::ReadCondHandleKey<InDetDD::HGTD_DetectorElementCollection> m_HGTD_ReadKey{this, "HGTD_ReadKey", "HGTD_DetectorElementCollection", "Key of output HGTD_DetectorElementCollection for HGTD"};
-                      
+
+      SG::ReadCondHandleKey<InDetDD::HGTD_DetectorElementCollection>
+        m_HGTD_ReadKey{
+          this,
+          "HGTD_ReadKey",
+          "HGTD_DetectorElementCollection",
+          "Key of output HGTD_DetectorElementCollection for HGTD"
+        };
   };
 
- inline std::pair<EventIDRange, const std::vector< const Trk::CylinderLayer* >* > HGTD_LayerBuilderCond::cylindricalLayers(const EventContext&) const
- { 
-   //create dummy infinite range
+  inline std::pair<EventIDRange, const std::vector<Trk::CylinderLayer*>*>
+  HGTD_LayerBuilderCond::cylindricalLayers(const EventContext&) const
+  {
+    // create dummy infinite range
     EventIDRange range;
-    return std::pair<EventIDRange, const std::vector< const Trk::CylinderLayer* >* >(range, 0);
- }
-  
- inline std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* > HGTD_LayerBuilderCond::planarLayers(const EventContext&) const
- { 
-   //create dummy infinite range
+    return std::pair<EventIDRange, const std::vector<Trk::CylinderLayer*>*>(
+      range, nullptr);
+  }
+
+  inline std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>
+  HGTD_LayerBuilderCond::planarLayers(const EventContext&) const
+  {
+    // create dummy infinite range
     EventIDRange range;
-    return std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* >(range, 0);
- }
- 
+    return std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>(range,
+                                                                         nullptr);
+  }
+
  inline const std::string& HGTD_LayerBuilderCond::identification() const
  { return m_identification; }
    

HighGranularityTimingDetector/HGTD_Reconstruction/HGTD_TrackingGeometry/HGTD_TrackingGeometry/HGTD_OverlapDescriptor.h

@@ -74,7 +74,7 @@ namespace HGTDet {
   private:
     bool dumpSurfaces(std::vector<Trk::SurfaceIntersection>& surfaces) const;    
     
-    float                                   m_binSize;
+    float                                   m_binSize = 0.0F;
     const Trk::BinnedArray<Trk::Surface>*   m_binnedArray;
     std::vector < float >                   m_valuesR;
     std::vector < std::vector< float> >     m_valuesPhi;

HighGranularityTimingDetector/HGTD_Reconstruction/HGTD_TrackingGeometry/src/HGTD_LayerBuilderCond.cxx

@@ -108,7 +108,8 @@ SG::ReadCondHandle<InDetDD::HGTD_DetectorElementCollection> HGTDet::HGTD_LayerBu
 
 
 /** LayerBuilder interface method - returning Endcap-like layers */
-std::pair<EventIDRange, const std::vector<const Trk::DiscLayer*>*>  HGTDet::HGTD_LayerBuilderCond::discLayers(const EventContext& ctx) const
+std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*>
+HGTDet::HGTD_LayerBuilderCond::discLayers(const EventContext& ctx) const
 {
   ATH_MSG_DEBUG( "calling HGTDet::HGTD_LayerBuilderCond::discLayers()" );
   
@@ -117,14 +118,14 @@ std::pair<EventIDRange, const std::vector<const Trk::DiscLayer*>*>  HGTDet::HGTD
     ATH_MSG_ERROR("HGTD Detector Manager or ID Helper could not be retrieved - giving up.");
     //create dummy infinite range
     EventIDRange range = IOVInfiniteRange::infiniteMixed();
-    return std::pair<EventIDRange, const std::vector<const Trk::DiscLayer*>*>(range,nullptr);
+    return std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*>(range,nullptr);
   } 
   
   // get general layout
   SG::ReadCondHandle<InDetDD::HGTD_DetectorElementCollection> readHandle = retrieveHGTDdetElements(ctx);
   if(*readHandle == nullptr){
     EventIDRange range = IOVInfiniteRange::infiniteMixed();
-    return std::pair<EventIDRange, std::vector<const Trk::DiscLayer*>*>(range,nullptr);
+    return std::pair<EventIDRange, std::vector<Trk::DiscLayer*>*>(range,nullptr);
   }
   const InDetDD::HGTD_DetectorElementCollection* readCdo{*readHandle};
   InDetDD::HGTD_DetectorElementCollection::const_iterator hgtdDetIter = readCdo->begin();
@@ -164,7 +165,10 @@ std::pair<EventIDRange, const std::vector<const Trk::DiscLayer*>*>  HGTDet::HGTD
      // get the identifier
      Identifier    currentId((*hgtdDetIter)->identify());
 
-     ATH_MSG_DEBUG("Element : " << m_hgtdHelper->endcap(currentId) << "/" << m_hgtdHelper->layer(currentId)  << "/" << m_hgtdHelper->eta_module(currentId) << "/" << m_hgtdHelper->phi_module(currentId));
+     ATH_MSG_DEBUG("Element : " << m_hgtdHelper->endcap(currentId) << "/"
+                                << m_hgtdHelper->layer(currentId) << "/"
+                                << m_hgtdHelper->eta_module(currentId) << "/"
+                                << m_hgtdHelper->phi_module(currentId));
 
      // increase the counter of HGTD modules
      hgtdModules++;
@@ -209,7 +213,7 @@ std::pair<EventIDRange, const std::vector<const Trk::DiscLayer*>*>  HGTDet::HGTD
   minRmin -= m_discEnvelopeR;  
   
   // construct the layers
-  std::vector< const Trk::DiscLayer* >* discLayers = new std::vector< const Trk::DiscLayer* >;
+  std::vector<Trk::DiscLayer*>* discLayers = new std::vector<Trk::DiscLayer* >;
   
   double thickness = m_discThickness;
   
@@ -265,12 +269,17 @@ std::pair<EventIDRange, const std::vector<const Trk::DiscLayer*>*>  HGTDet::HGTD
           ++dsumCheckSurfaces;
           usmIter = uniqueSurfaceMap.find(asurfIter);
           lastPhi = asurfIter->center().phi();
-          if ( usmIter != uniqueSurfaceMap.end() )
-            ATH_MSG_WARNING("Non-unique surface found with eta/phi = " << asurfIter->center().eta() << " / " << asurfIter->center().phi());
-          else uniqueSurfaceMap[asurfIter] = asurfIter->center();
-        } 
-        else {
-          ATH_MSG_WARNING("Zero-pointer in array detected in this ring, last valid phi value was = " << lastPhi << " --> discCounter: " << discCounter);            
+          if (usmIter != uniqueSurfaceMap.end()) {
+            ATH_MSG_WARNING("Non-unique surface found with eta/phi = "
+                            << asurfIter->center().eta() << " / "
+                            << asurfIter->center().phi());
+          } else {
+            uniqueSurfaceMap[asurfIter] = asurfIter->center();
+          }
+        } else {
+          ATH_MSG_WARNING("Zero-pointer in array detected in this ring, last "
+                          "valid phi value was = "
+                          << lastPhi << " --> discCounter: " << discCounter);
         }
       }
       sumCheckhgtdModules +=  dsumCheckSurfaces;   
@@ -321,7 +330,6 @@ std::pair<EventIDRange, const std::vector<const Trk::DiscLayer*>*>  HGTDet::HGTD
   return std::make_pair(range, discLayers);
 }
 
-
 const Trk::BinnedLayerMaterial HGTDet::HGTD_LayerBuilderCond::discLayerMaterial(double rMin, double rMax) const
 {
   Trk::BinUtility layerBinUtilityR(m_rBins, rMin, rMax, Trk::open, Trk::binR);
@@ -352,7 +360,7 @@ void HGTDet::HGTD_LayerBuilderCond::evaluateBestBinning(std::vector<Trk::Surface
   std::vector < std::pair< float, float> > centers = {};
   centers.reserve(surfaces.size());
   for ( auto& orderedSurface : surfaces) {
-    centers.push_back(std::make_pair(orderedSurface.second.perp(), orderedSurface.second.phi()));
+    centers.emplace_back(orderedSurface.second.perp(), orderedSurface.second.phi());
   }
   
   // sorting the centers accordingly to r

HighGranularityTimingDetector/HGTD_Reconstruction/HGTD_TrackingGeometry/src/HGTD_OverlapDescriptor.cxx

@@ -8,6 +8,10 @@
 ///////////////////////////////////////////////////////////////////
 
 // Amg
+#include <utility>
+
+
+
 #include "GeoPrimitives/GeoPrimitives.h"
 // HGTD
 #include "HGTD_TrackingGeometry/HGTD_OverlapDescriptor.h"
@@ -24,8 +28,8 @@ HGTDet::HGTD_OverlapDescriptor::HGTD_OverlapDescriptor(const Trk::BinnedArray<Tr
                                                        std::vector < std::vector< float> > valuesPhi,
                                                        int nStepsR, int nStepsPhi):
   m_binnedArray(bin_array),
-  m_valuesR(valuesR),
-  m_valuesPhi(valuesPhi),
+  m_valuesR(std::move(valuesR)),
+  m_valuesPhi(std::move(valuesPhi)),
   m_nStepsR(nStepsR),
   m_nStepsPhi(nStepsPhi)
 {}
@@ -37,7 +41,7 @@ bool HGTDet::HGTD_OverlapDescriptor::reachableSurfaces(std::vector<Trk::SurfaceI
                                                        const Amg::Vector3D&) const
   
 {
-  surfaces.push_back(Trk::SurfaceIntersection(Trk::Intersection(pos, 0., true),&tsf));
+  surfaces.emplace_back(Trk::Intersection(pos, 0., true),&tsf);
   
   // add the other targets
   // use the center of this surface in (x,y) global coordinates and look for
@@ -77,7 +81,7 @@ bool HGTDet::HGTD_OverlapDescriptor::reachableSurfaces(std::vector<Trk::SurfaceI
   }
   
   for (auto& surface : allSurfaces)
-    surfaces.push_back(Trk::SurfaceIntersection(Trk::Intersection(Amg::Vector3D(0.,0.,0.),0.,true),surface));
+    surfaces.emplace_back(Trk::Intersection(Amg::Vector3D(0.,0.,0.),0.,true),surface);
   
   return false;
 }

HighGranularityTimingDetector/HGTD_Reconstruction/HGTD_TrackingGeometry/src/HGTD_TrackingGeometryBuilderCond.cxx

@@ -102,7 +102,7 @@ std::pair<EventIDRange, const Trk::TrackingGeometry*> HGTDet::HGTD_TrackingGeome
   ATH_MSG_VERBOSE( "Starting to build HGTD_TrackingGeometry ..." );   
   
   // the return TG
-  const Trk::TrackingGeometry* hgtdTrackingGeometry = 0; 
+  const Trk::TrackingGeometry* hgtdTrackingGeometry = nullptr; 
   
   // the enclosed input volume (ID)
   double enclosedInnerSectorHalflength = std::numeric_limits<float>::max();
@@ -157,14 +157,17 @@ std::pair<EventIDRange, const Trk::TrackingGeometry*> HGTDet::HGTD_TrackingGeome
       }
     }
   }
-  
-  ATH_MSG_VERBOSE( "Got Dimensions Zmin/Rmin - Zmax/Rmax: " << enclosedInnerSectorHalflength << "/" << enclosedInnerRadius << " - " << enclosedOuterSectorHalflength << "/" << enclosedOuterRadius );   
-  
+
+  ATH_MSG_VERBOSE("Got Dimensions Zmin/Rmin - Zmax/Rmax: "
+                  << enclosedInnerSectorHalflength << "/" << enclosedInnerRadius
+                  << " - " << enclosedOuterSectorHalflength << "/"
+                  << enclosedOuterRadius);
+
   // prepare the layers
   std::vector<const Trk::Layer*> negativeLayers;
   std::vector<const Trk::Layer*> positiveLayers;  
   
-  std::pair<EventIDRange, const std::vector<const Trk::DiscLayer*>*> discLayersPair = m_layerBuilder->discLayers(ctx);
+  std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*> discLayersPair = m_layerBuilder->discLayers(ctx);
   const auto *discLayers = discLayersPair.second;
   
   float maxZ = -9999.;
@@ -233,8 +236,8 @@ std::pair<EventIDRange, const Trk::TrackingGeometry*> HGTDet::HGTD_TrackingGeome
                                                                         enclosedInnerSectorHalflength);
     Amg::Transform3D* idTr = new Amg::Transform3D(Trk::s_idTransform);
     // dummy objects
-    const Trk::LayerArray* dummyLayers = 0;
-    const Trk::TrackingVolumeArray* dummyVolumes = 0;
+    const Trk::LayerArray* dummyLayers = nullptr;
+    const Trk::TrackingVolumeArray* dummyVolumes = nullptr;
     
     innerVol = new Trk::TrackingVolume(idTr, idBounds, *materialProperties,
                                        dummyLayers, dummyVolumes,

InnerDetector/InDetDetDescr/InDetTrackingGeometry/InDetTrackingGeometry/BeamPipeBuilderCond.h

@@ -49,23 +49,26 @@ namespace InDet {
       BeamPipeBuilderCond(const std::string&,const std::string&,const IInterface*);
       /** Destructor */
       virtual ~BeamPipeBuilderCond();
-      
+
       /** AlgTool initialize method */
-      StatusCode initialize();
+      virtual StatusCode initialize() override;
       /** AlgTool finalize method */
-      StatusCode finalize();
-       
+      virtual StatusCode finalize() override;
+
       /** LayerBuilder interface method - returning Barrel-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::CylinderLayer* >* > cylindricalLayers(const EventContext& ctx) const; 
-      
+      virtual std::pair<EventIDRange, const std::vector<Trk::CylinderLayer*>*>
+      cylindricalLayers(const EventContext& ctx) const override final;
+
       /** LayerBuilder interface method - returning Endcap-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::DiscLayer* >* >     discLayers(const EventContext& ctx) const; 
-      
+      virtual std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*>
+      discLayers(const EventContext& ctx) const override final;
+
       /** LayerBuilder interface method - returning Planar-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* >    planarLayers(const EventContext& ctx) const; 
+      virtual std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>
+      planarLayers(const EventContext& ctx) const override final;
 
       /** Name identification */
-      const std::string& identification() const;      
+      virtual const std::string& identification() const override;      
           
     private:
       
@@ -93,20 +96,24 @@ namespace InDet {
       
   };
 
- inline std::pair<EventIDRange, const std::vector< const Trk::DiscLayer* >* >  BeamPipeBuilderCond::discLayers(const EventContext&) const
+  inline std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*>
+  BeamPipeBuilderCond::discLayers(const EventContext&) const
   {
-  //create dummy infinite range
+    // create dummy infinite range
     EventIDRange range;
-    return std::pair<EventIDRange, const std::vector< const Trk::DiscLayer* >* >(range,0); 
+    return std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*>(
+      range, nullptr);
   }
- 
- inline std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* > BeamPipeBuilderCond::planarLayers(const EventContext&) const
+
+  inline std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>
+  BeamPipeBuilderCond::planarLayers(const EventContext&) const
   {
-  //create dummy infinite range
+    // create dummy infinite range
     EventIDRange range;
-    return std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* >(range, 0);
+    return std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>(
+      range, nullptr);
   }
- 
+
  inline const std::string& BeamPipeBuilderCond::identification() const
  { return m_identification; } 
  

InnerDetector/InDetDetDescr/InDetTrackingGeometry/InDetTrackingGeometry/SiLayerBuilderCond.h

@@ -67,42 +67,57 @@ namespace InDet {
     
       /** AlgTool style constructor */
       SiLayerBuilderCond(const std::string&,const std::string&,const IInterface*);
-      
+
       /** Destructor */
       virtual ~SiLayerBuilderCond();
-      
+
       /** AlgTool initialize method */
-      StatusCode initialize();
+      virtual StatusCode initialize() override;
       /** AlgTool finalize method */
-      StatusCode finalize();
-       
+      virtual StatusCode finalize() override;
+
       /** LayerBuilder interface method - returning Barrel-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::CylinderLayer* >* > cylindricalLayers(const EventContext& ctx) const; 
-      
+      virtual std::pair<EventIDRange, const std::vector<Trk::CylinderLayer*>*>
+      cylindricalLayers(const EventContext& ctx) const override final;
+
       /** LayerBuilder interface method - returning Endcap-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::DiscLayer* >* >    discLayers(const EventContext& ctx) const; 
-      
+      virtual std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*>
+      discLayers(const EventContext& ctx) const override final;
+
       /** LayerBuilder interface method - returning Planar-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* >   planarLayers(const EventContext& ctx) const; 
-             
+      virtual std::pair<EventIDRange,
+                        const std::vector<Trk::PlaneLayer*>*>
+      planarLayers(const EventContext& ctx) const override final;
+
       /** Name identification */
-      const std::string& identification() const;      
-        
+      virtual const std::string& identification() const override final;
+
     private:
-      SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> retrieveSiDetElements(const EventContext& ctx) const;
-      std::vector< const Trk::CylinderLayer* >* dressCylinderLayers(const std::vector< const Trk::CylinderLayer* >& dLayers) const;
-      
-      /** create the disc layers, if no vector is given, then it's the first pass, else it's the DBM for the Pixels */
-      std::pair<EventIDRange, std::vector< const Trk::DiscLayer* >* > createDiscLayers(const EventContext& ctx, std::vector<const Trk::DiscLayer* >* dLayers = nullptr) const;
-      
-      /** create the disc layers, it is dedicated to ITk implementation of the endcap rings.
-       * Used for ITk specific case. */
-      std::pair<EventIDRange, std::vector< const Trk::DiscLayer* >* > createRingLayers(const EventContext& ctx) const;
-        
-      const Trk::BinnedLayerMaterial barrelLayerMaterial(double r, double hz) const;  //!< helper method to construct barrel material
-      const Trk::BinnedLayerMaterial endcapLayerMaterial(double rMin, double rMax) const; //!< helper method to construct endcap material
-        
-      void registerSurfacesToLayer(const std::vector<const Trk::Surface*>& surfaces, const Trk::Layer& layer) const; //!< layer association
+      SG::ReadCondHandle<InDetDD::SiDetectorElementCollection>
+      retrieveSiDetElements(const EventContext& ctx) const;
+      std::vector<Trk::CylinderLayer*>* dressCylinderLayers(
+        const std::vector<Trk::CylinderLayer*>& dLayers) const;
+
+      /** create the disc layers, if no vector is given, then it's the first
+       * pass, else it's the DBM for the Pixels */
+      std::pair<EventIDRange, std::vector<Trk::DiscLayer*>*> createDiscLayers(
+        const EventContext& ctx,
+        std::vector<Trk::DiscLayer*>* dLayers = nullptr) const;
+
+      /** create the disc layers, it is dedicated to ITk implementation of the
+       * endcap rings. Used for ITk specific case. */
+      std::pair<EventIDRange, std::vector<Trk::DiscLayer*>*> createRingLayers(
+        const EventContext& ctx) const;
+
+      //!< helper method to construct barrel material
+      const Trk::BinnedLayerMaterial barrelLayerMaterial(double r,
+                                                         double hz) const;
+
+      //!< helper method to construct endcap material
+      const Trk::BinnedLayerMaterial endcapLayerMaterial(double rMin,
+                                                         double rMax) const;
+
+      void registerSurfacesToLayer(const std::vector<const Trk::Surface*>& surfaces, Trk::Layer& layer) const; //!< layer association
 
       bool                                           m_pixelCase;                      //!< flag for pixel/sct
                                                      
@@ -143,16 +158,21 @@ namespace InDet {
                       
   };
 
- inline std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* > SiLayerBuilderCond::planarLayers(const EventContext&) const
+  inline std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>
+  SiLayerBuilderCond::planarLayers(const EventContext&) const
   {
-  //create dummy infinite range
+    // create dummy infinite range
     EventIDRange range;
-    return std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* >(range, 0);
+    return std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>(
+      range, nullptr);
   }
- 
- inline const std::string& SiLayerBuilderCond::identification() const
- { return m_identification; }
-   
+
+  inline const std::string&
+  SiLayerBuilderCond::identification() const
+  {
+    return m_identification;
+  }
+
 } // end of namespace
 
 

InnerDetector/InDetDetDescr/InDetTrackingGeometry/InDetTrackingGeometry/TRT_LayerBuilderCond.h

@@ -63,25 +63,33 @@ namespace InDet {
       virtual ~TRT_LayerBuilderCond();
       
       /** AlgTool initialize method */
-      StatusCode initialize();
-       
+      virtual StatusCode initialize() override final;
+
       /** LayerBuilderCond interface method - returning Barrel-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::CylinderLayer* >* > cylindricalLayers(const EventContext& ctx) const; 
-      
+      virtual std::pair<EventIDRange, const std::vector<Trk::CylinderLayer*>*>
+      cylindricalLayers(const EventContext& ctx) const override final;
+
       /** LayerBuilderCond interface method - returning Endcap-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::DiscLayer* >* >     discLayers(const EventContext& ctx) const; 
-      
+      virtual std::pair<EventIDRange, const std::vector<Trk::DiscLayer*>*> discLayers(
+        const EventContext& ctx) const override final;
+
       /** LayerBuilderCond interface method - returning Planar-like layers */
-      std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* >    planarLayers(const EventContext& ctx) const; 
-            
+      virtual std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>
+      planarLayers(const EventContext& ctx) const override final;
+
       /** Name identification */
-      const std::string& identification() const;      
+      virtual const std::string& identification() const override final;      
       
     private:
-                   
-      SG::ReadCondHandleKey<InDetDD::TRT_DetElementContainer> m_readKeyTRTContainer{this, "ReadKeyTRTDetectorElements","TRT_DetElementContainer","Key for input TRT detector element container read from cond store"};
+      SG::ReadCondHandleKey<InDetDD::TRT_DetElementContainer>
+        m_readKeyTRTContainer{
+          this,
+          "ReadKeyTRTDetectorElements",
+          "TRT_DetElementContainer",
+          "Key for input TRT detector element container read from cond store"
+        };
 
-      double                                        m_layerStrawRadius;         //!< straw radius
+      double m_layerStrawRadius; //!< straw radius
       double                                        m_layerThickness;           //!< modelled layer thickness
       bool                                          m_modelGeometry;            //!< Build the geometry with model layers
       unsigned int                                  m_modelBarrelLayers;        //!< model barrel layers with material
@@ -101,13 +109,15 @@ namespace InDet {
       
   };
 
- inline std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* > TRT_LayerBuilderCond::planarLayers(const EventContext&) const
+  inline std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>
+  TRT_LayerBuilderCond::planarLayers(const EventContext&) const
   {
-  //create dummy infinite range
+    // create dummy infinite range
     EventIDRange range;
-    return std::pair<EventIDRange, const std::vector< const Trk::PlaneLayer* >* >(range, 0);
+    return std::pair<EventIDRange, const std::vector<Trk::PlaneLayer*>*>(
+      range, 0);
   }
- 
+
  inline const std::string& TRT_LayerBuilderCond::identification() const
  { return m_identification; }
    

InnerDetector/InDetDetDescr/InDetTrackingGeometry/src/BeamPipeBuilderCond.cxx

@@ -98,10 +98,11 @@ StatusCode InDet::BeamPipeBuilderCond::finalize()
 
 /** LayerBuilder interface method - returning Barrel-like layers */
 //TODO: context is not used, beamPipe retrieved from manager. range is infinite
-std::pair<EventIDRange, const std::vector< const Trk::CylinderLayer* >*>  InDet::BeamPipeBuilderCond::cylindricalLayers(const EventContext&) const
+std::pair<EventIDRange, const std::vector<Trk::CylinderLayer*>*>
+InDet::BeamPipeBuilderCond::cylindricalLayers(const EventContext&) const
 {