geo::details::ActiveAreaCalculator Struct Reference

Class computing the active area of the plane. More...

Public Member Functions
	ActiveAreaCalculator (geo::PlaneGeo const &plane, double wMargin, double dMargin)
	ActiveAreaCalculator (geo::PlaneGeo const &plane, double margin=0.0)
	operator geo::PlaneGeo::Rect ()

Private Types
using	Projection_t = ROOT::Math::PositionVector2D< ROOT::Math::Cartesian2D< double >, geo::PlaneGeo::WidthDepthReferenceTag >
using	Vector_t = geo::PlaneGeo::WidthDepthDisplacement_t

Private Member Functions
void	initializeWireEnds ()
void	includeAllWireEnds ()
void	adjustCorners ()
void	applyMargin ()
geo::PlaneGeo::Rect	recomputeArea ()

Static Private Member Functions
static bool	none_or_both (bool a, bool b)
	Returns true if a and b are both true or both false (exclusive nor). More...
template<typename T >
static bool	equal (T a, T b, T tol=T(1e-5))
	Returns whether the two numbers are the same, lest a tolerance. More...

Private Attributes
PlaneGeo const &	plane
	Plane to work on. More...
double const	wMargin = 0.0
	Margin subtracted from each side of width. More...
double const	dMargin = 0.0
	Margin subtracted from each side of depth. More...
geo::PlaneGeo::Rect	activeArea
	Result. More...
Projection_t	wireEnds [4]
	Cache: wire end projections. More...

Static Private Attributes
static constexpr std::size_t	kFirstWireStart = 0
static constexpr std::size_t	kFirstWireEnd = 1
static constexpr std::size_t	kLastWireStart = 2
static constexpr std::size_t	kLastWireEnd = 3

Detailed Description

Class computing the active area of the plane.

The active area is defined in the width/depth space which include approximatively all wires.

This algorithm requires the frame reference and the wire pitch to be already defined.

That area is tuned so that all its points are closer than half a wire pitch from a wire.

Definition at line 78 of file PlaneGeo.cxx.

Member Typedef Documentation

using geo::details::ActiveAreaCalculator::Projection_t = ROOT::Math::PositionVector2D<ROOT::Math::Cartesian2D<double>, geo::PlaneGeo::WidthDepthReferenceTag>

private

Definition at line 92 of file PlaneGeo.cxx.

using geo::details::ActiveAreaCalculator::Vector_t = geo::PlaneGeo::WidthDepthDisplacement_t

private

Definition at line 93 of file PlaneGeo.cxx.

Constructor & Destructor Documentation

geo::details::ActiveAreaCalculator::ActiveAreaCalculator ( geo::PlaneGeo const &  plane, double  wMargin, double  dMargin  )

inline

Definition at line 80 of file PlaneGeo.cxx.

        : plane(plane), wMargin(wMargin), dMargin(dMargin)
      {}

geo::details::ActiveAreaCalculator::ActiveAreaCalculator ( geo::PlaneGeo const &  plane, double  margin = 0.0  )

inline

Definition at line 84 of file PlaneGeo.cxx.

        : ActiveAreaCalculator(plane, margin, margin)
      {}

Member Function Documentation

void geo::details::ActiveAreaCalculator::adjustCorners ( )

inlineprivate

Definition at line 150 of file PlaneGeo.cxx.

References lar::util::simple_geo::Rectangle< Data >::depth, geo::vect::dot(), equal(), geo::PlaneGeo::GetIncreasingWireDirection(), lar::util::simple_geo::Range< Data >::lower, none_or_both(), lar::util::simple_geo::Range< Data >::upper, geo::PlaneGeo::VectorWidthDepthProjection(), lar::util::simple_geo::Rectangle< Data >::width, geo::PlaneGeo::WirePitch(), X, x1, and Y.

