Trk::DetachedTrackingVolume Class Reference

Base Class for a navigation object (active/passive) in the Tracking realm. More...

#include <DetachedTrackingVolume.h>

Collaboration diagram for Trk::DetachedTrackingVolume:

Public Member Functions
	DetachedTrackingVolume ()
	Default Constructor.
	DetachedTrackingVolume (std::string name, std::unique_ptr< TrackingVolume > vol)
	Constructor with name.
	DetachedTrackingVolume (std::string name, std::unique_ptr< TrackingVolume > vol, std::unique_ptr< Layer > layer, std::unique_ptr< const std::vector< Layer * > > multilayer=nullptr)
	Constructor with name & layer representation.
	~DetachedTrackingVolume ()
	Destructor.
const TrackingVolume *	trackingVolume () const
	returns the TrackingVolume
TrackingVolume *	trackingVolume ()
const std::string &	name () const
	returns the Name
void	move (Amg::Transform3D &shift)
	moving object around
DetachedTrackingVolume *	clone (const std::string &name, Amg::Transform3D &shift) const
	clone with transform
const Layer *	layerRepresentation () const
	returns layer representation
Layer *	layerRepresentation ()
std::span< Layer const *const >	multilayerRepresentation () const
	returns (multi)layer representation
std::span< Layer *const >	multilayerRepresentation ()
void	sign (GeometrySignature signat, GeometryType geotype)
	sign the volume - the geometry builder has to do that
GeometrySignature	geometrySignature () const
	return the Signature
GeometryType	geometryType () const
	return the Type
void	setBaseTransform (std::unique_ptr< Amg::Transform3D > transf=nullptr)
	alignment methods: set base transform / default argument to current transform

Private Member Functions
void	compactify (size_t &cSurfaces, size_t &tSurfaces)
	Compactify – set TG as owner to surfaces.

Private Attributes
std::unique_ptr< TrackingVolume >	m_trkVolume = nullptr
std::unique_ptr< Layer >	m_layerRepresentation = nullptr
std::unique_ptr< const std::vector< Layer * > >	m_multilayerRepresentation = nullptr
const std::string	m_name {"undefined"}
std::unique_ptr< Amg::Transform3D >	m_baseTransform = nullptr

Friends
class	TrackingVolume
	Declare the IDetachedTrackingVolumeBuilder as a friend, to be able to change the volumelink.
class	DetachedTrackingVolumeBuilder
class	IDetachedTrackingVolumeBuilder

Detailed Description

Base Class for a navigation object (active/passive) in the Tracking realm.

Author

Sarka.nosp@m..Tod.nosp@m.orova.nosp@m.@cer.nosp@m.n.ch

Definition at line 37 of file DetachedTrackingVolume.h.

Constructor & Destructor Documentation

DetachedTrackingVolume() [1/3]

Trk::DetachedTrackingVolume::DetachedTrackingVolume

(

)

Default Constructor.

DetachedTrackingVolume() [2/3]

Trk::DetachedTrackingVolume::DetachedTrackingVolume	(	std::string	name,
		std::unique_ptr< TrackingVolume >	vol )

Constructor with name.

Definition at line 17 of file DetachedTrackingVolume.cxx.

  : m_trkVolume(std::move(volume))
  , m_name(std::move(name))
{}

DetachedTrackingVolume() [3/3]

Trk::DetachedTrackingVolume::DetachedTrackingVolume	(	std::string	name,
		std::unique_ptr< TrackingVolume >	vol,
		std::unique_ptr< Layer >	layer,
		std::unique_ptr< const std::vector< Layer * > >	multilayer = nullptr )

Constructor with name & layer representation.

Definition at line 23 of file DetachedTrackingVolume.cxx.

  : m_trkVolume(std::move(volume))
  , m_layerRepresentation(std::move(lay))
  , m_multilayerRepresentation(std::move(multilay))
  , m_name(std::move(name))
  , m_baseTransform(nullptr)
{}

~DetachedTrackingVolume()

Trk::DetachedTrackingVolume::~DetachedTrackingVolume

(

)

Destructor.

Definition at line 35 of file DetachedTrackingVolume.cxx.

                                                   {
  //These we have to delete manually
  if (m_multilayerRepresentation) {
    for (auto *layer : *m_multilayerRepresentation)
      delete layer;
  }
}

Member Function Documentation

clone()

Trk::DetachedTrackingVolume * Trk::DetachedTrackingVolume::clone	(	const std::string &	name,
		Amg::Transform3D &	shift ) const

clone with transform

Definition at line 58 of file DetachedTrackingVolume.cxx.

