Builds the Calo Blueprint Node. More...

#include <CaloBlueprintNodeBuilder.h>

Inheritance diagram for ActsTrk::CaloBlueprintNodeBuilder:

Collaboration diagram for ActsTrk::CaloBlueprintNodeBuilder:

Public Types
enum class	caloRegion { DiscNegativeZ , DiscPositiveZ , BarrelCylinder , nRegions }
using	DetElVec_t = std::vector<const CaloDetDescrElement*>
using	DetElementMap_t = std::array<DetElVec_t, CaloSampling::getNumberOfSamplings()>
	Vector of Detector Elements per calorimeter layer.
using	SurfaceMap_t
	Vector of surfaces per calorimeter region.

Public Member Functions
std::shared_ptr< Acts::BlueprintNode >	buildBlueprintNode (const Acts::GeometryContext &gctx, std::shared_ptr< Acts::BlueprintNode > &&childNode) override
virtual StatusCode	initialize () override final

Private Member Functions
DetElementMap_t	fillDetectorElements (const CaloDetDescrManager &detDecrMgr) const
	Fill the detector elements per calorimeter layer and sort them in ascending r(z) for the barrel (endcap) layers.
SurfaceMap_t	translateToSurfaces (const DetElementMap_t &detElements) const
	Translate all detector elements to a Cylinder and Disc surfaces.
std::shared_ptr< Acts::Surface >	createCylinderSurface (std::span< const CaloDetDescrElement *const > detElements) const
	Create a cylinder surface from a list of Calo detector description elements.
std::shared_ptr< Acts::Surface >	createDiscSurface (std::span< const CaloDetDescrElement *const > detElements) const
	Create a disc surface from the passed calo description elements.
std::unique_ptr< Acts::TrackingVolume >	envelopeVolume (const Acts::GeometryContext &tgContext, const SurfaceMap_t &surfacesPerRegion) const
	Create the envelope volume of the Calo Tracking Geometry.
std::vector< std::shared_ptr< Acts::Surface > >	fillLayer (const Acts::GeometryContext &tgContext, std::shared_ptr< Acts::Surface > &&centralSurf) const
	Fill the layer with extra surfaces.

Private Attributes
Gaudi::Property< std::vector< std::uint32_t > >	m_surfaceDuplicates
	Configure the insert of extra surfaces per each calorimeter layer.
Gaudi::Property< double >	m_radiusTolerance
Gaudi::Property< double >	m_zTolerance

Friends
std::ostream &	operator<< (std::ostream &ostr, const caloRegion region)

Detailed Description

Builds the Calo Blueprint Node.

Definition at line 29 of file CaloBlueprintNodeBuilder.h.

Member Typedef Documentation

◆ DetElementMap_t

using ActsTrk::CaloBlueprintNodeBuilder::DetElementMap_t = std::array<DetElVec_t, CaloSampling::getNumberOfSamplings()>

Vector of Detector Elements per calorimeter layer.

Definition at line 49 of file CaloBlueprintNodeBuilder.h.

◆ DetElVec_t

using ActsTrk::CaloBlueprintNodeBuilder::DetElVec_t = std::vector<const CaloDetDescrElement*>

Definition at line 47 of file CaloBlueprintNodeBuilder.h.

◆ SurfaceMap_t

using ActsTrk::CaloBlueprintNodeBuilder::SurfaceMap_t

Initial value:

std::array<std::vector<std::shared_ptr<Acts::Surface>>,

Acts::toUnderlying(caloRegion::nRegions)>

ActsTrk::CaloBlueprintNodeBuilder::caloRegion::nRegions

@ nRegions

Definition CaloBlueprintNodeBuilder.h:35

Vector of surfaces per calorimeter region.

Definition at line 52 of file CaloBlueprintNodeBuilder.h.

Member Enumeration Documentation

◆ caloRegion

enum class ActsTrk::CaloBlueprintNodeBuilder::caloRegion

strong

Enumerator
DiscNegativeZ
DiscPositiveZ
BarrelCylinder
nRegions

Definition at line 32 of file CaloBlueprintNodeBuilder.h.

                              {DiscNegativeZ, 
                               DiscPositiveZ, 
                               BarrelCylinder, 
                               nRegions};

Member Function Documentation

◆ buildBlueprintNode()

std::shared_ptr< Acts::BlueprintNode > ActsTrk::CaloBlueprintNodeBuilder::buildBlueprintNode	(	const Acts::GeometryContext &	gctx,
		std::shared_ptr< Acts::BlueprintNode > &&	childNode )

