ActsLayerBuilder Class Reference

#include <ActsLayerBuilder.h>

Inheritance diagram for ActsLayerBuilder:

Collaboration diagram for ActsLayerBuilder:

Classes
struct	Config

Public Types
enum	Mode {   Mode::Undefined, Mode::Pixel, Mode::SCT, Mode::TRT,   Mode::ITkPixelInner, Mode::ITkPixelOuter, Mode::ITkStrip }
using	ElementVector = ActsElementVector

Public Member Functions
	ActsLayerBuilder (const Config &cfg, std::unique_ptr< const Acts::Logger > logger=Acts::getDefaultLogger("GMLayBldr", Acts::Logging::INFO))
	Constructor. More...
	~ActsLayerBuilder ()
	Destructor. More...
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
void	setConfiguration (const Config &cfg)
	Name identification. More...
ActsLayerBuilder::Config	getConfiguration () const
	get the configuration object More...
virtual const std::string &	identification () const override
void	setLogger (std::unique_ptr< const Acts::Logger > logger)
	set logging instance More...

Private Member Functions
const Acts::Logger &	logger () const
	Private access to the logger. More...
std::vector< std::shared_ptr< const ActsDetectorElement > >	getDetectorElements () const
void	buildBarrel (const Acts::GeometryContext &gctx, Acts::LayerVector &layersOutput) const
void	buildEndcap (const Acts::GeometryContext &gctx, Acts::LayerVector &layersOutput, int type=0) const

Private Attributes
Config	m_cfg
	configuration object More...
std::unique_ptr< const Acts::Logger >	m_logger
	logging instance More...

Detailed Description

Definition at line 37 of file ActsLayerBuilder.h.

Member Typedef Documentation

ElementVector

using ActsLayerBuilder::ElementVector = ActsElementVector

Definition at line 44 of file ActsLayerBuilder.h.

Member Enumeration Documentation

Mode

enum ActsLayerBuilder::Mode

strong

Enumerator
Undefined
Pixel
SCT
TRT
ITkPixelInner
ITkPixelOuter
ITkStrip

Definition at line 40 of file ActsLayerBuilder.h.

                  {
    Undefined, Pixel, SCT, TRT, ITkPixelInner, ITkPixelOuter, ITkStrip,
  };

Constructor & Destructor Documentation

ActsLayerBuilder()

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

Constructor.

Parameters

cfg	is the configuration struct
logger	the local logging instance

Definition at line 40 of file ActsLayerBuilder.cxx.

  : m_cfg (cfg),
    m_logger(std::move(logger))
{
  if(m_cfg.mode == Mode::Undefined) {
    throw std::invalid_argument("ALB mode is undefined");
  }
}

~ActsLayerBuilder()

ActsLayerBuilder::~ActsLayerBuilder ( )

inline

Destructor.

Definition at line 97 of file ActsLayerBuilder.h.

{}

Member Function Documentation

buildBarrel()

void ActsLayerBuilder::buildBarrel ( const Acts::GeometryContext &  gctx, Acts::LayerVector &  layersOutput  ) const

private

