Vertex.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <array>
#include <iostream>
#include <utility>
 
#include "math/differences.hpp"
#include "precice/impl/Types.hpp"
#include "utils/assertion.hpp"
 
namespace precice {
namespace mesh {
 
class Vertex {
public:
  //( Used as the raw representation of the coordinates
  using RawCoords = std::array<double, 3>;
 
  template <typename VECTOR_T>
  Vertex(
      const VECTOR_T &coordinates,
      VertexID        id);
 
  int getDimensions() const;
 
  template <typename VECTOR_T>
  void setCoords(const VECTOR_T &coordinates);
 
  VertexID getID() const;
 
  Eigen::VectorXd getCoords() const;
 
  const RawCoords &rawCoords() const;
 
  int getGlobalIndex() const;
 
  void setGlobalIndex(int globalIndex);
 
  bool isOwner() const;
 
  void setOwner(bool owner);
 
  bool isTagged() const;
 
  void tag();
 
  inline double coord(int index) const;
 
  inline bool operator==(const Vertex &rhs) const;
 
  inline bool operator!=(const Vertex &rhs) const;
 
  inline bool operator<(const Vertex &rhs) const;
 
private:
  std::array<double, 3> _coords;
 
  short _dim;
 
  VertexID _id;
 
  int _globalIndex = -1;
 
  bool _owner = true;
 
  bool _tagged = false;
};
 
// ------------------------------------------------------ HEADER IMPLEMENTATION
 
template <typename VECTOR_T>
Vertex::Vertex(
    const VECTOR_T &coordinates,
    int             id)
    : _dim(coordinates.size()),
      _id(id)
{
  PRECICE_ASSERT(_dim == 2 || _dim == 3, _dim);
  _coords[0] = coordinates[0];
  _coords[1] = coordinates[1];
  _coords[2] = (_dim == 3) ? coordinates[2] : 0.0;
}
 
template <typename VECTOR_T>
void Vertex::setCoords(
    const VECTOR_T &coordinates)
{
  PRECICE_ASSERT(coordinates.size() == _dim, coordinates.size(), _dim);
  _coords[0] = coordinates[0];
  _coords[1] = coordinates[1];
  _coords[2] = (_dim == 3) ? coordinates[2] : 0.0;
}
 
inline VertexID Vertex::getID() const
{
  return _id;
}
 
inline Eigen::VectorXd Vertex::getCoords() const
{
  Eigen::VectorXd v(_dim);
  std::copy_n(_coords.data(), _dim, v.data());
  return v;
}
 
inline const Vertex::RawCoords &Vertex::rawCoords() const
{
  return _coords;
}
 
inline double Vertex::coord(int index) const
{
  PRECICE_ASSERT(0 <= index && index < _dim, index, _dim);
  return _coords.at(index);
}
 
inline bool Vertex::operator==(const Vertex &rhs) const
{
  return math::equals(getCoords(), rhs.getCoords());
}
 
inline bool Vertex::operator!=(const Vertex &rhs) const
{
  return !(*this == rhs);
}
 
inline bool Vertex::operator<(const Vertex &rhs) const
{
  return _id < rhs._id;
}
 
std::ostream &operator<<(std::ostream &os, const Vertex &v);
 
} // namespace mesh
} // namespace precice