ActsTrk::CaloBlueprintNodeBuilder Class Reference

Builds the Calo Blueprint Node. More...

#include <CaloBlueprintNodeBuilder.h>

Inheritance diagram for ActsTrk::CaloBlueprintNodeBuilder:

Collaboration diagram for ActsTrk::CaloBlueprintNodeBuilder:

Public Member Functions
StatusCode	initialize () override
StatusCode	finalize () override
std::shared_ptr< Acts::BlueprintNode >	buildBlueprintNode (const Acts::GeometryContext &gctx, std::shared_ptr< Acts::BlueprintNode > &&childNode) override
	Build the Itk Blueprint Node.

Private Member Functions
void	fillMaps (std::map< caloRegion, caloSampleDDEElementsMap_t > &caloRegionSampleDDEElementsMap, std::map< std::string, double > &caloDimensions) const
	fillMaps fills two maps.
void	generateCylinderSurfaces (caloSampleSurfaceMap_t &caloSampleSurfaceMap, caloSampleDDEElementsMap_t &caloSampleDDEElementsMap, bool asymmetricZ) const
	generateCylinderSurfaces generates cylindrical surfaces for each calo sampling.
std::shared_ptr< Acts::CylinderSurface >	generateCylinderSurface (const double maxLArBRadius, const double minLArBRadius, const double lowZLarB, const double highZLarB) const
	generateCylinderSurface generates a cylindrical surface for a given set of parameters.
void	addCylindricalTrackingVolumeToCaloNode (Acts::CylinderContainerBlueprintNode &containerNode, const std::string &volumeName, const std::vector< std::shared_ptr< Acts::Surface > > &surfaces, int layerIndex, const bool &isDisc) const
	addCylindricalTrackingVolumeToCaloNode adds a cylindrical tracking volume to the calo node.
void	generateDiscSurfaces (caloSampleSurfaceMap_t &caloSampleSurfaceMap, caloSampleDDEElementsMap_t &caloSampleDDEElementsMap) const
std::shared_ptr< Acts::DiscSurface >	generateDiscSurface (const double &z, const double &maxLArBRadius, const double &minLArBRadius) const
std::string	getSampleName (CaloCell_ID::CaloSample currentSample) const
CaloCell_ID::CaloSample	getSampleEnum (const std::string &sampleName) const

Private Attributes
std::unique_ptr< CaloDetDescrManager >	m_caloDetSecrMgr
std::vector< std::pair< std::string, CaloCell_ID::CaloSample > >	m_caloDiscSampleList
std::vector< std::pair< std::string, CaloCell_ID::CaloSample > >	m_caloCylinderSymmetricSampleList
std::vector< std::pair< std::string, CaloCell_ID::CaloSample > >	m_caloCylinderAsymmetricSampleList
Gaudi::Property< double >	m_radiusTolerance
Gaudi::Property< double >	m_zTolerance

Detailed Description

Builds the Calo Blueprint Node.

Definition at line 33 of file CaloBlueprintNodeBuilder.h.

Member Function Documentation

addCylindricalTrackingVolumeToCaloNode()

void ActsTrk::CaloBlueprintNodeBuilder::addCylindricalTrackingVolumeToCaloNode ( Acts::CylinderContainerBlueprintNode & containerNode, const std::string & volumeName, const std::vector< std::shared_ptr< Acts::Surface > > & surfaces, int layerIndex, const bool & isDisc ) const

private

addCylindricalTrackingVolumeToCaloNode adds a cylindrical tracking volume to the calo node.

It takes as input the container node, the calo dimensions map, the name of the volume and the vector of surfaces to be added to the volume. It creates a new CylinderContainerBlueprintNode in the container node, then creates a new Acts::TrackingVolume with the appropriate dimensions. Finally it adds the Acts::CylinderSurface to that Acts::TrackingVolume, then adds the tracking volume to the container node.

Definition at line 512 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                                                                                                                                      {
 
  // Construct the container node with geometry identifier and layer, and add the surfaces to the layer.
  Acts::GeometryIdentifierBlueprintNode& geoIdNode = containerNode.withGeometryIdentifier();
  geoIdNode.setAllVolumeIdsTo(s_caloBarrelId +
  layerIndex);
 
  AxisDirection axis = AxisDirection::AxisZ;
  if (isDisc) axis = AxisDirection::AxisR;
  CylinderContainerBlueprintNode& cylinder = geoIdNode.addCylinderContainer(volumeName,
  axis);
 
  cylinder.addLayer(volumeName + "_Layer", [&](auto& layer) {
        layer.setSurfaces(surfaces);
        layer.setEnvelope(Acts::ExtentEnvelope{{
            .z = {0.1_mm, 0.1_mm},
            .r = {2_mm, 2_mm},
        }});
    });
 
}

buildBlueprintNode()

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

override

Build the Itk Blueprint Node.

Parameters

gctx	Geometry context
child	The child node which is added to the itk node.

