MeshBuilderBase.cpp

#include <mesh/MeshBuilderBase.hpp>

#include <mesh/Connectivity.hpp>
#include <mesh/ConnectivityDescriptor.hpp>
#include <mesh/ConnectivityDispatcher.hpp>
#include <mesh/ItemId.hpp>
#include <mesh/Mesh.hpp>
#include <mesh/MeshData.hpp>
#include <mesh/MeshDataManager.hpp>
#include <utils/PugsAssert.hpp>
#include <utils/PugsMacros.hpp>

#include <vector>

template <size_t Dimension>
void
MeshBuilderBase::_dispatch()
{
  if (parallel::size() == 1) {
    return;
  }

  using ConnectivityType = Connectivity<Dimension>;
  using Rd               = TinyVector<Dimension>;
  using MeshType         = Mesh<ConnectivityType>;

  if (not m_mesh) {
    ConnectivityDescriptor descriptor;
    std::shared_ptr connectivity = ConnectivityType::build(descriptor);
    NodeValue<Rd> xr;
    m_mesh = std::make_shared<MeshType>(connectivity, xr);
  }

  const MeshType& mesh = dynamic_cast<const MeshType&>(*m_mesh);
  ConnectivityDispatcher<Dimension> dispatcher(mesh.connectivity());

  std::shared_ptr dispatched_connectivity = dispatcher.dispatchedConnectivity();
  NodeValue<Rd> dispatched_xr             = dispatcher.dispatch(mesh.xr());

  m_mesh = std::make_shared<MeshType>(dispatched_connectivity, dispatched_xr);
}

template void MeshBuilderBase::_dispatch<1>();
template void MeshBuilderBase::_dispatch<2>();
template void MeshBuilderBase::_dispatch<3>();

template <size_t Dimension>
void
MeshBuilderBase::_checkMesh() const
{
  using ConnectivityType = Connectivity<Dimension>;
  using MeshType         = Mesh<ConnectivityType>;

  if (not m_mesh) {
    throw UnexpectedError("mesh is not built yet");
  }

  const MeshType& mesh = dynamic_cast<const MeshType&>(*m_mesh);

  const ConnectivityType& connectivity = mesh.connectivity();

  if constexpr (Dimension > 2) {   // check for duplicated edges
    auto edge_to_node_matrix = connectivity.edgeToNodeMatrix();

    std::vector<std::vector<EdgeId>> node_edges(mesh.numberOfNodes());
    for (EdgeId edge_id = 0; edge_id < mesh.numberOfEdges(); ++edge_id) {
      auto node_list = edge_to_node_matrix[edge_id];
      for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
        node_edges[node_list[i_node]].push_back(edge_id);
      }