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 : // MOOSE includes
11 : #include "ConsoleUtils.h"
12 :
13 : #include "AuxiliarySystem.h"
14 : #include "Conversion.h"
15 : #include "Executioner.h"
16 : #include "MoosePreconditioner.h"
17 : #include "FEProblem.h"
18 : #include "MooseApp.h"
19 : #include "MooseMesh.h"
20 : #include "MooseObject.h"
21 : #include "NonlinearSystem.h"
22 : #include "OutputWarehouse.h"
23 : #include "SystemInfo.h"
24 : #include "Checkpoint.h"
25 : #include "InputParameterWarehouse.h"
26 : #include "Registry.h"
27 : #include "CommandLine.h"
28 : #include "Split.h"
29 :
30 : #include <filesystem>
31 :
32 : #include "libmesh/string_to_enum.h"
33 : #include "libmesh/simple_range.h"
34 :
35 : using namespace libMesh;
36 :
37 : namespace ConsoleUtils
38 : {
39 :
40 : std::string
41 28043 : indent(unsigned int spaces)
42 : {
43 56086 : return std::string(spaces, ' ');
44 : }
45 :
46 : std::string
47 90211 : outputFrameworkInformation(const MooseApp & app)
48 : {
49 90211 : std::stringstream oss;
50 90211 : oss << std::left;
51 :
52 90211 : oss << app.getSystemInfo().getInfo();
53 :
54 90211 : oss << "Input File(s):\n";
55 180698 : for (const auto & entry : app.getInputFileNames())
56 90487 : oss << " " << std::filesystem::absolute(entry).c_str() << "\n";
57 90211 : oss << "\n";
58 :
59 90211 : const auto & cl = std::as_const(*app.commandLine());
60 : // We skip the 0th argument of the main app, i.e., the name used to invoke the program
61 : const auto cl_range =
62 180422 : as_range(std::next(cl.getEntries().begin(), app.multiAppLevel() == 0), cl.getEntries().end());
63 :
64 90211 : std::stringstream args_oss;
65 788424 : for (const auto & entry : cl_range)
66 698213 : if (!entry.hit_param && !entry.subapp_name && entry.name != "-i")
67 468872 : args_oss << " " << cl.formatEntry(entry) << "\n";
68 90211 : if (args_oss.str().size())
69 86697 : oss << "Command Line Argument(s):\n" << args_oss.str() << "\n";
70 :
71 90211 : std::stringstream input_args_oss;
72 788424 : for (const auto & entry : cl_range)
73 698213 : if (entry.hit_param && !entry.subapp_name)
74 153329 : input_args_oss << " " << cl.formatEntry(entry) << "\n";
75 90211 : if (input_args_oss.str().size())
76 79216 : oss << "Command Line Input Argument(s):\n" << input_args_oss.str() << "\n";
77 :
78 90211 : const auto checkpoints = app.getOutputWarehouse().getOutputs<Checkpoint>();
79 90211 : if (checkpoints.size())
80 : {
81 75526 : oss << std::left << "Checkpoint:\n";
82 75526 : oss << checkpoints[0]->checkpointInfo().str();
83 75526 : oss << std::endl;
84 : }
85 :
86 90211 : oss << std::left << "Parallelism:\n"
87 : << std::setw(console_field_width)
88 90211 : << " Num Processors: " << static_cast<std::size_t>(app.n_processors()) << '\n'
89 : << std::setw(console_field_width)
90 90211 : << " Num Threads: " << static_cast<std::size_t>(libMesh::n_threads()) << std::endl;
91 :
92 180422 : return oss.str();
93 90211 : }
94 :
95 : std::string
96 55772 : outputMeshInformation(FEProblemBase & problem, bool verbose)
97 : {
98 55772 : std::stringstream oss;
99 55772 : oss << std::left;
100 :
101 55772 : const MooseMesh & mesh = problem.mesh();
102 :
103 55772 : const auto fe_backend = problem.feBackend();
104 :
105 55772 : if (verbose)
106 : {
107 55409 : oss << "\nMesh: " << '\n' << std::setw(console_field_width);
108 :
109 55409 : oss << " Parallel Type: " << (mesh.isDistributedMesh() ? "distributed" : "replicated");
110 55409 : if (fe_backend == Moose::FEBackend::LibMesh)
111 : {
112 55098 : bool forced = mesh.isParallelTypeForced();
113 55098 : bool pre_split = mesh.isSplit();
114 54472 : oss << (forced || pre_split ? " (" : "") << (forced ? "forced" : "")
115 626 : << (forced && pre_split ? ", " : "") << (pre_split ? "pre-split" : "")
116 110196 : << (forced || pre_split ? ")" : "");
117 : }
118 55409 : oss << '\n';
119 55409 : oss << std::setw(console_field_width) << " Mesh Dimension: " << mesh.dimension() << '\n'
120 55409 : << std::setw(console_field_width) << " Spatial Dimension: " << mesh.spatialDimension()
121 55409 : << '\n';
122 : }
123 :
124 : // Nodes, only associated with the mesh in libMesh
125 55772 : if (fe_backend == Moose::FEBackend::LibMesh)
126 : {
127 55461 : if (mesh.n_processors() > 1)
128 : {
129 25432 : dof_id_type nnodes = mesh.nNodes();
130 25432 : dof_id_type nnodes_local = mesh.nLocalNodes();
131 : oss << std::setw(console_field_width) << " Nodes:" << '\n'
132 25432 : << std::setw(console_field_width) << " Total:" << nnodes << '\n';
133 25432 : oss << std::setw(console_field_width) << " Local:" << nnodes_local << '\n';
134 25432 : dof_id_type min_nnodes = nnodes_local, max_nnodes = nnodes_local;
135 25432 : mesh.comm().min(min_nnodes);
136 25432 : mesh.comm().max(max_nnodes);
137 25432 : if (mesh.processor_id() == 0)
138 11886 : oss << std::setw(console_field_width) << " Min/Max/Avg:" << min_nnodes << '/'
139 11886 : << max_nnodes << '/' << nnodes / mesh.n_processors() << '\n';
140 : }
141 : else
142 30029 : oss << std::setw(console_field_width) << " Nodes:" << mesh.nNodes() << '\n';
143 : }
144 :
145 : // Elements
146 55772 : if (mesh.n_processors() > 1)
147 : {
148 25480 : dof_id_type nelems = mesh.nActiveElem();
149 25480 : dof_id_type nelems_local = mesh.nActiveLocalElem();
150 : oss << std::setw(console_field_width) << " Elems:" << '\n'
151 25480 : << std::setw(console_field_width) << " Total:" << nelems << '\n';
152 25480 : oss << std::setw(console_field_width) << " Local:" << nelems_local << '\n';
153 25480 : dof_id_type min_nelems = nelems_local, max_nelems = nelems_local;
154 25480 : mesh.comm().min(min_nelems);
155 25480 : mesh.comm().max(max_nelems);
156 25480 : if (mesh.processor_id() == 0)
157 11910 : oss << std::setw(console_field_width) << " Min/Max/Avg:" << min_nelems << '/' << max_nelems
158 11910 : << '/' << nelems / mesh.n_processors() << '\n';
159 : }
160 : else
161 30292 : oss << std::setw(console_field_width) << " Elems:" << mesh.nActiveElem() << '\n';
162 :
163 : // P-refinement
164 55772 : if (fe_backend == Moose::FEBackend::LibMesh)
165 : {
166 55461 : if (mesh.maxPLevel() > 0)
167 : oss << std::setw(console_field_width)
168 42 : << " Max p-Refinement Level: " << static_cast<std::size_t>(mesh.maxPLevel()) << '\n';
169 55461 : if (mesh.maxHLevel() > 0)
170 : oss << std::setw(console_field_width)
171 6393 : << " Max h-Refinement Level: " << static_cast<std::size_t>(mesh.maxHLevel()) << '\n';
172 : }
173 :
174 55772 : if (verbose)
175 : {
176 : oss << std::setw(console_field_width)
177 55409 : << " Num Subdomains: " << static_cast<std::size_t>(mesh.nSubdomains()) << '\n';
178 55409 : if (mesh.n_processors() > 1 && fe_backend == Moose::FEBackend::LibMesh)
179 : {
180 : oss << std::setw(console_field_width)
181 25258 : << " Num Partitions: " << static_cast<std::size_t>(mesh.nPartitions()) << '\n'
182 25258 : << std::setw(console_field_width) << " Partitioner: " << mesh.partitionerName()
183 25258 : << (mesh.isPartitionerForced() ? " (forced) " : "") << '\n';
184 25258 : if (mesh.skipPartitioning())
185 700 : oss << std::setw(console_field_width) << " Skipping all partitioning!" << '\n';
186 24558 : else if (mesh.skipNoncriticalPartitioning())
187 0 : oss << std::setw(console_field_width) << " Skipping noncritical partitioning!" << '\n';
188 : }
189 : }
190 :
191 55772 : oss << std::endl;
192 :
193 111544 : return oss.str();
194 55772 : }
195 :
196 : std::string
197 55772 : outputAuxiliarySystemInformation(FEProblemBase & problem)
198 : {
199 55772 : return outputSystemInformationHelper(problem.getAuxiliarySystem().system());
200 : }
201 :
202 : std::string
203 111819 : outputSystemInformationHelper(std::stringstream & oss, System & system)
204 : {
205 111819 : oss << std::left;
206 :
207 111819 : if (system.n_dofs())
208 : {
209 69575 : oss << std::setw(console_field_width) << " Num DOFs: " << system.n_dofs() << '\n'
210 69575 : << std::setw(console_field_width) << " Num Local DOFs: " << system.n_local_dofs() << '\n';
211 :
212 69575 : if (system.n_constrained_dofs())
213 : {
214 : oss << std::setw(console_field_width)
215 1246 : << " Num Constrained DOFs: " << system.n_constrained_dofs() << '\n'
216 : << std::setw(console_field_width)
217 1246 : << " Local Constrained DOFs: " << system.n_local_constrained_dofs() << '\n';
218 : }
219 :
220 69575 : std::streampos begin_string_pos = oss.tellp();
221 69575 : std::streampos curr_string_pos = begin_string_pos;
222 69575 : oss << std::setw(console_field_width) << " Variables: ";
223 159092 : for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
224 : {
225 89517 : const VariableGroup & vg_description(system.variable_group(vg));
226 :
227 89517 : if (vg_description.n_variables() > 1)
228 15442 : oss << "{ ";
229 89517 : if (vg_description.n_variables() > 10)
230 : {
231 : // when the number of variables in this group is larger than 10, we only output the first
232 : // and the last 5 variable names
233 3252 : for (unsigned int vn = 0; vn < 5; vn++)
234 : {
235 2710 : oss << "\"" << vg_description.name(vn) << "\" ";
236 2710 : curr_string_pos = oss.tellp();
237 2710 : insertNewline(oss, begin_string_pos, curr_string_pos);
238 : }
239 542 : oss << "... ";
240 542 : curr_string_pos = oss.tellp();
241 542 : insertNewline(oss, begin_string_pos, curr_string_pos);
242 3252 : for (unsigned int vn = vg_description.n_variables() - 5; vn < vg_description.n_variables();
243 : vn++)
244 : {
245 2710 : oss << "\"" << vg_description.name(vn) << "\" ";
246 2710 : curr_string_pos = oss.tellp();
247 2710 : insertNewline(oss, begin_string_pos, curr_string_pos);
248 : }
249 : }
250 : else
251 204520 : for (unsigned int vn = 0; vn < vg_description.n_variables(); vn++)
252 : {
253 115545 : oss << "\"" << vg_description.name(vn) << "\" ";
254 115545 : curr_string_pos = oss.tellp();
255 115545 : insertNewline(oss, begin_string_pos, curr_string_pos);
256 : }
257 :
258 89517 : if (vg_description.n_variables() > 1)
259 15442 : oss << "} ";
260 : }
261 69575 : oss << '\n';
262 :
263 69575 : begin_string_pos = oss.tellp();
264 69575 : curr_string_pos = begin_string_pos;
265 69575 : oss << std::setw(console_field_width) << " Finite Element Types: ";
266 : #ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
267 159092 : for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
268 : {
269 : oss << "\""
270 89517 : << libMesh::Utility::enum_to_string<FEFamily>(
271 89517 : system.get_dof_map().variable_group(vg).type().family)
272 179034 : << "\" ";
273 89517 : curr_string_pos = oss.tellp();
274 89517 : insertNewline(oss, begin_string_pos, curr_string_pos);
275 : }
276 69575 : oss << '\n';
277 : #else
278 : for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
279 : {
280 : oss << "\""
281 : << libMesh::Utility::enum_to_string<FEFamily>(
282 : system.get_dof_map().variable_group(vg).type().family)
283 : << "\", \""
284 : << libMesh::Utility::enum_to_string<FEFamily>(
285 : system.get_dof_map().variable_group(vg).type().radial_family)
286 : << "\" ";
287 : curr_string_pos = oss.tellp();
288 : insertNewline(oss, begin_string_pos, curr_string_pos);
289 : }
290 : oss << '\n';
291 :
292 : begin_string_pos = oss.tellp();
293 : curr_string_pos = begin_string_pos;
294 : oss << std::setw(console_field_width) << " Infinite Element Mapping: ";
295 : for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
296 : {
297 : oss << "\""
298 : << libMesh::Utility::enum_to_string<InfMapType>(
299 : system.get_dof_map().variable_group(vg).type().inf_map)
300 : << "\" ";
301 : curr_string_pos = oss.tellp();
302 : insertNewline(oss, begin_string_pos, curr_string_pos);
303 : }
304 : oss << '\n';
305 : #endif
306 :
307 69575 : begin_string_pos = oss.tellp();
308 69575 : curr_string_pos = begin_string_pos;
309 69575 : oss << std::setw(console_field_width) << " Approximation Orders: ";
310 159092 : for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
311 : {
312 : #ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
313 : oss << "\""
314 179034 : << Utility::enum_to_string<Order>(system.get_dof_map().variable_group(vg).type().order)
315 179034 : << "\" ";
316 : #else
317 : oss << "\""
318 : << Utility::enum_to_string<Order>(system.get_dof_map().variable_group(vg).type().order)
319 : << "\", \""
320 : << Utility::enum_to_string<Order>(
321 : system.get_dof_map().variable_group(vg).type().radial_order)
322 : << "\" ";
323 : #endif
324 89517 : curr_string_pos = oss.tellp();
325 89517 : insertNewline(oss, begin_string_pos, curr_string_pos);
326 : }
327 69575 : oss << "\n" << std::endl;
328 : }
329 :
330 111819 : return oss.str();
331 : }
332 :
333 : std::string
334 56047 : outputSolverSystemInformation(FEProblemBase & problem, const unsigned int sys_num)
335 : {
336 56047 : std::stringstream oss;
337 56047 : oss << std::left;
338 :
339 112094 : return outputSystemInformationHelper(oss, problem.getSolverSystem(sys_num).system());
340 56047 : }
341 :
342 : std::string
343 55772 : outputSystemInformationHelper(System & system)
344 : {
345 55772 : std::stringstream oss;
346 :
347 111544 : return outputSystemInformationHelper(oss, system);
348 55772 : }
349 :
350 : std::string
351 102 : outputRelationshipManagerInformation(const MooseApp & app)
352 : {
353 102 : std::stringstream oss;
354 102 : oss << std::left;
355 :
356 102 : auto info_strings = app.getRelationshipManagerInfo();
357 102 : if (info_strings.size())
358 : {
359 636 : for (const auto & info_pair : info_strings)
360 : oss << std::setw(console_field_width)
361 1068 : << " " + MooseUtils::underscoreToCamelCase(MooseUtils::toLower(info_pair.first), true) +
362 : ":"
363 1068 : << info_pair.second << '\n';
364 102 : oss << std::endl;
365 : }
366 :
367 204 : return oss.str();
368 102 : }
369 :
370 : std::string
371 55409 : outputExecutionInformation(const MooseApp & app, FEProblemBase & problem)
372 : {
373 :
374 55409 : std::stringstream oss;
375 55409 : oss << std::left;
376 :
377 55409 : Executioner * exec = app.getExecutioner();
378 :
379 : oss << "Execution Information:\n"
380 55409 : << std::setw(console_field_width) << " Executioner: " << exec->type() << '\n';
381 :
382 55409 : std::string time_stepper = exec->getTimeStepperName();
383 55409 : if (time_stepper != "")
384 25775 : oss << std::setw(console_field_width) << " TimeStepper: " << time_stepper << '\n';
385 55409 : const auto time_integrator_names = exec->getTimeIntegratorNames();
386 55409 : if (!time_integrator_names.empty())
387 : oss << std::setw(console_field_width)
388 77007 : << " TimeIntegrator(s): " << MooseUtils::join(time_integrator_names, " ") << '\n';
389 :
390 : oss << std::setw(console_field_width)
391 166227 : << std::string(" Solver") +
392 110818 : (problem.feBackend() == Moose::FEBackend::LibMesh ? " Mode" : "") + ": ";
393 111093 : for (const std::size_t i : make_range(problem.numSolverSystems()))
394 221636 : oss << (problem.numSolverSystems() > 1 ? "[" + problem.getSolverSystemNames()[i] + "]: " : "")
395 55684 : << problem.solverTypeString(i) << " ";
396 55409 : oss << '\n';
397 :
398 : // Check for a selection of common PETSc pc options on the command line for
399 : // all solver systems and all field splits within each nonlinear system
400 55409 : std::string pc_desc;
401 111093 : for (const std::size_t i : make_range(problem.numSolverSystems()))
402 : {
403 111368 : std::vector<std::string> splits = {""};
404 55684 : if (problem.isSolverSystemNonlinear(i))
405 54829 : for (const auto & split : problem.getNonlinearSystemBase(i).getSplits().getObjects())
406 485 : splits.push_back("fieldsplit_" + split->name() + "_");
407 :
408 111853 : for (const std::string & split : splits)
409 : {
410 56169 : std::string pc_desc_split;
411 56169 : const std::string prefix = problem.solverParams(i)._prefix + split;
412 553178 : for (const auto & entry : std::as_const(*app.commandLine()).getEntries())
413 1491027 : if (entry.name == prefix + "pc_type" || entry.name == prefix + "sub_pc_type" ||
414 1491027 : entry.name == prefix + "pc_hypre_type" || entry.name == prefix + "pc_fieldsplit_type")
415 0 : pc_desc_split += entry.value ? *entry.value + " " : "unspecified ";
416 :
417 56169 : if (!pc_desc_split.empty() && prefix.size() > 1)
418 0 : pc_desc += "[" + prefix.substr(1, prefix.size() - 2) + "]: ";
419 56169 : pc_desc += pc_desc_split;
420 56169 : }
421 55684 : }
422 :
423 : // Alert the user any unoverridden options will still be picked up from the input file
424 55409 : if (!pc_desc.empty())
425 0 : pc_desc += "(see input file for unoverridden options)";
426 :
427 : // If there are no PETSc pc options on the command line, print the input file options
428 55409 : if (pc_desc.empty())
429 55409 : pc_desc = problem.getPetscOptions().pc_description;
430 :
431 55409 : if (!pc_desc.empty())
432 23779 : oss << std::setw(console_field_width) << " PETSc Preconditioner: " << pc_desc << '\n';
433 :
434 55409 : std::string mpc_desc;
435 109753 : for (const std::size_t i : make_range(problem.numNonlinearSystems()))
436 : {
437 54344 : MoosePreconditioner const * mpc = problem.getNonlinearSystemBase(i).getPreconditioner();
438 54344 : if (mpc)
439 : {
440 13448 : if (problem.numNonlinearSystems() > 1)
441 268 : mpc_desc += "[" + problem.getNonlinearSystemNames()[i] + "]: ";
442 13448 : mpc_desc += mpc->type() + " ";
443 13448 : if (mpc->name().find("_moose_auto") != std::string::npos)
444 9469 : mpc_desc += "(auto) ";
445 : }
446 : }
447 :
448 55409 : if (!mpc_desc.empty())
449 13314 : oss << std::setw(console_field_width) << " MOOSE Preconditioner: " << mpc_desc << '\n';
450 :
451 110818 : return oss.str();
452 55409 : }
453 :
454 : std::string
455 10 : outputOutputInformation(MooseApp & app)
456 : {
457 10 : std::stringstream oss;
458 10 : oss << std::left;
459 :
460 10 : const std::vector<Output *> outputs = app.getOutputWarehouse().getOutputs<Output>();
461 10 : oss << "Outputs:\n";
462 60 : for (const auto & out : outputs)
463 : {
464 : // Display the "execute_on" settings
465 50 : const MultiMooseEnum & execute_on = out->executeOn();
466 50 : oss << " " << std::setw(console_field_width - 2) << out->name() << "\"" << execute_on
467 50 : << "\"\n";
468 :
469 : // Display the advanced "execute_on" settings, only if they are different from "execute_on"
470 50 : if (out->isAdvanced())
471 : {
472 20 : const OutputOnWarehouse & adv_on = out->advancedExecuteOn();
473 140 : for (const auto & adv_it : adv_on)
474 120 : if (execute_on != adv_it.second)
475 140 : oss << " " << std::setw(console_field_width - 4) << adv_it.first + ":" << "\""
476 70 : << adv_it.second << "\"" << std::endl;
477 : }
478 : }
479 :
480 20 : return oss.str();
481 10 : }
482 :
483 : std::string
484 26 : outputPreSMOResidualInformation()
485 : {
486 26 : std::stringstream oss;
487 26 : oss << std::left;
488 :
489 26 : oss << COLOR_BLUE;
490 : oss << "Executioner/use_pre_smo_residual is set to true. The pre-SMO residual will be evaluated "
491 : "at the beginning of each time step before executing objects that could modify the "
492 : "solution, such as preset BCs, predictors, correctors, constraints, and certain user "
493 : "objects. The pre-SMO residuals will be prefixed with * and will be used in the relative "
494 26 : "convergence check.\n";
495 26 : oss << COLOR_DEFAULT;
496 :
497 52 : return oss.str();
498 26 : }
499 :
500 : std::string
501 55422 : outputLegacyInformation(MooseApp & app)
502 : {
503 55422 : std::stringstream oss;
504 55422 : oss << std::left;
505 :
506 55422 : if (app.parameters().get<bool>("use_legacy_material_output"))
507 : {
508 0 : oss << COLOR_RED << "LEGACY MODES ENABLED:" << COLOR_DEFAULT << '\n';
509 : oss << " This application uses the legacy material output option: material properties are "
510 : "output only on TIMESTEP_END, not INITIAL. To remove this message, set "
511 : "'use_legacy_material_output' to false in this application. If there are gold output "
512 : "files that contain material property output for which output occurs on INITIAL, then "
513 : "these will generate diffs due to zero values being stored, and these tests should be "
514 : "re-golded.\n"
515 0 : << COLOR_DEFAULT << std::endl;
516 : }
517 :
518 55422 : if (app.parameters().get<bool>("use_legacy_initial_residual_evaluation_behavior"))
519 : {
520 0 : oss << COLOR_RED << "LEGACY MODES ENABLED:" << COLOR_DEFAULT << '\n';
521 : oss << " This application uses the legacy initial residual evaluation behavior. The legacy "
522 : "behavior performs an often times redundant residual evaluation before the solution "
523 : "modifying objects are executed prior to the initial (0th nonlinear iteration) residual "
524 : "evaluation. The new behavior skips that redundant residual evaluation unless the "
525 : "parameter Executioner/use_pre_smo_residual is set to true. To remove this message and "
526 : "enable the new behavior, set the parameter "
527 : "'use_legacy_initial_residual_evaluation_behavior' to false in *App.C. Some tests that "
528 : "rely on the side effects of the legacy behavior may fail/diff and should be "
529 : "re-golded.\n"
530 0 : << COLOR_DEFAULT << std::endl;
531 : }
532 :
533 110844 : return oss.str();
534 55422 : }
535 :
536 : std::string
537 10 : outputDataFilePaths()
538 : {
539 10 : std::stringstream oss;
540 10 : oss << "Data File Paths:\n";
541 20 : for (const auto & [name, path] : Registry::getDataFilePaths())
542 10 : oss << " " << name << ": " << path << "\n";
543 20 : return oss.str() + "\n";
544 10 : }
545 :
546 : std::string
547 10 : outputDataFileParams(MooseApp & app)
548 : {
549 10 : std::map<std::string, std::string> values; // for A-Z sort
550 526 : for (const auto & object_name_params_pair : app.getInputParameterWarehouse().getInputParameters())
551 : {
552 516 : const auto & params = object_name_params_pair.second;
553 13000 : for (const auto & name_value_pair : *params)
554 : {
555 12484 : const auto & name = name_value_pair.first;
556 12484 : if (const auto path = params->queryDataFileNamePath(name))
557 40 : if (params->getHitNode(name))
558 12484 : values.emplace(params->paramFullpath(name), path->path);
559 : }
560 : }
561 :
562 10 : std::stringstream oss;
563 10 : oss << "Data File Parameters:\n";
564 20 : for (const auto & [param, value] : values)
565 10 : oss << " " << param << " = " << value << "\n";
566 20 : return oss.str() + '\n';
567 10 : }
568 :
569 : void
570 368960 : insertNewline(std::stringstream & oss, std::streampos & begin, std::streampos & curr)
571 : {
572 368960 : if (curr - begin > console_line_length)
573 : {
574 6044 : oss << "\n";
575 6044 : begin = oss.tellp();
576 6044 : oss << std::setw(console_field_width + 2) << ""; // "{ "
577 : }
578 368960 : }
579 :
580 : std::string
581 63368 : formatString(std::string message, const std::string & prefix)
582 : {
583 63368 : MooseUtils::indentMessage(prefix, message, COLOR_DEFAULT, true, " ");
584 63368 : std::stringstream stream;
585 63368 : std::streampos start = stream.tellp();
586 63368 : stream << message;
587 63368 : std::streampos end = stream.tellp();
588 63368 : insertNewline(stream, start, end);
589 63368 : auto formatted_string = stream.str();
590 : // no need to end with a line break
591 63368 : if (formatted_string.back() == '\n')
592 0 : formatted_string.pop_back();
593 126736 : return formatted_string;
594 63368 : }
595 :
596 : std::string
597 13181 : mooseObjectVectorToString(const std::vector<MooseObject *> & objs, const std::string & sep /*=""*/)
598 : {
599 13181 : std::string object_names = "";
600 13181 : if (objs.size())
601 : {
602 : // Gather all the object names
603 13181 : std::vector<std::string> names;
604 13181 : names.reserve(objs.size());
605 37916 : for (const auto & obj : objs)
606 : {
607 : mooseAssert(obj, "Trying to print a null object");
608 24735 : names.push_back(obj->name());
609 : }
610 :
611 13181 : object_names = MooseUtils::join(names, sep);
612 13181 : }
613 13181 : return object_names;
614 0 : }
615 :
616 : } // ConsoleUtils namespace
|
