Trk::TrackingGeometry Class Reference

The TrackingGeometry class is the owner of the constructed TrackingVolumes. More...

#include <TrackingGeometry.h>

Collaboration diagram for Trk::TrackingGeometry:

Public Member Functions
	TrackingGeometry (TrackingVolume *highestVolume, NavigationLevel navlevel=globalSearch)
	Constructor.
virtual	~TrackingGeometry ()
	Destructor.
const TrackingVolume *	highestTrackingVolume () const
	return the world
TrackingVolume *	highestTrackingVolume ()
const TrackingVolume *	lowestTrackingVolume (const Amg::Vector3D &gp) const
	return the lowest tracking Volume
std::vector< const Trk::DetachedTrackingVolume * >	lowestDetachedTrackingVolumes (const Amg::Vector3D &gp) const
	return the vector of lowest detached tracking Volume(->overlaps)
const TrackingVolume *	lowestStaticTrackingVolume (const Amg::Vector3D &gp) const
	return the lowest static tracking Volume
const TrackingVolume *	trackingVolume (const std::string &name) const
	return the tracking Volume by name, 0 if it doesn't exist
const Layer *	associatedLayer (const Amg::Vector3D &gp) const
	Forward the associated Layer information.
const Layer *	nextLayer (const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool skipNavLayer=false) const
	Forward the next Layer information.
template<class T>
LayerIntersection< Amg::Vector3D >	closestMaterialLayer (const T &pars, PropDirection pDir=Trk::alongMomentum, const BoundaryCheck &bchk=true) const
	Closest Material Layer - used for the mapping option.
const std::map< Layer *, int > &	boundaryLayers ()
	Return the unique BoundarySurfaces with MaterialInformation.
auto	boundaryLayers () const
size_t	numBoundaryLayers () const
NavigationLevel	navigationLevel () const
	Return the Navigation Level - only one TrackingGeometry can have full association to GeoModel.
void	printVolumeHierarchy (MsgStream &msgstream) const
	Print the summary of volume Hierarchy of the TrackingGeometry.
void	indexStaticLayers (GeometrySignature geosit, int offset=0)
	indexLayers : method to re-set the index of the layers, depending on geometrySignature
void	dump (MsgStream &out, const std::string &head) const
void	addToGarbage (std::vector< std::unique_ptr< Trk::DetachedTrackingVolume > > &&garbageVec)
void	addToGarbage (std::vector< std::unique_ptr< Trk::TrackingVolume > > &&garbageVec)

Static Public Member Functions
static bool	atVolumeBoundary (const Amg::Vector3D &gp, const TrackingVolume *vol, double tol)
	check position at volume boundary
static bool	atVolumeBoundary (const Amg::Vector3D &gp, const Amg::Vector3D &mom, const TrackingVolume *vol, const TrackingVolume *&nextVol, Trk::PropDirection dir, double tol)
	check position at volume boundary + navigation link

Private Member Functions
void	sign (GeometrySignature geosit, GeometryType geotype=Static)
	Geometry Builder busineess: the geometry builder has to sign.
void	compactify (MsgStream &msgstream, TrackingVolume *vol=nullptr)
	Geometry Builder busineess: set all contained surfaces TG owned - this should save memory and avoid surface copying.
void	synchronizeLayers (MsgStream &msgstream, TrackingVolume *vol=nullptr)
	Geometry Builder business: synchronize all layers to enclosed volume dimensions.
void	registerNavigationLevel (NavigationLevel navlevel)
	private method the Navigation Level
void	registerTrackingVolumes (TrackingVolume &tvol, TrackingVolume *mvol=nullptr, int lvl=0)
	private method to register recursively the tracking volumes
TrackingVolume *	checkoutHighestTrackingVolume ()
	private method to be called from GeometryBuilder: return the world with ownership
void	printVolumeInformation (MsgStream &msgstream, const TrackingVolume &tvol, int lvl) const
	print VolumeInformation with Level