Definition at line 106 of file ActsLayerBuilder.cxx.

                                                                        {
 
  ACTS_VERBOSE("Build layers: BARREL");
  std::vector<std::shared_ptr<const ActsDetectorElement>> elements =
      getDetectorElements();
 
  std::map<int, std::vector<std::shared_ptr<const Acts::Surface>>> layers{};
 
  for (const auto &element : elements) {
 
    IdentityHelper id = element->identityHelper();
    if (id.bec() != 0)
      continue;
 
    if(m_cfg.mode == Mode::ITkPixelInner) {
      if(id.layer_disk() >= 2) continue;
    }
    if(m_cfg.mode == Mode::ITkPixelOuter) {
      if(id.layer_disk() <= 1) continue;
    }
 
    m_cfg.elementStore->push_back(element);
 
    int elementLayer;
    elementLayer = id.layer_disk();
 
    layers[elementLayer].push_back(element->surface().getSharedPtr());
  }
 
 
  if (m_cfg.objDebugOutput) {
    std::string lab;
    for (auto &[key, layerSurfaces] : layers) {
 
      std::stringstream name;
 
 
 
      name << "obj/" << m_cfg.mode << "_brl_" << std::setfill('0') << std::setw(2)
          << std::to_string(key) + "_bec"
          << ".obj";
 
      std::ofstream ofs{name.str()};
      Acts::ObjVisualization3D vis{};
      Acts::ViewConfig vc = Acts::s_viewSensitive;
      vc.quarterSegments = 200;
      for (const auto &surface : layerSurfaces) {
        Acts::GeometryView3D::drawSurface(vis, *surface, gctx,
                                          Acts::Transform3::Identity(), vc);
      }
 
      vis.write(ofs);
    }
  }
 
  ACTS_VERBOSE("Found " << layers.size() << " barrel layers");
  // pre loop for more concise output. only do if we actually print it
  if (logger().doPrint(Acts::Logging::VERBOSE)) {
    size_t n = 1;
    for (const auto &[key, surfaces] : layers) {
      Acts::ProtoLayer pl(gctx, surfaces);
      ACTS_VERBOSE("Layer #" << n << " with layerKey: (" << key << ")");
      ACTS_VERBOSE(" -> at rMin / rMax: " << pl.min(Acts::BinningValue::binR) << " / "
                                          << pl.max(Acts::BinningValue::binR));
      ACTS_VERBOSE("    -> at zMin / zMax: " << pl.min(Acts::BinningValue::binZ) << " / "
                                             << pl.max(Acts::BinningValue::binZ));
 
      n++;
    }
  }
 
  for (const auto &[key, surfaces] : layers) {
 
    std::unique_ptr<Acts::ApproachDescriptor> approachDescriptor = nullptr;
    std::shared_ptr<const Acts::ProtoSurfaceMaterial> materialProxy = nullptr;
 
    // layers and extent are determined, build actual layer
    Acts::ProtoLayer pl(gctx, surfaces);
    pl.envelope[Acts::BinningValue::binR] = m_cfg.barrelEnvelopeR;
    pl.envelope[Acts::BinningValue::binZ] = m_cfg.barrelEnvelopeZ;
 
    double layerZ = pl.medium(Acts::BinningValue::binZ, true);
    double layerHalfZ = 0.5 * pl.range(Acts::BinningValue::binZ);
 
    Acts::Transform3 transform(Translation3(0., 0., -layerZ));
    // set up approach descriptor
 
    std::shared_ptr<Acts::CylinderSurface> innerBoundary =
        Acts::Surface::makeShared<Acts::CylinderSurface>(
            transform, pl.min(Acts::BinningValue::binR), layerHalfZ);
 
    std::shared_ptr<Acts::CylinderSurface> outerBoundary =
        Acts::Surface::makeShared<Acts::CylinderSurface>(
            transform, pl.max(Acts::BinningValue::binR), layerHalfZ);
 
    std::shared_ptr<Acts::CylinderSurface> centralSurface =
        Acts::Surface::makeShared<Acts::CylinderSurface>(
            transform, (pl.min(Acts::BinningValue::binR) + pl.max(Acts::BinningValue::binR)) / 2.,
            layerHalfZ);
 
    size_t binsPhi = m_cfg.barrelMaterialBins.first;
    size_t binsZ = m_cfg.barrelMaterialBins.second;
 
    Acts::BinUtility materialBinUtil(binsPhi, -M_PI, M_PI, Acts::closed,
                                     Acts::BinningValue::binPhi);
    materialBinUtil += Acts::BinUtility(binsZ, -layerHalfZ, layerHalfZ,
                                        Acts::open, Acts::BinningValue::binZ, transform);
 
    materialProxy =
        std::make_shared<const Acts::ProtoSurfaceMaterial>(materialBinUtil);
 
    ACTS_VERBOSE("[L] Layer is marked to carry support material on Surface ( "
                 "inner=0 / center=1 / outer=2 ) : "
                 << "inner");
    ACTS_VERBOSE("with binning: [" << binsPhi << ", " << binsZ << "]");
 
    ACTS_VERBOSE("Created ApproachSurfaces for cylinder layer at:");
    ACTS_VERBOSE(" - inner:   R=" << pl.min(Acts::BinningValue::binR));
    ACTS_VERBOSE(" - central: R=" << (pl.min(Acts::BinningValue::binR) + pl.max(Acts::BinningValue::binR)) /
                                         2.);
    ACTS_VERBOSE(" - outer:   R=" << pl.max(Acts::BinningValue::binR));
 
    // set material on inner
    innerBoundary->assignSurfaceMaterial(materialProxy);
 
    std::vector<std::shared_ptr<const Acts::Surface>> aSurfaces;
    aSurfaces.push_back(std::move(innerBoundary));
    aSurfaces.push_back(std::move(centralSurface));
    aSurfaces.push_back(std::move(outerBoundary));
 
    approachDescriptor =
        std::make_unique<Acts::GenericApproachDescriptor>(std::move(aSurfaces));
 
    // count the number of relevant modules in each direction
    auto phiEqual = [this](const Acts::Surface &a,
                           const Acts::Surface &b) {
      Acts::GeometryContext gctx; // unused in matcher
      Acts::BinningValue bv = Acts::BinningValue::binPhi;
      return m_cfg.surfaceMatcher(gctx, bv, &a, &b);
    };
 
    auto zEqual = [this](const Acts::Surface &a,
                         const Acts::Surface &b) {
      Acts::GeometryContext gctx; // unused in matcher
      Acts::BinningValue bv = Acts::BinningValue::binZ;
      return m_cfg.surfaceMatcher(gctx, bv, &a, &b);
    };
 
    // Work around issue with clang10 --- it doesn't allow
    // listing surfaces directly in the capture list.
    auto& xsurfaces = surfaces;
    auto countKey = [&xsurfaces](auto equal) -> size_t {
      std::vector<const Acts::Surface *> keySurfaces;
      for (const auto &surface : xsurfaces) {
        bool exists = false;
        for (const auto* existing : keySurfaces) {
          if (equal(*surface, *existing)) {
            exists = true;
            break;
          }
        }
        if (!exists) {
          keySurfaces.push_back(surface.get());
        }
      }
      return keySurfaces.size();
    };
 
    size_t nModPhi = countKey(phiEqual);
    size_t nModZ = countKey(zEqual);
 
    ACTS_VERBOSE("Found " << nModPhi << " modules in phi " << nModZ
                          << " modules in z");
 
    std::shared_ptr<Acts::Layer> layer;
    if (m_cfg.mode == Mode::ITkStrip) {
      double f = 1.0;
      if (key <= 1) {
        f = 4.0; // four rows per module
      } else {
        f = 2.0; // two rows per module
      }
      size_t nBinsPhi = nModPhi / f;
      size_t nBinsZ = nModZ / f;
      layer = m_cfg.layerCreator->cylinderLayer(gctx, surfaces, nBinsPhi,
                                                nBinsZ, pl, transform,
                                                std::move(approachDescriptor));
    } else if (m_cfg.mode == Mode::ITkPixelInner ||
               m_cfg.mode == Mode::ITkPixelOuter) {
      double f = 1.0;
      if (key == 0) {
        f = 2.0;
      }
      size_t nBinsPhi = nModPhi / f;
      size_t nBinsZ = nModZ / f;
      layer = m_cfg.layerCreator->cylinderLayer(gctx, surfaces, nBinsPhi,
                                                nBinsZ, pl, transform,
                                                std::move(approachDescriptor));
    } else {
      layer = m_cfg.layerCreator->cylinderLayer(
          gctx, surfaces, Acts::equidistant, Acts::equidistant, pl, transform,
          std::move(approachDescriptor));
    }
 
    layersOutput.push_back(layer);
  }
}