Referenced by recomputeArea().

      {
        //
        // Modify the corners so that none is father than half a pitch from all
        // wires.
        //
        // directions in wire/depth plane
        Vector_t const widthDir = {1.0, 0.0};
        Vector_t const depthDir = {0.0, 1.0};
        Vector_t wireCoordDir =
          plane.VectorWidthDepthProjection(plane.GetIncreasingWireDirection());
        double const hp = plane.WirePitch() / 2.0; // half pitch

        //
        // The plan: identify if wires are across or corner, and then:
        // - across:
        //   - identify which sides
        //   - set the farther end of the wire from the side to be p/2 from
        //     its corner
        // - corner:
        //   - identify which corners
        //   - move the corners to p/2 from the wires
        //

        //
        // are the wires crossing side to side, as opposed to cutting corners?
        //

        // these are the angles of the original wire coordinate direction
        double const cosAngleWidth = geo::vect::dot(wireCoordDir, widthDir);
        double const cosAngleDepth = geo::vect::dot(wireCoordDir, depthDir);
        // if the wire coordinate direction is on first or third quadrant:
        bool const bPositiveAngle = none_or_both((wireCoordDir.X() >= 0), (wireCoordDir.Y() >= 0));

        // now we readjust the wire coordinate direction to always point
        // toward positive width; this breaks the relation between
        // wireCoordDir and which is the first/last wire
        if (cosAngleWidth < 0) wireCoordDir = -wireCoordDir;

        // let's study the first wire (ends are sorted by width)
        assert(wireEnds[kFirstWireEnd].X() >= wireEnds[kFirstWireStart].X());
        bool const bAlongWidth // horizontal
          = equal(wireEnds[kFirstWireEnd].X(), activeArea.width.upper) &&
            equal(wireEnds[kFirstWireStart].X(), activeArea.width.lower);
        bool const bAlongDepth =
          !bAlongWidth && // vertical
          equal(std::max(wireEnds[kFirstWireStart].Y(), wireEnds[kFirstWireEnd].Y()),
                activeArea.depth.upper) &&
          equal(std::min(wireEnds[kFirstWireStart].Y(), wireEnds[kFirstWireEnd].Y()),
                activeArea.depth.lower);
        assert(!(bAlongWidth && bAlongDepth));

        if (bAlongWidth) { // horizontal

          // +---------+
          // |   ___,--|  upper width bound
          // |--'      |

          // find which is the wire with higher width:
          // the last wire is highest if the wire coordinate direction (which
          // is defined by what is first and what is last) is parallel to the
          // width direction
          std::size_t const iUpperWire = (cosAngleDepth > 0) ? kLastWireStart : kFirstWireStart;
          // largest distance from upper depth bound of the two ends of wire
          double const maxUpperDistance =
            activeArea.depth.upper -
            std::min(wireEnds[iUpperWire].Y(), wireEnds[iUpperWire ^ 0x1].Y());
          // set the upper side so that the maximum distance is p/2
          // (it may be actually less if the wire is not perfectly horizontal)
          activeArea.depth.upper += (hp - maxUpperDistance);

          // |--.___   |
          // |      `--|  deal with the lower bound now
          // +---------+

          std::size_t const iLowerWire = (cosAngleDepth > 0) ? kFirstWireStart : kLastWireStart;
          // largest distance from lower depth bound of the two ends of wire
          double const maxLowerDistance =
            std::max(wireEnds[iLowerWire].Y(), wireEnds[iLowerWire ^ 0x1].Y()) -
            activeArea.depth.lower;
          // set the upper side so that the minimum distance is p/2
          activeArea.depth.lower -= (hp - maxLowerDistance);

        }                       // horizontal wires
        else if (bAlongDepth) { // vertical
          // --,---+
          //   |   |
          //    \  |
          //    |  |  upper depth bound
          //     \ |
          //     | |
          // ------+

          // find which is the wire with higher depth:
          // the last wire is highest if the wire coordinate direction (which
          // is defined by what is first and what is last) is parallel to the
          // depth direction
          std::size_t const iUpperWire = (cosAngleWidth > 0) ? kLastWireStart : kFirstWireStart;
          // largest distance from upper depth bound of the two ends of wire
          double const maxUpperDistance =
            activeArea.width.upper -
            std::min(wireEnds[iUpperWire].X(), wireEnds[iUpperWire ^ 0x1].X());
          // set the upper side so that the minimum distance is p/2
          activeArea.width.upper += (hp - maxUpperDistance);

          // +-,----
          // | |
          // |  \     .
          // |  |     deal with the lower bound now
          // |   \    .
          // |   |
          // +------
          std::size_t const iLowerWire = (cosAngleWidth > 0) ? kFirstWireStart : kLastWireStart;
          // largest distance from lower width bound of the two ends of wire
          double const maxLowerDistance =
            std::max(wireEnds[iLowerWire].X(), wireEnds[iLowerWire ^ 0x1].X()) -
            activeArea.width.lower;
          // set the upper side so that the minimum distance is p/2
          activeArea.width.lower -= (hp - maxLowerDistance);

        }                          // vertical wires
        else if (bPositiveAngle) { // wires are not going across: corners!
          // corners at (lower width, lower depth), (upper width, upper depth)

          // -._------+
          //    `-._  |  upper width corner (upper depth)
          //        `-|

          // start of the wire on the upper corner
          // (width coordinate is lower for start than for end)
          std::size_t const iUpperWire = (cosAngleWidth > 0) ? kLastWireStart : kFirstWireStart;

          double const upperDistance = geo::vect::dot(
            Vector_t(activeArea.width.upper - wireEnds[iUpperWire].X(), 0.0), wireCoordDir);
          // make the upper distance become p/2
          auto const upperDelta = (hp - upperDistance) * wireCoordDir;
          activeArea.width.upper += upperDelta.X();
          activeArea.depth.upper += upperDelta.Y();

          // |-._
          // |   `-._    lower width corner (lower depth)
          // +-------`-

          // end of the wire on the lower corner
          // (width coordinate is lower than the end)
          std::size_t const iLowerWire = (cosAngleWidth > 0) ? kFirstWireEnd : kLastWireEnd;

          double const lowerDistance = geo::vect::dot(
            Vector_t(wireEnds[iLowerWire].X() - activeArea.width.lower, 0.0), wireCoordDir);
          // make the lower distance become p/2 (note direction of wire coord)
          auto const lowerDelta = (hp - lowerDistance) * wireCoordDir;
          activeArea.width.lower -= lowerDelta.X();
          activeArea.depth.lower -= lowerDelta.Y();
        }
        else { // !bPositiveAngle
          // corners at (lower width, upper depth), (upper width, lower depth)

          //       _,-|
          //   _,-'   |  upper width corner (lower depth)
          // -'-------+

          // start of the wire on the upper corner
          // (width coordinate is lower than the end)
          std::size_t const iUpperWire = (cosAngleWidth > 0) ? kLastWireStart : kFirstWireStart;

          double const upperDistance = geo::vect::dot(
            Vector_t(activeArea.width.upper - wireEnds[iUpperWire].X(), 0.0), wireCoordDir);
          // make the upper distance become p/2
          auto const upperDelta = (hp - upperDistance) * wireCoordDir;
          activeArea.width.upper += upperDelta.X();
          activeArea.depth.lower += upperDelta.Y();

          // +------_,-
          // |  _,-'     lower width corner (upper depth)
          // |-'

          // end of the wire on the lower corner
          // (width coordinate is lower than the end)
          std::size_t const iLowerWire = (cosAngleWidth > 0) ? kFirstWireEnd : kLastWireEnd;

          double const lowerDistance = geo::vect::dot(
            Vector_t(wireEnds[iLowerWire].X() - activeArea.width.lower, 0.0), wireCoordDir);
          // make the lower distance become p/2 (note direction of wire coord)
          auto const lowerDelta = (hp - lowerDistance) * wireCoordDir;
          activeArea.width.lower -= lowerDelta.X();
          activeArea.depth.upper -= lowerDelta.Y();

        } // if ...

      } // adjustCorners()

