Mesh.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <deque>
#include <iosfwd>
#include <list>
#include <map>
#include <string>
#include <string_view>
#include <vector>
 
#include "logging/Logger.hpp"
#include "mesh/BoundingBox.hpp"
#include "mesh/Data.hpp"
#include "mesh/Edge.hpp"
#include "mesh/SharedPointer.hpp"
#include "mesh/Tetrahedron.hpp"
#include "mesh/Triangle.hpp"
#include "mesh/Vertex.hpp"
#include "precice/impl/Types.hpp"
#include "query/Index.hpp"
#include "utils/ManageUniqueIDs.hpp"
#include "utils/assertion.hpp"
 
namespace precice {
namespace mesh {
 
class Mesh {
public:
  using VertexContainer   = std::deque<Vertex>;
  using EdgeContainer     = std::deque<Edge>;
  using TriangleContainer = std::deque<Triangle>;
  using TetraContainer    = std::deque<Tetrahedron>;
  using DataContainer     = std::vector<PtrData>;
  using BoundingBoxMap    = std::map<int, BoundingBox>;
 
  using VertexDistribution = std::map<Rank, std::vector<VertexID>>;
 
  using CommunicationMap = std::map<Rank, std::vector<VertexID>>;
  using ConnectionMap    = CommunicationMap; // until we decide on a name
 
  using VertexOffsets = std::vector<int>;
 
  static constexpr MeshID MESH_ID_UNDEFINED{-1};
 
  Mesh(
      std::string name,
      int         dimensions,
      MeshID      id);
 
  Vertex &vertex(VertexID id);
 
  const Vertex &vertex(VertexID id) const;
 
  VertexContainer &vertices();
 
  const VertexContainer &vertices() const;
 
  std::size_t nVertices() const;
 
  bool empty() const
  {
    return _vertices.empty();
  }
 
  EdgeContainer &edges();
 
  const EdgeContainer &edges() const;
 
  bool hasEdges() const
  {
    return !_edges.empty();
  }
 
  TriangleContainer &triangles();
 
  const TriangleContainer &triangles() const;
 
  bool hasTriangles() const
  {
    return !_triangles.empty();
  }
 
  TetraContainer &tetrahedra();
 
  const TetraContainer &tetrahedra() const;
 
  bool hasTetrahedra() const
  {
    return !_tetrahedra.empty();
  }
 
  bool hasConnectivity() const
  {
    return hasEdges() || hasTriangles() || hasTetrahedra();
  }
 
  int getDimensions() const;
 
  Vertex &createVertex(const Eigen::VectorXd &coords);
 
  Edge &createEdge(
      Vertex &vertexOne,
      Vertex &vertexTwo);
 
  Triangle &createTriangle(
      Edge &edgeOne,
      Edge &edgeTwo,
      Edge &edgeThree);
 
  Triangle &createTriangle(
      Vertex &vertexOne,
      Vertex &vertexTwo,
      Vertex &vertexThree);
 
  Tetrahedron &createTetrahedron(
      Vertex &vertexOne,
      Vertex &vertexTwo,
      Vertex &vertexThree,
      Vertex &vertexFour);
 
  PtrData &createData(const std::string &name,
                      int                dimension,
                      DataID             id,
                      int                waveformDegree = time::Time::DEFAULT_WAVEFORM_DEGREE);
 
  const DataContainer &data() const;
 
  bool hasDataID(DataID dataID) const;
 
  const PtrData &data(DataID dataID) const;
 
  bool hasDataName(std::string_view dataName) const;
 
  std::vector<std::string> availableData() const;
 
  const PtrData &data(std::string_view dataName) const;
 
  const std::string &getName() const;
 
  MeshID getID() const;
 
  bool isValidVertexID(VertexID vertexID) const;
 
  void allocateDataValues(); //@todo Redesign mapping and remove this function. See https://github.com/precice/precice/issues/1651.
 
  void computeBoundingBox();
 
  void clear();
 
  void clearPartitioning();
 
  void setVertexDistribution(VertexDistribution vd)
  {
    PRECICE_ASSERT(std::all_of(vd.begin(), vd.end(), [](const auto &p) { return std::is_sorted(p.second.begin(), p.second.end()); }));
    _vertexDistribution = std::move(vd);
  }
 
  const VertexDistribution &getVertexDistribution() const
  {
    return _vertexDistribution;
  }
 
  const VertexOffsets &getVertexOffsets() const
  {
    return _vertexOffsets;
  }
 
  void setVertexOffsets(VertexOffsets vertexOffsets)
  {
    _vertexOffsets = std::move(vertexOffsets);
  }
 
  int getGlobalNumberOfVertices() const
  {
    return _globalNumberOfVertices;
  }
 
  void setGlobalNumberOfVertices(int num)
  {
    _globalNumberOfVertices = num;
  }
 
  // Get the data of owned vertices for given data ID
  Eigen::VectorXd getOwnedVertexData(const Eigen::VectorXd &values);
 
  // Tag all the vertices
  void tagAll();
 
  const std::vector<Rank> &getConnectedRanks() const
  {
    return _connectedRanks;
  }
 
  void setConnectedRanks(std::vector<Rank> ranks)
  {
    _connectedRanks = std::move(ranks);
  }
 
  CommunicationMap &getCommunicationMap()
  {
    return _communicationMap;
  }
 
  void addMesh(Mesh &deltaMesh);
 
  const BoundingBox &getBoundingBox() const;
 
  void expandBoundingBox(const BoundingBox &bounding_box);
 
  bool operator==(const Mesh &other) const;
 
  bool operator!=(const Mesh &other) const;
 
  const query::Index &index() const
  {
    return _index;
  }
 
  query::Index &index()
  {
    return _index;
  }
 
  void preprocess();
 
private:
  mutable logging::Logger _log{"mesh::Mesh"};
 
  std::string _name;
 
  int _dimensions;
 
  MeshID _id;
 
  VertexContainer   _vertices;
  EdgeContainer     _edges;
  TriangleContainer _triangles;
  TetraContainer    _tetrahedra;
 
  DataContainer _data;
 
  VertexDistribution _vertexDistribution;
 
 
  VertexOffsets _vertexOffsets;
 
  int _globalNumberOfVertices = -1;
 
  std::vector<Rank> _connectedRanks;
 
  CommunicationMap _communicationMap;
 
  BoundingBox _boundingBox;
 
  query::Index _index;
 
  void removeDuplicates();
 
  void generateImplictPrimitives();
};
 
std::ostream &operator<<(std::ostream &os, const Mesh &q);
 
} // namespace mesh
} // namespace precice