#include <PicardSolve.h>

Inheritance diagram for PicardSolve:

Public Types
enum	MooseFixedPointConvergenceReason { MooseFixedPointConvergenceReason::UNSOLVED = 0, MooseFixedPointConvergenceReason::CONVERGED_NONLINEAR = 1, MooseFixedPointConvergenceReason::CONVERGED_ABS = 2, MooseFixedPointConvergenceReason::CONVERGED_RELATIVE = 3, MooseFixedPointConvergenceReason::CONVERGED_CUSTOM = 4, MooseFixedPointConvergenceReason::REACH_MAX_ITS = 5, MooseFixedPointConvergenceReason::DIVERGED_MAX_ITS = -1, MooseFixedPointConvergenceReason::DIVERGED_NONLINEAR = -2, MooseFixedPointConvergenceReason::DIVERGED_FAILED_MULTIAPP = -3 }
	Enumeration for fixed point convergence reasons. More...

using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name. More...

Public Member Functions
	PicardSolve (Executioner &ex)

virtual void	allocateStorage (const bool primary) override final
	Allocate storage for the fixed point algorithm. More...

virtual bool	solve () override
	Iteratively solves the FEProblem. More...

unsigned int	numFixedPointIts () const
	Get the number of fixed point iterations performed Because this returns the number of fixed point iterations, rather than the current iteration count (which starts at 0), increment by 1. More...

unsigned int	numPicardIts () const
	Deprecated getter for the number of fixed point iterations. More...

MooseFixedPointConvergenceReason	checkConvergence () const
	Check the solver status. More...

bool	XFEMRepeatStep () const
	This function checks the _xfem_repeat_step flag set by solve. More...

void	clearFixedPointStatus ()
	Clear fixed point status. More...

bool	hasFixedPointIteration ()
	Whether or not this has fixed point iterations. More...

void	setMultiAppRelaxationFactor (Real factor)
	Set relaxation factor for the current solve as a SubApp. More...

void	setMultiAppTransformedVariables (const std::vector< std::string > &vars)
	Set relaxation variables for the current solve as a SubApp. More...

virtual void	setMultiAppTransformedPostprocessors (const std::vector< PostprocessorName > &pps)
	Set relaxation postprocessors for the current solve as a SubApp. More...

bool	autoAdvance () const
	Whether sub-applications are automatically advanced no matter what happens during their solves. More...

void	failStep ()
	Mark the current solve as failed due to external conditions. More...

virtual void	setInnerSolve (SolveObject &solve)
	Set the inner solve object wrapped by this object. More...

virtual bool	enabled () const
	Return the enabled status of the object. More...

std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group. More...

std::shared_ptr< const MooseObject >	getSharedPtr () const

MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with. More...

const std::string &	type () const
	Get the type of this class. More...

virtual const std::string &	name () const
	Get the name of the class. More...

std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling. More...

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const
	Calls moose error with the message `msg`. More...

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
	The unique parameter name of a valid parameter of this object for accessing parameter controls. More...

const InputParameters &	parameters () const
	Get the parameters of the object. More...

MooseObjectName	uniqueName () const
	The unique name for accessing input parameters of this object in the InputParameterWarehouse. More...

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object. More...

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object. More...

template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object. More...

template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...

bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...

bool	isParamSetByUser (const std::string &nm) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default. More...

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action. More...

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type. More...

template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError(). More...

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
	Emits a documented error with object name and type. More...

template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type. More...

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning(). More...

template<typename... Args>
void	mooseDeprecated (Args &&... args) const

template<typename... Args>
void	mooseInfo (Args &&... args) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

std::string	getDataFileName (const std::string &param) const
	Returns the path of a data file for a given FileName type parameter, searching (in the following order) More...

std::string	getDataFileNameByName (const std::string &name, const std::string *param=nullptr) const
	Returns the path of a data file for a given relative file path. More...

PerfGraph &	perfGraph ()
	Get the PerfGraph. More...

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
	Determine whether or not the Postprocessor is a default value. More...

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const
	Determine if the Postprocessor data exists. More...

bool	hasPostprocessorByName (const PostprocessorName &name) const
	Determine if the Postprocessor data exists. More...

std::size_t	coupledPostprocessors (const std::string &param_name) const
	Returns number of Postprocessors coupled under parameter name. More...

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const
	Get the name of a postprocessor. More...


const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
	doco-normal-methods-begin Retrieve the value of a Postprocessor or one of it's old or older values More...

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const


virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const
	Retrieve the value of the Postprocessor. More...

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects. More...

Protected Member Functions
virtual bool	solveStep (Real &begin_norm, Real &end_norm, const std::set< dof_id_type > &transformed_dofs)
	Perform one fixed point iteration or a full solve. More...

virtual void	saveAllValues (const bool primary)
	Save both the variable and postprocessor values. More...

void	computeCustomConvergencePostprocessor ()
	Computes and prints the user-specified postprocessor assessing convergence. More...

bool	examineFixedPointConvergence (bool &converged)
	Examine the various convergence metrics. More...

void	printFixedPointConvergenceReason ()
	Print information about the fixed point convergence. More...

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing. More...

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing. More...

std::string	timedSectionName (const std::string &section_name) const

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const
	Helper for deriving classes to override to add dependencies when a Postprocessor is requested. More...

Protected Attributes
unsigned int	_min_fixed_point_its
	Minimum fixed point iterations. More...

unsigned int	_max_fixed_point_its
	Maximum fixed point iterations. More...

bool	_has_fixed_point_its
	Whether or not we activate fixed point iteration. More...

bool	_accept_max_it
	Whether or not to treat reaching maximum number of fixed point iteration as converged. More...

bool	_has_fixed_point_norm
	Whether or not to use residual norm to check the fixed point convergence. More...

Real	_fixed_point_rel_tol
	Relative tolerance on residual norm. More...

Real	_fixed_point_abs_tol
	Absolute tolerance on residual norm. More...

bool	_fixed_point_force_norms
	Whether or not we force evaluation of residual norms even without multiapps. More...

const PostprocessorValue *	_fixed_point_custom_pp
	Postprocessor value for user-defined fixed point convergence check. More...

const Real	_relax_factor
	Relaxation factor for fixed point Iteration. More...

std::vector< std::string >	_transformed_vars
	The variables (transferred or not) that are going to be relaxed. More...

const std::vector< PostprocessorName >	_transformed_pps
	The postprocessors (transferred or not) that are going to be relaxed. More...

std::vector< std::vector< PostprocessorValue > >	_transformed_pps_values
	Previous values of the relaxed postprocessors. More...

Real	_secondary_relaxation_factor
	Relaxation factor outside of fixed point iteration (used as a subapp) More...

std::vector< std::string >	_secondary_transformed_variables
	Variables to be relaxed outside of fixed point iteration (used as a subapp) More...

std::vector< PostprocessorName >	_secondary_transformed_pps
	Postprocessors to be relaxed outside of fixed point iteration (used as a subapp) More...

std::vector< std::vector< PostprocessorValue > >	_secondary_transformed_pps_values
	Previous values of the postprocessors relaxed outside of the fixed point iteration (used as a subapp) More...

Executioner &	_executioner
	Executioner used to construct this. More...

FEProblemBase &	_problem
	Reference to FEProblem. More...

std::shared_ptr< DisplacedProblem >	_displaced_problem
	Displaced problem. More...

MooseMesh &	_mesh
	Mesh. More...

MooseMesh *	_displaced_mesh
	Displaced mesh. More...

SystemBase &	_solver_sys
	Reference to a system for creating vectors as needed for the solve, etc. More...

AuxiliarySystem &	_aux
	Reference to auxiliary system for faster access. More...

SolveObject *	_inner_solve
	SolveObject wrapped by this solve object. More...

const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects. More...

MooseApp &	_app
	The MOOSE application this is associated with. More...

const std::string	_type
	The type of this class. More...

const std::string	_name
	The name of this class. More...

const InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...

Factory &	_factory
	The Factory associated with the MooseApp. More...

ActionFactory &	_action_factory
	Builds Actions. More...

const Parallel::Communicator &	_communicator

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...

const std::string	_prefix
	A prefix to use for all sections. More...


unsigned int	_fixed_point_it

unsigned int	_main_fixed_point_it
	fixed point iteration counter for the main app More...

Real	_fixed_point_initial_norm
	Initial residual norm. More...

std::vector< Real >	_fixed_point_timestep_begin_norm
	Full history of residual norm after evaluation of timestep_begin. More...

std::vector< Real >	_fixed_point_timestep_end_norm
	Full history of residual norm after evaluation of timestep_end. More...

MooseFixedPointConvergenceReason	_fixed_point_status
	Status of fixed point solve. More...

Private Member Functions
virtual void	saveVariableValues (const bool primary) override final
	Saves the current values of the variables, and update the old(er) vectors. More...

virtual void	savePostprocessorValues (const bool primary) override final
	Saves the current values of the postprocessors, and update the old(er) vectors. More...

virtual bool	useFixedPointAlgorithmUpdateInsteadOfPicard (const bool primary) override final
	Use the fixed point algorithm transform instead of simply using the Picard update. More...

virtual void	transformPostprocessors (const bool primary) override final
	Use the fixed point algorithm to transform the postprocessors. More...

virtual void	transformVariables (const std::set< dof_id_type > &transformed_dofs, const bool primary) override final
	Use the fixed point algorithm to transform the variables. More...

virtual void	printFixedPointConvergenceHistory () override final
	Print the convergence history of the coupling, at every coupling iteration. More...

Private Attributes
TagID	_old_tag_id
	Vector tag id for the previous solution variable, as a main app. More...

TagID	_secondary_old_tag_id
	Vector tag id for the previous solution variable, as a sub app. More...

Detailed Description

Definition at line 18 of file PicardSolve.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface< MooseObject >::DataFileParameterType = DataFileName

inherited

The parameter type this interface expects for a data file name.

Definition at line 26 of file DataFileInterface.h.

Member Enumeration Documentation

◆ MooseFixedPointConvergenceReason

enum FixedPointSolve::MooseFixedPointConvergenceReason

stronginherited

Enumeration for fixed point convergence reasons.

Enumerator
UNSOLVED
CONVERGED_NONLINEAR
CONVERGED_ABS
CONVERGED_RELATIVE
CONVERGED_CUSTOM
REACH_MAX_ITS
DIVERGED_MAX_ITS
DIVERGED_NONLINEAR
DIVERGED_FAILED_MULTIAPP

Definition at line 33 of file FixedPointSolve.h.

   {
     UNSOLVED = 0,
     CONVERGED_NONLINEAR = 1,
     CONVERGED_ABS = 2,
     CONVERGED_RELATIVE = 3,
     CONVERGED_CUSTOM = 4,
     REACH_MAX_ITS = 5,
     DIVERGED_MAX_ITS = -1,
     DIVERGED_NONLINEAR = -2,
     DIVERGED_FAILED_MULTIAPP = -3
   };

