Trk::CombinedVolumeBounds Class Reference

Bounds for a generic combined volume, the decomposeToSurfaces method creates a vector of n surfaces (n1+n2-nshared): More...

#include <CombinedVolumeBounds.h>

Inheritance diagram for Trk::CombinedVolumeBounds:

Collaboration diagram for Trk::CombinedVolumeBounds:

Public Member Functions
	CombinedVolumeBounds ()
	Default Constructor.
	CombinedVolumeBounds (std::unique_ptr< Volume > first, std::unique_ptr< Volume > second, bool intersection)
	Constructor - the box boundaries.
	CombinedVolumeBounds (const CombinedVolumeBounds &bobo)
	Copy Constructor.
virtual	~CombinedVolumeBounds ()
	Destructor.
CombinedVolumeBounds &	operator= (const CombinedVolumeBounds &bobo)
	Assignment operator.
virtual CombinedVolumeBounds *	clone () const override final
	Virtual constructor.
virtual bool	inside (const Amg::Vector3D &, double tol=0.) const override final
	This method checks if position in the 3D volume frame is inside the volume.
virtual std::vector< std::unique_ptr< Trk::Surface > >	decomposeToSurfaces (const Amg::Transform3D &transform) override final
	Method to decompose the Bounds into boundarySurfaces.
virtual ObjectAccessor	boundarySurfaceAccessor (const Amg::Vector3D &gp, const Amg::Vector3D &dir, bool forceInside=false) const override final
	Provide accessor for BoundarySurfaces.
const Volume *	first () const
	This method returns the first VolumeBounds.
const Volume *	second () const
	This method returns the second VolumeBounds.
bool	intersection () const
	This method distinguishes between Union(0) and Intersection(1).
const std::vector< bool > &	boundsOrientation () const
	This method returns bounds orientation.
virtual MsgStream &	dump (MsgStream &sl) const override final
	Output Method for MsgStream.
virtual std::ostream &	dump (std::ostream &sl) const override final
	Output Method for std::ostream.

Static Private Member Functions
static Trk::Volume *	createSubtractedVolume (const Amg::Transform3D &transf, const Trk::Volume *subtrVol)

Private Attributes
std::unique_ptr< Volume >	m_first {}
std::unique_ptr< Volume >	m_second {}
bool	m_intersection {}
EightObjectsAccessor	m_objectAccessor {}
std::vector< bool >	m_boundsOrientation {}

Detailed Description

Bounds for a generic combined volume, the decomposeToSurfaces method creates a vector of n surfaces (n1+n2-nshared):

BoundarySurfaceFace [index]: [n1+n2-nshared] combined surfaces

designed to allow transcript of GeoShapeUnion and GeoShapeIntersection

Author

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

Christos Anastopoulos (Athena MT modifications)

Definition at line 44 of file CombinedVolumeBounds.h.

Constructor & Destructor Documentation

CombinedVolumeBounds() [1/3]

Trk::CombinedVolumeBounds::CombinedVolumeBounds ( )

default

Default Constructor.

CombinedVolumeBounds() [2/3]

Trk::CombinedVolumeBounds::CombinedVolumeBounds	(	std::unique_ptr< Volume >	first,
		std::unique_ptr< Volume >	second,
		bool	intersection )

Constructor - the box boundaries.

Definition at line 36 of file CombinedVolumeBounds.cxx.

  : VolumeBounds()
  , m_first(std::move(vol1))
  , m_second(std::move(vol2))
  , m_intersection(intersection)
  , m_objectAccessor()
  , m_boundsOrientation()
{}

CombinedVolumeBounds() [3/3]

Trk::CombinedVolumeBounds::CombinedVolumeBounds

(

const CombinedVolumeBounds &

bobo

)

Copy Constructor.

Definition at line 48 of file CombinedVolumeBounds.cxx.

  : VolumeBounds()
  , m_first{bobo.m_first->clone()}
  , m_second{bobo.m_second->clone()}
  , m_intersection(bobo.m_intersection)
  , m_objectAccessor(bobo.m_objectAccessor)
  , m_boundsOrientation(bobo.m_boundsOrientation)
{}

~CombinedVolumeBounds()

Trk::CombinedVolumeBounds::~CombinedVolumeBounds ( )

