Trk::MaterialMapper Class Reference

Implementation of the class MaterialMapper. More...

#include <MaterialMapper.h>

Inheritance diagram for Trk::MaterialMapper:

Collaboration diagram for Trk::MaterialMapper:

Public Member Functions
	MaterialMapper (const std::string &, const std::string &, const IInterface *)
	AlgTool like constructor.
virtual	~MaterialMapper ()
	Virtual destructor.
StatusCode	initialize ()
	AlgTool initialize method.
StatusCode	finalize ()
	AlgTool finalize method.
void	recordMaterialHit (const AssociatedMaterial &amhit, const Amg::Vector3D &projectedPosition) const
	Record material hit along the recording.
void	recordLayerHit (const AssociatedMaterial &amhit, bool full=false) const
	Record material hit - if various hits per uniform layer are recorded, or if you want to record one full hit.
void	recordSurfaceHit (const Amg::Vector2D &locpos, const AssociatedMaterial &amhit) const
	Record material hit on a surface.
void	handle (const Incident &inc)
	Handle the incident from the incident service.
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	sysInitialize () override
	Perform system initialization for an algorithm.
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
	DeclareInterfaceID (IMaterialMapper, 1, 0)
	Creates the InterfaceID and interfaceID() method.

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
void	finalizeVolumeHits (bool mapped=true) const
	Finalize the Volume Steps.
void	finalizeLayerHits () const
	Finalize the SingleLayer Steps.
void	finalizeSurfaceHits () const
	Finalize the SingleLayer Steps.
void	bookValidationTree ()
	Validation : book the Tree.
VolumeTreeObject *	volumeTreeObject (const Layer *lay=0, const TrackingVolume *tvol=0) const
	find (&&,||) create a VolumeTreObject
LayerTreeObject *	layerTreeObject (const Layer &lay, bool full=false) const
	find (&&,||) create the LayerTreeObject
SurfaceTreeObject *	surfaceTreeObject (const Layer &lay) const
	find (&&,||) create the LayerTreeObject
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< IIncidentSvc >	m_incidentSvc
ServiceHandle< ITHistSvc >	m_histSvc
Gaudi::Property< unsigned int >	m_maxMappingEvents
unsigned int	m_processedEvents = 0
TTree *	m_validationTree = nullptr
	The validation tree.
Gaudi::Property< std::string >	m_validationTreeName
Gaudi::Property< std::string >	m_validationTreeDescription
Gaudi::Property< std::string >	m_validationTreeFolder
int	m_materialSteps = 0
	number of update positions
float	m_averageEta {}
	average eta
float	m_averagePhi {}
	average ogu
float	m_mappedPath {}
	total mapped path
float	m_mappedPathInX0 {}
	total mapped path in X0
float	m_mappedPathInL0 {}
	total mapped path in L0
float	m_mappedPathRho {}
	total mapped path times rho
float	m_mappedPathZARho {}
	total mapped path times (Z/A)*rho
float	m_unmappedPathInX0 {}
	total path in x0 in these events lost
int	m_mapped [TRKDETDESCRTOOLS_MAXSTEPS] {}
	mapped or not mapped
float	m_materialAccumPathInX0 [TRKDETDESCRTOOLS_MAXSTEPS] {}
	accumulated path length in x0
float	m_materialAccumPathZARho [TRKDETDESCRTOOLS_MAXSTEPS] {}
	accumulated path length times (Z/A)*rho
float	m_materialStepPath [TRKDETDESCRTOOLS_MAXSTEPS] {}
	step path
float	m_materialStepX0 [TRKDETDESCRTOOLS_MAXSTEPS] {}
	step x0
float	m_materialStepL0 [TRKDETDESCRTOOLS_MAXSTEPS] {}
	step l0
float	m_materialStepZ [TRKDETDESCRTOOLS_MAXSTEPS] {}
	step Z
float	m_materialStepA [TRKDETDESCRTOOLS_MAXSTEPS] {}
	step A
float	m_materialStepRho [TRKDETDESCRTOOLS_MAXSTEPS] {}
	step rho
float	m_materialStepPositionX [TRKDETDESCRTOOLS_MAXSTEPS] {}
	x position of the material recording
float	m_materialStepPositionY [TRKDETDESCRTOOLS_MAXSTEPS] {}
	y position of the material recording
float	m_materialStepPositionZ [TRKDETDESCRTOOLS_MAXSTEPS] {}
	z position of the material recording
float	m_materialStepPositionR [TRKDETDESCRTOOLS_MAXSTEPS] {}
	r value of the material recording
float	m_materialProjPositionX [TRKDETDESCRTOOLS_MAXSTEPS] {}
	x position of the material recording when assigned to layer
float	m_materialProjPositionY [TRKDETDESCRTOOLS_MAXSTEPS] {}
	y position of the material recording when assigned to layer
float	m_materialProjPositionZ [TRKDETDESCRTOOLS_MAXSTEPS] {}
	z position of the material recording when assigned to layer
float	m_materialProjPositionR [TRKDETDESCRTOOLS_MAXSTEPS] {}
	r value of the material recording when assigned to layer
float	m_materialProjDistance [TRKDETDESCRTOOLS_MAXSTEPS] {}
	the distance to the projected hit