Definition at line 47 of file CaloBlueprintNodeBuilder.cxx.

                                                                                {
 
 
  std::map<caloRegion, caloSampleSurfaceMap_t> caloRegionSampleSurfaceMap;
  std::map<caloRegion, caloSampleDDEElementsMap_t> caloRegionSampleDDEElementsMap;
  std::map<std::string, double> caloDimensions;
 
  fillMaps(caloRegionSampleDDEElementsMap, caloDimensions);
 
  ATH_MSG_DEBUG("Have filled first two maps");
 
  generateCylinderSurfaces(caloRegionSampleSurfaceMap[caloRegion::CylinderSymmetricZZero], caloRegionSampleDDEElementsMap[caloRegion::CylinderSymmetricZZero],false);
  generateCylinderSurfaces(caloRegionSampleSurfaceMap[caloRegion::CylinderNegativeZ], caloRegionSampleDDEElementsMap[caloRegion::CylinderNegativeZ],true);
  generateCylinderSurfaces(caloRegionSampleSurfaceMap[caloRegion::CylinderPositiveZ], caloRegionSampleDDEElementsMap[caloRegion::CylinderPositiveZ],true);
  generateDiscSurfaces(caloRegionSampleSurfaceMap[caloRegion::DiscNegativeZ], caloRegionSampleDDEElementsMap[caloRegion::DiscNegativeZ]);
  generateDiscSurfaces(caloRegionSampleSurfaceMap[caloRegion::DiscPositiveZ], caloRegionSampleDDEElementsMap[caloRegion::DiscPositiveZ]);
 
  ATH_MSG_DEBUG("Have generated calorimeter cylindrical surfaces");
 
  // The calo node is a container node that will hold the itk and calo nodes as children. 
  // The calo cylinder is static in order to avoid merging issues with the itk portals 
  // that are supposed to carry material.
  // The envelope of the calo node is set to the maximum radius and half length in z of the calorimeter, 
  // which is via a loop over all CaloDetDescrElements in the CaloDetDescrManager in the fillMaps function.
 
  double caloEvelopeMaxR = caloDimensions.at("maxR") + 5._mm;
  double caloEnvelopeHalfLenghtZ = (caloDimensions.at("maxPosZ") - caloDimensions.at("minNegZ"))/2.0  + 5._mm;
 
  ATH_MSG_INFO("Calo envelope dimensions: maxR = " << caloEvelopeMaxR << ", halfLengthZ = " << caloEnvelopeHalfLenghtZ);
  std::shared_ptr<StaticBlueprintNode> itkCaloNode{};
  {
    auto envelope = std::make_unique<TrackingVolume>(Amg::Transform3D::Identity(),
                                                     std::make_shared<CylinderVolumeBounds>(0., caloEvelopeMaxR, caloEnvelopeHalfLenghtZ),"ITkCalo");
    envelope->assignGeometryId(Acts::GeometryIdentifier{}.withVolume(s_caloEnvelopeID));
    itkCaloNode = std::make_shared<StaticBlueprintNode>(std::move(envelope));
  }
  if (childNode) {
    itkCaloNode->addChild(std::move(childNode));
  }
 
  ATH_MSG_DEBUG("Top level calorimeter node created");
            
  auto caloNode = std::make_shared<CylinderContainerBlueprintNode>("CaloNode", AxisDirection::AxisZ);
  CylinderContainerBlueprintNode& caloBarrelCylinderNode = caloNode->addCylinderContainer("CaloBarrelSymmetricZZeroCylinders", AxisDirection::AxisR);
  caloBarrelCylinderNode.setAttachmentStrategy(VolumeAttachmentStrategy::Gap);
  caloBarrelCylinderNode.setResizeStrategy(ResizeStrategy::Gap);
  
  ATH_MSG_DEBUG("EM Barrel container node created");
 
  unsigned int volumeCounter = 0;
 
  //Barrel cylinders symmetric about z = 0
  for (unsigned int sampleIndex = 0; sampleIndex < m_caloCylinderSymmetricSampleList.size(); ++sampleIndex) {
    auto& sampleName = m_caloCylinderSymmetricSampleList.at(sampleIndex).first;
    addCylindricalTrackingVolumeToCaloNode(caloBarrelCylinderNode, sampleName, caloRegionSampleSurfaceMap[caloRegion::CylinderSymmetricZZero].at({sampleName, getSampleEnum(sampleName)}), volumeCounter, false);
    volumeCounter++;
  }
 
  //now do asymmetric cylinders
  for (unsigned int sampleIndex = 0; sampleIndex < m_caloCylinderAsymmetricSampleList.size(); ++sampleIndex) {
    auto& sampleName = m_caloCylinderAsymmetricSampleList.at(sampleIndex).first;
    //The tile extended barrel and gap must be added to top level node directly because they always overlap in R
    //or Z with other calorimeter surfaces, volumes etc.
    //Note there is a speed penalty to do it this way.
    itkCaloNode->addLayer(sampleName+"NegZ_Layer", [&](auto& layer) {
      layer.setSurfaces(caloRegionSampleSurfaceMap[caloRegion::CylinderNegativeZ].at({sampleName, getSampleEnum(sampleName)}));
      layer.setEnvelope(Acts::ExtentEnvelope{{
          .z = {0.1_mm, 0.1_mm},
          .r = {2_mm, 2_mm},
      }});
    });
    itkCaloNode->addLayer(sampleName+"PosZ_Layer", [&](auto& layer) {
      layer.setSurfaces(caloRegionSampleSurfaceMap[caloRegion::CylinderPositiveZ].at({sampleName, getSampleEnum(sampleName)}));
      layer.setEnvelope(Acts::ExtentEnvelope{{
          .z = {0.1_mm, 0.1_mm},
          .r = {2_mm, 2_mm},
      }});
    });
  }
 
  auto caloEndCapNegativeNode = std::make_shared<CylinderContainerBlueprintNode>("CaloNode", AxisDirection::AxisZ);
  
  CylinderContainerBlueprintNode& caloEndCapDiscNegativeZNode = caloEndCapNegativeNode->addCylinderContainer("CaloEndCapDiscNegativeZ", AxisDirection::AxisZ);
  caloEndCapDiscNegativeZNode.setAttachmentStrategy(VolumeAttachmentStrategy::Gap);
  // The -z end of this container defines the calorimeter's global minZ, so the
  // enclosing envelope's -z edge coincides with this container's own -z edge to
  // within floating-point rounding. With ResizeStrategy::Gap on that side, the
  // resize mints a degenerate (~1e-13 mm) end-gap volume whose two disc faces
  // coincide, which CylinderNavigationPolicy cannot resolve. Expand the
  // outermost wheel on the boundary (-z) side instead; keep Gap on the interior
  // (+z) side. NOTE: (inner, outer) map to (minZ, maxZ) for an AxisZ stack.
  caloEndCapDiscNegativeZNode.setResizeStrategies(ResizeStrategy::Expand, ResizeStrategy::Gap);
 
  auto caloEndCapPositiveNode = std::make_shared<CylinderContainerBlueprintNode>("CaloNode", AxisDirection::AxisZ);
  CylinderContainerBlueprintNode& caloEndCapDiscPositiveZNode = caloEndCapPositiveNode->addCylinderContainer("CaloEndCapDiscPositiveZ", AxisDirection::AxisZ);
  caloEndCapDiscPositiveZNode.setAttachmentStrategy(VolumeAttachmentStrategy::Gap);
  // Mirror of the negative endcap: the +z (maxZ, outer) end is the global maxZ
  // boundary, so Expand there and keep Gap on the interior (-z) side.
  caloEndCapDiscPositiveZNode.setResizeStrategies(ResizeStrategy::Gap, ResizeStrategy::Expand);
  
  for (unsigned int sampleIndex = 0; sampleIndex < m_caloDiscSampleList.size(); ++sampleIndex) {
    auto& sampleName = m_caloDiscSampleList.at(sampleIndex).first;
    addCylindricalTrackingVolumeToCaloNode(caloEndCapDiscNegativeZNode, sampleName+"NegZ", caloRegionSampleSurfaceMap[caloRegion::DiscNegativeZ].at({sampleName, getSampleEnum(sampleName)}), volumeCounter, true);
    volumeCounter++;
    addCylindricalTrackingVolumeToCaloNode(caloEndCapDiscPositiveZNode, sampleName+"PosZ", caloRegionSampleSurfaceMap[caloRegion::DiscPositiveZ].at({sampleName, getSampleEnum(sampleName)}), volumeCounter, true);
    volumeCounter++;
  }
  
  ATH_MSG_DEBUG("Have added all Barrel layers to caloBarrelCylinderNode");
 
  // Add calo barrel node to the top level calo node.
  itkCaloNode->addChild(caloNode);
  itkCaloNode->addChild(caloEndCapNegativeNode);
  itkCaloNode->addChild(caloEndCapPositiveNode);
 
  //return the top level calo node
  return itkCaloNode;
}