override

Build the list of detector elements

Convert the detector elements to surfaces

Bare pointer to put the surfaces that cannot be put into wrapping cylinders

Definition at line 220 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                 {
    std::unique_ptr<CaloDetDescrManager> caloDetDescrMgr = buildCaloDetDescrNoAlign(serviceLocator(), Athena::getMessageSvc());
    DetElementMap_t detElements = fillDetectorElements(*caloDetDescrMgr);                                      
    SurfaceMap_t sensitives = translateToSurfaces(detElements);
    
    std::shared_ptr<Acts::BlueprintNode> caloNode{};
    Acts::TrackingVolume* caloVolume{}; 
    {
        auto caloEnvelope = envelopeVolume(tgContext, sensitives);
        caloVolume = caloEnvelope.get();
        caloNode = std::make_unique<Acts::StaticBlueprintNode>(std::move(caloEnvelope));
    }
    auto barrelNode = std::make_shared<Acts::CylinderContainerBlueprintNode>(
            "CaloBarrelCylinder", Acts::AxisDirection::AxisR);
    barrelNode->setAttachmentStrategy(Acts::VolumeAttachmentStrategy::Second);
    barrelNode->setResizeStrategy(Acts::VolumeResizeStrategy::Expand);
    if (childNode) {
        barrelNode->addChild(std::move(childNode));
    }
    std::unordered_map<CaloSampling::CaloSample, unsigned> barrelExtraCounts{};    
    for (std::shared_ptr<Acts::Surface>& surface : sensitives[Acts::toUnderlying(caloRegion::BarrelCylinder)]) {
        const auto layer = static_cast<CaloSampling::CaloSample>(surface->geometryId().layer());
        if (s_caloCylinderAsymmetricSampleList.count(layer) || 
            layer == CaloSampling::TileBar2) {
            std::ranges::for_each(fillLayer(tgContext, std::move(surface)),
                [&](std::shared_ptr<Acts::Surface>& surfToAdd){
                surfToAdd->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(s_caloEnvelopeID)
                                            .withLayer(layer)
                                            .withSensitive(barrelExtraCounts[layer]++));
                caloVolume->addSurface(std::move(surfToAdd));
                });
            continue;
        }
        auto layerNode = std::make_shared<Acts::LayerBlueprintNode>(std::format("{:}_Layer", CaloSampling::getSamplingName(layer)));
        layerNode->setSurfaces(fillLayer(tgContext, std::move(surface)));
        layerNode->setEnvelope(Acts::ExtentEnvelope{{
                                     .z = {0.1_mm, 0.1_mm},
                                     .r = {1._cm, 1._cm}}});
        auto idNode = std::make_shared<Acts::GeometryIdentifierBlueprintNode>();
        idNode->addChild(std::move(layerNode));
        idNode->setAllVolumeIdsTo(s_caloBarrelId);
        idNode->setLayerIdTo(layer);
        barrelNode->addChild(std::move(idNode));
    }
    caloNode->addChild(std::move(barrelNode));
    for (const auto& disc: {caloRegion::DiscNegativeZ, caloRegion::DiscPositiveZ}){
        auto layerNode = std::make_shared<Acts::LayerBlueprintNode>(std::format("CaloLayer{:}", disc));
        layerNode->setEnvelope(Acts::ExtentEnvelope{{
                                    .z = {1_mm, 1_mm},
                                    .r = {2_mm, 2_mm}, }});
        using namespace ActsTrk::detail::GeoVolIds;
        const std::size_t volId = disc == caloRegion::DiscNegativeZ ? s_caloEndcapCId : s_caloEndcapAId; 
        std::vector<std::shared_ptr<Acts::Surface>> layerSurfaces{};
 
        for (auto& surface : sensitives[Acts::toUnderlying(disc)]) {
 
            const auto layer = static_cast<CaloSampling::CaloSample>(surface->geometryId().layer());
            if (layer != CaloSampling::TileGap3) {
                std::ranges::for_each(fillLayer(tgContext, std::move(surface)),
                                      [&](std::shared_ptr<Acts::Surface>& surf) {
                                        surf->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(volId).
                                                            withLayer(layer).withSensitive(layerSurfaces.size()+1));
                                        layerSurfaces.push_back(std::move(surf));
                                      });
            } else {
                surface->assignGeometryId(surface->geometryId().withVolume(s_caloEnvelopeID)
                                .withSensitive(barrelExtraCounts[layer]++));
                caloVolume->addSurface(std::move(surface));
            }
        }
        layerNode->setSurfaces(std::move(layerSurfaces));
        auto idNode = std::make_shared<Acts::GeometryIdentifierBlueprintNode>();
        idNode->addChild(std::move(layerNode));
        idNode->setAllVolumeIdsTo(volId);
        caloNode->addChild(std::move(idNode));
    }
    return caloNode;
}