Static Private Member Functions
static void	dumpLayer (MsgStream &out, const std::string &head, const Layer *layer)

Private Attributes
TrackingVolume *	m_world {}
	The known world - and the beam.
std::map< Layer *, int >	m_boundaryLayers
	The unique boundary Layers.
std::map< const std::string, const TrackingVolume * >	m_trackingVolumes
	The Volumes in a map for later finding.
NavigationLevel	m_navigationLevel
	The Navigation level for identification.
std::vector< std::unique_ptr< DetachedTrackingVolume > >	m_detachedVolGarbage {}
	In some cases the Tracking Geometry needs to keep certain objectss alive delete them at the end of its lifetime.
std::vector< std::unique_ptr< TrackingVolume > >	m_trkVolumeGarbage {}

Friends
class	GeometryBuilder
	Give the GeometryBuilder friend rights.
class	GeometryBuilderCond

Detailed Description

The TrackingGeometry class is the owner of the constructed TrackingVolumes.

It enables both, a global search for an asociatedVolume (respectively, if existing, a global search of an associated Layer or the next associated Layer), such as a continous navigation by BoundarySurfaces between the confined TrackingVolumes.

Author

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

Christos Anastopoulos (Athena MT modifications)

Definition at line 65 of file TrackingGeometry.h.

Constructor & Destructor Documentation

TrackingGeometry()

Trk::TrackingGeometry::TrackingGeometry	(	TrackingVolume *	highestVolume,
		NavigationLevel	navlevel = globalSearch )

Constructor.

Definition at line 24 of file TrackingGeometry.cxx.

                                                               :
   m_world(highestVolume),
  m_navigationLevel(navLev) {
  // for the time being only world
  if (!m_world) return;
  registerTrackingVolumes(*m_world);
}

~TrackingGeometry()

Trk::TrackingGeometry::~TrackingGeometry ( )

virtual

Destructor.

Definition at line 33 of file TrackingGeometry.cxx.

                                       {
    if (m_world) delete m_world;
}

Member Function Documentation

addToGarbage() [1/2]

void Trk::TrackingGeometry::addToGarbage

(

std::vector< std::unique_ptr< Trk::DetachedTrackingVolume > > &&

garbageVec

)

Definition at line 36 of file TrackingGeometry.cxx.

                                                                                                    {
  m_detachedVolGarbage.insert(m_detachedVolGarbage.end(),
                              std::make_move_iterator(garbageVec.begin()),
                              std::make_move_iterator(garbageVec.end()));
}

addToGarbage() [2/2]

void Trk::TrackingGeometry::addToGarbage

(

std::vector< std::unique_ptr< Trk::TrackingVolume > > &&

garbageVec

)

Definition at line 41 of file TrackingGeometry.cxx.

                                                                                           {
  m_trkVolumeGarbage.insert(m_trkVolumeGarbage.end(),
                            std::make_move_iterator(garbageVec.begin()),
                            std::make_move_iterator(garbageVec.end()));
}

associatedLayer()

const Layer * Trk::TrackingGeometry::associatedLayer

(

const Amg::Vector3D &

gp

)

const

Forward the associated Layer information.

atVolumeBoundary() [1/2]

bool Trk::TrackingGeometry::atVolumeBoundary ( const Amg::Vector3D & gp, const Amg::Vector3D & mom, const TrackingVolume * vol, const TrackingVolume *& nextVol, Trk::PropDirection dir, double tol )

static

check position at volume boundary + navigation link

Definition at line 264 of file TrackingGeometry.cxx.

{
  bool isAtBoundary = false;
  nextVol = nullptr;
  if (!vol)
    return isAtBoundary;
  const auto& bounds = vol->boundarySurfaces();
  for (size_t ib = 0; ib < bounds.size(); ++ib) {
    const Trk::Surface& surf = bounds[ib]->surfaceRepresentation();
    if (surf.isOnSurface(gp, true, tol, tol)) {
      isAtBoundary = true;
      const Trk::TrackingVolume* attachedVol =
        bounds[ib]->attachedVolume(gp, mom, dir);
      if (!nextVol && attachedVol)
        nextVol = attachedVol;
    }
  }
  return isAtBoundary;
}

