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 "MeshInfo.h"
11 : #include "SubProblem.h"
12 : #include "libmesh/system.h"
13 : #include "libmesh/equation_systems.h"
14 : #include "libmesh/parallel_sync.h"
15 :
16 : registerMooseObject("MooseApp", MeshInfo);
17 :
18 : InputParameters
19 15055 : MeshInfo::validParams()
20 : {
21 15055 : InputParameters params = GeneralReporter::validParams();
22 30110 : params.addClassDescription(
23 : "Report mesh information, such as the number of elements, nodes, and degrees of freedom.");
24 :
25 : MultiMooseEnum items(
26 : "num_dofs num_dofs_nonlinear num_dofs_auxiliary num_elements num_nodes num_local_dofs "
27 : "num_local_dofs_nonlinear num_local_dofs_auxiliary num_local_elements num_local_nodes "
28 : "local_sidesets local_sideset_elems sidesets sideset_elems local_subdomains "
29 30110 : "local_subdomain_elems subdomains subdomain_elems");
30 45165 : params.addParam<MultiMooseEnum>(
31 : "items",
32 : items,
33 : "The iteration information to output, if nothing is provided everything will be output.");
34 :
35 30110 : return params;
36 15055 : }
37 :
38 371 : MeshInfo::MeshInfo(const InputParameters & parameters)
39 : : GeneralReporter(parameters),
40 371 : _items(getParam<MultiMooseEnum>("items")),
41 1113 : _num_dofs(declareHelper<unsigned int>("num_dofs", REPORTER_MODE_REPLICATED)),
42 1113 : _num_dofs_nl(declareHelper<unsigned int>("num_dofs_nonlinear", REPORTER_MODE_REPLICATED)),
43 1113 : _num_dofs_aux(declareHelper<unsigned int>("num_dofs_auxiliary", REPORTER_MODE_REPLICATED)),
44 371 : _num_dofs_constrained(
45 1113 : declareHelper<unsigned int>("num_dofs_constrained", REPORTER_MODE_REPLICATED)),
46 1113 : _num_elem(declareHelper<unsigned int>("num_elements", REPORTER_MODE_REPLICATED)),
47 1113 : _num_node(declareHelper<unsigned int>("num_nodes", REPORTER_MODE_REPLICATED)),
48 1113 : _num_local_dofs(declareHelper<unsigned int>("num_local_dofs", REPORTER_MODE_DISTRIBUTED)),
49 371 : _num_local_dofs_nl(
50 1113 : declareHelper<unsigned int>("num_dofs_local_nonlinear", REPORTER_MODE_DISTRIBUTED)),
51 371 : _num_local_dofs_aux(
52 1113 : declareHelper<unsigned int>("num_dofs_local_auxiliary", REPORTER_MODE_DISTRIBUTED)),
53 1113 : _num_local_elem(declareHelper<unsigned int>("num_local_elements", REPORTER_MODE_DISTRIBUTED)),
54 1113 : _num_local_node(declareHelper<unsigned int>("num_local_nodes", REPORTER_MODE_DISTRIBUTED)),
55 :
56 1113 : _local_sidesets(declareHelper<std::map<BoundaryID, SidesetInfo>>("local_sidesets",
57 : REPORTER_MODE_DISTRIBUTED)),
58 1113 : _local_sideset_elems(declareHelper<std::map<BoundaryID, SidesetInfo>>(
59 : "local_sideset_elems", REPORTER_MODE_DISTRIBUTED)),
60 1113 : _sidesets(declareHelper<std::map<BoundaryID, SidesetInfo>>("sidesets", REPORTER_MODE_ROOT)),
61 371 : _sideset_elems(
62 1113 : declareHelper<std::map<BoundaryID, SidesetInfo>>("sideset_elems", REPORTER_MODE_ROOT)),
63 :
64 1113 : _local_subdomains(declareHelper<std::map<SubdomainID, SubdomainInfo>>(
65 : "local_subdomains", REPORTER_MODE_DISTRIBUTED)),
66 1113 : _local_subdomain_elems(declareHelper<std::map<SubdomainID, SubdomainInfo>>(
67 : "local_subdomain_elems", REPORTER_MODE_DISTRIBUTED)),
68 371 : _subdomains(
69 1113 : declareHelper<std::map<SubdomainID, SubdomainInfo>>("subdomains", REPORTER_MODE_ROOT)),
70 371 : _subdomain_elems(
71 1113 : declareHelper<std::map<SubdomainID, SubdomainInfo>>("subdomain_elems", REPORTER_MODE_ROOT)),
72 :
73 371 : _equation_systems(_fe_problem.es()),
74 371 : _nonlinear_system(_fe_problem.es().get_system("nl0")),
75 371 : _aux_system(_fe_problem.es().get_system("aux0")),
76 742 : _mesh(_fe_problem.mesh().getMesh())
77 : {
78 371 : }
79 :
80 : void
81 344 : MeshInfo::execute()
82 : {
83 344 : _num_dofs_nl = _nonlinear_system.n_dofs();
84 344 : _num_dofs_aux = _aux_system.n_dofs();
85 344 : _num_dofs = _equation_systems.n_dofs();
86 344 : _num_dofs_constrained = 0;
87 1032 : for (auto s : make_range(_equation_systems.n_systems()))
88 688 : _num_dofs_constrained += _equation_systems.get_system(s).n_constrained_dofs();
89 :
90 344 : _num_node = _mesh.n_nodes();
91 344 : _num_elem = _mesh.n_elem();
92 344 : _num_local_dofs_nl = _nonlinear_system.n_local_dofs();
93 344 : _num_local_dofs_aux = _aux_system.n_local_dofs();
94 344 : _num_local_dofs = _num_local_dofs_nl + _num_local_dofs_aux;
95 344 : _num_local_node = _mesh.n_local_nodes();
96 344 : _num_local_elem = _mesh.n_local_elem();
97 :
98 344 : possiblyAddSidesetInfo();
99 344 : possiblyAddSubdomainInfo();
100 344 : }
101 :
102 : void
103 344 : MeshInfo::possiblyAddSidesetInfo()
104 : {
105 : // Helper for adding the sideset names to a given map of sidesets
106 313 : auto add_sideset_names = [&](std::map<BoundaryID, SidesetInfo> & sidesets)
107 : {
108 1192 : for (auto & pair : sidesets)
109 879 : pair.second.name = _mesh.get_boundary_info().get_sideset_name(pair.second.id);
110 313 : };
111 :
112 : // Helper for sorting all of the sides in each sideset
113 224 : auto sort_sides = [](std::map<BoundaryID, SidesetInfo> & sidesets)
114 : {
115 801 : for (auto & pair : sidesets)
116 577 : std::sort(pair.second.sides.begin(), pair.second.sides.end());
117 224 : };
118 :
119 344 : const bool include_all = !_items.isValid();
120 :
121 1214 : if (include_all || _items.isValueSet("local_sidesets") ||
122 1794 : _items.isValueSet("local_sideset_elems") || _items.isValueSet("sideset_elems"))
123 : {
124 170 : _local_sidesets.clear();
125 170 : _local_sideset_elems.clear();
126 170 : _sideset_elems.clear();
127 :
128 : // Fill the local sideset information; all cases need it
129 170 : std::map<BoundaryID, SidesetInfo> sidesets;
130 170 : for (const auto & bnd_elem :
131 2984 : as_range(_fe_problem.mesh().bndElemsBegin(), _fe_problem.mesh().bndElemsEnd()))
132 2644 : if (bnd_elem->_elem->processor_id() == processor_id())
133 : {
134 1744 : auto & entry = sidesets[bnd_elem->_bnd_id];
135 1744 : entry.id = bnd_elem->_bnd_id;
136 1744 : entry.sides.emplace_back(bnd_elem->_elem->id(), bnd_elem->_side);
137 170 : }
138 :
139 : // For local sidesets: copy over the local info, remove the sides, and add the names
140 402 : if (include_all || _items.isValueSet("local_sidesets"))
141 : {
142 : // Copy over the local sideset info, remove the sides, and add the names
143 54 : _local_sidesets = sidesets;
144 216 : for (auto & pair : _local_sidesets)
145 162 : pair.second.sides.clear();
146 54 : add_sideset_names(_local_sidesets);
147 : }
148 :
149 : // For local sideset elems: copy over the local info, and add the names
150 402 : if (include_all || _items.isValueSet("local_sideset_elems"))
151 : {
152 54 : _local_sideset_elems = sidesets;
153 54 : sort_sides(_local_sideset_elems);
154 54 : add_sideset_names(_local_sideset_elems);
155 : }
156 :
157 : // For the global sideset elems, we need to communicate all of the elems
158 402 : if (include_all || _items.isValueSet("sideset_elems"))
159 : {
160 : // Set up a structure for sending each (id, elem id, side) tuple to root
161 : std::map<processor_id_type,
162 : std::vector<std::tuple<boundary_id_type, dof_id_type, unsigned int>>>
163 170 : send_info;
164 170 : auto & root_info = send_info[0];
165 691 : for (const auto & pair : sidesets)
166 2265 : for (const auto & side : pair.second.sides)
167 1744 : root_info.emplace_back(pair.second.id, side.first, side.second);
168 :
169 : // Take the received information and insert it into _sideset_elems
170 : auto accumulate_info =
171 170 : [this](processor_id_type,
172 : const std::vector<std::tuple<boundary_id_type, dof_id_type, unsigned int>> & info)
173 : {
174 1914 : for (const auto & tuple : info)
175 : {
176 1744 : const auto id = std::get<0>(tuple);
177 1744 : auto & entry = _sideset_elems[id];
178 1744 : entry.id = id;
179 1744 : entry.sides.emplace_back(std::get<1>(tuple), std::get<2>(tuple));
180 : }
181 170 : };
182 :
183 : // Push the information and insert it into _sideset_elems on root
184 170 : Parallel::push_parallel_vector_data(comm(), send_info, accumulate_info);
185 :
186 170 : sort_sides(_sideset_elems);
187 170 : add_sideset_names(_sideset_elems);
188 170 : }
189 170 : }
190 :
191 : // For global sideset information without elements, we can simplify communication.
192 : // All we need are the boundary IDs from libMesh (may not be reduced, so take the union)
193 : // and then add the names (global)
194 924 : if (include_all || _items.isValueSet("sidesets"))
195 : {
196 64 : _sidesets.clear();
197 :
198 64 : auto boundary_ids = _mesh.get_boundary_info().get_boundary_ids();
199 64 : comm().set_union(boundary_ids, 0);
200 64 : if (processor_id() == 0)
201 : {
202 175 : for (const auto id : boundary_ids)
203 140 : _sidesets[id].id = id;
204 35 : add_sideset_names(_sidesets);
205 : }
206 64 : }
207 344 : }
208 :
209 : void
210 478 : to_json(nlohmann::json & json, const std::map<BoundaryID, MeshInfo::SidesetInfo> & sidesets)
211 : {
212 1303 : for (const auto & pair : sidesets)
213 : {
214 825 : const MeshInfo::SidesetInfo & sideset_info = pair.second;
215 :
216 825 : nlohmann::json sideset_json;
217 825 : sideset_json["id"] = sideset_info.id;
218 825 : if (sideset_info.name.size())
219 825 : sideset_json["name"] = sideset_info.name;
220 825 : if (sideset_info.sides.size())
221 : {
222 550 : auto & sides_json = sideset_json["sides"];
223 :
224 3194 : for (const std::pair<dof_id_type, unsigned int> & pair : sideset_info.sides)
225 : {
226 2644 : nlohmann::json side_json;
227 2644 : side_json["elem_id"] = pair.first;
228 2644 : side_json["side"] = pair.second;
229 2644 : sides_json.push_back(side_json);
230 2644 : }
231 : }
232 :
233 825 : json.push_back(sideset_json);
234 825 : }
235 478 : }
236 :
237 : void
238 95 : dataStore(std::ostream & stream, MeshInfo::SidesetInfo & sideset_info, void * context)
239 : {
240 95 : storeHelper(stream, sideset_info.id, context);
241 95 : storeHelper(stream, sideset_info.name, context);
242 95 : storeHelper(stream, sideset_info.sides, context);
243 95 : }
244 :
245 : void
246 95 : dataLoad(std::istream & stream, MeshInfo::SidesetInfo & sideset_info, void * context)
247 : {
248 95 : loadHelper(stream, sideset_info.id, context);
249 95 : loadHelper(stream, sideset_info.name, context);
250 95 : loadHelper(stream, sideset_info.sides, context);
251 95 : }
252 :
253 : void
254 344 : MeshInfo::possiblyAddSubdomainInfo()
255 : {
256 : // Helper for adding the subdomain names to a given map of subdomains
257 242 : auto add_subdomain_names = [&](std::map<SubdomainID, SubdomainInfo> & subdomains)
258 : {
259 690 : for (auto & pair : subdomains)
260 448 : pair.second.name = _mesh.subdomain_name(pair.second.id);
261 242 : };
262 :
263 : // Helper for sorting all of the elems in each subdomain
264 153 : auto sort_elems = [](std::map<SubdomainID, SubdomainInfo> & subdomains)
265 : {
266 504 : for (auto & pair : subdomains)
267 351 : std::sort(pair.second.elems.begin(), pair.second.elems.end());
268 153 : };
269 :
270 344 : const bool include_all = !_items.isValid();
271 :
272 1214 : if (include_all || _items.isValueSet("local_subdomains") ||
273 1794 : _items.isValueSet("local_subdomain_elems") || _items.isValueSet("subdomain_elems"))
274 : {
275 150 : _local_subdomains.clear();
276 150 : _local_subdomain_elems.clear();
277 150 : _subdomain_elems.clear();
278 :
279 : // Fill the local subdomain information; all cases need it
280 150 : std::map<SubdomainID, SubdomainInfo> subdomains;
281 4002 : for (const auto & elem : *_fe_problem.mesh().getActiveLocalElementRange())
282 : {
283 3852 : auto & entry = subdomains[elem->subdomain_id()];
284 3852 : entry.id = elem->subdomain_id();
285 3852 : entry.elems.push_back(elem->id());
286 : }
287 :
288 : // For local subdomains: copy over the local info, remove the elems, and add the names
289 342 : if (include_all || _items.isValueSet("local_subdomains"))
290 : {
291 54 : _local_subdomains = subdomains;
292 108 : for (auto & pair : _local_subdomains)
293 54 : pair.second.elems.clear();
294 54 : add_subdomain_names(_local_subdomains);
295 : }
296 :
297 : // For local subdomain elems: copy over the local info, and add the names
298 342 : if (include_all || _items.isValueSet("local_subdomain_elems"))
299 : {
300 54 : _local_subdomain_elems = subdomains;
301 54 : sort_elems(_local_subdomain_elems);
302 54 : add_subdomain_names(_local_subdomain_elems);
303 : }
304 :
305 : // For the global subdomain elems, we need to communicate all of the elems
306 342 : if (include_all || _items.isValueSet("subdomain_elems"))
307 : {
308 : // Set up a structure for sending each (id, elem id) to root
309 150 : std::map<processor_id_type, std::vector<std::pair<subdomain_id_type, dof_id_type>>> send_info;
310 150 : auto & root_info = send_info[0];
311 480 : for (const auto & pair : subdomains)
312 4182 : for (const auto elem_id : pair.second.elems)
313 3852 : root_info.emplace_back(pair.second.id, elem_id);
314 :
315 : // Take the received information and insert it into _subdomain_elems
316 : auto accumulate_info =
317 150 : [this](processor_id_type,
318 : const std::vector<std::pair<subdomain_id_type, dof_id_type>> & info)
319 : {
320 4002 : for (const auto & subdomain_elem_pair : info)
321 : {
322 3852 : auto & entry = _subdomain_elems[subdomain_elem_pair.first];
323 3852 : entry.id = subdomain_elem_pair.first;
324 3852 : entry.elems.emplace_back(subdomain_elem_pair.second);
325 : }
326 150 : };
327 :
328 : // Push the information and insert it into _subdomain_elems on root
329 150 : Parallel::push_parallel_vector_data(comm(), send_info, accumulate_info);
330 :
331 150 : if (processor_id() == 0)
332 : {
333 99 : sort_elems(_subdomain_elems);
334 99 : add_subdomain_names(_subdomain_elems);
335 : }
336 150 : }
337 150 : }
338 :
339 : // For global subdomain information without elements, we can simplify communication.
340 : // All we need are the subdomain IDs from libMesh and then add the names (global)
341 924 : if (include_all || _items.isValueSet("subdomains"))
342 : {
343 64 : _subdomains.clear();
344 :
345 64 : std::set<subdomain_id_type> subdomain_ids;
346 64 : _mesh.subdomain_ids(subdomain_ids);
347 :
348 64 : if (processor_id() == 0)
349 : {
350 78 : for (const auto id : subdomain_ids)
351 43 : _subdomains[id].id = id;
352 35 : add_subdomain_names(_subdomains);
353 : }
354 64 : }
355 344 : }
356 :
357 : void
358 448 : to_json(nlohmann::json & json, const std::map<SubdomainID, MeshInfo::SubdomainInfo> & subdomains)
359 : {
360 878 : for (const auto & pair : subdomains)
361 : {
362 430 : const MeshInfo::SubdomainInfo & subdomain_info = pair.second;
363 :
364 430 : nlohmann::json subdomain_json;
365 430 : subdomain_json["id"] = subdomain_info.id;
366 430 : if (subdomain_info.name.size())
367 286 : subdomain_json["name"] = subdomain_info.name;
368 430 : if (subdomain_info.elems.size())
369 : {
370 342 : auto & sides_json = subdomain_json["elems"];
371 6444 : for (const auto & id : subdomain_info.elems)
372 6102 : sides_json.push_back(id);
373 : }
374 :
375 430 : json.push_back(subdomain_json);
376 430 : }
377 448 : }
378 :
379 : void
380 50 : dataStore(std::ostream & stream, MeshInfo::SubdomainInfo & subdomain_info, void * context)
381 : {
382 50 : storeHelper(stream, subdomain_info.id, context);
383 50 : storeHelper(stream, subdomain_info.name, context);
384 50 : storeHelper(stream, subdomain_info.elems, context);
385 50 : }
386 :
387 : void
388 50 : dataLoad(std::istream & stream, MeshInfo::SubdomainInfo & subdomain_info, void * context)
389 : {
390 50 : loadHelper(stream, subdomain_info.id, context);
391 50 : loadHelper(stream, subdomain_info.name, context);
392 50 : loadHelper(stream, subdomain_info.elems, context);
393 50 : }
|
