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 28051 : indent(unsigned int spaces)
42 : {
43 56102 : return std::string(spaces, ' ');
44 : }
45 :
46 : std::string
47 91689 : outputFrameworkInformation(const MooseApp & app)
48 : {
49 91689 : std::stringstream oss;
50 91689 : oss << std::left;
51 :
52 91689 : oss << app.getSystemInfo().getInfo();
53 :
54 91689 : oss << "Input File(s):\n";
55 183654 : for (const auto & entry : app.getInputFileNames())
56 91965 : oss << " " << std::filesystem::absolute(entry).c_str() << "\n";
57 91689 : oss << "\n";
58 :
59 91689 : 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 183378 : as_range(std::next(cl.getEntries().begin(), app.multiAppLevel() == 0), cl.getEntries().end());
63 :
64 91689 : std::stringstream args_oss;
65 803538 : for (const auto & entry : cl_range)
66 711849 : if (!entry.hit_param && !entry.subapp_name && entry.name != "-i")
67 478843 : args_oss << " " << cl.formatEntry(entry) << "\n";
68 91689 : if (args_oss.str().size())
69 88175 : oss << "Command Line Argument(s):\n" << args_oss.str() << "\n";
70 :
71 91689 : std::stringstream input_args_oss;
72 803538 : for (const auto & entry : cl_range)
73 711849 : if (entry.hit_param && !entry.subapp_name)
74 155547 : input_args_oss << " " << cl.formatEntry(entry) << "\n";
75 91689 : if (input_args_oss.str().size())
76 80663 : oss << "Command Line Input Argument(s):\n" << input_args_oss.str() << "\n";
77 :
78 91689 : const auto checkpoints = app.getOutputWarehouse().getOutputs<Checkpoint>();
79 91689 : if (checkpoints.size())
80 : {
81 76973 : oss << std::left << "Checkpoint:\n";
82 76973 : oss << checkpoints[0]->checkpointInfo().str();
83 76973 : oss << std::endl;
84 : }
85 :
86 91689 : oss << std::left << "Parallelism:\n"
87 : << std::setw(console_field_width)
88 91689 : << " Num Processors: " << static_cast<std::size_t>(app.n_processors()) << '\n'
89 : << std::setw(console_field_width)
90 91689 : << " Num Threads: " << static_cast<std::size_t>(libMesh::n_threads()) << std::endl;
91 :
92 183378 : return oss.str();
93 91689 : }
94 :
95 : std::string
96 56677 : outputMeshInformation(FEProblemBase & problem, bool verbose)
97 : {
98 56677 : std::stringstream oss;
99 56677 : oss << std::left;
100 :
101 56677 : const MooseMesh & mesh = problem.mesh();
102 :
103 56677 : const auto fe_backend = problem.feBackend();
104 :
105 56677 : if (verbose)
106 : {
107 56314 : oss << "\nMesh: " << '\n' << std::setw(console_field_width);
108 :
109 56314 : oss << " Parallel Type: " << (mesh.isDistributedMesh() ? "distributed" : "replicated");
110 56314 : if (fe_backend == Moose::FEBackend::LibMesh)
111 : {
112 55965 : bool forced = mesh.isParallelTypeForced();
113 55965 : bool pre_split = mesh.isSplit();
114 55339 : oss << (forced || pre_split ? " (" : "") << (forced ? "forced" : "")
115 626 : << (forced && pre_split ? ", " : "") << (pre_split ? "pre-split" : "")
116 111930 : << (forced || pre_split ? ")" : "");
117 : }
118 56314 : oss << '\n';
119 56314 : oss << std::setw(console_field_width) << " Mesh Dimension: " << mesh.dimension() << '\n'
120 56314 : << std::setw(console_field_width) << " Spatial Dimension: " << mesh.spatialDimension()
121 56314 : << '\n';
122 : }
123 :
124 : // Nodes, only associated with the mesh in libMesh
125 56677 : if (fe_backend == Moose::FEBackend::LibMesh)
126 : {
127 56328 : if (mesh.n_processors() > 1)
128 : {
129 25740 : dof_id_type nnodes = mesh.nNodes();
130 25740 : dof_id_type nnodes_local = mesh.nLocalNodes();
131 : oss << std::setw(console_field_width) << " Nodes:" << '\n'
132 25740 : << std::setw(console_field_width) << " Total:" << nnodes << '\n';
133 25740 : oss << std::setw(console_field_width) << " Local:" << nnodes_local << '\n';
134 25740 : dof_id_type min_nnodes = nnodes_local, max_nnodes = nnodes_local;
135 25740 : mesh.comm().min(min_nnodes);
136 25740 : mesh.comm().max(max_nnodes);
137 25740 : if (mesh.processor_id() == 0)
138 12040 : oss << std::setw(console_field_width) << " Min/Max/Avg:" << min_nnodes << '/'
139 12040 : << max_nnodes << '/' << nnodes / mesh.n_processors() << '\n';
140 : }
141 : else
142 30588 : oss << std::setw(console_field_width) << " Nodes:" << mesh.nNodes() << '\n';
143 : }
144 :
145 : // Elements
146 56677 : if (mesh.n_processors() > 1)
147 : {
148 25808 : dof_id_type nelems = mesh.nActiveElem();
149 25808 : dof_id_type nelems_local = mesh.nActiveLocalElem();
150 : oss << std::setw(console_field_width) << " Elems:" << '\n'
151 25808 : << std::setw(console_field_width) << " Total:" << nelems << '\n';
152 25808 : oss << std::setw(console_field_width) << " Local:" << nelems_local << '\n';
153 25808 : dof_id_type min_nelems = nelems_local, max_nelems = nelems_local;
154 25808 : mesh.comm().min(min_nelems);
155 25808 : mesh.comm().max(max_nelems);
156 25808 : if (mesh.processor_id() == 0)
157 12074 : oss << std::setw(console_field_width) << " Min/Max/Avg:" << min_nelems << '/' << max_nelems
158 12074 : << '/' << nelems / mesh.n_processors() << '\n';
159 : }
160 : else
161 30869 : oss << std::setw(console_field_width) << " Elems:" << mesh.nActiveElem() << '\n';
162 :
163 : // P-refinement
164 56677 : if (fe_backend == Moose::FEBackend::LibMesh)
165 : {
166 56328 : 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 56328 : 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 56677 : if (verbose)
175 : {
176 : oss << std::setw(console_field_width)
177 56314 : << " Num Subdomains: " << static_cast<std::size_t>(mesh.nSubdomains()) << '\n';
178 56314 : if (mesh.n_processors() > 1 && fe_backend == Moose::FEBackend::LibMesh)
179 : {
180 : oss << std::setw(console_field_width)
181 25566 : << " Num Partitions: " << static_cast<std::size_t>(mesh.nPartitions()) << '\n'
182 25566 : << std::setw(console_field_width) << " Partitioner: " << mesh.partitionerName()
183 25566 : << (mesh.isPartitionerForced() ? " (forced) " : "") << '\n';
184 25566 : if (mesh.skipPartitioning())
185 700 : oss << std::setw(console_field_width) << " Skipping all partitioning!" << '\n';
186 24866 : else if (mesh.skipNoncriticalPartitioning())
187 0 : oss << std::setw(console_field_width) << " Skipping noncritical partitioning!" << '\n';
188 : }
189 : }
190 :
191 56677 : oss << std::endl;
192 :
193 113354 : return oss.str();
194 56677 : }
195 :
196 : std::string
197 56677 : outputAuxiliarySystemInformation(FEProblemBase & problem)
198 : {
199 56677 : return outputSystemInformationHelper(problem.getAuxiliarySystem().system());
200 : }
201 :
202 : std::string
203 113629 : outputSystemInformationHelper(std::stringstream & oss, System & system)
204 : {
205 113629 : oss << std::left;
206 :
207 113629 : if (system.n_dofs())
208 : {
209 70664 : oss << std::setw(console_field_width) << " Num DOFs: " << system.n_dofs() << '\n'
210 70664 : << std::setw(console_field_width) << " Num Local DOFs: " << system.n_local_dofs() << '\n';
211 :
212 70664 : 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 70664 : std::streampos begin_string_pos = oss.tellp();
221 70664 : std::streampos curr_string_pos = begin_string_pos;
222 70664 : oss << std::setw(console_field_width) << " Variables: ";
223 161403 : for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
224 : {
225 90739 : const VariableGroup & vg_description(system.variable_group(vg));
226 :
227 90739 : if (vg_description.n_variables() > 1)
228 15765 : oss << "{ ";
229 90739 : 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 207412 : for (unsigned int vn = 0; vn < vg_description.n_variables(); vn++)
252 : {
253 117215 : oss << "\"" << vg_description.name(vn) << "\" ";
254 117215 : curr_string_pos = oss.tellp();
255 117215 : insertNewline(oss, begin_string_pos, curr_string_pos);
256 : }
257 :
258 90739 : if (vg_description.n_variables() > 1)
259 15765 : oss << "} ";
260 : }
261 70664 : oss << '\n';
262 :
263 70664 : begin_string_pos = oss.tellp();
264 70664 : curr_string_pos = begin_string_pos;
265 70664 : oss << std::setw(console_field_width) << " Finite Element Types: ";
266 : #ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
267 161403 : for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
268 : {
269 : oss << "\""
270 90739 : << libMesh::Utility::enum_to_string<FEFamily>(
271 90739 : system.get_dof_map().variable_group(vg).type().family)
272 181478 : << "\" ";
273 90739 : curr_string_pos = oss.tellp();
274 90739 : insertNewline(oss, begin_string_pos, curr_string_pos);
275 : }
276 70664 : 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 70664 : begin_string_pos = oss.tellp();
308 70664 : curr_string_pos = begin_string_pos;
309 70664 : oss << std::setw(console_field_width) << " Approximation Orders: ";
310 161403 : for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
311 : {
312 : #ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
313 : oss << "\""
314 181478 : << Utility::enum_to_string<Order>(system.get_dof_map().variable_group(vg).type().order)
315 181478 : << "\" ";
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 90739 : curr_string_pos = oss.tellp();
325 90739 : insertNewline(oss, begin_string_pos, curr_string_pos);
326 : }
327 70664 : oss << "\n" << std::endl;
328 : }
329 :
330 113629 : return oss.str();
331 : }
332 :
333 : std::string
334 56952 : outputSolverSystemInformation(FEProblemBase & problem, const unsigned int sys_num)
335 : {
336 56952 : std::stringstream oss;
337 56952 : oss << std::left;
338 :
339 113904 : return outputSystemInformationHelper(oss, problem.getSolverSystem(sys_num).system());
340 56952 : }
341 :
342 : std::string
343 56677 : outputSystemInformationHelper(System & system)
344 : {
345 56677 : std::stringstream oss;
346 :
347 113354 : return outputSystemInformationHelper(oss, system);
348 56677 : }
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 56314 : outputExecutionInformation(const MooseApp & app, FEProblemBase & problem)
372 : {
373 :
374 56314 : std::stringstream oss;
375 56314 : oss << std::left;
376 :
377 56314 : Executioner * exec = app.getExecutioner();
378 :
379 : oss << "Execution Information:\n"
380 56314 : << std::setw(console_field_width) << " Executioner: " << exec->type() << '\n';
381 :
382 56314 : std::string time_stepper = exec->getTimeStepperName();
383 56314 : if (time_stepper != "")
384 26296 : oss << std::setw(console_field_width) << " TimeStepper: " << time_stepper << '\n';
385 56314 : const auto time_integrator_names = exec->getTimeIntegratorNames();
386 56314 : if (!time_integrator_names.empty())
387 : oss << std::setw(console_field_width)
388 78549 : << " TimeIntegrator(s): " << MooseUtils::join(time_integrator_names, " ") << '\n';
389 :
390 : oss << std::setw(console_field_width)
391 168942 : << std::string(" Solver") +
392 112628 : (problem.feBackend() == Moose::FEBackend::LibMesh ? " Mode" : "") + ": ";
393 112903 : for (const std::size_t i : make_range(problem.numSolverSystems()))
394 225256 : oss << (problem.numSolverSystems() > 1 ? "[" + problem.getSolverSystemNames()[i] + "]: " : "")
395 56589 : << problem.solverTypeString(i) << " ";
396 56314 : 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 56314 : std::string pc_desc;
401 112903 : for (const std::size_t i : make_range(problem.numSolverSystems()))
402 : {
403 113178 : std::vector<std::string> splits = {""};
404 56589 : if (problem.isSolverSystemNonlinear(i))
405 55734 : for (const auto & split : problem.getNonlinearSystemBase(i).getSplits().getObjects())
406 485 : splits.push_back("fieldsplit_" + split->name() + "_");
407 :
408 113663 : for (const std::string & split : splits)
409 : {
410 57074 : std::string pc_desc_split;
411 57074 : const std::string prefix = problem.solverParams(i)._prefix + split;
412 563489 : for (const auto & entry : std::as_const(*app.commandLine()).getEntries())
413 1519245 : if (entry.name == prefix + "pc_type" || entry.name == prefix + "sub_pc_type" ||
414 1519245 : entry.name == prefix + "pc_hypre_type" || entry.name == prefix + "pc_fieldsplit_type")
415 0 : pc_desc_split += entry.value ? *entry.value + " " : "unspecified ";
416 :
417 57074 : if (!pc_desc_split.empty() && prefix.size() > 1)
418 0 : pc_desc += "[" + prefix.substr(1, prefix.size() - 2) + "]: ";
419 57074 : pc_desc += pc_desc_split;
420 57074 : }
421 56589 : }
422 :
423 : // Alert the user any unoverridden options will still be picked up from the input file
424 56314 : 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 56314 : if (pc_desc.empty())
429 56314 : pc_desc = problem.getPetscOptions().pc_description;
430 :
431 56314 : if (!pc_desc.empty())
432 24145 : oss << std::setw(console_field_width) << " PETSc Preconditioner: " << pc_desc << '\n';
433 :
434 56314 : std::string mpc_desc;
435 111563 : for (const std::size_t i : make_range(problem.numNonlinearSystems()))
436 : {
437 55249 : MoosePreconditioner const * mpc = problem.getNonlinearSystemBase(i).getPreconditioner();
438 55249 : if (mpc)
439 : {
440 13796 : if (problem.numNonlinearSystems() > 1)
441 268 : mpc_desc += "[" + problem.getNonlinearSystemNames()[i] + "]: ";
442 13796 : mpc_desc += mpc->type() + " ";
443 13796 : if (mpc->name().find("_moose_auto") != std::string::npos)
444 9602 : mpc_desc += "(auto) ";
445 : }
446 : }
447 :
448 56314 : if (!mpc_desc.empty())
449 13662 : oss << std::setw(console_field_width) << " MOOSE Preconditioner: " << mpc_desc << '\n';
450 :
451 112628 : return oss.str();
452 56314 : }
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 56327 : outputLegacyInformation(MooseApp & app)
502 : {
503 56327 : std::stringstream oss;
504 56327 : oss << std::left;
505 :
506 56327 : 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 56327 : 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 112654 : return oss.str();
534 56327 : }
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 373326 : insertNewline(std::stringstream & oss, std::streampos & begin, std::streampos & curr)
571 : {
572 373326 : if (curr - begin > console_line_length)
573 : {
574 6071 : oss << "\n";
575 6071 : begin = oss.tellp();
576 6071 : oss << std::setw(console_field_width + 2) << ""; // "{ "
577 : }
578 373326 : }
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
|