atVolumeBoundary() [2/2]

bool Trk::TrackingGeometry::atVolumeBoundary ( const Amg::Vector3D & gp, const TrackingVolume * vol, double tol )

static

check position at volume boundary

Definition at line 246 of file TrackingGeometry.cxx.

{
  bool isAtBoundary = false;
  if (!vol)
    return isAtBoundary;
  const auto& bounds = vol->boundarySurfaces();
  for (size_t ib = 0; ib < bounds.size(); ++ib) {
    const Trk::Surface& surf = bounds[ib]->surfaceRepresentation();
    if (surf.isOnSurface(gp, true, tol, tol))
      isAtBoundary = true;
  }
  return isAtBoundary;
}

boundaryLayers() [1/2]

const std::map< Layer *, int > & Trk::TrackingGeometry::boundaryLayers

(

)

Return the unique BoundarySurfaces with MaterialInformation.

boundaryLayers() [2/2]

auto Trk::TrackingGeometry::boundaryLayers

(

)

const

checkoutHighestTrackingVolume()

Trk::TrackingVolume * Trk::TrackingGeometry::checkoutHighestTrackingVolume ( )

private

private method to be called from GeometryBuilder: return the world with ownership

Definition at line 165 of file TrackingGeometry.cxx.

                                                   {
  Trk::TrackingVolume* checkoutVolume{nullptr};
  std::swap(m_world, checkoutVolume);
  // clear the boundary layers they go with the highest volume
  m_boundaryLayers.clear();
  return checkoutVolume;
}

closestMaterialLayer()

template<class T>

LayerIntersection< Amg::Vector3D > Trk::TrackingGeometry::closestMaterialLayer	(	const T &	pars,
		PropDirection	pDir = Trk::alongMomentum,
		const BoundaryCheck &	bchk = true ) const

Closest Material Layer - used for the mapping option.

compactify()

void Trk::TrackingGeometry::compactify ( MsgStream & msgstream, TrackingVolume * vol = nullptr )

private

Geometry Builder busineess: set all contained surfaces TG owned - this should save memory and avoid surface copying.

• prints compactification statistics

Definition at line 137 of file TrackingGeometry.cxx.

{
  msg << MSG::VERBOSE
      << "====== Calling TrackingGeometry::compactify() ===== " << std::endl;
  Trk::TrackingVolume* tVolume = vol ? vol : highestTrackingVolume();
  size_t cSurfaces = 0;
  size_t tSurfaces = 0;
  if (tVolume) {
    tVolume->compactify(cSurfaces, tSurfaces);
  }
  msg << MSG::VERBOSE << "  --> set TG ownership of " << cSurfaces << " out of "
      << tSurfaces << std::endl;
  for (const auto& bLayerIter : m_boundaryLayers) {
    bLayerIter.first->surfaceRepresentation().setOwner(Trk::TGOwn);
  }
  msg << MSG::VERBOSE << "  --> set TG ownership of " << m_boundaryLayers.size()
      << " boundary layers." << std::endl;
  msg << MSG::VERBOSE << endmsg;
}

dump()

void Trk::TrackingGeometry::dump	(	MsgStream &	out,
		const std::string &	head ) const

Definition at line 290 of file TrackingGeometry.cxx.

