Trk::SubtractedVolumeBounds Class Reference

#include <SubtractedVolumeBounds.h>

Inheritance diagram for Trk::SubtractedVolumeBounds:

Collaboration diagram for Trk::SubtractedVolumeBounds:

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

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

Private Attributes
Volume *	m_outer
Volume *	m_inner
EightObjectsAccessor	m_objectAccessor
	There's only one single object Acessor for the moment has to be implemented if Subtracteds are used more widely. More...
std::vector< bool >	m_boundsOrientation

Detailed Description

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

BoundarySurfaceFace [index]: [n1] surfaces from 'outer' volume [n1+n2-n_subtr] remaining surfaces (after subtraction) from 'inner' volume

Author

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

Definition at line 40 of file SubtractedVolumeBounds.h.

Constructor & Destructor Documentation

SubtractedVolumeBounds() [1/3]

Trk::SubtractedVolumeBounds::SubtractedVolumeBounds

(

)

Default Constructor.

Definition at line 33 of file SubtractedVolumeBounds.cxx.

  : VolumeBounds()
  , m_outer(nullptr)
  , m_inner(nullptr)
  , m_objectAccessor()
  , m_boundsOrientation()
{}

SubtractedVolumeBounds() [2/3]

Trk::SubtractedVolumeBounds::SubtractedVolumeBounds	(	Volume *	outerVol,
		Volume *	innerVol
	)

Constructor - the box boundaries.

Definition at line 41 of file SubtractedVolumeBounds.cxx.

  : VolumeBounds()
  , m_outer(vol1)
  , m_inner(vol2)
  , m_objectAccessor()
  , m_boundsOrientation()
{}

SubtractedVolumeBounds() [3/3]

Trk::SubtractedVolumeBounds::SubtractedVolumeBounds

(

const SubtractedVolumeBounds &

bobo

)

Copy Constructor.

Definition at line 49 of file SubtractedVolumeBounds.cxx.

  : VolumeBounds()
  , m_outer(bobo.m_outer)
  , m_inner(bobo.m_inner)
  , m_objectAccessor(bobo.m_objectAccessor)
  , m_boundsOrientation()
{
  m_boundsOrientation.resize(bobo.m_boundsOrientation.size());
  for (unsigned int i = 0; i < bobo.m_boundsOrientation.size(); i++)
    m_boundsOrientation[i] = bobo.m_boundsOrientation[i];
}

~SubtractedVolumeBounds()

Trk::SubtractedVolumeBounds::~SubtractedVolumeBounds ( )

virtual

Destructor.

Definition at line 62 of file SubtractedVolumeBounds.cxx.

{
  m_boundsOrientation.clear();
  delete m_outer;
  delete m_inner;
}

Member Function Documentation

boundarySurfaceAccessor()

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

inlinefinaloverridevirtual

Provide accessor for BoundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 119 of file SubtractedVolumeBounds.h.

                                                        {
  return Trk::ObjectAccessor(m_objectAccessor);
}

boundsOrientation()

std::vector< bool > Trk::SubtractedVolumeBounds::boundsOrientation ( ) const

inline

This method returns bounds orientation.

Definition at line 124 of file SubtractedVolumeBounds.h.

                                                                       {
  return (m_boundsOrientation);
}

clone()

SubtractedVolumeBounds * Trk::SubtractedVolumeBounds::clone ( ) const

inlinefinaloverridevirtual

Virtual constructor.

Implements Trk::VolumeBounds.

Definition at line 104 of file SubtractedVolumeBounds.h.

                                                                   {
  return new SubtractedVolumeBounds(*this);
}

createSubtractedVolume()

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

staticprivate

Definition at line 331 of file SubtractedVolumeBounds.cxx.

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

decomposeToSurfaces()

const std::vector< const Trk::Surface * > * Trk::SubtractedVolumeBounds::decomposeToSurfaces ( const Amg::Transform3D &  transform )

finaloverridevirtual

Method to decompose the Bounds into boundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 85 of file SubtractedVolumeBounds.cxx.