void geo::details::ActiveAreaCalculator::applyMargin ( )

inlineprivate

Definition at line 341 of file PlaneGeo.cxx.

References lar::util::simple_geo::Rectangle< Data >::depth, dMargin, lar::util::simple_geo::Range< Data >::lower, lar::util::simple_geo::Range< Data >::upper, lar::util::simple_geo::Rectangle< Data >::width, and wMargin.

Referenced by recomputeArea().

      {
        if (wMargin != 0.0) {
          activeArea.width.lower += wMargin;
          activeArea.width.upper -= wMargin;
        }
        if (dMargin != 0.0) {
          activeArea.depth.lower += dMargin;
          activeArea.depth.upper -= dMargin;
        }
      } // applyMargin()

template<typename T >

static bool geo::details::ActiveAreaCalculator::equal ( T  a, T  b, T  tol = T(1e-5)  )

inlinestaticprivate

Returns whether the two numbers are the same, lest a tolerance.

Definition at line 385 of file PlaneGeo.cxx.

References util::abs().

Referenced by adjustCorners().

      {
        return std::abs(a - b) <= tol;
      }

void geo::details::ActiveAreaCalculator::includeAllWireEnds ( )

inlineprivate

Definition at line 136 of file PlaneGeo.cxx.

References lar::util::simple_geo::Rectangle< Data >::depth, lar::util::simple_geo::Range< Data >::extendToInclude(), and lar::util::simple_geo::Rectangle< Data >::width.

Referenced by recomputeArea().

      {
        //
        // Find the basic area containing all the coordinates.
        //

        // include all the coordinates of the first and last wire
        for (auto const& aWireEnd : wireEnds) {
          activeArea.width.extendToInclude(aWireEnd.X());
          activeArea.depth.extendToInclude(aWireEnd.Y());
        }

      } // includeAllWireEnds()

void geo::details::ActiveAreaCalculator::initializeWireEnds ( )

inlineprivate

Definition at line 111 of file PlaneGeo.cxx.

