Loading [MathJax]/extensions/tex2jax.js
https://mooseframework.inl.gov
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
BreakMeshByElementGenerator.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 "CastUniquePointer.h"
12 #include "MooseMeshUtils.h"
13 
14 #include "libmesh/partitioner.h"
15 
18  ExplodeMeshGenerator,
19  "05/18/2024 24:00",
21 
24 {
26  params.addClassDescription("Break all element-element interfaces in the specified subdomains.");
27  params.addRequiredParam<MeshGeneratorName>("input", "The mesh we want to modify");
28  params.addParam<std::vector<SubdomainID>>("subdomains", "The list of subdomain IDs to explode.");
29  params.addRequiredParam<BoundaryName>(
30  "interface_name", "The boundary name containing all broken element-element interfaces.");
31  return params;
32 }
33 
35  : MeshGenerator(parameters),
36  _input(getMesh("input")),
37  _subdomains(getParam<std::vector<SubdomainID>>("subdomains")),
38  _interface_name(getParam<BoundaryName>("interface_name"))
39 {
40 }
41 
42 std::unique_ptr<MeshBase>
44 {
45  std::unique_ptr<MeshBase> mesh = std::move(_input);
46 
47  // check that the subdomain IDs exist in the mesh
48  for (const auto & id : _subdomains)
50  paramError("subdomains", "The block ID '", id, "' was not found in the mesh");
51 
52  BoundaryInfo & boundary_info = mesh->get_boundary_info();
53  if (boundary_info.get_id_by_name(_interface_name) != Moose::INVALID_BOUNDARY_ID)
54  paramError("interface_name", "The specified interface name already exits in the mesh.");
55 
56  const auto node_to_elem_map = buildSubdomainRestrictedNodeToElemMap(mesh, _subdomains);
57 
58  duplicateNodes(mesh, node_to_elem_map);
59 
60  createInterface(*mesh, node_to_elem_map);
61 
62  Partitioner::set_node_processor_ids(*mesh);
63 
64  return dynamic_pointer_cast<MeshBase>(mesh);
65 }
66 
69  std::unique_ptr<MeshBase> & mesh, const std::vector<SubdomainID> & subdomains) const
70 {
71  NodeToElemMapType node_to_elem_map;
72  for (const auto & elem : mesh->active_element_ptr_range())
73  {
74  // Skip if the element is not in the specified subdomains
75  if (std::find(subdomains.begin(), subdomains.end(), elem->subdomain_id()) == subdomains.end())
76  continue;
77 
78  std::set<const Elem *> neighbors;
79  elem->find_point_neighbors(neighbors);
80 
81  for (auto n : make_range(elem->n_nodes()))
82  {
83  // if ANY neighboring element that contains this node is not in the specified subdomains,
84  // don't add this node to the map, i.e. don't split this node.
85  bool should_duplicate = true;
86  for (auto neighbor : neighbors)
87  if (neighbor->contains_point(elem->node_ref(n)) &&
88  std::find(subdomains.begin(), subdomains.end(), neighbor->subdomain_id()) ==
89  subdomains.end())
90  {
91  should_duplicate = false;
92  break;
93  }
94 
95  if (should_duplicate)
96  node_to_elem_map[elem->node_id(n)].insert(elem->id());
97  }
98  }
99 
100  return node_to_elem_map;
101 }
102 
103 void
104 BreakMeshByElementGenerator::duplicateNodes(std::unique_ptr<MeshBase> & mesh,
105  const NodeToElemMapType & node_to_elem_map) const
106 {
107  for (const auto & [node_id, connected_elem_ids] : node_to_elem_map)
108  for (auto & connected_elem_id : connected_elem_ids)
109  if (connected_elem_id != *connected_elem_ids.begin())
110  duplicateNode(mesh, mesh->elem_ptr(connected_elem_id), mesh->node_ptr(node_id));
111 }
112 
113 void
114 BreakMeshByElementGenerator::duplicateNode(std::unique_ptr<MeshBase> & mesh,
115  Elem * elem,
116  const Node * node) const
117 {
118  std::unique_ptr<Node> new_node = Node::build(*node, Node::invalid_id);
119  new_node->processor_id() = elem->processor_id();
120  Node * added_node = mesh->add_node(std::move(new_node));
121  for (const auto j : elem->node_index_range())
122  if (elem->node_id(j) == node->id())
123  {
124  elem->set_node(j, added_node);
125  break;
126  }
127 
128  // Add boundary info to the new node
129  BoundaryInfo & boundary_info = mesh->get_boundary_info();
130  std::vector<boundary_id_type> node_boundary_ids;
131  boundary_info.boundary_ids(node, node_boundary_ids);
132  boundary_info.add_node(added_node, node_boundary_ids);
133 }
134 
135 void
137  const NodeToElemMapType & node_to_elem_map) const
138 {
139  BoundaryInfo & boundary_info = mesh.get_boundary_info();
140  const auto & existing_boundary_ids = boundary_info.get_boundary_ids();
141  boundary_id_type interface_id =
142  existing_boundary_ids.empty() ? 0 : *existing_boundary_ids.rbegin() + 1;
143  boundary_info.sideset_name(interface_id) = _interface_name;
144 
145  std::set<std::pair<dof_id_type, unsigned int>> sides_to_add;
146 
147  for (const auto & node_to_elems : node_to_elem_map)
148  for (const auto & elem_id_i : node_to_elems.second)
149  {
150  Elem * elem_i = mesh.elem_ptr(elem_id_i);
151  for (const auto & elem_id_j : node_to_elems.second)
152  {
153  Elem * elem_j = mesh.elem_ptr(elem_id_j);
154  if (elem_i != elem_j && elem_id_i < elem_id_j && elem_i->has_neighbor(elem_j))
155  sides_to_add.insert(std::make_pair(elem_id_i, elem_i->which_neighbor_am_i(elem_j)));
156  }
157  }
158 
159  for (const auto & [elem_id, side] : sides_to_add)
160  boundary_info.add_side(elem_id, side, interface_id);
161 }
std::map< const dof_id_type, std::set< dof_id_type > > NodeToElemMapType
NodeToElemMapType buildSubdomainRestrictedNodeToElemMap(std::unique_ptr< MeshBase > &mesh, const std::vector< SubdomainID > &subdomains) const
const BoundaryID INVALID_BOUNDARY_ID
Definition: MooseTypes.C:22
static InputParameters validParams()
MeshBase & mesh
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
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", BreakMeshByElementGenerator)
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...
bool hasSubdomainID(const MeshBase &input_mesh, const SubdomainID &id)
Whether a particular subdomain ID exists in the mesh.
int8_t boundary_id_type
std::unique_ptr< MeshBase > & _input
The mesh to modify.
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
registerMooseObjectRenamed("MooseApp", ExplodeMeshGenerator, "05/18/2024 24:00", BreakMeshByElementGenerator)
void duplicateNode(std::unique_ptr< MeshBase > &mesh, Elem *elem, const Node *node) const
IntRange< T > make_range(T beg, T end)
void duplicateNodes(std::unique_ptr< MeshBase > &mesh, const NodeToElemMapType &node_to_elem_map) const
std::unique_ptr< MeshBase > generate() override
Generate / modify the mesh.
BreakMeshByElementGenerator(const InputParameters &parameters)
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...
const std::vector< SubdomainID > & _subdomains
MeshGenerators are objects that can modify or add to an existing mesh.
Definition: MeshGenerator.h:32
void createInterface(MeshBase &mesh, const NodeToElemMapType &node_to_elem_map) const