{
  auto newTV = std::make_unique<TrackingVolume>(*(this->trackingVolume()), shift);
  TrackingVolumeArray* confinedVolumes = newTV->confinedVolumes();
  LayerArray* confinedLayers= newTV->confinedLayers();
  Trk::ArraySpan<Trk::Layer* const> confinedArbitraryLayers = newTV->confinedArbitraryLayers();
  //
  Trk::DetachedTrackingVolume* newStat = nullptr;
  // layer representation ?
  std::unique_ptr<Trk::PlaneLayer> newLay = nullptr;
  if (this->layerRepresentation()) {
    std::unique_ptr<std::vector<Trk::Layer*>> newMulti = nullptr;
    const Trk::PlaneLayer* pl = dynamic_cast<const Trk::PlaneLayer*>(this->layerRepresentation());
    if (pl) {
      newLay = std::make_unique<Trk::PlaneLayer>(*pl);
      newLay->moveLayer(shift);
      if (!this->multilayerRepresentation().empty()) {
        newMulti = std::make_unique<std::vector<Trk::Layer*>>();
        for (unsigned int i = 0; i < this->multilayerRepresentation().size(); i++) {
          const Trk::PlaneLayer* mpl = dynamic_cast<const Trk::PlaneLayer*>((this->multilayerRepresentation())[i]);
          if (mpl) {
            Trk::PlaneLayer* newPl = new Trk::PlaneLayer(*mpl);
            newPl->moveLayer(shift);
            newMulti->push_back(newPl);
          } else
            std::cout << "WARNING   Trk::DetachedTrackingVolume::clone()   "
                         "dynamic cast to 'const Trk::PlaneLayer* mpl' failed!"
                      << std::endl;
        }
      }
      newStat = new Trk::DetachedTrackingVolume(name, std::move(newTV), std::move(newLay), std::move(newMulti));
    } else {
      std::cout << "WARNING   Trk::DetachedTrackingVolume::clone()   dynamic "
                   "cast to 'const Trk::PlaneLayer* pl' failed!"
                << std::endl;
      newStat = new Trk::DetachedTrackingVolume(name, std::move(newTV));
    }
  } else {
    newStat = new Trk::DetachedTrackingVolume(name, std::move(newTV));
  }
  //
  // enclose layers
  if (confinedVolumes) {
    std::span<Trk::TrackingVolume * const> vols = confinedVolumes->arrayObjects();
    for (auto *vol : vols) {
      Trk::LayerArray* layAr = vol->confinedLayers();
      Trk::ArraySpan<Trk::Layer* const> alays = vol->confinedArbitraryLayers();
      if (layAr) {
        std::span<Trk::Layer* const> lays = layAr->arrayObjects();
        for (auto *lay : lays) {
          lay->encloseDetachedTrackingVolume(*newStat);
        }
      }
      if (!alays.empty()) {
        for (auto *alay : alays) {
          alay->encloseDetachedTrackingVolume(*newStat);
        }
      }
    }
  }
  if (confinedLayers) {
    std::span<Trk::Layer* const> lays = confinedLayers->arrayObjects();
    for (auto *lay : lays){
      lay->encloseDetachedTrackingVolume(*newStat);
    }
  }
  if (!confinedArbitraryLayers.empty()) {
    for (auto *alay : confinedArbitraryLayers) {
      alay->encloseDetachedTrackingVolume(*newStat);
    }
  }
  return newStat;
}

compactify()

void Trk::DetachedTrackingVolume::compactify ( size_t & cSurfaces, size_t & tSurfaces )

private

Compactify – set TG as owner to surfaces.

Definition at line 134 of file DetachedTrackingVolume.cxx.

{
  // deal with the Tracking Volume representation
  if (m_trkVolume){
    m_trkVolume->compactify(cSurfaces, tSurfaces);
  }
 
  // deal with the layer representation
  if (layerRepresentation()) {
    ++tSurfaces;
    if (layerRepresentation()->surfaceRepresentation().owner() == Trk::noOwn) {
      layerRepresentation()->surfaceRepresentation().setOwner(Trk::TGOwn);
      ++cSurfaces;
    }
  }
  // deal with the multi-layer representation
  if (!multilayerRepresentation().empty()) {
    tSurfaces += m_multilayerRepresentation->size();
    for (const auto& mLayerIter : (*m_multilayerRepresentation)) {
      if ((*mLayerIter).surfaceRepresentation().owner() == Trk::noOwn) {
        (*mLayerIter).surfaceRepresentation().setOwner(Trk::TGOwn);
        ++cSurfaces;
      }
    }
  }
}

geometrySignature()

Trk::GeometrySignature Trk::DetachedTrackingVolume::geometrySignature

(

)

const

return the Signature

Definition at line 168 of file DetachedTrackingVolume.cxx.

                                                                        {
  return m_trkVolume->geometrySignature();
}

geometryType()

Trk::GeometryType Trk::DetachedTrackingVolume::geometryType

(

)

const

return the Type

Definition at line 172 of file DetachedTrackingVolume.cxx.

                                                              {
  return m_trkVolume->geometryType();
}

layerRepresentation() [1/2]

Layer * Trk::DetachedTrackingVolume::layerRepresentation ( )

inline

