MooseMeshUtils.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "libmesh/replicated_mesh.h"
#include "libmesh/boundary_info.h"
 
#include "MooseUtils.h"
#include "MooseTypes.h"
#include "FaceInfo.h"
#include "MeshGenerator.h"
 
// Utilities for MeshBase
// Many of these utilities could live in libMesh, and in fact, before adding a new one here
// you should also check mesh_tools.h in libMesh to see if it does not exist there already.
 
namespace MooseMeshUtils
{
 
// Used to temporarily store information about which lower-dimensional
// sides to add and what subdomain id to use for the added sides.
struct ElemSidePair
{
  ElemSidePair(Elem * elem_in, unsigned short int side_in) : elem(elem_in), side(side_in) {}
 
  Elem * elem;
  unsigned short int side;
};
 
void mergeBoundaryIDsWithSameName(MeshBase & mesh);
 
void changeBoundaryId(MeshBase & mesh,
                      const libMesh::boundary_id_type old_id,
                      const libMesh::boundary_id_type new_id,
                      bool delete_prev);
 
void
changeSubdomainId(MeshBase & mesh, const subdomain_id_type old_id, const subdomain_id_type new_id);
 
std::vector<BoundaryID> getBoundaryIDs(const libMesh::MeshBase & mesh,
                                       const std::vector<BoundaryName> & boundary_name,
                                       bool generate_unknown,
                                       const std::set<BoundaryID> & mesh_boundary_ids);
 
std::vector<BoundaryID> getBoundaryIDs(const libMesh::MeshBase & mesh,
                                       const std::vector<BoundaryName> & boundary_name,
                                       bool generate_unknown);
 
std::set<BoundaryID> getBoundaryIDSet(const libMesh::MeshBase & mesh,
                                      const std::vector<BoundaryName> & boundary_name,
                                      bool generate_unknown);
 
BoundaryID getBoundaryID(const BoundaryName & boundary_name, const MeshBase & mesh);
 
std::set<std::pair<BoundaryName, BoundaryID>>
getAllBoundaryNamesAndIDs(const libMesh::MeshBase & mesh);
 
SubdomainID getSubdomainID(const SubdomainName & subdomain_name, const MeshBase & mesh);
 
std::vector<subdomain_id_type> getSubdomainIDs(const libMesh::MeshBase & mesh,
                                               const std::vector<SubdomainName> & subdomain_name);
std::set<subdomain_id_type> getSubdomainIDs(const libMesh::MeshBase & mesh,
                                            const std::set<SubdomainName> & subdomain_name);
 
std::set<std::pair<SubdomainName, SubdomainID>>
getAllSubdomainNamesAndIDs(const libMesh::MeshBase & mesh);
 
Point meshCentroidCalculator(const MeshBase & mesh);
 
Point boundaryCentroidCalculator(const BoundaryName & boundary, MeshBase & mesh);
 
RealVectorValue boundaryWeightedNormal(const BoundaryName & boundary, MeshBase & mesh);
 
template <typename P, typename C>
void
coordTransformFactor(const P & point,
                     C & factor,
                     const Moose::CoordinateSystemType coord_type,
                     const unsigned int rz_radial_coord = libMesh::invalid_uint)
{
  switch (coord_type)
  {
    case Moose::COORD_XYZ:
      factor = 1.0;
      break;
    case Moose::COORD_RZ:
    {
      mooseAssert(rz_radial_coord != libMesh::invalid_uint,
                  "Must pass in a valid rz radial coordinate");
      factor = 2 * M_PI * point(rz_radial_coord);
      break;
    }
    case Moose::COORD_RSPHERICAL:
      factor = 4 * M_PI * point(0) * point(0);
      break;
    default:
      mooseError("Unknown coordinate system");
  }
}
 
template <typename P, typename C>
C
computeDistanceToAxis(const P & point, const Point & origin, const RealVectorValue & direction)
{
  return (point - origin).cross(direction).norm();
}
 
Real computeMaxDistanceToAxis(const MeshBase & mesh,
                              const Point & origin,
                              const RealVectorValue & direction);
 
template <typename P, typename C>
void
coordTransformFactorRZGeneral(const P & point,
                              const std::pair<Point, RealVectorValue> & axis,
                              C & factor)
{
  factor = 2 * M_PI * computeDistanceToAxis<P, C>(point, axis.first, axis.second);
}
 
inline void
computeFiniteVolumeCoords(FaceInfo & fi,
                          const Moose::CoordinateSystemType coord_type,
                          const unsigned int rz_radial_coord = libMesh::invalid_uint)
{
  coordTransformFactor(fi.faceCentroid(), fi.faceCoord(), coord_type, rz_radial_coord);
}
 
std::unordered_map<dof_id_type, dof_id_type>
getExtraIDUniqueCombinationMap(const MeshBase & mesh,
                               const std::set<SubdomainID> & block_ids,
                               std::vector<ExtraElementIDName> extra_ids);
 
bool isCoPlanar(const std::vector<Point> & vec_pts, const Point plane_nvec, const Point fixed_pt);
 
bool isCoPlanar(const std::vector<Point> & vec_pts, const Point plane_nvec);
 
bool isCoPlanar(const std::vector<Point> & vec_pts);
 
SubdomainID getNextFreeSubdomainID(MeshBase & input_mesh);
 
BoundaryID getNextFreeBoundaryID(MeshBase & input_mesh);
 
bool hasSubdomainID(const MeshBase & input_mesh, const SubdomainID & id);
 
bool hasSubdomainName(const MeshBase & input_mesh, const SubdomainName & name);
 
bool hasBoundaryID(const MeshBase & input_mesh, const BoundaryID id);
 
bool hasBoundaryName(const MeshBase & mesh, const BoundaryName & name);
 
bool hasBoundaryNameOrID(const MeshBase & mesh, const BoundaryName & name_or_id);
 
void makeOrderedNodeList(std::vector<std::pair<dof_id_type, dof_id_type>> & node_assm,
                         std::vector<dof_id_type> & elem_id_list,
                         std::vector<dof_id_type> & midpoint_node_list,
                         std::vector<dof_id_type> & ordered_node_list,
                         std::vector<dof_id_type> & ordered_elem_id_list);
 
void makeOrderedNodeList(std::vector<std::pair<dof_id_type, dof_id_type>> & node_assm,
                         std::vector<dof_id_type> & elem_id_list,
                         std::vector<dof_id_type> & ordered_node_list,
                         std::vector<dof_id_type> & ordered_elem_id_list);
 
template <typename T, typename Q>
Q
getIDFromName(const T & name)
{
  if (!MooseUtils::isDigits(name))
    mooseError(
        "'name' ", name, " should only contain digits that can be converted to a numerical type.");
  long long id = std::stoll(name);
  Q id_Q = Q(id);
  if (id < std::numeric_limits<Q>::min() || id > std::numeric_limits<Q>::max())
    mooseError(MooseUtils::prettyCppType<T>(&name),
               " ",
               name,
               " is not within the numeric limits of the expected ID type ",
               MooseUtils::prettyCppType<Q>(&id_Q),
               ".");
 
  return id_Q;
}
 
void swapNodesInElem(Elem & elem, const unsigned int nd1, const unsigned int nd2);
 
template <typename T>
void
idSwapParametersProcessor(const std::string & class_name,
                          const std::string & id_name,
                          const std::vector<std::vector<T>> & id_swaps,
                          std::vector<std::unordered_map<T, T>> & id_swap_pairs,
                          const unsigned int row_index_shift = 0)
{
  id_swap_pairs.resize(id_swaps.size());
  for (const auto i : index_range(id_swaps))
  {
    const auto & swaps = id_swaps[i];
    auto & swap_pairs = id_swap_pairs[i];
 
    if (swaps.size() % 2)
      throw MooseException("Row ",
                           row_index_shift + i + 1,
                           " of ",
                           id_name,
                           " in ",
                           class_name,
                           " does not contain an even number of entries! Num entries: ",
                           swaps.size());
 
    swap_pairs.reserve(swaps.size() / 2);
    for (unsigned int j = 0; j < swaps.size(); j += 2)
      swap_pairs[swaps[j]] = swaps[j + 1];
  }
}
 
void extraElemIntegerSwapParametersProcessor(
    const std::string & class_name,
    const unsigned int num_sections,
    const unsigned int num_integers,
    const std::vector<std::vector<std::vector<dof_id_type>>> & elem_integers_swaps,
    std::vector<std::unordered_map<dof_id_type, dof_id_type>> & elem_integers_swap_pairs);
 
std::unique_ptr<ReplicatedMesh> buildBoundaryMesh(const MeshBase & input_mesh,
                                                  const boundary_id_type boundary_id);
 
std::unique_ptr<ReplicatedMesh> buildLoopBoundaryOf2DMesh(const MeshBase & input_mesh,
                                                          const boundary_id_type boundary_id);
 
std::unordered_map<dof_id_type, std::unordered_set<dof_id_type>>
buildBoundaryNodeToElemMap(const MeshBase & input_mesh, const boundary_id_type boundary_id);
 
std::set<dof_id_type> getBoundaryNodes(const MeshBase & mesh, const BoundaryID boundary_id);
 
void createSubdomainFromSidesets(MeshBase & mesh,
                                 std::vector<BoundaryName> boundary_names,
                                 const SubdomainID new_subdomain_id,
                                 const SubdomainName & new_subdomain_name);
 
void convertBlockToMesh(MeshBase & source_mesh,
                        MeshBase & target_mesh,
                        const std::vector<SubdomainName> & target_blocks);
 
void copyIntoMesh(MeshGenerator & mg,
                  UnstructuredMesh & destination,
                  const UnstructuredMesh & source,
                  const bool avoid_merging_subdomains,
                  const bool avoid_merging_boundaries,
                  const Parallel::Communicator & communicator);
 
void buildPolyLineMesh(MeshBase & mesh,
                       const std::vector<Point> & points,
                       const bool loop,
                       const BoundaryName & start_boundary,
                       const BoundaryName & end_boundary,
                       const std::vector<unsigned int> & nums_edges_between_points);
 
void buildPolyLineMesh(MeshBase & mesh,
                       const std::vector<Point> & points,
                       const std::vector<Point> & mid_points,
                       const bool loop,
                       const BoundaryName & start_boundary,
                       const BoundaryName & end_boundary,
                       const std::vector<unsigned int> & nums_edges_between_points);
 
void buildPolyLineMesh(MeshBase & mesh,
                       const std::vector<Point> & points,
                       const bool loop,
                       const BoundaryName & start_boundary,
                       const BoundaryName & end_boundary,
                       const Real max_elem_size);
 
void addExternalBoundary(MeshBase & mesh, const BoundaryID extern_bid, bool & has_external_bid);
 
std::vector<unsigned int> nodalQuadraturePointToNodeMap(const Elem & elem,
                                                        const std::vector<Point> & q_points);
}