virtualdefault

Destructor.

Member Function Documentation

boundarySurfaceAccessor()

ObjectAccessor Trk::CombinedVolumeBounds::boundarySurfaceAccessor ( const Amg::Vector3D & gp, const Amg::Vector3D & dir, bool forceInside = false ) const

inlinefinaloverridevirtual

Provide accessor for BoundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 131 of file CombinedVolumeBounds.h.

                                                        {
  return Trk::ObjectAccessor(m_objectAccessor);
}

boundsOrientation()

const std::vector< bool > & Trk::CombinedVolumeBounds::boundsOrientation ( ) const

inline

This method returns bounds orientation.

Definition at line 136 of file CombinedVolumeBounds.h.

                                                                            {
  return (m_boundsOrientation);
}

clone()

CombinedVolumeBounds * Trk::CombinedVolumeBounds::clone ( ) const

inlinefinaloverridevirtual

Virtual constructor.

Implements Trk::VolumeBounds.

Definition at line 108 of file CombinedVolumeBounds.h.

                                                               {
  return new CombinedVolumeBounds(*this);
}

createSubtractedVolume()

Trk::Volume * Trk::CombinedVolumeBounds::createSubtractedVolume ( const Amg::Transform3D & transf, const Trk::Volume * subtrVol )

staticprivate

Definition at line 341 of file CombinedVolumeBounds.cxx.

{
  if (!subtrVol){
    return nullptr;
  }
  return new Trk::Volume(*subtrVol, transf);
}

decomposeToSurfaces()

std::vector< std::unique_ptr< Trk::Surface > > Trk::CombinedVolumeBounds::decomposeToSurfaces ( const Amg::Transform3D & transform )

finaloverridevirtual