buildEndcap()

void ActsLayerBuilder::buildEndcap ( const Acts::GeometryContext &  gctx, Acts::LayerVector &  layersOutput, int  type = 0  ) const

private

Definition at line 315 of file ActsLayerBuilder.cxx.

{
 
  ACTS_VERBOSE("Build layers: " << (type < 0 ? "NEGATIVE" : "POSITIVE")
                                << " ENDCAP");
  std::vector<std::shared_ptr<const ActsDetectorElement>> elements =
      getDetectorElements();
  std::map<std::tuple<int, int, int>, std::vector<const Acts::Surface *>>
      initialLayers{};
 
  for (const auto &element : elements) {
 
    IdentityHelper id = element->identityHelper();
    if (id.bec() * type <= 0) {
      continue;
    }
 
    if(m_cfg.mode == Mode::ITkPixelInner) {
      if(id.layer_disk() >= 3) continue;
    }
    if(m_cfg.mode == Mode::ITkPixelOuter) {
      if(id.layer_disk() <= 2) continue;
    }
 
    m_cfg.elementStore->push_back(element);
 
    std::tuple<int, int, int> key{id.bec(), id.layer_disk(), id.eta_module()};
 
    initialLayers[key].push_back(&element->surface());
  }
 
  ACTS_VERBOSE("Found " << initialLayers.size() << " "
                        << (type < 0 ? "NEGATIVE" : "POSITIVE")
                        << " ENDCAP inital layers");
 
  std::vector<Acts::ProtoLayer> protoLayers;
  protoLayers.reserve(initialLayers.size());
 
  for (const auto &[key, surfaces] : initialLayers) {
    auto &pl = protoLayers.emplace_back(gctx, surfaces);
    pl.envelope[Acts::BinningValue::binR] = m_cfg.endcapEnvelopeR;
    pl.envelope[Acts::BinningValue::binZ] = m_cfg.endcapEnvelopeZ;
  }
 
  // sort proto layers by their medium z position
  std::sort(protoLayers.begin(), protoLayers.end(),
            [type](const Acts::ProtoLayer &a, const Acts::ProtoLayer &b) {
              double midA = (a.min(Acts::BinningValue::binZ) + a.max(Acts::BinningValue::binZ)) / 2.0;
              double midB = (b.min(Acts::BinningValue::binZ) + b.max(Acts::BinningValue::binZ)) / 2.0;
              if (type < 0) {
                return midA < midB;
              } else {
                return midA > midB;
              }
            });
 
  auto plPrintZ = [](const auto &pl) -> std::string {
    std::stringstream ss;
    double zMid = (pl.min(Acts::BinningValue::binZ) + pl.max(Acts::BinningValue::binZ)) / 2.0;
    ss << " < " << pl.min(Acts::BinningValue::binZ) << " | " << zMid << " | "
       << pl.max(Acts::BinningValue::binZ) << " > ";
    return ss.str();
  };
  if (logger().doPrint(Acts::Logging::VERBOSE)) {
    for (const auto &pl : protoLayers) {
 
      ACTS_VERBOSE(" -> at < zMin | zMid | zMax >: " << plPrintZ(pl));
 
      ACTS_VERBOSE("    -> at rMin / rMax: " << pl.min(Acts::BinningValue::binR) << " / "
                                             << pl.max(Acts::BinningValue::binR));
    }
  }
 
  std::vector<Acts::ProtoLayer> mergedProtoLayers;
 
  if (m_cfg.doEndcapLayerMerging) {
    mergedProtoLayers.push_back(protoLayers.front());
    std::vector<const Acts::Surface *> surfaces;
    for (size_t i = 1; i < protoLayers.size(); i++) {
      auto &pl = protoLayers[i];
      auto &pl_prev = mergedProtoLayers.back();
      // do they intersect?
      ACTS_VERBOSE("Compare: " << plPrintZ(pl_prev) << " and " << plPrintZ(pl));
      bool overlap = (pl.min(Acts::BinningValue::binZ) <= pl_prev.max(Acts::BinningValue::binZ) &&
                      pl.max(Acts::BinningValue::binZ) >= pl_prev.min(Acts::BinningValue::binZ));
      ACTS_VERBOSE(" -> overlap? " << (overlap ? "yes" : "no"));
      if (overlap) {
        ACTS_VERBOSE(" ===> merging");
        surfaces.clear();
        surfaces.reserve(pl.surfaces().size() + pl_prev.surfaces().size());
        surfaces.insert(surfaces.end(), pl.surfaces().begin(),
                        pl.surfaces().end());
        surfaces.insert(surfaces.end(), pl_prev.surfaces().begin(),
                        pl_prev.surfaces().end());
        mergedProtoLayers.pop_back();
        auto &new_pl =
            mergedProtoLayers.emplace_back(gctx, std::move(surfaces));
        new_pl.envelope[Acts::BinningValue::binR] = pl.envelope[Acts::BinningValue::binR];
        new_pl.envelope[Acts::BinningValue::binZ] = pl.envelope[Acts::BinningValue::binZ];
      } else {
        mergedProtoLayers.push_back(std::move(pl));
      }
    }
 
    ACTS_VERBOSE("" << mergedProtoLayers.size() << " "
                    << (type < 0 ? "NEGATIVE" : "POSITIVE")
                    << " ENDCAP layers remain after merging");
  } else {
    mergedProtoLayers = protoLayers;
  }
 
  if (m_cfg.objDebugOutput) {
    for (size_t i = 0; i < mergedProtoLayers.size(); i++) {
 
      std::stringstream ss;
      ss << "obj/" << m_cfg.mode << "_" << (type < 0 ? "neg" : "pos")
         << "_disk_" << std::setfill('0') << std::setw(2) << i << ".obj";
 
      std::ofstream ofs{ss.str()};
      Acts::ObjVisualization3D vis{};
      Acts::ViewConfig vc = Acts::s_viewSensitive;
      vc.quarterSegments = 200;
      for (const auto &surface : mergedProtoLayers[i].surfaces()) {
        Acts::GeometryView3D::drawSurface(vis, *surface, gctx,
                                          Acts::Transform3::Identity(), vc);
      }
 
      vis.write(ofs);
    }
  }
 
  std::vector<std::shared_ptr<const Surface>> ownedSurfaces;
  for (const auto &pl : mergedProtoLayers) {
 
    std::unique_ptr<Acts::ApproachDescriptor> approachDescriptor = nullptr;
    std::shared_ptr<const Acts::ProtoSurfaceMaterial> materialProxy = nullptr;
 
    double layerZ = pl.medium(Acts::BinningValue::binZ);
    double layerHalfZ = 0.5 * pl.range(Acts::BinningValue::binZ);
    double layerThickness = pl.range(Acts::BinningValue::binZ);
 
    double layerZInner = layerZ - layerHalfZ;
    double layerZOuter = layerZ + layerHalfZ;
 
    if (std::abs(layerZInner) > std::abs(layerZOuter))
      std::swap(layerZInner, layerZOuter);
 
    std::vector<std::shared_ptr<const Acts::Surface>> aSurfaces;
 
    Acts::Transform3 transformNominal(Translation3(0., 0., layerZ));
    Acts::Transform3 transformInner(Translation3(0., 0., layerZInner));
    Acts::Transform3 transformOuter(Translation3(0., 0., layerZOuter));
 
    std::shared_ptr<Acts::DiscSurface> innerBoundary =
      Acts::Surface::makeShared<Acts::DiscSurface>(
        transformInner, pl.min(Acts::BinningValue::binR), pl.max(Acts::BinningValue::binR));
    aSurfaces.push_back(innerBoundary);
 
    std::shared_ptr<Acts::DiscSurface> nominalSurface =
      Acts::Surface::makeShared<Acts::DiscSurface>(
        transformNominal, pl.min(Acts::BinningValue::binR), pl.max(Acts::BinningValue::binR));
    aSurfaces.push_back(nominalSurface);
 
    std::shared_ptr<Acts::DiscSurface> outerBoundary =
      Acts::Surface::makeShared<Acts::DiscSurface>(
        transformOuter, pl.min(Acts::BinningValue::binR), pl.max(Acts::BinningValue::binR));
    aSurfaces.push_back(outerBoundary);
 
    if(layerThickness > 2_mm) {
      ACTS_VERBOSE("Wide disc layer ("<< layerThickness << ") => adding cylinder like approach surfaces");
      Acts::Transform3 trf{Translation3{0, 0, layerZ}};
      auto cylinderInner = 
        Acts::Surface::makeShared<Acts::CylinderSurface>(
          trf, pl.min(Acts::BinningValue::binR), layerHalfZ);
        aSurfaces.push_back(cylinderInner);
 
      auto cylinderOuter = 
        Acts::Surface::makeShared<Acts::CylinderSurface>(
          trf, pl.max(Acts::BinningValue::binR), layerHalfZ);
        aSurfaces.push_back(cylinderOuter);
    }
 
 
    size_t matBinsPhi = m_cfg.endcapMaterialBins.first;
    size_t matBinsR = m_cfg.endcapMaterialBins.second;
 
    Acts::BinUtility materialBinUtil(matBinsPhi, -M_PI, M_PI, Acts::closed,
                                     Acts::BinningValue::binPhi);
    materialBinUtil +=
        Acts::BinUtility(matBinsR, pl.min(Acts::BinningValue::binR), pl.max(Acts::BinningValue::binR),
                         Acts::open, Acts::BinningValue::binR, transformNominal);
 
    materialProxy =
        std::make_shared<const Acts::ProtoSurfaceMaterial>(materialBinUtil);
 
    ACTS_VERBOSE("[L] Layer is marked to carry support material on Surface ( "
                 "inner=0 / center=1 / outer=2 ) : "
                 << "inner");
    ACTS_VERBOSE("with binning: [" << matBinsPhi << ", " << matBinsR << "]");
 
    ACTS_VERBOSE("Created ApproachSurfaces for disc layer at:");
    ACTS_VERBOSE(" - inner:   Z=" << layerZInner);
    ACTS_VERBOSE(" - central: Z=" << layerZ);
    ACTS_VERBOSE(" - outer:   Z=" << layerZOuter);
 
    // set material on inner
    innerBoundary->assignSurfaceMaterial(materialProxy);
 
 
    // std::set<int> ringIds;
    bool isITk = m_cfg.mode == Mode::ITkPixelInner ||
                 m_cfg.mode == Mode::ITkPixelOuter ||
                 m_cfg.mode == Mode::ITkStrip;
 
    std::map<int, std::set<int>> phiModuleByRing;
 
    // want to figure out bins in phi
    for (const auto &srf : pl.surfaces()) {
      auto elm = dynamic_cast<const ActsDetectorElement *>(
          srf->associatedDetectorElement());
      if (elm) {
        auto id = elm->identityHelper();
        int ring_number;
        if(m_cfg.mode == Mode::ITkStrip || !isITk) {
          ring_number = id.eta_module();
        }
        else {
          ring_number = id.layer_disk();
        }
        phiModuleByRing[ring_number].insert(id.phi_module());
      }
    }
    size_t nModPhi = std::numeric_limits<size_t>::max();
    for(const auto& [ring, phiModules] : phiModuleByRing) {
      nModPhi = std::min(nModPhi, phiModules.size());
    }
 
    size_t nModR = phiModuleByRing.size();
 
    ACTS_VERBOSE("Identifier reports: " << nModPhi << " is lowest for " << nModR
                                        << " r-rings");
 
    size_t nBinsPhi = nModPhi;
    size_t nBinsR = nModR;
 
    if(!isITk) {
      // In the ID, the modules in the innermost r-rings are exactly shifted by
      // one half module width since it's the same number of modules, this gives
      // binning trouble. Reduce bins by half: about 2 module pairs should be in
      // each bin. This should be fine.
      // @TODO: evaluate
      nBinsPhi /= 2.0;
    }
    if(m_cfg.mode == Mode::ITkStrip) {
      // up to four rows per module
      nBinsR /= 4.0;
    }
 
    ACTS_VERBOSE("Creating r x phi binned layer with " << nBinsR << " x "
                                                       << nBinsPhi << " bins");
 
 
    approachDescriptor =
        std::make_unique<Acts::GenericApproachDescriptor>(aSurfaces);
 
    // get ownership of pl surfaces
    ownedSurfaces.clear();
    ownedSurfaces.reserve(pl.surfaces().size());
    std::transform(pl.surfaces().begin(), pl.surfaces().end(),
                   std::back_inserter(ownedSurfaces),
                   [](const auto &s) { return s->getSharedPtr(); });
 
    auto layer = m_cfg.layerCreator->discLayer(gctx, ownedSurfaces, nBinsR,
                                               nBinsPhi, pl, transformNominal,
                                               std::move(approachDescriptor));
 
    layersOutput.push_back(layer);
  }
}

