Trk::LayerMaterialProvider Class Reference

AlgTool that retrieves the LayerMaterial from COOL and loads it onto the geometry. More...

#include <LayerMaterialProvider.h>

Inheritance diagram for Trk::LayerMaterialProvider:

Collaboration diagram for Trk::LayerMaterialProvider:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	process (TrackingGeometry &tgeo) const override
	Processor Action to work on TrackingGeometry& tgeo.
virtual StatusCode	process (TrackingVolume &tvol, size_t level=0) const override
	Processor Action to work on TrackingVolumes - the level is for the hierachy tree.
StatusCode	process (TrackingVolume &lay, const LayerMaterialMap &layerMaterialMap, size_t level) const
virtual StatusCode	process (Layer &lay, size_t level=0) const override
	Processor Action to work on Layers.
StatusCode	process (Layer &lay, const LayerMaterialMap &layerMaterialMap, size_t level) const
virtual StatusCode	process (Surface &surf, size_t level=0) const override
	Processor Action to work on Surfaces.

Private Member Functions
void	dumpMaterialMap (const LayerMaterialMap &layerMaterialMap) const

Private Attributes
SG::ReadCondHandleKey< LayerMaterialMap >	m_layerMaterialMapKey
Gaudi::Property< std::string >	m_layerMaterialMapName

Detailed Description

AlgTool that retrieves the LayerMaterial from COOL and loads it onto the geometry.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Definition at line 38 of file LayerMaterialProvider.h.

Member Function Documentation

dumpMaterialMap()

void Trk::LayerMaterialProvider::dumpMaterialMap ( const LayerMaterialMap & layerMaterialMap ) const

private

Definition at line 227 of file LayerMaterialProvider.cxx.

{
    if (msgLvl (MSG::VERBOSE)) {
      static std::atomic_flag flag ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT;
      if (!flag.test_and_set()) {
        ATH_MSG_VERBOSE("Listing the layer indeces found in the loaded LayerMaterialMap");
        for ( const auto & lmIter : layerMaterialMap ){
          ATH_MSG_VERBOSE("  -> Found map for layer with index " << lmIter.first);
        }
      }
    }
}

initialize()

StatusCode Trk::LayerMaterialProvider::initialize ( )

overridevirtual

Definition at line 24 of file LayerMaterialProvider.cxx.

{
  ATH_CHECK( m_layerMaterialMapKey.initialize (SG::AllowEmpty) );
  return StatusCode::SUCCESS;
}

process() [1/6]

StatusCode Trk::LayerMaterialProvider::process	(	Trk::Layer &	lay,
		const LayerMaterialMap &	layerMaterialMap,
		size_t	level ) const

Definition at line 180 of file LayerMaterialProvider.cxx.

{
  // skip Layers w/o material
  if (!lay.layerMaterialProperties())
    return StatusCode::SUCCESS;
 
  // get the layer index for assignment
  Trk::LayerIndex lIndex = lay.layerIndex();
 
  // display
  std::stringstream displayBuffer;
  for (size_t il = 0; il < level; ++il)
    displayBuffer << " ";
 
  // find the layer and assign the material properties
  auto lmIter = layerMaterialMap.find(lIndex);
  if (lmIter != layerMaterialMap.end()) {
    ATH_MSG_VERBOSE(displayBuffer.str()
                    << "---[+] found material for Layer with Index: "
                    << lIndex.value());
    if (lay.surfaceRepresentation().isFree()) {
      ATH_MSG_VERBOSE(displayBuffer.str()
                      << "---[!] the Layer is not owned by the "
                         "TrackingGeometry, could indicate problem.");
    } else {
      ATH_MSG_VERBOSE(displayBuffer.str()
                      << "---[+] the Layer is owned by the TrackingGeometry.");
    }
    lay.assignMaterialProperties(*((*lmIter).second));
  } else {
    ATH_MSG_WARNING(displayBuffer.str()
                    << "---[!] could not find material for Layer with Index: "
                    << lIndex.value());
    return StatusCode::RECOVERABLE;
  }
  return StatusCode::SUCCESS;
}

process() [2/6]

StatusCode Trk::LayerMaterialProvider::process ( Trk::Layer & lay, size_t level = 0 ) const

overridevirtual

Processor Action to work on Layers.

Definition at line 164 of file LayerMaterialProvider.cxx.