{
  out << MSG::ALWAYS;
  for (const auto& bound_layers : m_boundaryLayers) {
    out << head << " [" << bound_layers.second << "] ";
    dumpLayer(out, "", bound_layers.first);
  }
  int counter = 0;
  for (const std::pair<const std::string, const TrackingVolume*>& volume : m_trackingVolumes) {
    out << head << " [" << counter++ << "] " << volume.first << " volumeBound=";
    volume.second->volumeBounds().dump(out);
    out << std::endl;
    Trk::ArraySpan<const Trk::Layer* const> confArbLayers =
      volume.second->confinedArbitraryLayers();
    if (!confArbLayers.empty()) {
      int j = 0;
      for (const Layer* confined_layer : confArbLayers) {
        out << head << " [" << counter++ << "] " << volume.first
            << " confinedArbitrary layer " << j++ << " ";
        dumpLayer(out, "", confined_layer);
      }
    }
    if (volume.second->confinedLayers()) {
      int j = 0;
      for (const Layer* confined_layer :
           volume.second->confinedLayers()->arrayObjects()) {
        out << head << " [" << counter++ << "] " << volume.first
            << " confined layer" << j++ << " ";
        dumpLayer(out, "", confined_layer);
      }
    }
  }
  out << endmsg;
}

dumpLayer()

void Trk::TrackingGeometry::dumpLayer ( MsgStream & out, const std::string & head, const Layer * layer )

staticprivate

Definition at line 325 of file TrackingGeometry.cxx.

{
  if (!layer) {
    return;
  }
  out << head << layer->layerIndex().value() << " [t=" << layer->layerType()
      << "] d=" << layer->thickness();
  out << layer->surfaceRepresentation();
  out << std::endl;
}

highestTrackingVolume() [1/2]

TrackingVolume * Trk::TrackingGeometry::highestTrackingVolume

(

)

highestTrackingVolume() [2/2]

const TrackingVolume * Trk::TrackingGeometry::highestTrackingVolume

(

)

const

return the world

indexStaticLayers()

void Trk::TrackingGeometry::indexStaticLayers	(	GeometrySignature	geosit,
		int	offset = 0 )

indexLayers : method to re-set the index of the layers, depending on geometrySignature

Definition at line 237 of file TrackingGeometry.cxx.

{
  if (m_world) {
    m_world->indexContainedStaticLayers(geosit, offset);
    m_world->indexContainedMaterialLayers(geosit, offset);
  }
}

lowestDetachedTrackingVolumes()

std::vector< const Trk::DetachedTrackingVolume * > Trk::TrackingGeometry::lowestDetachedTrackingVolumes

(

const Amg::Vector3D &

gp

)

const

return the vector of lowest detached tracking Volume(->overlaps)

Definition at line 60 of file TrackingGeometry.cxx.

{
  double tol = 0.001;
  const Trk::TrackingVolume* currentVolume = lowestStaticTrackingVolume(gp);
  if (currentVolume){
    return currentVolume->assocDetachedSubVolumes(gp, tol);
  }
  return {};
}

lowestStaticTrackingVolume()

const Trk::TrackingVolume * Trk::TrackingGeometry::lowestStaticTrackingVolume

(

const Amg::Vector3D &

gp

)

const

return the lowest static tracking Volume

Definition at line 72 of file TrackingGeometry.cxx.

{
  const Trk::TrackingVolume* searchVolume = highestTrackingVolume();
  const Trk::TrackingVolume* currentVolume = nullptr;
  while (currentVolume != searchVolume && searchVolume) {
    currentVolume = searchVolume;
    if (searchVolume->confinedDetachedVolumes().empty())
      searchVolume = searchVolume->associatedSubVolume(gp);
  }
  return (currentVolume);
}

lowestTrackingVolume()

const Trk::TrackingVolume * Trk::TrackingGeometry::lowestTrackingVolume

(

const Amg::Vector3D &

gp

)

const

return the lowest tracking Volume

Definition at line 48 of file TrackingGeometry.cxx.

{
  const Trk::TrackingVolume* searchVolume = highestTrackingVolume();
  const Trk::TrackingVolume* currentVolume = nullptr;
  while (currentVolume != searchVolume && searchVolume) {
    currentVolume = searchVolume;
    searchVolume = searchVolume->associatedSubVolume(gp);
  }
  return (currentVolume);
}

navigationLevel()

NavigationLevel Trk::TrackingGeometry::navigationLevel