fillMaps()

void ActsTrk::CaloBlueprintNodeBuilder::fillMaps ( std::map< caloRegion, caloSampleDDEElementsMap_t > & caloRegionSampleDDEElementsMap, std::map< std::string, double > & caloDimensions ) const

private

fillMaps fills two maps.

The first maps each calo sampling to a vector of surfaces (initially empty) The second maps each calo sampling to a vector of CaloDetDescrElements The second map is filled by looping over all DDE in the CaloDetDescrManager and adding each DDE to the vector corresponding to its sampling in the map

Definition at line 172 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                             {
 
 
  //loop over all possible calo sampling layers
  //and create empty vectors of surfaces in the map
 
  //Create map between each calorimeter sampling and a vector of
  //cylinder surfaces. We can have N cylinders in a given sampling,
  //and the value of N is determined by how often the average radius 
  //calculated for a given phi ring, at fixed Z, changes by more than 
  //a tolerance value
 
  float maxR{0.}, maxPosZ{-std::numeric_limits<float>::max()}, minNegZ{std::numeric_limits<float>::max()};
 
  //for each calo sampling collect all the DDE in a vector    
  for (const CaloDetDescrElement* theDDE : m_caloDetSecrMgr->element_range()){
    if (!theDDE){ 
      ATH_MSG_ERROR("Null pointer to CaloDetDescrElement");
      continue;
    }
 
    maxR = std::max(theDDE->r(), maxR);
    maxPosZ = std::max(maxPosZ, theDDE->z());
    minNegZ = std::min(minNegZ, theDDE->z());
 
    CaloCell_ID::CaloSample currentSample=theDDE->getSampling();
    std::pair <std::string, CaloCell_ID::CaloSample> samplePair = std::make_pair(getSampleName(currentSample), currentSample);
    
    //check if have cylinder symmetric about z = 0
    if (Acts::rangeContainsValue(m_caloCylinderSymmetricSampleList, samplePair)){
      caloRegionSampleDDEElementsMap[caloRegion::CylinderSymmetricZZero][samplePair].push_back(theDDE);
    }
    
    //check if have cylinder asymmetric about z = 0, if so check if in negative or positive z
    if (Acts::rangeContainsValue(m_caloCylinderAsymmetricSampleList, samplePair)){
      if (theDDE->z() < 0.0) {
        caloRegionSampleDDEElementsMap[caloRegion::CylinderNegativeZ][samplePair].push_back(theDDE);
      }
      else {
        caloRegionSampleDDEElementsMap[caloRegion::CylinderPositiveZ][samplePair].push_back(theDDE);
      }
    }
 
    //check if sampling is in disc list
    if (Acts::rangeContainsValue(m_caloDiscSampleList, samplePair)) {
      //check if in negative or positive z
      if (theDDE->z() < 0.0) {
        caloRegionSampleDDEElementsMap[caloRegion::DiscNegativeZ][samplePair].push_back(theDDE);
      } else {
        caloRegionSampleDDEElementsMap[caloRegion::DiscPositiveZ][samplePair].push_back(theDDE);
      }
    }
  }
 
  caloDimensions["maxR"] = maxR;
  caloDimensions["maxPosZ"] = maxPosZ;
  caloDimensions["minNegZ"] = minNegZ;
 
  auto sortAllLayersInZ = [&caloRegionSampleDDEElementsMap](const std::vector<std::pair<std::string, CaloCell_ID::CaloSample>>& caloSampleList, const caloRegion& region) {
    for (const auto & currentSample : caloSampleList) {
      std::vector<const CaloDetDescrElement*>& currentElements = caloRegionSampleDDEElementsMap[region][currentSample];
      std::ranges::sort(currentElements, 
                        [](const CaloDetDescrElement* a, 
                           const CaloDetDescrElement* b) {
                            return a->z() < b->z();
                        });
    }
  };
 
  //Sort the DDE, by Z, in all possible layers
  sortAllLayersInZ(m_caloCylinderSymmetricSampleList, caloRegion::CylinderSymmetricZZero);
  sortAllLayersInZ(m_caloCylinderAsymmetricSampleList, caloRegion::CylinderNegativeZ);
  sortAllLayersInZ(m_caloCylinderAsymmetricSampleList, caloRegion::CylinderPositiveZ);
 
  auto sortAllLayersInR = [&caloRegionSampleDDEElementsMap](const std::vector<std::pair<std::string, CaloCell_ID::CaloSample>>& caloSampleList, const caloRegion& region) {
    for (const auto& currentSample : caloSampleList) {
      std::vector<const CaloDetDescrElement*>& currentElements = caloRegionSampleDDEElementsMap[region][currentSample];
      std::ranges::sort(currentElements, 
                        [](const CaloDetDescrElement* a, 
                           const CaloDetDescrElement* b) {
                            return a->r() < b->r();
                        });
    }
  };
 
  //Sort the DDE, by R, in all possible layers
  sortAllLayersInR(m_caloDiscSampleList, caloRegion::DiscNegativeZ);
  sortAllLayersInR(m_caloDiscSampleList, caloRegion::DiscPositiveZ);
 
}