{
  // double tol=0.001;
  // get surfaces for outer boundaries
  const std::vector<const Trk::Surface*>* outerSurfaces =
    m_outer->volumeBounds().decomposeToSurfaces(transf * m_outer->transform());
  // get surfaces for inner boundaries
  const std::vector<const Trk::Surface*>* innerSurfaces =
    m_inner->volumeBounds().decomposeToSurfaces(transf * m_inner->transform());
  std::vector<unsigned int> subtrInner;
  std::vector<const Trk::Surface*>* retsf =
    new std::vector<const Trk::Surface*>;
 
  unsigned int nSurf = outerSurfaces->size() + innerSurfaces->size();
  m_boundsOrientation.resize(nSurf);
 
  const Trk::CylinderVolumeBounds* cylVol =
    dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_outer->volumeBounds()));
  const Trk::SimplePolygonBrepVolumeBounds* spbVol =
    dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(
      &(m_outer->volumeBounds()));
  const Trk::CombinedVolumeBounds* comVol =
    dynamic_cast<const Trk::CombinedVolumeBounds*>(&(m_outer->volumeBounds()));
  const Trk::SubtractedVolumeBounds* subVol =
    dynamic_cast<const Trk::SubtractedVolumeBounds*>(
      &(m_outer->volumeBounds()));
 
  // loop over 'outer' boundary surfaces; modified by subtracted volume
  for (unsigned int out = 0; out < outerSurfaces->size(); out++) {
    const SubtractedPlaneSurface* splo =
      dynamic_cast<const SubtractedPlaneSurface*>((*outerSurfaces)[out]);
    const PlaneSurface* plo =
      dynamic_cast<const PlaneSurface*>((*outerSurfaces)[out]);
    const SubtractedCylinderSurface* sclo =
      dynamic_cast<const SubtractedCylinderSurface*>((*outerSurfaces)[out]);
    const CylinderSurface* clo =
      dynamic_cast<const CylinderSurface*>((*outerSurfaces)[out]);
    const DiscSurface* dlo =
      dynamic_cast<const DiscSurface*>((*outerSurfaces)[out]);
    if (!(splo || plo || sclo || clo || dlo)) {
      throw std::runtime_error("Unhandled surface.");
    }
    // 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;
    //
    Trk::Volume* innerSub = createSubtractedVolume(
      (*outerSurfaces)[out]->transform().inverse() * transf, m_inner);
 
    if (splo || sclo) { // multiple subtraction
      SharedObject<Trk::AreaExcluder> vEx;
      bool shared = false;
      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.get());
      if (!volExcl)
        throw std::logic_error("Not a VolumeExcluder");
      Trk::Volume* outerSub = new Trk::Volume(*volExcl->volume());
 
      Trk::Volume* comb_sub = nullptr;
      if (!shared)
        comb_sub = new Trk::Volume(
          nullptr, new Trk::CombinedVolumeBounds(innerSub, outerSub, false));
      else
        comb_sub = new Trk::Volume(
          nullptr, new Trk::SubtractedVolumeBounds(outerSub, innerSub));
      Trk::VolumeExcluder* volEx = new Trk::VolumeExcluder(comb_sub);
      if (splo)
        retsf->push_back(new Trk::SubtractedPlaneSurface(*splo, volEx, shared));
      if (sclo)
        retsf->push_back(
          new Trk::SubtractedCylinderSurface(*sclo, volEx, shared));
    } else {
      Trk::VolumeExcluder* volEx = new Trk::VolumeExcluder(innerSub);
      if (plo)
        retsf->push_back(new Trk::SubtractedPlaneSurface(*plo, volEx, false));
      if (clo)
        retsf->push_back(
          new Trk::SubtractedCylinderSurface(*clo, volEx, false));
      if (dlo) {
        // turn disc into ellipse for simplification
        const DiscBounds* db =
          dynamic_cast<const DiscBounds*>(&(dlo->bounds()));
        if (!db)
          throw std::logic_error("Not DiscBounds");
        EllipseBounds* eb = new EllipseBounds(
          db->rMin(), db->rMin(), db->rMax(), db->rMax(), db->halfPhiSector());
        plo = new PlaneSurface(Amg::Transform3D(dlo->transform()), eb);
        retsf->push_back(new Trk::SubtractedPlaneSurface(*plo, volEx, false));
        delete plo;
      }
    }
  }
 
  // loop over 'inner' boundary surfaces; include only if represent a new
  // surface change: include allways otherwise orientation messed up bonus :
  // solves 'double boundary' problem
 
  cylVol =
    dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_inner->volumeBounds()));
  spbVol = dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(
    &(m_inner->volumeBounds()));
  comVol =
    dynamic_cast<const Trk::CombinedVolumeBounds*>(&(m_inner->volumeBounds()));
  subVol = dynamic_cast<const Trk::SubtractedVolumeBounds*>(
    &(m_inner->volumeBounds()));
  unsigned int nOut = outerSurfaces->size();
 
  for (unsigned int in = 0; in < innerSurfaces->size(); in++) {
    const SubtractedPlaneSurface* spli =
      dynamic_cast<const SubtractedPlaneSurface*>((*innerSurfaces)[in]);
    const PlaneSurface* pli =
      dynamic_cast<const PlaneSurface*>((*innerSurfaces)[in]);
    const SubtractedCylinderSurface* scli =
      dynamic_cast<const SubtractedCylinderSurface*>((*innerSurfaces)[in]);
    const CylinderSurface* cli =
      dynamic_cast<const CylinderSurface*>((*innerSurfaces)[in]);
    const DiscSurface* dli =
      dynamic_cast<const DiscSurface*>((*innerSurfaces)[in]);
    // resolve bounds orientation : copy from combined/subtracted, swap inner
    // cyl, swap bottom spb, swap all
    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] = true;
    else if (spbVol && in == 0)
      m_boundsOrientation[nOut + in] = true;
    else
      m_boundsOrientation[nOut + in] = false;
    //
    Trk::Volume* outerSub = createSubtractedVolume(
      (*innerSurfaces)[in]->transform().inverse() * transf, m_outer);
 
    if (spli || scli) {
      bool shared = false;
      SharedObject<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.get());
      if (!volExcl)
        throw std::logic_error("Not a VolumeExcluder");
      Trk::Volume* innerSub = new Trk::Volume(*volExcl->volume());
 
      // combined volume
      Trk::Volume* comb_sub = nullptr;
      if (!shared)
        comb_sub = new Trk::Volume(
          nullptr, new Trk::SubtractedVolumeBounds(outerSub, innerSub));
      else
        comb_sub = new Trk::Volume(
          nullptr, new Trk::CombinedVolumeBounds(innerSub, outerSub, true));
      Trk::VolumeExcluder* volEx = new Trk::VolumeExcluder(comb_sub);
      if (spli)
        retsf->push_back(new Trk::SubtractedPlaneSurface(*spli, volEx, true));
      if (scli)
        retsf->push_back(
          new Trk::SubtractedCylinderSurface(*scli, volEx, true));
 
    } else if (pli || cli) {
      Trk::VolumeExcluder* volEx = new Trk::VolumeExcluder(outerSub);
      if (pli)
        retsf->push_back(new Trk::SubtractedPlaneSurface(*pli, volEx, true));
      if (cli)
        retsf->push_back(new Trk::SubtractedCylinderSurface(*cli, volEx, true));
    } else if (dli) {
      // turn disc into ellipse for simplification
      const DiscBounds* db = dynamic_cast<const DiscBounds*>(&(dli->bounds()));
      if (!db)
        throw std::logic_error("Not DiscBounds");
      EllipseBounds* eb = new EllipseBounds(
        db->rMin(), db->rMin(), db->rMax(), db->rMax(), db->halfPhiSector());
      PlaneSurface pla(Amg::Transform3D(dli->transform()), eb);
      Trk::VolumeExcluder* volEx = new Trk::VolumeExcluder(outerSub);
      retsf->push_back(new Trk::SubtractedPlaneSurface(pla, volEx, true));
    } else {
      throw std::runtime_error(
        "Unhandled surface in "
        "Trk::SubtractedVolumeBounds::decomposeToSurfaces.");
    }
  }
 
  for (const auto *outerSurface : *outerSurfaces)
    delete outerSurface;
  for (const auto *innerSurface : *innerSurfaces)
    delete innerSurface;
  delete outerSurfaces;
  delete innerSurfaces;
 
  return retsf;
}

