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::Experimental::BlueprintNode >	buildBlueprintNode (const Acts::GeometryContext &gctx, std::shared_ptr< Acts::Experimental::BlueprintNode > &&childNode) override
	Build the Itk Blueprint Node.

Private Member Functions
void	fillMaps (caloSampleSurfaceMap_t &caloSampleSurfaceMap, caloSampleDDEElementsMap_t &caloSampleDDEElementsMap) const
	fillMaps fills two maps.
void	fillCaloDimensionsMap (caloDimensionMap_t &caloDimensionsMap, caloSampleDDEElementsMap_t &caloSampleDDEElementsMap) const
	fillCaloDimensionsMap fills a map of calorimeter dimensions for each sampling layer.
void	generateCylinderSurfaces (caloSampleSurfaceMap_t &caloSampleSurfaceMap, caloSampleDDEElementsMap_t &caloSampleDDEElementsMap) 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::Experimental::CylinderContainerBlueprintNode &containerNode, caloDimensionMap_t &caloDimensionMap, const std::string &volumeName, const std::vector< std::shared_ptr< Acts::Surface > > &surfaces, int layerIndex) const
	addCylindricalTrackingVolumeToCaloNode adds a cylindrical tracking volume to the calo node.
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_caloCylinderSampleList
Gaudi::Property< double >	m_radiusTolerance
Gaudi::Property< double >	m_zTolerance

Detailed Description

Builds the Calo Blueprint Node.

Definition at line 30 of file CaloBlueprintNodeBuilder.h.

Member Function Documentation

addCylindricalTrackingVolumeToCaloNode()