finalize()

StatusCode ActsTrk::CaloBlueprintNodeBuilder::finalize ( )

override

Definition at line 167 of file CaloBlueprintNodeBuilder.cxx.

                                                     {
  ATH_MSG_DEBUG("Finalizing CaloBlueprintNodeBuilder");
  return StatusCode::SUCCESS;
}

generateCylinderSurface()

std::shared_ptr< CylinderSurface > ActsTrk::CaloBlueprintNodeBuilder::generateCylinderSurface ( const double maxLArBRadius, const double minLArBRadius, const double lowZLarB, const double highZLarB ) const

private

generateCylinderSurface generates a cylindrical surface for a given set of parameters.

To do this it calculates the radius and length of the cylinder, then shifts it in Z to the midpoint of the Z values used to build it. It then creates the Acts::CylinderSurface and returns it via a shared pointer.

Definition at line 379 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                         {
 
  //Characterise the dimensions of the  cylinder
  double LArBRadius = (maxLArBRadius + minLArBRadius) / 2.0;
  double LArBLength = std::abs(highZLarB - lowZLarB);
 
  double zShift = (highZLarB + lowZLarB) / 2.0;
  ATH_MSG_DEBUG("Cylinder radius and length are " << LArBRadius << " and " << 0.5*(LArBLength) << " with shift of " << zShift
            <<"lowZLarB: "<<lowZLarB<<", highZLarB: "<<highZLarB);
  return Surface::makeShared<CylinderSurface>(Amg::getTranslateZ3D(zShift), LArBRadius, LArBLength/2);
 
}

