ConsoleUtils Namespace Reference

Functions
std::string	indent (unsigned int spaces)
	Create empty string for indenting.
std::string	outputFrameworkInformation (const MooseApp &app)
	Outputs framework information.
std::string	outputMeshInformation (FEProblemBase &problem, bool verbose=true)
	Output the mesh information.
std::string	outputAuxiliarySystemInformation (FEProblemBase &problem)
	Output the Auxiliary system information.
std::string	outputSolverSystemInformation (FEProblemBase &problem, const unsigned int solver_sys_num)
	Output a solver system information.
std::string	outputRelationshipManagerInformation (const MooseApp &app)
	Output action RelationshipManager information.
std::string	outputExecutionInformation (const MooseApp &app, FEProblemBase &problem)
	Output execution information.
std::string	outputOutputInformation (MooseApp &app)
	Output the output information.
std::string	outputSystemInformationHelper (libMesh::System &system)
	Output system information.
std::string	outputPreSMOResidualInformation ()
	Output the information about pre-SMO residual evaluation.
std::string	outputLegacyInformation (MooseApp &app)
	Output the legacy flag information.
std::string	outputDataFilePaths ()
	Output the registered data paths for searching.
std::string	outputDataFileParams (MooseApp &app)
	Output the (param path = value) pairs for each DataFileName parameter.
void	insertNewline (std::stringstream &oss, std::streampos &begin, std::streampos &curr)
	Helper function function for stringstream formatting.
std::string	formatString (std::string message, const std::string &prefix)
	Add new lines and prefixes to a string for pretty display in output NOTE: This makes a copy of the string, on purpose, to be able to return a modified copy.
std::string	mooseObjectVectorToString (const std::vector< MooseObject * > &objs, const std::string &sep=" ")
	Routine to output the name of MooseObjects in a string.
std::string	outputSystemInformationHelper (std::stringstream &oss, System &system)
std::string	outputSystemInformationHelper (System &system)

Variables
static const unsigned int	console_field_width = 27
	Width used for printing simulation information.
static const unsigned int	console_line_length = 100
	Line length for printing simulation information.

Function Documentation

formatString()

std::string ConsoleUtils::formatString	(	std::string	message,
		const std::string &	prefix
	)

Add new lines and prefixes to a string for pretty display in output NOTE: This makes a copy of the string, on purpose, to be able to return a modified copy.

Returns

the formatted string

Definition at line 581 of file ConsoleUtils.C.

{
  MooseUtils::indentMessage(prefix, message, COLOR_DEFAULT, true, " ");
  std::stringstream stream;
  std::streampos start = stream.tellp();
  stream << message;
  std::streampos end = stream.tellp();
  insertNewline(stream, start, end);
  auto formatted_string = stream.str();
  // no need to end with a line break
  if (formatted_string.back() == '\n')
    formatted_string.pop_back();
  return formatted_string;
}