Constructor & Destructor Documentation

◆ PicardSolve()

PicardSolve::PicardSolve ( Executioner & ex )

Definition at line 71 of file PicardSolve.C.

                                          : FixedPointSolve(ex)
 {
   // Handle deprecated parameters
   if (!parameters().isParamSetByAddParam("picard_max_its"))
   {
     _max_fixed_point_its = getParam<unsigned int>("picard_max_its");
     _has_fixed_point_its = _max_fixed_point_its > 1;
   }
 
   if (!parameters().isParamSetByAddParam("accept_on_max_picard_iteration"))
     _accept_max_it = getParam<bool>("accept_on_max_picard_iteration");
 
   if (!parameters().isParamSetByAddParam("disable_picard_residual_norm_check"))
     _has_fixed_point_norm = !getParam<bool>("disable_picard_residual_norm_check");
 
   if (!parameters().isParamSetByAddParam("picard_rel_tol"))
     _fixed_point_rel_tol = getParam<Real>("picard_rel_tol");
 
   if (!parameters().isParamSetByAddParam("picard_abs_tol"))
     _fixed_point_abs_tol = getParam<Real>("picard_abs_tol");
 
   if (isParamValid("picard_custom_pp"))
     _fixed_point_custom_pp = &getPostprocessorValue("picard_custom_pp");
 
   if (!parameters().isParamSetByAddParam("picard_force_norms"))
     _fixed_point_force_norms = getParam<bool>("picard_force_norms");
 
   allocateStorage(true);
 }

Member Function Documentation

◆ addPostprocessorDependencyHelper()

virtual void PostprocessorInterface::addPostprocessorDependencyHelper ( const PostprocessorName & ) const

inlineprotectedvirtualinherited

Helper for deriving classes to override to add dependencies when a Postprocessor is requested.

Reimplemented in AuxKernelTempl< ComputeValueType >, AuxKernelTempl< RT >, AuxKernelTempl< RealVectorValue >, AuxKernelTempl< Real >, UserObject, and InitialConditionBase.

Definition at line 141 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal().

141 {}

◆ allocateStorage()

void PicardSolve::allocateStorage ( const bool primary )

finaloverridevirtual

Allocate storage for the fixed point algorithm.

This creates the system vector of old (older, pre/post solve) variable values and the array of old (older, pre/post solve) postprocessor values.

Parameters

primary Whether this routine is to allocate storage for the primary transformed quantities (as main app) or the secondary ones (as a subapp)

Implements FixedPointSolve.

Definition at line 102 of file PicardSolve.C.

Referenced by PicardSolve().

 {
   Real relaxation_factor;
   TagID old_tag_id;
   const std::vector<PostprocessorName> * transformed_pps;
   std::vector<std::vector<PostprocessorValue>> * transformed_pps_values;
   if (primary)
   {
     relaxation_factor = _relax_factor;
     old_tag_id = _problem.addVectorTag("xn_m1", Moose::VECTOR_TAG_SOLUTION);
     _old_tag_id = old_tag_id;
     transformed_pps = &_transformed_pps;
     transformed_pps_values = &_transformed_pps_values;
   }
   else
   {
     relaxation_factor = _secondary_relaxation_factor;
     old_tag_id = _problem.addVectorTag("secondary_xn_m1", Moose::VECTOR_TAG_SOLUTION);
     _secondary_old_tag_id = old_tag_id;
     transformed_pps = &_secondary_transformed_pps;
     transformed_pps_values = &_secondary_transformed_pps_values;
   }
 
   if (relaxation_factor != 1.)
   {
     // Store a copy of the previous solution
     _solver_sys.addVector(old_tag_id, false, PARALLEL);
 
     // Allocate storage for the previous postprocessor values
     (*transformed_pps_values).resize((*transformed_pps).size());
     for (size_t i = 0; i < (*transformed_pps).size(); i++)
       (*transformed_pps_values)[i].resize(1);
   }
 }

◆ autoAdvance()

bool FixedPointSolve::autoAdvance ( ) const

inherited

Whether sub-applications are automatically advanced no matter what happens during their solves.

Definition at line 599 of file FixedPointSolve.C.

Referenced by FixedPointSolve::solve(), and FixedPointSolve::solveStep().

 {
   bool auto_advance = !(_has_fixed_point_its && _problem.isTransient());
 
   if (dynamic_cast<EigenExecutionerBase *>(&_executioner) && _has_fixed_point_its)
     auto_advance = true;
 
   if (_auto_advance_set_by_user)
     auto_advance = _auto_advance_user_value;
 
   return auto_advance;
 }

◆ callMooseError()

void MooseBase::callMooseError	(	std::string	msg,
		const bool	with_prefix
	)		const

inherited

Calls moose error with the message msg.

Will prefix the message with the subapp name if one exists.

If with_prefix, then add the prefix from errorPrefix() to the error.

Definition at line 33 of file MooseBase.C.

Referenced by InputParameters::callMooseErrorHelper(), MooseBaseErrorInterface::mooseDocumentedError(), MooseBaseErrorInterface::mooseError(), MooseBaseErrorInterface::mooseErrorNonPrefixed(), and MooseBaseParameterInterface::paramError().

 {
   _app.getOutputWarehouse().mooseConsole();
   const std::string prefix = _app.isUltimateMaster() ? "" : _app.name();
   if (with_prefix)
     msg = errorPrefix("error") + msg;
   moose::internal::mooseErrorRaw(msg, prefix);
 }

◆ checkConvergence()

MooseFixedPointConvergenceReason FixedPointSolve::checkConvergence ( ) const

inlineinherited

Check the solver status.

Definition at line 64 of file FixedPointSolve.h.

64 { return _fixed_point_status; }

FixedPointSolve::_fixed_point_status

MooseFixedPointConvergenceReason _fixed_point_status

Status of fixed point solve.

Definition: FixedPointSolve.h:237

◆ clearFixedPointStatus()

void FixedPointSolve::clearFixedPointStatus ( )

inlineinherited

Clear fixed point status.

Definition at line 70 of file FixedPointSolve.h.

70 { _fixed_point_status = MooseFixedPointConvergenceReason::UNSOLVED; }

FixedPointSolve::MooseFixedPointConvergenceReason::UNSOLVED

FixedPointSolve::_fixed_point_status

MooseFixedPointConvergenceReason _fixed_point_status

Status of fixed point solve.

Definition: FixedPointSolve.h:237

◆ computeCustomConvergencePostprocessor()

void FixedPointSolve::computeCustomConvergencePostprocessor ( )

protectedinherited

Computes and prints the user-specified postprocessor assessing convergence.

Definition at line 501 of file FixedPointSolve.C.

Referenced by FixedPointSolve::solve().

 {
   if ((_fixed_point_it == 0 && getParam<bool>("direct_pp_value")) ||
       !getParam<bool>("direct_pp_value"))
     _pp_scaling = *_fixed_point_custom_pp;
   _pp_new = *_fixed_point_custom_pp;
 
   auto ppname = getParam<PostprocessorName>("custom_pp");
   _pp_history << std::setw(2) << _fixed_point_it + 1 << " fixed point " << ppname << " = "
               << Console::outputNorm(std::numeric_limits<Real>::max(), _pp_new, 8) << std::endl;
   _console << _pp_history.str();
 }

◆ connectControllableParams()

void MooseBaseParameterInterface::connectControllableParams	(	const std::string &	parameter,
		const std::string &	object_type,
		const std::string &	object_name,
		const std::string &	object_parameter
	)		const

inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 33 of file MooseBaseParameterInterface.C.

 {
   MooseObjectParameterName primary_name(uniqueName(), parameter);
   const auto base_type = _factory.getValidParams(object_type).get<std::string>("_moose_base");
   MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
   _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
       primary_name, secondary_name);
 
   const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
   for (const auto & tag : tags)
   {
     if (!tag.empty())
     {
       MooseObjectParameterName tagged_name(tag, _moose_base.name(), parameter);
       _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
           tagged_name, secondary_name);
     }
   }
 }

◆ coupledPostprocessors()

std::size_t PostprocessorInterface::coupledPostprocessors ( const std::string & param_name ) const

inherited

Returns number of Postprocessors coupled under parameter name.

Parameters

param_name The name of the Postprocessor parameter

Returns: Number of coupled post-processors, 1 if it's a single

Definition at line 129 of file PostprocessorInterface.C.

Referenced by FunctionValuePostprocessor::FunctionValuePostprocessor().

 {
   checkParam(param_name);
 
   if (_ppi_params.isType<PostprocessorName>(param_name))
     return 1;
   return _ppi_params.get<std::vector<PostprocessorName>>(param_name).size();
 }

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 50 of file MooseObject.h.

Referenced by EigenKernel::enabled().

50 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition: MooseObject.h:61

◆ errorPrefix()

std::string MooseBase::errorPrefix ( const std::string & error_type ) const

inherited

Returns: A prefix to be used in errors that contains the input file location associated with this object (if any) and the name and type of the object.

Definition at line 43 of file MooseBase.C.

Referenced by MooseBase::callMooseError(), MooseBaseErrorInterface::mooseWarning(), and MooseBaseParameterInterface::paramErrorMsg().

 {
   std::stringstream oss;
   if (const auto node = _params.getHitNode())
     if (!node->isRoot())
       oss << node->fileLocation() << ":\n";
   oss << "The following " << error_type << " occurred in the ";
   if (const auto base_ptr = _params.getBase())
     oss << *base_ptr;
   else
     oss << "object";
   oss << " '" << name() << "' of type " << type() << ".\n\n";
   return oss.str();
 }

◆ examineFixedPointConvergence()

bool FixedPointSolve::examineFixedPointConvergence ( bool & converged )

protectedinherited

Examine the various convergence metrics.

Definition at line 515 of file FixedPointSolve.C.

Referenced by FixedPointSolve::solve().

 {
   if (_fixed_point_it + 2 > _min_fixed_point_its)
   {
     Real max_norm = std::max(_fixed_point_timestep_begin_norm[_fixed_point_it],
                              _fixed_point_timestep_end_norm[_fixed_point_it]);
 
     Real max_relative_drop = max_norm / _fixed_point_initial_norm;
 
     if (_has_fixed_point_norm && max_norm < _fixed_point_abs_tol)
     {
       _fixed_point_status = MooseFixedPointConvergenceReason::CONVERGED_ABS;
       return true;
     }
     if (_has_fixed_point_norm && max_relative_drop < _fixed_point_rel_tol)
     {
       _fixed_point_status = MooseFixedPointConvergenceReason::CONVERGED_RELATIVE;
       return true;
     }
     if (std::abs(_pp_new - _pp_old) < _custom_abs_tol)
     {
       _fixed_point_status = MooseFixedPointConvergenceReason::CONVERGED_CUSTOM;
       return true;
     }
     if (std::abs((_pp_new - _pp_old) / _pp_scaling) < _custom_rel_tol)
     {
       _fixed_point_status = MooseFixedPointConvergenceReason::CONVERGED_CUSTOM;
       return true;
     }
   }
   if (_fixed_point_it + 1 == _max_fixed_point_its)
   {
     if (_accept_max_it)
     {
       _fixed_point_status = MooseFixedPointConvergenceReason::REACH_MAX_ITS;
       converged = true;
     }
     else
     {
       _fixed_point_status = MooseFixedPointConvergenceReason::DIVERGED_MAX_ITS;
       converged = false;
     }
     return true;
   }
   return false;
 }

