MeshContext.hpp

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include "MappingContext.hpp"
#include "SharedPointer.hpp"
#include "com/Communication.hpp"
#include "mapping/Mapping.hpp"
#include "mesh/SharedPointer.hpp"
#include "partition/ReceivedPartition.hpp"
#include "partition/SharedPointer.hpp"
 
namespace precice::impl {

struct MeshContext {
  void require(mapping::Mapping::MeshRequirement requirement);

  mesh::PtrMesh mesh;

  mapping::Mapping::MeshRequirement meshRequirement = mapping::Mapping::MeshRequirement::UNDEFINED;

  std::string receiveMeshFrom;

  double safetyFactor = -1;

  bool allowDirectAccess = false;

  std::shared_ptr<mesh::BoundingBox> userDefinedAccessRegion;

  bool provideMesh = false;

  partition::ReceivedPartition::GeometricFilter geoFilter = partition::ReceivedPartition::GeometricFilter::UNDEFINED;

  partition::PtrPartition partition;

  std::vector<MappingContext> fromMappingContexts;

  std::vector<MappingContext> toMappingContexts;

  void checkVerticesInsideAccessRegion(precice::span<const double> coordinates, const int meshDim, std::string_view functionName) const;
 
  std::vector<std::reference_wrapper<const mesh::Vertex>> filterVerticesToLocalAccessRegion(bool requiresBB) const;
 
  void clearMappings()
  {
    for (auto &mc : fromMappingContexts) {
      mc.mapping->clear();
    }
    for (auto &mc : toMappingContexts) {
      mc.mapping->clear();
    }
  }
 
private:
  mutable logging::Logger _log{"impl::MeshContext"};
};
 
inline void MeshContext::require(mapping::Mapping::MeshRequirement requirement)
{
  meshRequirement = std::max(meshRequirement, requirement);
}
 
inline void MeshContext::checkVerticesInsideAccessRegion(precice::span<const double> coordinates, const int meshDim, std::string_view functionName) const
{
 
  if (userDefinedAccessRegion) {
    const auto                        nVertices = (coordinates.size() / meshDim);
    Eigen::Map<const Eigen::MatrixXd> C(coordinates.data(), meshDim, nVertices);
    Eigen::VectorXd                   minCoeffs = C.rowwise().minCoeff();
    Eigen::VectorXd                   maxCoeffs = C.rowwise().maxCoeff();
    bool                              minCheck  = (minCoeffs.array() >= userDefinedAccessRegion->minCorner().array()).all();
    bool                              maxCheck  = (maxCoeffs.array() <= userDefinedAccessRegion->maxCorner().array()).all();
    PRECICE_CHECK(minCheck && maxCheck, "The provided coordinates in \"{}\" are not within the access region defined with \"setMeshAccessRegion()\". "
                                        "Minimum corner of the provided values is (x,y,z) = ({}), the minimum corner of the access region box is (x,y,z) = ({}). "
                                        "Maximum corner of the provided values is (x,y,z) = ({}), the maximum corner of the access region box is (x,y,z) = ({}). ",
                  functionName, minCoeffs, userDefinedAccessRegion->minCorner(), maxCoeffs, userDefinedAccessRegion->maxCorner());
    C.colwise().maxCoeff();
  }
}
 
inline std::vector<std::reference_wrapper<const mesh::Vertex>> MeshContext::filterVerticesToLocalAccessRegion(bool requiresBB) const
{
  std::vector<std::reference_wrapper<const mesh::Vertex>> filteredVertices;
  for (const auto &v : mesh->vertices()) {
    // either the vertex lies within the region OR the user-defined region is not strictly necessary
    if (userDefinedAccessRegion) {
      // region is defined: only add if the vertex is inside the region
      if (userDefinedAccessRegion->contains(v)) {
        filteredVertices.push_back(std::cref(v));
      }
    } else if (!requiresBB) {
      // region is not defined, so if filtering isn't required, add all vertices
      filteredVertices.push_back(std::cref(v));
    }
  }
  return filteredVertices;
}
 
} // namespace precice::impl