generateCylinderSurfaces()

void ActsTrk::CaloBlueprintNodeBuilder::generateCylinderSurfaces ( caloSampleSurfaceMap_t & caloSampleSurfaceMap, caloSampleDDEElementsMap_t & caloSampleDDEElementsMap, bool asymmetricZ ) const

private

generateCylinderSurfaces generates cylindrical surfaces for each calo sampling.

It does this for cylindrical layers by scanning in Z, for each Z finding the average radius of the cells in a phi ring If the average radius changes by more than a tolerance value (m_radiusTolerance), a new cylinder surface is created. The surfaces are added to the relevant vector of surfaces in the caloSampleSurfaceMap.

Definition at line 264 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                                                                        {
 
  const std::vector<std::pair<std::string, CaloCell_ID::CaloSample>>& sampleList{asymmetricZ ?
      m_caloCylinderAsymmetricSampleList : m_caloCylinderSymmetricSampleList};
 
  for (const auto & currentSample : sampleList) {
 
    const std::vector<const CaloDetDescrElement*>& currentElements = caloSampleDDEElementsMap[currentSample];
 
    double maxLArBRadius = 0.0, minLArBRadius = std::numeric_limits<double>::max();
    double lowZLarB = std::numeric_limits<double>::max(), 
          highZLarB = -std::numeric_limits<double>::max();
 
    //loop over cells runs from -z to +z in a given sampling layer
    //There are many cells with the same z value, but different phi values
    //We will find the average radius of the cells in a given phi ring
    double totalRadiusFixedPhi = 0.0;
    bool firstCellInPhiRing = true;
    unsigned int phiCounter = 0;
 
    //Then we will also track changes in radius as we move in Z from
    //each ring of cells in phi to the next ring of cells in phi
    bool firstPhiRing = true;
    double initialRadius = 0.0;
    double initialZ = -std::numeric_limits<double>::max();
 
    //check if we ever move along in Z value
    bool movedInZ = false;
 
    for (const CaloDetDescrElement* theDDE : currentElements){
 
      double z = theDDE->z();   
      double radius = theDDE->r();
 
      ATH_MSG_DEBUG(" Calo Sampling is " << currentSample.first);
 
      if (firstCellInPhiRing) {
        ATH_MSG_DEBUG("First Cell in phi ring " << currentSample.first << " has z = " << z << " and r = " << radius);
        initialZ = z;
        firstCellInPhiRing = false;
      }
 
      if (firstPhiRing) {
        ATH_MSG_DEBUG("First Cell in layer " << currentSample.first << " has z = " << z << " and r = " << radius);
        initialRadius = theDDE->r();
        firstPhiRing = false;
        lowZLarB = z;
      }
 
      ATH_MSG_DEBUG("Z and initialZ are " << z << " and " << initialZ);
 
      //if z has not changed then we add the radius to the summed radius for this phi ring
      //and increment the counter of cells in this phi ring
      if (std::abs(z - initialZ) < 0.0001) {
        ATH_MSG_DEBUG("phiCounter is " << phiCounter << " and radius is " << radius << " and totalRadiusFixedPhi is " << totalRadiusFixedPhi << " and hash is " << theDDE->calo_hash());
        totalRadiusFixedPhi += radius;
        phiCounter++;
        continue;
      }
      else {
        movedInZ = true;
        firstCellInPhiRing = true;
        if (phiCounter > 0) {
          double cellRingRadius = totalRadiusFixedPhi / phiCounter;
          totalRadiusFixedPhi = 0.0;
          phiCounter = 0;
 
          maxLArBRadius = std::max(maxLArBRadius, cellRingRadius);
          minLArBRadius = std::min(minLArBRadius, cellRingRadius);
 
          //if radius changes by more than tolerance, then we will create a cylinder
          //with the average cell radius and length from neg to pos z
          highZLarB = z;
          ATH_MSG_DEBUG("Values of cellRingRadius, initialRadius, highZLarB and lowZLarB are " << cellRingRadius << ", " << initialRadius << ", " << highZLarB << " and " << lowZLarB);
          if (std::abs(cellRingRadius - initialRadius) > m_radiusTolerance && 
              highZLarB - lowZLarB > 0.0) {
            ATH_MSG_DEBUG("CYLINDER: Create cylinder for layer " << currentSample.first);                
            ATH_MSG_DEBUG("CYLINDER: Create Cylinder: Min and Max LAr B radius are " << minLArBRadius << " " << maxLArBRadius);
            ATH_MSG_DEBUG("CYLINDER: Create Cylinder: Min and Max LAr B z are " << lowZLarB << " " << highZLarB);
 
            caloSampleSurfaceMap[currentSample].push_back(generateCylinderSurface(maxLArBRadius, minLArBRadius, lowZLarB, highZLarB));
 
            //reset the dimensions of the cylinder to the initial conditions, in 
           //preparation for the next cylinder
           firstPhiRing = true;
           minLArBRadius = std::numeric_limits<double>::max();
           maxLArBRadius = 0.0;
           lowZLarB = 0.0;
           highZLarB = 0.0;
          }//if radius changes by more than tolerance
        }//if at least one cell in phi (should always be the case!)
        else ATH_MSG_ERROR("phiCounter is zero!");
      }//if z has changed
    }//loop over calorimeter DDE
 
    if (0 == caloSampleSurfaceMap[currentSample].size()){
      //If we never found any shift in Z whilst looping over the DDE
      //then thee min/max Z and radius were not set
      //so we set them here.
      if (!movedInZ) {
        lowZLarB = initialZ;
        highZLarB = initialZ+0.001;
        if (phiCounter > 0) {
          maxLArBRadius = totalRadiusFixedPhi / phiCounter;
          minLArBRadius = 0.0;
        }
      }
      ATH_MSG_DEBUG("CYLINDER: Zero size Vector: Create cylinder for layer " << currentSample.first);   
      ATH_MSG_DEBUG("CYLINDER: Create Cylinder: Min and Max LAr B radius are " << minLArBRadius << " " << maxLArBRadius);
      ATH_MSG_DEBUG("CYLINDER: Create Cylinder: Min and Max LAr B z are " << lowZLarB << " " << highZLarB);
      caloSampleSurfaceMap[currentSample].push_back(generateCylinderSurface(maxLArBRadius, minLArBRadius, lowZLarB, highZLarB));
    }
  }   
}