◆ failStep()

void FixedPointSolve::failStep ( )

inlineinherited

Mark the current solve as failed due to external conditions.

Definition at line 104 of file FixedPointSolve.h.

Referenced by Terminator::execute().

104 { _fail_step = true; }

FixedPointSolve::_fail_step

bool _fail_step

force the current step to fail, triggering are repeat with a cut dt

Definition: FixedPointSolve.h:267

◆ getCheckedPointerParam()

template<typename T >

T MooseBaseParameterInterface::getCheckedPointerParam	(	const std::string &	name,
		const std::string &	error_string = `""`
	)		const

inherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 268 of file MooseBaseParameterInterface.h.

 {
   return parameters().getCheckedPointerParam<T>(name, error_string);
 }

◆ getDataFileName()

std::string DataFileInterface< MooseObject >::getDataFileName ( const std::string & param ) const

inherited

Returns the path of a data file for a given FileName type parameter, searching (in the following order)

relative to the input file directory
relative to the running binary (assuming the application is installed)
relative to all registered data file directories

Definition at line 24 of file DataFileInterface.C.

 {
   // The path from the parameters, which has not been modified because it is a DataFileName
   const auto & value = _parent.template getParam<DataFileParameterType>(param);
   if (value.empty())
     _parent.paramInfo(param, "Data file name is empty");
 
   const std::filesystem::path value_path = std::filesystem::path(std::string(value));
 
   // If the file is absolute, we should reference that directly and don't need to add
   // any info beacuse this is not ambiguous
   if (value_path.is_absolute() && MooseUtils::checkFileReadable(value, false, false, false))
     return value;
 
   // Look relative to the input file
   const auto base = _parent.parameters().getParamFileBase(param);
   const std::string relative_to_context = std::filesystem::absolute(base / value_path).c_str();
   if (MooseUtils::checkFileReadable(relative_to_context, false, false, false))
   {
     _parent.paramInfo(param, "Data file '", value, "' found relative to the input file.");
     return relative_to_context;
   }
 
   // Isn't absolute and couldn't find relative to the input file, so search the data
   return getDataFileNameByName(value, &param);
 }

◆ getDataFileNameByName()

std::string DataFileInterface< MooseObject >::getDataFileNameByName	(	const std::string &	name,
		const std::string *	param = `nullptr`
	)		const

inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName. The optional param pointer can be used to turn the mooseErrors this function emits into paramErrors

relative to the running binary (assuming the application is installed)
relative to all registered data file directories

Definition at line 53 of file DataFileInterface.C.

 {
   const auto share_dir = MooseUtils::pathjoin(Moose::getExecutablePath(), "..", "share");
   if (MooseUtils::pathIsDirectory(share_dir))
   {
     const auto dirs = MooseUtils::listDir(share_dir, false);
     for (const auto & data_dir : dirs)
     {
       const auto path = MooseUtils::pathjoin(data_dir, "data", relative_path);
       if (MooseUtils::checkFileReadable(path, false, false, false))
       {
         if (param)
           _parent.paramInfo(
               *param, "Data file '", path, "' found in an installed app distribution.");
         else
           mooseInfo("Data file '", path, "' found in an installed app distribution.");
         return path;
       }
     }
   }
 
   for (const auto & data_dir : Registry::getRegistry().getDataFilePaths())
   {
     const auto path = MooseUtils::pathjoin(data_dir, relative_path);
     if (MooseUtils::checkFileReadable(path, false, false, false))
     {
       if (param)
         _parent.paramInfo(*param, "Data file '", path, "' found in a source repository.");
       else
         mooseInfo("Data file '", path, "' found in a source repository.");
       return path;
     }
   }
 
   mooseException(param ? _parent.parameters().inputLocation(*param) : _parent.name(),
                  ": Unable to find data file '",
                  relative_path,
                  "' anywhere");
 }

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

Referenced by ReporterTransferInterface::checkHasReporterValue(), Coupleable::checkWritableVar(), MooseBaseParameterInterface::connectControllableParams(), Coupleable::Coupleable(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

45 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:84

◆ getParam() [1/2]

template<typename T >

const T & MooseBaseParameterInterface::getParam ( const std::string & name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 204 of file MooseBaseParameterInterface.h.

 {
   return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0), &_moose_base);
 }

◆ getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBaseParameterInterface::getParam	(	const std::string &	param1,
		const std::string &	param2
	)		const

inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters

param1	The name of first parameter
param2	The name of second parameter

Returns: Vector of pairs of first and second parameters

Definition at line 261 of file MooseBaseParameterInterface.h.

 {
   return _pars.get<T1, T2>(param1, param2);
 }

◆ getPostprocessorName()

const PostprocessorName & PostprocessorInterface::getPostprocessorName	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Get the name of a postprocessor.

This can only be used if the postprocessor parameter does not have a default value set (see isDefaultPostprocessorValue()), in which case the "name" is actually the default value.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the Postprocessor

Returns: The name of the given Postprocessor

Definition at line 185 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel().

 {
   return getPostprocessorNameInternal(param_name, index, /* allow_default_value = */ false);
 }

◆ getPostprocessorValue()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValue	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

doco-normal-methods-begin Retrieve the value of a Postprocessor or one of it's old or older values

Parameters

param_name	The name of the Postprocessor parameter (see below)
index	The index of the Postprocessor

Returns: A reference to the desired value

The name required by this method is the name that is hard-coded into your source code. For example, if you have a Kernel that requires a Postprocessor you may have an input file with "pp = my_pp", this function requires the "pp" name as input (see .../moose_test/functions/PostprocessorFunction.C)

see getPostprocessorValueByName getPostprocessorValueOldByName getPostprocessorValueOlderByName

Definition at line 36 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel(), FunctionValuePostprocessor::FunctionValuePostprocessor(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), ParsedPostprocessor::ParsedPostprocessor(), and PicardSolve().

 {
   return getPostprocessorValueInternal(param_name, index, /* t_index = */ 0);
 }

◆ getPostprocessorValueByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueByName ( const PostprocessorName & name ) const

virtualinherited

Retrieve the value of the Postprocessor.

Parameters

name	Postprocessor name (see below)

Returns: A reference to the desired value

The name required by this method is the name defined in the input file. For example, if you have a Kernel that requires a Postprocessor you may have an input file with "pp = my_pp", this method requires the "my_pp" name as input (see .../moose_test/functions/PostprocessorFunction.C)

see getPostprocessorValue getPostprocessorValueOld getPostprocessorValueOlder

Definition at line 57 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel(), PIDTransientControl::execute(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), ParsedODEKernel::ParsedODEKernel(), SecantSolve::savePostprocessorValues(), SteffensenSolve::savePostprocessorValues(), savePostprocessorValues(), WebServerControl::startServer(), Terminator::Terminator(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), transformPostprocessors(), and VectorOfPostprocessors::VectorOfPostprocessors().

 {
   return getPostprocessorValueByNameInternal(name, /* t_index = */ 0);
 }

◆ getPostprocessorValueOld()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOld	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Definition at line 43 of file PostprocessorInterface.C.

 {
   return getPostprocessorValueInternal(param_name, index, /* t_index = */ 1);
 }

◆ getPostprocessorValueOldByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOldByName ( const PostprocessorName & name ) const

inherited

Definition at line 63 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel().

 {
   return getPostprocessorValueByNameInternal(name, /* t_index = */ 1);
 }

◆ getPostprocessorValueOlder()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOlder	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Definition at line 50 of file PostprocessorInterface.C.

 {
   return getPostprocessorValueInternal(param_name, index, /* t_index = */ 2);
 }

◆ getPostprocessorValueOlderByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOlderByName ( const PostprocessorName & name ) const

inherited

Definition at line 69 of file PostprocessorInterface.C.

 {
   return getPostprocessorValueByNameInternal(name, /* t_index = */ 2);
 }

◆ getRenamedParam()

template<typename T >

const T & MooseBaseParameterInterface::getRenamedParam	(	const std::string &	old_name,
		const std::string &	new_name
	)		const

inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters

old_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 211 of file MooseBaseParameterInterface.h.

 {
   // this enables having a default on the new parameter but bypassing it with the old one
   // Most important: accept new parameter
   if (isParamSetByUser(new_name) && !isParamValid(old_name))
     return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
   // Second most: accept old parameter
   else if (isParamValid(old_name) && !isParamSetByUser(new_name))
     return InputParameters::getParamHelper(old_name, _pars, static_cast<T *>(0), &_moose_base);
   // Third most: accept default for new parameter
   else if (isParamValid(new_name) && !isParamValid(old_name))
     return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
   // Refuse: no default, no value passed
   else if (!isParamValid(old_name) && !isParamValid(new_name))
     mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
                "' is being retrieved without being set.\n"
                "Did you misspell it?");
   // Refuse: both old and new parameters set by user
   else
     mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
                "' may not be provided alongside former parameter '" + old_name + "'");
 }

◆ getSharedPtr() [1/2]

std::shared_ptr< MooseObject > MooseObject::getSharedPtr ( )

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 72 of file MooseObject.C.

 {
   try
   {
     return shared_from_this();
   }
   catch (std::bad_weak_ptr &)
   {
     mooseError(not_shared_error);
   }
 }

◆ getSharedPtr() [2/2]

std::shared_ptr< const MooseObject > MooseObject::getSharedPtr ( ) const

inherited

Definition at line 85 of file MooseObject.C.

 {
   try
   {
     return shared_from_this();
   }
   catch (std::bad_weak_ptr &)
   {
     mooseError(not_shared_error);
   }
 }

◆ hasFixedPointIteration()

bool FixedPointSolve::hasFixedPointIteration ( )

inlineinherited

Whether or not this has fixed point iterations.

Definition at line 73 of file FixedPointSolve.h.

73 { return _has_fixed_point_its; }

FixedPointSolve::_has_fixed_point_its

bool _has_fixed_point_its

Whether or not we activate fixed point iteration.

Definition: FixedPointSolve.h:191

◆ hasPostprocessor()