References geo::PlaneGeo::FirstWire(), geo::WireGeo::GetEnd(), geo::WireGeo::GetStart(), kFirstWireEnd, kFirstWireStart, kLastWireEnd, kLastWireStart, geo::PlaneGeo::LastWire(), geo::PlaneGeo::PointWidthDepthProjection(), and X.

Referenced by recomputeArea().

      {
        //
        // Collect the projections of the relevant points.
        //
        // Sorted so that start points have width not larger than end points.
        //
        // PointWidthDepthProjection() erroneously returns a vector rather
        // than a point, so a conversion is required
        auto makeProjection = [](auto v) { return Projection_t(v.X(), v.Y()); };

        wireEnds[kFirstWireStart] =
          makeProjection(plane.PointWidthDepthProjection(plane.FirstWire().GetStart()));
        wireEnds[kFirstWireEnd] =
          makeProjection(plane.PointWidthDepthProjection(plane.FirstWire().GetEnd()));
        if (wireEnds[kFirstWireStart].X() > wireEnds[kFirstWireEnd].X())
          std::swap(wireEnds[kFirstWireStart], wireEnds[kFirstWireEnd]);
        wireEnds[kLastWireStart] =
          makeProjection(plane.PointWidthDepthProjection(plane.LastWire().GetStart()));
        wireEnds[kLastWireEnd] =
          makeProjection(plane.PointWidthDepthProjection(plane.LastWire().GetEnd()));
        if (wireEnds[kLastWireStart].X() > wireEnds[kLastWireEnd].X())
          std::swap(wireEnds[kLastWireStart], wireEnds[kLastWireEnd]);
      } // initializeWireEnds()

static bool geo::details::ActiveAreaCalculator::none_or_both ( bool  a, bool  b  )

inlinestaticprivate

Returns true if a and b are both true or both false (exclusive nor).

Definition at line 381 of file PlaneGeo.cxx.

Referenced by adjustCorners().

{ return a == b; }

geo::details::ActiveAreaCalculator::operator geo::PlaneGeo::Rect ( )

inline

Definition at line 88 of file PlaneGeo.cxx.

References recomputeArea().

{ return recomputeArea(); }

geo::PlaneGeo::Rect geo::details::ActiveAreaCalculator::recomputeArea ( )

inlineprivate

Definition at line 353 of file PlaneGeo.cxx.

References activeArea, adjustCorners(), applyMargin(), includeAllWireEnds(), and initializeWireEnds().

Referenced by operator geo::PlaneGeo::Rect().

      {
        activeArea = {};

        //
        // 0. collect the projections of the relevant point
        //
        initializeWireEnds();

        //
        // 1. find the basic area containing all the coordinates
        //
        includeAllWireEnds();

        //
        // 2. adjust area so that no corner is father than half a wire pitch
        //
        adjustCorners();

        //
        // 3. apply an absolute margin
        //
        applyMargin();

        return activeArea;
      } // computeArea()

Member Data Documentation

geo::PlaneGeo::Rect geo::details::ActiveAreaCalculator::activeArea

private

Result.

Definition at line 106 of file PlaneGeo.cxx.

Referenced by recomputeArea().

double const geo::details::ActiveAreaCalculator::dMargin = 0.0

private

Margin subtracted from each side of depth.

Definition at line 105 of file PlaneGeo.cxx.

Referenced by applyMargin().

constexpr std::size_t geo::details::ActiveAreaCalculator::kFirstWireEnd = 1

staticprivate

Definition at line 99 of file PlaneGeo.cxx.

Referenced by initializeWireEnds().

constexpr std::size_t geo::details::ActiveAreaCalculator::kFirstWireStart = 0

staticprivate

Definition at line 98 of file PlaneGeo.cxx.

Referenced by initializeWireEnds().

constexpr std::size_t geo::details::ActiveAreaCalculator::kLastWireEnd = 3

staticprivate

Definition at line 101 of file PlaneGeo.cxx.

Referenced by initializeWireEnds().

constexpr std::size_t geo::details::ActiveAreaCalculator::kLastWireStart = 2

staticprivate

Definition at line 100 of file PlaneGeo.cxx.

Referenced by initializeWireEnds().

PlaneGeo const& geo::details::ActiveAreaCalculator::plane

private

Plane to work on.

Definition at line 103 of file PlaneGeo.cxx.

Projection_t geo::details::ActiveAreaCalculator::wireEnds[4]

private

Cache: wire end projections.

Definition at line 109 of file PlaneGeo.cxx.

double const geo::details::ActiveAreaCalculator::wMargin = 0.0

private

Margin subtracted from each side of width.

Definition at line 104 of file PlaneGeo.cxx.

Referenced by applyMargin().

---

The documentation for this struct was generated from the following file:

• larcorealg/v09_13_01/source/larcorealg/Geometry/PlaneGeo.cxx