Gaudi::Property< bool >	m_volumeValidation {this, "TrackingVolumeValidation", true}
Gaudi::Property< std::string >	m_volumeTreePrefix {this, "TrackingVolumeTreePrefix", "VolumeMaterial"}
std::map< const Trk::TrackingVolume *, VolumeTreeObject * >	m_volumeTrees
std::map< const Trk::TrackingVolume *, VolumeTreeObject * >	m_volumeTreesUnmapped
Gaudi::Property< bool >	m_layerValidation {this, "DetailedLayerValidation", true}
Gaudi::Property< std::string >	m_layerTreePrefix {this, "DetailedLayerTreePrefix", "LayerMaterial_"}
std::map< const Trk::Layer *, LayerTreeObject * >	m_layerTrees
std::map< const Trk::Layer *, LayerTreeObject * >	m_layerFullTrees
Gaudi::Property< bool >	m_surfaceValidation {this, "DetailedSurfaceValidation", true}
Gaudi::Property< std::string >	m_surfaceTreePrefix {this, "DetailedSurfaceTreePrefix", "SurfaceMaterial_"}
std::map< const Trk::Layer *, SurfaceTreeObject * >	m_surfaceTrees
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

Implementation of the class MaterialMapper.

The correct material mapping can only be done with stiff tracks as the finalizeEvent method requires an eta,phi bin!

Author

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

Definition at line 204 of file MaterialMapper.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MaterialMapper()

Trk::MaterialMapper::MaterialMapper	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

AlgTool like constructor.

Definition at line 19 of file MaterialMapper.cxx.

: AthAlgTool(t,n,p),
  m_incidentSvc("IncidentSvc", n),
  m_histSvc("THistSvc", n)
{
    declareInterface<IMaterialMapper>(this);
}

~MaterialMapper()

Trk::MaterialMapper::~MaterialMapper ( )

virtual

Virtual destructor.

Definition at line 28 of file MaterialMapper.cxx.

{
    // memory cleanup
    if (m_volumeValidation) {
        auto volTreeIter = m_volumeTrees.begin();
        auto endVolTreeIter = m_volumeTrees.end();
        for ( ; volTreeIter != endVolTreeIter; delete (volTreeIter->second), ++volTreeIter) {}
    }
 
    if (m_layerValidation) {
        // delete the layer hit TTree
        auto layTreeIter  = m_layerTrees.begin();
        auto endLayTreeIter = m_layerTrees.end();
        for ( ; layTreeIter != endLayTreeIter; delete (layTreeIter->second), ++layTreeIter) {}
        // delete the layer per event TTree
        layTreeIter  = m_layerFullTrees.begin();
        endLayTreeIter = m_layerFullTrees.end();
        for ( ; layTreeIter != endLayTreeIter; delete (layTreeIter->second), ++layTreeIter) {}
    }
 
    if (m_surfaceValidation) {
        // finalize the Hit Tree
        auto surfTreeIter  = m_surfaceTrees.begin();
        auto endSurfTreeIter = m_surfaceTrees.end();
        for ( ; surfTreeIter != endSurfTreeIter; delete (surfTreeIter->second), ++surfTreeIter) {}
    }
}

Member Function Documentation

bookValidationTree()

void Trk::MaterialMapper::bookValidationTree ( )

private

Validation : book the Tree.

Definition at line 576 of file MaterialMapper.cxx.

{
 
    ATH_MSG_INFO( "Booking the Validation Tree ... " );
 
    // (1) Main MaterialMapper TTree
    // ------------- validation section ------------------------------------------
    m_validationTree = new TTree(m_validationTreeName.value().c_str(), m_validationTreeDescription.value().c_str());
    
    // position coordinates of the update
    m_validationTree->Branch("Eta",                    &m_averageEta,            "averageEta/F");
    m_validationTree->Branch("Phi",                    &m_averagePhi,            "averagePhiF");
    m_validationTree->Branch("Path",                   &m_mappedPath,            "path/F");
    m_validationTree->Branch("PathInX0",               &m_mappedPathInX0,        "pathInX0/F");
    m_validationTree->Branch("PathInL0",               &m_mappedPathInL0,        "pathInL0/F");
    m_validationTree->Branch("PathRho",                &m_mappedPathRho,         "pathRho/F");
    m_validationTree->Branch("PathZARho",              &m_mappedPathZARho,       "pathZARho/F");
    m_validationTree->Branch("UnmappedPathInX0",       &m_unmappedPathInX0,      "unmappedPathInX0/F");
    m_validationTree->Branch("MaterialSteps",          &m_materialSteps,         "steps/I");
    m_validationTree->Branch("Mapped",                 m_mapped,                 "mapped[steps]/I");
    m_validationTree->Branch("MaterialAccumPathInX0",  m_materialAccumPathInX0,  "materialAccumPinX0[steps]/F");
    m_validationTree->Branch("MaterialAccumPathZARho", m_materialAccumPathZARho, "materialAccumPZARho[steps]/F");
    m_validationTree->Branch("MaterialStepPath",       m_materialStepPath,       "materialStepPath[steps]/F");
    m_validationTree->Branch("MaterialStepX0",         m_materialStepX0,         "materialStepX0[steps]/F");
    m_validationTree->Branch("MaterialStepL0",         m_materialStepL0,         "materialStepL0[steps]/F");
    m_validationTree->Branch("MaterialStepZ",          m_materialStepZ,          "materialStepZ[steps]/F");
    m_validationTree->Branch("MaterialStepA",          m_materialStepA,          "materialStepA[steps]/F");
    m_validationTree->Branch("MaterialStepRho",        m_materialStepRho,        "materialStepRho[steps]/F");
    m_validationTree->Branch("MaterialStepPositionX",  m_materialStepPositionX , "materialStepX[steps]/F");
    m_validationTree->Branch("MaterialStepPositionY",  m_materialStepPositionY , "materialStepY[steps]/F");
    m_validationTree->Branch("MaterialStepPositionZ",  m_materialStepPositionZ , "materialStepZ[steps]/F");
    m_validationTree->Branch("MaterialStepPositionR",  m_materialStepPositionR , "materialStepR[steps]/F");
    m_validationTree->Branch("MaterialProjPositionX",  m_materialProjPositionX , "materialProjX[steps]/F");
    m_validationTree->Branch("MaterialProjPositionY",  m_materialProjPositionY , "materialProjY[steps]/F");
    m_validationTree->Branch("MaterialProjPositionZ",  m_materialProjPositionZ , "materialProjZ[steps]/F");
    m_validationTree->Branch("MaterialProjPositionR",  m_materialProjPositionR , "materialProjR[steps]/F");
    m_validationTree->Branch("MaterialProjDistance",   m_materialProjDistance  , "materialProjD[steps]/F");
    
    // now register the Tree
    if (m_histSvc->regTree(m_validationTreeFolder.value().c_str(), m_validationTree).isFailure()) {
        ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !" );
        delete m_validationTree; m_validationTree = nullptr;
        return;
    }
    
    ATH_MSG_INFO( "                            ... successful." );
 
} 

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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());
 
  }

