https://mooseframework.inl.gov
ParsedGenerateSideset.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 
10 #include "ParsedGenerateSideset.h"
11 #include "Conversion.h"
12 #include "MooseMeshUtils.h"
13 #include "CastUniquePointer.h"
14 
15 #include "libmesh/fparser_ad.hh"
16 #include "libmesh/distributed_mesh.h"
17 #include "libmesh/elem.h"
18 #include "libmesh/fe_base.h"
19 
20 #include <typeinfo>
21 
23 
26 {
29 
30  params.addRequiredParam<std::string>("combinatorial_geometry",
31  "Function expression encoding a combinatorial geometry");
32  params.addRequiredParam<BoundaryName>("new_sideset_name", "The name of the new sideset");
33 
34  params.addParam<std::vector<std::string>>(
35  "constant_names", {}, "Vector of constants used in the parsed function");
36  params.addParam<std::vector<std::string>>(
37  "constant_expressions",
38  {},
39  "Vector of values for the constants in constant_names (can be an FParser expression)");
40 
41  // This sideset generator can only handle a single new sideset name, not a vector of names
42  params.suppressParameter<std::vector<BoundaryName>>("new_boundary");
43 
44  params.addClassDescription(
45  "A MeshGenerator that adds element sides to a sideset if the centroid of the side satisfies "
46  "the `combinatorial_geometry` expression.");
47 
48  return params;
49 }
50 
52  : SideSetsGeneratorBase(parameters),
53  FunctionParserUtils<false>(parameters),
54  _function(parameters.get<std::string>("combinatorial_geometry"))
55 {
56  _boundary_names.push_back(getParam<BoundaryName>("new_sideset_name"));
57 
58  // Create parsed function
59  _func_F = std::make_shared<SymFunction>();
61  _function,
62  "x,y,z",
63  getParam<std::vector<std::string>>("constant_names"),
64  getParam<std::vector<std::string>>("constant_expressions"),
65  comm());
66 
67  _func_params.resize(3);
68 }
69 
70 std::unique_ptr<MeshBase>
72 {
73  std::unique_ptr<MeshBase> mesh = std::move(_input);
74  if (!mesh->is_replicated())
76  "ParsedGenerateSideset is not implemented for distributed meshes. Make sure the "
77  "parsed sideset does NOT cross any mesh distribution boundaries, using the ProcessorAux");
78 
79  setup(*mesh);
80 
81  // Get a reference to our BoundaryInfo object for later use
82  BoundaryInfo & boundary_info = mesh->get_boundary_info();
83 
84  // Get the BoundaryIDs from the mesh
85  std::vector<boundary_id_type> boundary_ids =
87  mooseAssert(boundary_ids.size() == 1, "Length of boundary_ids should be one");
88 
89  for (const auto & elem : mesh->active_element_ptr_range())
90  {
91  // check if the element is included
93  continue;
94 
95  for (const auto side : make_range(elem->n_sides()))
96  {
97  _fe_face->reinit(elem, side);
98  // We'll just use the normal of the first qp
99  const Point & face_normal = _fe_face->get_normals()[0];
100 
101  if (!elemSideSatisfiesRequirements(elem, side, *mesh, _normal, face_normal))
102  continue;
103 
104  // check expression
105  std::unique_ptr<Elem> curr_side = elem->side_ptr(side);
106  _func_params[0] = curr_side->vertex_average()(0);
107  _func_params[1] = curr_side->vertex_average()(1);
108  _func_params[2] = curr_side->vertex_average()(2);
109  if (evaluate(_func_F))
110  {
111  if (_replace)
112  boundary_info.remove_side(elem, side);
113  boundary_info.add_side(elem, side, boundary_ids[0]);
114  }
115  }
116  }
117  finalize();
118  boundary_info.sideset_name(boundary_ids[0]) = _boundary_names[0];
119 
120  mesh->set_isnt_prepared();
121  return dynamic_pointer_cast<MeshBase>(mesh);
122 }
bool elementSubdomainIdInList(const Elem *const elem, const std::vector< subdomain_id_type > &subdomain_id_list) const
Determines whether the given element&#39;s subdomain id is in the given subdomain_id_list.
GenericReal< is_ad > evaluate(SymFunctionPtr &, const std::string &object_name="")
Evaluate FParser object and check EvalError.
SymFunctionPtr _func_F
function parser object describing the combinatorial geometry
bool elemSideSatisfiesRequirements(const Elem *const elem, const unsigned int side, const MeshBase &mesh, const Point &normal, const Point &face_normal)
Determines whether the given element&#39;s side satisfies the following parameters: include_only_external...
std::unique_ptr< MeshBase > generate() override
Generate / modify the mesh.
std::unique_ptr< MeshBase > & _input
the mesh to add the sidesets to
ParsedGenerateSideset(const InputParameters &parameters)
std::string _function
function expression
Point _normal
if specified, then faces are only added if their normal is close to this
static InputParameters validParams()
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
Definition: MooseUtils.h:1155
MeshBase & mesh
const bool _replace
Whether or not to remove the old sidesets (all of them, if any) when adding sidesets.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
const Parallel::Communicator & comm() const
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.
MeshGenerator for defining a sideset by a parsed expression and optionally by considering additional ...
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
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...
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...
std::vector< subdomain_id_type > _included_subdomain_ids
A list of included subdomain ids that the side has to be part of, extracted from the included_subdoma...
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
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 parsedFunctionSetup(SymFunctionPtr &function, const std::string &expression, const std::string &variables, const std::vector< std::string > &constant_names, const std::vector< std::string > &constant_expressions, const libMesh::Parallel::Communicator &comm) const
Performs setup steps on a SymFunction.
void finalize()
This method finalizes the object, setting names back in the boundary_info object and releasing memory...
static InputParameters validParams()
const bool _check_subdomains
whether to check subdomain ids of the element in the (element, side, boundary id) tuple when adding s...
std::vector< GenericReal< is_ad > > _func_params
Array to stage the parameters passed to the functions when calling Eval.
IntRange< T > make_range(T beg, T end)
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...
static InputParameters validParams()
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
registerMooseObject("MooseApp", ParsedGenerateSideset)
std::unique_ptr< libMesh::FEBase > _fe_face
void setup(MeshBase &mesh)
This method is used to construct the FE object so we can compute normals of faces.