{
  const LayerMaterialMap* layerMaterialMap = nullptr;
  if (!m_layerMaterialMapKey.key().empty()) {
    SG::ReadCondHandle<LayerMaterialMap> layerMaterialMapH(
      m_layerMaterialMapKey);
    layerMaterialMap = *layerMaterialMapH;
  } else {
    ATH_CHECK(detStore()->retrieve(layerMaterialMap, m_layerMaterialMapName));
  }
  dumpMaterialMap(*layerMaterialMap);
  ATH_CHECK(process(lay, *layerMaterialMap, level));
  return StatusCode::SUCCESS;
}

process() [3/6]

StatusCode Trk::LayerMaterialProvider::process ( Trk::Surface & surf, size_t level = 0 ) const

overridevirtual

Processor Action to work on Surfaces.

Definition at line 221 of file LayerMaterialProvider.cxx.

                                                                     {
    return StatusCode::SUCCESS;
}

process() [4/6]

StatusCode Trk::LayerMaterialProvider::process ( Trk::TrackingGeometry & tgeo ) const

overridevirtual

Processor Action to work on TrackingGeometry& tgeo.

Definition at line 32 of file LayerMaterialProvider.cxx.

{
  const LayerMaterialMap* layerMaterialMap = nullptr;
  if (!m_layerMaterialMapKey.key().empty()) {
    SG::ReadCondHandle<LayerMaterialMap> layerMaterialMapH (m_layerMaterialMapKey);
    layerMaterialMap = *layerMaterialMapH;
  }
  else {
    ATH_CHECK( detStore()->retrieve (layerMaterialMap, m_layerMaterialMapName) );
  }
  dumpMaterialMap (*layerMaterialMap);
 
  ATH_MSG_VERBOSE("Start processing the TrackingGeometry recursively");
  // retrieve the highest tracking volume
  Trk::TrackingVolume* worldVolume = tgeo.highestTrackingVolume();
  // check for the world volume
  if (worldVolume){
      // TrackingVolume : confined layers
      ATH_MSG_VERBOSE("TrackingVolume '" << worldVolume->volumeName() << "' retrieved as highest level node.");
      if (process(*worldVolume, *layerMaterialMap, 0).isFailure() ) {
          ATH_MSG_FATAL("Could not load material maps for provided TrackingGeometry, abort job.");
          return StatusCode::FAILURE;
      }
      // Boundary layers
      if (!tgeo.boundaryLayers().empty()){
          ATH_MSG_VERBOSE("TrackingGeometry has " <<  tgeo.numBoundaryLayers() << " unique boundary layers, loading material.");
          for (const auto& bLayerIter : tgeo.boundaryLayers() ){
              Trk::Layer* lay = bLayerIter.first;
              int layCount = bLayerIter.second;
              int layIndex = lay->layerIndex().value();
              // only move on if layer index is different from 0
              if (layIndex){
                  StatusCode sc( process(*lay, *layerMaterialMap, 0) );
          // @TODO Currently recoverable errors are treated as failure. Is this the intended behaviour ? Elsewhere recoverable errors are treated as recoverable
                  if (sc.isSuccess())
                      ATH_MSG_DEBUG("---[B] Boundary layer with " << layCount << " references : successfully loaded material map for layer " << layIndex );
                  // else if (sc.isRecoverable())
                  //    ATH_MSG_WARNING("Failed to call process(const Layer&) on layers - but recoverable.");
                  else {
                      ATH_MSG_FATAL("Failed to call process(const Layer&) on layer. Aborting.");
                      return StatusCode::FAILURE;
                  }
              }
           } // loop over layers
       }// we have boundary layers
       return StatusCode::SUCCESS;
  } // we have a world volume
  // abort job
  ATH_MSG_FATAL("No highest level TrackingVolume found. Stopping recursive parsing, abort job.");
  return StatusCode::FAILURE;
}

process() [5/6]

StatusCode Trk::LayerMaterialProvider::process	(	Trk::TrackingVolume &	tvol,
		const LayerMaterialMap &	layerMaterialMap,
		size_t	level ) const

Definition at line 103 of file LayerMaterialProvider.cxx.

