triangle.h

 
#ifndef INCG6f934bca210e4020914d12e0910fab42
#define INCG6f934bca210e4020914d12e0910fab42
 
#include <lf/mesh/mesh.h>
 
namespace lf::mesh::hybrid2d {
 
class Point;
class Segment;
 
class Triangle : public mesh::Entity {
  using size_type = mesh::Mesh::size_type;
 
 public:
  Triangle() = default;
 
  Triangle(const Triangle&) = delete;
  Triangle(Triangle&&) noexcept = default;
  Triangle& operator=(const Triangle&) = delete;
  Triangle& operator=(Triangle&&) noexcept = default;
  explicit Triangle(size_type index,
                    std::unique_ptr<geometry::Geometry>&& geometry,
                    const Point* corner0, const Point* corner1,
                    const Point* corner2, const Segment* edge0,
                    const Segment* edge1, const Segment* edge2);
 
  [[nodiscard]] unsigned Codim() const override { return 0; }
 
  [[nodiscard]] size_type index() const { return index_; }
 
  [[nodiscard]] std::span<const Entity* const> SubEntities(
      unsigned rel_codim) const override;
 
  [[nodiscard]] std::span<const lf::mesh::Orientation> RelativeOrientations()
      const override {
    return edge_ori_;
  }
 
  [[nodiscard]] const geometry::Geometry* Geometry() const override {
    return geometry_.get();
  }
  [[nodiscard]] base::RefEl RefEl() const override {
    return base::RefEl::kTria();
  }
  [[nodiscard]] bool operator==(const mesh::Entity& rhs) const override {
    return this == &rhs;
  }
  ~Triangle() 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*, 3> nodes_{};           // nodes = corners of cell
  std::array<const Segment*, 3> edges_{};         // edges of the cells
  std::array<lf::mesh::Orientation, 3>
      edge_ori_{};          // orientation of edges (set in constructor)
  Entity* this_ = nullptr;  // needed for SubEntity()
};
 
}  // namespace lf::mesh::hybrid2d
 
#endif  // INCG6f934bca210e4020914d12e0910fab42