DeclareInterfaceID()

Trk::IMaterialMapper::DeclareInterfaceID ( IMaterialMapper , 1 , 0  )

inherited

Creates the InterfaceID and interfaceID() method.

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

finalize()

StatusCode Trk::MaterialMapper::finalize

(

)

AlgTool finalize method.

Definition at line 74 of file MaterialMapper.cxx.

{
    ATH_MSG_INFO(  "finalize() successful" );
    return StatusCode::SUCCESS;
}

finalizeLayerHits()

void Trk::MaterialMapper::finalizeLayerHits ( ) const

private

Finalize the SingleLayer Steps.

Definition at line 254 of file MaterialMapper.cxx.

{
 
    ATH_MSG_VERBOSE( "finalizeEvent() on Layer hits " );
 
    for (size_t iltm = 0; iltm < 2; ++iltm)     {   
        // loop over all layer Tree objects and fill them
        auto layObjIter  = iltm ? m_layerFullTrees.begin() : m_layerTrees.begin();
        auto endIter     = iltm ? m_layerFullTrees.end() : m_layerTrees.end();
        // do the loop
        for ( ; layObjIter != endIter; ++layObjIter ) {
        
            Trk::LayerTreeObject* layTreeObj = layObjIter->second;
        
            if (!layTreeObj) continue;
        
            // get the number of single hits
            int hits = (*layTreeObj).densedHits;
        
            if ((*layTreeObj).pathInX0 > 0.) {
                if (hits>1) {
                    (*layTreeObj).densedHitX         /= hits;
                    (*layTreeObj).densedHitY         /= hits;
                    (*layTreeObj).densedHitZ         /= hits;
                    (*layTreeObj).densedHitR         /= hits;
                    (*layTreeObj).densedHitPhi       /= hits;
                    (*layTreeObj).densedHitTheta     /= hits;
                    (*layTreeObj).correctionFactor   /= hits;
                    (*layTreeObj).A                  /= (*layTreeObj).rho;
                    (*layTreeObj).Z                  /= (*layTreeObj).rho;
                    (*layTreeObj).rho                /= (*layTreeObj).path;
                }
                // fill the layer Tree Object
                (*layTreeObj).tree->Fill();          
            }
            // reset
            (*layTreeObj).layerHits         = 0;
            (*layTreeObj).path              = 0.;
            (*layTreeObj).pathInX0          = 0.;
            (*layTreeObj).pathInL0          = 0.;
            (*layTreeObj).densedHits        = 0;
            (*layTreeObj).densedHitX        = 0.;
            (*layTreeObj).densedHitY        = 0.;
            (*layTreeObj).densedHitZ        = 0.;
            (*layTreeObj).densedHitR        = 0.;
            (*layTreeObj).densedHitPhi      = 0.;
            (*layTreeObj).densedHitTheta    = 0.;
            (*layTreeObj).correctionFactor  = 0.;
            (*layTreeObj).A                 = 0.;
            (*layTreeObj).Z                 = 0.;
            (*layTreeObj).rho               = 0.;
        }
    }
}

finalizeSurfaceHits()

void Trk::MaterialMapper::finalizeSurfaceHits ( ) const

private

Finalize the SingleLayer Steps.

Definition at line 341 of file MaterialMapper.cxx.

{
 
    ATH_MSG_VERBOSE( "finalizeEvent() on Surface hits " );   
 
    // loop over all layer Tree objects and fill them
    auto surfObjIter  = m_surfaceTrees.begin();
    auto endIter      = m_surfaceTrees.end();
    // do the loop
    for ( ; surfObjIter != endIter; ++surfObjIter ) {
        Trk::SurfaceTreeObject* surfTreeObj = surfObjIter->second;
        // get the number of single hits
        int hits = (*surfTreeObj).surfaceHits;
        // fill only if hits have been there
        if ((*surfTreeObj).pathInX0 > 0.) {
            if (hits>1) {
                (*surfTreeObj).loc1               /= hits;
                (*surfTreeObj).loc2               /= hits;
                (*surfTreeObj).eta                /= hits;
                (*surfTreeObj).correctionFactor   /= hits;
                (*surfTreeObj).A                  /= hits; 
                (*surfTreeObj).Z                  /= hits; 
                (*surfTreeObj).rho                /= hits; 
            }
            // fill the tree
            (*surfTreeObj).tree->Fill();
        }
        // reset
        (*surfTreeObj).loc1               = 0.;
        (*surfTreeObj).loc2               = 0.;
        (*surfTreeObj).eta                = 0.;
 
        (*surfTreeObj).correctionFactor   = 0.;
        (*surfTreeObj).path               = 0.;
        (*surfTreeObj).pathInX0           = 0.;
        (*surfTreeObj).pathInL0           = 0.;
        (*surfTreeObj).rho                = 0.;
 
        (*surfTreeObj).surfaceHits        = 0;
 
    }
}

finalizeVolumeHits()

void Trk::MaterialMapper::finalizeVolumeHits ( bool mapped = true ) const

private

Finalize the Volume Steps.

Definition at line 166 of file MaterialMapper.cxx.