centralLayers()

const Acts::LayerVector ActsLayerBuilder::centralLayers ( const Acts::GeometryContext &  gctx ) const

override

Definition at line 59 of file ActsLayerBuilder.cxx.

                                                                     {
  ACTS_VERBOSE("Building central layers");
  Acts::LayerVector cVector;
  buildBarrel(gctx, cVector);
  return cVector;
}

getConfiguration()

ActsLayerBuilder::Config ActsLayerBuilder::getConfiguration ( ) const

inline

get the configuration object

Definition at line 123 of file ActsLayerBuilder.h.

  {
    return m_cfg;
  }

getDetectorElements()

std::vector< std::shared_ptr< const ActsDetectorElement > > ActsLayerBuilder::getDetectorElements ( ) const

private

Definition at line 75 of file ActsLayerBuilder.cxx.

                                            {
  ACTS_VERBOSE("Retrieving detector elements from detector manager");
  if (m_cfg.mng == nullptr) {
    ACTS_ERROR("Manager is null");
    throw std::runtime_error{"Detector manager is null"};
  }
  auto siDetMng = static_cast<const InDetDD::SiDetectorManager *>(m_cfg.mng);
  ACTS_VERBOSE("Detector manager has "
               << std::distance(siDetMng->getDetectorElementBegin(),
                                siDetMng->getDetectorElementEnd())
               << " elements");
 
  std::vector<std::shared_ptr<const ActsDetectorElement>> elements;
 
  InDetDD::SiDetectorElementCollection::const_iterator iter;
  for (iter = siDetMng->getDetectorElementBegin();
       iter != siDetMng->getDetectorElementEnd(); ++iter) {
    const InDetDD::SiDetectorElement *siDetElement =
        dynamic_cast<InDetDD::SiDetectorElement *>(*iter);
    if (siDetElement == nullptr) {
      ACTS_ERROR("Detector element was nullptr");
      throw std::runtime_error{"Corrupt detector element collection"};
    }
    elements.push_back(
        std::make_shared<const ActsDetectorElement>(*siDetElement));
  }
  ACTS_VERBOSE("Retrieved " << elements.size() << " elements");
 
  return elements;
}