bool PostprocessorInterface::hasPostprocessor	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Determine if the Postprocessor data exists.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the Postprocessor

Returns: True if the Postprocessor exists

See also: hasPostprocessorByName getPostprocessorValue

Definition at line 107 of file PostprocessorInterface.C.

 {
   if (!postprocessorsAdded())
     _ppi_moose_object.mooseError(
         "Cannot call hasPostprocessor() until all Postprocessors have been constructed.");
 
   return hasPostprocessorByName(getPostprocessorNameInternal(param_name, index));
 }

◆ hasPostprocessorByName()

bool PostprocessorInterface::hasPostprocessorByName ( const PostprocessorName & name ) const

inherited

Determine if the Postprocessor data exists.

Parameters

name	The name of the Postprocessor

Returns: True if the Postprocessor exists

See also: hasPostprocessor getPostprocessorValueByName

Definition at line 118 of file PostprocessorInterface.C.

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), AdvancedOutput::initShowHideLists(), TableOutput::outputReporters(), Exodus::outputReporters(), and WebServerControl::startServer().

 {
   if (!postprocessorsAdded())
     _ppi_moose_object.mooseError(
         "Cannot call hasPostprocessorByName() until all Postprocessors have been constructed.");
 
   return _ppi_feproblem.getReporterData().hasReporterValue<PostprocessorValue>(
       PostprocessorReporterName(name));
 }

◆ isDefaultPostprocessorValue()

bool PostprocessorInterface::isDefaultPostprocessorValue	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Determine whether or not the Postprocessor is a default value.

A default value is when the value is either the value set by addParam, or is a user-set value in input instead of a name to a postprocessor.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the postprocessor

Returns: True if the Postprocessor is a default value, false if the Postprocessor is the name of a Postprocessor

Definition at line 75 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel().

 {
   return isDefaultPostprocessorValueByName(getPostprocessorNameInternal(param_name, index));
 }

◆ isParamSetByUser()

bool MooseBaseParameterInterface::isParamSetByUser ( const std::string & nm ) const

inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters

nm	The name of the parameter to test

Definition at line 117 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), SetAdaptivityOptionsAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), PhysicsBase::checkSecondParamSetOnlyIfFirstOneTrue(), LibtorchNeuralNetControl::conditionalParameterError(), FixedPointSolve::FixedPointSolve(), MooseBaseParameterInterface::getRenamedParam(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObject::readXda(), and SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator().

117 { return _pars.isParamSetByUser(nm); }

InputParameters::isParamSetByUser

bool isParamSetByUser(const std::string &name) const

Method returns true if the parameter was by the user.

Definition: InputParameters.C:1074

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:162

◆ isParamValid()

bool MooseBaseParameterInterface::isParamValid ( const std::string & name ) const

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 111 of file MooseBaseParameterInterface.h.

111 { return _pars.isParamValid(name); }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:162

InputParameters::isParamValid

bool isParamValid(const std::string &name) const

This method returns parameters that have been initialized in one fashion or another, i.e.

Definition: InputParameters.C:376

◆ mooseDeprecated()

template<typename... Args>

void MooseBaseErrorInterface::mooseDeprecated ( Args &&... args ) const

inlineinherited

Definition at line 91 of file MooseBaseErrorInterface.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), Executioner::augmentedPicardConvergenceCheck(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), FEProblemBase::computeResidual(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), Executioner::picardSolve(), ReferenceResidualProblem::ReferenceResidualProblem(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), and UserForcingFunction::UserForcingFunction().

   {
     moose::internal::mooseDeprecatedStream(_console, false, true, std::forward<Args>(args)...);
   }

◆ mooseDocumentedError()

template<typename... Args>

void MooseBaseErrorInterface::mooseDocumentedError	(	const std::string &	repo_name,
		const unsigned int	issue_num,
		Args &&...	args
	)		const

inlineinherited

Emits a documented error with object name and type.

Documented errors are errors that have an issue associated with them.

The repository name repo_name links a named repository to a URL and should be registered at the application level with registerRepository(). See Moose.C for an example of the "moose" repository registration.

Parameters

repo_name	The repository name where the issue resides
issue_num	The number of the issue
args	The error message to be combined

Definition at line 61 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     const auto msg = moose::internal::formatMooseDocumentedError(repo_name, issue_num, oss.str());
     _moose_base.callMooseError(msg, /* with_prefix = */ true);
   }

◆ mooseError()

template<typename... Args>

void MooseBaseErrorInterface::mooseError ( Args &&... args ) const

inlineinherited

Emits an error prefixed with object name and type.

Definition at line 29 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     _moose_base.callMooseError(oss.str(), /* with_prefix = */ true);
   }

◆ mooseErrorNonPrefixed()

template<typename... Args>

void MooseBaseErrorInterface::mooseErrorNonPrefixed ( Args &&... args ) const

inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 40 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     _moose_base.callMooseError(oss.str(), /* with_prefix = */ false);
   }

◆ mooseInfo()

template<typename... Args>

void MooseBaseErrorInterface::mooseInfo ( Args &&... args ) const

inlineinherited

Definition at line 97 of file MooseBaseErrorInterface.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ProjectionAux::ProjectionAux(), ReferenceResidualProblem::ReferenceResidualProblem(), FEProblemBase::setRestartFile(), and SymmetryTransformGenerator::SymmetryTransformGenerator().

   {
     moose::internal::mooseInfoStream(_console, std::forward<Args>(args)...);
   }

◆ mooseWarning()

template<typename... Args>

void MooseBaseErrorInterface::mooseWarning ( Args &&... args ) const

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 75 of file MooseBaseErrorInterface.h.

Referenced by AddKernelAction::act(), SetupMeshAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), BoundsBase::BoundsBase(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), PhysicsBase::checkRequiredTasks(), OversampleOutput::cloneMesh(), GapValueAux::computeValue(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), Positions::getNearestPositionIndex(), LineValueSampler::getValue(), Terminator::handleMessage(), ElementGroupCentroidPositions::initialize(), CartesianGridDivision::initialize(), SphericalGridDivision::initialize(), CylindricalGridDivision::initialize(), ReferenceResidualProblem::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

   {
     moose::internal::mooseWarningStream(
         _console, _moose_base.errorPrefix("warning"), std::forward<Args>(args)...);
   }

◆ mooseWarningNonPrefixed()

template<typename... Args>

void MooseBaseErrorInterface::mooseWarningNonPrefixed ( Args &&... args ) const

inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 85 of file MooseBaseErrorInterface.h.

   {
     moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
   }

◆ name()

virtual const std::string& MooseBase::name ( ) const

inlinevirtualinherited

Get the name of the class.

Returns: The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

57 { return _name; }

MooseBase::_name

const std::string _name

The name of this class.

Definition: MooseBase.h:90

◆ numFixedPointIts()

unsigned int FixedPointSolve::numFixedPointIts ( ) const

inlineinherited

Get the number of fixed point iterations performed Because this returns the number of fixed point iterations, rather than the current iteration count (which starts at 0), increment by 1.

Returns: Number of fixed point iterations performed

Definition at line 53 of file FixedPointSolve.h.

Referenced by IterationInfo::execute(), PIDTransientControl::execute(), ChangeOverFixedPointPostprocessor::finalize(), and NumFixedPointIterations::getValue().

53 { return _fixed_point_it + 1; }

FixedPointSolve::_fixed_point_it

unsigned int _fixed_point_it

Definition: FixedPointSolve.h:227

◆ numPicardIts()

unsigned int FixedPointSolve::numPicardIts ( ) const

inlineinherited

Deprecated getter for the number of fixed point iterations.

Definition at line 56 of file FixedPointSolve.h.

   {
     mooseDeprecated("numPicards() is deprecated. Please use numFixedPointIts() instead.");
 
     return _fixed_point_it + 1;
   }

◆ paramError()

template<typename... Args>

void MooseBaseParameterInterface::paramError	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 237 of file MooseBaseParameterInterface.h.

 {
   Moose::show_trace = false;
   _moose_base.callMooseError(paramErrorMsg(param, std::forward<Args>(args)...),
                              /* with_prefix = */ false);
   Moose::show_trace = true;
 }

◆ parameters()

const InputParameters& MooseBaseParameterInterface::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 62 of file MooseBaseParameterInterface.h.

62 { return _pars; }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:162

◆ paramInfo()

template<typename... Args>

void MooseBaseParameterInterface::paramInfo	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 254 of file MooseBaseParameterInterface.h.

Referenced by TransientMultiApp::TransientMultiApp().

 {
   mooseInfo(paramErrorMsg(param, std::forward<Args>(args)...));
 }

◆ paramWarning()

template<typename... Args>

void MooseBaseParameterInterface::paramWarning	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 247 of file MooseBaseParameterInterface.h.

Referenced by MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), FixedPointSolve::FixedPointSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), and MooseMesh::MooseMesh().

 {
   mooseWarning(paramErrorMsg(param, std::forward<Args>(args)...));
 }

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), and PerfGraphOutput::output().

 {
   return _pg_moose_app.perfGraph();
 }

◆ printFixedPointConvergenceHistory()

void PicardSolve::printFixedPointConvergenceHistory ( )

finaloverrideprivatevirtual

Print the convergence history of the coupling, at every coupling iteration.

Implements FixedPointSolve.

Definition at line 260 of file PicardSolve.C.

 {
   _console << "\n 0 Picard |R| = "
            << Console::outputNorm(std::numeric_limits<Real>::max(), _fixed_point_initial_norm)
            << '\n';
 
   Real max_norm_old = _fixed_point_initial_norm;
   for (unsigned int i = 0; i <= _fixed_point_it; ++i)
   {
     Real max_norm =
         std::max(_fixed_point_timestep_begin_norm[i], _fixed_point_timestep_end_norm[i]);
     _console << std::setw(2) << i + 1
              << " Picard |R| = " << Console::outputNorm(max_norm_old, max_norm) << '\n';
     max_norm_old = max_norm;
   }
 
   _console << std::endl;
 }

◆ printFixedPointConvergenceReason()

void FixedPointSolve::printFixedPointConvergenceReason ( )

protectedinherited

Print information about the fixed point convergence.

Definition at line 563 of file FixedPointSolve.C.

