segment.h

 
#ifndef INCGfeff908010fa4d75a9c006c02b4fafe7
#define INCGfeff908010fa4d75a9c006c02b4fafe7
 
#include <lf/mesh/mesh.h>
 
namespace lf::mesh::hybrid2d {
 
// Forward declaration:
class Point;
 
class Segment : public mesh::Entity {
  using size_type = mesh::Mesh::size_type;
 
 public:
  Segment() = default;
 
  Segment(const Segment&) = delete;
  Segment(Segment&&) noexcept = default;
  Segment& operator=(const Segment&) = delete;
  Segment& operator=(Segment&&) noexcept = default;
  explicit Segment(size_type index,
                   std::unique_ptr<geometry::Geometry>&& geometry,
                   const Point* endpoint0, const Point* endpoint1)
      : index_(index),
        geometry_(std::move(geometry)),
        nodes_({endpoint0, endpoint1}),
        this_(this) {
    LF_VERIFY_MSG((endpoint0 != nullptr) && (endpoint1 != nullptr),
                  "Invalid pointer to endnode of edge");
    if (geometry_) {
      LF_VERIFY_MSG(geometry_->DimLocal() == 1,
                    "Geometry must describe a curve");
      LF_VERIFY_MSG(geometry_->RefEl() == base::RefEl::kSegment(),
                    "Segment geometry must fit a segment");
    }
  }
 
  [[nodiscard]] unsigned Codim() const override { return 1; }
 
  [[nodiscard]] std::span<const Entity* const> SubEntities(
      unsigned rel_codim) const override;
 
  [[nodiscard]] std::span<const lf::mesh::Orientation> RelativeOrientations()
      const override {
    return endpoint_ori_;
  }
 
  [[nodiscard]] size_type index() const { return index_; }
 
  [[nodiscard]] const geometry::Geometry* Geometry() const override {
    return geometry_.get();
  }
  [[nodiscard]] base::RefEl RefEl() const override {
    return base::RefEl::kSegment();
  }
  [[nodiscard]] bool operator==(const mesh::Entity& rhs) const override {
    return this == &rhs;
  }
  ~Segment() override = default;
 
 private:
  size_type index_ = -1;  // zero-based index of this entity.
  std::unique_ptr<geometry::Geometry> geometry_;  // shape information
  std::array<const Point*, 2> nodes_{};           // nodes connected by edge
  Entity* this_ = nullptr;                        // needed for SubEntity()
  static constexpr std::array<lf::mesh::Orientation, 2> endpoint_ori_{
      lf::mesh::Orientation::negative,
      lf::mesh::Orientation::positive};  // orientation of endpoints
};
 
}  // namespace lf::mesh::hybrid2d
 
#endif  // INCGfeff908010fa4d75a9c006c02b4fafe7