generateDiscSurface()

std::shared_ptr< Acts::DiscSurface > ActsTrk::CaloBlueprintNodeBuilder::generateDiscSurface ( const double & z, const double & maxLArBRadius, const double & minLArBRadius ) const

private

Definition at line 503 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                                                  {
 
  ATH_MSG_DEBUG("DISC: Disc min and max radius are " << minLArBRadius << " and " << maxLArBRadius << " with z of " << z);
  auto surface = Surface::makeShared<DiscSurface>(Amg::getTranslateZ3D(z), minLArBRadius, maxLArBRadius);
 
  return surface;
 
}

generateDiscSurfaces()

void ActsTrk::CaloBlueprintNodeBuilder::generateDiscSurfaces ( caloSampleSurfaceMap_t & caloSampleSurfaceMap, caloSampleDDEElementsMap_t & caloSampleDDEElementsMap ) const

private

Definition at line 395 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                                                  {
 
  for (const auto & currentSample : m_caloDiscSampleList) {
 
        const std::vector<const CaloDetDescrElement*> & currentElements = caloSampleDDEElementsMap[currentSample];
 
        //FCAL is treated differently because it is non-projective
        //We create one surface for each of FCAL0, FCAL1 and FCAL2
        if (CaloCell_ID::FCAL0 == currentSample.second || CaloCell_ID::FCAL1 == currentSample.second || CaloCell_ID::FCAL2 == currentSample.second) {
          ATH_MSG_DEBUG("TOM3: FCAL sampling " << currentSample.second);    
          
          double fcalRMin = std::numeric_limits<double>::max();
          double fcalRMax = std::numeric_limits<double>::min();
          double fcalZSum = 0;
          size_t cellCount = 0;
 
          for (const CaloDetDescrElement*  theDDE : currentElements) {
            double r = theDDE->r();
            fcalRMin = std::min(fcalRMin,r);
            fcalRMax = std::max(fcalRMax,r);
            fcalZSum += theDDE->z();
            cellCount++;
          }
          if (cellCount == 0)[[unlikely]]{
            ATH_MSG_WARNING("cellCount is zero in CaloBlueprintNodeBuilder::generateDiscSurfaces");
            continue;
          }
          double fcalZ = fcalZSum / cellCount;
          caloSampleSurfaceMap[currentSample].push_back(generateDiscSurface(fcalZ,fcalRMax, fcalRMin));
          //now continue to the next sampling
          continue;
        }
 
        //For other disc calorimeter layers we proceed to create many surfaces as needed.
        double totalZFixedPhi = 0.0;
        bool firstCellInPhiRing = true;
        unsigned int phiCounter = 0;
 
        bool firstPhiRing = true;
        double initialRadius = 0.0;
        double initialZ = -std::numeric_limits<double>::max();
 
        //loop over cells runs from -z to +z in a given sampling layer
        //There are many cells with the same z value, but different phi values
        //We will find a min amd max radius in this phi ring.
        double minDiscRadius = std::numeric_limits<double>::max(), maxDiscRadius = 0.0;
 
        unsigned int currentElementsSize = currentElements.size();
        unsigned int DDECounter = 0;
 
        for (const CaloDetDescrElement* theDDE : currentElements){
 
            bool isLastDDE = (DDECounter == (currentElementsSize-1));
 
            ATH_MSG_DEBUG("Disc DDE with sampling, r and z of " << currentSample << ", " << theDDE->r() << ", " << theDDE->z());
            ATH_MSG_DEBUG("isLastDDE is " << isLastDDE);
 
            double z = theDDE->z();   
            double radius = theDDE->r();
 
            if (firstCellInPhiRing) {
                initialRadius = radius;
                firstCellInPhiRing = false;
            }
 
            if (firstPhiRing) {
                initialZ = z;
                firstPhiRing = false;
                minDiscRadius = radius;
            }
 
            //if radius is unchanged then we add the z to the summed z for this phi ring
            //and increment the counter of cells in this phi ring
            if (std::abs(radius - initialRadius) < 0.0001 && !isLastDDE) {
                totalZFixedPhi += z;
                phiCounter++;
                DDECounter++;
                continue;
            }
            else {
                firstCellInPhiRing = true;
                if (phiCounter > 0) {
                    double cellRingZ = totalZFixedPhi / phiCounter;
                    totalZFixedPhi = 0.0;
                    phiCounter = 0;
 
                    //if z changes by more than tolerance, then we will create a disc
                    //with the min and max radius found
                    //if we reach the last DDE and no new surface has been created, then we also create a disc surface
                    maxDiscRadius = radius;
                    ATH_MSG_DEBUG("cellRingZ, initialZ and z tolerance are " << cellRingZ << ", " << initialZ << " and " << m_zTolerance);
                    if (std::abs(cellRingZ - initialZ) > m_zTolerance || isLastDDE) {
                      ATH_MSG_DEBUG("DISC: About to create disc surface for sampling " << currentSample);
                        caloSampleSurfaceMap[currentSample].push_back(generateDiscSurface(cellRingZ,maxDiscRadius, minDiscRadius));
                        //reset the dimensions of the disc to the initial conditions, in 
                        //preparation for the next disc
                        minDiscRadius = std::numeric_limits<double>::max();
                        maxDiscRadius = 0.0;
                        firstPhiRing = true; 
                    }//if z changes by more than tolerance
                }//if at least one cell in phi (should always be the case!)
                else ATH_MSG_ERROR("phiCounter is zero!");
            }//if radius has changed
            DDECounter++;
        }//loop over calorimeter DDE
  }//loop over calo samplings        
}

