ActsLayerBuilder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ACTSGEOMETRY_ACTSLAYERBUILDER_H
#define ACTSGEOMETRY_ACTSLAYERBUILDER_H
 
// PACKAGE
#include "ActsGeometry/ActsDetectorElement.h"
#include "ActsGeometry/ActsElementVector.h"
 
// ATHENA
#include "CxxUtils/checker_macros.h"
 
// ACTS
#include "Acts/Geometry/ILayerBuilder.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "Acts/Utilities/BinningType.hpp"
 
 
#include <mutex>
#include <array>
#include <iosfwd>
#include <vector>
#include <memory>
#include <utility>
#include <functional>
 
class ActsTrackingGeomtrySvc;
 
namespace InDetDD {
  class SiDetectorManager;
}
 
namespace Acts {
class Surface;
class LayerCreator;
class GeometryContext;
}

class ActsLayerBuilder : public Acts::ILayerBuilder
{
public:
  enum class Mode {
    Undefined, Pixel, SCT, TRT, ITkPixelInner, ITkPixelOuter, ITkStrip,
  };
 
  using ElementVector = ActsElementVector;

 
  struct Config
  {
    std::string                          configurationName = "undefined";
    Mode mode = Mode::Undefined;
    const InDetDD::SiDetectorManager*   mng{};
    std::shared_ptr<const Acts::LayerCreator> layerCreator = nullptr;
    Acts::BinningType bTypePhi = Acts::equidistant;
    Acts::BinningType bTypeR = Acts::equidistant;
    Acts::BinningType                    bTypeZ = Acts::equidistant;
    std::shared_ptr<ElementVector> elementStore;
 
    std::array<double, 2> endcapEnvelopeR = {2 * Acts::UnitConstants::mm,
                         2 * Acts::UnitConstants::mm};
    std::array<double, 2> endcapEnvelopeZ = {2 * Acts::UnitConstants::mm,
                         2 * Acts::UnitConstants::mm};
    
    std::array<double, 2> barrelEnvelopeR = {2 * Acts::UnitConstants::mm,
                         2 * Acts::UnitConstants::mm};
    std::array<double, 2> barrelEnvelopeZ = {2 * Acts::UnitConstants::mm,
                         2 * Acts::UnitConstants::mm};

    std::vector<float> passiveBarrelLayerRadii = {};
    std::vector<float> passiveBarrelLayerHalflengthZ = {};
    std::vector<float> passiveBarrelLayerThickness = {};
    
    std::pair<size_t, size_t> endcapMaterialBins = {20, 5};
    std::pair<size_t, size_t> barrelMaterialBins = {10, 10};
 
    std::function<bool(const Acts::GeometryContext &, Acts::AxisDirection,
                       const Acts::Surface *, const Acts::Surface *)>
        surfaceMatcher;
 
    bool doEndcapLayerMerging = true;
 
    bool objDebugOutput = false;

    double numberOfBinsFactor = 5.0;

    double numberOfInnermostLayerBinsFactor = 2.0;
    
  };

  ActsLayerBuilder(const Config&                cfg,
                       std::unique_ptr<const Acts::Logger> logger
                       = Acts::getDefaultLogger("GMLayBldr", Acts::Logging::INFO));

  ~ActsLayerBuilder() {}
 
  const Acts::LayerVector
  negativeLayers(const Acts::GeometryContext& gctx) const override;
 
  const Acts::LayerVector
  centralLayers(const Acts::GeometryContext& gctx) const override;
 
  const Acts::LayerVector
  positiveLayers(const Acts::GeometryContext& gctx) const override;
 

  // const std::string&
  // identification() const final;

  void
  setConfiguration(const Config& cfg);

  // Config
  // getConfiguration() const;
 
  const ActsLayerBuilder::Config&
  getConfiguration() const
  {
    return m_cfg;
  }
 
  virtual
  const std::string&
  identification() const override
  {
    return m_cfg.configurationName;
  }

  void
  setLogger(std::unique_ptr<const Acts::Logger> logger);
 
private:
  Config m_cfg;

  const Acts::Logger&
  logger() const
  {
    return *m_logger;
  }
 
  std::vector<std::shared_ptr<const ActsDetectorElement>>
  getDetectorElements() const;

  std::unique_ptr<const Acts::Logger> m_logger;

  //std::vector<std::shared_ptr<const ActsDetectorElement>> m_elementStore;
 
 
  // Private helper method : build layers
  // @param layers is goint to be filled
  // @param type is the indication which ones to build -1 | 0 | 1
  void
  buildBarrel(const Acts::GeometryContext& gctx, Acts::LayerVector& layersOutput) const;
 
  void
  buildEndcap(const Acts::GeometryContext& gctx, Acts::LayerVector& layersOutput, int type = 0) const;
 
};
 
std::ostream& operator<<(std::ostream& os, const ActsLayerBuilder::Mode& mode);
 
#endif