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 "FillBetweenSidesetsGenerator.h"
11 : #include "FillBetweenPointVectorsTools.h"
12 :
13 : #include "MooseMeshUtils.h"
14 : #include "CastUniquePointer.h"
15 : #include "libmesh/node.h"
16 : #include "libmesh/mesh_serializer.h"
17 :
18 : registerMooseObject("MooseApp", FillBetweenSidesetsGenerator);
19 :
20 : InputParameters
21 14441 : FillBetweenSidesetsGenerator::validParams()
22 : {
23 14441 : InputParameters params = MeshGenerator::validParams();
24 14441 : params.addRequiredParam<MeshGeneratorName>("input_mesh_1",
25 : "The input mesh that contains boundary_1");
26 14441 : params.addRequiredParam<MeshGeneratorName>("input_mesh_2",
27 : "The input mesh that contains boundary_2");
28 14441 : params.addRequiredParam<std::vector<BoundaryName>>(
29 : "boundary_1", "the first boundary that needs to be connected.");
30 14441 : params.addRequiredParam<std::vector<BoundaryName>>(
31 : "boundary_2", "the second boundary that needs to be connected.");
32 43323 : params.addParam<Point>(
33 28882 : "mesh_1_shift", Point(0.0, 0.0, 0.0), "Translation vector to be applied to input_mesh_1");
34 43323 : params.addParam<Point>(
35 28882 : "mesh_2_shift", Point(0.0, 0.0, 0.0), "Translation vector to be applied to input_mesh_2");
36 14441 : params.addRequiredRangeCheckedParam<unsigned int>(
37 : "num_layers", "num_layers>0", "Number of layers of elements created between the boundaries.");
38 14441 : params.addParam<subdomain_id_type>("block_id", 1, "ID to be assigned to the transition layer.");
39 43323 : params.addParam<boundary_id_type>(
40 : "input_boundary_1_id",
41 28882 : 10000,
42 : "Boundary ID to be assigned to the boundary defined by positions_vector_1.");
43 43323 : params.addParam<boundary_id_type>(
44 : "input_boundary_2_id",
45 28882 : 10000,
46 : "Boundary ID to be assigned to the boundary defined by positions_vector_2.");
47 43323 : params.addParam<boundary_id_type>("begin_side_boundary_id",
48 28882 : 10000,
49 : "Boundary ID to be assigned to the boundary connecting "
50 : "starting points of the positions_vectors.");
51 43323 : params.addParam<boundary_id_type>("end_side_boundary_id",
52 28882 : 10000,
53 : "Boundary ID to be assigned to the boundary connecting ending "
54 : "points of the positions_vectors.");
55 43323 : params.addParam<bool>(
56 : "use_quad_elements",
57 28882 : false,
58 : "Whether QUAD4 instead of TRI3 elements are used to construct the transition layer.");
59 43323 : params.addRangeCheckedParam<Real>(
60 : "bias_parameter",
61 28882 : 1.0,
62 : "bias_parameter>=0",
63 : "Parameter used to set up biasing of the layers: bias_parameter > 0.0 is used as the biasing "
64 : "factor; bias_parameter = 0.0 activates automatic biasing based on local node density on "
65 : "both input boundaries.");
66 43323 : params.addRangeCheckedParam<Real>(
67 : "gaussian_sigma",
68 28882 : 3.0,
69 : "gaussian_sigma>0.0",
70 : "Gaussian parameter used to smoothen local node density for automatic biasing; this "
71 : "parameter is not used if another biasing option is selected.");
72 43323 : params.addParam<bool>(
73 : "keep_inputs",
74 28882 : true,
75 : "Whether to output the input meshes stitched with the transition layer connector.");
76 14441 : params.addClassDescription("This FillBetweenSidesetsGenerator object is designed to generate a "
77 : "transition layer to connect two boundaries of two input meshes.");
78 14441 : return params;
79 0 : }
80 :
81 90 : FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(const InputParameters & parameters)
82 : : MeshGenerator(parameters),
83 90 : _input_name_1(getParam<MeshGeneratorName>("input_mesh_1")),
84 90 : _input_name_2(getParam<MeshGeneratorName>("input_mesh_2")),
85 90 : _boundary_1(getParam<std::vector<BoundaryName>>("boundary_1")),
86 90 : _boundary_2(getParam<std::vector<BoundaryName>>("boundary_2")),
87 90 : _mesh_1_shift(getParam<Point>("mesh_1_shift")),
88 90 : _mesh_2_shift(getParam<Point>("mesh_2_shift")),
89 90 : _num_layers(getParam<unsigned int>("num_layers")),
90 90 : _block_id(getParam<subdomain_id_type>("block_id")),
91 90 : _input_boundary_1_id(getParam<boundary_id_type>("input_boundary_1_id")),
92 90 : _input_boundary_2_id(getParam<boundary_id_type>("input_boundary_2_id")),
93 90 : _begin_side_boundary_id(getParam<boundary_id_type>("begin_side_boundary_id")),
94 90 : _end_side_boundary_id(getParam<boundary_id_type>("end_side_boundary_id")),
95 90 : _use_quad_elements(getParam<bool>("use_quad_elements")),
96 90 : _bias_parameter(getParam<Real>("bias_parameter")),
97 90 : _sigma(getParam<Real>("gaussian_sigma")),
98 90 : _keep_inputs(getParam<bool>("keep_inputs")),
99 90 : _input_1(getMeshByName(_input_name_1)),
100 180 : _input_2(getMeshByName(_input_name_2))
101 : {
102 90 : if (_input_name_1.compare(_input_name_2) == 0)
103 4 : paramError("input_mesh_2", "This parameter must be different from input_mesh_1.");
104 86 : }
105 :
106 : std::unique_ptr<MeshBase>
107 83 : FillBetweenSidesetsGenerator::generate()
108 : {
109 83 : auto input_mesh_1 = std::move(_input_1);
110 83 : auto input_mesh_2 = std::move(_input_2);
111 :
112 : // Only serialized meshes are supported right now
113 83 : libMesh::MeshSerializer serial_1(*input_mesh_1);
114 83 : libMesh::MeshSerializer serial_2(*input_mesh_2);
115 :
116 166 : if (*(input_mesh_1->elem_dimensions().begin()) != 2 ||
117 166 : *(input_mesh_1->elem_dimensions().rbegin()) != 2)
118 0 : paramError("input_mesh_1", "Only 2D meshes are supported.");
119 166 : if (*(input_mesh_2->elem_dimensions().begin()) != 2 ||
120 166 : *(input_mesh_2->elem_dimensions().rbegin()) != 2)
121 0 : paramError("input_mesh_2", "Only 2D meshes are supported.");
122 :
123 83 : MeshTools::Modification::translate(
124 83 : *input_mesh_1, _mesh_1_shift(0), _mesh_1_shift(1), _mesh_1_shift(2));
125 83 : MeshTools::Modification::translate(
126 83 : *input_mesh_2, _mesh_2_shift(0), _mesh_2_shift(1), _mesh_2_shift(2));
127 :
128 : const auto input_mesh_1_external_bids =
129 83 : MooseMeshUtils::getBoundaryIDs(*input_mesh_1, _boundary_1, false);
130 : const auto input_mesh_2_external_bids =
131 83 : MooseMeshUtils::getBoundaryIDs(*input_mesh_2, _boundary_2, false);
132 :
133 135 : for (unsigned int i = 1; i < input_mesh_1_external_bids.size(); i++)
134 : {
135 52 : MooseMeshUtils::changeBoundaryId(
136 52 : *input_mesh_1, input_mesh_1_external_bids[i], input_mesh_1_external_bids.front(), true);
137 : }
138 127 : for (unsigned int i = 1; i < input_mesh_2_external_bids.size(); i++)
139 : {
140 44 : MooseMeshUtils::changeBoundaryId(
141 44 : *input_mesh_2, input_mesh_2_external_bids[i], input_mesh_2_external_bids.front(), true);
142 : }
143 :
144 83 : if (!FillBetweenPointVectorsTools::isExternalBoundary(*input_mesh_1,
145 83 : input_mesh_1_external_bids.front()))
146 0 : paramError("boundary_1", "The boundary provided is not an external boundary.");
147 83 : if (!FillBetweenPointVectorsTools::isExternalBoundary(*input_mesh_2,
148 83 : input_mesh_2_external_bids.front()))
149 0 : paramError("boundary_2", "The boundary provided is not an external boundary.");
150 :
151 : Real max_input_mesh_1_node_radius;
152 : Real max_input_mesh_2_node_radius;
153 83 : std::vector<dof_id_type> boundary_1_ordered_nodes;
154 83 : std::vector<dof_id_type> boundary_2_ordered_nodes;
155 :
156 : try
157 : {
158 166 : FillBetweenPointVectorsTools::isBoundaryOpenSingleSegment(
159 83 : *input_mesh_1,
160 : max_input_mesh_1_node_radius,
161 : boundary_1_ordered_nodes,
162 83 : MooseMeshUtils::meshCentroidCalculator(*input_mesh_1),
163 83 : input_mesh_1_external_bids.front());
164 : }
165 8 : catch (MooseException & e)
166 : {
167 8 : paramError("boundary_1", e.what());
168 0 : }
169 : try
170 : {
171 150 : FillBetweenPointVectorsTools::isBoundaryOpenSingleSegment(
172 75 : *input_mesh_2,
173 : max_input_mesh_2_node_radius,
174 : boundary_2_ordered_nodes,
175 75 : MooseMeshUtils::meshCentroidCalculator(*input_mesh_2),
176 75 : input_mesh_2_external_bids.front());
177 : }
178 0 : catch (MooseException & e)
179 : {
180 0 : paramError("boundary_2", e.what());
181 0 : }
182 :
183 75 : std::vector<Point> positions_vector_1;
184 75 : std::vector<Point> positions_vector_2;
185 :
186 652 : for (auto & boundary_1_node_id : boundary_1_ordered_nodes)
187 577 : positions_vector_1.push_back(*input_mesh_1->node_ptr(boundary_1_node_id));
188 :
189 796 : for (auto & boundary_2_node_id : boundary_2_ordered_nodes)
190 721 : positions_vector_2.push_back(*input_mesh_2->node_ptr(boundary_2_node_id));
191 :
192 0 : const boundary_id_type input_boundary_1_id = _keep_inputs ? (std::max({_input_boundary_1_id,
193 35 : _input_boundary_2_id,
194 35 : _begin_side_boundary_id,
195 35 : _end_side_boundary_id}) +
196 : 1)
197 110 : : _input_boundary_1_id;
198 40 : const boundary_id_type input_boundary_2_id =
199 75 : _keep_inputs ? (input_boundary_1_id + 1) : _input_boundary_2_id;
200 75 : auto mesh = buildReplicatedMesh(2);
201 75 : FillBetweenPointVectorsTools::fillBetweenPointVectorsGenerator(*mesh,
202 : positions_vector_1,
203 : positions_vector_2,
204 75 : _num_layers,
205 75 : _block_id,
206 : input_boundary_1_id,
207 : input_boundary_2_id,
208 75 : _begin_side_boundary_id,
209 75 : _end_side_boundary_id,
210 75 : _type,
211 75 : _name,
212 75 : _use_quad_elements,
213 75 : _bias_parameter,
214 75 : _sigma);
215 :
216 75 : if (_keep_inputs)
217 : {
218 35 : mesh->prepare_for_use();
219 70 : mesh->stitch_meshes(*input_mesh_1,
220 : input_boundary_1_id,
221 35 : input_mesh_1_external_bids.front(),
222 : TOLERANCE,
223 : true,
224 : false,
225 : true,
226 : true);
227 70 : mesh->stitch_meshes(*input_mesh_2,
228 : input_boundary_2_id,
229 35 : input_mesh_2_external_bids.front(),
230 : TOLERANCE,
231 : true,
232 : false,
233 : true,
234 : true);
235 : }
236 150 : return dynamic_pointer_cast<MeshBase>(mesh);
237 75 : }
|