getSampleEnum()

CaloCell_ID::CaloSample ActsTrk::CaloBlueprintNodeBuilder::getSampleEnum ( const std::string & sampleName ) const

inlineprivate

Definition at line 156 of file CaloBlueprintNodeBuilder.h.

                                                                           {
      CaloCell_ID::CaloSample sampleEnum = CaloCell_ID::Unknown;
      for (auto& [name, sample] : m_caloCylinderSymmetricSampleList) {
        if (sampleName == name) {
          sampleEnum = sample;
          break;
        }
      }
      if (sampleEnum == CaloCell_ID::Unknown) {
        for (auto& [name, sample] : m_caloCylinderAsymmetricSampleList) {
          if (sampleName == name) {
            sampleEnum = sample;
            break;
          }
        }
      }
      if (sampleEnum == CaloCell_ID::Unknown) {
        for (auto& [name, sample] : m_caloDiscSampleList) {
          if (sampleName == name) {
            sampleEnum = sample;
            break;
          }
        }
      }
      return sampleEnum;
    }

getSampleName()

std::string ActsTrk::CaloBlueprintNodeBuilder::getSampleName ( CaloCell_ID::CaloSample currentSample ) const

inlineprivate

Definition at line 129 of file CaloBlueprintNodeBuilder.h.

                                                                       {
      std::string sampleName = "";
      for ( auto& [name, sample] : m_caloCylinderSymmetricSampleList) {
        if (currentSample == sample) {
          sampleName = name;
          break;
        }
      }
      if (sampleName == "") {
        for ( auto& [name, sample] : m_caloCylinderAsymmetricSampleList) {
          if (currentSample == sample) {
            sampleName = name;
            break;
          }
        }
      }
      if (sampleName == "") {
        for ( auto& [name, sample] : m_caloDiscSampleList) {
          if (currentSample == sample) {
            sampleName = name;
            break;
          }
        }
      }
      return sampleName;
    }