Method to decompose the Bounds into boundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 74 of file CombinedVolumeBounds.cxx.

                                                                         {
 
  auto retsf = std::vector<std::unique_ptr<Trk::Surface>>();
 
  const Trk::CylinderVolumeBounds* cylVol = dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_first->volumeBounds()));
  const Trk::SimplePolygonBrepVolumeBounds* spbVol = dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(&(m_first->volumeBounds()));
  const Trk::CombinedVolumeBounds* comVol = dynamic_cast<const Trk::CombinedVolumeBounds*>(&(m_first->volumeBounds()));
  const Trk::SubtractedVolumeBounds* subVol = dynamic_cast<const Trk::SubtractedVolumeBounds*>(&(m_first->volumeBounds()));
 
  // get surfaces for first boundaries
  std::vector<std::unique_ptr<Trk::Surface>> firstSurfaces =
    m_first->volumeBounds().decomposeToSurfaces(transf * m_first->transform());
  // get surfaces for second boundaries
  std::vector<std::unique_ptr<Trk::Surface>> secondSurfaces =
      m_second->volumeBounds().decomposeToSurfaces(transf * m_second->transform());
  unsigned int nSurf = firstSurfaces.size() + secondSurfaces.size();
  m_boundsOrientation.resize(nSurf);
 
  std::vector<unsigned int> subtrSecond;
 
  // loop over surfaces; convert disc surface to a plane surface using elliptic
  // bounds
  for (unsigned int out = 0; out < firstSurfaces.size(); out++) {
    //
    const SubtractedPlaneSurface* splo = dynamic_cast<const SubtractedPlaneSurface*>(firstSurfaces[out].get());
    const PlaneSurface* plo = dynamic_cast<const PlaneSurface*>(firstSurfaces[out].get());
    const SubtractedCylinderSurface* sclo = dynamic_cast<const SubtractedCylinderSurface*>(firstSurfaces[out].get());
    const CylinderSurface* clo = dynamic_cast<const CylinderSurface*>(firstSurfaces[out].get());
    const DiscSurface* dlo = dynamic_cast<const DiscSurface*>(firstSurfaces[out].get());
 
    // resolve bounds orientation : copy from combined/subtracted, swap inner
    // cyl, swap bottom spb
    if (comVol){
      m_boundsOrientation[out] = comVol->boundsOrientation()[out];
    }
    else if (subVol){
      m_boundsOrientation[out] = subVol->boundsOrientation()[out];
    }
    else if (cylVol && clo && out == 3){
      m_boundsOrientation[out] = false;
    }
    else if (spbVol && out == 0){
      m_boundsOrientation[out] = false;
    }
    else{
      m_boundsOrientation[out] = true;
    }
 
    std::unique_ptr<Trk::Volume> secondSub(createSubtractedVolume(
      firstSurfaces[out]->transform().inverse() * transf, m_second.get()));
 
    if (sclo || splo) {
      bool shared = false;
      const Trk::AreaExcluder* vEx;
      if (splo) {
        vEx = splo->subtractedVolume();
        shared = splo->shared();
      }
      if (sclo) {
        vEx = sclo->subtractedVolume();
        shared = sclo->shared();
      }
      const Trk::VolumeExcluder* volExcl = dynamic_cast<const Trk::VolumeExcluder*>(vEx);
      if (!volExcl){
        throw std::logic_error("Not a VolumeExcluder");
      }
 
      auto firstSub = std::make_unique<Trk::Volume>(*volExcl->volume());
 
      std::unique_ptr<Trk::Volume> comb_sub{};
      if (!shared && !m_intersection){
        comb_sub = std::make_unique<Trk::Volume>(
          nullptr,
          std::make_shared<Trk::CombinedVolumeBounds>(std::move(secondSub), std::move(firstSub), m_intersection));
      }
      if (!shared && m_intersection){
        comb_sub = std::make_unique<Trk::Volume>(
          nullptr,
          std::make_shared<Trk::SubtractedVolumeBounds>(std::move(secondSub), std::move(firstSub)));
      }
      if (shared && m_intersection){
        comb_sub = std::make_unique<Trk::Volume>(
          nullptr,
          std::make_shared<Trk::CombinedVolumeBounds>(std::move(secondSub), std::move(firstSub), m_intersection));
      }
      if (shared && !m_intersection){
        comb_sub = std::make_unique<Trk::Volume>(
          nullptr,
          std::make_shared<Trk::SubtractedVolumeBounds>(std::move(firstSub), std::move(secondSub)));
      }
      auto volEx = std::make_shared<const Trk::VolumeExcluder>(std::move(comb_sub));
      bool new_shared = shared;
      if (m_intersection){
        new_shared = true;
      }
      if (splo){
        retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(*splo, std::move(volEx), new_shared));
      }
      else if (sclo){
        retsf.push_back(std::make_unique<Trk::SubtractedCylinderSurface>(*sclo, std::move(volEx), new_shared));
      }
    } else if (plo || clo || dlo) {
      auto volEx = std::make_shared<const Trk::VolumeExcluder>(std::move(secondSub));
      if (plo){
        retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(*plo, std::move(volEx), m_intersection));
      }
      else if (clo){
        retsf.push_back(std::make_unique<Trk::SubtractedCylinderSurface>(*clo, std::move(volEx), m_intersection));
      }
      else if (dlo) {
        const DiscBounds* db = dynamic_cast<const DiscBounds*>(&(dlo->bounds()));
        if (!db){
          throw std::logic_error("Not DiscBounds");
        }
        auto eb = std::make_shared<EllipseBounds>(db->rMin(), db->rMin(), db->rMax(), db->rMax(), db->halfPhiSector());
        retsf.push_back( std::make_unique<Trk::SubtractedPlaneSurface>(
            PlaneSurface(Amg::Transform3D(dlo->transform()), eb),
            std::move(volEx),
            m_intersection));
      }
    } else {
      throw std::runtime_error(
        "Unhandled surface in CombinedVolumeBounds::decomposeToSurfaces.");
    }
  }
 
  cylVol =
    dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_second->volumeBounds()));
  spbVol = dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(
    &(m_second->volumeBounds()));
  comVol =
    dynamic_cast<const Trk::CombinedVolumeBounds*>(&(m_second->volumeBounds()));
  subVol = dynamic_cast<const Trk::SubtractedVolumeBounds*>(
    &(m_second->volumeBounds()));
  unsigned int nOut = firstSurfaces.size();
 
  for (unsigned int in = 0; in < secondSurfaces.size(); in++) {
    //
    const SubtractedPlaneSurface* spli = dynamic_cast<const SubtractedPlaneSurface*>(secondSurfaces[in].get());
    const PlaneSurface* pli = dynamic_cast<const PlaneSurface*>(secondSurfaces[in].get());
    const SubtractedCylinderSurface* scli = dynamic_cast<const SubtractedCylinderSurface*>(secondSurfaces[in].get());
    const CylinderSurface* cli = dynamic_cast<const CylinderSurface*>(secondSurfaces[in].get());
    const DiscSurface* dli = dynamic_cast<const DiscSurface*>(secondSurfaces[in].get());
 
    // resolve bounds orientation : copy from combined/subtracted, swap inner
    // cyl, swap bottom spb
    if (comVol){
      m_boundsOrientation[nOut + in] = comVol->boundsOrientation()[in];
    }
    else if (subVol){
      m_boundsOrientation[nOut + in] = subVol->boundsOrientation()[in];
    }
    else if (cylVol && cli && in == 3){
      m_boundsOrientation[nOut + in] = false;
    }
    else if (spbVol && in == 0){
      m_boundsOrientation[nOut + in] = false;
    }
    else{
      m_boundsOrientation[nOut + in] = true;
    }
 
    std::unique_ptr<Trk::Volume> firstSub(createSubtractedVolume(
      secondSurfaces[in]->transform().inverse() * transf, m_first.get()));
    if (scli || spli) {
      bool shared = false;
      const Trk::AreaExcluder* vEx;
      if (spli) {
        vEx = spli->subtractedVolume();
        shared = spli->shared();
      }
      if (scli) {
        vEx = scli->subtractedVolume();
        shared = scli->shared();
      }
      const Trk::VolumeExcluder* volExcl = dynamic_cast<const Trk::VolumeExcluder*>(vEx);
      if (!volExcl){
        throw std::logic_error("Not a VolumeExcluder");
      }
      auto secondSub = std::make_unique<Trk::Volume>(*volExcl->volume());
 
      std::unique_ptr<Trk::Volume> comb_sub{};
      if (!shared && !m_intersection){
        comb_sub = std::make_unique<Trk::Volume>(
          nullptr,
          std::make_shared<Trk::CombinedVolumeBounds>(std::move(firstSub), std::move(secondSub), m_intersection));
      }
      if (!shared && m_intersection){
        comb_sub = std::make_unique<Trk::Volume>(
          nullptr,
          std::make_shared<Trk::SubtractedVolumeBounds>(std::move(firstSub), std::move(secondSub)));
      }
      if (shared && m_intersection){
        comb_sub = std::make_unique<Trk::Volume>(
          nullptr,
          std::make_shared<Trk::CombinedVolumeBounds>(std::move(firstSub), std::move(secondSub), m_intersection));
      }
      if (shared && !m_intersection){
        comb_sub = std::make_unique<Trk::Volume>(
          nullptr,
          std::make_shared<Trk::SubtractedVolumeBounds>(std::move(secondSub), std::move(firstSub)));
      }
      auto volEx = std::make_shared<const Trk::VolumeExcluder>(std::move(comb_sub));
      bool new_shared = shared;
      if (m_intersection){
        new_shared = true;
      }
      if (spli){
        retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(*spli, std::move(volEx), new_shared));
      }
      else if (scli)
        retsf.push_back( std::make_unique<Trk::SubtractedCylinderSurface>(*scli, std::move(volEx), new_shared));
 
    } else if (pli || cli || dli) {
      auto volEx = std::make_shared<const Trk::VolumeExcluder>(std::move(firstSub));
      if (pli){
        retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(*pli, std::move(volEx), m_intersection));
      }
      else if (cli){
        retsf.push_back(std::make_unique<Trk::SubtractedCylinderSurface>(*cli, std::move(volEx), m_intersection));
      }
      else if (dli) {
        const DiscBounds* db = dynamic_cast<const DiscBounds*>(&(dli->bounds()));
        if (!db){
          throw std::logic_error("Not DiscBounds");
        }
        auto eb = std::make_shared<EllipseBounds>(db->rMin(), db->rMin(), db->rMax(), db->rMax(), db->halfPhiSector());
        auto pliN = PlaneSurface(Amg::Transform3D(dli->transform()), eb);
        retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(pliN, std::move(volEx), m_intersection));
      }
    } else {
      throw std::runtime_error(
        "Unhandled surface in CombinedVolumeBounds::decomposeToSurfaces.");
    }
  }
  return retsf;
}

