Merge branch 'main' into uncomment-athena-breaking-code

CI/physmon/workflows/physmon_ckf_tracking.py

@@ -112,6 +112,15 @@ def run_ckf_tracking(truthSmearedSeeded, truthEstimatedSeeded, label):
             else SeedingAlgorithm.Default
             if label == "seeded"
             else SeedingAlgorithm.Orthogonal,
+            initialSigmas=[
+                1 * u.mm,
+                1 * u.mm,
+                1 * u.degree,
+                1 * u.degree,
+                0.1 / u.GeV,
+                1 * u.ns,
+            ],
+            initialVarInflation=[1.0] * 6,
             geoSelectionConfigFile=setup.geoSel,
             rnd=rnd,  # only used by SeedingAlgorithm.TruthSmeared
             outputDirRoot=tp,

CI/physmon/workflows/physmon_vertexing.py

@@ -99,6 +99,15 @@ def run_vertexing(fitter, mu, events):
             ),
             SeedFinderOptionsArg(bFieldInZ=2 * u.T),
             seedingAlgorithm=SeedingAlgorithm.Default,
+            initialSigmas=[
+                1 * u.mm,
+                1 * u.mm,
+                1 * u.degree,
+                1 * u.degree,
+                0.1 / u.GeV,
+                1 * u.ns,
+            ],
+            initialVarInflation=[1.0] * 6,
             geoSelectionConfigFile=setup.geoSel,
         )
 

CMakeLists.txt

@@ -185,7 +185,7 @@ endif()
 # minimal dependency versions. they are defined here in a single place so
 # they can be easily upgraded, although they might not be used if the
 # dependency is included via `add_subdirectory(...)`.
-set(_acts_actsvg_version 0.4.39)
+set(_acts_actsvg_version 0.4.40)
 set(_acts_autodiff_version 0.6)
 set(_acts_boost_version 1.71.0)
 set(_acts_dd4hep_version 1.21)

Core/include/Acts/Detector/Blueprint.hpp

@@ -10,10 +10,12 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Definitions/Common.hpp"
+#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Geometry/VolumeBounds.hpp"
 #include "Acts/Utilities/BinningData.hpp"
 #include "Acts/Utilities/StringHelpers.hpp"
 
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ -91,6 +93,9 @@ struct Node final {
   /// Branch definition binning
   std::vector<BinningValue> binning = {};
 
+  /// Portal proto material binning
+  std::map<unsigned int, BinningDescription> portalMaterialBinning = {};
+
   /// Auxiliary information
   std::vector<std::string> auxiliary = {};
 

Core/include/Acts/Detector/LayerStructureBuilder.hpp

@@ -94,8 +94,6 @@ class LayerStructureBuilder : public IInternalStructureBuilder {
     unsigned int nMinimalSurfaces = 4u;
     /// Polyhedron approximations
     unsigned int nSegments = 1u;
-    /// Full closed phi binning
-    bool fullPhiBinning = true;
     /// Extra information, mainly for screen output
     std::string auxiliary = "";
   };

Core/include/Acts/Detector/ProtoBinning.hpp

@@ -39,6 +39,8 @@ struct ProtoBinning {
   std::vector<ActsScalar> edges = {};
   /// An expansion for the filling (in bins)
   std::size_t expansion = 0u;
+  /// Indication if this is an auto-range binning
+  bool autorange = false;
 
   /// Convenience constructors - for variable binning
   ///
@@ -106,7 +108,8 @@ struct ProtoBinning {
       : binValue(bValue),
         boundaryType(bType),
         edges(nbins + 1, 0.),
-        expansion(exp) {}
+        expansion(exp),
+        autorange(true) {}
 
   // Return the number of bins
   std::size_t bins() const { return edges.size() - 1u; }
@@ -118,7 +121,11 @@ struct ProtoBinning {
        << binningValueNames()[binValue];
     ss << (axisType == Acts::detail::AxisType::Variable ? ", variable "
                                                         : ", equidistant ");
-    ss << "within [" << edges.front() << ", " << edges.back() << "] ";
+    if (!autorange) {
+      ss << "within [" << edges.front() << ", " << edges.back() << "] ";
+    } else {
+      ss << "within automatic range";
+    }
     return ss.str();
   }
 };

Core/include/Acts/Detector/ProtoSupport.hpp

@@ -10,6 +10,7 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Definitions/Common.hpp"
+#include "Acts/Detector/ProtoBinning.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/BinningData.hpp"
 #include "Acts/Utilities/detail/AxisFwd.hpp"
@@ -21,22 +22,60 @@
 namespace Acts {
 
 namespace Experimental {
-/// @brief Support parameter definitions
+/// @brief Support surface building instructions
+///
+/// There are two ways to build a support surface:
+///
+/// 1. Provide a surface type and the values for the binning
+///
+/// 2. Provide a surface directly
+///
+/// In both cases a binning description for proto material can be attached,
+/// if the surface is split into planar approximinations, the proto binning
+/// is assumed to be
 struct ProtoSupport {
-  /// Define whether you want to build support structures
-  std::array<ActsScalar, 5u> values = {};
+  // Building instructions 1 (surface type, parameters, transform is provided):
+
   /// The surface type to be built
   Surface::SurfaceType type = Surface::SurfaceType::Other;
-  /// Define in which values the support should be constrained
-  std::vector<BinningValue> constraints = s_binningValues;
-  /// Potential splits into planar approximations
-  unsigned int splits = 1u;
-  /// The (optional) layer transform
-  std::optional<Transform3> transform = std::nullopt;
-  /// Alternatively - the support surface can already be provided
+
+  /// The offset of the support to an estimated position (e.g. from an extent)
+  ActsScalar offset = 0.;
+
+  /// A given extent from the volume, this allows to set support surfaces
+  /// to fit into given volume extensions (flagged by the binning value
+  /// being constrained by this extent)
+  Extent volumeExtent;
+
+  /// The volume envelope/clearance parameters: these are chosen such that the
+  /// support surface does not touch the volume extent
+  ExtentEnvelope volumeClearance = zeroEnvelopes;
+
+  /// The constrain(s) from the internal surfaces, done by parsing
+  /// the polyhedron vertices of the internal objects before support building
+  ///
+  /// The internal constraint would overwrite the volume one in order to allow
+  /// support surfaces to be fitted from global volume extensions to the
+  /// actually contained internal objects.
+  std::vector<BinningValue> internalConstraints = {};
+
+  // Building instructions 2 (surface is provided):
+
+  /// The support surface can already be provided
   std::shared_ptr<Surface> surface = nullptr;
-  /// Indicate if the support surface should always be addressed in navigation
-  bool assignToAll = false;
+
+  /// The (optional) binning description for proto material
+  std::optional<BinningDescription> protoMaterialBinning = std::nullopt;
+
+  /// Potential splits into planar approximations (valid for cylinder/disc)
+  unsigned int splits = 1u;
+
+  /// Planar placement (only valid for planar support surfaces)
+  BinningValue pPlacement = binZ;
+
+  /// Indicate if the support surface(s) should always be addressed in
+  /// navigation
+  bool assignToAll = true;
 };
 
 }  // namespace Experimental