Vertex.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <algorithm>
#include <array>
#include <iostream>
#include <utility>
 
#include "math/differences.hpp"
#include "precice/impl/Types.hpp"
#include "utils/assertion.hpp"
 
namespace precice::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 setTagged(bool tagged);
 
  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.fill(0.0);
  std::copy_n(coordinates.begin(), _dim, _coords.data());
}
 
template <typename VECTOR_T>
void Vertex::setCoords(
    const VECTOR_T &coordinates)
{
  PRECICE_ASSERT(coordinates.size() == _dim, coordinates.size(), _dim);
  _coords.fill(0.0);
  std::copy_n(coordinates.begin(), _dim, _coords.data());
}
 
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 precice::mesh