SolutionInvalidity Class Reference

The SolutionInvalidity will contain all the information about the occurrence(s) of solution invalidity. More...

#include <SolutionInvalidity.h>

Inheritance diagram for SolutionInvalidity:

Classes
struct	InvalidCounts
	Struct used in _counts for storing warning and invalid-solution occurrences. More...
struct	TimestepCounts
	Struct used in InvalidCounts for storing the time history of invalid occurrences. More...

Public Types
using	SolutionInvalidityRegistry = moose::internal::SolutionInvalidityRegistry

Public Member Functions
	SolutionInvalidity (MooseApp &app)
	Create a new SolutionInvalidity.
void	flagInvalidSolutionInternal (const InvalidSolutionID _invalid_solution_id)
	Increments solution invalid occurrences for each solution id.
bool	hasInvalidSolutionWarning () const
	Whether or not an invalid solution was encountered that was a warning.
bool	hasInvalidSolutionError () const
	Whether or not an invalid solution was encountered that was an error.
bool	hasInvalidSolution () const
	Whether or not any invalid solution was encountered (error or warning).
bool	hasEverHadSolutionIssue () const
	Whether or not any warning or invalid solution has ever been encountered during the simulation.
void	resetTimeStepOccurences ()
	Reset the number of solution invalid occurrences back to zero for the current time step.
void	resetIterationOccurences ()
	Reset the number of solution invalid occurrences back to zero.
void	accumulateIterationIntoTimeStepOccurences ()
	Pass the number of solution invalid occurrences from current iteration to cumulative counters.
void	accumulateTimeStepIntoTotalOccurences (const unsigned int timestep_index)
	Pass the number of solution invalid occurrences from current timestep to cumulative timestep counter (e.g. the total)
const std::vector< InvalidCounts > &	counts () const
	Access the private solution invalidity counts.
void	print (const ConsoleStream &console) const
	Print the summary table of Solution Invalid warnings.
void	printHistory (const ConsoleStream &console, unsigned int &timestep_interval_size) const
	Print the time history table of Solution Invalid warnings.
void	printDebug (InvalidSolutionID _invalid_solution_id) const
	Immediately print the section and message for debug purpose.
void	syncIteration ()
	Sync iteration counts to main processor Sum across all processors.
bool	hasSynced () const
	Whether the solution invalidity has synchronized iteration counts across MPI processes.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Protected Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.
const Parallel::Communicator &	_communicator

Private Types
typedef VariadicTable< std::string, unsigned long int, unsigned long int, unsigned long int, std::string >	FullTable
typedef VariadicTable< std::string, std::string, unsigned long int, unsigned long int >	TimeTable

Private Member Functions
FullTable	summaryTable () const
	Build a VariadicTable for solution invalidity.
TimeTable	transientTable (unsigned int &time_interval) const
	Build a VariadicTable for solution invalidity history.

Private Attributes
std::mutex	_invalid_mutex
	Mutex for locking access to the invalid counts TODO: These can be changed to shared_mutexes.
SolutionInvalidityRegistry &	_solution_invalidity_registry
	Create a registry to keep track of the names and occurrences of the solution invalidity.
std::vector< InvalidCounts >	_counts
	Store the solution invalidity counts.
bool	_has_synced
	Whether or not we've synced (can check counts/existance of warnings or errors)
bool	_has_solution_warning
	Whether or not we have a warning (only after a sync)
bool	_has_solution_error
	Whether or not we have an invalid solution (only after a sync)
bool	_has_recorded_issue
	Whether or not we have ever had any warning or solution issue during the simulation.

Friends
void	dataStore (std::ostream &, SolutionInvalidity &, void *)
void	dataLoad (std::istream &, SolutionInvalidity &, void *)

Detailed Description

The SolutionInvalidity will contain all the information about the occurrence(s) of solution invalidity.

Definition at line 37 of file SolutionInvalidity.h.

Member Typedef Documentation

FullTable

typedef VariadicTable<std::string, unsigned long int, unsigned long int, unsigned long int, std::string> SolutionInvalidity::FullTable

private

Definition at line 154 of file SolutionInvalidity.h.

SolutionInvalidityRegistry

using SolutionInvalidity::SolutionInvalidityRegistry = moose::internal::SolutionInvalidityRegistry

Definition at line 40 of file SolutionInvalidity.h.

TimeTable

typedef VariadicTable<std::string, std::string, unsigned long int, unsigned long int> SolutionInvalidity::TimeTable

private

Definition at line 159 of file SolutionInvalidity.h.

Constructor & Destructor Documentation

SolutionInvalidity()