◆ createCylinderSurface()

std::shared_ptr< Acts::Surface > ActsTrk::CaloBlueprintNodeBuilder::createCylinderSurface ( std::span< const CaloDetDescrElement *const > detElements ) const

private

Create a cylinder surface from a list of Calo detector description elements.

The surface is constructed such that the radius is the radial midpoint of the passed elements, the thickness is capturing the minimal and maximal passed radius and the half length completley encloses the passed description elements.

Parameters

detElements The list of detector elements from which the envelope surface shall be translated.

Definition at line 138 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                   {
          
  float zMin{std::numeric_limits<float>::max()}, 
        zMax{-std::numeric_limits<float>::max()},
        rMin{std::numeric_limits<float>::max()}, rMax{0.f};
  for (const CaloDetDescrElement* detEl : detElVec){
      zMin = std::min(zMin, detEl->z() - 0.5f*detEl->dz());
      zMax = std::max(zMax, detEl->z() + 0.5f*detEl->dz());
      rMin = std::min(rMin, detEl->r() - 0.5f*detEl->dr());
      rMax = std::max(rMax, detEl->r() + 0.5f*detEl->dr());
  }
  const float cylinderR = 0.5*(rMin + rMax);
  const float cylinderZ = 0.5*(zMax - zMin);
  const float surfaceZ =  0.5*(zMin + zMax);
  auto cylinder = Acts::Surface::makeShared<Acts::CylinderSurface>(Amg::getTranslateZ3D(surfaceZ), cylinderR, cylinderZ);
  cylinder->assignThickness(0.5*(rMax - rMin));
  cylinder->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(detElVec.front()->getSampling()));
  ATH_MSG_DEBUG(__func__<<"() - Create surface "<<CaloSampling::getSamplingName(detElVec.front()->getSampling())
                  <<" r["<<rMin<<";"<<rMax<<"] z["<<zMin<<";"<<zMax<<"]"
                  <<" -> surface parameters R: "<<cylinder->bounds()<<", Z position: "<<surfaceZ
                  <<", "<<cylinder->geometryId());
  return cylinder;  
}

◆ createDiscSurface()

std::shared_ptr< Acts::Surface > ActsTrk::CaloBlueprintNodeBuilder::createDiscSurface ( std::span< const CaloDetDescrElement *const > detElements ) const

private

Create a disc surface from the passed calo description elements.

The disc is placed at the central z considering the longitudinal spread of the elements. The radius of the disc fully encapsulates the detector description elements and the assigned thickness represents the maximum and minimum z

Parameters

detElements The list of detector elements from which the envelope surface shall be translated.

Definition at line 162 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                               {
    float zMin{std::numeric_limits<float>::max()}, 
          zMax{-std::numeric_limits<float>::max()},
          rMin{std::numeric_limits<float>::max()}, rMax{0.f};
    for (const CaloDetDescrElement* detEl : detElVec){
      zMin = std::min(zMin, detEl->z() - 0.5f*detEl->dz());
      zMax = std::max(zMax, detEl->z() + 0.5f*detEl->dz());
      rMin = std::min(rMin, detEl->r() - 0.5f*detEl->dr());
      rMax = std::max(rMax, detEl->r() + 0.5f*detEl->dr());
    }
    const float surfaceZ = 0.5*(zMin + zMax);
    const auto sampling = detElVec.front()->getSampling();
    ATH_MSG_DEBUG(__func__<<"() - Create surface "<<CaloSampling::getSamplingName(sampling)
                  <<" r["<<rMin<<";"<<rMax<<"] z["<<zMin<<";"<<zMax<<"]"
                  <<" -> surface position: "<<surfaceZ);    
    auto disc = Acts::Surface::makeShared<Acts::DiscSurface>(Amg::getTranslateZ3D(surfaceZ), rMin, rMax);
    disc->assignThickness(0.5*(zMax - zMin));
    disc->assignGeometryId(Acts::GeometryIdentifier{}.withLayer(sampling));
    return disc;
}

◆ envelopeVolume()