{
    ATH_MSG_VERBOSE( "finalizeEvent() on Volume hits " );   
 
    auto volTreeIter = mapped ? m_volumeTrees.begin() : m_volumeTreesUnmapped.begin();
    auto endVolTreeIter = mapped ? m_volumeTrees.end() : m_volumeTreesUnmapped.end();
 
    // do the loop
    for ( ; volTreeIter != endVolTreeIter; ++volTreeIter ) {
 
        Trk::VolumeTreeObject* volTreeObj = volTreeIter->second;
 
        if (!volTreeObj) continue;
 
        if ((*volTreeObj).path > 0.) {
            // spatial mapping
            (*volTreeObj).eta         = m_averageEta;
            (*volTreeObj).phi         = m_averagePhi;
            // fill the volume Tree Object
            (*volTreeObj).tree->Fill();          
        }
        // reset
        (*volTreeObj).eta           = 0.;
        (*volTreeObj).phi           = 0.;
        (*volTreeObj).path          = 0.;
        (*volTreeObj).pathInX0      = 0.;
        (*volTreeObj).pathInL0      = 0.;
        (*volTreeObj).pathZARho     = 0.;
 
    }
}

handle()

void Trk::MaterialMapper::handle

(

const Incident &

inc

)

Handle the incident from the incident service.

Definition at line 543 of file MaterialMapper.cxx.

                                                    {
  // check the incident type
  if ( inc.type() == IncidentType::EndEvent && m_materialSteps){
    // check if the hit collection already contains:
      ATH_MSG_VERBOSE("EndEvent incident caught, finalize histogramns");
      // average Eta / Phi 
      m_averageEta /= m_materialSteps;
      m_averagePhi /= m_materialSteps;
      // (a) the volume validation
      finalizeVolumeHits(true);    // trees with mapped hits
      finalizeVolumeHits(false);   // trees with unmapped hits
      // (b) the layer validation
      finalizeLayerHits();
      // (c) the surface validation (reference material)
      finalizeSurfaceHits();
      // fill the main TTree & reset
      m_validationTree->Fill();
      // initialize the eta/phi
      m_averageEta          = 0.;
      m_averagePhi          = 0.;
      // initialize the rest
      m_materialSteps       = 0; 
      m_mappedPath          = 0.;
      m_mappedPathInX0      = 0.;
      m_mappedPathInL0      = 0.;
      m_mappedPathRho       = 0.;
      m_mappedPathZARho     = 0.; 
      // increate counter
      ++m_processedEvents;       
  }
  }

initialize()

StatusCode Trk::MaterialMapper::initialize

(

)

AlgTool initialize method.

Definition at line 58 of file MaterialMapper.cxx.

{
 
    // Athena/Gaudi framework
    ATH_CHECK( m_incidentSvc.retrieve() );
    ATH_CHECK( m_histSvc.retrieve() );
 
    // register to the incident service: EndEvent for histogram filling and reset
    m_incidentSvc->addListener( this, IncidentType::EndEvent);
    
    // book the Tree 
    bookValidationTree();
    return StatusCode::SUCCESS;
}     

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

layerTreeObject()

Trk::LayerTreeObject * Trk::MaterialMapper::layerTreeObject ( const Layer & lay, bool full = false ) const

private

find (&&,||) create the LayerTreeObject

Definition at line 434 of file MaterialMapper.cxx.