void ActsTrk::CaloBlueprintNodeBuilder::addCylindricalTrackingVolumeToCaloNode ( Acts::Experimental::CylinderContainerBlueprintNode & containerNode, caloDimensionMap_t & caloDimensionMap, const std::string & volumeName, const std::vector< std::shared_ptr< Acts::Surface > > & surfaces, int layerIndex ) 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 355 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                                                                                                                                         {
 
  // Construct the container node with geometry identifier and layer, and add the surfaces to the layer.
 
  Acts::Experimental::GeometryIdentifierBlueprintNode& geoIdNode = containerNode.withGeometryIdentifier();
  geoIdNode.setAllVolumeIdsTo(s_caloBarrelId +
  layerIndex);
  CylinderContainerBlueprintNode& cylinder = geoIdNode.addCylinderContainer(volumeName,
  AxisDirection::AxisZ);
 
  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::Experimental::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 50 of file CaloBlueprintNodeBuilder.cxx.

                                                                                {
 
  caloSampleSurfaceMap_t caloSampleSurfaceMap;
  caloSampleDDEElementsMap_t caloSampleDDEElementsMap;
  fillMaps(caloSampleSurfaceMap, caloSampleDDEElementsMap);
 
  ATH_MSG_DEBUG("Have filled first two maps");
 
  // TODO: it seems that only the CaloMaxR and CaloHalfLengthZ 
  // m_radiusTolerancesions are used later on... do we need the others?
  caloDimensionMap_t caloDimensionMap;
  fillCaloDimensionsMap(caloDimensionMap, caloSampleDDEElementsMap);
 
  ATH_MSG_DEBUG("Have filled calo dimensions map");
 
  generateCylinderSurfaces(caloSampleSurfaceMap, caloSampleDDEElementsMap);
 
  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.
  // Take the itk+calo cylinder dimensions based from the previously evaluated map adding some tolerance.
  auto itkCaloNode = std::make_shared<StaticBlueprintNode>( 
      std::make_unique<TrackingVolume>(Transform3::Identity(),
          std::make_shared<CylinderVolumeBounds>(0., 
                                                 caloDimensionMap["CaloMaxR"] + m_radiusTolerance, 
                                                 caloDimensionMap["CaloHalfLengthZ"] + m_zTolerance),"ITkCalo"));
 
  if (childNode) itkCaloNode->addChild(std::move(childNode));
 
  ATH_MSG_DEBUG("Top level calorimeter node created");
 
  // create the caloBarrel cylinder container node, which will hold all the barrel layers as cylinders.
  auto caloBarrelNode = std::make_shared<CylinderContainerBlueprintNode>("CaloBarrel", AxisDirection::AxisR);
  caloBarrelNode->setAttachmentStrategy(VolumeAttachmentStrategy::Gap);
  caloBarrelNode->setResizeStrategy(ResizeStrategy::Gap);
 
  ATH_MSG_DEBUG("EM Barrel container node created");
 
  // This is a temporary list for the cylindrical layers in the barrel.
  // TODO: Extend to include the disk layers and the endcap.
 
  std::vector<std::string> caloBarrelCylindricalLayerNames = {"PreSamplerB", "EMB1", "EMB2", "EMB3", "TileBar0", "TileBar1", "TileBar2"};
  for (unsigned int sampleIndex = 0; sampleIndex < caloBarrelCylindricalLayerNames.size(); ++sampleIndex) {
    auto& sampleName = caloBarrelCylindricalLayerNames.at(sampleIndex);
    addCylindricalTrackingVolumeToCaloNode(*caloBarrelNode, caloDimensionMap, sampleName, caloSampleSurfaceMap.at({sampleName, getSampleEnum(sampleName)}), sampleIndex);
  }
 
  ATH_MSG_DEBUG("Have added all Barrel layers to caloBarrelNode");
 
  // Add calo barrel node to the top level calo node.
  itkCaloNode->addChild(caloBarrelNode);
 
  //return the top level calo node
  return itkCaloNode;
}

fillCaloDimensionsMap()

void ActsTrk::CaloBlueprintNodeBuilder::fillCaloDimensionsMap ( caloDimensionMap_t & caloDimensionsMap, caloSampleDDEElementsMap_t & caloSampleDDEElementsMap ) const

private

fillCaloDimensionsMap fills a map of calorimeter dimensions for each sampling layer.

The map contains minR, maxR, minZ, maxZ and halfLengthZ for each sampling layer.

Definition at line 270 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                                            {
 
  //initialise parameters we will use to find the dimensions of the calorimeter
  double minR = std::numeric_limits<double>::max();
  double maxR = 0.0;
  double minZ = std::numeric_limits<double>::max();
  double maxZ = -std::numeric_limits<double>::max();
 
  //define functions we will use
  auto checkMinR = [&minR](const CaloDetDescrElement* theDDE){double r = theDDE->r();if (r < minR) minR = r;};
  auto checkMaxR = [&maxR](const CaloDetDescrElement* theDDE){double r = theDDE->r();if (r > maxR) maxR = r;};
  auto checkMinMaxZ = [&minZ,&maxZ](const CaloDetDescrElement* theDDE){double z = theDDE->z();if (z > maxZ) maxZ = z;if (z < minZ) minZ = z;};
  auto calcHalfLengthZ = [&minZ, &maxZ](){return (maxZ - minZ) / 2.0;};
 
  //function to use the above to get minR, maxR and halfLengthZ
  auto getMinRMaxRHalfLengthZ = [&minR, &maxR, &minZ, &maxZ, &caloSampleDDEElementsMap, &checkMinR, &checkMaxR, &checkMinMaxZ, &calcHalfLengthZ, this](CaloCell_ID::CaloSample currentSample) {
 
    minR = std::numeric_limits<double>::max();
    maxR = 0.0;
    minZ = std::numeric_limits<double>::max();
    maxZ = -std::numeric_limits<double>::max();
 
    for (const CaloDetDescrElement* theDDE : caloSampleDDEElementsMap.at({getSampleName(currentSample), currentSample})) {
      checkMinR(theDDE);
      checkMaxR(theDDE);   
      checkMinMaxZ(theDDE);
    }
 
    return calcHalfLengthZ();
  };
 
  //find minR from PreSamplerB
  for (const CaloDetDescrElement* theDDE : caloSampleDDEElementsMap.at({getSampleName(CaloCell_ID::PreSamplerB), CaloCell_ID::PreSamplerB})) checkMinR(theDDE);
 
  //find maxR from TileBar2, TileGap2 and Tile Ext2
  for (auto& currentSample : std::vector<std::pair<std::string, CaloCell_ID::CaloSample>>{{"TileBar2", CaloCell_ID::TileBar2}, {"TileGap2", CaloCell_ID::TileGap2}, {"TileExt2", CaloCell_ID::TileExt2}}) {
    for (const CaloDetDescrElement* theDDE : caloSampleDDEElementsMap.at(currentSample)) checkMaxR(theDDE);
  }
 
  ATH_MSG_DEBUG("Min R in PreSamplerB is " << minR);
  ATH_MSG_DEBUG("Max R in TileBar2, TileGap2 and TileExt2 is " << maxR);
 
  caloDimensionsMap["CaloMinR"] = minR;
  caloDimensionsMap["CaloMaxR"] = maxR;
 
  //find minZ and maxZ from all barrel samplings
  for (auto& currentSample : m_caloCylinderSampleList) {
    for (const CaloDetDescrElement* theDDE : caloSampleDDEElementsMap.at(currentSample)) checkMinMaxZ(theDDE);
  }
 
  caloDimensionsMap["CaloMinZ"] = minZ;
  caloDimensionsMap["CaloMaxZ"] = maxZ;
 
  double halfLengthZ = calcHalfLengthZ();
  ATH_MSG_DEBUG("Half length in Z for entire barrel is " << halfLengthZ);
  caloDimensionsMap["CaloHalfLengthZ"] = halfLengthZ;
 
  auto putMinRMaxRHalfLengthZInMap = [&caloDimensionsMap,&minR,&maxR,&halfLengthZ](const std::string& sampleString){
    //PresamplerB, TileBar0/2, TileGap1/2, TileExt0/1/2 return the same radial value for all DDE, so need to make a small offset because a zero thickness
    //cylinder is not allowed by Acts volumes etc.
    float smallOffset = 0.1;
    if (std::fabs((maxR - minR)) < smallOffset) maxR = minR + smallOffset;
    caloDimensionsMap[sampleString + "MinR"] = minR;
    caloDimensionsMap[sampleString + "MaxR"] = maxR;
    caloDimensionsMap[sampleString + "HalfLengthZ"] = halfLengthZ;
  };
 
  halfLengthZ = getMinRMaxRHalfLengthZ(CaloCell_ID::PreSamplerB);
  putMinRMaxRHalfLengthZInMap("PreSamplerB");
  halfLengthZ = getMinRMaxRHalfLengthZ(CaloCell_ID::EMB1);
  putMinRMaxRHalfLengthZInMap("EMB1");
  halfLengthZ = getMinRMaxRHalfLengthZ(CaloCell_ID::EMB2);
  putMinRMaxRHalfLengthZInMap("EMB2");
  halfLengthZ = getMinRMaxRHalfLengthZ(CaloCell_ID::EMB3);
  putMinRMaxRHalfLengthZInMap("EMB3");
  halfLengthZ = getMinRMaxRHalfLengthZ(CaloCell_ID::TileBar0);
  putMinRMaxRHalfLengthZInMap("TileBar0");
  halfLengthZ = getMinRMaxRHalfLengthZ(CaloCell_ID::TileBar1);
  putMinRMaxRHalfLengthZInMap("TileBar1");
  halfLengthZ = getMinRMaxRHalfLengthZ(CaloCell_ID::TileBar2);
  putMinRMaxRHalfLengthZInMap("TileBar2");
  halfLengthZ = getMinRMaxRHalfLengthZ(CaloCell_ID::TileGap1);
 
}

fillMaps()

void ActsTrk::CaloBlueprintNodeBuilder::fillMaps ( caloSampleSurfaceMap_t & caloSampleSurfaceMap, caloSampleDDEElementsMap_t & caloSampleDDEElementsMap ) 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 114 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
 
  //Use the same loop to create map bwteeen sampling and vectors of DDE
  for (const auto & currentSample : m_caloCylinderSampleList) {
    caloSampleSurfaceMap[currentSample] = std::vector<std::shared_ptr<Surface> >();
    caloSampleDDEElementsMap[currentSample] = std::vector<const CaloDetDescrElement*>();
  }
 
  for (const auto & currentSample : m_caloDiscSampleList) {
    caloSampleSurfaceMap[currentSample] = std::vector<std::shared_ptr<Surface> >();
    caloSampleDDEElementsMap[currentSample] = std::vector<const CaloDetDescrElement*>();
  }
 
  //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;
    }
    CaloCell_ID::CaloSample currentSample=theDDE->getSampling();
    caloSampleDDEElementsMap[{getSampleName(currentSample), currentSample}].push_back(theDDE);
  }
 
  auto sortAllLayersInZ = [&caloSampleDDEElementsMap](const std::vector<std::pair<std::string, CaloCell_ID::CaloSample>>& caloSampleList) {
    for (const auto & currentSample : caloSampleList) {
      std::vector<const CaloDetDescrElement*> currentElements = caloSampleDDEElementsMap[currentSample];
      std::sort(currentElements.begin(), currentElements.end(), [](const CaloDetDescrElement* a, const CaloDetDescrElement* b) {return a->z() < b->z();});
      caloSampleDDEElementsMap[currentSample] = std::move(currentElements);
    }
  };
 
  //Sort the DDE, by Z, in all possible layers
  sortAllLayersInZ(m_caloCylinderSampleList);
  sortAllLayersInZ(m_caloDiscSampleList);
 
}