SolutionInvalidity::SolutionInvalidity

(

MooseApp &

app

)

Create a new SolutionInvalidity.

Definition at line 27 of file SolutionInvalidity.C.

  : ConsoleStreamInterface(app),
    ParallelObject(app.comm()),
    _solution_invalidity_registry(moose::internal::getSolutionInvalidityRegistry()),
    _has_synced(true),
    _has_solution_warning(false),
    _has_solution_error(false),
    _has_recorded_issue(false)
{
}

Member Function Documentation

accumulateIterationIntoTimeStepOccurences()

void SolutionInvalidity::accumulateIterationIntoTimeStepOccurences

(

)

Pass the number of solution invalid occurrences from current iteration to cumulative counters.

Definition at line 94 of file SolutionInvalidity.C.

{
  for (auto & entry : _counts)
    entry.current_timestep_counts += entry.current_counts;
}

Referenced by NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemSolve::initialSetup(), and FixedPointSolve::solveStep().

accumulateTimeStepIntoTotalOccurences()

void SolutionInvalidity::accumulateTimeStepIntoTotalOccurences

(

const unsigned int

timestep_index

)

Pass the number of solution invalid occurrences from current timestep to cumulative timestep counter (e.g. the total)

Definition at line 101 of file SolutionInvalidity.C.

{
  for (auto & entry : _counts)
    if (entry.current_timestep_counts)
    {
      if (entry.timestep_counts.empty() ||
          entry.timestep_counts.back().timestep_index != timestep_index)
        entry.timestep_counts.emplace_back(timestep_index);
      entry.timestep_counts.back().counts = entry.current_timestep_counts;
      entry.total_counts += entry.current_timestep_counts;
    }
}

Referenced by FEProblemSolve::initialSetup(), and FixedPointSolve::solveStep().

counts()

const std::vector< InvalidCounts > & SolutionInvalidity::counts ( ) const

inline

Access the private solution invalidity counts.

Definition at line 113 of file SolutionInvalidity.h.

{ return _counts; }

Referenced by syncIteration(), and to_json().

flagInvalidSolutionInternal()

void SolutionInvalidity::flagInvalidSolutionInternal

(

const InvalidSolutionID

_invalid_solution_id

)

Increments solution invalid occurrences for each solution id.

Definition at line 39 of file SolutionInvalidity.C.

{
  std::lock_guard<std::mutex> lock_id(_invalid_mutex);
  if (_counts.size() <= _invalid_solution_id)
    _counts.resize(_invalid_solution_id + 1);
 
  ++_counts[_invalid_solution_id].current_counts;
}

hasEverHadSolutionIssue()

bool SolutionInvalidity::hasEverHadSolutionIssue

(

)

const

Whether or not any warning or invalid solution has ever been encountered during the simulation.

This must be called after a sync.

Definition at line 69 of file SolutionInvalidity.C.

{
  mooseAssert(_has_synced, "Has not synced");
  return _has_recorded_issue;
}

Referenced by SolutionInvalidityOutput::shouldOutput().

hasInvalidSolution()

bool SolutionInvalidity::hasInvalidSolution

(

)

const

Whether or not any invalid solution was encountered (error or warning).

This must be called after a sync.

Definition at line 63 of file SolutionInvalidity.C.

{
  return hasInvalidSolutionWarning() || hasInvalidSolutionError();
}

Referenced by SolutionInvalidityOutput::shouldOutput().

hasInvalidSolutionError()

bool SolutionInvalidity::hasInvalidSolutionError

(

)

const

Whether or not an invalid solution was encountered that was an error.

This must be called after a sync.

Definition at line 56 of file SolutionInvalidity.C.

{
  mooseAssert(_has_synced, "Has not synced");
  return _has_solution_error;
}

Referenced by FEProblemBase::acceptInvalidSolution(), hasInvalidSolution(), and printHistory().

hasInvalidSolutionWarning()

bool SolutionInvalidity::hasInvalidSolutionWarning

(

)

const

Whether or not an invalid solution was encountered that was a warning.

This must be called after a sync.

Definition at line 49 of file SolutionInvalidity.C.

{
  mooseAssert(_has_synced, "Has not synced");
  return _has_solution_warning;
}

Referenced by hasInvalidSolution().

hasSynced()

bool SolutionInvalidity::hasSynced ( ) const

inline

Whether the solution invalidity has synchronized iteration counts across MPI processes.

Definition at line 139 of file SolutionInvalidity.h.

{ return _has_synced; }

Referenced by NonlinearSystem::converged().

print()

void SolutionInvalidity::print

(

const ConsoleStream &

console

)

const

