Plane.h

Go to the documentation of this file.

#ifndef Geom_Plane_H
#define Geom_Plane_H

#include "DataFormats/GeometrySurface/interface/Surface.h"

class Plane : public Surface {
public:
  template <typename... Args>
  Plane(Args&&... args) : Surface(std::forward<Args>(args)...) {
    setPosPrec();
    computeSpan();
  }

  using PlanePointer = ReferenceCountingPointer<Plane>;
  using ConstPlanePointer = ConstReferenceCountingPointer<Plane>;
  using BoundPlanePointer = ReferenceCountingPointer<Plane>;
  using ConstBoundPlanePointer = ConstReferenceCountingPointer<Plane>;

  template <typename... Args>
  static PlanePointer build(Args&&... args) {
    return PlanePointer(new Plane(std::forward<Args>(args)...));
  }

  ~Plane() override {}

  // extension of Surface interface for planes

  GlobalVector normalVector() const { return GlobalVector(rotation().z()); }

  float localZ(const GlobalPoint& gp) const { return normalVector().dot(gp - position()); }

  float localZclamped(const GlobalPoint& gp) const {
    auto d = localZ(gp);
    return std::abs(d) > posPrec() ? d : 0;
  }

  float localZ(const GlobalVector& gv) const { return normalVector().dot(gv); }

  // precision on position
  float posPrec() const { return m_posPrec; }

  void computeSpan() {
    if (theBounds)
      theBounds->computeSpan(*this);
  }

  // implementation of Surface interface

  SurfaceOrientation::Side side(const LocalPoint& p, Scalar toler) const final {
    return (std::abs(p.z()) < toler)
               ? SurfaceOrientation::onSurface
               : (p.z() > 0 ? SurfaceOrientation::positiveSide : SurfaceOrientation::negativeSide);
  }

  SurfaceOrientation::Side side(const GlobalPoint& p, Scalar toler) const final {
    Scalar lz = localZ(p);
    return (std::abs(lz) < toler ? SurfaceOrientation::onSurface
                                 : (lz > 0 ? SurfaceOrientation::positiveSide : SurfaceOrientation::negativeSide));
  }

  ConstReferenceCountingPointer<TangentPlane> tangentPlane(const GlobalPoint&) const final;

  ConstReferenceCountingPointer<TangentPlane> tangentPlane(const LocalPoint&) const final;

private:
  void setPosPrec() {
    constexpr auto maxf = std::numeric_limits<float>::max();
    auto p = position();
    float l = std::max(std::max(std::abs(p.x()), std::abs(p.y())), std::abs(p.z()));
    m_posPrec = std::abs(
        l - ::nextafterf(l, maxf));  //  LSB  (can be multiplied by 4 or divided by 4 for safety depending on usage)
  }

  Scalar m_posPrec;  // the precision on the actual global position
};
using BoundPlane = Plane;

#endif