finalize()

StatusCode ActsTrk::CaloBlueprintNodeBuilder::finalize ( )

override

Definition at line 109 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 256 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                                                                                      {
 
  //Characterise the dimensions of the  cylinder
  double LArBRadius = (maxLArBRadius + minLArBRadius) / 2.0;
  double LArBLength = std::abs(highZLarB - lowZLarB);
 
  ATH_MSG_DEBUG("Cylinder radius and length are " << LArBRadius << " and " << LArBLength);
 
  auto surface = Surface::makeShared<CylinderSurface>(Transform3::Identity(), LArBRadius, LArBLength);
    
  return surface;
 
}

generateCylinderSurfaces()

void ActsTrk::CaloBlueprintNodeBuilder::generateCylinderSurfaces ( caloSampleSurfaceMap_t & caloSampleSurfaceMap, caloSampleDDEElementsMap_t & caloSampleDDEElementsMap ) 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 161 of file CaloBlueprintNodeBuilder.cxx.

                                                                                                                                                                      {
 
  for (const auto & currentSample : m_caloCylinderSampleList) {
 
    std::vector<const CaloDetDescrElement*> currentElements = caloSampleDDEElementsMap[currentSample];
 
    double maxLArBRadius = 0.0, minLArBRadius = std::numeric_limits<double>::max();
    double lowZLarB = 0.0, highZLarB = 0.0;
 
    //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();
 
    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 {
        firstCellInPhiRing = true;
        if (phiCounter > 0) {
          double cellRingRadius = totalRadiusFixedPhi / phiCounter;
          totalRadiusFixedPhi = 0.0;
          phiCounter = 0;
 
          if (cellRingRadius > maxLArBRadius) maxLArBRadius = radius;
          if (cellRingRadius < minLArBRadius) minLArBRadius = radius;
 
          //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()){
      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));
    }
  }   
}