{
    if (!lay.layerIndex().value()) return nullptr;
 
    // try to find the histogram
 
    Trk::LayerTreeObject* layTreeObj = nullptr;
 
    if (full) {
      auto it = m_layerFullTrees.find(&lay);
      if (it != m_layerFullTrees.end()) {
        return it->second;
      }
    }
    else {
      auto it = m_layerTrees.find(&lay);
      if (it != m_layerTrees.end()) {
        return it->second;
      }
    }
 
    {
        // check if it is a boundary MaterialLayer
        const Trk::MaterialLayer* mLayer = dynamic_cast<const Trk::MaterialLayer*>(&lay);
        if (mLayer)
            ATH_MSG_INFO("MaterialLayer from BoundarySurface detected.");
        // get the TrackingVolume
        const Trk::TrackingVolume* enclosingVolume = lay.enclosingTrackingVolume();
        TString tvolName = (enclosingVolume) ?  enclosingVolume->volumeName() : "BoundaryLayers";
        tvolName.ReplaceAll("::","_");
 
        TString treeName   = tvolName;
                treeName  += "_";
                treeName  += m_layerTreePrefix.value();
 
        TString layerType = (lay.surfaceRepresentation().type() == Trk::SurfaceType::Cylinder) ? 
                "CylinderLayer_" : "DiscLayer_";
        if (full) treeName += "full_";
                treeName  += layerType;
        if (mLayer) treeName += "boundary_";
                treeName  += lay.layerIndex().value();
 
        TString treeTitle  = "TrackingVolume :";
                treeTitle += tvolName;
 
        TString treeRegName  = "/val/";
                treeRegName += treeName;
 
        ATH_MSG_INFO( "No Tree found for Layer " << lay.layerIndex().value() << " in Volume '" << tvolName << "'.");
        ATH_MSG_INFO( "   -> Booking it now with register name : " << treeRegName.Data() );
 
        layTreeObj = new Trk::LayerTreeObject(treeName, treeTitle);
        if (full) m_layerFullTrees.insert(std::make_pair(&lay,layTreeObj));
        else m_layerTrees.insert(std::make_pair(&lay,layTreeObj));
 
        // now register the Tree
        if (m_histSvc->regTree(treeRegName.Data(), (*layTreeObj).tree).isFailure()) {
            ATH_MSG_ERROR( "initialize() Could not register the validation Tree -> Switching Tree output for this layer off !" );
            delete layTreeObj; layTreeObj = nullptr;
        }
 
    }
 
    return layTreeObj;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

recordLayerHit()

void Trk::MaterialMapper::recordLayerHit ( const AssociatedMaterial & amhit, bool full = false ) const

virtual

Record material hit - if various hits per uniform layer are recorded, or if you want to record one full hit.

Implements Trk::IMaterialMapper.

Definition at line 199 of file MaterialMapper.cxx.

{
    
    if (m_processedEvents >= m_maxMappingEvents) return;
    
    const Trk::Layer* lay = amhit.associatedLayer();
    if (m_layerValidation && lay) {
        // try to find the histogram
        Trk::LayerTreeObject* layTreeObj   = layerTreeObject(*lay,full);
        if (layTreeObj
                && (*layTreeObj).layerHits < TRKDETDESCRTOOLS_MAXLAYERHITS
                && amhit.steplengthInX0() > 0.)
        {
 
            const Amg::Vector3D&  pos = amhit.materialPosition();
 
            // hit positions
            double posX   = pos.x();
            double posY   = pos.y();
            double posZ   = pos.z();
            double posR   = pos.perp();
            double posEta = pos.eta();
 
            // fill the hit position --------------------
            (*layTreeObj).hitPositionX[(*layTreeObj).layerHits] = posX;
            (*layTreeObj).hitPositionY[(*layTreeObj).layerHits] = posY;
            (*layTreeObj).hitPositionZ[(*layTreeObj).layerHits] = posZ;
            (*layTreeObj).hitPositionR[(*layTreeObj).layerHits] = posR;
            (*layTreeObj).hitPositionEta[(*layTreeObj).layerHits] = posEta;
 
            // increase the layer Hits
            ++(*layTreeObj).layerHits;
            ++(*layTreeObj).densedHits;
 
            // fill the densed Hit position ---------------
            (*layTreeObj).densedHitX         += posX;
            (*layTreeObj).densedHitY         += posY;
            (*layTreeObj).densedHitZ         += posZ;
            (*layTreeObj).densedHitR         += posR;
            (*layTreeObj).densedHitPhi       += pos.phi();
            (*layTreeObj).densedHitTheta     += pos.theta();
 
            // fill the correction factor ------------------
            (*layTreeObj).correctionFactor   += amhit.correctionFactor();
            (*layTreeObj).path               += amhit.steplength();
            (*layTreeObj).pathInX0           += amhit.steplengthInX0();
            (*layTreeObj).pathInL0           += amhit.steplengthInL0();
            (*layTreeObj).A                  += amhit.A() * amhit.rho() * amhit.steplength();
            (*layTreeObj).Z                  += amhit.Z() * amhit.rho() * amhit.steplength();
            (*layTreeObj).rho                += amhit.rho() * amhit.steplength();
 
        }
    }
}

recordMaterialHit()

void Trk::MaterialMapper::recordMaterialHit ( const AssociatedMaterial & amhit, const Amg::Vector3D & projectedPosition ) const

virtual

Record material hit along the recording.

Implements Trk::IMaterialMapper.

Definition at line 80 of file MaterialMapper.cxx.

{
 
    if (m_processedEvents >= m_maxMappingEvents) return;
 
    // ----------------------------------- Recording Hits section --------------------------------
    const Amg::Vector3D& position = amhit.materialPosition();
 
    // get the tracking volume
    const Trk::TrackingVolume* tvol = amhit.associatedTrackingVolume();
    const Trk::Layer*           lay = amhit.associatedLayer();
    
    if (!tvol) {
        ATH_MSG_WARNING("Could not associate TrackingVolume to material step!");
        return;
    }
    
    // ----------------------------------- The Material Validation code --------------------------
    const Trk::TrackingVolume* itvol = tvol;
    while (itvol) {
        // get the volume tree object
        ATH_MSG_VERBOSE( "getting volTreeObj for:   " << itvol->volumeName() << "   at:   " << itvol );
        Trk::VolumeTreeObject* volTreeObj   = volumeTreeObject(lay,itvol);
        if (volTreeObj) {
            // add the quantities
            (*volTreeObj).path          += amhit.steplength();
            (*volTreeObj).pathInX0      += amhit.steplengthInX0();
            (*volTreeObj).pathInL0      += amhit.steplengthInL0();
            if(amhit.A() != 0.0) {
                (*volTreeObj).pathZARho     += (amhit.Z()/amhit.A())*amhit.rho()*amhit.steplength();
            }
        } else
            ATH_MSG_WARNING( "Cannot find/create VolumeTreeObject for volume '" << itvol->volumeName() << "'." );
        itvol = itvol->getMotherVolume();
        if (itvol) ATH_MSG_VERBOSE( "motherVolume found:   " << itvol->volumeName() );
    }
 
    // -------------------------------- main tree section -----------------------------------------
    // eta / phi
    m_averageEta += position.eta();
    m_averagePhi += position.phi();
    // effectively crossed Z/A*rho
    double steplength = amhit.steplength();
    // fill the variables for spatial information & event characteristics
    if (lay) {
        m_mappedPath            +=  steplength;
        m_mappedPathInX0        +=  amhit.steplengthInX0();
        m_mappedPathInL0        +=  amhit.steplengthInL0();
        m_mappedPathRho         +=  amhit.rho()*steplength;
        if(amhit.A() != 0.0) {
            m_mappedPathZARho       +=  (amhit.Z()/amhit.A())*amhit.rho()*steplength;
        }
        ATH_MSG_VERBOSE("[ MaterialMapper ] Accumulated Path in Rho (*Z/A) = " << m_mappedPathRho << " ( " <<  m_mappedPathZARho << " )");
    } else 
        m_unmappedPathInX0 +=  amhit.steplengthInX0();
    
    // mapping information
    m_mapped[m_materialSteps]                    = lay ? lay->layerIndex().value() : 0;
    // the position & step information 
    m_materialAccumPathInX0[m_materialSteps]     = m_mappedPathInX0;
    m_materialAccumPathZARho[m_materialSteps]    = m_mappedPathZARho;
    m_materialStepPath[m_materialSteps]          = steplength;
    m_materialStepX0[m_materialSteps]            = amhit.x0();
    m_materialStepL0[m_materialSteps]            = amhit.l0();
    m_materialStepA[m_materialSteps]             = amhit.A();
    m_materialStepZ[m_materialSteps]             = amhit.Z();
    m_materialStepRho[m_materialSteps]           = amhit.rho();
    m_materialStepPositionX[m_materialSteps]     = position.x();
    m_materialStepPositionY[m_materialSteps]     = position.y();
    m_materialStepPositionZ[m_materialSteps]     = position.z();
    m_materialStepPositionR[m_materialSteps]     = position.perp();
    // record the projected position as well         
    m_materialProjPositionX[m_materialSteps]     = projectedPosition.x();
    m_materialProjPositionY[m_materialSteps]     = projectedPosition.y();
    m_materialProjPositionZ[m_materialSteps]     = projectedPosition.z();
    m_materialProjPositionR[m_materialSteps]     = projectedPosition.perp();
    m_materialProjDistance[m_materialSteps]      = (position-projectedPosition).mag();
    // and increase the number of steps
    ++m_materialSteps;
    
 
    // record the layer hit
    if (m_layerValidation) recordLayerHit(amhit);
}

recordSurfaceHit()

void Trk::MaterialMapper::recordSurfaceHit ( const Amg::Vector2D & locpos, const AssociatedMaterial & amhit ) const

virtual

Record material hit on a surface.

Implements Trk::IMaterialMapper.

Definition at line 310 of file MaterialMapper.cxx.

{
 
   if (m_processedEvents >= m_maxMappingEvents) return;
 
   const Trk::Layer* lay = amhit.associatedLayer();
   if (m_surfaceValidation && lay) {
        // try to find the histogram
        Trk::SurfaceTreeObject* surfTreeObj = surfaceTreeObject(*lay);
        // now fill
        if (surfTreeObj) {
            // fill it
            (*surfTreeObj).loc1               += locpos[0];
            (*surfTreeObj).loc2               += locpos[1];
            (*surfTreeObj).eta                += amhit.materialPosition().eta();
            (*surfTreeObj).correctionFactor   += amhit.correctionFactor();
            (*surfTreeObj).path               += amhit.steplength();
            (*surfTreeObj).pathInX0           += amhit.steplengthInX0();
            (*surfTreeObj).pathInL0           += amhit.steplengthInL0();
            (*surfTreeObj).A                  += amhit.A()*amhit.steplength()*amhit.rho();
            (*surfTreeObj).Z                  += amhit.Z()*amhit.steplength()*amhit.rho();
            (*surfTreeObj).rho                += amhit.rho()*amhit.steplength();
            // increase the surface hits
            ++(*surfTreeObj).surfaceHits;
 
        }
    }
}

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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

surfaceTreeObject()

Trk::SurfaceTreeObject * Trk::MaterialMapper::surfaceTreeObject ( const Layer & lay ) const

private

find (&&,||) create the LayerTreeObject

Definition at line 501 of file MaterialMapper.cxx.

{
    // try to find the histogram
    auto endIter  = m_surfaceTrees.end();
    auto findIter = m_surfaceTrees.end();
 
    Trk::SurfaceTreeObject* surfTreeObj = nullptr;
 
    findIter = m_surfaceTrees.find(&lay);
    if (findIter == endIter) {
        // get the TrackingVolume
        const Trk::TrackingVolume* enclosingVolume = lay.enclosingTrackingVolume();
        TString volumeName = (enclosingVolume) ?  enclosingVolume->volumeName() : "Unknown";
 
        TString treeName   = m_surfaceTreePrefix.value();
                treeName  += lay.layerIndex().value();
 
        TString treeTitle  = "TrackingVolume :";
                treeTitle += volumeName;
 
        TString treeRegName  = "/val/";
                treeRegName += treeName;
 
        ATH_MSG_INFO( "No Tree found for Layer " << lay.layerIndex().value()
                << " in Volume '" << volumeName << "'." );
        ATH_MSG_INFO( "   -> Booking it now with register name : " << treeRegName.Data() );
 
        surfTreeObj = new Trk::SurfaceTreeObject(treeName, treeTitle);
        m_surfaceTrees.insert(std::make_pair(&lay,surfTreeObj));
 
        // now register the Tree
        if (m_histSvc->regTree(treeRegName.Data(), (*surfTreeObj).tree).isFailure()) {
            ATH_MSG_INFO( "initialize() Could not register the validation Tree -> Switching Tree output for this surface off !" );
            delete surfTreeObj; surfTreeObj = nullptr;
        }
 
    } else  // a tree is found
        surfTreeObj = findIter->second;
    return surfTreeObj;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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);
      }
    }
  }

