Triangle.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <algorithm>
#include <array>
#include <iostream>
#include <tuple>
 
#include "math/differences.hpp"
#include "mesh/Edge.hpp"
#include "mesh/RangeAccessor.hpp"
#include "precice/impl/Types.hpp"
#include "utils/assertion.hpp"
 
namespace precice::mesh {
class Vertex;
}
 
// ----------------------------------------------------------- CLASS DEFINITION
 
namespace precice::mesh {
 
class Triangle {
public:
 
  using const_iterator = IndexRangeIterator<const Triangle, const Vertex::RawCoords>;
 
  using iterator = const_iterator;
 
  using value_type = Vertex::RawCoords;
 
  static constexpr int vertexCount{3};
 
  Triangle(
      Edge &edgeOne,
      Edge &edgeTwo,
      Edge &edgeThree);
 
  Triangle(
      Vertex &VertexOne,
      Vertex &VertexTwo,
      Vertex &VertexThree);
 
  int getDimensions() const;
 
  Vertex &vertex(int i);
 
  const Vertex &vertex(int i) const;
 
 
  iterator begin();
 
  iterator end();
 
  const_iterator begin() const;
 
  const_iterator end() const;
 
  const_iterator cbegin() const;
 
  const_iterator cend() const;
 
 
  Eigen::VectorXd computeNormal() const;
 
  double getArea() const;
 
  const Eigen::VectorXd getCenter() const;
 
  double getEnclosingRadius() const;
 
  bool operator==(const Triangle &other) const;
 
  bool operator!=(const Triangle &other) const;
 
  bool operator<(const Triangle &other) const
  {
    return std::make_tuple(_vertices[0]->getID(), _vertices[1]->getID(), _vertices[2]->getID()) <
           std::make_tuple(other._vertices[0]->getID(), other._vertices[1]->getID(), other._vertices[2]->getID());
  }
  bool operator<(const Triangle &other) const {…}
 
private:
  std::array<Vertex *, 3> _vertices;
};
class Triangle {…};
 
// --------------------------------------------------------- HEADER DEFINITIONS
 
inline Vertex &Triangle::vertex(int i)
{
  PRECICE_ASSERT((i >= 0) && (i < 3), i);
  return *_vertices[i];
}
inline Vertex &Triangle::vertex(int i) {…}
 
inline const Vertex &Triangle::vertex(int i) const
{
  PRECICE_ASSERT((i >= 0) && (i < 3), i);
  return *_vertices[i];
}
inline const Vertex &Triangle::vertex(int i) const {…}
 
inline Triangle::iterator Triangle::begin()
{
  return {this, 0};
}
inline Triangle::iterator Triangle::begin() {…}
 
inline Triangle::iterator Triangle::end()
{
  return {this, 3};
}
inline Triangle::iterator Triangle::end() {…}
 
inline Triangle::const_iterator Triangle::begin() const
{
  return {this, 0};
}
inline Triangle::const_iterator Triangle::begin() const {…}
 
inline Triangle::const_iterator Triangle::end() const
{
  return {this, 3};
}
inline Triangle::const_iterator Triangle::end() const {…}
 
inline Triangle::const_iterator Triangle::cbegin() const
{
  return begin();
}
inline Triangle::const_iterator Triangle::cbegin() const {…}
 
inline Triangle::const_iterator Triangle::cend() const
{
  return end();
}
inline Triangle::const_iterator Triangle::cend() const {…}
 
std::ostream &operator<<(std::ostream &os, const Triangle &t);
 
} // namespace precice::mesh