https://mooseframework.inl.gov
SideSetsFromPointsGenerator.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
11 #include "Parser.h"
12 #include "InputParameters.h"
13 #include "MooseMeshUtils.h"
14 #include "CastUniquePointer.h"
15 
16 #include "libmesh/mesh.h"
17 #include "libmesh/mesh_generation.h"
18 #include "libmesh/mesh_serializer.h"
19 #include "libmesh/string_to_enum.h"
20 #include "libmesh/quadrature_gauss.h"
21 #include "libmesh/point_locator_base.h"
22 #include "libmesh/enum_point_locator_type.h"
23 #include "libmesh/distributed_mesh.h"
24 #include "libmesh/elem.h"
25 #include "libmesh/fe_base.h"
26 #include "libmesh/mesh_tools.h"
27 
28 #include <typeinfo>
29 
31 
34 {
36 
37  params.addClassDescription("Adds a new sideset starting at the specified point containing all "
38  "connected element faces with the same normal.");
39  params.addRequiredParam<std::vector<Point>>(
40  "points", "A list of points from which to start painting sidesets");
41 
42  params.suppressParameter<Point>("normal");
43  params.suppressParameter<Real>("normal_tol");
44 
45  // It doesn't make sense to allow internal sides for this side set generator.
46  params.setParameters("include_only_external_sides", true);
47  params.suppressParameter<bool>("include_only_external_sides");
48 
49  return params;
50 }
51 
53  : SideSetsGeneratorBase(parameters), _points(getParam<std::vector<Point>>("points"))
54 {
55  if (_points.size() != _boundary_names.size())
56  mooseError("point list and boundary list are not the same length");
57  _using_normal = true;
58 }
59 
60 std::unique_ptr<MeshBase>
62 {
63  std::unique_ptr<MeshBase> mesh = std::move(_input);
64 
65  // Our flood fill doesn't do any communication, so it requires a
66  // serialized mesh
68 
69  // Get the BoundaryIDs from the mesh
70  std::vector<BoundaryID> boundary_ids =
72 
73  setup(*mesh);
74 
75  _visited.clear();
76 
77  std::unique_ptr<libMesh::PointLocatorBase> pl =
79 
80  for (const auto i : index_range(boundary_ids))
81  {
82  std::set<const Elem *> candidate_elements;
83  (*pl)(_points[i], candidate_elements);
84 
85  const Elem * elem_to_flood = nullptr;
86  Point normal_to_flood;
87 
88  for (const Elem * elem : candidate_elements)
89  for (const auto side : make_range(elem->n_sides()))
90  {
91  if (elem->neighbor_ptr(side))
92  continue;
93 
94  // See if this point is on this side
95  std::unique_ptr<const Elem> elem_side = elem->side_ptr(side);
96 
97  if (elem_side->contains_point(_points[i]))
98  {
99  // This is a good side to paint our sideset with.
100  // Get the normal.
101  const std::vector<Point> & normals = _fe_face->get_normals();
102  _fe_face->reinit(elem, side);
103 
104  // If we *already* found a good but different side to paint
105  // our sideset with, we've got an ambiguity here.
106  if (elem_to_flood && (!normalsWithinTol(normal_to_flood, normals[0], _normal_tol) ||
107  elem_to_flood->which_neighbor_am_i(elem) == libMesh::invalid_uint))
108  mooseError("Two ambiguous potential sideset sources found for boundary `",
109  _boundary_names[i],
110  "' at ",
111  _points[i],
112  ":\nElement ",
113  elem_to_flood->id(),
114  " normal ",
115  normal_to_flood,
116  " and\n",
117  ":\nElement ",
118  elem->id(),
119  " normal ",
120  normals[0]);
121 
122  elem_to_flood = elem;
123  normal_to_flood = normals[0];
124  // Don't just flood here; keep looking for possible ambiguity
125  }
126  }
127 
128  flood(elem_to_flood, normal_to_flood, boundary_ids[i], *mesh);
129  }
130 
131 #ifdef DEBUG
132  MeshTools::libmesh_assert_valid_boundary_ids(*mesh);
133 #endif
134 
135  finalize();
136 
137  for (const auto i : index_range(boundary_ids))
138  mesh->get_boundary_info().sideset_name(boundary_ids[i]) = _boundary_names[i];
139 
140  mesh->set_isnt_prepared();
141  return dynamic_pointer_cast<MeshBase>(mesh);
142 }
std::unique_ptr< MeshBase > & _input
the mesh to add the sidesets to
const unsigned int invalid_uint
const Real _normal_tol
if normal is specified, then faces are only added if face_normal.normal_hat <= 1 - normal_tol where n...
MeshBase & mesh
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
static InputParameters validParams()
bool normalsWithinTol(const Point &normal_1, const Point &normal_2, const Real &tol) const
Determines whether two normal vectors are within normal_tol of each other.
std::vector< BoundaryName > _boundary_names
The list of new boundary names.
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
registerMooseObject("MooseApp", SideSetsFromPointsGenerator)
void addRequiredParam(const std::string &name, const std::string &doc_string)
This method adds a parameter and documentation string to the InputParameters object that will be extr...
std::vector< Point > _points
holds the points used to generate sidesets
void suppressParameter(const std::string &name)
This method suppresses an inherited parameter so that it isn&#39;t required or valid in the derived class...
void flood(const Elem *elem, const Point &normal, const boundary_id_type &side_id, MeshBase &mesh)
This method implements a recursive flood routine to paint a sideset of mesh to neighboring faces give...
A mesh generator to generate new sidesets from all faces connected to points with the same normal as ...
SideSetsFromPointsGenerator(const InputParameters &parameters)
std::vector< BoundaryID > getBoundaryIDs(const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
Gets the boundary IDs with their names.
void finalize()
This method finalizes the object, setting names back in the boundary_info object and releasing memory...
static InputParameters validParams()
bool _using_normal
true if only faces close to "normal" will be added
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
IntRange< T > make_range(T beg, T end)
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...
std::unique_ptr< MeshBase > generate() override
Generate / modify the mesh.
std::map< boundary_id_type, std::set< const Elem * > > _visited
std::unique_ptr< libMesh::FEBase > _fe_face
static std::unique_ptr< PointLocatorBase > build(PointLocatorType t, const MeshBase &mesh, const PointLocatorBase *master=nullptr)
void setup(MeshBase &mesh)
This method is used to construct the FE object so we can compute normals of faces.
auto index_range(const T &sizable)
void setParameters(const std::string &name, const T &value, Ts... extra_input_parameters)
Given a series of parameters names and values, sets each name to the corresponding value...