volumeTreeObject()

Trk::VolumeTreeObject * Trk::MaterialMapper::volumeTreeObject ( const Layer * lay = 0, const TrackingVolume * tvol = 0 ) const

private

find (&&,||) create a VolumeTreObject

Definition at line 385 of file MaterialMapper.cxx.

{
    // try to find the histogram
    auto endIter =  lay ? m_volumeTrees.end() : m_volumeTreesUnmapped.end();
    auto findIter = lay ? m_volumeTrees.end() : m_volumeTreesUnmapped.end();
 
    Trk::VolumeTreeObject* tvolTreeObj = nullptr;
 
    findIter = lay ? m_volumeTrees.find(tvol) : m_volumeTreesUnmapped.find(tvol);
 
    if (findIter == endIter) {
 
        TString   tvolName   = tvol->volumeName();
        tvolName.ReplaceAll("::","_");
 
        TString   treeName   = tvolName;
                  treeName  += "_";
                  treeName  += m_volumeTreePrefix.value();
        if (!lay) treeName  += "_UNMAPPED";
 
        TString   treeTitle  = "TrackingVolume : ";
                  treeTitle += tvolName;
        if (!lay) treeTitle += " - UNMAPPED";
 
        TString treeRegName  = "/val/";
                treeRegName += treeName;
 
        ATH_MSG_INFO( "No Tree found for " << treeTitle );
        ATH_MSG_INFO( "   -> Booking it now with register name : " << treeRegName.Data() );
 
        tvolTreeObj = new Trk::VolumeTreeObject(treeName, treeTitle);
        if (lay)
            m_volumeTrees.insert(std::make_pair(tvol,tvolTreeObj));
        else
            m_volumeTreesUnmapped.insert(std::make_pair(tvol,tvolTreeObj));
 
        // now register the Tree
        if (m_histSvc->regTree(treeRegName.Data(), (*tvolTreeObj).tree).isFailure()) {
            ATH_MSG_ERROR( "initialize() Could not register the validation Tree -> Switching Tree output for this volume off !" );
            delete tvolTreeObj; tvolTreeObj = nullptr;
        }
 
    } else  // a tree is found
        tvolTreeObj = findIter->second;
 
    return tvolTreeObj;
}