std::unique_ptr< Acts::TrackingVolume > ActsTrk::CaloBlueprintNodeBuilder::envelopeVolume	(	const Acts::GeometryContext &	tgContext,
		const SurfaceMap_t &	surfacesPerRegion ) const

private

Create the envelope volume of the Calo Tracking Geometry.

The volume encapsulates all calorimeter surfaces taking the respective thickness into account. The inner radius is set to zero to make space for the ITk. The GeometryIdentifier is set to the central calo volume ID

Parameters

tgContext	The geometry context to align the particular surfaces and volumes
surfacesPerRegion	List of the constructed calorimeter surfaces

Definition at line 302 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                           {
    double maxR{0.}, minZ{std::numeric_limits<double>::max()}, maxZ{-std::numeric_limits<double>::max()};
    for (auto& surfaces : surfacePerRegion) {
        for (auto& surface : surfaces) {
            const Amg::Vector3D center = surface->center(tgContext);
            if (surface->type() == Acts::Surface::SurfaceType::Disc) {
              minZ = std::min(minZ, center.z() - 0.5*surface->thickness());
              maxZ = std::max(maxZ, center.z() + 0.5*surface->thickness());
              const auto& bounds = static_cast<const Acts::RadialBounds&>(surface->bounds());
              maxR = std::max(maxR, bounds.rMax());
            } else {
              const auto& bounds = static_cast<const Acts::CylinderBounds&>(surface->bounds());
              using enum Acts::CylinderBounds::BoundValues;
              minZ = std::min(minZ, center.z() - bounds.get(eHalfLengthZ));
              maxZ = std::max(maxZ, center.z() + bounds.get(eHalfLengthZ));
              maxR = std::max(maxR, bounds.get(eR) + 0.5*surface->thickness());
            }
        }
    }
    auto volBounds = std::make_shared<Acts::CylinderVolumeBounds>(0, maxR + 1_cm,  0.5*(maxZ - minZ) + 1._cm);
    ATH_MSG_DEBUG(__func__<<"() Create envelope volume with bounds "<<(*volBounds));
    auto volume = std::make_unique<Acts::TrackingVolume>(Amg::getTranslateZ3D(0.5*(minZ + maxZ)),
                                                         volBounds, "ITkCalo");
    volume->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(s_caloEnvelopeID));
    return volume;
  }

◆ fillDetectorElements()

DetElementMap_t ActsTrk::CaloBlueprintNodeBuilder::fillDetectorElements ( const CaloDetDescrManager & detDecrMgr ) const

private

Fill the detector elements per calorimeter layer and sort them in ascending r(z) for the barrel (endcap) layers.

Remove duplicates from the list where r and z are within the precision tolerance

Parameters

detDescrMgr The calorimeter detector description manager from which the detector elements are retrieved

Barrel elements that are cylinders sort them by R

Endcap elements are discs and sort them first by Z

Remove duplicate elements

The detector elements from TileBar2 and TileGap2 produce each a cylinder which is exactly at the same R but overlaping with the other. Merge them into a single vector

Definition at line 90 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                          {
    DetElementMap_t sortedElements{};
    for (const CaloDetDescrElement* theDDE : detDecrMgr.element_range()){ 
        const CaloCell_ID::CaloSample sample =theDDE->getSampling();
        sortedElements[Acts::toUnderlying(sample)].push_back(theDDE);
    }
    for (DetElVec_t& detElVec : sortedElements) {
       if (detElVec.empty()) {
           continue;
       }
       const CaloCell_ID::CaloSample sample = detElVec.front()->getSampling();
       std::ranges::sort(detElVec, [&](const CaloDetDescrElement* a, const CaloDetDescrElement* b){
            if (!s_caloDiscSampleList.count(sample)) {
                if (std::abs(a->r() - b->r()) > Acts::s_epsilon) {
                    return a->r() < b->r();
                }
                return a->z() < b->z();
            }
            if (std::abs(a->z() - b->z()) > Acts::s_epsilon) {
              return a->z() < b->z();
            }
            return a->r() < b->r();
      });
      auto [begin, end] = std::ranges::unique(detElVec, 
                    [&](const CaloDetDescrElement* a,  const CaloDetDescrElement* b) {
                        return std::abs(a->r() - b->r()) < Acts::s_onSurfaceTolerance &&
                               std::abs(a->z() - b->z()) < Acts::s_onSurfaceTolerance;
                    });
      const std::size_t nBefore = detElVec.size();
      detElVec.erase(begin, end);
      ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Removed "<<(nBefore - detElVec.size())
          <<" detector elements for layer "<<CaloSampling::getSamplingName(sample)
          <<", current size: "<<detElVec.size()<<"\n"<<print(detElVec));
    }
    DetElVec_t& gapVec = sortedElements[CaloSampling::TileGap2];
    DetElVec_t& barVec = sortedElements[CaloSampling::TileBar2];
    barVec.insert(barVec.end(), gapVec.begin(), gapVec.end());
    gapVec.clear();
    return sortedElements;
}