identification()

virtual const std::string& ActsLayerBuilder::identification ( ) const

inlineoverridevirtual

Definition at line 130 of file ActsLayerBuilder.h.

  {
    return m_cfg.configurationName;
  }

logger()

const Acts::Logger& ActsLayerBuilder::logger ( ) const

inlineprivate

Private access to the logger.

Definition at line 145 of file ActsLayerBuilder.h.

  {
    return *m_logger;
  }

negativeLayers()

const Acts::LayerVector ActsLayerBuilder::negativeLayers ( const Acts::GeometryContext &  gctx ) const

override

Definition at line 51 of file ActsLayerBuilder.cxx.

                                                                      {
  ACTS_VERBOSE("Building negative layers");
  Acts::LayerVector nVector;
  buildEndcap(gctx, nVector, -1);
  return nVector;
}

positiveLayers()

const Acts::LayerVector ActsLayerBuilder::positiveLayers ( const Acts::GeometryContext &  gctx ) const

override

Definition at line 67 of file ActsLayerBuilder.cxx.

                                                                      {
  ACTS_VERBOSE("Building positive layers");
  Acts::LayerVector pVector;
  buildEndcap(gctx, pVector, 1);
  return pVector;
}

setConfiguration()

void ActsLayerBuilder::setConfiguration

(

const Config &

cfg

)

Name identification.

set the configuration object

Parameters

cfg	is the configuration struct

setLogger()

void ActsLayerBuilder::setLogger

(

std::unique_ptr< const Acts::Logger >

logger

)

set logging instance

Member Data Documentation

m_cfg

Config ActsLayerBuilder::m_cfg

private

configuration object

Definition at line 141 of file ActsLayerBuilder.h.

m_logger

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

private

logging instance

Definition at line 154 of file ActsLayerBuilder.h.

---

The documentation for this class was generated from the following files:

• ActsLayerBuilder.h
• ActsLayerBuilder.cxx