dump() [1/2]

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

overridevirtual

Output Method for MsgStream.

Implements Trk::VolumeBounds.

Definition at line 305 of file SubtractedVolumeBounds.cxx.

{
  std::stringstream temp_sl;
  temp_sl << std::setiosflags(std::ios::fixed);
  temp_sl << std::setprecision(7);
  temp_sl << "Trk::SubtractedVolumeBounds: outer,inner ";
  sl << temp_sl.str();
  std::as_const(*m_outer).volumeBounds().dump(sl);
  std::as_const(*m_inner).volumeBounds().dump(sl);
  return sl;
}

dump() [2/2]

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

finaloverridevirtual

Output Method for std::ostream.

Implements Trk::VolumeBounds.

Definition at line 318 of file SubtractedVolumeBounds.cxx.

{
  std::stringstream temp_sl;
  temp_sl << std::setiosflags(std::ios::fixed);
  temp_sl << std::setprecision(7);
  temp_sl << "Trk::SubtractedVolumeBounds: outer,inner ";
  sl << temp_sl.str();
  std::as_const(*m_outer).volumeBounds().dump(sl);
  std::as_const(*m_inner).volumeBounds().dump(sl);
  return sl;
}

inner() [1/2]

Volume * Trk::SubtractedVolumeBounds::inner ( )

