Index.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <vector>
 
#include "logging/Logger.hpp"
#include "mapping/Polation.hpp"
#include "mesh/BoundingBox.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"
 
namespace precice::query {
 
using MatchID = int;
 
constexpr MatchID NO_MATCH{-1};
 
using Distance = double;
constexpr double INVALID_DISTANCE{-1};
 
template <class Tag>
struct MatchType {
  MatchID index{NO_MATCH};
  MatchType() = default;
  explicit MatchType(MatchID i)
      : index(i) {};
  explicit MatchType(MatchID i) {…}
};
struct MatchType {…};
 
using GenericMatch  = MatchType<struct GenericMatchTag>;
using VertexMatch   = MatchType<struct VertexMatchTag>;
using EdgeMatch     = MatchType<struct EdgeMatchTag>;
using TriangleMatch = MatchType<struct TriangleTag>;
using TetraMatch    = MatchType<struct TetraTag>;
 
struct ProjectionMatch {
  ProjectionMatch(const mapping::Polation &p)
      : polation(p) {}
  ProjectionMatch(const mapping::Polation &p) {…}
  ProjectionMatch(mapping::Polation &&p)
      : polation(std::move(p)) {}
  ProjectionMatch(mapping::Polation &&p) {…}
 
  ProjectionMatch(const ProjectionMatch &other)            = default;
  ProjectionMatch(ProjectionMatch &&other)                 = default;
  ProjectionMatch &operator=(const ProjectionMatch &other) = default;
  ProjectionMatch &operator=(ProjectionMatch &&other)      = default;
 
  mapping::Polation polation;
 
  bool operator<(ProjectionMatch const &other) const
  {
    return polation.distance() < other.polation.distance();
  };
  bool operator<(ProjectionMatch const &other) const {…}
};
struct ProjectionMatch {…};
 
class Index {
 
public:
  Index(mesh::PtrMesh mesh);
  Index(mesh::Mesh &mesh);
  ~Index();
 
  VertexMatch getClosestVertex(const Eigen::VectorXd &sourceCoord);
 
  std::vector<VertexID> getClosestVertices(const Eigen::VectorXd &sourceCoord, int n);
 
  std::vector<EdgeMatch> getClosestEdges(const Eigen::VectorXd &sourceCoord, int n);
 
  std::vector<TriangleMatch> getClosestTriangles(const Eigen::VectorXd &sourceCoord, int n);
 
  std::vector<VertexID> getVerticesInsideBox(const mesh::Vertex &centerVertex, double radius);
 
  std::vector<VertexID> getVerticesInsideBox(const mesh::BoundingBox &bb);
 
  bool isAnyVertexInsideBox(const mesh::Vertex &centerVertex, double radius);
 
  std::vector<TetrahedronID> getEnclosingTetrahedra(const Eigen::VectorXd &location);
 
  ProjectionMatch findNearestProjection(const Eigen::VectorXd &location, int n);
 
  ProjectionMatch findCellOrProjection(const Eigen::VectorXd &location, int n);
 
  // Index tree, bounds
  mesh::BoundingBox getRtreeBounds();
 
  void clear();
 
private:
  class IndexImpl;
  std::unique_ptr<IndexImpl> _pimpl;
 
  mesh::Mesh *_mesh;
 
  static precice::logging::Logger _log;
 
  ProjectionMatch findVertexProjection(const Eigen::VectorXd &location);
 
  ProjectionMatch findEdgeProjection(const Eigen::VectorXd &location, int n, ProjectionMatch closestVertex);
 
  ProjectionMatch findTriangleProjection(const Eigen::VectorXd &location, int n, ProjectionMatch closestVertex);
};
class Index {…};
 
} // namespace precice::query