Referenced by FixedPointSolve::solve().

 {
   _console << "Fixed point convergence reason: ";
   switch (_fixed_point_status)
   {
     case MooseFixedPointConvergenceReason::CONVERGED_ABS:
       _console << "CONVERGED_ABS";
       break;
     case MooseFixedPointConvergenceReason::CONVERGED_RELATIVE:
       _console << "CONVERGED_RELATIVE";
       break;
     case MooseFixedPointConvergenceReason::CONVERGED_CUSTOM:
       _console << "CONVERGED_CUSTOM";
       break;
     case MooseFixedPointConvergenceReason::REACH_MAX_ITS:
       _console << "REACH_MAX_ITS";
       break;
     case MooseFixedPointConvergenceReason::DIVERGED_MAX_ITS:
       _console << "DIVERGED_MAX_ITS";
       break;
     case MooseFixedPointConvergenceReason::DIVERGED_NONLINEAR:
       _console << "DIVERGED_NONLINEAR";
       break;
     case MooseFixedPointConvergenceReason::DIVERGED_FAILED_MULTIAPP:
       _console << "DIVERGED_FAILED_MULTIAPP";
       break;
     default:
       // UNSOLVED and CONVERGED_NONLINEAR should not be hit when coupling
       // iteration is not on here
       mooseError("Internal error: wrong fixed point status!");
       break;
   }
   _console << std::endl;
 }

◆ registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection	(	const std::string &	section_name,
		const unsigned int	level
	)		const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns: The ID of the section - use when starting timing

Definition at line 53 of file PerfGraphInterface.C.

 {
   const auto timed_section_name = timedSectionName(section_name);
   if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
     return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
   else
     return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
 }

◆ registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection	(	const std::string &	section_name,
		const unsigned int	level,
		const std::string &	live_message,
		const bool	print_dots = `true`
	)		const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns: The ID of the section - use when starting timing

Definition at line 64 of file PerfGraphInterface.C.

 {
   const auto timed_section_name = timedSectionName(section_name);
   if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
     return moose::internal::getPerfGraphRegistry().registerSection(
         timedSectionName(section_name), level, live_message, print_dots);
   else
     return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
 }

◆ saveAllValues()

void FixedPointSolve::saveAllValues ( const bool primary )

protectedvirtualinherited

Save both the variable and postprocessor values.

Definition at line 366 of file FixedPointSolve.C.

Referenced by FixedPointSolve::solveStep().

 {
   saveVariableValues(primary);
   savePostprocessorValues(primary);
 }

◆ savePostprocessorValues()

void PicardSolve::savePostprocessorValues ( const bool primary )

finaloverrideprivatevirtual

Saves the current values of the postprocessors, and update the old(er) vectors.

Parameters

primary Whether this routine is to save the variables for the primary transformed quantities (as main app) or the secondary ones (as a subapp)

Implements FixedPointSolve.

Definition at line 163 of file PicardSolve.C.

 {
   Real relaxation_factor;
   const std::vector<PostprocessorName> * transformed_pps;
   std::vector<std::vector<PostprocessorValue>> * transformed_pps_values;
   if (primary)
   {
     relaxation_factor = _relax_factor;
     transformed_pps = &_transformed_pps;
     transformed_pps_values = &_transformed_pps_values;
   }
   else
   {
     relaxation_factor = _secondary_relaxation_factor;
     transformed_pps = &_secondary_transformed_pps;
     transformed_pps_values = &_secondary_transformed_pps_values;
   }
 
   if (relaxation_factor != 1.)
     // Save postprocessor previous values
     for (size_t i = 0; i < (*transformed_pps).size(); i++)
       (*transformed_pps_values)[i][0] = getPostprocessorValueByName((*transformed_pps)[i]);
 }

◆ saveVariableValues()

void PicardSolve::saveVariableValues ( const bool primary )

finaloverrideprivatevirtual

Saves the current values of the variables, and update the old(er) vectors.

Parameters

primary Whether this routine is to save the variables for the primary transformed quantities (as main app) or the secondary ones (as a subapp)

Implements FixedPointSolve.

Definition at line 138 of file PicardSolve.C.

 {
   Real relaxation_factor;
   TagID old_tag_id;
   if (primary)
   {
     relaxation_factor = _relax_factor;
     old_tag_id = _old_tag_id;
   }
   else
   {
     relaxation_factor = _secondary_relaxation_factor;
     old_tag_id = _secondary_old_tag_id;
   }
 
   if (relaxation_factor != 1.)
   {
     // Save variable previous values
     NumericVector<Number> & solution = _solver_sys.solution();
     NumericVector<Number> & transformed_old = _solver_sys.getVector(old_tag_id);
     transformed_old = solution;
   }
 }

◆ setInnerSolve()

virtual void SolveObject::setInnerSolve ( SolveObject & solve )

inlinevirtualinherited

Set the inner solve object wrapped by this object.

Reimplemented in FEProblemSolve.

Definition at line 36 of file SolveObject.h.

36 { _inner_solve = &solve; }

SolveObject::_inner_solve

SolveObject * _inner_solve

SolveObject wrapped by this solve object.

Definition: SolveObject.h:54

SolveObject::solve

virtual bool solve()=0

Solve routine provided by this object.

◆ setMultiAppRelaxationFactor()

void FixedPointSolve::setMultiAppRelaxationFactor ( Real factor )

inlineinherited

Set relaxation factor for the current solve as a SubApp.

Definition at line 76 of file FixedPointSolve.h.

76 { _secondary_relaxation_factor = factor; }

FixedPointSolve::_secondary_relaxation_factor

Real _secondary_relaxation_factor

Relaxation factor outside of fixed point iteration (used as a subapp)

Definition: FixedPointSolve.h:217

◆ setMultiAppTransformedPostprocessors()

virtual void FixedPointSolve::setMultiAppTransformedPostprocessors ( const std::vector< PostprocessorName > & pps )

inlinevirtualinherited

Set relaxation postprocessors for the current solve as a SubApp.

Definition at line 85 of file FixedPointSolve.h.

   {
     _secondary_transformed_pps = pps;
   }

◆ setMultiAppTransformedVariables()

void FixedPointSolve::setMultiAppTransformedVariables ( const std::vector< std::string > & vars )

inlineinherited

Set relaxation variables for the current solve as a SubApp.

Definition at line 79 of file FixedPointSolve.h.

   {
     _secondary_transformed_variables = vars;
   }

◆ solve()

bool FixedPointSolve::solve ( )

overridevirtualinherited

Iteratively solves the FEProblem.

Returns: True if solver is converged.

Implements SolveObject.

Definition at line 195 of file FixedPointSolve.C.

 {
   TIME_SECTION("PicardSolve", 1);
 
   Real current_dt = _problem.dt();
 
   _fixed_point_timestep_begin_norm.clear();
   _fixed_point_timestep_end_norm.clear();
   _fixed_point_timestep_begin_norm.resize(_max_fixed_point_its);
   _fixed_point_timestep_end_norm.resize(_max_fixed_point_its);
 
   bool converged = true;
 
   // need to back up multi-apps even when not doing fixed point iteration for recovering from failed
   // multiapp solve
   _problem.backupMultiApps(EXEC_MULTIAPP_FIXED_POINT_BEGIN);
   _problem.backupMultiApps(EXEC_TIMESTEP_BEGIN);
   _problem.backupMultiApps(EXEC_TIMESTEP_END);
   _problem.backupMultiApps(EXEC_MULTIAPP_FIXED_POINT_END);
 
   // Prepare to relax variables as a main app
   std::set<dof_id_type> transformed_dofs;
   if ((_relax_factor != 1.0 || !dynamic_cast<PicardSolve *>(this)) && _transformed_vars.size() > 0)
   {
     // Snag all of the local dof indices for all of these variables
     AllLocalDofIndicesThread aldit(_problem, _transformed_vars);
     ConstElemRange & elem_range = *_problem.mesh().getActiveLocalElementRange();
     Threads::parallel_reduce(elem_range, aldit);
 
     transformed_dofs = aldit.getDofIndices();
   }
 
   // Prepare to relax variables as a subapp
   std::set<dof_id_type> secondary_transformed_dofs;
   if (_secondary_relaxation_factor != 1.0 || !dynamic_cast<PicardSolve *>(this))
   {
     if (_secondary_transformed_variables.size() > 0)
     {
       // Snag all of the local dof indices for all of these variables
       AllLocalDofIndicesThread aldit(_problem, _secondary_transformed_variables);
       ConstElemRange & elem_range = *_problem.mesh().getActiveLocalElementRange();
       Threads::parallel_reduce(elem_range, aldit);
 
       secondary_transformed_dofs = aldit.getDofIndices();
     }
 
     // To detect a new time step
     if (_old_entering_time == _problem.time())
     {
       // Keep track of the iteration number of the main app
       _main_fixed_point_it++;
 
       // Save variable values before the solve. Solving will provide new values
       saveVariableValues(false);
     }
     else
       _main_fixed_point_it = 0;
   }
 
   for (_fixed_point_it = 0; _fixed_point_it < _max_fixed_point_its; ++_fixed_point_it)
   {
     if (_has_fixed_point_its)
     {
       if (_fixed_point_it == 0)
       {
         if (_has_fixed_point_norm)
         {
           // First fixed point iteration - need to save off the initial nonlinear residual
           _fixed_point_initial_norm = _problem.computeResidualL2Norm();
           _console << COLOR_MAGENTA << "Initial fixed point residual norm: " << COLOR_DEFAULT;
           if (_fixed_point_initial_norm == std::numeric_limits<Real>::max())
             _console << " MAX ";
           else
             _console << std::scientific << _fixed_point_initial_norm;
           _console << COLOR_DEFAULT << "\n" << std::endl;
         }
       }
       else
       {
         // For every iteration other than the first, we need to restore the state of the MultiApps
         _problem.restoreMultiApps(EXEC_MULTIAPP_FIXED_POINT_BEGIN);
         _problem.restoreMultiApps(EXEC_TIMESTEP_BEGIN);
         _problem.restoreMultiApps(EXEC_TIMESTEP_END);
         _problem.restoreMultiApps(EXEC_MULTIAPP_FIXED_POINT_END);
       }
 
       _console << COLOR_MAGENTA << "Beginning fixed point iteration " << _fixed_point_it
                << COLOR_DEFAULT << std::endl
                << std::endl;
     }
 
     // Save last postprocessor value as value before solve
     if (_fixed_point_custom_pp && _fixed_point_it > 0 && !getParam<bool>("direct_pp_value"))
       _pp_old = *_fixed_point_custom_pp;
 
     // Solve a single application for one time step
     bool solve_converged = solveStep(_fixed_point_timestep_begin_norm[_fixed_point_it],
                                      _fixed_point_timestep_end_norm[_fixed_point_it],
                                      transformed_dofs);
 
     // Get new value and print history for the custom postprocessor convergence criterion
     if (_fixed_point_custom_pp)
       computeCustomConvergencePostprocessor();
 
     if (solve_converged)
     {
       if (_has_fixed_point_its)
       {
         if (_has_fixed_point_norm)
           // Print the evolution of the main app residual over the fixed point iterations
           printFixedPointConvergenceHistory();
 
         // Examine convergence metrics & properties and set the convergence reason
         bool break_out = examineFixedPointConvergence(converged);
         if (break_out)
           break;
       }
     }
     else
     {
       // If the last solve didn't converge then we need to exit this step completely (even in the
       // case of coupling). So we can retry...
       converged = false;
       break;
     }
 
     if (converged)
     {
       // Fixed point iteration loop ends right above
       _problem.execute(EXEC_MULTIAPP_FIXED_POINT_END);
       _problem.execTransfers(EXEC_MULTIAPP_FIXED_POINT_END);
       if (!_problem.execMultiApps(EXEC_MULTIAPP_FIXED_POINT_END, autoAdvance()))
       {
         _fixed_point_status = MooseFixedPointConvergenceReason::DIVERGED_FAILED_MULTIAPP;
         return false;
       }
       _problem.outputStep(EXEC_MULTIAPP_FIXED_POINT_END);
     }
 
     _problem.dt() =
         current_dt; // _dt might be smaller than this at this point for multistep methods
   }
 
   // Save postprocessors after the solve and their potential timestep_end execution
   // The postprocessors could be overwritten at timestep_begin, which is why they are saved
   // after the solve. They could also be saved right after the transfers.
   if (_old_entering_time == _problem.time())
     savePostprocessorValues(false);
 
   if (converged)
   {
     // Update the subapp using the fixed point algorithm
     if (_secondary_transformed_variables.size() > 0 &&
         useFixedPointAlgorithmUpdateInsteadOfPicard(false) && _old_entering_time == _problem.time())
       transformVariables(secondary_transformed_dofs, false);
 
     // Update the entering time, used to detect failed solves
     _old_entering_time = _problem.time();
   }
 
   if (_has_fixed_point_its)
     printFixedPointConvergenceReason();
 
   // clear history to avoid displaying it again on next solve that can happen for example during
   // transient
   _pp_history.str("");
 
   return converged;
 }