Print the summary table of Solution Invalid warnings.

Parameters

console

The output stream to output to

Definition at line 115 of file SolutionInvalidity.C.

{
  console << "\nSolution Invalid Warnings:\n";
  summaryTable().print(console);
}

printDebug()

void SolutionInvalidity::printDebug

(

InvalidSolutionID

_invalid_solution_id

)

const

Immediately print the section and message for debug purpose.

Definition at line 208 of file SolutionInvalidity.C.

{
  const auto & info = _solution_invalidity_registry.item(_invalid_solution_id);
  _console << info.object_type << ": " << info.message << "\n" << std::flush;
}

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

printHistory()

void SolutionInvalidity::printHistory	(	const ConsoleStream &	console,
		unsigned int &	timestep_interval_size
	)		const

Print the time history table of Solution Invalid warnings.

Parameters

console

The output stream to output to

Definition at line 122 of file SolutionInvalidity.C.

{
  if (hasInvalidSolutionError())
    console << "\nSolution Invalid History:\n";
  else
    console << "\nWarnings History:\n";
  transientTable(timestep_interval_size).print(console);
}

Referenced by SolutionInvalidityOutput::output().

resetIterationOccurences()

void SolutionInvalidity::resetIterationOccurences

(

)

Reset the number of solution invalid occurrences back to zero.

Definition at line 76 of file SolutionInvalidity.C.

{
  // Zero current counts
  for (auto & entry : _counts)
    entry.current_counts = 0;
}

Referenced by FEProblemBase::computeJacobianSys(), FEProblemBase::computeResidualSys(), and FixedPointSolve::solveStep().

resetTimeStepOccurences()

void SolutionInvalidity::resetTimeStepOccurences

(

)

Reset the number of solution invalid occurrences back to zero for the current time step.

Definition at line 84 of file SolutionInvalidity.C.

{
  // Reset that we have synced because we're on a new iteration
  _has_synced = false;
 
  for (auto & entry : _counts)
    entry.current_timestep_counts = 0;
}

Referenced by FixedPointSolve::solveStep().

summaryTable()

SolutionInvalidity::FullTable SolutionInvalidity::summaryTable ( ) const

private

Build a VariadicTable for solution invalidity.

Definition at line 215 of file SolutionInvalidity.C.

{
  mooseAssert(_has_synced, "Has not synced");
 
  FullTable vtable({"Object", "Converged", "Timestep", "Total", "Message"}, 4);
 
  vtable.setColumnFormat({
      VariadicTableColumnFormat::AUTO, // Object Type
      VariadicTableColumnFormat::AUTO, // Converged Iteration Warnings
      VariadicTableColumnFormat::AUTO, // Latest Time Step Warnings
      VariadicTableColumnFormat::AUTO, // Total Simulation Warnings
      VariadicTableColumnFormat::AUTO, // Message
  });
 
  vtable.setColumnPrecision({
      1, // Object Name
      0, // Converged Iteration Warnings
      0, // Latest Time Step Warnings
      0, // Total Simulation Warnings
      1, // Message
  });
 
  if (processor_id() == 0)
  {
    for (const auto id : index_range(_counts))
    {
      const auto & entry = _counts[id];
      if (entry.current_counts)
      {
        const auto & info = _solution_invalidity_registry.item(id);
        vtable.addRow(info.object_type,              // Object Type
                      entry.current_counts,          // Converged Iteration Warnings
                      entry.current_timestep_counts, // Latest Time Step Warnings
                      entry.total_counts,            // Total Iteration Warnings
                      info.message                   // Message
        );
      }
    }
  }
 
  return vtable;
}

Referenced by print().

syncIteration()

void SolutionInvalidity::syncIteration

(

)

Sync iteration counts to main processor Sum across all processors.

Definition at line 133 of file SolutionInvalidity.C.