(

)

const

Return the Navigation Level - only one TrackingGeometry can have full association to GeoModel.

nextLayer()

const Layer * Trk::TrackingGeometry::nextLayer	(	const Amg::Vector3D &	gp,
		const Amg::Vector3D &	mom,
		bool	skipNavLayer = false ) const

Forward the next Layer information.

numBoundaryLayers()

size_t Trk::TrackingGeometry::numBoundaryLayers

(

)

const

printVolumeHierarchy()

void Trk::TrackingGeometry::printVolumeHierarchy

(

MsgStream &

msgstream

)

const

Print the summary of volume Hierarchy of the TrackingGeometry.

Definition at line 174 of file TrackingGeometry.cxx.

{
  msg << "TrackingGeometry Summary : " << std::endl;
  const Trk::TrackingVolume* highestVolume = highestTrackingVolume();
  int level = 0;
  if (highestVolume)
    printVolumeInformation(msg, *highestVolume, level);
  msg << endmsg;
}

printVolumeInformation()

void Trk::TrackingGeometry::printVolumeInformation ( MsgStream & msgstream, const TrackingVolume & tvol, int lvl ) const

private

print VolumeInformation with Level

Definition at line 185 of file TrackingGeometry.cxx.

{
  int sublevel = lvl + 1;
 
  for (int indent = 0; indent < sublevel; ++indent)
    msg << "  ";
  msg << "TrackingVolume ( at : " << (&tvol) << ") name: " << tvol.volumeName()
      << std::endl;
 
  const Trk::BinnedArray<Trk::Layer>* confinedLayers = tvol.confinedLayers();
  if (confinedLayers) {
    std::span<Trk::Layer const* const> layers =
      confinedLayers->arrayObjects();
    for (int indent = 0; indent < sublevel; ++indent)
      msg << "  ";
    msg << "- found : " << layers.size() << " confined Layers" << std::endl;
  }
 
  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)
      msg << "  ";
    msg << "- found : " << volumes.size() << " confined TrackingVolumes"
        << std::endl;
 
    for (const auto& volumesIter : volumes)
      if (volumesIter)
        printVolumeInformation(msg, *volumesIter, sublevel);
  }
 
  Trk::ArraySpan<const Trk::TrackingVolume* const> confinedDenseVolumes =
    tvol.confinedDenseVolumes();
  if (!confinedDenseVolumes.empty()) {
    for (int indent = 0; indent < sublevel; ++indent) {
      msg << "  ";
    }
    msg << "- found : " << confinedDenseVolumes.size()
        << " confined unordered (dense) TrackingVolumes" << std::endl;
 
    for (const auto& volumesIter : (confinedDenseVolumes))
      if (volumesIter) {
        printVolumeInformation(msg, *volumesIter, sublevel);
      }
  }
}

registerNavigationLevel()

void Trk::TrackingGeometry::registerNavigationLevel ( NavigationLevel navlevel )

private

private method the Navigation Level

registerTrackingVolumes()

void Trk::TrackingGeometry::registerTrackingVolumes ( Trk::TrackingVolume & tvol, Trk::TrackingVolume * mvol = nullptr, int lvl = 0 )

private

private method to register recursively the tracking volumes

should detached tracking volumes be part of the tracking geometry ?

register the boundary layers

Definition at line 85 of file TrackingGeometry.cxx.