◆ solveStep()

bool FixedPointSolve::solveStep	(	Real &	begin_norm,
		Real &	end_norm,
		const std::set< dof_id_type > &	transformed_dofs
	)

protectedvirtualinherited

Perform one fixed point iteration or a full solve.

Parameters

begin_norm	Residual norm after timestep_begin execution
end_norm	Residual norm after timestep_end execution
transformed_dofs	DoFs targetted by the fixed point algorithm

Returns: True if both nonlinear solve and the execution of multiapps are successful.

Note: this function also set _xfem_repeat_step flag for XFEM. It tracks _xfem_update_count state. FIXME: The proper design will be to let XFEM use Picard iteration to control the execution.

Definition at line 373 of file FixedPointSolve.C.

Referenced by FixedPointSolve::solve().

 {
   bool auto_advance = autoAdvance();
 
   // Compute previous norms for coloring the norm output
   Real begin_norm_old = (_fixed_point_it > 0 ? _fixed_point_timestep_begin_norm[_fixed_point_it - 1]
                                              : std::numeric_limits<Real>::max());
   Real end_norm_old = (_fixed_point_it > 0 ? _fixed_point_timestep_end_norm[_fixed_point_it - 1]
                                            : std::numeric_limits<Real>::max());
 
   _executioner.preSolve();
   _problem.execTransfers(EXEC_TIMESTEP_BEGIN);
 
   if (_fixed_point_it == 0)
   {
     _problem.execute(EXEC_MULTIAPP_FIXED_POINT_BEGIN);
     _problem.execTransfers(EXEC_MULTIAPP_FIXED_POINT_BEGIN);
     if (!_problem.execMultiApps(EXEC_MULTIAPP_FIXED_POINT_BEGIN, autoAdvance()))
     {
       _fixed_point_status = MooseFixedPointConvergenceReason::DIVERGED_FAILED_MULTIAPP;
       return false;
     }
     _problem.outputStep(EXEC_MULTIAPP_FIXED_POINT_BEGIN);
   }
 
   if (!_problem.execMultiApps(EXEC_TIMESTEP_BEGIN, auto_advance))
   {
     _fixed_point_status = MooseFixedPointConvergenceReason::DIVERGED_FAILED_MULTIAPP;
     return false;
   }
 
   if (_problem.haveXFEM() && _update_xfem_at_timestep_begin)
     _problem.updateMeshXFEM();
 
   _problem.execute(EXEC_TIMESTEP_BEGIN);
 
   // Transform the fixed point postprocessors before solving, but after the timestep_begin transfers
   // have been received
   if (_transformed_pps.size() > 0 && useFixedPointAlgorithmUpdateInsteadOfPicard(true))
     transformPostprocessors(true);
   if (_secondary_transformed_pps.size() > 0 && useFixedPointAlgorithmUpdateInsteadOfPicard(false) &&
       _problem.time() == _old_entering_time)
     transformPostprocessors(false);
 
   if (_has_fixed_point_its && _has_fixed_point_norm)
     if (_problem.hasMultiApps(EXEC_TIMESTEP_BEGIN) || _fixed_point_force_norms)
     {
       begin_norm = _problem.computeResidualL2Norm();
 
       _console << COLOR_MAGENTA << "Fixed point residual norm after TIMESTEP_BEGIN MultiApps: "
                << Console::outputNorm(begin_norm_old, begin_norm) << std::endl;
     }
 
   // Perform output for timestep begin
   _problem.outputStep(EXEC_TIMESTEP_BEGIN);
 
   // Update warehouse active objects
   _problem.updateActiveObjects();
 
   // Save the current values of variables and postprocessors, before the solve
   saveAllValues(true);
 
   if (_has_fixed_point_its)
     _console << COLOR_MAGENTA << "\nMain app solve:" << COLOR_DEFAULT << std::endl;
   if (!_inner_solve->solve())
   {
     _fixed_point_status = MooseFixedPointConvergenceReason::DIVERGED_NONLINEAR;
 
     // Perform the output of the current, failed time step (this only occurs if desired)
     _problem.outputStep(EXEC_FAILED);
     return false;
   }
   else
     _fixed_point_status = MooseFixedPointConvergenceReason::CONVERGED_NONLINEAR;
 
   // Use the fixed point algorithm if the conditions (availability of values, etc) are met
   if (_transformed_vars.size() > 0 && useFixedPointAlgorithmUpdateInsteadOfPicard(true))
     transformVariables(transformed_dofs, true);
 
   if (_problem.haveXFEM() && (_xfem_update_count < _max_xfem_update) && _problem.updateMeshXFEM())
   {
     _console << "\nXFEM modified mesh, repeating step" << std::endl;
     _xfem_repeat_step = true;
     ++_xfem_update_count;
   }
   else
   {
     if (_problem.haveXFEM())
     {
       _xfem_repeat_step = false;
       _xfem_update_count = 0;
       _console << "\nXFEM did not modify mesh, continuing" << std::endl;
     }
 
     _problem.onTimestepEnd();
     _problem.execute(EXEC_TIMESTEP_END);
 
     _problem.execTransfers(EXEC_TIMESTEP_END);
     if (!_problem.execMultiApps(EXEC_TIMESTEP_END, auto_advance))
     {
       _fixed_point_status = MooseFixedPointConvergenceReason::DIVERGED_FAILED_MULTIAPP;
       return false;
     }
   }
 
   if (_fail_step)
   {
     _fail_step = false;
     return false;
   }
 
   _executioner.postSolve();
 
   if (_has_fixed_point_its && _has_fixed_point_norm)
     if (_problem.hasMultiApps(EXEC_TIMESTEP_END) || _fixed_point_force_norms)
     {
       end_norm = _problem.computeResidualL2Norm();
 
       _console << COLOR_MAGENTA << "Fixed point residual norm after TIMESTEP_END MultiApps: "
                << Console::outputNorm(end_norm_old, end_norm) << std::endl;
     }
 
   return true;
 }

◆ timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string & section_name ) const

protectedinherited

Returns: The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

 {
   return _prefix.empty() ? "" : (_prefix + "::") + section_name;
 }

◆ transformPostprocessors()

void PicardSolve::transformPostprocessors ( const bool primary )

finaloverrideprivatevirtual

Use the fixed point algorithm to transform the postprocessors.

If this routine is not called, the next value of the postprocessors will just be from the unrelaxed Picard fixed point algorithm.

Parameters

primary Whether this routine is to save the variables for the primary transformed quantities (as main app) or the secondary ones (as a subapp)

Implements FixedPointSolve.

Definition at line 199 of file PicardSolve.C.

 {
   Real relaxation_factor;
   const std::vector<PostprocessorName> * transformed_pps;
   std::vector<std::vector<PostprocessorValue>> * transformed_pps_values;
   if (primary)
   {
     relaxation_factor = _relax_factor;
     transformed_pps = &_transformed_pps;
     transformed_pps_values = &_transformed_pps_values;
   }
   else
   {
     relaxation_factor = _secondary_relaxation_factor;
     transformed_pps = &_secondary_transformed_pps;
     transformed_pps_values = &_secondary_transformed_pps_values;
   }
 
   // Relax the postprocessors
   for (size_t i = 0; i < (*transformed_pps).size(); i++)
   {
     // Get new postprocessor value
     const Real current_value = getPostprocessorValueByName((*transformed_pps)[i]);
     const Real old_value = (*transformed_pps_values)[i][0];
 
     // Compute and set relaxed value
     Real new_value = current_value;
     new_value = relaxation_factor * current_value + (1 - relaxation_factor) * old_value;
     _problem.setPostprocessorValueByName((*transformed_pps)[i], new_value);
   }
 }

◆ transformVariables()

void PicardSolve::transformVariables	(	const std::set< dof_id_type > &	transformed_dofs,
		const bool	primary
	)

finaloverrideprivatevirtual

Use the fixed point algorithm to transform the variables.

If this routine is not called, the next value of the variables will just be from the unrelaxed Picard fixed point algorithm.

Parameters

transformed_dofs	The dofs that will be affected by the algorithm
primary	Whether this routine is to save the variables for the primary transformed quantities (as main app) or the secondary ones (as a subapp)

Implements FixedPointSolve.

Definition at line 232 of file PicardSolve.C.

 {
   Real relaxation_factor;
   TagID old_tag_id;
   if (primary)
   {
     relaxation_factor = _relax_factor;
     old_tag_id = _old_tag_id;
   }
   else
   {
     relaxation_factor = _secondary_relaxation_factor;
     old_tag_id = _secondary_old_tag_id;
   }
 
   NumericVector<Number> & solution = _solver_sys.solution();
   NumericVector<Number> & transformed_old = _solver_sys.getVector(old_tag_id);
 
   for (const auto & dof : transformed_dofs)
     solution.set(dof,
                  (transformed_old(dof) * (1.0 - relaxation_factor)) +
                      (solution(dof) * relaxation_factor));
 
   solution.close();
   _solver_sys.update();
 }

◆ type()

const std::string& MooseBase::type ( ) const

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 51 of file MooseBase.h.

51 { return _type; }

MooseBase::_type

const std::string _type

The type of this class.