{
  std::stringstream displayBuffer;
  for (size_t il = 0; il < level; ++il) displayBuffer << " ";
  // formatted screen output
  ATH_MSG_VERBOSE(displayBuffer.str() << "TrackingVolume '" << tvol.volumeName() << "'");
 
  // @TODO add boundary surfaces
 
  // Process the contained layers
  Trk::LayerArray* layerArray = tvol.confinedLayers();
  if (layerArray) {
      // display output
      std::span<Trk::Layer * const> layers = layerArray->arrayObjects();
      ATH_MSG_VERBOSE(displayBuffer.str() << "--> has " << layers.size() << " confined layers." );
      for ( const auto & layIter : layers ){
          if (!layIter)
              ATH_MSG_WARNING("Zero-pointer found in LayerArray - indicates problem !");
          else {
            // get the layer index and only process if it's an indexed layer
            int layIndex = layIter->layerIndex().value();
            if (layIndex){
                StatusCode sc = process(*layIter, layerMaterialMap, level);
                if (sc.isSuccess())
                    ATH_MSG_DEBUG(displayBuffer.str() << "---[M] Material layer: successfully loaded material map for layer " << layIndex );
                else if (sc.isRecoverable())
                    ATH_MSG_WARNING("Failed to call process(const Layer&) on layers - but recoverable.");
                else {
                    ATH_MSG_FATAL("Failed to call process(const Layer&) on layer. Aborting.");
                    return StatusCode::FAILURE;
                }
            } else
                ATH_MSG_DEBUG(displayBuffer.str() << "---[o] Navigation layer: skipping.");
        }
      }
   }
 
   // Process the contained TrackingVolumes (recursively) if they exist
   Trk::BinnedArray<Trk::TrackingVolume >* confinedVolumes = tvol.confinedVolumes();
   // register the next round
   if (confinedVolumes) {
       std::span<Trk::TrackingVolume * const> volumes = confinedVolumes->arrayObjects();
       std::span<Trk::TrackingVolume * const>::iterator volumesIter = volumes.begin();
       for (; volumesIter != volumes.end(); ++volumesIter){
           if (!(*volumesIter))
              ATH_MSG_WARNING("Zero-pointer found in VolumeArray - indicates problem !");
           if ((*volumesIter) && process(**volumesIter, layerMaterialMap, ++level).isFailure() ){
               ATH_MSG_FATAL("Failed to call process(const TrackingVolume&) on confined volumes. Aborting.");
               return StatusCode::FAILURE;
           }
       }
   }
 
   // return
   return StatusCode::SUCCESS;
}

process() [6/6]

StatusCode Trk::LayerMaterialProvider::process ( Trk::TrackingVolume & tvol, size_t level = 0 ) const

overridevirtual

Processor Action to work on TrackingVolumes - the level is for the hierachy tree.

Definition at line 86 of file LayerMaterialProvider.cxx.

{
  const LayerMaterialMap* layerMaterialMap = nullptr;
  if (!m_layerMaterialMapKey.key().empty()) {
    SG::ReadCondHandle<LayerMaterialMap> layerMaterialMapH (m_layerMaterialMapKey);
    layerMaterialMap = *layerMaterialMapH;
  }
  else {
    ATH_CHECK( detStore()->retrieve (layerMaterialMap, m_layerMaterialMapName) );
  }
  dumpMaterialMap (*layerMaterialMap);
  ATH_CHECK( process (tvol, *layerMaterialMap, level) );
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_layerMaterialMapKey

SG::ReadCondHandleKey<LayerMaterialMap> Trk::LayerMaterialProvider::m_layerMaterialMapKey

private

Initial value:

{ this, "LayerMaterialMapKey", "/GLOBAL/TrackingGeo/LayerMaterialV2",
            "COOL folder for material map" }

Definition at line 73 of file LayerMaterialProvider.h.

          { this, "LayerMaterialMapKey", "/GLOBAL/TrackingGeo/LayerMaterialV2",
            "COOL folder for material map" };

m_layerMaterialMapName

Gaudi::Property<std::string> Trk::LayerMaterialProvider::m_layerMaterialMapName

private

Initial value:

{this, "LayerMaterialMapName", "",
       "If LayerMaterialMapKey is not set, then fall back to retrieving this from the detector store."}

Definition at line 77 of file LayerMaterialProvider.h.

      {this, "LayerMaterialMapName", "",
       "If LayerMaterialMapKey is not set, then fall back to retrieving this from the detector store."};

---

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

• LayerMaterialProvider.h
• LayerMaterialProvider.cxx