14 #include "Acts/Definitions/Algebra.hpp"
15 #include "Acts/Definitions/Units.hpp"
16 #include "Acts/Geometry/ApproachDescriptor.hpp"
17 #include "Acts/Geometry/GenericApproachDescriptor.hpp"
18 #include "Acts/Geometry/GeometryContext.hpp"
19 #include "Acts/Geometry/CylinderLayer.hpp"
20 #include "Acts/Geometry/LayerCreator.hpp"
21 #include "Acts/Geometry/ProtoLayer.hpp"
22 #include "Acts/Material/ProtoSurfaceMaterial.hpp"
23 #include "Acts/Surfaces/CylinderSurface.hpp"
24 #include "Acts/Surfaces/DiscSurface.hpp"
25 #include "Acts/Utilities/BinningType.hpp"
26 #include "Acts/Surfaces/AnnulusBounds.hpp"
28 #include "Acts/Visualization/GeometryView3D.hpp"
29 #include "Acts/Visualization/ObjVisualization3D.hpp"
31 #include <Acts/Utilities/AxisDefinitions.hpp>
33 #include <unordered_map>
37 using Acts::Transform3;
38 using Acts::Translation3;
40 using namespace Acts::UnitLiterals;
43 std::unique_ptr<const Acts::Logger>
logger)
45 m_logger(std::move(
logger))
48 throw std::invalid_argument(
"ALB mode is undefined");
52 const Acts::LayerVector
54 ACTS_VERBOSE(
"Building negative layers");
55 Acts::LayerVector nVector;
60 const Acts::LayerVector
62 ACTS_VERBOSE(
"Building central layers");
63 Acts::LayerVector cVector;
68 const Acts::LayerVector
70 ACTS_VERBOSE(
"Building positive layers");
71 Acts::LayerVector pVector;
76 std::vector<std::shared_ptr<const ActsDetectorElement>>
78 ACTS_VERBOSE(
"Retrieving detector elements from detector manager");
80 ACTS_ERROR(
"Manager is null");
81 throw std::runtime_error{
"Detector manager is null"};
84 ACTS_VERBOSE(
"Detector manager has "
86 siDetMng->getDetectorElementEnd())
89 std::vector<std::shared_ptr<const ActsDetectorElement>> elements;
92 for (
iter = siDetMng->getDetectorElementBegin();
93 iter != siDetMng->getDetectorElementEnd(); ++
iter) {
96 if (siDetElement ==
nullptr) {
97 ACTS_ERROR(
"Detector element was nullptr");
98 throw std::runtime_error{
"Corrupt detector element collection"};
101 std::make_shared<const ActsDetectorElement>(*siDetElement));
103 ACTS_VERBOSE(
"Retrieved " << elements.size() <<
" elements");
109 Acts::LayerVector &layersOutput)
const {
110 using enum Acts::AxisDirection;
112 ACTS_VERBOSE(
"Build layers: BARREL");
113 std::vector<std::shared_ptr<const ActsDetectorElement>> elements =
116 std::map<int, std::vector<std::shared_ptr<const Acts::Surface>>>
layers{};
118 for (
const auto &element : elements) {
125 if(
id.layer_disk() >= 2)
continue;
128 if(
id.layer_disk() <= 1)
continue;
134 elementLayer =
id.layer_disk();
136 layers[elementLayer].push_back(element->surface().getSharedPtr());
142 for (
auto &[
key, layerSurfaces] :
layers) {
144 std::stringstream
name;
148 name <<
"obj/" <<
m_cfg.
mode <<
"_brl_" << std::setfill(
'0') << std::setw(2)
152 std::ofstream ofs{
name.str()};
153 Acts::ObjVisualization3D vis{};
154 Acts::ViewConfig vc = Acts::s_viewSensitive;
155 vc.quarterSegments = 200;
156 for (
const auto &surface : layerSurfaces) {
157 Acts::GeometryView3D::drawSurface(vis, *surface, gctx,
158 Acts::Transform3::Identity(), vc);
165 ACTS_VERBOSE(
"Found " <<
layers.size() <<
" barrel layers");
169 for (
const auto &[
key, surfaces] :
layers) {
170 Acts::ProtoLayer pl(gctx, surfaces);
171 ACTS_VERBOSE(
"Layer #" <<
n <<
" with layerKey: (" <<
key <<
")");
172 ACTS_VERBOSE(
" -> at rMin / rMax: " << pl.min(AxisR) <<
" / "
174 ACTS_VERBOSE(
" -> at zMin / zMax: " << pl.min(AxisZ) <<
" / "
181 for (
const auto &[
key, surfaces] :
layers) {
183 std::unique_ptr<Acts::ApproachDescriptor> approachDescriptor =
nullptr;
184 std::shared_ptr<const Acts::ProtoSurfaceMaterial> materialProxy =
nullptr;
187 Acts::ProtoLayer pl(gctx, surfaces);
191 double layerZ = pl.medium(AxisZ,
true);
192 double layerHalfZ = 0.5 * pl.range(AxisZ);
194 Acts::Transform3
transform(Translation3(0., 0., -layerZ));
197 std::shared_ptr<Acts::CylinderSurface> innerBoundary =
198 Acts::Surface::makeShared<Acts::CylinderSurface>(
201 std::shared_ptr<Acts::CylinderSurface> outerBoundary =
202 Acts::Surface::makeShared<Acts::CylinderSurface>(
205 std::shared_ptr<Acts::CylinderSurface> centralSurface =
206 Acts::Surface::makeShared<Acts::CylinderSurface>(
207 transform, (pl.min(AxisR) + pl.max(AxisR)) / 2.,
215 materialBinUtil += Acts::BinUtility(
binsZ, -layerHalfZ, layerHalfZ,
219 std::make_shared<const Acts::ProtoSurfaceMaterial>(materialBinUtil);
221 ACTS_VERBOSE(
"[L] Layer is marked to carry support material on Surface ( "
222 "inner=0 / center=1 / outer=2 ) : "
224 ACTS_VERBOSE(
"with binning: [" << binsPhi <<
", " <<
binsZ <<
"]");
226 ACTS_VERBOSE(
"Created ApproachSurfaces for cylinder layer at:");
227 ACTS_VERBOSE(
" - inner: R=" << pl.min(AxisR));
228 ACTS_VERBOSE(
" - central: R=" << (pl.min(AxisR) + pl.max(AxisR)) /
230 ACTS_VERBOSE(
" - outer: R=" << pl.max(AxisR));
233 innerBoundary->assignSurfaceMaterial(materialProxy);
235 std::vector<std::shared_ptr<const Acts::Surface>> aSurfaces;
236 aSurfaces.push_back(std::move(innerBoundary));
237 aSurfaces.push_back(std::move(centralSurface));
238 aSurfaces.push_back(std::move(outerBoundary));
241 std::make_unique<Acts::GenericApproachDescriptor>(std::move(aSurfaces));
244 auto phiEqual = [
this](
const Acts::Surface &
a,
245 const Acts::Surface &
b) {
246 Acts::GeometryContext gctx;
250 auto zEqual = [
this](
const Acts::Surface &
a,
251 const Acts::Surface &
b) {
252 Acts::GeometryContext gctx;
258 auto& xsurfaces = surfaces;
259 auto countKey = [&xsurfaces](
auto equal) ->
size_t {
260 std::vector<const Acts::Surface *> keySurfaces;
261 for (
const auto &surface : xsurfaces) {
263 for (
const auto* existing : keySurfaces) {
264 if (
equal(*surface, *existing)) {
270 keySurfaces.push_back(surface.get());
273 return keySurfaces.size();
276 size_t nModPhi = countKey(phiEqual);
277 size_t nModZ = countKey(zEqual);
279 ACTS_VERBOSE(
"Found " << nModPhi <<
" modules in phi " << nModZ
282 std::shared_ptr<Acts::Layer>
layer;
290 size_t nBinsPhi = nModPhi;
291 size_t nBinsZ = nModZ /
f;
294 std::move(approachDescriptor));
297 size_t nBinsPhi = nModPhi;
298 size_t nBinsZ = nModZ;
301 std::move(approachDescriptor));
305 std::move(approachDescriptor));
308 layersOutput.push_back(
layer);
313 ACTS_DEBUG(
"Configured to build " << numPassiveLayers <<
" passive central layers.");
314 if (numPassiveLayers != 0
u) {
315 for (std::size_t icl = 0; icl < numPassiveLayers; ++icl) {
316 ACTS_VERBOSE(
"- build layer " << icl
322 auto cBounds = std::make_shared<const Acts::CylinderBounds>(
326 std::shared_ptr<Acts::Layer>
layer =
329 layersOutput.push_back(
layer);
335 Acts::LayerVector &layersOutput,
int type)
const
337 using enum Acts::AxisDirection;
339 ACTS_VERBOSE(
"Build layers: " << (
type < 0 ?
"NEGATIVE" :
"POSITIVE")
341 std::vector<std::shared_ptr<const ActsDetectorElement>> elements =
343 std::map<std::tuple<int, int, int>, std::vector<const Acts::Surface *>>
346 for (
const auto &element : elements) {
354 if(
id.layer_disk() >= 3)
continue;
357 if(
id.layer_disk() <= 2)
continue;
362 std::tuple<int, int, int>
key{
id.bec(),
id.layer_disk(),
id.eta_module()};
364 initialLayers[
key].push_back(&element->surface());
367 ACTS_VERBOSE(
"Found " << initialLayers.size() <<
" "
368 << (
type < 0 ?
"NEGATIVE" :
"POSITIVE")
369 <<
" ENDCAP inital layers");
371 std::vector<Acts::ProtoLayer> protoLayers;
372 protoLayers.reserve(initialLayers.size());
374 for (
const auto &[
key, surfaces] : initialLayers) {
375 auto &pl = protoLayers.emplace_back(gctx, surfaces);
381 std::sort(protoLayers.begin(), protoLayers.end(),
382 [
type](
const Acts::ProtoLayer &
a,
const Acts::ProtoLayer &
b) {
383 double midA = (a.min(AxisZ) + a.max(AxisZ)) / 2.0;
384 double midB = (b.min(AxisZ) + b.max(AxisZ)) / 2.0;
392 auto plPrintZ = [](
const auto &pl) -> std::string {
393 std::stringstream
ss;
394 double zMid = (pl.min(AxisZ) + pl.max(AxisZ)) / 2.0;
395 ss <<
" < " << pl.min(AxisZ) <<
" | " << zMid <<
" | "
396 << pl.max(AxisZ) <<
" > ";
400 for (
const auto &pl : protoLayers) {
402 ACTS_VERBOSE(
" -> at < zMin | zMid | zMax >: " << plPrintZ(pl));
404 ACTS_VERBOSE(
" -> at rMin / rMax: " << pl.min(AxisR) <<
" / "
409 std::vector<Acts::ProtoLayer> mergedProtoLayers;
411 if (m_cfg.doEndcapLayerMerging) {
412 mergedProtoLayers.push_back(protoLayers.front());
413 std::vector<const Acts::Surface *> surfaces;
414 for (
size_t i = 1;
i < protoLayers.size();
i++) {
415 auto &pl = protoLayers[
i];
416 auto &pl_prev = mergedProtoLayers.back();
418 ACTS_VERBOSE(
"Compare: " << plPrintZ(pl_prev) <<
" and " << plPrintZ(pl));
419 bool overlap = (pl.min(AxisZ) <= pl_prev.max(AxisZ) &&
420 pl.max(AxisZ) >= pl_prev.min(AxisZ));
421 ACTS_VERBOSE(
" -> overlap? " << (overlap ?
"yes" :
"no"));
423 ACTS_VERBOSE(
" ===> merging");
425 surfaces.reserve(pl.surfaces().size() + pl_prev.surfaces().size());
426 surfaces.insert(surfaces.end(), pl.surfaces().begin(),
427 pl.surfaces().end());
428 surfaces.insert(surfaces.end(), pl_prev.surfaces().begin(),
429 pl_prev.surfaces().end());
430 mergedProtoLayers.pop_back();
432 mergedProtoLayers.emplace_back(gctx, std::move(surfaces));
433 new_pl.envelope[AxisR] = pl.envelope[AxisR];
434 new_pl.envelope[AxisZ] = pl.envelope[AxisZ];
436 mergedProtoLayers.push_back(std::move(pl));
440 ACTS_VERBOSE(
"" << mergedProtoLayers.size() <<
" "
441 << (
type < 0 ?
"NEGATIVE" :
"POSITIVE")
442 <<
" ENDCAP layers remain after merging");
444 mergedProtoLayers = protoLayers;
447 if (m_cfg.objDebugOutput) {
448 for (
size_t i = 0;
i < mergedProtoLayers.size();
i++) {
450 std::stringstream
ss;
451 ss <<
"obj/" << m_cfg.mode <<
"_" << (
type < 0 ?
"neg" :
"pos")
452 <<
"_disk_" << std::setfill(
'0') << std::setw(2) <<
i <<
".obj";
454 std::ofstream ofs{
ss.str()};
455 Acts::ObjVisualization3D vis{};
456 Acts::ViewConfig vc = Acts::s_viewSensitive;
457 vc.quarterSegments = 200;
458 for (
const auto &surface : mergedProtoLayers[
i].surfaces()) {
459 Acts::GeometryView3D::drawSurface(vis, *surface, gctx,
460 Acts::Transform3::Identity(), vc);
467 std::vector<std::shared_ptr<const Surface>> ownedSurfaces;
468 for (
const auto &pl : mergedProtoLayers) {
470 std::unique_ptr<Acts::ApproachDescriptor> approachDescriptor =
nullptr;
471 std::shared_ptr<const Acts::ProtoSurfaceMaterial> materialProxy =
nullptr;
473 double layerZ = pl.medium(AxisZ);
474 double layerHalfZ = 0.5 * pl.range(AxisZ);
475 double layerThickness = pl.range(AxisZ);
477 double layerZInner = layerZ - layerHalfZ;
478 double layerZOuter = layerZ + layerHalfZ;
480 if (std::abs(layerZInner) > std::abs(layerZOuter))
483 std::vector<std::shared_ptr<const Acts::Surface>> aSurfaces;
485 Acts::Transform3 transformNominal(Translation3(0., 0., layerZ));
486 Acts::Transform3 transformInner(Translation3(0., 0., layerZInner));
487 Acts::Transform3 transformOuter(Translation3(0., 0., layerZOuter));
489 std::shared_ptr<Acts::DiscSurface> innerBoundary =
490 Acts::Surface::makeShared<Acts::DiscSurface>(
491 transformInner, pl.min(AxisR), pl.max(AxisR));
492 aSurfaces.push_back(innerBoundary);
494 std::shared_ptr<Acts::DiscSurface> nominalSurface =
495 Acts::Surface::makeShared<Acts::DiscSurface>(
496 transformNominal, pl.min(AxisR), pl.max(AxisR));
497 aSurfaces.push_back(nominalSurface);
499 std::shared_ptr<Acts::DiscSurface> outerBoundary =
500 Acts::Surface::makeShared<Acts::DiscSurface>(
501 transformOuter, pl.min(AxisR), pl.max(AxisR));
502 aSurfaces.push_back(outerBoundary);
504 if(layerThickness > 2_mm) {
505 ACTS_VERBOSE(
"Wide disc layer ("<< layerThickness <<
") => adding cylinder like approach surfaces");
506 Acts::Transform3
trf{Translation3{0, 0, layerZ}};
508 Acts::Surface::makeShared<Acts::CylinderSurface>(
509 trf, pl.min(AxisR), layerHalfZ);
510 aSurfaces.push_back(cylinderInner);
513 Acts::Surface::makeShared<Acts::CylinderSurface>(
514 trf, pl.max(AxisR), layerHalfZ);
515 aSurfaces.push_back(cylinderOuter);
519 size_t matBinsPhi = m_cfg.endcapMaterialBins.first;
520 size_t matBinsR = m_cfg.endcapMaterialBins.second;
525 Acts::BinUtility(matBinsR, pl.min(AxisR), pl.max(AxisR),
529 std::make_shared<const Acts::ProtoSurfaceMaterial>(materialBinUtil);
531 ACTS_VERBOSE(
"[L] Layer is marked to carry support material on Surface ( "
532 "inner=0 / center=1 / outer=2 ) : "
534 ACTS_VERBOSE(
"with binning: [" << matBinsPhi <<
", " << matBinsR <<
"]");
536 ACTS_VERBOSE(
"Created ApproachSurfaces for disc layer at:");
537 ACTS_VERBOSE(
" - inner: Z=" << layerZInner);
538 ACTS_VERBOSE(
" - central: Z=" << layerZ);
539 ACTS_VERBOSE(
" - outer: Z=" << layerZOuter);
542 innerBoundary->assignSurfaceMaterial(materialProxy);
546 bool isITk = m_cfg.mode == Mode::ITkPixelInner ||
547 m_cfg.mode == Mode::ITkPixelOuter ||
548 m_cfg.mode == Mode::ITkStrip;
550 std::map<int, std::set<int>> phiModuleByRing;
553 for (
const auto &srf : pl.surfaces()) {
555 srf->associatedDetectorElement());
559 if(m_cfg.mode == Mode::ITkStrip || !isITk) {
563 ring_number =
id.layer_disk();
565 phiModuleByRing[ring_number].insert(
id.phi_module());
569 for(
const auto& [ring, phiModules] : phiModuleByRing) {
570 nModPhi =
std::min(nModPhi, phiModules.size());
573 size_t nModR = phiModuleByRing.size();
575 ACTS_VERBOSE(
"Identifier reports: " << nModPhi <<
" is lowest for " << nModR
578 size_t nBinsPhi = nModPhi;
579 size_t nBinsR = nModR;
589 if(m_cfg.mode == Mode::ITkStrip) {
594 ACTS_VERBOSE(
"Creating r x phi binned layer with " << nBinsR <<
" x "
595 << nBinsPhi <<
" bins");
599 std::make_unique<Acts::GenericApproachDescriptor>(aSurfaces);
602 ownedSurfaces.clear();
603 ownedSurfaces.reserve(pl.surfaces().size());
605 std::back_inserter(ownedSurfaces),
606 [](
const auto &
s) { return s->getSharedPtr(); });
608 auto layer = m_cfg.layerCreator->discLayer(gctx, ownedSurfaces, nBinsR,
609 nBinsPhi, pl, Transform3::Identity(),
610 std::move(approachDescriptor));
612 layersOutput.push_back(
layer);
632 case Mode::ITkPixelInner:
633 os <<
"ITkPixelInner";
635 case Mode::ITkPixelOuter:
636 os <<
"ITkPixelOuter";