{
  std::map<processor_id_type, std::vector<std::tuple<std::string, std::string, int, unsigned int>>>
      data_to_send;
 
  // Reset this as we need to see if we have new counts
  _has_solution_warning = false;
  _has_solution_error = false;
 
  for (const auto id : index_range(_counts))
  {
    auto & entry = _counts[id];
    if (entry.current_counts)
    {
      const auto & info = _solution_invalidity_registry.item(id);
      data_to_send[0].emplace_back(
          info.object_type, info.message, info.warning, entry.current_counts);
      entry.current_counts = 0;
    }
  }
 
  const auto receive_data = [this](const processor_id_type libmesh_dbg_var(pid), const auto & data)
  {
    mooseAssert(processor_id() == 0, "Should only receive on processor 0");
 
    for (const auto & [object_type, message, warning_int, counts] : data)
    {
      mooseAssert(counts, "Should not send data without counts");
 
      // We transfer this as an integer (which is guaranteed by the standard to cast to a bool)
      // because TIMPI doesn't currently support transferring bools
      const bool warning = warning_int;
 
      InvalidSolutionID main_id = 0;
      const moose::internal::SolutionInvalidityName name(object_type, message);
      if (_solution_invalidity_registry.keyExists(name))
      {
        main_id = _solution_invalidity_registry.id(name);
        mooseAssert(_solution_invalidity_registry.item(main_id).warning == warning,
                    "Inconsistent registration of invalidity warning and error");
      }
      else
      {
        mooseAssert(pid != 0, "Should only hit on other processors");
        main_id = moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
            object_type, message, warning);
      }
      if (_counts.size() <= main_id)
        _counts.resize(main_id + 1);
 
      _counts[main_id].current_counts += counts;
 
      if (warning)
        _has_solution_warning = true;
      else
        _has_solution_error = true;
    }
  };
 
  // Communicate the counts
  TIMPI::push_parallel_vector_data(comm(), data_to_send, receive_data);
 
  // Set the state across all processors
  comm().max(_has_solution_warning);
  comm().max(_has_solution_error);
 
  // Keep track of any occurence
  if (_has_solution_warning || _has_solution_error)
    _has_recorded_issue = true;
 
  // We've now synced
  _has_synced = true;
}

Referenced by SolverSystem::checkInvalidSolution(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemSolve::initialSetup(), SolutionInvalidityOutput::shouldOutput(), and FixedPointSolve::solveStep().

transientTable()

SolutionInvalidity::TimeTable SolutionInvalidity::transientTable ( unsigned int &  time_interval ) const

private

Build a VariadicTable for solution invalidity history.

Definition at line 259 of file SolutionInvalidity.C.

{
  mooseAssert(_has_synced, "Has not synced");
 
  TimeTable vtable({"Object", "Step", "Interval Count", "Total Count"}, 4);
 
  vtable.setColumnFormat({
      VariadicTableColumnFormat::AUTO, // Object information
      VariadicTableColumnFormat::AUTO, // Simulation Time Step
      VariadicTableColumnFormat::AUTO, // Latest Time Step Warnings
      VariadicTableColumnFormat::AUTO, // Total Iteration Warnings
  });
 
  vtable.setColumnPrecision({
      1, // Object information
      1, // Simulation Time Step
      0, // Latest Time Step Warnings
      0, // Total Iteration Warnings
  });
 
  if (processor_id() == 0)
  {
    for (const auto id : index_range(_counts))
    {
      const auto & entry = _counts[id];
      const auto & info = _solution_invalidity_registry.item(id);
      std::vector<unsigned int> interval_counts;
      std::vector<unsigned int> total_counts;
 
      if (!entry.timestep_counts.empty())
      {
        // Allow warnings from the setup step
        for (unsigned int timestep = 0; timestep <= entry.timestep_counts.back().timestep_index;
             timestep += step_interval)
        {
 
          auto start_it = timestep;
          auto end_it = (timestep + step_interval < entry.timestep_counts.back().timestep_index)
                            ? start_it + step_interval
                            : entry.timestep_counts.back().timestep_index;
 
          int interval_sum = 0;
          for (auto ts_count : entry.timestep_counts)
          {
            // Allow warnings from the setup step
            if (ts_count.timestep_index >= start_it &&
                (ts_count.timestep_index < end_it || start_it == end_it))
              interval_sum += ts_count.counts;
          }
 
          interval_counts.push_back(interval_sum);
        }
      }
 
      unsigned int interval_sum = 0;
      for (unsigned int interval_index : index_range(interval_counts))
      {
        std::string interval_index_str =
            (step_interval > 1) ? std::to_string(interval_index) + "-" +
                                      std::to_string(interval_index + step_interval - 1)
                                : std::to_string(interval_index);
 
        interval_sum += interval_counts[interval_index];
        vtable.addRow(info.object_type + " : " + info.message, // Object information
                      interval_index_str,                      // Interval Index
                      interval_counts[interval_index],         // Interval Counts
                      interval_sum                             // Total Iteration Warnings
 
        );
      }
    }
  }
  return vtable;
}

Referenced by printHistory().

Friends And Related Symbol Documentation

dataLoad

void dataLoad ( std::istream &  stream, SolutionInvalidity &  solution_invalidity, void *  context  )

friend

Definition at line 384 of file SolutionInvalidity.C.

{
  if (solution_invalidity.processor_id() != 0)
    return;
 
  std::size_t num_counts;
  // load data block size
  dataLoad(stream, num_counts, context);
 
  std::string object_type, message;
  bool warning;
  InvalidSolutionID id;
 
  // loop over and load stored data
  for (size_t i = 0; i < num_counts; i++)
  {
    dataLoad(stream, object_type, context);
    dataLoad(stream, message, context);
    dataLoad(stream, warning, context);
 
    const moose::internal::SolutionInvalidityName name(object_type, message);
    if (solution_invalidity._solution_invalidity_registry.keyExists(name))
      id = solution_invalidity._solution_invalidity_registry.id(name);
    else
      id = moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
          object_type, message, warning);
 
    if (solution_invalidity._counts.size() <= id)
      solution_invalidity._counts.resize(id + 1);
 
    auto & entry = solution_invalidity._counts[id];
    dataLoad(stream, entry.current_counts, context);
    dataLoad(stream, entry.current_timestep_counts, context);
    dataLoad(stream, entry.timestep_counts, context);
    dataLoad(stream, entry.total_counts, context);
  }
}

