Trk::MaterialMapping Class Reference

A simple algorithm that throws random points through detector and associates them with the given/found layer. More...

#include <MaterialMapping.h>

Inheritance diagram for Trk::MaterialMapping:

Collaboration diagram for Trk::MaterialMapping:

Public Member Functions
	MaterialMapping (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Athena-Algorithm Constructor.
	~MaterialMapping ()
	Default Destructor.
StatusCode	initialize ()
	standard Athena-Algorithm method
StatusCode	execute ()
	standard Athena-Algorithm method
StatusCode	finalize ()
	standard Athena-Algorithm method
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	associateHit (const Trk::Layer &tvol, const Amg::Vector3D &pos, const Amg::Vector3D &layerHitPosition, double stepl, const Trk::Material &mat)
	Associate the Step to the Layer.
void	registerVolume (const Trk::TrackingVolume &tvol, int lvl)
	Output information with Level.
void	assignLayerMaterialProperties (Trk::TrackingVolume &tvol, Trk::LayerMaterialMap *propSet)
	create the LayerMaterialRecord *‍/
void	insertLayerMaterialRecord (const Trk::Layer &lay)
StatusCode	handleTrackingGeometry ()
	Retrieve the TrackingGeometry and its informations.
const TrackingGeometry &	trackingGeometry () const
void	throwFailedToGetTrackingGeometry () const
const TrackingGeometry *	retrieveTrackingGeometry (const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_checkForEmptyHits
	use extrapoaltion engine to check for empty hits
ToolHandle< IExtrapolationEngine >	m_extrapolationEngine
std::string	m_mappingVolumeName
const Trk::TrackingVolume *	m_mappingVolume
SG::ReadHandleKey< MaterialStepCollection >	m_inputMaterialStepCollection
	output / input steering
std::string	m_outputLayerMaterialSetName
double	m_etaCutOff
	general steering
int	m_etaSide
	needed for debugging: -1 negative | 0 all | 1 positive
bool	m_useLayerThickness
	use the actual layer thickness
int	m_associationType
ToolHandle< ILayerMaterialAnalyser >	m_layerMaterialRecordAnalyser
ToolHandleArray< ILayerMaterialAnalyser >	m_layerMaterialAnalysers
ToolHandleArray< ILayerMaterialCreator >	m_layerMaterialCreators
bool	m_mapMaterial
	Mapper and Inspector.
ToolHandle< IMaterialMapper >	m_materialMapper
bool	m_mapComposition
	map the composition of the material
double	m_minCompositionFraction
	minimal fraction to be accounted for the composition recording
Trk::ElementTable *	m_elementTable
	the accumulated element table
SG::ReadHandleKey< Trk::ElementTable >	m_inputEventElementTable
	input event table
std::map< const Layer *, LayerMaterialRecord >	m_layerRecords
	this is the general record for the search
std::map< const Layer *, bool >	m_layersRecordedPerEvent
	these are the layers hit per event - for empty hit scaling
double	m_accumulatedMaterialXX0
	the accumulated material information
double	m_accumulatedRhoS
size_t	m_mapped
size_t	m_unmapped
size_t	m_skippedOutside
int	m_layerMaterialScreenOutput
SG::ReadCondHandleKey< TrackingGeometry >	m_trackingGeometryReadKey
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

A simple algorithm that throws random points through detector and associates them with the given/found layer.

Author

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

Definition at line 72 of file MaterialMapping.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MaterialMapping()

Trk::MaterialMapping::MaterialMapping	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Athena-Algorithm Constructor.

Definition at line 37 of file MaterialMapping.cxx.

: AthAlgorithm(name,pSvcLocator),
  m_checkForEmptyHits(true),
  m_mappingVolumeName("Atlas"),
  m_mappingVolume(nullptr),
  m_inputMaterialStepCollection("MaterialStepRecords"),
  m_etaCutOff(6.0),
  m_etaSide(0),
  m_useLayerThickness(false),
  m_associationType(1),
  m_mapMaterial(true),
  m_mapComposition(false),
  m_minCompositionFraction(0.005),
  m_elementTable(nullptr),
  m_inputEventElementTable("ElementTable"),
  m_accumulatedMaterialXX0(0.),
  m_accumulatedRhoS(0.),
  m_mapped(0),
  m_unmapped(0),
  m_skippedOutside(0),
  m_layerMaterialScreenOutput(0)
#ifdef TRKDETDESCR_MEMUSAGE
  ,m_memoryLogger()
#endif
{
    // the name of the volume to map
    declareProperty("MappingVolumeName"           , m_mappingVolumeName);
    // the extrapolation engine
    declareProperty("CheckForEmptyHits"           , m_checkForEmptyHits);
    // general steering
    declareProperty("EtaCutOff"                   , m_etaCutOff);
    declareProperty("EtaSide"                     , m_etaSide);
    // the toolhandle of the MaterialMapper to be used
    declareProperty("MapMaterial"                 , m_mapMaterial);
    // Composition related parameters
    declareProperty("MapComposition"              , m_mapComposition);
    declareProperty("MinCompositionFraction"      , m_minCompositionFraction);
    // Steer the layer thickness
    declareProperty("UseActualLayerThicknesss"    , m_useLayerThickness);
    // some job setup
    declareProperty("MaterialAssociationType"     , m_associationType);
    declareProperty("InputMaterialStepCollection" , m_inputMaterialStepCollection);
    declareProperty("InputElementTable"           , m_inputEventElementTable);
    // Output screen stuff
    declareProperty("MaterialScreenOutputLevel"   , m_layerMaterialScreenOutput);
 
}

~MaterialMapping()

Trk::MaterialMapping::~MaterialMapping ( )

default

Default Destructor.

Member Function Documentation

assignLayerMaterialProperties()

void Trk::MaterialMapping::assignLayerMaterialProperties ( Trk::TrackingVolume & tvol, Trk::LayerMaterialMap * propSet )

private

create the LayerMaterialRecord *‍/

Definition at line 367 of file MaterialMapping.cxx.

{
 
    if (!propSet) return;
 
    ATH_MSG_INFO("Processing TrackingVolume: "<< tvol.volumeName() );
 
    // ----------------------------------- loop over confined layers ------------------------------------------
    Trk::BinnedArray< Trk::Layer >* confinedLayers = tvol.confinedLayers();
    if (confinedLayers) {
        // get the objects in a vector-like format
        std::span<Trk::Layer * const> layers = confinedLayers->arrayObjects();
        ATH_MSG_INFO("--> found : "<< layers.size() << "confined Layers");
        // the iterator over the vector
        // loop over layers
        for (Trk::Layer* layer : layers) {
            // assign the material and output
            if (layer && (*layer).layerIndex().value() ) {
                ATH_MSG_INFO("  > LayerIndex: "<< (*layer).layerIndex() );
                // set the material!
                if (propSet) {
                    // find the pair
                    auto curIt = propSet->find((*layer).layerIndex());
                    if (curIt != propSet->end()) {
                        ATH_MSG_INFO("LayerMaterial assigned for Layer with index: "<< (*layer).layerIndex() );
                        // set it to the layer
                        layer->assignMaterialProperties(*((*curIt).second), 1.);
                    }
                }
            }
        }
    }
 
    // ----------------------------------- loop over confined volumes -----------------------------
    Trk::BinnedArray<Trk::TrackingVolume >* confinedVolumes = tvol.confinedVolumes();
    if (confinedVolumes) {
        // get the objects in a vector-like format
        std::span<Trk::TrackingVolume * const> volumes = confinedVolumes->arrayObjects();
        ATH_MSG_INFO("--> found : "<< volumes.size() << "confined TrackingVolumes");
        // loop over volumes
        for (const auto & volume : volumes) {
            // assing the material and output
            if (volume)
                assignLayerMaterialProperties(*volume, propSet); // call itself recursively
        }
    }
}

associateHit()

bool Trk::MaterialMapping::associateHit ( const Trk::Layer & tvol, const Amg::Vector3D & pos, const Amg::Vector3D & layerHitPosition, double stepl, const Trk::Material & mat )

private

Associate the Step to the Layer.

Definition at line 322 of file MaterialMapping.cxx.

{
    // get the intersection with the layer
    ++m_mapped;
    // get the layer
    const Trk::Layer* layer = &associatedLayer;
 
    // get the associated volume
    const Trk::TrackingVolume* associatedVolume = trackingGeometry().lowestTrackingVolume(pos);
 
    // try to find the layer material record
    auto clIter = m_layerRecords.find(layer);
    if (clIter != m_layerRecords.end() ){
        // remember that you actually hit this layer
        m_layersRecordedPerEvent[layer] = true;
        // LayerMaterialRecord found, add the hit
        (*clIter).second.associateGeantinoHit(positionOnLayer, stepl, mat);
        ATH_MSG_VERBOSE("- associate Geantino Information at intersection [r/z] = " << positionOnLayer.perp() << "/"<< positionOnLayer.z() );
        ATH_MSG_VERBOSE("                                      mapping distance = " << (pos-positionOnLayer).mag() );
        ATH_MSG_VERBOSE("- associate Geantino Information ( s, s/x0 , x0 , l0, a, z, rho ) = "
                            << stepl << ", "<< stepl/mat.X0 << ", "<< mat.X0 << ", "<< mat.L0 << ", "<< mat.A << ", "<<  mat.Z << ", "<< mat.rho );
        m_accumulatedMaterialXX0 += stepl/mat.X0;
        m_accumulatedRhoS += stepl*mat.rho;
        ATH_MSG_VERBOSE("- accumulated material information X/x0 = " << m_accumulatedMaterialXX0);
        ATH_MSG_VERBOSE("- accumulated effective densitity rho*s = " << m_accumulatedRhoS);
        ATH_MSG_VERBOSE("- to layer with index "<< layer->layerIndex().value() << " from '"<< associatedVolume->volumeName() << "'.");
        // record the plain information w/o correction & intersection
        if (m_mapMaterial && !m_materialMapper.empty()){
                Trk::AssociatedMaterial am(pos, stepl, mat, 1., associatedVolume, layer);
                m_materialMapper->recordMaterialHit(am, positionOnLayer);
                ATH_MSG_VERBOSE(" - associated material produced as : " << am);
            }
 
    } else if (layer) {
        ATH_MSG_WARNING("- associate hit - the layer with index " << layer->layerIndex().value() << " was not found - should not happen!");
    }
    // return
    return true;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode Trk::MaterialMapping::execute

(

)

standard Athena-Algorithm method

Definition at line 117 of file MaterialMapping.cxx.

{
    ATH_MSG_VERBOSE("MaterialMapping execute() start");
 
    // ------------------------------- get the trackingGeometry at first place
    if (!m_mappingVolume) {
        StatusCode retrieveCode = handleTrackingGeometry();
        if (retrieveCode.isFailure()){
            ATH_MSG_INFO("Could not retrieve mapping volume from tracking geometry. Exiting.");
            return retrieveCode;
        }
    }
    if (m_mappingVolume)
      ATH_MSG_VERBOSE("Mapping volume correctly retrieved from tracking geometry");
 
 
    SG::ReadHandle<MaterialStepCollection> materialStepCollection(m_inputMaterialStepCollection);
 
        // --------- prepare the element table ---------------------------------------------------
 
    if (m_mapComposition) {
      SG::ReadHandle<Trk::ElementTable> eTableEvent(m_inputEventElementTable);
      (*m_elementTable) += (*eTableEvent);  // accummulate the table
    }
 
 
    // event parameters - associated asteps, and layers hit per event
    int associatedSteps      = 0;
    m_accumulatedMaterialXX0 = 0.;
    m_accumulatedRhoS        = 0.;
    m_layersRecordedPerEvent.clear();
    // clearing the recorded layers per event
    if (materialStepCollection.isValid() && !materialStepCollection->empty()){
 
       // get the number of material steps
       size_t materialSteps = materialStepCollection->size();
       ATH_MSG_DEBUG("[+] Successfully read  "<<  materialSteps << " geantino steps");
 
       // create a direction out of the last material step
       double dirx = (*materialStepCollection)[materialSteps-1]->hitX();
       double diry = (*materialStepCollection)[materialSteps-1]->hitY();
       double dirz = (*materialStepCollection)[materialSteps-1]->hitZ();
       Amg::Vector3D direction = Amg::Vector3D(dirx,diry,dirz).unit();
 
       double eta = direction.eta();
       // skip the event if the eta cut is not met
       if ( fabs(eta) > m_etaCutOff || (m_etaSide && m_etaSide*eta < 0.)  ) {
           ATH_MSG_VERBOSE("[-] Event is outside eta acceptance of " << m_etaCutOff << ". Skipping it.");
           return StatusCode::SUCCESS;
       }
 
       // now propagate through the full detector and collect the layers
       Trk::NeutralCurvilinearParameters ncP(Amg::Vector3D(0.,0.,0.), direction, 0.);
       // create a neutral extrapolation cell
       Trk::ExtrapolationCell<Trk::NeutralParameters> ecc(ncP);
       ecc.navigationCurvilinear = false;
       ecc.addConfigurationMode(Trk::ExtrapolationMode::StopAtBoundary);
       ecc.addConfigurationMode(Trk::ExtrapolationMode::CollectPassive);
       ecc.addConfigurationMode(Trk::ExtrapolationMode::CollectBoundary);
 
       // let's extrapolate through the detector and remember which layers (with material) should have been hit
       std::vector< std::pair<const Trk::Layer*, Amg::Vector3D> > layersAndHits;
       // call the extrapolation engine
       Trk::ExtrapolationCode eCode = m_extrapolationEngine->extrapolate(ecc);
       // end the parameters if there
       if (eCode.isSuccess()){
           // name of passive surfaces found
           size_t nLayersHit = ecc.extrapolationSteps.size();
           ATH_MSG_VERBOSE("[+] Extrapolation to layers did succeed and found " << nLayersHit << " layers.");
           // reserve the size of the vectors
           layersAndHits.reserve(nLayersHit);
           // for screen output
           size_t ilayer = 0;
           // find all the intersected material - remember the last parameters
           const Trk::NeutralParameters* parameters = nullptr;
           // loop over the collected information
           for (auto& es : ecc.extrapolationSteps){
               // continue if we have parameters
              parameters = es.parameters;
              if (parameters){
                  const Trk::Surface& pSurface = parameters->associatedSurface();
                  // get the surface with associated layer (that has material)
                  ATH_MSG_VERBOSE("[L] Testing layer with associatedLayer() " << pSurface.associatedLayer() << " and materialLayer() " << pSurface.materialLayer() );
 
                  if ((pSurface.associatedLayer() &&
                       pSurface.associatedLayer()->layerMaterialProperties()) ||
                      pSurface.materialLayer()) {
                    // material layer
 
                    const Trk::Layer* mLayer = pSurface.materialLayer()
                                                   ? pSurface.materialLayer()
                                                   : pSurface.associatedLayer();
                    // record that one
                    std::pair<const Trk::Layer*, Amg::Vector3D> layerHitPair(
                        mLayer, parameters->position());
                    ATH_MSG_VERBOSE("[L] Layer "
                                    << ++ilayer << " with index "
                                    << mLayer->layerIndex().value()
                                    << " hit at "
                                    << Amg::toString(parameters->position()));
                    layersAndHits.push_back(layerHitPair);
                  }
                  delete parameters;
              }
            }
            // cleanup of the final hits
            if (ecc.endParameters != parameters) delete ecc.endParameters;
 
            // we have no layers and Hits
            if (layersAndHits.empty()){
                ATH_MSG_VERBOSE("[!] No Layer was intersected - skipping.");
                return StatusCode::SUCCESS;
            }
 
            // layers are ordered, hence you can move the starting point along
            size_t currentLayer = 0;
            // loop through hits and find the closest layer, the start point moves outwards as we go
            for ( const Trk::MaterialStep* step : *materialStepCollection ) {
               // verbose output
               ATH_MSG_VERBOSE("[L] starting from layer " << currentLayer << " from layer collection for this step.");
               // step length and position
               double t     = step->steplength();
               Amg::Vector3D pos(step->hitX(), step->hitY(), step->hitZ());
               // skip if :
               // -- 0) no mapping volume exists
               // -- 1) outside the mapping volume
               // -- 2) outside the eta acceptance
               if (!m_mappingVolume || !(m_mappingVolume->inside(pos)) || fabs(pos.eta()) > m_etaCutOff ){
                  ++m_skippedOutside;
                  continue;
               }
               // now find the closest layer
               // (a) if the currentLayer is the last layer and the hit is still inside -> assign
               if (currentLayer < nLayersHit-1) {
                   // search through the layers - this is the reference distance for projection
                   double currentDistance = (pos-layersAndHits[currentLayer].second).mag();
                   ATH_MSG_VERBOSE("- current distance is " << currentDistance << " from " << Amg::toString(pos) << " and " << Amg::toString(layersAndHits[currentLayer].second) );
                   for (size_t testLayer = (currentLayer+1); testLayer < nLayersHit; ++testLayer){
                       // calculate teh distance to the testLayer
                       double testDistance = (pos-layersAndHits[testLayer].second).mag();
                       ATH_MSG_VERBOSE("[L] Testing layer " << testLayer << " from layer collection for this step.");
                       ATH_MSG_VERBOSE("- test    distance is " << testDistance << " from " << Amg::toString(pos) << " and " << Amg::toString(layersAndHits[testLayer].second) );
                       if ( testDistance < currentDistance ){
                           // screen output
                           ATH_MSG_VERBOSE("[L] Skipping over to current layer " << testLayer << " because " << testDistance << " < " << currentDistance);
                           // the test distance did shrink - update currentLayer
                           currentLayer      = testLayer;
                           currentDistance   = testDistance;
                       } else {
                           // stick to the layer you have
                           break;
                       }
                   }
               }
               // the currentLayer *should* be correct now
               const Trk::Layer* assignedLayer =  layersAndHits[currentLayer].first;
               Amg::Vector3D assignedPosition  = layersAndHits[currentLayer].second;
               // associate the hit
               // (1) count it
               ++associatedSteps;
               // (2) associate it
               associateHit(*assignedLayer, pos, assignedPosition, t, step->fullMaterial());
          } // loop over material Steps
 
          // check for the empty hits - they need to be taken into account
          ATH_MSG_VERBOSE("Found " << layersAndHits.size() << " intersected layers - while having " << m_layersRecordedPerEvent.size() << " recorded ones.");
 
          // now - cross-chek if you have additional layers
          for ( auto& lhp : layersAndHits){
              // check if you find the layer int he already done record-map : not found - we need to do an empty hit scaling
              if (m_layersRecordedPerEvent.find(lhp.first) == m_layersRecordedPerEvent.end()){
                  // try to find the layer material record
                  auto clIter = m_layerRecords.find(lhp.first);
                  if (clIter != m_layerRecords.end() ){
                      (*clIter).second.associateEmptyHit(lhp.second);
                      ATH_MSG_VERBOSE("- to layer with index "<< lhp.first->layerIndex().value() << " with empty hit detected.");
                  } else
                      ATH_MSG_WARNING("- no Layer found in the associated map! Should not happen.");
              }
           }
 
           // check whether the event was good for at least one hit
           if (associatedSteps) {
               ATH_MSG_VERBOSE("There are associated steps, need to call finalizeEvent() & record to the MaterialMapper.");
               // finalize the event   --------------------- Layers ---------------------------------------------
               for (auto& lRecord : m_layerRecords ) {
                   // associated material
                   Trk::AssociatedMaterial* assMatHit = lRecord.second.finalizeEvent((*lRecord.first));
                   // record the full layer hit
                   if (assMatHit && !m_materialMapper.empty()) m_materialMapper->recordLayerHit(*assMatHit, true);
                   delete assMatHit;
                   // call the material mapper finalize method
                   ATH_MSG_VERBOSE("Calling finalizeEvent on the MaterialMapper ...");
               }
           } // the event had at least one associated hit
 
        } // end of eCode.success : needed for new mapping schema
 
     } // material steps existed
 
 
    return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode Trk::MaterialMapping::finalize

(

)

standard Athena-Algorithm method

Definition at line 417 of file MaterialMapping.cxx.

{
 
    ATH_MSG_INFO("========================================================================================= ");
    ATH_MSG_INFO("finalize() starts ...");
 
#ifdef TRKDETDESCR_MEMUSAGE
    m_memoryLogger.refresh(getpid());
    ATH_MSG_INFO("[ memory usage ] Start building of material maps: " );
    ATH_MSG_INFO( m_memoryLogger );
#endif
 
    // create a dedicated LayerMaterialMap by layerMaterialCreator;
    std::map< std::string, Trk::LayerMaterialMap* > layerMaterialMaps;
    for (  auto& lmcIter : m_layerMaterialCreators  ){
        ATH_MSG_INFO("-> Creating material map '"<< lmcIter->layerMaterialName() << "' from creator "<<  lmcIter.typeAndName() );
        layerMaterialMaps[lmcIter->layerMaterialName()] = new Trk::LayerMaterialMap();
    }
 
    ATH_MSG_INFO( m_layerRecords.size() << " LayerMaterialRecords to be finalized for this material mapping run.");
 
    // loop over the layers and output the stuff --- fill the associatedLayerMaterialProperties
    for ( auto& lIter :  m_layerRecords ) {
        // Get the key map, the layer & the volume name
        const Trk::Layer*  layer = lIter.first;
        Trk::LayerIndex layerKey = layer->layerIndex();
        // get the enclosing tracking volume
        const Trk::TrackingVolume* eVolume = layer->enclosingTrackingVolume();
        // assign the string
        std::string vName = eVolume ? (eVolume->volumeName()) : " BoundaryCollection ";
        ATH_MSG_INFO("Finalize MaterialAssociation for Layer "<< layerKey.value() << " in " << vName );
        // normalize - use m_finalizeRunDebug
        (lIter.second).finalizeRun(m_mapComposition);
        // output the material to the analyser if registered
        if (!m_layerMaterialRecordAnalyser.empty() && m_layerMaterialRecordAnalyser->analyseLayerMaterial(*layer, lIter.second).isFailure() )
            ATH_MSG_WARNING("Could not analyse the LayerMaterialRecord  for layer "<< layerKey.value() );
        // check if we have analysers per creator
        bool analyse = (m_layerMaterialCreators.size() == m_layerMaterialAnalysers.size());
        // and now use the creators to make the maps out of the LayerMaterialRecord
        size_t ilmc = 0;
        for ( auto& lmcIter : m_layerMaterialCreators ){
            // call the creator and register in the according map
#ifdef TRKDETDESCR_MEMUSAGE
            m_memoryLogger.refresh(getpid());
            ATH_MSG_INFO("[ memory usage ] Before building the map for Layer "<< layerKey.value()  );
            ATH_MSG_INFO( m_memoryLogger );
#endif
            const Trk::LayerMaterialProperties* lMaterial = lmcIter->createLayerMaterial(lIter.second);
#ifdef TRKDETDESCR_MEMUSAGE
            m_memoryLogger.refresh(getpid());
            ATH_MSG_INFO("[ memory usage ] After building the map for Layer "<< layerKey.value()  );
            ATH_MSG_INFO( m_memoryLogger );
#endif
            if (lMaterial)
                ATH_MSG_VERBOSE("LayerMaterial map created as "<< *lMaterial );
            // insert the created map for the given layer
            (*layerMaterialMaps[lmcIter->layerMaterialName()])[layerKey.value()] = lMaterial;
            // analyse the it if configured
            if (analyse && lMaterial && (m_layerMaterialAnalysers[ilmc]->analyseLayerMaterial(*layer, *lMaterial)).isFailure() )
                ATH_MSG_WARNING("Could not analyse created LayerMaterialProperties for layer "<< layerKey.value() );
            ++ilmc;
        }
    }
 
    ATH_MSG_INFO("Finalize map synchronization and write the maps to the DetectorStore.");
 
    for (auto& ilmIter : layerMaterialMaps ){
      // elementTable handling - if existent
      if (m_mapComposition){
          auto tElementTable = std::make_shared<Trk::ElementTable>(*m_elementTable);
          ilmIter.second->updateElementTable(tElementTable);
          if (ilmIter.second->elementTable()){
              ATH_MSG_INFO("ElementTable for LayerMaterialMap '" << ilmIter.first << "' found and syncrhonized." );
              ATH_MSG_INFO( *(ilmIter.second->elementTable()) );
          }
      }
      // detector store writing
      if ( (detStore()->record(ilmIter.second, ilmIter.first, false)).isFailure()){
          ATH_MSG_ERROR( "Writing of LayerMaterialMap with name '" << ilmIter.first << "' was not successful." );
          delete ilmIter.second;
      } else ATH_MSG_INFO( "LayerMaterialMap: " << ilmIter.first << " written to the DetectorStore!" );
    }
    delete m_elementTable;
 
#ifdef TRKDETDESCR_MEMUSAGE
    m_memoryLogger.refresh(getpid());
    ATH_MSG_INFO( "[ memory usage ] At the end of the material map creation.");
    ATH_MSG_INFO( m_memoryLogger );
#endif
 
    ATH_MSG_INFO( "========================================================================================= " );
    ATH_MSG_INFO( "    ->  Total mapped hits                  : "  << m_mapped         );
    double unmapped = (m_unmapped+m_mapped) ? double(m_unmapped)/double(m_unmapped+m_mapped) : 0.;
    ATH_MSG_INFO( "    ->  Total (rel.) unmapped hits         : "  << m_unmapped << " (" <<  unmapped << ")" );
    ATH_MSG_INFO( "    ->  Skipped (outisde)                  : "  << m_skippedOutside );
    ATH_MSG_INFO( "========================================================================================= " );
    ATH_MSG_INFO( "finalize() successful");
    return StatusCode::SUCCESS;
}

handleTrackingGeometry()

StatusCode Trk::MaterialMapping::handleTrackingGeometry ( )

private

Retrieve the TrackingGeometry and its informations.

Definition at line 518 of file MaterialMapping.cxx.

{
    // either get a string volume or the highest one
    const Trk::TrackingVolume* trackingVolume = trackingGeometry().highestTrackingVolume();
 
    // prepare the mapping volume
    m_mappingVolume = trackingGeometry().trackingVolume(m_mappingVolumeName);
 
    // register the confined layers from the TrackingVolume
    registerVolume(*trackingVolume, 0);
 
    ATH_MSG_INFO("Add "<< m_layerRecords.size() << " confined volume layers to mapping setup.");
    ATH_MSG_INFO("Add "<< trackingGeometry().numBoundaryLayers() << " boundary layers to mapping setup.");
 
    // register the layers from boundary surfaces
    for (const auto bLayerIter : trackingGeometry().boundaryLayers())
        insertLayerMaterialRecord(*(bLayerIter.first));
 
    ATH_MSG_INFO("Map for "<< m_layerRecords.size() << " layers booked & prepared for mapping procedure");
 
    return StatusCode::SUCCESS;
 
}

initialize()

StatusCode Trk::MaterialMapping::initialize

(

)

standard Athena-Algorithm method

Definition at line 89 of file MaterialMapping.cxx.

{
 
    ATH_MSG_INFO("initialize()");
 
    ATH_CHECK( m_trackingGeometryReadKey.initialize(!m_trackingGeometryReadKey.key().empty()) );
 
    ATH_CHECK(m_extrapolationEngine.retrieve());
 
    if ( !m_materialMapper.empty() )
      ATH_CHECK( m_materialMapper.retrieve() );
 
    if ( !m_layerMaterialRecordAnalyser.empty() )
      ATH_CHECK( m_layerMaterialRecordAnalyser.retrieve() );
 
    if ( !m_layerMaterialCreators.empty() )
      ATH_CHECK( m_layerMaterialCreators.retrieve() );
 
    if ( !m_layerMaterialAnalysers.empty() )
      ATH_CHECK( m_layerMaterialAnalysers.retrieve() );
 
    ATH_CHECK( m_inputMaterialStepCollection.initialize() );
    ATH_CHECK(  m_inputEventElementTable.initialize() );
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

insertLayerMaterialRecord()

void Trk::MaterialMapping::insertLayerMaterialRecord ( const Trk::Layer & lay )

private

Definition at line 596 of file MaterialMapping.cxx.

                                                                     {
 // first occurrance, create a new LayerMaterialRecord
 // - get the bin utility for the binned material (if necessary)
 // - get the material first
 const Trk::LayerMaterialProperties* layerMaterialProperties = lay.layerMaterialProperties();
 // - dynamic cast to the BinnedLayerMaterial
 const Trk::BinnedLayerMaterial* layerBinnedMaterial
 = dynamic_cast<const Trk::BinnedLayerMaterial*>(layerMaterialProperties);
 // get the binned array
 const Trk::BinUtility* layerMaterialBinUtility = (layerBinnedMaterial) ? layerBinnedMaterial->binUtility() : nullptr;
 // now fill the layer material record
 if (layerMaterialBinUtility){
     // create a new Layer Material record in the map
     Trk::LayerMaterialRecord  lmr((m_useLayerThickness ? lay.thickness() : 1.),
                                   layerMaterialBinUtility,
                                   (Trk::MaterialAssociationType)m_associationType);
     // and fill it into the map
     m_layerRecords[&lay] = lmr;
 }
}

msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

registerVolume()

void Trk::MaterialMapping::registerVolume ( const Trk::TrackingVolume & tvol, int lvl )

private

Output information with Level.

private void Method to map the layer material

Definition at line 543 of file MaterialMapping.cxx.

{
    int sublevel = lvl+1;
 
    for (int indent=0; indent<sublevel; ++indent)
        std::cout << " ";
    std::cout << "TrackingVolume name: "<< tvol.volumeName() << std::endl;
 
    // all those to be processed
    std::vector<const Trk::Layer*> volumeLayers;
 
    // collect all material layers that have layerMaterial
    const Trk::BinnedArray< Trk::Layer >* confinedLayers = tvol.confinedLayers();
    if (confinedLayers) {
         // this go ahead with the layers
         std::span<Trk::Layer const * const> layers = confinedLayers->arrayObjects();
         for (int indent=0; indent<sublevel; ++indent)
             std::cout << " ";
         std::cout << "- found : "<< layers.size() << "confined Layers"<< std::endl;
         // loop over and fill them
         auto clIter  = layers.begin();
         auto clIterE = layers.end();
         for ( ; clIter != clIterE; ++clIter ) {
            // only take layers with MaterialProperties defined and which are within the mapping volume
            const Amg::Vector3D& sReferencePoint = (*clIter)->surfaceRepresentation().globalReferencePoint();
            bool insideMappingVolume = m_mappingVolume ? m_mappingVolume->inside(sReferencePoint) : true;
            if ((*clIter)->layerMaterialProperties() && insideMappingVolume)
                volumeLayers.push_back((*clIter));
        }
    }
 
   // now create LayerMaterialRecords for all
   for ( auto& lIter : volumeLayers )
           insertLayerMaterialRecord(*lIter);
 
    // step dopwn the navigation tree to reach the confined volumes
    const Trk::BinnedArray<Trk::TrackingVolume >* confinedVolumes = tvol.confinedVolumes();
    if (confinedVolumes) {
        std::span<Trk::TrackingVolume const * const> volumes = confinedVolumes->arrayObjects();
 
        for (int indent=0; indent<sublevel; ++indent)
            std::cout << " ";
        std::cout << "- found : "<< volumes.size() << "confined TrackingVolumes"<< std::endl;
        // loop over the confined volumes
        auto volumesIter = volumes.begin();
        for (; volumesIter != volumes.end(); ++volumesIter)
            if (*volumesIter) {
                registerVolume(**volumesIter, sublevel);
            }
    }
 
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

retrieveTrackingGeometry()

const TrackingGeometry * Trk::MaterialMapping::retrieveTrackingGeometry ( const EventContext & ctx ) const

inlineprivate

Definition at line 186 of file MaterialMapping.h.

  {
    SG::ReadCondHandle<TrackingGeometry> handle(m_trackingGeometryReadKey, ctx);
    if (!handle.isValid()) {
      ATH_MSG_FATAL("Could not load TrackingGeometry with name '"
                    << m_trackingGeometryReadKey.key() << "'. Aborting.");
      throwFailedToGetTrackingGeometry();
    }
    return handle.cptr();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

throwFailedToGetTrackingGeometry()

void Trk::MaterialMapping::throwFailedToGetTrackingGeometry ( ) const

private

Definition at line 617 of file MaterialMapping.cxx.

                                                                {
   std::stringstream msg;
   msg << "Failed to get conditions data " << m_trackingGeometryReadKey.key() << ".";
   throw std::runtime_error(msg.str());
}

trackingGeometry()

const Trk::TrackingGeometry & Trk::MaterialMapping::trackingGeometry ( ) const

inlineprivate

Definition at line 211 of file MaterialMapping.h.

{
  const Trk::TrackingGeometry* tracking_geometry =
    retrieveTrackingGeometry(Gaudi::Hive::currentContext());
  if (!tracking_geometry) {
    ATH_MSG_FATAL("Did not get valid TrackingGeometry. Aborting.");
    throw GaudiException("MaterialMapping",
                         "Problem with TrackingGeometry loading.",
                         StatusCode::FAILURE);
  }
  return *tracking_geometry;
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_accumulatedMaterialXX0

double Trk::MaterialMapping::m_accumulatedMaterialXX0

private

the accumulated material information

Definition at line 175 of file MaterialMapping.h.

m_accumulatedRhoS

double Trk::MaterialMapping::m_accumulatedRhoS

private

Definition at line 176 of file MaterialMapping.h.

m_associationType

int Trk::MaterialMapping::m_associationType

private

Definition at line 134 of file MaterialMapping.h.

m_checkForEmptyHits

bool Trk::MaterialMapping::m_checkForEmptyHits

private

use extrapoaltion engine to check for empty hits

Definition at line 115 of file MaterialMapping.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_elementTable

Trk::ElementTable* Trk::MaterialMapping::m_elementTable

private

the accumulated element table

Definition at line 165 of file MaterialMapping.h.

m_etaCutOff

double Trk::MaterialMapping::m_etaCutOff

private

general steering

Definition at line 131 of file MaterialMapping.h.

m_etaSide

int Trk::MaterialMapping::m_etaSide

private

needed for debugging: -1 negative | 0 all | 1 positive

Definition at line 132 of file MaterialMapping.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_extrapolationEngine

ToolHandle<IExtrapolationEngine> Trk::MaterialMapping::m_extrapolationEngine

private

Initial value:

{
    this,
    "ExtrapolationEngine",
    "",
    "Extrapolation Engine"
  }

Definition at line 116 of file MaterialMapping.h.

                                                        {
    this,
    "ExtrapolationEngine",
    "",
    "Extrapolation Engine"
  };

m_inputEventElementTable

SG::ReadHandleKey<Trk::ElementTable> Trk::MaterialMapping::m_inputEventElementTable

private

input event table

Definition at line 167 of file MaterialMapping.h.

m_inputMaterialStepCollection

SG::ReadHandleKey<MaterialStepCollection> Trk::MaterialMapping::m_inputMaterialStepCollection

private

output / input steering

Definition at line 127 of file MaterialMapping.h.

m_layerMaterialAnalysers

ToolHandleArray<ILayerMaterialAnalyser> Trk::MaterialMapping::m_layerMaterialAnalysers

private

Initial value:

{
    this,
    "LayerMaterialAnalysers",
    {},
    "Layer material analysers per creator (if wanted)"
  }

Definition at line 142 of file MaterialMapping.h.

                                                                  {
    this,
    "LayerMaterialAnalysers",
    {},
    "Layer material analysers per creator (if wanted)"
  };

m_layerMaterialCreators

ToolHandleArray<ILayerMaterialCreator> Trk::MaterialMapping::m_layerMaterialCreators

private

Initial value:

{
    this,
    "LayerMaterialCreators",
    {},
    "Layer material creators"
  }

Definition at line 148 of file MaterialMapping.h.

                                                                {
    this,
    "LayerMaterialCreators",
    {},
    "Layer material creators"
  };

m_layerMaterialRecordAnalyser

ToolHandle<ILayerMaterialAnalyser> Trk::MaterialMapping::m_layerMaterialRecordAnalyser

private

Initial value:

{
    this,
    "LayerMaterialRecordAnalyser",
    "",
    "Layer material analyser for the layer material record"
  }

Definition at line 136 of file MaterialMapping.h.

                                                                  {
    this,
    "LayerMaterialRecordAnalyser",
    "",
    "Layer material analyser for the layer material record"
  };

m_layerMaterialScreenOutput

int Trk::MaterialMapping::m_layerMaterialScreenOutput

private

Definition at line 183 of file MaterialMapping.h.

m_layerRecords

std::map<const Layer*, LayerMaterialRecord> Trk::MaterialMapping::m_layerRecords

private

this is the general record for the search

Definition at line 171 of file MaterialMapping.h.

m_layersRecordedPerEvent

std::map<const Layer*, bool> Trk::MaterialMapping::m_layersRecordedPerEvent

private

these are the layers hit per event - for empty hit scaling

Definition at line 173 of file MaterialMapping.h.

m_mapComposition

bool Trk::MaterialMapping::m_mapComposition

private

map the composition of the material

Definition at line 161 of file MaterialMapping.h.

m_mapMaterial

bool Trk::MaterialMapping::m_mapMaterial

private

Mapper and Inspector.

Definition at line 156 of file MaterialMapping.h.

m_mapped

size_t Trk::MaterialMapping::m_mapped

private

Definition at line 179 of file MaterialMapping.h.

m_mappingVolume

const Trk::TrackingVolume* Trk::MaterialMapping::m_mappingVolume

private

Definition at line 124 of file MaterialMapping.h.

m_mappingVolumeName

std::string Trk::MaterialMapping::m_mappingVolumeName

private

Definition at line 123 of file MaterialMapping.h.

m_materialMapper

ToolHandle<IMaterialMapper> Trk::MaterialMapping::m_materialMapper

private

Initial value:

{ this,
                                                "MaterialMapper",
                                                "",
                                                "IMaterialMapper algTool" }

Definition at line 157 of file MaterialMapping.h.

                                              { this,
                                                "MaterialMapper",
                                                "",
                                                "IMaterialMapper algTool" };

m_minCompositionFraction

double Trk::MaterialMapping::m_minCompositionFraction

private

minimal fraction to be accounted for the composition recording

Definition at line 162 of file MaterialMapping.h.

m_outputLayerMaterialSetName

std::string Trk::MaterialMapping::m_outputLayerMaterialSetName

private

Definition at line 128 of file MaterialMapping.h.

m_skippedOutside

size_t Trk::MaterialMapping::m_skippedOutside

private

Definition at line 181 of file MaterialMapping.h.

m_trackingGeometryReadKey

SG::ReadCondHandleKey<TrackingGeometry> Trk::MaterialMapping::m_trackingGeometryReadKey

private

Initial value:

{
    this,
    "TrackingGeometryReadKey",
    "",
    "Key of the TrackingGeometry conditions data."
  }

Definition at line 198 of file MaterialMapping.h.

                                                                 {
    this,
    "TrackingGeometryReadKey",
    "",
    "Key of the TrackingGeometry conditions data."
  };

m_unmapped

size_t Trk::MaterialMapping::m_unmapped

private

Definition at line 180 of file MaterialMapping.h.

m_useLayerThickness

bool Trk::MaterialMapping::m_useLayerThickness

private

use the actual layer thickness

Definition at line 133 of file MaterialMapping.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• MaterialMapping.h
• MaterialMapping.cxx