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 invalid 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. More...
void	flagInvalidSolutionInternal (const InvalidSolutionID _invalid_solution_id)
	Increments solution invalid occurrences for each solution id. More...
bool	hasInvalidSolutionWarning () const
	Whether or not an invalid solution was encountered that was a warning. More...
bool	hasInvalidSolutionError () const
	Whether or not an invalid solution was encountered that was an error. More...
bool	hasInvalidSolution () const
	Whether or not any invalid solution was encountered (error or warning). More...
void	resetSolutionInvalidTimeStep ()
	Reset the number of solution invalid occurrences back to zero for the current time step. More...
void	resetSolutionInvalidCurrentIteration ()
	Reset the number of solution invalid occurrences back to zero. More...
void	solutionInvalidAccumulation ()
	Pass the number of solution invalid occurrences from current iteration to cumulative counters. More...
void	solutionInvalidAccumulationTimeStep (const unsigned int timestep_index)
	Pass the number of solution invalid occurrences from current iteration to cumulative time iteration counters. More...
void	computeTotalCounts ()
	Compute the total number of solution invalid occurrences. More...
const std::vector< InvalidCounts > &	counts () const
	Access the private solution invalidity counts. More...
void	print (const ConsoleStream &console) const
	Print the summary table of Solution Invalid warnings. More...
void	printHistory (const ConsoleStream &console, unsigned int &timestep_interval_size) const
	Print the time history table of Solution Invalid warnings. More...
void	printDebug (InvalidSolutionID _invalid_solution_id) const
	Immediately print the section and message for debug purpose. More...
void	syncIteration ()
	Sync iteration counts to main processor. More...
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. More...
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. More...
TimeTable	transientTable (unsigned int &time_interval) const
	Build a VariadicTable for solution invalidity history. More...

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

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 142 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 147 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)
{
}

Member Function Documentation

computeTotalCounts()

void SolutionInvalidity::computeTotalCounts

(

)

Compute the total number of solution invalid occurrences.

Definition at line 107 of file SolutionInvalidity.C.

{
  mooseAssert(_has_synced, "Has not synced");

  for (auto & entry : _counts)
  {
    entry.total_counts = 0;
    for (auto & time_counts : entry.timestep_counts)
      entry.total_counts += time_counts.counts;
  }
}

counts()

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

inline

Access the private solution invalidity counts.

Definition at line 105 of file SolutionInvalidity.h.

Referenced by syncIteration(), and to_json().

{ return _counts; }

flagInvalidSolutionInternal()

void SolutionInvalidity::flagInvalidSolutionInternal

(

const InvalidSolutionID

_invalid_solution_id

)

Increments solution invalid occurrences for each solution id.

Definition at line 38 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;
}

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 62 of file SolutionInvalidity.C.

Referenced by SolutionInvalidityOutput::shouldOutput().

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

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 55 of file SolutionInvalidity.C.

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

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

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 48 of file SolutionInvalidity.C.

Referenced by hasInvalidSolution().

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

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 120 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 206 of file SolutionInvalidity.C.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

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

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 127 of file SolutionInvalidity.C.

Referenced by SolutionInvalidityOutput::output().

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

resetSolutionInvalidCurrentIteration()

void SolutionInvalidity::resetSolutionInvalidCurrentIteration

(

)

Reset the number of solution invalid occurrences back to zero.

Definition at line 68 of file SolutionInvalidity.C.

Referenced by NonlinearSystemBase::jacobianSetup(), and NonlinearSystemBase::residualSetup().

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

resetSolutionInvalidTimeStep()

void SolutionInvalidity::resetSolutionInvalidTimeStep

(

)

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

Definition at line 76 of file SolutionInvalidity.C.

Referenced by NonlinearSystem::solve().

{
  // Reset that we have synced because we're on a new iteration
  _has_synced = false;

  for (auto & entry : _counts)
    entry.current_timestep_counts = 0;
}

solutionInvalidAccumulation()

void SolutionInvalidity::solutionInvalidAccumulation

(

)

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

Definition at line 86 of file SolutionInvalidity.C.

Referenced by NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), and NonlinearSystemBase::computeResidualInternal().

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

solutionInvalidAccumulationTimeStep()

void SolutionInvalidity::solutionInvalidAccumulationTimeStep

(

const unsigned int

timestep_index

)

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

Definition at line 93 of file SolutionInvalidity.C.

Referenced by NonlinearSystem::solve().

{
  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;
    }
}

summaryTable()

SolutionInvalidity::FullTable SolutionInvalidity::summaryTable ( ) const

private

Build a VariadicTable for solution invalidity.

Definition at line 213 of file SolutionInvalidity.C.

Referenced by print().

{
  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;
}

syncIteration()

void SolutionInvalidity::syncIteration

(

)

Sync iteration counts to main processor.

Definition at line 135 of file SolutionInvalidity.C.

Referenced by SolverSystem::checkInvalidSolution(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualInternal(), dataStore(), and SolutionInvalidityOutput::shouldOutput().

{
  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);

  // We've now synced
  _has_synced = true;
}

transientTable()

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

private

Build a VariadicTable for solution invalidity history.

Definition at line 257 of file SolutionInvalidity.C.

Referenced by printHistory().

{
  mooseAssert(_has_synced, "Has not synced");

  TimeTable vtable({"Object", "Time", "Stepinterval 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())
      {
        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)
          {
            if (ts_count.timestep_index >= start_it && ts_count.timestep_index < 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 =
            std::to_string(interval_index) + "-" + std::to_string(interval_index + step_interval);

        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;
}

Friends And Related Function Documentation

dataLoad

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

friend

Definition at line 377 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 348 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(), MeshOnlyAction::act(), SetupDebugAction::act(), MaterialOutputAction::act(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkRelativeConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), LinearSystem::computeLinearSystemTags(), FEProblemBase::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MFEMSteady::execute(), MessageFromInput::execute(), SteadyBase::execute(), Eigenvalue::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), CoarsenBlockGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseBaseErrorInterface::mooseDeprecated(), MooseBaseErrorInterface::mooseInfo(), MooseBaseErrorInterface::mooseWarning(), MooseBaseErrorInterface::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ReporterDebugOutput::output(), PerfGraphOutput::output(), SolutionInvalidityOutput::output(), MaterialPropertyDebugOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), printDebug(), EigenExecutionerBase::printEigenvalue(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), PicardSolve::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(), EigenProblem::solve(), NonlinearSystem::solve(), LinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), LStableDirk4::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), FixedPointSolve::solveStep(), PerfGraphLivePrint::start(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), TerminateChainControl::terminate(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_counts

std::vector<InvalidCounts> SolutionInvalidity::_counts

private

Store the solution invalidity counts.

Definition at line 156 of file SolutionInvalidity.h.

Referenced by computeTotalCounts(), counts(), dataLoad(), dataStore(), flagInvalidSolutionInternal(), resetSolutionInvalidCurrentIteration(), resetSolutionInvalidTimeStep(), solutionInvalidAccumulation(), solutionInvalidAccumulationTimeStep(), summaryTable(), syncIteration(), and transientTable().

_has_solution_error

bool SolutionInvalidity::_has_solution_error

private

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

Definition at line 163 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 161 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 159 of file SolutionInvalidity.h.

Referenced by computeTotalCounts(), hasInvalidSolutionError(), hasInvalidSolutionWarning(), resetSolutionInvalidTimeStep(), 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 135 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 153 of file SolutionInvalidity.h.

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

---

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

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