◆ fillLayer()

std::vector< std::shared_ptr< Acts::Surface > > ActsTrk::CaloBlueprintNodeBuilder::fillLayer	(	const Acts::GeometryContext &	tgContext,
		std::shared_ptr< Acts::Surface > &&	centralSurf ) const

private

Fill the layer with extra surfaces.

Via the <insertExtraSuraces> property, it can be steered how many extra surfaces are inserted between the central surface and the virtual boundaries (defined by the extra thickness). E.g. a value of one inserts one surface in front and another one behind the central surface

Parameters

tgContext	The geometry context to access the surface transforms
centralSurf	The central surface to be duplicated

Definition at line 330 of file CaloBlueprintNodeBuilder.cxx.

                                                                                           {
        unsigned extraSurf = m_surfaceDuplicates.value().at(centralSurf->geometryId().layer());
        centralSurf->assignGeometryId(Acts::GeometryIdentifier{});
        if (extraSurf == 0) {
            return {std::move(centralSurf)};
        }
        const double stepLength =  centralSurf->thickness() / (extraSurf +1u);
        const Acts::Transform3& trf = centralSurf->localToGlobalTransform(tgContext);
        std::vector<std::shared_ptr<Acts::Surface>> surfaces{};
        if (centralSurf->type() == Acts::Surface::SurfaceType::Cylinder) {
            const auto& bounds = static_cast<const Acts::CylinderBounds&>(centralSurf->bounds());
            const double radius = bounds.get(Acts::CylinderBounds::BoundValues::eR);
            const double halfZ = bounds.get(Acts::CylinderBounds::BoundValues::eHalfLengthZ);
            for (unsigned extra = 1ul; extra <= extraSurf; ++extra) {
                surfaces.emplace_back(Acts::Surface::makeShared<Acts::CylinderSurface>(trf, radius - stepLength* extra, halfZ));
                surfaces.emplace_back(Acts::Surface::makeShared<Acts::CylinderSurface>(trf, radius + stepLength* extra, halfZ));
            }
        } else if (centralSurf->type() == Acts::Surface::SurfaceType::Disc) {
            using DiscB = Acts::RadialBounds;
            auto bounds = std::make_shared<DiscB>(static_cast<const DiscB&>(centralSurf->bounds()));
            for (unsigned extra = 1ul; extra <= extraSurf; ++extra) {
                const double shiftZ = stepLength *extra;
                surfaces.emplace_back(Acts::Surface::makeShared<Acts::DiscSurface>(trf * Amg::getTranslateZ3D(shiftZ),
                                                                                   bounds));
                surfaces.emplace_back(Acts::Surface::makeShared<Acts::DiscSurface>(trf * Amg::getTranslateZ3D(-shiftZ),
                                                                                   bounds));
            }
        }
        surfaces.push_back(std::move(centralSurf));
        return surfaces;
  }

◆ initialize()

StatusCode ActsTrk::CaloBlueprintNodeBuilder::initialize ( )

finaloverridevirtual

