addressing first round of MR comments

Core/include/Acts/Geometry/Extent.hpp

@@ -8,16 +8,17 @@
 
 #pragma once
 
-#include <iostream>
-#include <utility>
-#include <vector>
 #include "Acts/Utilities/BinningType.hpp"
 #include "Acts/Utilities/Definitions.hpp"
 #include "Acts/Utilities/Helpers.hpp"
 
+#include <iosfwd>
+#include <utility>
+#include <vector>
+
 namespace Acts {
 
-using range_type = std::pair<double, double>;
+using Range = std::pair<double, double>;
 
 // @brief Extent in space
 ///
@@ -29,22 +30,21 @@ struct Extent {
   static constexpr double maxval = std::numeric_limits<double>::max();
 
   /// Start value
-  static constexpr range_type maxrange = {maxval, -maxval};
+  static constexpr Range maxrange = {maxval, -maxval};
 
   // The different ranges
-  std::vector<range_type> ranges = std::vector<range_type>(9, maxrange);
+  std::vector<Range> ranges = std::vector<Range>(9, maxrange);
 
   // Constructor
   Extent() = default;
 
-  /// Merge another extent in - using operator+=
+  /// Extend with another extent
   /// @param other is the source Extent
-  Extent& operator+=(const Extent& other) {
+  void extend(const Extent& other) {
     for (auto ir = 0; ir < other.ranges.size(); ++ir) {
       ranges[ir].first = std::min(ranges[ir].first, other.ranges[ir].first);
       ranges[ir].second = std::max(ranges[ir].second, other.ranges[ir].second);
     }
-    return (*this);
   }
 
   /// Convert to output stream for screen output
@@ -79,9 +79,9 @@ struct Extent {
       ranges[bval].first = std::min(value, ranges[bval].first);
       ranges[bval].second = std::max(value, ranges[bval].second);
     };
-    // Walk through the binnin parameters
+    // Walk through the binning parameters
     for (int bval = 0; bval < binValues; ++bval) {
-      BinningValue bValue = (BinningValue)bval;
+      BinningValue bValue = static_cast<BinningValue>(bval);
       minMax(bValue, VectorHelpers::cast(vtx, bValue));
     }
   }

Core/include/Acts/Geometry/Polyhedron.hpp

@@ -8,13 +8,14 @@
 
 #pragma once
 
-#include <limits>
-#include <vector>
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Surfaces/BoundaryCheck.hpp"
 #include "Acts/Utilities/Definitions.hpp"
 #include "Acts/Utilities/Helpers.hpp"
 
+#include <limits>
+#include <vector>
+
 namespace Acts {
 
 /// @class Polyhedron
@@ -27,7 +28,7 @@ namespace Acts {
 /// that need to be connected to form a face.
 /// This allows the @c objString method to produce a ready-to-go obj output.
 struct Polyhedron {
-  using face_type = std::vector<size_t>;
+  using Face = std::vector<size_t>;
 
   /// Default constructor
   Polyhedron() = default;
@@ -39,8 +40,8 @@ struct Polyhedron {
   /// @param radialCheck A dedicated check for radial extent done
   /// @note This creates copies of the input vectors
   Polyhedron(const std::vector<Vector3D>& verticesIn,
-             const std::vector<face_type>& facesIn,
-             const std::vector<face_type>& triangularMeshIn,
+             const std::vector<Face>& facesIn,
+             const std::vector<Face>& triangularMeshIn,
              bool radialCheck = false)
       : vertices(verticesIn),
         faces(facesIn),
@@ -52,12 +53,12 @@ struct Polyhedron {
   /// List of faces connecting the vertices.
   /// each face is a list of vertices v
   /// corresponding to the vertex vector above
-  std::vector<face_type> faces;
+  std::vector<Face> faces;
 
   /// List of faces connecting the vertices.
   /// each face is a list of vertices v
   /// - in this case restricted to a triangular representation
-  std::vector<face_type> triangularMesh;
+  std::vector<Face> triangularMesh;
 
   /// Add another Polyhedrons
   ///

Core/include/Acts/Surfaces/AnnulusBounds.hpp

@@ -129,7 +129,7 @@ class AnnulusBounds : public DiscBounds {
   std::vector<Vector2D> corners() const;
 
   /// This method returns the xy coordinates of the four corners of the
-  /// bounds in module coorindates (in X/y)
+  /// bounds in module coorindates (in x/y)
   /// Starting from the upper right (max R, pos locX) and proceding clock-wise
   /// i.e. (max R; pos locX), (min R; pos locX), (min R; neg loc X), (max R: neg
   /// locX)

Core/include/Acts/Surfaces/detail/FacesHelper.hpp

@@ -20,7 +20,7 @@ namespace detail {
 
 /// @brief Helper for writing out faces for polyhedron representation
 struct FacesHelper {
-  using FaceVector = std::vector<Polyhedron::face_type>;
+  using FaceVector = std::vector<Polyhedron::Face>;
 
   /// @brief This method words for all convex type surface setups
   /// It includes:

Core/src/Geometry/Extent.cpp

@@ -8,12 +8,11 @@
 
 #include "Acts/Geometry/Extent.hpp"
 
-// STD/STL
-#include <iostream>
+#include <ostream>
 
 std::ostream& Acts::Extent::toStream(std::ostream& sl) const {
   sl << "Extent in space : " << std::endl;
-  for (size_t ib = 0; ib < size_t(binValues); ++ib) {
+  for (size_t ib = 0; ib < static_cast<size_t>(binValues); ++ib) {
     sl << "  - value :" << std::setw(10) << binningValueNames[ib]
        << " | range = [" << ranges[ib].first << ", " << ranges[ib].second << "]"
        << std::endl;

Core/src/Geometry/Polyhedron.cpp

@@ -14,10 +14,10 @@ Acts::Polyhedron& Acts::Polyhedron::operator+=(const Acts::Polyhedron& other) {
   size_t cvert = vertices.size();
   vertices.insert(vertices.end(), other.vertices.begin(), other.vertices.end());
   /// Add the new faces with offsets
-  auto join = [&](std::vector<face_type>& existing,
-                  const std::vector<face_type>& additional) -> void {
+  auto join = [&](std::vector<Face>& existing,
+                  const std::vector<Face>& additional) -> void {
     for (const auto& aface : additional) {
-      face_type nface = aface;
+      Face nface = aface;
       std::transform(nface.begin(), nface.end(), nface.begin(),
                      [&](size_t x) { return (x + cvert); });
       existing.push_back(nface);

Core/src/Surfaces/ConeSurface.cpp

@@ -198,8 +198,8 @@ Acts::Polyhedron Acts::ConeSurface::polyhedronRepresentation(
     const GeometryContext& gctx, size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3D> vertices;
-  std::vector<Polyhedron::face_type> faces;
-  std::vector<Polyhedron::face_type> triangularMesh;
+  std::vector<Polyhedron::Face> faces;
+  std::vector<Polyhedron::Face> triangularMesh;
 
   if (bounds().minZ() == -std::numeric_limits<double>::infinity() or
       bounds().maxZ() == std::numeric_limits<double>::infinity()) {

Core/src/Surfaces/CylinderSurface.cpp

@@ -189,8 +189,8 @@ Acts::Polyhedron Acts::CylinderSurface::polyhedronRepresentation(
     const GeometryContext& gctx, size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3D> vertices;
-  std::vector<Polyhedron::face_type> faces;
-  std::vector<Polyhedron::face_type> triangularMesh;
+  std::vector<Polyhedron::Face> faces;
+  std::vector<Polyhedron::Face> triangularMesh;
 
   auto ctrans = transform(gctx);
   bool fullCylinder = bounds().coversFullAzimuth();

Core/src/Surfaces/DiscSurface.cpp

@@ -156,8 +156,8 @@ Acts::Polyhedron Acts::DiscSurface::polyhedronRepresentation(
     const GeometryContext& gctx, size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3D> vertices;
-  std::vector<Polyhedron::face_type> faces;
-  std::vector<Polyhedron::face_type> triangularMesh;
+  std::vector<Polyhedron::Face> faces;
+  std::vector<Polyhedron::Face> triangularMesh;
 
   // Understand the disc
   bool fullDisc = m_bounds->coversFullAzimuth();

Core/src/Surfaces/PerigeeSurface.cpp

@@ -72,8 +72,8 @@ Acts::Polyhedron Acts::PerigeeSurface::polyhedronRepresentation(
     const GeometryContext& gctx, size_t /*lseg*/) const {
   // Prepare vertices and faces
   std::vector<Vector3D> vertices;
-  std::vector<Polyhedron::face_type> faces;
-  std::vector<Polyhedron::face_type> triangularMesh;
+  std::vector<Polyhedron::Face> faces;
+  std::vector<Polyhedron::Face> triangularMesh;
 
   const Transform3D& ctransform = transform(gctx);
   Vector3D left(0, 0, -100.);

Core/src/Surfaces/PlaneSurface.cpp

@@ -122,8 +122,8 @@ Acts::Polyhedron Acts::PlaneSurface::polyhedronRepresentation(
     const GeometryContext& gctx, size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3D> vertices;
-  std::vector<Polyhedron::face_type> faces;
-  std::vector<Polyhedron::face_type> triangularMesh;
+  std::vector<Polyhedron::Face> faces;
+  std::vector<Polyhedron::Face> triangularMesh;
 
   // If you have bounds you can create a polyhedron representation
   if (m_bounds) {

Core/src/Surfaces/StrawSurface.cpp

@@ -59,8 +59,8 @@ Acts::Polyhedron Acts::StrawSurface::polyhedronRepresentation(
     const GeometryContext& gctx, size_t lseg) const {
   // Prepare vertices and faces
   std::vector<Vector3D> vertices;
-  std::vector<Polyhedron::face_type> faces;
-  std::vector<Polyhedron::face_type> triangularMesh;
+  std::vector<Polyhedron::Face> faces;
+  std::vector<Polyhedron::Face> triangularMesh;
 
   const Transform3D& ctransform = transform(gctx);
   // Draw the bounds if more than one segment are chosen

Tests/UnitTests/Core/Geometry/ExtentTests.cpp

@@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(ExtentTest) {
 
   // Create a second Extent
   Extent otherExt;
-  otherExt += gExt;
+  otherExt.extend(gExt);
 
   CHECK_CLOSE_ABS(otherExt.min(binX), 15_mm, 1e-6);
   CHECK_CLOSE_ABS(otherExt.max(binX), 18_mm, 1e-6);