inline

Definition at line 117 of file SubtractedVolumeBounds.h.

{ return m_inner; }

inner() [2/2]

const Volume * Trk::SubtractedVolumeBounds::inner ( ) const

inline

This method returns the inner Volume.

Definition at line 116 of file SubtractedVolumeBounds.h.

{ return m_inner; }

inside()

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

inlinefinaloverridevirtual

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

Implements Trk::VolumeBounds.

Definition at line 108 of file SubtractedVolumeBounds.h.

                                                             {
  return (m_outer->inside(pos, tol) && !m_inner->inside(pos, -tol));
}

operator=()

Trk::SubtractedVolumeBounds & Trk::SubtractedVolumeBounds::operator=

(

const SubtractedVolumeBounds &

bobo

)

Assignment operator.

Definition at line 70 of file SubtractedVolumeBounds.cxx.

{
  if (this != &bobo) {
    m_outer = bobo.m_outer;
    m_inner = bobo.m_inner;
    m_objectAccessor = bobo.m_objectAccessor;
    m_boundsOrientation = bobo.m_boundsOrientation;
    m_boundsOrientation.resize(bobo.m_boundsOrientation.size());
    for (unsigned int i = 0; i < bobo.m_boundsOrientation.size(); i++)
      m_boundsOrientation[i] = bobo.m_boundsOrientation[i];
  }
  return *this;
}

outer() [1/2]

Volume * Trk::SubtractedVolumeBounds::outer ( )

inline

Definition at line 114 of file SubtractedVolumeBounds.h.

{ return m_outer; }

outer() [2/2]

const Volume * Trk::SubtractedVolumeBounds::outer ( ) const

inline

This method returns the outer Volume.

Definition at line 113 of file SubtractedVolumeBounds.h.

{ return m_outer; }

Member Data Documentation

m_boundsOrientation

std::vector<bool> Trk::SubtractedVolumeBounds::m_boundsOrientation

private

Definition at line 101 of file SubtractedVolumeBounds.h.

m_inner

Volume* Trk::SubtractedVolumeBounds::m_inner

private

Definition at line 95 of file SubtractedVolumeBounds.h.

m_objectAccessor

EightObjectsAccessor Trk::SubtractedVolumeBounds::m_objectAccessor

private

There's only one single object Acessor for the moment has to be implemented if Subtracteds are used more widely.

Definition at line 99 of file SubtractedVolumeBounds.h.

m_outer

Volume* Trk::SubtractedVolumeBounds::m_outer

private

Definition at line 94 of file SubtractedVolumeBounds.h.

---

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

• SubtractedVolumeBounds.h
• SubtractedVolumeBounds.cxx