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::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,
      bool        isJustInTime = false);

  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::Ref<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);

  PtrData &createData(const std::string                 &name,
                      int                                dimension,
                      DataID                             id,
                      int                                waveformDegree,
                      std::vector<std::optional<double>> lowerBound,
                      std::vector<std::optional<double>> upperBound);

  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 clearDataStamples();
 
  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;
  }

  bool isPartitionEmpty(Rank rank) const;

  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;
  }
 
  bool isJustInTime() const
  {
    return _isJustInTime;
  }

  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;

  bool _isJustInTime = false;
 
  BoundingBox _boundingBox;
 
  query::Index _index;

  void removeDuplicates();

  void generateImplictPrimitives();
};
 
std::ostream &operator<<(std::ostream &os, const Mesh &q);
 
} // namespace precice::mesh