Member Data Documentation

m_averageEta

float Trk::MaterialMapper::m_averageEta {}

mutableprivate

average eta

Definition at line 284 of file MaterialMapper.h.

{};                                             

m_averagePhi

float Trk::MaterialMapper::m_averagePhi {}

mutableprivate

average ogu

Definition at line 285 of file MaterialMapper.h.

{};                                             

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_histSvc

ServiceHandle<ITHistSvc> Trk::MaterialMapper::m_histSvc

private

Definition at line 261 of file MaterialMapper.h.

m_incidentSvc

ServiceHandle<IIncidentSvc> Trk::MaterialMapper::m_incidentSvc

private

Definition at line 260 of file MaterialMapper.h.

m_layerFullTrees

std::map< const Trk::Layer*, LayerTreeObject* > Trk::MaterialMapper::m_layerFullTrees

mutableprivate

Definition at line 324 of file MaterialMapper.h.

m_layerTreePrefix

Gaudi::Property<std::string> Trk::MaterialMapper::m_layerTreePrefix {this, "DetailedLayerTreePrefix", "LayerMaterial_"}

private

Definition at line 321 of file MaterialMapper.h.

{this, "DetailedLayerTreePrefix", "LayerMaterial_"};

m_layerTrees

std::map< const Trk::Layer*, LayerTreeObject* > Trk::MaterialMapper::m_layerTrees

mutableprivate

Definition at line 323 of file MaterialMapper.h.

m_layerValidation

Gaudi::Property<bool> Trk::MaterialMapper::m_layerValidation {this, "DetailedLayerValidation", true}

private

Definition at line 320 of file MaterialMapper.h.

{this, "DetailedLayerValidation", true};

m_mapped

