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 85 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 103 of file PlaneGeo.cxx.

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

private

Definition at line 104 of file PlaneGeo.cxx.

Constructor & Destructor Documentation

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

inline

Definition at line 88 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 94 of file PlaneGeo.cxx.

        : ActiveAreaCalculator(plane, margin, margin)
        {}

Member Function Documentation

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

inlineprivate

Definition at line 164 of file PlaneGeo.cxx.

        {
          //
          // 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 377 of file PlaneGeo.cxx.

        {
          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 422 of file PlaneGeo.cxx.

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

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

inlineprivate

Definition at line 150 of file PlaneGeo.cxx.

        {
          //
          // 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 124 of file PlaneGeo.cxx.

        {
          //
          // 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 418 of file PlaneGeo.cxx.

{ return a == b; }

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

inline

Definition at line 98 of file PlaneGeo.cxx.

        { return recomputeArea(); }

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

inlineprivate

Definition at line 390 of file PlaneGeo.cxx.

        {
          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 119 of file PlaneGeo.cxx.

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

private

Margin subtracted from each side of depth.

Definition at line 118 of file PlaneGeo.cxx.

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

staticprivate

Definition at line 112 of file PlaneGeo.cxx.

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

staticprivate

Definition at line 111 of file PlaneGeo.cxx.

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

staticprivate

Definition at line 114 of file PlaneGeo.cxx.

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

staticprivate

Definition at line 113 of file PlaneGeo.cxx.

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

private

Plane to work on.

Definition at line 116 of file PlaneGeo.cxx.

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

private

Cache: wire end projections.

Definition at line 122 of file PlaneGeo.cxx.

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

private

Margin subtracted from each side of width.

Definition at line 117 of file PlaneGeo.cxx.

---

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

• larcorealg/larcorealg/Geometry/PlaneGeo.cxx