Definition: MooseBase.h:87

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns: The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 27 of file MooseBase.C.

Referenced by MaterialPropertyStorage::addProperty(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

 {
   return type() + std::string(" \"") + name() + std::string("\"");
 }

◆ uniqueName()

MooseObjectName MooseBaseParameterInterface::uniqueName ( ) const

inlineinherited

The unique name for accessing input parameters of this object in the InputParameterWarehouse.

Definition at line 67 of file MooseBaseParameterInterface.h.

Referenced by MooseBaseParameterInterface::connectControllableParams(), and Action::uniqueActionName().

   {
     return MooseObjectName(_pars.get<std::string>("_unique_name"));
   }

◆ uniqueParameterName()

MooseObjectParameterName MooseBaseParameterInterface::uniqueParameterName ( const std::string & parameter_name ) const

inlineinherited

The unique parameter name of a valid parameter of this object for accessing parameter controls.

Definition at line 52 of file MooseBaseParameterInterface.h.

   {
     return MooseObjectParameterName(
         _pars.get<std::string>("_moose_base"), _moose_base.name(), parameter_name);
   }

◆ useFixedPointAlgorithmUpdateInsteadOfPicard()

bool PicardSolve::useFixedPointAlgorithmUpdateInsteadOfPicard ( const bool primary )

finaloverrideprivatevirtual

Use the fixed point algorithm transform instead of simply using the Picard update.

Parameters

primary Whether this routine is used for the primary transformed quantities (as main app) or the secondary ones (as a subapp)

Implements FixedPointSolve.

Definition at line 188 of file PicardSolve.C.

 {
   // unrelaxed Picard is the default update for fixed point iterations
   // old values are required for relaxation
   if (primary)
     return _relax_factor != 1. && _fixed_point_it > 0;
   else
     return _secondary_relaxation_factor != 1. && _main_fixed_point_it > 0;
 }

◆ validParams()

InputParameters PicardSolve::validParams ( )

static

Definition at line 19 of file PicardSolve.C.

Referenced by Executioner::validParams().

 {
   InputParameters params = FixedPointSolve::validParams();
 
   params.addDeprecatedParam<unsigned int>(
       "picard_max_its",
       1,
       "Specifies the maximum number of Picard iterations. "
       "Mainly used when  wanting to do Picard iterations with MultiApps "
       "that are set to execute_on timestep_end or timestep_begin. "
       "Setting this parameter to 1 turns off the Picard iterations.",
       "Deprecated, use fixed_point_max_its");
   params.addDeprecatedParam<bool>(
       "accept_on_max_picard_iteration",
       false,
       "True to treat reaching the maximum number of Picard iterations as converged.",
       "Deprecated, use accept_on_max_fixed_point_iteration");
   params.addDeprecatedParam<bool>(
       "disable_picard_residual_norm_check",
       false,
       "Disable the Picard residual norm evaluation thus the three parameters "
       "picard_rel_tol, picard_abs_tol and picard_force_norms.",
       "Deprecated, use disable_fixed_point_residual_norm_check");
   params.addDeprecatedParam<Real>("picard_rel_tol",
                                   1e-8,
                                   "The relative nonlinear residual drop to shoot for "
                                   "during Picard iterations. This check is "
                                   "performed based on the Master app's nonlinear "
                                   "residual.",
                                   "Deprecated, use fixed_point_rel_tol");
   params.addDeprecatedParam<Real>("picard_abs_tol",
                                   1e-50,
                                   "The absolute nonlinear residual to shoot for "
                                   "during Picard iterations. This check is "
                                   "performed based on the Master app's nonlinear "
                                   "residual.",
                                   "Deprecated, use fixed_point_abs_tol");
   params.addDeprecatedParam<PostprocessorName>("picard_custom_pp",
                                                "Postprocessor for custom picard convergence check.",
                                                "Deprecated, use custom_pp");
   params.deprecateParam("picard_custom_pp", "custom_pp", "06/06/2024");
 
   params.addDeprecatedParam<bool>(
       "picard_force_norms",
       false,
       "Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the "
       "existence of active MultiApps with those execute_on flags, default: false.",
       "Deprecated, use fixed_point_force_norms");
 
   return params;
 }

◆ XFEMRepeatStep()

bool FixedPointSolve::XFEMRepeatStep ( ) const

inlineinherited

This function checks the _xfem_repeat_step flag set by solve.

Definition at line 67 of file FixedPointSolve.h.

Referenced by TimeSequenceStepperBase::step().

67 { return _xfem_repeat_step; }

FixedPointSolve::_xfem_repeat_step

bool _xfem_repeat_step

Whether step should be repeated due to xfem modifying the mesh.

Definition: FixedPointSolve.h:261

Member Data Documentation

◆ _accept_max_it

bool FixedPointSolve::_accept_max_it

protectedinherited

Whether or not to treat reaching maximum number of fixed point iteration as converged.

Definition at line 193 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), and PicardSolve().

◆ _action_factory

ActionFactory& MooseBaseParameterInterface::_action_factory

protectedinherited

Builds Actions.

Definition at line 168 of file MooseBaseParameterInterface.h.

Referenced by PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

◆ _aux

AuxiliarySystem& SolveObject::_aux

protectedinherited

Reference to auxiliary system for faster access.

Definition at line 52 of file SolveObject.h.

◆ _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.

◆ _displaced_mesh

MooseMesh* SolveObject::_displaced_mesh

protectedinherited

Displaced mesh.

Definition at line 48 of file SolveObject.h.

◆ _displaced_problem

std::shared_ptr<DisplacedProblem> SolveObject::_displaced_problem

protectedinherited

Displaced problem.

Definition at line 44 of file SolveObject.h.

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition at line 61 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _executioner

Executioner& SolveObject::_executioner

protectedinherited

Executioner used to construct this.

Definition at line 40 of file SolveObject.h.

Referenced by FixedPointSolve::autoAdvance(), and FixedPointSolve::solveStep().

◆ _factory

Factory& MooseBaseParameterInterface::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 165 of file MooseBaseParameterInterface.h.

Referenced by ElementIDOutputAction::act(), AutoCheckpointAction::act(), PartitionerAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), AdaptivityAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), SetupPreconditionerAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), SetupResidualDebugAction::act(), SetAdaptivityOptionsAction::act(), MaterialDerivativeTestAction::act(), CreateDisplacedProblemAction::act(), DisplayGhostingAction::act(), AddControlAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), AddNodalNormalsAction::act(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), MooseBaseParameterInterface::connectControllableParams(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), and ProjectedStatefulMaterialStorageAction::processProperty().

◆ _fixed_point_abs_tol

Real FixedPointSolve::_fixed_point_abs_tol

protectedinherited

Absolute tolerance on residual norm.

Definition at line 199 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), and PicardSolve().

◆ _fixed_point_custom_pp

const PostprocessorValue* FixedPointSolve::_fixed_point_custom_pp

protectedinherited

Postprocessor value for user-defined fixed point convergence check.

Definition at line 205 of file FixedPointSolve.h.

Referenced by FixedPointSolve::computeCustomConvergencePostprocessor(), PicardSolve(), and FixedPointSolve::solve().

◆ _fixed_point_force_norms

bool FixedPointSolve::_fixed_point_force_norms

protectedinherited

Whether or not we force evaluation of residual norms even without multiapps.

Definition at line 201 of file FixedPointSolve.h.

Referenced by PicardSolve(), and FixedPointSolve::solveStep().

◆ _fixed_point_initial_norm

Real FixedPointSolve::_fixed_point_initial_norm

protectedinherited

Initial residual norm.

Definition at line 231 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), SteffensenSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), printFixedPointConvergenceHistory(), and FixedPointSolve::solve().

◆ _fixed_point_it

unsigned int FixedPointSolve::_fixed_point_it

protectedinherited

Variables used by the fixed point iteration fixed point iteration counter

Definition at line 227 of file FixedPointSolve.h.

Referenced by FixedPointSolve::computeCustomConvergencePostprocessor(), FixedPointSolve::examineFixedPointConvergence(), FixedPointSolve::numFixedPointIts(), FixedPointSolve::numPicardIts(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), printFixedPointConvergenceHistory(), SteffensenSolve::savePostprocessorValues(), SteffensenSolve::saveVariableValues(), FixedPointSolve::solve(), FixedPointSolve::solveStep(), SecantSolve::useFixedPointAlgorithmUpdateInsteadOfPicard(), SteffensenSolve::useFixedPointAlgorithmUpdateInsteadOfPicard(), and useFixedPointAlgorithmUpdateInsteadOfPicard().

◆ _fixed_point_rel_tol

Real FixedPointSolve::_fixed_point_rel_tol

protectedinherited

Relative tolerance on residual norm.

Definition at line 197 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), and PicardSolve().

◆ _fixed_point_status

MooseFixedPointConvergenceReason FixedPointSolve::_fixed_point_status

protectedinherited

Status of fixed point solve.

Definition at line 237 of file FixedPointSolve.h.

