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