Definition at line 121 of file DetachedTrackingVolume.h.

                                                          {
  return m_layerRepresentation.get();
}

layerRepresentation() [2/2]

const Layer * Trk::DetachedTrackingVolume::layerRepresentation ( ) const

inline

returns layer representation

Definition at line 117 of file DetachedTrackingVolume.h.

                                                                      {
  return m_layerRepresentation.get();
}

move()

void Trk::DetachedTrackingVolume::move

(

Amg::Transform3D &

shift

)

moving object around

Definition at line 44 of file DetachedTrackingVolume.cxx.

{
  m_trkVolume->moveTV(shift);
  if (m_layerRepresentation) {
    m_layerRepresentation->moveLayer(shift);
  }
  if (m_multilayerRepresentation) {
    for (auto* layer : *m_multilayerRepresentation) {
      layer->moveLayer(shift);
    }
  }
}

multilayerRepresentation() [1/2]

std::span< Layer *const > Trk::DetachedTrackingVolume::multilayerRepresentation ( )

inline

Definition at line 137 of file DetachedTrackingVolume.h.

{
  if (m_multilayerRepresentation) {
    return std::span<Layer* const>(m_multilayerRepresentation->begin(),
                                   m_multilayerRepresentation->end());
  }
  return {};
}

multilayerRepresentation() [2/2]

std::span< Layer const *const > Trk::DetachedTrackingVolume::multilayerRepresentation ( ) const

inline

returns (multi)layer representation

Definition at line 127 of file DetachedTrackingVolume.h.

{
  if (m_multilayerRepresentation) {
    return std::span<Layer const* const>(m_multilayerRepresentation->begin(),
                                         m_multilayerRepresentation->end());
  }
  return {};
}

name()

const std::string & Trk::DetachedTrackingVolume::name ( ) const

inline

returns the Name

Definition at line 115 of file DetachedTrackingVolume.h.

{ return (m_name); }

setBaseTransform()

void Trk::DetachedTrackingVolume::setBaseTransform

(

std::unique_ptr< Amg::Transform3D >

transf = nullptr

)

alignment methods: set base transform / default argument to current transform

Definition at line 176 of file DetachedTrackingVolume.cxx.

                                                                                     {
  if (transf){
    m_baseTransform = std::move(transf);
  }
  else {
    m_baseTransform = std::make_unique<Amg::Transform3D>(this->trackingVolume()->transform());
  }
}

sign()

void Trk::DetachedTrackingVolume::sign	(	GeometrySignature	signat,
		GeometryType	geotype )

sign the volume - the geometry builder has to do that

Definition at line 162 of file DetachedTrackingVolume.cxx.

{
  m_trkVolume->sign(signat, geotype);
}

trackingVolume() [1/2]

TrackingVolume * Trk::DetachedTrackingVolume::trackingVolume ( )

inline

Definition at line 111 of file DetachedTrackingVolume.h.

                                                             {
  return m_trkVolume.get();
}

trackingVolume() [2/2]

const TrackingVolume * Trk::DetachedTrackingVolume::trackingVolume ( ) const

inline

returns the TrackingVolume

Definition at line 107 of file DetachedTrackingVolume.h.

                                                                          {
  return m_trkVolume.get();
}

Friends And Related Symbol Documentation

DetachedTrackingVolumeBuilder

friend class DetachedTrackingVolumeBuilder

friend

Definition at line 41 of file DetachedTrackingVolume.h.

IDetachedTrackingVolumeBuilder

friend class IDetachedTrackingVolumeBuilder

friend

Definition at line 42 of file DetachedTrackingVolume.h.

TrackingVolume

friend class TrackingVolume

friend

Declare the IDetachedTrackingVolumeBuilder as a friend, to be able to change the volumelink.

Definition at line 40 of file DetachedTrackingVolume.h.

Member Data Documentation

m_baseTransform

std::unique_ptr<Amg::Transform3D> Trk::DetachedTrackingVolume::m_baseTransform = nullptr

private

Definition at line 104 of file DetachedTrackingVolume.h.

m_layerRepresentation

std::unique_ptr<Layer> Trk::DetachedTrackingVolume::m_layerRepresentation = nullptr

private

Definition at line 99 of file DetachedTrackingVolume.h.

m_multilayerRepresentation

std::unique_ptr<const std::vector<Layer*> > Trk::DetachedTrackingVolume::m_multilayerRepresentation = nullptr

private

Definition at line 101 of file DetachedTrackingVolume.h.

m_name

const std::string Trk::DetachedTrackingVolume::m_name {"undefined"}

private

Definition at line 102 of file DetachedTrackingVolume.h.

{"undefined"};

m_trkVolume

std::unique_ptr<TrackingVolume> Trk::DetachedTrackingVolume::m_trkVolume = nullptr

private

Definition at line 98 of file DetachedTrackingVolume.h.

---

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

• DetachedTrackingVolume.h
• DetachedTrackingVolume.cxx