make some useful methods public

Author: paulgessinger

Core/include/Acts/Geometry/BlueprintBuilder.hpp

@@ -255,6 +255,9 @@ class BlueprintBuilder {
 
   std::shared_ptr<Acts::Experimental::LayerBlueprintNode> makeLayer(
       const Element& detElement, const LayerSpec& layerSpec) const;
+  std::shared_ptr<Acts::Experimental::LayerBlueprintNode> makeLayer(
+      const Element& parent, std::span<const Element> sensitives,
+      const LayerSpec& layerSpec) const;
 
   LayerAssembler layers() const;
   BarrelEndcapAssembler barrelEndcap() const;
@@ -275,15 +278,9 @@ class BlueprintBuilder {
   const Acts::Logger& logger() const;
   const Backend& backend() const;
 
- private:
-  std::shared_ptr<Acts::Experimental::LayerBlueprintNode>
-  makeLayerFromSensitives(const Element& parent,
-                          std::span<const Element> sensitives,
-                          const LayerSpec& layerSpec) const;
-
-  static std::vector<Element> resolveSensitives(const Backend& backend,
-                                                const Element& detElement);
+  std::vector<Element> resolveSensitives(const Element& detElement) const;
 
+ private:
   std::unique_ptr<const Acts::Logger> m_logger;
   Backend m_backend;
 };

Core/include/Acts/Geometry/detail/BlueprintBuilder_impl.hpp

@@ -395,8 +395,8 @@ template <detail::BlueprintBackend BackendT>
 std::shared_ptr<Acts::Experimental::LayerBlueprintNode>
 BlueprintBuilder<BackendT>::makeLayer(const Element& detElement,
                                       const LayerSpec& layerSpec) const {
-  auto sensitives = resolveSensitives(m_backend, detElement);
-  return makeLayerFromSensitives(detElement, sensitives, layerSpec);
+  auto sensitives = resolveSensitives(detElement);
+  return makeLayer(detElement, sensitives, layerSpec);
 }
 
 template <detail::BlueprintBackend BackendT>
@@ -530,7 +530,7 @@ BlueprintBuilder<BackendT>::findEndcapElements(const Element& assembly) const {
 
 template <detail::BlueprintBackend BackendT>
 std::shared_ptr<Acts::Experimental::LayerBlueprintNode>
-BlueprintBuilder<BackendT>::makeLayerFromSensitives(
+BlueprintBuilder<BackendT>::makeLayer(
     const Element& parent, std::span<const Element> sensitives,
     const LayerSpec& layerSpec) const {
   std::string fullLayerName = getPathToElementName(parent);
@@ -545,15 +545,14 @@ BlueprintBuilder<BackendT>::makeLayerFromSensitives(
 
 template <detail::BlueprintBackend BackendT>
 std::vector<typename BlueprintBuilder<BackendT>::Element>
-BlueprintBuilder<BackendT>::resolveSensitives(const Backend& backend,
-                                              const Element& detElement) {
+BlueprintBuilder<BackendT>::resolveSensitives(const Element& detElement) const {
   std::vector<Element> sensitives;
 
   std::function<void(const Element&)> visit = [&](const Element& elem) {
-    if (backend.isSensitive(elem)) {
+    if (m_backend.isSensitive(elem)) {
       sensitives.push_back(elem);
     }
-    for (const auto& child : backend.children(elem)) {
+    for (const auto& child : m_backend.children(elem)) {
       visit(child);
     }
   };

Plugins/DD4hep/src/BlueprintBuilder.cpp

@@ -107,40 +107,6 @@ bool DD4hepBackend::isTracker(const Element& element) const {
   return dd4hep::DetType{element.typeFlag()}.is(dd4hep::DetType::TRACKER);
 }
 
-namespace {
-Acts::Transform3 convertTGeoTransform(const TGeoShape& shape,
-                                      const TGeoMatrix& transform,
-                                      TGeoAxes axes, double lengthScale) {
-  const Double_t* translation = transform.GetTranslation();
-  const Double_t* rotation = transform.GetRotationMatrix();
-
-  auto [cBounds, cTransform, cThickness] =
-      ActsPlugins::TGeoSurfaceConverter::cylinderComponents(
-          shape, rotation, translation, axes, lengthScale);
-  if (cBounds != nullptr) {
-    return cTransform;
-  }
-
-  auto [dBounds, dTransform, dThickness] = TGeoSurfaceConverter::discComponents(
-      shape, rotation, translation, axes, lengthScale);
-  if (dBounds != nullptr) {
-    return dTransform;
-  }
-
-  auto [pBounds, pTransform, pThickness] =
-      TGeoSurfaceConverter::planeComponents(shape, rotation, translation, axes,
-                                            lengthScale);
-  if (pBounds != nullptr) {
-    return pTransform;
-  }
-
-  throw std::runtime_error(
-      "Could not extract transform from TGeoShape of type " +
-      std::string(shape.ClassName()));
-}
-
-}  // namespace
-
 std::shared_ptr<Acts::Experimental::LayerBlueprintNode>
 DD4hepBackend::makeLayer(const dd4hep::DetElement& parent,
                          std::span<const dd4hep::DetElement> sensitives,
@@ -172,10 +138,10 @@ DD4hepBackend::makeLayer(const dd4hep::DetElement& parent,
   if (layerSpec.layerAxes.has_value()) {
     ACTS_DEBUG("Finding layer transform automatically using layer axes: "
                << layerSpec.layerAxes.value());
-    Acts::Transform3 layerTransform =
-        convertTGeoTransform(*parent.placement().ptr()->GetVolume()->GetShape(),
-                             parent.nominal().worldTransformation(),
-                             layerSpec.layerAxes.value(), m_cfg.lengthScale);
+    Acts::Transform3 layerTransform = TGeoSurfaceConverter::transformFromShape(
+        *parent.placement().ptr()->GetVolume()->GetShape(),
+        parent.nominal().worldTransformation(), layerSpec.layerAxes.value(),
+        m_cfg.lengthScale);
 
     ACTS_VERBOSE(" -> Layer transform:\n" << layerTransform.matrix());
     node->setTransform(layerTransform);

Plugins/Root/include/ActsPlugins/Root/TGeoSurfaceConverter.hpp

@@ -98,6 +98,20 @@ struct TGeoSurfaceConverter {
       const TGeoShape& tgShape, const TGeoMatrix& tgMatrix, TGeoAxes axes,
       double scalor = 10.) noexcept(false);
 
+  /// Extract the transform from a TGeoShape by trying cylinder, disc, then
+  /// plane conversion.
+  ///
+  /// @param tgShape The TGeoShape
+  /// @param tgMatrix The matrix representing the transform
+  /// @param axes The axes definition
+  /// @param scalor The unit scalor between TGeo and Acts
+  /// @return The Acts transform
+  /// @throws std::runtime_error if the shape cannot be converted
+  static Acts::Transform3 transformFromShape(const TGeoShape& tgShape,
+                                             const TGeoMatrix& tgMatrix,
+                                             TGeoAxes axes,
+                                             double scalor = 10.) noexcept(false);
+
   /// Translate TGeo degree [0, 360) to radian
   /// * will correct to [-pi,pi)
   /// * it will return any multiple of 360.0 to 2pi

Plugins/Root/src/TGeoSurfaceConverter.cpp

@@ -484,3 +484,32 @@ ActsPlugins::TGeoSurfaceConverter::toSurface(const TGeoShape& tgShape,
 
   return {nullptr, 0.};
 }
+
+Acts::Transform3 ActsPlugins::TGeoSurfaceConverter::transformFromShape(
+    const TGeoShape& tgShape, const TGeoMatrix& tgMatrix, TGeoAxes axes,
+    double scalor) noexcept(false) {
+  const Double_t* rotation = tgMatrix.GetRotationMatrix();
+  const Double_t* translation = tgMatrix.GetTranslation();
+
+  auto [cBounds, cTransform, cThickness] =
+      cylinderComponents(tgShape, rotation, translation, axes, scalor);
+  if (cBounds != nullptr) {
+    return cTransform;
+  }
+
+  auto [dBounds, dTransform, dThickness] =
+      discComponents(tgShape, rotation, translation, axes, scalor);
+  if (dBounds != nullptr) {
+    return dTransform;
+  }
+
+  auto [pBounds, pTransform, pThickness] =
+      planeComponents(tgShape, rotation, translation, axes, scalor);
+  if (pBounds != nullptr) {
+    return pTransform;
+  }
+
+  throw std::runtime_error(
+      "Could not extract transform from TGeoShape of type " +
+      std::string(tgShape.ClassName()));
+}