https://mooseframework.inl.gov
PolyLineMeshGenerator.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 "PolyLineMeshGenerator.h"
11 
12 #include "CastUniquePointer.h"
13 #include "MooseMeshUtils.h"
14 #include "MooseUtils.h"
15 
16 #include "libmesh/elem.h"
17 #include "libmesh/int_range.h"
18 #include "libmesh/unstructured_mesh.h"
19 
21 
24 {
26 
27  params.addParam<std::vector<Point>>("points", "The points defining the polyline, in order");
28 
29  params.addParam<bool>("loop", false, "Whether edges should form a closed loop");
30 
31  params.addParam<BoundaryName>(
32  "start_boundary", "start", "Boundary to assign to (non-looped) polyline start");
33 
34  params.addParam<BoundaryName>(
35  "end_boundary", "end", "Boundary to assign to (non-looped) polyline end");
36 
37  params.addParam<unsigned int>(
38  "num_edges_between_points", 1, "How many Edge elements to build between each point pair");
39 
40  params.addClassDescription("Generates meshes from edges connecting a list of points.");
41 
42  return params;
43 }
44 
46  : MeshGenerator(parameters),
47  _points(getParam<std::vector<Point>>("points")),
48  _loop(getParam<bool>("loop")),
49  _start_boundary(getParam<BoundaryName>("start_boundary")),
50  _end_boundary(getParam<BoundaryName>("end_boundary")),
51  _num_edges_between_points(getParam<unsigned int>("num_edges_between_points"))
52 {
53  if (_points.size() < 2)
54  paramError("points", "At least 2 points are needed to define a polyline");
55 
56  if (_loop && _points.size() < 3)
57  paramError("points", "At least 3 points are needed to define a polygon");
58 }
59 
60 std::unique_ptr<MeshBase>
62 {
63  auto uptr_mesh = buildMeshBaseObject();
64  MeshBase & mesh = *uptr_mesh;
65 
66  const auto n_points = _points.size();
67  for (auto i : make_range(n_points))
68  {
69  Point p = _points[i];
70  mesh.add_point(p, i * _num_edges_between_points);
72  {
73  if (!_loop && (i + 1) == n_points)
74  break;
75 
76  const auto ip1 = (i + 1) % n_points;
77  const Point pvec = (_points[ip1] - p) / _num_edges_between_points;
78 
79  for (auto j : make_range(1u, _num_edges_between_points))
80  {
81  p += pvec;
82  mesh.add_point(p, i * _num_edges_between_points + j);
83  }
84  }
85  }
86 
87  const auto n_segments = _loop ? n_points : (n_points - 1);
88  const auto n_elem = n_segments * _num_edges_between_points;
89  const auto max_nodes = n_points * _num_edges_between_points;
90  for (auto i : make_range(n_elem))
91  {
92  const auto ip1 = (i + 1) % max_nodes;
93  auto elem = Elem::build(EDGE2);
94  elem->set_node(0, mesh.node_ptr(i));
95  elem->set_node(1, mesh.node_ptr(ip1));
96  elem->set_id() = i;
97  mesh.add_elem(std::move(elem));
98  }
99 
100  if (!_loop)
101  {
102  BoundaryInfo & bi = mesh.get_boundary_info();
103  std::vector<BoundaryName> bdy_names{_start_boundary, _end_boundary};
104  std::vector<boundary_id_type> ids = MooseMeshUtils::getBoundaryIDs(mesh, bdy_names, true);
105  bi.add_side(mesh.elem_ptr(0), 0, ids[0]);
106  bi.add_side(mesh.elem_ptr(n_elem - 1), 1, ids[1]);
107  }
108 
109  mesh.prepare_for_use();
110 
111  return uptr_mesh;
112 }
Generates a polyline (open ended or looped) of Edge elements through a series of nodal locations and ...
static InputParameters validParams()
dof_id_type n_elem(const MeshBase::const_element_iterator &begin, const MeshBase::const_element_iterator &end)
registerMooseObject("MooseApp", PolyLineMeshGenerator)
MeshBase & mesh
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
const BoundaryName _start_boundary
Boundary names to assign to (non-looped) polyline start and end.
PolyLineMeshGenerator(const InputParameters &parameters)
const bool _loop
Whether edges should form a closed loop.
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 paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
static InputParameters validParams()
Definition: MeshGenerator.C:23
EDGE2
const BoundaryName _end_boundary
const std::vector< Point > _points
The points defining the polyline, in order.
IntRange< T > make_range(T beg, T end)
std::unique_ptr< MeshBase > generate() override
Generate / modify the mesh.
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...
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...
std::unique_ptr< MeshBase > buildMeshBaseObject(unsigned int dim=libMesh::invalid_uint)
Build a MeshBase object whose underlying type will be determined by the Mesh input file block...
MeshGenerators are objects that can modify or add to an existing mesh.
Definition: MeshGenerator.h:32
void ErrorVector unsigned int
const unsigned int _num_edges_between_points
How many Edge elements to build between each point pair.