SolutionInvalidInterface

Tracking warning occurences

The SolutionInvalidInterface tracks the occurences of mooseWarning and paramWarning across all MooseObject and MOOSE Action System. If any, these occurences are reported by the SolutionInvalidityOutput, displayed at the end of the simulation.

Declaring a solution as invalid

The SolutionInvalidInterface defines the method used to mark a solution as "invalid". An invalid solution means that the solution somehow does not satisfy requirements such as a value being out of bounds of a correlation. Solutions are allowed to be invalid _during_ the nonlinear solve - but are not allowed to invalid once it converges. A "converged" solution that is marked as invalid will cause MOOSE to behave as if the solution did NOT converge - including cutting back timesteps, etc.

This can be overridden by setting Problem/allow_invalid_solution=true.

#pragma once

// MOOSE includes
#include "Moose.h"
#include "SolutionInvalidity.h"
#include "MooseBase.h"

// Forward declarations
class FEProblemBase;

#define flagInvalidSolution(message)                                                               \
  do                                                                                               \
  {                                                                                                \
    static const auto __invalid_id = this->registerInvalidSolutionInternal(message, false);        \
    this->flagInvalidSolutionInternal<false>(__invalid_id);                                        \
  } while (0)

#define flagSolutionWarning(message)                                                               \
  do                                                                                               \
  {                                                                                                \
    static const auto __invalid_id = this->registerInvalidSolutionInternal(message, true);         \
    this->flagInvalidSolutionInternal<true>(__invalid_id);                                         \
  } while (0)

// This macro is useful when we have different messages but appearing in the same place in the code
// for example when nesting a solution warning creation under the mooseWarning
#define flagSolutionWarningMultipleRegistration(message)                                           \
  do                                                                                               \
  {                                                                                                \
    const auto __invalid_id = this->registerInvalidSolutionInternal(message, true);                \
    this->flagInvalidSolutionInternal<true>(__invalid_id);                                         \
  } while (0)

// Every class using this interface must specify either
// 'usingCombinedWarningSolutionWarnings' or 'usingMooseBaseWarnings'
#define usingCombinedWarningSolutionWarnings                                                       \
  using SolutionInvalidInterface::mooseWarning;                                                    \
  using SolutionInvalidInterface::mooseWarningNonPrefixed;                                         \
  using SolutionInvalidInterface::mooseDeprecated;                                                 \
  using SolutionInvalidInterface::paramWarning
#define usingMooseBaseWarnings                                                                     \
  using MooseBase::mooseWarning;                                                                   \
  using MooseBase::mooseWarningNonPrefixed;                                                        \
  using MooseBase::mooseDeprecated;                                                                \
  using MooseBase::paramWarning

/**
 * An interface that allows the marking of invalid solutions during a solve
 */
class SolutionInvalidInterface
{
public:
  SolutionInvalidInterface(const MooseBase * const moose_base, const InputParameters & params);

#ifdef MOOSE_KOKKOS_ENABLED
  /**
   * Special constructor used for Kokkos functor copy during parallel dispatch
   */
  SolutionInvalidInterface(const SolutionInvalidInterface & object,
                           const Moose::Kokkos::FunctorCopy & key);
#endif

  template <typename... Args>
  void mooseWarning(Args &&... args) const
  {
    _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

  template <typename... Args>
  void mooseWarningNonPrefixed(Args &&... args) const
  {
    _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

  template <typename... Args>
  void mooseDeprecated(Args &&... args) const
  {
    _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
  }

  template <typename... Args>
  void paramWarning(const std::string & param, Args... args) const
  {
    _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
                                            param + "'");
  }

protected:
  template <bool warning>
  void flagInvalidSolutionInternal(const InvalidSolutionID invalid_solution_id) const;

  // Register invalid solution with a message
  InvalidSolutionID registerInvalidSolutionInternal(const std::string & message,
                                                    const bool warning) const;

private:
  /// The MooseBase that owns this interface
  const MooseBase & _si_moose_base;

  /// A pointer to FEProblem base
  const FEProblemBase * _si_problem;
};