dump() [1/2]

MsgStream & Trk::CombinedVolumeBounds::dump ( MsgStream & sl ) const

finaloverridevirtual

Output Method for MsgStream.

Implements Trk::VolumeBounds.

Definition at line 315 of file CombinedVolumeBounds.cxx.

{
  std::stringstream temp_sl;
  temp_sl << std::setiosflags(std::ios::fixed);
  temp_sl << std::setprecision(7);
  temp_sl << "Trk::CombinedVolumeBounds: first,second ";
  sl << temp_sl.str();
  std::as_const(*m_first).volumeBounds().dump(sl);
  std::as_const(*m_second).volumeBounds().dump(sl);
  return sl;
}

dump() [2/2]

std::ostream & Trk::CombinedVolumeBounds::dump ( std::ostream & sl ) const

finaloverridevirtual

Output Method for std::ostream.

Implements Trk::VolumeBounds.

Definition at line 328 of file CombinedVolumeBounds.cxx.

{
  std::stringstream temp_sl;
  temp_sl << std::setiosflags(std::ios::fixed);
  temp_sl << std::setprecision(7);
  temp_sl << "Trk::CombinedVolumeBounds: first,second ";
  sl << temp_sl.str();
  std::as_const(*m_first).volumeBounds().dump(sl);
  std::as_const(*m_second).volumeBounds().dump(sl);
  return sl;
}

