EIC code displayed by LXR master/​include/​ActsPlugins/​DD4hep/​DD4hepDetectorSurfaceFactory.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-11 09:40:21

 // This file is part of the ACTS project.
 //
 // Copyright (C) 2016 CERN for the benefit of the ACTS project
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 #pragma once
 
 #include "Acts/Definitions/Units.hpp"
 #include "Acts/Detector/ProtoSupport.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/Logger.hpp"
 #include "Acts/Utilities/ProtoAxis.hpp"
 
 #include <tuple>
 #include <vector>
 
 #include <DD4hep/DD4hepUnits.h>
 
 class TGeoMatrix;
 
 namespace dd4hep {
 class DetElement;
 }
 
 namespace Acts {
 
 class ISurfaceMaterial;
 
 }  // namespace Acts
 
 namespace ActsPlugins {
 class DD4hepDetectorElement;
 
 /// A factory to convert DD4hep DetectorElements into sensitive
 /// of passive surfaces which are filled into a Cache object,
 /// also the create DD4hepDetector elements are provided
 ///
 class DD4hepDetectorSurfaceFactory {
  public:
   /// DD4hepDetectorElement construction factory
   using ElementFactory = std::function<std::shared_ptr<DD4hepDetectorElement>(
       const dd4hep::DetElement&, const std::string&, double, bool,
       std::shared_ptr<const Acts::ISurfaceMaterial>)>;
 
   /// Collect the sensitive surface & detector element
   using DD4hepSensitiveSurface =
       std::tuple<std::shared_ptr<DD4hepDetectorElement>,
                  std::shared_ptr<Acts::Surface>>;
 
   /// Collect the passive surfaces, bool whether it should be
   /// added as an "always try, i.e. assignToAll=true" surface
   using DD4hepPassiveSurface = std::tuple<std::shared_ptr<Acts::Surface>, bool>;
 
   /// Configuration struct
   struct Config {
     /// The factory to create the DD4hepDetectorElement
     ElementFactory detectorElementFactory =
         [](const dd4hep::DetElement& detElem, const std::string& axes,
            double scalor, bool isDisc,
            const std::shared_ptr<const Acts::ISurfaceMaterial>& material) {
           return std::make_shared<DD4hepDetectorElement>(detElem, axes, scalor,
                                                          isDisc, material);
         };
   };
 
   /// Nested cache that records the conversion status
   struct Cache {
     /// The created detector elements - for the detector store
     std::vector<DD4hepSensitiveSurface> sensitiveSurfaces;
     /// The created non-const surfaces - for further processing,
     std::vector<DD4hepPassiveSurface> passiveSurfaces;
     /// matching and conversion statistics: surfaces
     std::size_t convertedSurfaces = 0;
     /// matching and conversion statistics: materials
     std::size_t convertedMaterials = 0;
     /// The collected binnings
     std::vector<std::tuple<Acts::DirectedProtoAxis, std::size_t>> binnings = {};
     /// The collected supports
     std::vector<Acts::Experimental::ProtoSupport> supports = {};
     /// Optionally provide an Extent object to measure the sensitives
     std::optional<Acts::Extent> sExtent = std::nullopt;
     /// Optionally provide an Extent object to measure the passive
     std::optional<Acts::Extent> pExtent = std::nullopt;
     /// Optionally provide an Extent constraints to measure the layers
     std::vector<Acts::AxisDirection> extentConstraints = {};
     /// The approximination of a circle quarter for extent measuring
     std::size_t nExtentQSegments = 1u;
   };
 
   /// Nested options struct to steer the conversion
   struct Options {
     /// Convert sensitive surfaces
     bool convertSensitive = true;
     /// Convert passive surfaces
     bool convertPassive = true;
     /// Convert material directly
     bool convertMaterial = false;
     /// New reference material thickness for surfaces
     double surfaceMaterialThickness = 1 * Acts::UnitConstants::mm;
   };
 
   /// The DD4hep detector element factory
   ///
   /// @param config the configuration struct
   /// @param mlogger a screen output logger
   explicit DD4hepDetectorSurfaceFactory(
       const Config& config,
       std::unique_ptr<const Acts::Logger> mlogger = Acts::getDefaultLogger(
           "DD4hepDetectorSurfaceFactory", Acts::Logging::INFO));
 
   /// Construction method of the detector elements
   ///
   /// @param cache [in,out] into which the Elements are filled
   /// @param gctx the geometry context
   /// @param dd4hepElement the detector element representing the super structure
   /// @param options to steer the conversion
   ///
   /// @note this method will call the recursive construction
   void construct(Cache& cache, const Acts::GeometryContext& gctx,
                  const dd4hep::DetElement& dd4hepElement,
                  const Options& options);
 
  private:
   /// Auto-calculate the unit length conversion
   static constexpr double unitLength =
       Acts::UnitConstants::mm / dd4hep::millimeter;
 
   /// The configuration of the factory
   Config m_config;
 
   /// Logging instance
   std::unique_ptr<const Acts::Logger> m_logger;
 
   /// Private access to the logger
   const Acts::Logger& logger() const { return *m_logger; }
 
   /// Construction method of the detector elements - recursive walk down
   ///
   /// @param cache [in,out] into which the Elements are filled
   /// @param gctx the geometry context
   /// @param dd4hepElement the detector element representing the super structure
   /// @param options to steer the conversion
   /// @param level the current level of the tree, used for log message output
   ///
   /// @note this method is called recursively
   void recursiveConstruct(Cache& cache, const Acts::GeometryContext& gctx,
                           const dd4hep::DetElement& dd4hepElement,
                           const Options& options, int level);
 
   /// Method to convert a single sensitive detector element
   ///
   /// @param cache [in,out] into which the Elements are filled
   /// @param gctx the geometry context
   /// @param dd4hepElement the detector element
   /// @param options to steer the conversion
   ///
   /// @note the cache is handed through in order to optionally measure the
   /// extent of the sensitive surface and register it
   ///
   /// @return a created detector element and surface
   DD4hepSensitiveSurface constructSensitiveComponents(
       Cache& cache, const Acts::GeometryContext& gctx,
       const dd4hep::DetElement& dd4hepElement, const Options& options) const;
 
   /// Method to convert a single sensitive detector element
   ///
   /// @param cache [in,out] into which the Elements are filled
   /// @param gctx the geometry context
   /// @param dd4hepElement the detector element
   /// @param options to steer the conversion
   ///
   /// @return a created surface
   DD4hepPassiveSurface constructPassiveComponents(
       Cache& cache, const Acts::GeometryContext& gctx,
       const dd4hep::DetElement& dd4hepElement, const Options& options) const;
 
   /// Attach surface material if present
   ///
   /// @param gctx the geometry context
   /// @param prefix the acts prefix for the variant parameter string
   /// @param dd4hepElement the detector element
   /// @param surface the surface to attach the material to
   /// @param thickness the thickness of the condensed component
   /// @param options to steer the conversion
   ///
   /// @note the cache is handed through in order to optionally measure the
   /// extent of the sensitive surface and register it
   ///
   /// @note void function that also checks the options if the attachment should be applied
   void attachSurfaceMaterial(const Acts::GeometryContext& gctx,
                              const std::string& prefix,
                              const dd4hep::DetElement& dd4hepElement,
                              Acts::Surface& surface, double thickness,
                              const Options& options) const;
 };
 
 }  // namespace ActsPlugins

This page was automatically generated by the 2.3.7 LXR engine. The LXR team