dataStore

void dataStore ( std::ostream &  stream, SolutionInvalidity &  solution_invalidity, void *  context  )

friend

Definition at line 355 of file SolutionInvalidity.C.

{
  solution_invalidity.syncIteration();
 
  if (solution_invalidity.processor_id() != 0)
    return;
 
  // Build data structure for store
  std::size_t size = solution_invalidity._counts.size();
  dataStore(stream, size, context);
 
  for (const auto id : index_range(solution_invalidity._counts))
  {
    auto & entry = solution_invalidity._counts[id];
    const auto & info = solution_invalidity._solution_invalidity_registry.item(id);
    std::string type = info.object_type;
    std::string message = info.message;
    bool warning = info.warning;
    dataStore(stream, type, context);
    dataStore(stream, message, context);
    dataStore(stream, warning, context);
    dataStore(stream, entry.current_counts, context);
    dataStore(stream, entry.current_timestep_counts, context);
    dataStore(stream, entry.timestep_counts, context);
    dataStore(stream, entry.total_counts, context);
  }
}

Member Data Documentation

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), Adaptivity::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_counts

std::vector<InvalidCounts> SolutionInvalidity::_counts

private

Store the solution invalidity counts.

Definition at line 168 of file SolutionInvalidity.h.

Referenced by accumulateIterationIntoTimeStepOccurences(), accumulateTimeStepIntoTotalOccurences(), counts(), flagInvalidSolutionInternal(), resetIterationOccurences(), resetTimeStepOccurences(), summaryTable(), syncIteration(), and transientTable().

_has_recorded_issue

bool SolutionInvalidity::_has_recorded_issue

private

Whether or not we have ever had any warning or solution issue during the simulation.

Definition at line 177 of file SolutionInvalidity.h.

Referenced by hasEverHadSolutionIssue(), and syncIteration().

_has_solution_error

bool SolutionInvalidity::_has_solution_error

private

Whether or not we have an invalid solution (only after a sync)

Definition at line 175 of file SolutionInvalidity.h.

Referenced by hasInvalidSolutionError(), and syncIteration().

_has_solution_warning

bool SolutionInvalidity::_has_solution_warning

private

Whether or not we have a warning (only after a sync)

Definition at line 173 of file SolutionInvalidity.h.

Referenced by hasInvalidSolutionWarning(), and syncIteration().

_has_synced

bool SolutionInvalidity::_has_synced

private

Whether or not we've synced (can check counts/existance of warnings or errors)

Definition at line 171 of file SolutionInvalidity.h.

Referenced by hasEverHadSolutionIssue(), hasInvalidSolutionError(), hasInvalidSolutionWarning(), hasSynced(), resetTimeStepOccurences(), summaryTable(), syncIteration(), and transientTable().

_invalid_mutex

std::mutex SolutionInvalidity::_invalid_mutex

mutableprivate

Mutex for locking access to the invalid counts TODO: These can be changed to shared_mutexes.

Definition at line 147 of file SolutionInvalidity.h.

Referenced by flagInvalidSolutionInternal().

_solution_invalidity_registry

SolutionInvalidityRegistry& SolutionInvalidity::_solution_invalidity_registry

private

Create a registry to keep track of the names and occurrences of the solution invalidity.

Definition at line 165 of file SolutionInvalidity.h.

Referenced by printDebug(), summaryTable(), syncIteration(), and transientTable().

---

The documentation for this class was generated from the following files:

• include/utils/SolutionInvalidity.h
• src/utils/SolutionInvalidity.C