initialize()

StatusCode ActsTrk::CaloBlueprintNodeBuilder::initialize ( )

override

Definition at line 39 of file CaloBlueprintNodeBuilder.cxx.

                                                       {
  ATH_MSG_DEBUG("Initializing CaloBlueprintNodeBuilder");
 
  m_caloDetSecrMgr = buildCaloDetDescrNoAlign(serviceLocator(), Athena::getMessageSvc());
  
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_caloCylinderAsymmetricSampleList

std::vector<std::pair<std::string, CaloCell_ID::CaloSample> > ActsTrk::CaloBlueprintNodeBuilder::m_caloCylinderAsymmetricSampleList

private

Initial value:

{ 
          {"TileGap1", CaloCell_ID::TileGap1},
          {"TileGap2", CaloCell_ID::TileGap2},
          {"TileExt0", CaloCell_ID::TileExt0},
          {"TileExt1", CaloCell_ID::TileExt1},
          {"TileExt2", CaloCell_ID::TileExt2}}

Definition at line 111 of file CaloBlueprintNodeBuilder.h.

                                                                                               { 
          {"TileGap1", CaloCell_ID::TileGap1},
          {"TileGap2", CaloCell_ID::TileGap2},
          {"TileExt0", CaloCell_ID::TileExt0},
          {"TileExt1", CaloCell_ID::TileExt1},
          {"TileExt2", CaloCell_ID::TileExt2}};

m_caloCylinderSymmetricSampleList

std::vector<std::pair<std::string, CaloCell_ID::CaloSample> > ActsTrk::CaloBlueprintNodeBuilder::m_caloCylinderSymmetricSampleList

private

Initial value:

{ 
          { "PreSamplerB", CaloCell_ID::PreSamplerB}, 
          {"EMB1", CaloCell_ID::EMB1},
          {"EMB2", CaloCell_ID::EMB2},
          {"EMB3", CaloCell_ID::EMB3},
          {"TileBar0", CaloCell_ID::TileBar0},
          {"TileBar1", CaloCell_ID::TileBar1},
          {"TileBar2", CaloCell_ID::TileBar2}}

Definition at line 102 of file CaloBlueprintNodeBuilder.h.

                                                                                              { 
          { "PreSamplerB", CaloCell_ID::PreSamplerB}, 
          {"EMB1", CaloCell_ID::EMB1},
          {"EMB2", CaloCell_ID::EMB2},
          {"EMB3", CaloCell_ID::EMB3},
          {"TileBar0", CaloCell_ID::TileBar0},
          {"TileBar1", CaloCell_ID::TileBar1},
          {"TileBar2", CaloCell_ID::TileBar2}};

m_caloDetSecrMgr

std::unique_ptr<CaloDetDescrManager> ActsTrk::CaloBlueprintNodeBuilder::m_caloDetSecrMgr

private

Definition at line 83 of file CaloBlueprintNodeBuilder.h.

m_caloDiscSampleList

std::vector<std::pair<std::string, CaloCell_ID::CaloSample> > ActsTrk::CaloBlueprintNodeBuilder::m_caloDiscSampleList

private

Initial value:

{
          {"PreSamplerE", CaloCell_ID::PreSamplerE},
          {"EME1",CaloCell_ID::EME1},
          {"EME2",CaloCell_ID::EME2},
          {"EME3",CaloCell_ID::EME3},
          {"HEC0",CaloCell_ID::HEC0},
          {"HEC1",CaloCell_ID::HEC1},
          {"HEC2",CaloCell_ID::HEC2}, 
          {"HEC3",CaloCell_ID::HEC3}, 
          {"TileGap3",CaloCell_ID::TileGap3},
          {"FCAL0",CaloCell_ID::FCAL0},
          {"FCAL1",CaloCell_ID::FCAL1},
          {"FCAL2",CaloCell_ID::FCAL2}}

Definition at line 88 of file CaloBlueprintNodeBuilder.h.

                                                                                 {
          {"PreSamplerE", CaloCell_ID::PreSamplerE},
          {"EME1",CaloCell_ID::EME1},
          {"EME2",CaloCell_ID::EME2},
          {"EME3",CaloCell_ID::EME3},
          {"HEC0",CaloCell_ID::HEC0},
          {"HEC1",CaloCell_ID::HEC1},
          {"HEC2",CaloCell_ID::HEC2}, 
          {"HEC3",CaloCell_ID::HEC3}, 
          {"TileGap3",CaloCell_ID::TileGap3},
          {"FCAL0",CaloCell_ID::FCAL0},
          {"FCAL1",CaloCell_ID::FCAL1},
          {"FCAL2",CaloCell_ID::FCAL2}};

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 118 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_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 123 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:

• CaloBlueprintNodeBuilder.h
• CaloBlueprintNodeBuilder.cxx