Definition at line 81 of file CaloBlueprintNodeBuilder.cxx.

                                                {
    if (m_surfaceDuplicates.value().size() != CaloSampling::getNumberOfSamplings()) {
        ATH_MSG_ERROR("Invalid size of "<<m_surfaceDuplicates<<". Expected: "
            <<CaloSampling::getNumberOfSamplings()<<" got "<<m_surfaceDuplicates.value().size());
        return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
}

◆ translateToSurfaces()

SurfaceMap_t ActsTrk::CaloBlueprintNodeBuilder::translateToSurfaces ( const DetElementMap_t & detElements ) const

private

Translate all detector elements to a Cylinder and Disc surfaces.

Per calorimeter layer the detector elements are combined to single or multiple surfaces and then sorted into the

Parameters

detElements The calorimeter detector description elements split by their logical CaloSamplingID

Definition at line 183 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                      {
    SurfaceMap_t surfaces{};
    for (const DetElVec_t& detElVec : sortedElements) {
        if (detElVec.empty()) {
            continue;
        }
        const CaloCell_ID::CaloSample sample = detElVec.front()->getSampling();
        using enum caloRegion;
        if (s_caloCylinderSymmetricSampleList.count(sample)) {
            surfaces[Acts::toUnderlying(BarrelCylinder)].push_back(createCylinderSurface(detElVec));
        } else if (s_caloCylinderAsymmetricSampleList.count(sample)) {
            for (DetElVec_t::const_iterator itr = detElVec.begin(); 
                 itr != detElVec.end(); ) {
                const CaloDetDescrElement* detEl{*itr};
                auto next = std::ranges::find_if(itr, detElVec.end(), [&](const CaloDetDescrElement* testMe){                 
                  return detEl->z() *  testMe->z() < 0.;
                });
                surfaces[Acts::toUnderlying(BarrelCylinder)].push_back(createCylinderSurface({itr, next}));
                itr = next;
            } 
        } else {
           for (DetElVec_t::const_iterator itr = detElVec.begin(); 
                 itr != detElVec.end(); ) {
                const CaloDetDescrElement* detEl{*itr};
                auto next = std::ranges::find_if(itr, detElVec.end(), [&](const CaloDetDescrElement* testMe){                 
                  return detEl->z() * testMe->z() < 0.;
                });
                const auto idx = detEl->z() > 0 ? Acts::toUnderlying(DiscPositiveZ)
                                                : Acts::toUnderlying(DiscNegativeZ);
                surfaces[idx].push_back(createDiscSurface({itr, next}));
                itr = next;
            }  
        }
    }
    return surfaces;
}

◆ operator<<

std::ostream & operator<<	(	std::ostream &	ostr,
		const caloRegion	region )

friend

Definition at line 36 of file CaloBlueprintNodeBuilder.h.

                                                                                 {
            using enum caloRegion;
            switch(region) {
              case DiscNegativeZ: ostr<<"DiscNegativeZ"; break;
              case DiscPositiveZ: ostr<<"DiscPositiveZ"; break;
              case BarrelCylinder: ostr<<"BarrelCylinder"; break;
              case nRegions: ostr<<"nRegions"; break;
            }
            return ostr;
        }

Member Data Documentation

◆ m_radiusTolerance

Gaudi::Property<double> ActsTrk::CaloBlueprintNodeBuilder::m_radiusTolerance

private

Initial value:

{ this
        , "RadiusTolerance"
        , 2.0
        , "Tolerance for determining if a ring of cells in phi has changed the radius w.r.t to the previous ring in phi" }

Definition at line 109 of file CaloBlueprintNodeBuilder.h.

                                                { this
        , "RadiusTolerance"
        , 2.0
        , "Tolerance for determining if a ring of cells in phi has changed the radius w.r.t to the previous ring in phi" };

◆ m_surfaceDuplicates

Gaudi::Property<std::vector<std::uint32_t> > ActsTrk::CaloBlueprintNodeBuilder::m_surfaceDuplicates

private

Initial value:

{this, "insertExtraSurfaces",

std::vector<std::uint32_t>(CaloSampling::Unknown, 0) }

Configure the insert of extra surfaces per each calorimeter layer.

Definition at line 106 of file CaloBlueprintNodeBuilder.h.

106 {this, "insertExtraSurfaces",

107 std::vector<std::uint32_t>(CaloSampling::Unknown, 0) };

◆ m_zTolerance

Gaudi::Property<double> ActsTrk::CaloBlueprintNodeBuilder::m_zTolerance

private

Initial value:

{ this
        , "ZTolerance"
        , 2.0
        , "Tolerance for determining if a ring of cells in phi has changed the z w.r.t to the previous ring in phi" }

Definition at line 114 of file CaloBlueprintNodeBuilder.h.

                                           { this
        , "ZTolerance"
        , 2.0
        , "Tolerance for determining if a ring of cells in phi has changed the z w.r.t to the previous ring in phi" };

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ DetElementMap_t

◆ DetElVec_t

◆ SurfaceMap_t

Member Enumeration Documentation

◆ caloRegion

Member Function Documentation

◆ buildBlueprintNode()

◆ createCylinderSurface()

◆ createDiscSurface()

◆ envelopeVolume()

◆ fillDetectorElements()

◆ fillLayer()

◆ initialize()

◆ translateToSurfaces()

Friends And Related Symbol Documentation

◆ operator<<

Member Data Documentation

◆ m_radiusTolerance

◆ m_surfaceDuplicates

◆ m_zTolerance