int Trk::MaterialMapper::m_mapped[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

mapped or not mapped

Definition at line 292 of file MaterialMapper.h.

{};                      

m_mappedPath

float Trk::MaterialMapper::m_mappedPath {}

mutableprivate

total mapped path

Definition at line 286 of file MaterialMapper.h.

{};                                             

m_mappedPathInL0

float Trk::MaterialMapper::m_mappedPathInL0 {}

mutableprivate

total mapped path in L0

Definition at line 288 of file MaterialMapper.h.

{};                                         

m_mappedPathInX0

float Trk::MaterialMapper::m_mappedPathInX0 {}

mutableprivate

total mapped path in X0

Definition at line 287 of file MaterialMapper.h.

{};                                         

m_mappedPathRho

float Trk::MaterialMapper::m_mappedPathRho {}

mutableprivate

total mapped path times rho

Definition at line 289 of file MaterialMapper.h.

{};                                          

m_mappedPathZARho

float Trk::MaterialMapper::m_mappedPathZARho {}

mutableprivate

total mapped path times (Z/A)*rho

Definition at line 290 of file MaterialMapper.h.

{};                                        

m_materialAccumPathInX0

float Trk::MaterialMapper::m_materialAccumPathInX0[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

accumulated path length in x0

Definition at line 293 of file MaterialMapper.h.

{};       

m_materialAccumPathZARho

float Trk::MaterialMapper::m_materialAccumPathZARho[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

accumulated path length times (Z/A)*rho

Definition at line 294 of file MaterialMapper.h.

{};      

m_materialProjDistance

float Trk::MaterialMapper::m_materialProjDistance[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

the distance to the projected hit

Definition at line 309 of file MaterialMapper.h.

{};        

m_materialProjPositionR

float Trk::MaterialMapper::m_materialProjPositionR[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

r value of the material recording when assigned to layer

Definition at line 308 of file MaterialMapper.h.

{};       

m_materialProjPositionX

float Trk::MaterialMapper::m_materialProjPositionX[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

x position of the material recording when assigned to layer

Definition at line 305 of file MaterialMapper.h.

{};       

m_materialProjPositionY

float Trk::MaterialMapper::m_materialProjPositionY[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

y position of the material recording when assigned to layer

Definition at line 306 of file MaterialMapper.h.

{};       

m_materialProjPositionZ

float Trk::MaterialMapper::m_materialProjPositionZ[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

z position of the material recording when assigned to layer

Definition at line 307 of file MaterialMapper.h.

{};       

m_materialStepA

float Trk::MaterialMapper::m_materialStepA[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

step A

Definition at line 299 of file MaterialMapper.h.

{};               

m_materialStepL0

float Trk::MaterialMapper::m_materialStepL0[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

step l0

Definition at line 297 of file MaterialMapper.h.

{};              

m_materialStepPath

float Trk::MaterialMapper::m_materialStepPath[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

step path

Definition at line 295 of file MaterialMapper.h.

{};            

m_materialStepPositionR

float Trk::MaterialMapper::m_materialStepPositionR[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

r value of the material recording

Definition at line 304 of file MaterialMapper.h.

{};       

m_materialStepPositionX

float Trk::MaterialMapper::m_materialStepPositionX[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

x position of the material recording

Definition at line 301 of file MaterialMapper.h.

{};       

m_materialStepPositionY

float Trk::MaterialMapper::m_materialStepPositionY[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

y position of the material recording

Definition at line 302 of file MaterialMapper.h.

{};       

m_materialStepPositionZ

float Trk::MaterialMapper::m_materialStepPositionZ[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

z position of the material recording

Definition at line 303 of file MaterialMapper.h.

{};       

m_materialStepRho

float Trk::MaterialMapper::m_materialStepRho[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

step rho

Definition at line 300 of file MaterialMapper.h.

{};             

m_materialSteps

int Trk::MaterialMapper::m_materialSteps = 0

mutableprivate

number of update positions

Definition at line 283 of file MaterialMapper.h.

m_materialStepX0

float Trk::MaterialMapper::m_materialStepX0[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

step x0

Definition at line 296 of file MaterialMapper.h.

{};              

m_materialStepZ

float Trk::MaterialMapper::m_materialStepZ[TRKDETDESCRTOOLS_MAXSTEPS] {}

mutableprivate

step Z

Definition at line 298 of file MaterialMapper.h.

{};               

m_maxMappingEvents

Gaudi::Property<unsigned int> Trk::MaterialMapper::m_maxMappingEvents

private

Initial value:

{this, "MaximumMappingEvents", 100000,
           "The maximum mapping events to control the output file size"}

Definition at line 264 of file MaterialMapper.h.

          {this, "MaximumMappingEvents", 100000,
           "The maximum mapping events to control the output file size"};

m_processedEvents

unsigned int Trk::MaterialMapper::m_processedEvents = 0

mutableprivate

Definition at line 267 of file MaterialMapper.h.

m_surfaceTreePrefix

Gaudi::Property<std::string> Trk::MaterialMapper::m_surfaceTreePrefix {this, "DetailedSurfaceTreePrefix", "SurfaceMaterial_"}

private

Definition at line 329 of file MaterialMapper.h.

{this, "DetailedSurfaceTreePrefix", "SurfaceMaterial_"};

m_surfaceTrees

std::map< const Trk::Layer*, SurfaceTreeObject* > Trk::MaterialMapper::m_surfaceTrees

mutableprivate

Definition at line 331 of file MaterialMapper.h.

m_surfaceValidation

Gaudi::Property<bool> Trk::MaterialMapper::m_surfaceValidation {this, "DetailedSurfaceValidation", true}

private

Definition at line 327 of file MaterialMapper.h.

{this, "DetailedSurfaceValidation", true};

m_unmappedPathInX0

float Trk::MaterialMapper::m_unmappedPathInX0 {}

mutableprivate

total path in x0 in these events lost

Definition at line 291 of file MaterialMapper.h.

{};                                       

m_validationTree

TTree* Trk::MaterialMapper::m_validationTree = nullptr

private

The validation tree.

Definition at line 270 of file MaterialMapper.h.

m_validationTreeDescription

Gaudi::Property<std::string> Trk::MaterialMapper::m_validationTreeDescription

private

Initial value:

{this, "ValidationTreeDescription", "Material Effects Updator information",
           "validation tree description - second argument in TTree"}

Definition at line 274 of file MaterialMapper.h.

          {this, "ValidationTreeDescription", "Material Effects Updator information",
           "validation tree description - second argument in TTree"};

m_validationTreeFolder

Gaudi::Property<std::string> Trk::MaterialMapper::m_validationTreeFolder

private

Initial value:

{this, "ValidationTreeFolder", "/val/MaterialMapper",
           "stream/folder to for the TTree to be written out"}

Definition at line 277 of file MaterialMapper.h.

          {this, "ValidationTreeFolder", "/val/MaterialMapper",
           "stream/folder to for the TTree to be written out"};

m_validationTreeName

Gaudi::Property<std::string> Trk::MaterialMapper::m_validationTreeName

private

Initial value:

{this, "ValidationTreeName", "MaterialMapper",
           "validation tree name - to be accessed by this from root"}

Definition at line 271 of file MaterialMapper.h.

          {this, "ValidationTreeName", "MaterialMapper",
           "validation tree name - to be accessed by this from root"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_volumeTreePrefix

Gaudi::Property<std::string> Trk::MaterialMapper::m_volumeTreePrefix {this, "TrackingVolumeTreePrefix", "VolumeMaterial"}

private

Definition at line 314 of file MaterialMapper.h.

{this, "TrackingVolumeTreePrefix", "VolumeMaterial"};

m_volumeTrees

std::map< const Trk::TrackingVolume*, VolumeTreeObject* > Trk::MaterialMapper::m_volumeTrees

mutableprivate

Definition at line 316 of file MaterialMapper.h.

m_volumeTreesUnmapped

std::map< const Trk::TrackingVolume*, VolumeTreeObject* > Trk::MaterialMapper::m_volumeTreesUnmapped

mutableprivate

Definition at line 317 of file MaterialMapper.h.

m_volumeValidation

Gaudi::Property<bool> Trk::MaterialMapper::m_volumeValidation {this, "TrackingVolumeValidation", true}

private

Definition at line 312 of file MaterialMapper.h.

{this, "TrackingVolumeValidation", true};

---

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

• MaterialMapper.h
• MaterialMapper.cxx