first()

const Volume * Trk::CombinedVolumeBounds::first ( ) const

inline

This method returns the first VolumeBounds.

Definition at line 119 of file CombinedVolumeBounds.h.

                                                       {
  return m_first.get();
}

inside()

bool Trk::CombinedVolumeBounds::inside ( const Amg::Vector3D & pos, double tol = 0. ) const

inlinefinaloverridevirtual

This method checks if position in the 3D volume frame is inside the volume.

Implements Trk::VolumeBounds.

Definition at line 112 of file CombinedVolumeBounds.h.

                                                                                 {
  if (m_intersection) {
    return (m_first->inside(pos, tol) && m_second->inside(pos, tol));
  }
  return (m_first->inside(pos, tol) || m_second->inside(pos, tol));
}

intersection()

bool Trk::CombinedVolumeBounds::intersection ( ) const

inline

This method distinguishes between Union(0) and Intersection(1).

Definition at line 127 of file CombinedVolumeBounds.h.

                                                     {
  return m_intersection;
}

operator=()

Trk::CombinedVolumeBounds & Trk::CombinedVolumeBounds::operator=

(

const CombinedVolumeBounds &

bobo

)

Assignment operator.

Definition at line 61 of file CombinedVolumeBounds.cxx.

{
  if (this != &bobo) {
    m_first.reset(bobo.m_first->clone());
    m_second.reset(bobo.m_second->clone());
    m_intersection = bobo.m_intersection;
    m_objectAccessor = bobo.m_objectAccessor;
    m_boundsOrientation = bobo.m_boundsOrientation;
  }
  return *this;
}

second()

const Volume * Trk::CombinedVolumeBounds::second ( ) const

inline

This method returns the second VolumeBounds.

Definition at line 123 of file CombinedVolumeBounds.h.

                                                        {
  return m_second.get();
}

Member Data Documentation

m_boundsOrientation

std::vector<bool> Trk::CombinedVolumeBounds::m_boundsOrientation {}

private

Definition at line 105 of file CombinedVolumeBounds.h.

{};

m_first

std::unique_ptr<Volume> Trk::CombinedVolumeBounds::m_first {}

private

Definition at line 101 of file CombinedVolumeBounds.h.

{};

m_intersection

bool Trk::CombinedVolumeBounds::m_intersection {}

private

Definition at line 103 of file CombinedVolumeBounds.h.

{};

m_objectAccessor

EightObjectsAccessor Trk::CombinedVolumeBounds::m_objectAccessor {}

private

Definition at line 104 of file CombinedVolumeBounds.h.

{};

m_second

std::unique_ptr<Volume> Trk::CombinedVolumeBounds::m_second {}

private

Definition at line 102 of file CombinedVolumeBounds.h.

{};

---

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

• CombinedVolumeBounds.h
• CombinedVolumeBounds.cxx