Referenced by FixedPointSolve::checkConvergence(), FixedPointSolve::clearFixedPointStatus(), FixedPointSolve::examineFixedPointConvergence(), FixedPointSolve::printFixedPointConvergenceReason(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

◆ _fixed_point_timestep_begin_norm

std::vector<Real> FixedPointSolve::_fixed_point_timestep_begin_norm

protectedinherited

Full history of residual norm after evaluation of timestep_begin.

Definition at line 233 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), printFixedPointConvergenceHistory(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

◆ _fixed_point_timestep_end_norm

std::vector<Real> FixedPointSolve::_fixed_point_timestep_end_norm

protectedinherited

Full history of residual norm after evaluation of timestep_end.

Definition at line 235 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), printFixedPointConvergenceHistory(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

◆ _has_fixed_point_its

bool FixedPointSolve::_has_fixed_point_its

protectedinherited

Whether or not we activate fixed point iteration.

Definition at line 191 of file FixedPointSolve.h.

Referenced by FixedPointSolve::autoAdvance(), FixedPointSolve::hasFixedPointIteration(), PicardSolve(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

◆ _has_fixed_point_norm

bool FixedPointSolve::_has_fixed_point_norm

protectedinherited

Whether or not to use residual norm to check the fixed point convergence.

Definition at line 195 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), FixedPointSolve::FixedPointSolve(), PicardSolve(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

◆ _inner_solve

SolveObject* SolveObject::_inner_solve

protectedinherited

SolveObject wrapped by this solve object.

Definition at line 54 of file SolveObject.h.

Referenced by SolveObject::setInnerSolve(), and FixedPointSolve::solveStep().

◆ _main_fixed_point_it

unsigned int FixedPointSolve::_main_fixed_point_it

protectedinherited

fixed point iteration counter for the main app

Definition at line 229 of file FixedPointSolve.h.

Referenced by SteffensenSolve::savePostprocessorValues(), SteffensenSolve::saveVariableValues(), FixedPointSolve::solve(), SteffensenSolve::useFixedPointAlgorithmUpdateInsteadOfPicard(), SecantSolve::useFixedPointAlgorithmUpdateInsteadOfPicard(), and useFixedPointAlgorithmUpdateInsteadOfPicard().

◆ _max_fixed_point_its

unsigned int FixedPointSolve::_max_fixed_point_its

protectedinherited

Maximum fixed point iterations.

Definition at line 189 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), FixedPointSolve::FixedPointSolve(), PicardSolve(), FixedPointSolve::solve(), and SteffensenSolve::SteffensenSolve().

◆ _mesh

MooseMesh& SolveObject::_mesh

protectedinherited

Mesh.

Definition at line 46 of file SolveObject.h.

◆ _min_fixed_point_its

unsigned int FixedPointSolve::_min_fixed_point_its

protectedinherited

Minimum fixed point iterations.

Definition at line 187 of file FixedPointSolve.h.

Referenced by FixedPointSolve::examineFixedPointConvergence(), FixedPointSolve::FixedPointSolve(), and SteffensenSolve::SteffensenSolve().

◆ _name

const std::string MooseBase::_name

protectedinherited

The name of this class.

Definition at line 90 of file MooseBase.h.

Referenced by AddBCAction::act(), AddDamperAction::act(), AddKernelAction::act(), AddMeshGeneratorAction::act(), AddFVInterfaceKernelAction::act(), AddIndicatorAction::act(), AddMultiAppAction::act(), AddInterfaceKernelAction::act(), AddPostprocessorAction::act(), AddConstraintAction::act(), AddScalarKernelAction::act(), AddDiracKernelAction::act(), ReadExecutorParamsAction::act(), AddVectorPostprocessorAction::act(), AddFVInitialConditionAction::act(), AddMarkerAction::act(), AddInitialConditionAction::act(), AddDGKernelAction::act(), AddMaterialAction::act(), AddTransferAction::act(), AddNodalKernelAction::act(), PartitionerAction::act(), AddFunctorMaterialAction::act(), AddUserObjectAction::act(), AddReporterAction::act(), AddFieldSplitAction::act(), AddTimesAction::act(), AddPositionsAction::act(), AddFVBCAction::act(), AddFVKernelAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddFunctionAction::act(), AddMeshDivisionAction::act(), AddTimeStepperAction::act(), AddDistributionAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddSamplerAction::act(), AddOutputAction::act(), AddPeriodicBCAction::act(), AddControlAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenSidesetsGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::name(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseBase::setData(), and Split::setup().

◆ _old_tag_id

TagID PicardSolve::_old_tag_id

private

Vector tag id for the previous solution variable, as a main app.

Definition at line 86 of file PicardSolve.h.

Referenced by allocateStorage(), saveVariableValues(), and transformVariables().

◆ _pars

const InputParameters& MooseBaseParameterInterface::_pars

protectedinherited

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition at line 162 of file MooseBaseParameterInterface.h.

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _problem

FEProblemBase& SolveObject::_problem

protectedinherited

Reference to FEProblem.

Definition at line 42 of file SolveObject.h.

Referenced by SecantSolve::allocateStorage(), SteffensenSolve::allocateStorage(), allocateStorage(), FixedPointSolve::autoAdvance(), FEProblemSolve::FEProblemSolve(), FEProblemSolve::solve(), FixedPointSolve::solve(), FixedPointSolve::solveStep(), SteffensenSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), and transformPostprocessors().

◆ _relax_factor

const Real FixedPointSolve::_relax_factor

protectedinherited

Relaxation factor for fixed point Iteration.

Definition at line 208 of file FixedPointSolve.h.

Referenced by allocateStorage(), savePostprocessorValues(), saveVariableValues(), FixedPointSolve::solve(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), transformPostprocessors(), SecantSolve::transformVariables(), SteffensenSolve::transformVariables(), transformVariables(), and useFixedPointAlgorithmUpdateInsteadOfPicard().

◆ _secondary_old_tag_id

TagID PicardSolve::_secondary_old_tag_id

private

Vector tag id for the previous solution variable, as a sub app.

Definition at line 89 of file PicardSolve.h.

Referenced by allocateStorage(), saveVariableValues(), and transformVariables().

◆ _secondary_relaxation_factor

Real FixedPointSolve::_secondary_relaxation_factor

protectedinherited

Relaxation factor outside of fixed point iteration (used as a subapp)

Definition at line 217 of file FixedPointSolve.h.

Referenced by allocateStorage(), FixedPointSolve::FixedPointSolve(), savePostprocessorValues(), saveVariableValues(), FixedPointSolve::setMultiAppRelaxationFactor(), FixedPointSolve::solve(), SteffensenSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), transformPostprocessors(), SecantSolve::transformVariables(), SteffensenSolve::transformVariables(), transformVariables(), and useFixedPointAlgorithmUpdateInsteadOfPicard().

◆ _secondary_transformed_pps

std::vector<PostprocessorName> FixedPointSolve::_secondary_transformed_pps

protectedinherited

Postprocessors to be relaxed outside of fixed point iteration (used as a subapp)

Definition at line 221 of file FixedPointSolve.h.

Referenced by SteffensenSolve::allocateStorage(), allocateStorage(), FixedPointSolve::FixedPointSolve(), SecantSolve::savePostprocessorValues(), SteffensenSolve::savePostprocessorValues(), savePostprocessorValues(), SecantSolve::SecantSolve(), FixedPointSolve::setMultiAppTransformedPostprocessors(), FixedPointSolve::solveStep(), SteffensenSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), and transformPostprocessors().

◆ _secondary_transformed_pps_values

std::vector<std::vector<PostprocessorValue> > FixedPointSolve::_secondary_transformed_pps_values

protectedinherited

Previous values of the postprocessors relaxed outside of the fixed point iteration (used as a subapp)

Definition at line 223 of file FixedPointSolve.h.

Referenced by SteffensenSolve::allocateStorage(), allocateStorage(), SteffensenSolve::savePostprocessorValues(), SecantSolve::savePostprocessorValues(), savePostprocessorValues(), SecantSolve::SecantSolve(), SteffensenSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), and transformPostprocessors().

◆ _secondary_transformed_variables

std::vector<std::string> FixedPointSolve::_secondary_transformed_variables

protectedinherited

Variables to be relaxed outside of fixed point iteration (used as a subapp)

Definition at line 219 of file FixedPointSolve.h.

Referenced by FixedPointSolve::FixedPointSolve(), FixedPointSolve::setMultiAppTransformedVariables(), and FixedPointSolve::solve().

◆ _solver_sys

SystemBase& SolveObject::_solver_sys

protectedinherited

Reference to a system for creating vectors as needed for the solve, etc.

Definition at line 50 of file SolveObject.h.

Referenced by SecantSolve::allocateStorage(), SteffensenSolve::allocateStorage(), allocateStorage(), SteffensenSolve::saveVariableValues(), SecantSolve::saveVariableValues(), saveVariableValues(), SteffensenSolve::transformVariables(), SecantSolve::transformVariables(), and transformVariables().

◆ _transformed_pps

const std::vector<PostprocessorName> FixedPointSolve::_transformed_pps

protectedinherited

The postprocessors (transferred or not) that are going to be relaxed.

Definition at line 212 of file FixedPointSolve.h.

Referenced by SteffensenSolve::allocateStorage(), allocateStorage(), FixedPointSolve::FixedPointSolve(), SteffensenSolve::savePostprocessorValues(), SecantSolve::savePostprocessorValues(), savePostprocessorValues(), SecantSolve::SecantSolve(), FixedPointSolve::solveStep(), SteffensenSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), and transformPostprocessors().

◆ _transformed_pps_values

std::vector<std::vector<PostprocessorValue> > FixedPointSolve::_transformed_pps_values

protectedinherited

Previous values of the relaxed postprocessors.

Definition at line 214 of file FixedPointSolve.h.

Referenced by SteffensenSolve::allocateStorage(), allocateStorage(), SteffensenSolve::savePostprocessorValues(), SecantSolve::savePostprocessorValues(), savePostprocessorValues(), SecantSolve::SecantSolve(), SteffensenSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), and transformPostprocessors().

◆ _transformed_vars

std::vector<std::string> FixedPointSolve::_transformed_vars

protectedinherited

The variables (transferred or not) that are going to be relaxed.

Definition at line 210 of file FixedPointSolve.h.

Referenced by FixedPointSolve::FixedPointSolve(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

◆ _type

const std::string MooseBase::_type

protectedinherited

The type of this class.

Definition at line 87 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FEProblemBase::init(), FEProblemBase::solverTypeString(), and MooseBase::type().

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

include/executioners/PicardSolve.h
src/executioners/PicardSolve.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Member Enumeration Documentation

◆ MooseFixedPointConvergenceReason

Constructor & Destructor Documentation

◆ PicardSolve()

Member Function Documentation

◆ addPostprocessorDependencyHelper()

◆ allocateStorage()

◆ autoAdvance()

◆ callMooseError()

◆ checkConvergence()

◆ clearFixedPointStatus()

◆ computeCustomConvergencePostprocessor()

◆ connectControllableParams()

◆ coupledPostprocessors()

◆ enabled()

◆ errorPrefix()

◆ examineFixedPointConvergence()

◆ failStep()

◆ getCheckedPointerParam()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getMooseApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getPostprocessorName()

◆ getPostprocessorValue()

◆ getPostprocessorValueByName()

◆ getPostprocessorValueOld()

◆ getPostprocessorValueOldByName()

◆ getPostprocessorValueOlder()

◆ getPostprocessorValueOlderByName()

◆ getRenamedParam()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ hasFixedPointIteration()

◆ hasPostprocessor()

◆ hasPostprocessorByName()

◆ isDefaultPostprocessorValue()

◆ isParamSetByUser()

◆ isParamValid()

◆ mooseDeprecated()

◆ mooseDocumentedError()

◆ mooseError()

◆ mooseErrorNonPrefixed()

◆ mooseInfo()

◆ mooseWarning()

◆ mooseWarningNonPrefixed()

◆ name()

◆ numFixedPointIts()

◆ numPicardIts()

◆ paramError()

◆ parameters()

◆ paramInfo()

◆ paramWarning()

◆ perfGraph()

◆ printFixedPointConvergenceHistory()

◆ printFixedPointConvergenceReason()

◆ registerTimedSection() [1/2]

◆ registerTimedSection() [2/2]

◆ saveAllValues()

◆ savePostprocessorValues()

◆ saveVariableValues()

◆ setInnerSolve()

◆ setMultiAppRelaxationFactor()

◆ setMultiAppTransformedPostprocessors()

◆ setMultiAppTransformedVariables()

◆ solve()

◆ solveStep()

◆ timedSectionName()