Line data    Source code

       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             : 
      20             : registerMooseObject("MooseApp", PolyLineMeshGenerator);
      21             : 
      22             : InputParameters
      23       15125 : PolyLineMeshGenerator::validParams()
      24             : {
      25       15125 :   InputParameters params = MeshGenerator::validParams();
      26             : 
      27       15125 :   params.addParam<std::vector<Point>>("points", "The points defining the polyline, in order");
      28             : 
      29       15125 :   params.addParam<bool>("loop", false, "Whether edges should form a closed loop");
      30             : 
      31       15125 :   params.addParam<BoundaryName>(
      32             :       "start_boundary", "start", "Boundary to assign to (non-looped) polyline start");
      33             : 
      34       15125 :   params.addParam<BoundaryName>(
      35             :       "end_boundary", "end", "Boundary to assign to (non-looped) polyline end");
      36             : 
      37       45375 :   params.addParam<unsigned int>(
      38       30250 :       "num_edges_between_points", 1, "How many Edge elements to build between each point pair");
      39             : 
      40       15125 :   params.addClassDescription("Generates meshes from edges connecting a list of points.");
      41             : 
      42       15125 :   return params;
      43           0 : }
      44             : 
      45         430 : PolyLineMeshGenerator::PolyLineMeshGenerator(const InputParameters & parameters)
      46             :   : MeshGenerator(parameters),
      47         430 :     _points(getParam<std::vector<Point>>("points")),
      48         430 :     _loop(getParam<bool>("loop")),
      49         430 :     _start_boundary(getParam<BoundaryName>("start_boundary")),
      50         430 :     _end_boundary(getParam<BoundaryName>("end_boundary")),
      51         860 :     _num_edges_between_points(getParam<unsigned int>("num_edges_between_points"))
      52             : {
      53         430 :   if (_points.size() < 2)
      54           0 :     paramError("points", "At least 2 points are needed to define a polyline");
      55             : 
      56         430 :   if (_loop && _points.size() < 3)
      57           0 :     paramError("points", "At least 3 points are needed to define a polygon");
      58         430 : }
      59             : 
      60             : std::unique_ptr<MeshBase>
      61         417 : PolyLineMeshGenerator::generate()
      62             : {
      63         417 :   auto uptr_mesh = buildMeshBaseObject();
      64         417 :   MeshBase & mesh = *uptr_mesh;
      65             : 
      66         417 :   const auto n_points = _points.size();
      67        2091 :   for (auto i : make_range(n_points))
      68             :   {
      69        1685 :     Point p = _points[i];
      70        1685 :     mesh.add_point(p, i * _num_edges_between_points);
      71        1685 :     if (_num_edges_between_points > 1)
      72             :     {
      73         110 :       if (!_loop && (i + 1) == n_points)
      74          11 :         break;
      75             : 
      76          99 :       const auto ip1 = (i + 1) % n_points;
      77          99 :       const Point pvec = (_points[ip1] - p) / _num_edges_between_points;
      78             : 
      79         319 :       for (auto j : make_range(1u, _num_edges_between_points))
      80             :       {
      81         220 :         p += pvec;
      82         220 :         mesh.add_point(p, i * _num_edges_between_points + j);
      83             :       }
      84             :     }
      85             :   }
      86             : 
      87         417 :   const auto n_segments = _loop ? n_points : (n_points - 1);
      88         417 :   const auto n_elem = n_segments * _num_edges_between_points;
      89         417 :   const auto max_nodes = n_points * _num_edges_between_points;
      90        2277 :   for (auto i : make_range(n_elem))
      91             :   {
      92        1860 :     const auto ip1 = (i + 1) % max_nodes;
      93        1860 :     auto elem = Elem::build(EDGE2);
      94        1860 :     elem->set_node(0, mesh.node_ptr(i));
      95        1860 :     elem->set_node(1, mesh.node_ptr(ip1));
      96        1860 :     elem->set_id() = i;
      97        1860 :     mesh.add_elem(std::move(elem));
      98        1860 :   }
      99             : 
     100         417 :   if (!_loop)
     101             :   {
     102          45 :     BoundaryInfo & bi = mesh.get_boundary_info();
     103         135 :     std::vector<BoundaryName> bdy_names{_start_boundary, _end_boundary};
     104          45 :     std::vector<boundary_id_type> ids = MooseMeshUtils::getBoundaryIDs(mesh, bdy_names, true);
     105          45 :     bi.add_side(mesh.elem_ptr(0), 0, ids[0]);
     106          45 :     bi.add_side(mesh.elem_ptr(n_elem - 1), 1, ids[1]);
     107          45 :   }
     108             : 
     109         417 :   mesh.prepare_for_use();
     110             : 
     111         417 :   return uptr_mesh;
     112          45 : }