DD4hepDetectorSurfaceFactory.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file DD4hepDetectorSurfaceFactory.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2023 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 http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Definitions/Common.hpp"
#include "Acts/Definitions/Units.hpp"
#include "Acts/Detector/LayerStructureBuilder.hpp"
#include "Acts/Detector/ProtoBinning.hpp"
#include "Acts/Surfaces/Surface.hpp"

#include <tuple>
#include <vector>

#include <DD4hep/DD4hepUnits.h>

class TGeoMatrix;

namespace dd4hep {
class DetElement;
}

namespace Acts {

using namespace UnitLiterals;

class DD4hepDetectorElement;

class DD4hepDetectorSurfaceFactory {
 public:
  using DD4hepSensitiveSurface =
      std::tuple<std::shared_ptr<DD4hepDetectorElement>,
                 std::shared_ptr<Surface>>;

  using DD4hepPassiveSurface = std::tuple<std::shared_ptr<Surface>, bool>;

  struct Cache {
    std::vector<DD4hepSensitiveSurface> sensitiveSurfaces;
    std::vector<DD4hepPassiveSurface> passiveSurfaces;
    std::size_t convertedSurfaces = 0;
    std::size_t convertedMaterials = 0;
    std::vector<Experimental::ProtoBinning> binnings = {};
    std::vector<Experimental::ProtoSupport> supports = {};
  };

  struct Options {
    bool convertSensitive = true;
    bool convertPassive = true;
    bool convertMaterial = true;
    bool convertProxyMaterial = true;
    ActsScalar surfaceMaterialThickness = 1_mm;
  };

  DD4hepDetectorSurfaceFactory(
      std::unique_ptr<const Logger> mlogger = getDefaultLogger(
          "DD4hepDetectorSurfaceFactory", Acts::Logging::INFO));

  void construct(Cache& cache, const dd4hep::DetElement& dd4hepElement,
                 const Options& options);

 private:
  static constexpr ActsScalar unitLength =
      Acts::UnitConstants::mm / dd4hep::millimeter;

  std::unique_ptr<const Logger> m_logger;

  const Logger& logger() const { return *m_logger; }

  void recursiveConstruct(Cache& cache, const dd4hep::DetElement& dd4hepElement,
                          const Options& options, int level);

  DD4hepSensitiveSurface constructSensitiveComponents(
      const dd4hep::DetElement& dd4hepElement, const Options& options) const;

  DD4hepPassiveSurface constructPassiveComponents(
      const dd4hep::DetElement& dd4hepElement, const Options& options) const;

  void attachSurfaceMaterial(const dd4hep::DetElement& dd4hepElement,
                             Acts::Surface& surface, ActsScalar thickness,
                             const Options& options) const;
};

}  // namespace Acts