getSampleEnum()

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

inlineprivate

Definition at line 134 of file CaloBlueprintNodeBuilder.h.

                                                                           {
      CaloCell_ID::CaloSample sampleEnum = CaloCell_ID::Unknown;
      for (auto& [name, sample] : m_caloCylinderSampleList) {
        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 115 of file CaloBlueprintNodeBuilder.h.

                                                                       {
      std::string sampleName = "";
      for ( auto& [name, sample] : m_caloCylinderSampleList) {
        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 41 of file CaloBlueprintNodeBuilder.cxx.

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

Member Data Documentation

m_caloCylinderSampleList

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

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},
          {"TileGap1", CaloCell_ID::TileGap1},
          {"TileGap2", CaloCell_ID::TileGap2},
          {"TileExt0", CaloCell_ID::TileExt0},
          {"TileExt1", CaloCell_ID::TileExt1},
          {"TileExt2", CaloCell_ID::TileExt2}}

Definition at line 91 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},
          {"TileGap1", CaloCell_ID::TileGap1},
          {"TileGap2", CaloCell_ID::TileGap2},
          {"TileExt0", CaloCell_ID::TileExt0},
          {"TileExt1", CaloCell_ID::TileExt1},
          {"TileExt2", CaloCell_ID::TileExt2}};

m_caloDetSecrMgr

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

private

Definition at line 76 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}}

Definition at line 81 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}};

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 104 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 109 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