Referenced by MooseObjectWarehouseBase< T >::activeObjectsToFormattedString(), SolutionUserObjectBase::getLocalVarIndex(), ComputeLinearFVElementalThread::printBlockExecutionInformation(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttributeTagType >::printBlockExecutionInformation(), NonlinearThread::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttributeTagType >::printBoundaryExecutionInformation(), ComputeElemAuxBcsThread< AuxKernelType >::printBoundaryExecutionInformation(), ThreadedElementLoop< RangeType >::printExecutionOrdering(), and ComputeNodalUserObjectsThread::printGeneralExecutionInformation().

indent()

std::string ConsoleUtils::indent

(

unsigned int

spaces

)

Create empty string for indenting.

Definition at line 39 of file ConsoleUtils.C.

{
  return std::string(spaces, ' ');
}

Referenced by FEProblemBase::checkDependMaterialsHelper(), ControllableItem::dump(), ControllableAlias::dump(), MessageFromInput::execute(), ControlOutput::outputActiveObjects(), and ControlOutput::outputControls().

insertNewline()

void ConsoleUtils::insertNewline	(	std::stringstream &	oss,
		std::streampos &	begin,
		std::streampos &	curr
	)

Helper function function for stringstream formatting.

Definition at line 570 of file ConsoleUtils.C.

{
  if (curr - begin > console_line_length)
  {
    oss << "\n";
    begin = oss.tellp();
    oss << std::setw(console_field_width + 2) << ""; // "{ "
  }
}

Referenced by formatString(), outputSystemInformationHelper(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), and MaterialPropertyDebugOutput::printMaterialProperties().

mooseObjectVectorToString()

std::string ConsoleUtils::mooseObjectVectorToString	(	const std::vector< MooseObject * > &	objs,
		const std::string &	sep = " "
	)

Routine to output the name of MooseObjects in a string.

Parameters

objs	the vector with all the MooseObjects
sep	a separator in between each object's name

Definition at line 597 of file ConsoleUtils.C.

{
  std::string object_names = "";
  if (objs.size())
  {
    // Gather all the object names
    std::vector<std::string> names;
    names.reserve(objs.size());
    for (const auto & obj : objs)
    {
      mooseAssert(obj, "Trying to print a null object");
      names.push_back(obj->name());
    }
 
    object_names = MooseUtils::join(names, sep);
  }
  return object_names;
}

Referenced by ComputeLinearFVElementalThread::printBlockExecutionInformation(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttributeTagType >::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttributeTagType >::printBoundaryExecutionInformation(), ComputeElemAuxBcsThread< AuxKernelType >::printBoundaryExecutionInformation(), ThreadedElementLoop< RangeType >::printExecutionOrdering(), and ComputeNodalUserObjectsThread::printGeneralExecutionInformation().

outputAuxiliarySystemInformation()

std::string ConsoleUtils::outputAuxiliarySystemInformation

(

FEProblemBase &

problem

)

Output the Auxiliary system information.

Definition at line 195 of file ConsoleUtils.C.

{
  return outputSystemInformationHelper(problem.getAuxiliarySystem().system());
}

Referenced by Console::meshChanged(), and Console::outputSystemInformation().

outputDataFileParams()

std::string ConsoleUtils::outputDataFileParams

(

MooseApp &

app

)

Output the (param path = value) pairs for each DataFileName parameter.

Definition at line 547 of file ConsoleUtils.C.

{
  std::map<std::string, std::string> values; // for A-Z sort
  for (const auto & object_name_params_pair : app.getInputParameterWarehouse().getInputParameters())
  {
    const auto & params = object_name_params_pair.second;
    for (const auto & name_value_pair : *params)
    {
      const auto & name = name_value_pair.first;
      if (const auto path = params->queryDataFileNamePath(name))
        if (params->getHitNode(name))
          values.emplace(params->paramFullpath(name), path->path);
    }
  }
 
  std::stringstream oss;
  oss << "Data File Parameters:\n";
  for (const auto & [param, value] : values)
    oss << "  " << param << " = " << value << "\n";
  return oss.str() + '\n';
}

Referenced by Console::outputSystemInformation().

outputDataFilePaths()

std::string ConsoleUtils::outputDataFilePaths

(

)

Output the registered data paths for searching.

Definition at line 537 of file ConsoleUtils.C.

{
  std::stringstream oss;
  oss << "Data File Paths:\n";
  for (const auto & [name, path] : Registry::getDataFilePaths())
    oss << "  " << name << ": " << path << "\n";
  return oss.str() + "\n";
}

Referenced by Console::outputSystemInformation().

outputExecutionInformation()

std::string ConsoleUtils::outputExecutionInformation	(	const MooseApp &	app,
		FEProblemBase &	problem
	)

Output execution information.

Definition at line 369 of file ConsoleUtils.C.

{
 
  std::stringstream oss;
  oss << std::left;
 
  Executioner * exec = app.getExecutioner();
 
  oss << "Execution Information:\n"
      << std::setw(console_field_width) << "  Executioner: " << exec->type() << '\n';
 
  std::string time_stepper = exec->getTimeStepperName();
  if (time_stepper != "")
    oss << std::setw(console_field_width) << "  TimeStepper: " << time_stepper << '\n';
  const auto time_integrator_names = exec->getTimeIntegratorNames();
  if (!time_integrator_names.empty())
    oss << std::setw(console_field_width)
        << "  TimeIntegrator(s): " << MooseUtils::join(time_integrator_names, " ") << '\n';
 
  oss << std::setw(console_field_width)
      << std::string("  Solver") +
             (problem.feBackend() == Moose::FEBackend::LibMesh ? " Mode" : "") + ": ";
  for (const std::size_t i : make_range(problem.numSolverSystems()))
    oss << (problem.numSolverSystems() > 1 ? "[" + problem.getSolverSystemNames()[i] + "]: " : "")
        << problem.solverTypeString(i) << " ";
  oss << '\n';
 
  // Check for a selection of common PETSc pc options on the command line for
  // all solver systems and all field splits within each nonlinear system
  std::string pc_desc;
  for (const std::size_t i : make_range(problem.numSolverSystems()))
  {
    std::vector<std::string> splits = {""};
    if (problem.isSolverSystemNonlinear(i))
      for (const auto & split : problem.getNonlinearSystemBase(i).getSplits().getObjects())
        splits.push_back("fieldsplit_" + split->name() + "_");
 
    for (const std::string & split : splits)
    {
      std::string pc_desc_split;
      const std::string prefix = problem.solverParams(i)._prefix + split;
      for (const auto & entry : std::as_const(*app.commandLine()).getEntries())
        if (entry.name == prefix + "pc_type" || entry.name == prefix + "sub_pc_type" ||
            entry.name == prefix + "pc_hypre_type" || entry.name == prefix + "pc_fieldsplit_type")
          pc_desc_split += entry.value ? *entry.value + " " : "unspecified ";
 
      if (!pc_desc_split.empty() && prefix.size() > 1)
        pc_desc += "[" + prefix.substr(1, prefix.size() - 2) + "]: ";
      pc_desc += pc_desc_split;
    }
  }
 
  // Alert the user any unoverridden options will still be picked up from the input file
  if (!pc_desc.empty())
    pc_desc += "(see input file for unoverridden options)";
 
  // If there are no PETSc pc options on the command line, print the input file options
  if (pc_desc.empty())
    pc_desc = problem.getPetscOptions().pc_description;
 
  if (!pc_desc.empty())
    oss << std::setw(console_field_width) << "  PETSc Preconditioner: " << pc_desc << '\n';
 
  std::string mpc_desc;
  for (const std::size_t i : make_range(problem.numNonlinearSystems()))
  {
    MoosePreconditioner const * mpc = problem.getNonlinearSystemBase(i).getPreconditioner();
    if (mpc)
    {
      if (problem.numNonlinearSystems() > 1)
        mpc_desc += "[" + problem.getNonlinearSystemNames()[i] + "]: ";
      mpc_desc += mpc->type() + " ";
      if (mpc->name().find("_moose_auto") != std::string::npos)
        mpc_desc += "(auto) ";
    }
  }
 
  if (!mpc_desc.empty())
    oss << std::setw(console_field_width) << "  MOOSE Preconditioner: " << mpc_desc << '\n';
 
  oss << "\n";
 
  return oss.str();
}

Referenced by Console::outputSystemInformation().

outputFrameworkInformation()

std::string ConsoleUtils::outputFrameworkInformation

(

const MooseApp &

app

)

Outputs framework information.

This includes the versions and timestamps

Definition at line 45 of file ConsoleUtils.C.

{
  std::stringstream oss;
  oss << std::left;
 
  oss << app.getSystemInfo().getInfo();
 
  oss << "Input File(s):\n";
  for (const auto & entry : app.getInputFileNames())
    oss << "  " << std::filesystem::absolute(entry).c_str() << "\n";
  oss << "\n";
 
  const auto & cl = std::as_const(*app.commandLine());
  // We skip the 0th argument of the main app, i.e., the name used to invoke the program
  const auto cl_range =
      as_range(std::next(cl.getEntries().begin(), app.multiAppLevel() == 0), cl.getEntries().end());
 
  std::stringstream args_oss;
  for (const auto & entry : cl_range)
    if (!entry.hit_param && !entry.subapp_name && entry.name != "-i")
      args_oss << "  " << cl.formatEntry(entry) << "\n";
  if (args_oss.str().size())
    oss << "Command Line Argument(s):\n" << args_oss.str() << "\n";
 
  std::stringstream input_args_oss;
  for (const auto & entry : cl_range)
    if (entry.hit_param && !entry.subapp_name)
      input_args_oss << "  " << cl.formatEntry(entry) << "\n";
  if (input_args_oss.str().size())
    oss << "Command Line Input Argument(s):\n" << input_args_oss.str() << "\n";
 
  const auto checkpoints = app.getOutputWarehouse().getOutputs<Checkpoint>();
  if (checkpoints.size())
  {
    oss << std::left << "Checkpoint:\n";
    oss << checkpoints[0]->checkpointInfo().str();
    oss << std::endl;
  }
 
  oss << std::left << "Parallelism:\n"
      << std::setw(console_field_width)
      << "  Num Processors: " << static_cast<std::size_t>(app.n_processors()) << '\n'
      << std::setw(console_field_width)
      << "  Num Threads: " << static_cast<std::size_t>(libMesh::n_threads()) << std::endl;
 
  return oss.str();
}

Referenced by Console::outputSystemInformation(), and ExodusFormatter::printInputFile().

outputLegacyInformation()

std::string ConsoleUtils::outputLegacyInformation

(

MooseApp &

app

)

Output the legacy flag information.

Definition at line 501 of file ConsoleUtils.C.

{
  std::stringstream oss;
  oss << std::left;
 
  if (app.parameters().get<bool>("use_legacy_material_output"))
  {
    oss << COLOR_RED << "LEGACY MODES ENABLED:" << COLOR_DEFAULT << '\n';
    oss << " This application uses the legacy material output option: material properties are "
           "output only on TIMESTEP_END, not INITIAL. To remove this message, set "
           "'use_legacy_material_output' to false in this application. If there are gold output "
           "files that contain material property output for which output occurs on INITIAL, then "
           "these will generate diffs due to zero values being stored, and these tests should be "
           "re-golded.\n"
        << COLOR_DEFAULT << std::endl;
  }
 
  if (app.parameters().get<bool>("use_legacy_initial_residual_evaluation_behavior"))
  {
    oss << COLOR_RED << "LEGACY MODES ENABLED:" << COLOR_DEFAULT << '\n';
    oss << " This application uses the legacy initial residual evaluation behavior. The legacy "
           "behavior performs an often times redundant residual evaluation before the solution "
           "modifying objects are executed prior to the initial (0th nonlinear iteration) residual "
           "evaluation. The new behavior skips that redundant residual evaluation unless the "
           "parameter Executioner/use_pre_smo_residual is set to true. To remove this message and "
           "enable the new behavior, set the parameter "
           "'use_legacy_initial_residual_evaluation_behavior' to false in *App.C. Some tests that "
           "rely on the side effects of the legacy behavior may fail/diff and should be "
           "re-golded.\n"
        << COLOR_DEFAULT << std::endl;
  }
 
  return oss.str();
}

Referenced by Console::outputSystemInformation().

outputMeshInformation()

std::string ConsoleUtils::outputMeshInformation	(	FEProblemBase &	problem,
		bool	verbose = true
	)

Output the mesh information.

Definition at line 94 of file ConsoleUtils.C.

{
  std::stringstream oss;
  oss << std::left;
 
  const MooseMesh & mesh = problem.mesh();
 
  const auto fe_backend = problem.feBackend();
 
  if (verbose)
  {
    oss << "\nMesh: " << '\n' << std::setw(console_field_width);
 
    oss << "  Parallel Type: " << (mesh.isDistributedMesh() ? "distributed" : "replicated");
    if (fe_backend == Moose::FEBackend::LibMesh)
    {
      bool forced = mesh.isParallelTypeForced();
      bool pre_split = mesh.isSplit();
      oss << (forced || pre_split ? " (" : "") << (forced ? "forced" : "")
          << (forced && pre_split ? ", " : "") << (pre_split ? "pre-split" : "")
          << (forced || pre_split ? ")" : "");
    }
    oss << '\n';
    oss << std::setw(console_field_width) << "  Mesh Dimension: " << mesh.dimension() << '\n'
        << std::setw(console_field_width) << "  Spatial Dimension: " << mesh.spatialDimension()
        << '\n';
  }
 
  // Nodes, only associated with the mesh in libMesh
  if (fe_backend == Moose::FEBackend::LibMesh)
  {
    if (mesh.n_processors() > 1)
    {
      dof_id_type nnodes = mesh.nNodes();
      dof_id_type nnodes_local = mesh.nLocalNodes();
      oss << std::setw(console_field_width) << "  Nodes:" << '\n'
          << std::setw(console_field_width) << "    Total:" << nnodes << '\n';
      oss << std::setw(console_field_width) << "    Local:" << nnodes_local << '\n';
      dof_id_type min_nnodes = nnodes_local, max_nnodes = nnodes_local;
      mesh.comm().min(min_nnodes);
      mesh.comm().max(max_nnodes);
      if (mesh.processor_id() == 0)
        oss << std::setw(console_field_width) << "    Min/Max/Avg:" << min_nnodes << '/'
            << max_nnodes << '/' << nnodes / mesh.n_processors() << '\n';
    }
    else
      oss << std::setw(console_field_width) << "  Nodes:" << mesh.nNodes() << '\n';
  }
 
  // Elements
  if (mesh.n_processors() > 1)
  {
    dof_id_type nelems = mesh.nActiveElem();
    dof_id_type nelems_local = mesh.nActiveLocalElem();
    oss << std::setw(console_field_width) << "  Elems:" << '\n'
        << std::setw(console_field_width) << "    Total:" << nelems << '\n';
    oss << std::setw(console_field_width) << "    Local:" << nelems_local << '\n';
    dof_id_type min_nelems = nelems_local, max_nelems = nelems_local;
    mesh.comm().min(min_nelems);
    mesh.comm().max(max_nelems);
    if (mesh.processor_id() == 0)
      oss << std::setw(console_field_width) << "    Min/Max/Avg:" << min_nelems << '/' << max_nelems
          << '/' << nelems / mesh.n_processors() << '\n';
  }
  else
    oss << std::setw(console_field_width) << "  Elems:" << mesh.nActiveElem() << '\n';
 
  // P-refinement
  if (fe_backend == Moose::FEBackend::LibMesh)
  {
    if (mesh.maxPLevel() > 0)
      oss << std::setw(console_field_width)
          << "  Max p-Refinement Level: " << static_cast<std::size_t>(mesh.maxPLevel()) << '\n';
    if (mesh.maxHLevel() > 0)
      oss << std::setw(console_field_width)
          << "  Max h-Refinement Level: " << static_cast<std::size_t>(mesh.maxHLevel()) << '\n';
  }
 
  if (verbose)
  {
    oss << std::setw(console_field_width)
        << "  Num Subdomains: " << static_cast<std::size_t>(mesh.nSubdomains()) << '\n';
    if (mesh.n_processors() > 1 && fe_backend == Moose::FEBackend::LibMesh)
    {
      oss << std::setw(console_field_width)
          << "  Num Partitions: " << static_cast<std::size_t>(mesh.nPartitions()) << '\n'
          << std::setw(console_field_width) << "  Partitioner: " << mesh.partitionerName()
          << (mesh.isPartitionerForced() ? " (forced) " : "") << '\n';
      if (mesh.skipPartitioning())
        oss << std::setw(console_field_width) << "  Skipping all partitioning!" << '\n';
      else if (mesh.skipNoncriticalPartitioning())
        oss << std::setw(console_field_width) << "  Skipping noncritical partitioning!" << '\n';
    }
  }
 
  oss << std::endl;
 
  return oss.str();
}

Referenced by Console::meshChanged(), and Console::outputSystemInformation().

outputOutputInformation()

std::string ConsoleUtils::outputOutputInformation

(

MooseApp &

app

)

Output the output information.

Definition at line 455 of file ConsoleUtils.C.

{
  std::stringstream oss;
  oss << std::left;
 
  const std::vector<Output *> outputs = app.getOutputWarehouse().getOutputs<Output>();
  oss << "Outputs:\n";
  for (const auto & out : outputs)
  {
    // Display the "execute_on" settings
    const MultiMooseEnum & execute_on = out->executeOn();
    oss << "  " << std::setw(console_field_width - 2) << out->name() << "\"" << execute_on
        << "\"\n";
 
    // Display the advanced "execute_on" settings, only if they are different from "execute_on"
    if (out->isAdvanced())
    {
      const OutputOnWarehouse & adv_on = out->advancedExecuteOn();
      for (const auto & adv_it : adv_on)
        if (execute_on != adv_it.second)
          oss << "    " << std::setw(console_field_width - 4) << adv_it.first + ":" << "\""
              << adv_it.second << "\"" << std::endl;
    }
  }
 
  return oss.str();
}

Referenced by Console::outputSystemInformation().

outputPreSMOResidualInformation()

std::string ConsoleUtils::outputPreSMOResidualInformation

(

)

Output the information about pre-SMO residual evaluation.

Definition at line 484 of file ConsoleUtils.C.

{
  std::stringstream oss;
  oss << std::left;
 
  oss << COLOR_BLUE;
  oss << "Executioner/use_pre_smo_residual is set to true. The pre-SMO residual will be evaluated "
         "at the beginning of each time step before executing objects that could modify the "
         "solution, such as preset BCs, predictors, correctors, constraints, and certain user "
         "objects. The pre-SMO residuals will be prefixed with * and will be used in the relative "
         "convergence check.\n";
  oss << COLOR_DEFAULT;
 
  return oss.str();
}

Referenced by Console::outputSystemInformation().

outputRelationshipManagerInformation()

std::string ConsoleUtils::outputRelationshipManagerInformation

(

const MooseApp &

app

)

Output action RelationshipManager information.

Definition at line 349 of file ConsoleUtils.C.

{
  std::stringstream oss;
  oss << std::left;
 
  auto info_strings = app.getRelationshipManagerInfo();
  if (info_strings.size())
  {
    for (const auto & info_pair : info_strings)
      oss << std::setw(console_field_width)
          << "  " + MooseUtils::underscoreToCamelCase(MooseUtils::toLower(info_pair.first), true) +
                 ":"
          << info_pair.second << '\n';
    oss << std::endl;
  }
 
  return oss.str();
}

Referenced by Console::outputSystemInformation().

outputSolverSystemInformation()

std::string ConsoleUtils::outputSolverSystemInformation	(	FEProblemBase &	problem,
		const unsigned int	solver_sys_num
	)

Output a solver system information.

Definition at line 332 of file ConsoleUtils.C.

{
  std::stringstream oss;
  oss << std::left;
 
  return outputSystemInformationHelper(oss, problem.getSolverSystem(sys_num).system());
}

Referenced by Console::meshChanged(), and Console::outputSystemInformation().

outputSystemInformationHelper() [1/3]

std::string ConsoleUtils::outputSystemInformationHelper

(

libMesh::System &

system

)

Output system information.

Parameters

system

The libMesh system to output

See also

outputAuxiliarySystemInformation outputNonlinearSystemInformation

Referenced by outputAuxiliarySystemInformation(), outputSolverSystemInformation(), and outputSystemInformationHelper().

outputSystemInformationHelper() [2/3]

std::string ConsoleUtils::outputSystemInformationHelper	(	std::stringstream &	oss,
		System &	system
	)

Definition at line 201 of file ConsoleUtils.C.

{
  oss << std::left;
 
  if (system.n_dofs())
  {
    oss << std::setw(console_field_width) << "  Num DOFs: " << system.n_dofs() << '\n'
        << std::setw(console_field_width) << "  Num Local DOFs: " << system.n_local_dofs() << '\n';
 
    if (system.n_constrained_dofs())
    {
      oss << std::setw(console_field_width)
          << "  Num Constrained DOFs: " << system.n_constrained_dofs() << '\n'
          << std::setw(console_field_width)
          << "  Local Constrained DOFs: " << system.n_local_constrained_dofs() << '\n';
    }
 
    std::streampos begin_string_pos = oss.tellp();
    std::streampos curr_string_pos = begin_string_pos;
    oss << std::setw(console_field_width) << "  Variables: ";
    for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
    {
      const libMesh::VariableGroup & vg_description(system.variable_group(vg));
 
      if (vg_description.n_variables() > 1)
        oss << "{ ";
      if (vg_description.n_variables() > 10)
      {
        // when the number of variables in this group is larger than 10, we only output the first
        // and the last 5 variable names
        for (unsigned int vn = 0; vn < 5; vn++)
        {
          oss << "\"" << vg_description.name(vn) << "\" ";
          curr_string_pos = oss.tellp();
          insertNewline(oss, begin_string_pos, curr_string_pos);
        }
        oss << "... ";
        curr_string_pos = oss.tellp();
        insertNewline(oss, begin_string_pos, curr_string_pos);
        for (unsigned int vn = vg_description.n_variables() - 5; vn < vg_description.n_variables();
             vn++)
        {
          oss << "\"" << vg_description.name(vn) << "\" ";
          curr_string_pos = oss.tellp();
          insertNewline(oss, begin_string_pos, curr_string_pos);
        }
      }
      else
        for (unsigned int vn = 0; vn < vg_description.n_variables(); vn++)
        {
          oss << "\"" << vg_description.name(vn) << "\" ";
          curr_string_pos = oss.tellp();
          insertNewline(oss, begin_string_pos, curr_string_pos);
        }
 
      if (vg_description.n_variables() > 1)
        oss << "} ";
    }
    oss << '\n';
 
    begin_string_pos = oss.tellp();
    curr_string_pos = begin_string_pos;
    oss << std::setw(console_field_width) << "  Finite Element Types: ";
#ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
    for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
    {
      oss << "\""
          << libMesh::Utility::enum_to_string<FEFamily>(
                 system.get_dof_map().variable_group(vg).type().family)
          << "\" ";
      curr_string_pos = oss.tellp();
      insertNewline(oss, begin_string_pos, curr_string_pos);
    }
    oss << '\n';
#else
    for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
    {
      oss << "\""
          << libMesh::Utility::enum_to_string<FEFamily>(
                 system.get_dof_map().variable_group(vg).type().family)
          << "\", \""
          << libMesh::Utility::enum_to_string<FEFamily>(
                 system.get_dof_map().variable_group(vg).type().radial_family)
          << "\" ";
      curr_string_pos = oss.tellp();
      insertNewline(oss, begin_string_pos, curr_string_pos);
    }
    oss << '\n';
 
    begin_string_pos = oss.tellp();
    curr_string_pos = begin_string_pos;
    oss << std::setw(console_field_width) << "  Infinite Element Mapping: ";
    for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
    {
      oss << "\""
          << libMesh::Utility::enum_to_string<InfMapType>(
                 system.get_dof_map().variable_group(vg).type().inf_map)
          << "\" ";
      curr_string_pos = oss.tellp();
      insertNewline(oss, begin_string_pos, curr_string_pos);
    }
    oss << '\n';
#endif
 
    begin_string_pos = oss.tellp();
    curr_string_pos = begin_string_pos;
    oss << std::setw(console_field_width) << "  Approximation Orders: ";
    for (unsigned int vg = 0; vg < system.n_variable_groups(); vg++)
    {
#ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
      oss << "\""
          << Utility::enum_to_string<Order>(system.get_dof_map().variable_group(vg).type().order)
          << "\" ";
#else
      oss << "\""
          << Utility::enum_to_string<Order>(system.get_dof_map().variable_group(vg).type().order)
          << "\", \""
          << Utility::enum_to_string<Order>(
                 system.get_dof_map().variable_group(vg).type().radial_order)
          << "\" ";
#endif
      curr_string_pos = oss.tellp();
      insertNewline(oss, begin_string_pos, curr_string_pos);
    }
    oss << "\n" << std::endl;
  }
 
  return oss.str();
}

outputSystemInformationHelper() [3/3]

std::string ConsoleUtils::outputSystemInformationHelper

(

System &

system

)

Definition at line 341 of file ConsoleUtils.C.

{
  std::stringstream oss;
 
  return outputSystemInformationHelper(oss, system);
}

Variable Documentation

console_field_width

const unsigned int ConsoleUtils::console_field_width = 27

static

Width used for printing simulation information.

Definition at line 30 of file ConsoleUtils.h.

Referenced by MessageFromInput::execute(), insertNewline(), MaterialPropertyDebugOutput::output(), ControlOutput::outputControls(), outputExecutionInformation(), outputFrameworkInformation(), outputMeshInformation(), outputOutputInformation(), outputRelationshipManagerInformation(), outputSystemInformationHelper(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), MaterialPropertyDebugOutput::printMaterialMap(), and MaterialPropertyDebugOutput::printMaterialProperties().

console_line_length

const unsigned int ConsoleUtils::console_line_length = 100

static

Line length for printing simulation information.

Definition at line 33 of file ConsoleUtils.h.

Referenced by insertNewline().