{
  int sublvl = lvl + 1;
  std::string indent = "";
  for (int l = 0; l < lvl; ++l){
    indent += "  ";
  }
 
  tvol.setMotherVolume(mvol);
  m_trackingVolumes[tvol.volumeName()] = (&tvol);
  Trk::BinnedArray<Trk::TrackingVolume>* confinedVolumes = tvol.confinedVolumes();
  if (confinedVolumes) {
    std::span<Trk::TrackingVolume* const> volumes = confinedVolumes->arrayObjects();
    for (const auto& volumesIter : volumes){
      if (volumesIter){
        registerTrackingVolumes(*volumesIter, &tvol, sublvl);
      }
    }
  }
 
  Trk::ArraySpan<Trk::TrackingVolume* const> confinedDenseVolumes = tvol.confinedDenseVolumes();
  if (!confinedDenseVolumes.empty()) {
    for (const auto& volumesIter : confinedDenseVolumes){
      if (volumesIter){
        registerTrackingVolumes(*volumesIter, &tvol, sublvl);
      }
    }
  }
  Trk::ArraySpan<Trk::DetachedTrackingVolume* const> confinedDetachedVolumes = tvol.confinedDetachedVolumes();
  if (!confinedDetachedVolumes.empty()) {
    for (const auto& volumesIter : confinedDetachedVolumes){
      if (volumesIter &&
          tvol.inside(volumesIter->trackingVolume()->center(), 0.)){
        registerTrackingVolumes( *(volumesIter->trackingVolume()), &tvol, sublvl);
      }
    }
  }
  // boundary layers
  const auto& bounds = tvol.boundarySurfaces();
  for (const auto & bound : bounds) {
    Trk::MaterialLayer* bLayer = bound->surfaceRepresentation().materialLayer();
    if (bLayer) {
      int& layerCount{m_boundaryLayers[bLayer]};
      ++layerCount;
    }
  }
}

sign()

void Trk::TrackingGeometry::sign ( GeometrySignature geosit, GeometryType geotype = Static )

private

Geometry Builder busineess: the geometry builder has to sign.

synchronizeLayers()

void Trk::TrackingGeometry::synchronizeLayers ( MsgStream & msgstream, TrackingVolume * vol = nullptr )

private

Geometry Builder business: synchronize all layers to enclosed volume dimensions.

Definition at line 158 of file TrackingGeometry.cxx.

{
  Trk::TrackingVolume* tVolume = vol ? vol : highestTrackingVolume();
  tVolume->synchronizeLayers(msg);
}

trackingVolume()

const TrackingVolume * Trk::TrackingGeometry::trackingVolume

(

const std::string &

name

)

const

return the tracking Volume by name, 0 if it doesn't exist

Friends And Related Symbol Documentation

GeometryBuilder

friend class GeometryBuilder

friend

Give the GeometryBuilder friend rights.

Definition at line 69 of file TrackingGeometry.h.

GeometryBuilderCond

friend class GeometryBuilderCond

friend

Definition at line 71 of file TrackingGeometry.h.

Member Data Documentation

m_boundaryLayers

std::map<Layer*, int> Trk::TrackingGeometry::m_boundaryLayers

private

The unique boundary Layers.

Definition at line 189 of file TrackingGeometry.h.

m_detachedVolGarbage

std::vector<std::unique_ptr<DetachedTrackingVolume> > Trk::TrackingGeometry::m_detachedVolGarbage {}

private

In some cases the Tracking Geometry needs to keep certain objectss alive delete them at the end of its lifetime.

This should typically happen for objects that can be referenced but are not owned by any other object

Definition at line 203 of file TrackingGeometry.h.

{};

m_navigationLevel

NavigationLevel Trk::TrackingGeometry::m_navigationLevel

private

The Navigation level for identification.

Definition at line 195 of file TrackingGeometry.h.

m_trackingVolumes

std::map<const std::string, const TrackingVolume*> Trk::TrackingGeometry::m_trackingVolumes

private

The Volumes in a map for later finding.

Definition at line 192 of file TrackingGeometry.h.

m_trkVolumeGarbage

std::vector<std::unique_ptr<TrackingVolume> > Trk::TrackingGeometry::m_trkVolumeGarbage {}

private

Definition at line 204 of file TrackingGeometry.h.

{};

m_world

TrackingVolume* Trk::TrackingGeometry::m_world {}

private

The known world - and the beam.

Definition at line 186 of file TrackingGeometry.h.

{};

---

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

• TrackingGeometry.h
• TrackingGeometry.cxx