www.mooseframework.org
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | List of all members
InversePowerMethod Class Reference

#include <InversePowerMethod.h>

Inheritance diagram for InversePowerMethod:
[legend]

Public Member Functions

 InversePowerMethod (const InputParameters &parameters)
 
virtual void init () override
 Initialize the executioner. More...
 
virtual void execute () override
 Pure virtual execute function MUST be overridden by children classes. More...
 
virtual bool lastSolveConverged () const override
 Whether or not the last solve converged. More...
 
const Real & eigenvalueOld ()
 The old eigenvalue used by inverse power iterations. More...
 
virtual void makeBXConsistent (Real k)
 Normalize solution so that |Bx| = k. More...
 
virtual void checkIntegrity ()
 Make sure time kernel is not presented. More...
 
virtual bool inversePowerIteration (unsigned int min_iter, unsigned int max_iter, Real pfactor, bool cheb_on, Real tol_eig, bool echo, PostprocessorName xdiff, Real tol_x, Real &k, Real &initial_res)
 Perform inverse power iterations with the initial guess of the solution. More...
 
virtual void preIteration ()
 Override this for actions that should take place before linear solve of each inverse power iteration. More...
 
virtual void postIteration ()
 Override this for actions that should take place after linear solve of each inverse power iteration. More...
 
virtual void postExecute () override
 Override this for actions that should take place after the main solve. More...
 
virtual Real normalizeSolution (bool force=true)
 Normalize the solution vector based on the postprocessor value for normalization. More...
 
virtual bool nonlinearSolve (Real rel_tol, Real abs_tol, Real pfactor, Real &k)
 Perform nonlinear solve with the initial guess of the solution. More...
 
Real & eigenValue ()
 A method for returning the eigenvalue computed by the executioner. More...
 
virtual void preExecute ()
 Override this for actions that should take place before execution. More...
 
virtual void preSolve ()
 Override this for actions that should take place before execution. More...
 
virtual void postSolve ()
 Override this for actions that should take place after execution. More...
 
virtual Problemproblem ()
 Deprecated: Return a reference to this Executioner's Problem instance. More...
 
FEProblemBasefeProblem ()
 Return a reference to this Executioner's FEProblemBase instance. More...
 
virtual std::string getTimeStepperName ()
 The name of the TimeStepper This is an empty string for non-Transient executioners. More...
 
virtual void parentOutputPositionChanged ()
 Can be used by subsclasses to call parentOutputPositionChanged() on the underlying FEProblemBase. More...
 
PicardSolvepicardSolve ()
 Return underlining PicardSolve object. More...
 
virtual bool augmentedPicardConvergenceCheck () const
 Augmented Picard convergence check that can be overridden by derived executioners. More...
 
const std::string & type () const
 Get the type of this object. More...
 
const std::string & name () const
 Get the name of the object. More...
 
const InputParametersparameters () const
 Get the parameters of the object. More...
 
template<typename T >
const T & getParam (const std::string &name) const
 Retrieve a parameter for the object. More...
 
template<typename 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...
 
MooseAppgetMooseApp () const
 Get the MooseApp this object is associated with. More...
 
virtual bool enabled () const
 Return the enabled status of the object. More...
 
template<typename... Args>
void paramError (const std::string &param, Args... args)
 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)
 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)
 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...
 
template<typename... Args>
void mooseError (Args &&... args) const
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 
template<typename... Args>
void mooseInfo (Args &&... args) const
 
template<class T >
const T & getUserObject (const std::string &name)
 Get an user object with a given parameter name. More...
 
template<class T >
const T & getUserObjectByName (const std::string &name)
 Get an user object with a given name. More...
 
const UserObjectgetUserObjectBase (const std::string &name)
 Get an user object with a given parameter name. More...
 
const UserObjectgetUserObjectBaseByName (const std::string &name)
 Get an user object with a given name. More...
 
bool hasPostprocessor (const std::string &name) const
 Determine if the Postprocessor exists. More...
 
bool hasPostprocessorByName (const PostprocessorName &name)
 Determine if the Postprocessor exists. More...
 
const PostprocessorValuegetPostprocessorValue (const std::string &name)
 Retrieve the value of a Postprocessor or one of it's old or older values. More...
 
const PostprocessorValuegetPostprocessorValueOld (const std::string &name)
 
const PostprocessorValuegetPostprocessorValueOlder (const std::string &name)
 
const PostprocessorValuegetPostprocessorValueByName (const PostprocessorName &name)
 Retrieve the value of the Postprocessor. More...
 
const PostprocessorValuegetPostprocessorValueOldByName (const PostprocessorName &name)
 
const PostprocessorValuegetPostprocessorValueOlderByName (const PostprocessorName &name)
 
const PostprocessorValuegetDefaultPostprocessorValue (const std::string &name)
 Return the default postprocessor value. More...
 

Public Attributes

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

Protected Member Functions

virtual void takeStep ()
 
virtual void printEigenvalue ()
 Print eigenvalue. More...
 
void chebyshev (Chebyshev_Parameters &params, unsigned int iter, const PostprocessorValue *solution_diff)
 
virtual void addAttributeReporter (const std::string &name, Real &attribute, const std::string execute_on="")
 Adds a postprocessor to report a Real class attribute. More...
 
template<typename T >
T & declareRestartableData (std::string data_name)
 Declare a piece of data as "restartable". More...
 
template<typename T >
T & declareRestartableData (std::string data_name, const T &init_value)
 Declare a piece of data as "restartable" and initialize it. More...
 
template<typename T >
T & declareRestartableDataWithContext (std::string data_name, void *context)
 Declare a piece of data as "restartable". More...
 
template<typename T >
T & declareRestartableDataWithContext (std::string data_name, const T &init_value, void *context)
 Declare a piece of data as "restartable" and initialize it. More...
 
template<typename T >
T & declareRecoverableData (std::string data_name)
 Declare a piece of data as "recoverable". More...
 
template<typename T >
T & declareRecoverableData (std::string data_name, const T &init_value)
 Declare a piece of data as "restartable" and initialize it. More...
 
template<typename T >
T & declareRestartableDataWithObjectName (std::string data_name, std::string object_name)
 Declare a piece of data as "restartable". More...
 
template<typename T >
T & declareRestartableDataWithObjectNameWithContext (std::string data_name, std::string object_name, void *context)
 Declare a piece of data as "restartable". More...
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level)
 Call to register a named section for timing. More...
 

Protected Attributes

const PostprocessorName & _solution_diff_name
 name of the postprocessor for evaluating |x-xprevious|; empty means that no postprocessor is provided and power iteration will not check convergence based on it More...
 
const PostprocessorValue_solution_diff
 postprocessor for evaluating |x-xprevious| More...
 
const unsigned int & _min_iter
 minimum number of power iterations More...
 
const unsigned int & _max_iter
 maximum number of power iterations More...
 
const Real & _eig_check_tol
 convergence tolerance on eigenvalue More...
 
const Real & _sol_check_tol
 convergence tolerance on solution difference More...
 
const Real & _pfactor
 tolerance on each power iteration (always one nonlinear iteration) More...
 
const bool & _cheb_on
 indicating if Chebyshev acceleration is turned on More...
 
bool _last_solve_converged
 flag to indicate if inverse power iteration converged More...
 
FEProblemBase_problem
 
MooseEigenSystem_eigen_sys
 
Real & _eigenvalue
 Storage for the eigenvalue computed by the executioner. More...
 
const Real & _source_integral
 
Real _source_integral_old
 
const Real & _normalization
 Postprocessor for normalization. More...
 
ExecFlagEnum _norm_exec
 
PerfID _final_timer
 
FEProblemBase_fe_problem
 
PicardSolve _picard_solve
 
Real _initial_residual_norm
 Initial Residual Variables. More...
 
Real _old_initial_residual_norm
 
std::string _restart_file_base
 
std::vector< std::string > _splitting
 
const InputParameters_pars
 Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...
 
MooseApp_app
 The MooseApp this object is associated with. More...
 
const std::string & _type
 The type of this object (the Class name) More...
 
const std::string & _name
 The name of this object, reference to value stored in InputParameters. More...
 
const bool & _enabled
 Reference to the "enable" InputParaemters, used by Controls for toggling on/off MooseObjects. More...
 
const InputParameters_pg_params
 Params. More...
 
PerfGraph_perf_graph
 The performance graph to add to. More...
 
std::string _prefix
 A prefix to use for all sections. More...
 

Detailed Description

Definition at line 21 of file InversePowerMethod.h.

Constructor & Destructor Documentation

◆ InversePowerMethod()

InversePowerMethod::InversePowerMethod ( const InputParameters parameters)

Definition at line 35 of file InversePowerMethod.C.

37  _solution_diff_name(getParam<PostprocessorName>("xdiff")),
38  _min_iter(getParam<unsigned int>("min_power_iterations")),
39  _max_iter(getParam<unsigned int>("max_power_iterations")),
40  _eig_check_tol(getParam<Real>("eig_check_tol")),
41  _sol_check_tol(getParam<Real>("sol_check_tol")),
42  _pfactor(getParam<Real>("pfactor")),
43  _cheb_on(getParam<bool>("Chebyshev_acceleration_on"))
44 {
45  if (!_app.isRecovering() && !_app.isRestarting())
46  _eigenvalue = getParam<Real>("k0");
47 
48  addAttributeReporter("eigenvalue", _eigenvalue, "initial timestep_end");
49 
50  if (_max_iter < _min_iter)
51  mooseError("max_power_iterations<min_power_iterations!");
52  if (_eig_check_tol < 0.0)
53  mooseError("eig_check_tol<0!");
54  if (_pfactor < 0.0)
55  mooseError("pfactor<0!");
56 }
const unsigned int & _min_iter
minimum number of power iterations
virtual void addAttributeReporter(const std::string &name, Real &attribute, const std::string execute_on="")
Adds a postprocessor to report a Real class attribute.
Definition: Executioner.C:255
EigenExecutionerBase(const InputParameters &parameters)
Constructor.
const Real & _pfactor
tolerance on each power iteration (always one nonlinear iteration)
void mooseError(Args &&... args) const
Definition: MooseObject.h:144
bool isRestarting() const
Whether or not this is a "restart" calculation.
Definition: MooseApp.C:859
const bool & _cheb_on
indicating if Chebyshev acceleration is turned on
const unsigned int & _max_iter
maximum number of power iterations
const PostprocessorName & _solution_diff_name
name of the postprocessor for evaluating |x-xprevious|; empty means that no postprocessor is provided...
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62
const Real & _sol_check_tol
convergence tolerance on solution difference
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:174
bool isRecovering() const
Whether or not this is a "recover" calculation.
Definition: MooseApp.C:853
const Real & _eig_check_tol
convergence tolerance on eigenvalue

Member Function Documentation

◆ addAttributeReporter()

void Executioner::addAttributeReporter ( const std::string &  name,
Real &  attribute,
const std::string  execute_on = "" 
)
protectedvirtualinherited

Adds a postprocessor to report a Real class attribute.

Parameters
nameThe name of the postprocessor to create
attributeThe Real class attribute to report
execute_onWhen to execute the postprocessor that is created

Definition at line 255 of file Executioner.C.

Referenced by InversePowerMethod(), and NonlinearEigen::NonlinearEigen().

258 {
259  FEProblemBase * problem = getCheckedPointerParam<FEProblemBase *>(
260  "_fe_problem_base",
261  "Failed to retrieve FEProblemBase when adding a attribute reporter in Executioner");
262  InputParameters params = _app.getFactory().getValidParams("ExecutionerAttributeReporter");
263  params.set<Real *>("value") = &attribute;
264  if (!execute_on.empty())
265  params.set<ExecFlagEnum>("execute_on") = execute_on;
266  problem->addPostprocessor("ExecutionerAttributeReporter", name, params);
267 }
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:25
InputParameters getValidParams(const std::string &name)
Get valid parameters for the object.
Definition: Factory.C:67
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Factory & getFactory()
Retrieve the Factory associated with this App.
Definition: MooseApp.h:280
virtual Problem & problem()
Deprecated: Return a reference to this Executioner&#39;s Problem instance.
Definition: Executioner.C:236
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:174
const std::string & name() const
Get the name of the object.
Definition: MooseObject.h:56

◆ augmentedPicardConvergenceCheck()

virtual bool Executioner::augmentedPicardConvergenceCheck ( ) const
inlinevirtualinherited

Augmented Picard convergence check that can be overridden by derived executioners.

Definition at line 117 of file Executioner.h.

Referenced by PicardSolve::solve().

117 { return false; }

◆ chebyshev()

void EigenExecutionerBase::chebyshev ( Chebyshev_Parameters params,
unsigned int  iter,
const PostprocessorValue solution_diff 
)
protectedinherited

Definition at line 469 of file EigenExecutionerBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

472 {
473  if (!solution_diff)
474  mooseError("solution diff is required for Chebyshev acceleration");
475 
476  if (chebyshev_parameters.lgac == 0)
477  {
478  if (chebyshev_parameters.icho == 0)
479  chebyshev_parameters.ratio = *solution_diff / chebyshev_parameters.flux_error_norm_old;
480  else
481  {
482  chebyshev_parameters.ratio = chebyshev_parameters.ratio_new;
483  chebyshev_parameters.icho = 0;
484  }
485 
486  if (iter > chebyshev_parameters.finit && chebyshev_parameters.ratio >= 0.4 &&
487  chebyshev_parameters.ratio <= 1)
488  {
489  chebyshev_parameters.lgac = 1;
490  chebyshev_parameters.icheb = 1;
491  chebyshev_parameters.error_begin = *solution_diff;
492  chebyshev_parameters.iter_begin = iter;
493  double alp = 2 / (2 - chebyshev_parameters.ratio);
494  std::vector<double> coef(2);
495  coef[0] = alp;
496  coef[1] = 1 - alp;
500  }
501  }
502  else
503  {
504  chebyshev_parameters.icheb++;
505  double gamma = acosh(2 / chebyshev_parameters.ratio - 1);
506  double alp = 4 / chebyshev_parameters.ratio *
507  std::cosh((chebyshev_parameters.icheb - 1) * gamma) /
508  std::cosh(chebyshev_parameters.icheb * gamma);
509  double beta = (1 - chebyshev_parameters.ratio / 2) * alp - 1;
510  /* if (iter<int(chebyshev_parameters.iter_begin+chebyshev_parameters.n_iter))
511  {
512  std::vector<double> coef(3);
513  coef[0] = alp;
514  coef[1] = 1-alp+beta;
515  coef[2] = -beta;
516  _eigen_sys.combineSystemSolution(NonlinearSystem::EIGEN, coef);
517  }
518  else
519  {*/
520  double gamma_new =
521  (*solution_diff / chebyshev_parameters.error_begin) *
522  (std::cosh((chebyshev_parameters.icheb - 1) * acosh(2 / chebyshev_parameters.ratio - 1)));
523  if (gamma_new < 1.0)
524  gamma_new = 1.0;
525 
526  chebyshev_parameters.ratio_new =
527  chebyshev_parameters.ratio / 2 *
528  (std::cosh(acosh(gamma_new) / (chebyshev_parameters.icheb - 1)) + 1);
529  if (gamma_new > 1.01)
530  {
531  chebyshev_parameters.lgac = 0;
532  // chebyshev_parameters.icheb = 0;
533  // if (chebyshev_parameters.icheb>30)
534  // {
535  if (chebyshev_parameters.icheb > 0)
536  {
537  chebyshev_parameters.icho = 1;
538  chebyshev_parameters.finit = iter;
539  }
540  else
541  {
542  chebyshev_parameters.icho = 0;
543  chebyshev_parameters.finit = iter + chebyshev_parameters.fsmooth;
544  }
545  }
546  else
547  {
548  std::vector<double> coef(3);
549  coef[0] = alp;
550  coef[1] = 1 - alp + beta;
551  coef[2] = -beta;
555  }
556  // }
557  }
558  chebyshev_parameters.flux_error_norm_old = *solution_diff;
559 }
void mooseError(Args &&... args) const
Definition: MooseObject.h:144
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
void combineSystemSolution(SYSTEMTAG tag, const std::vector< Real > &coefficients)
Linear combination of the solution vectors.
const ExecFlagType EXEC_LINEAR
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
MooseEigenSystem & _eigen_sys

◆ checkIntegrity()

void EigenExecutionerBase::checkIntegrity ( )
virtualinherited

Make sure time kernel is not presented.

Definition at line 148 of file EigenExecutionerBase.C.

Referenced by EigenExecutionerBase::init().

149 {
150  // check to make sure that we don't have any time kernels in this simulation
152  mooseError("You have specified time kernels in your steady state eigenvalue simulation");
154  mooseError("You have not specified any eigen kernels in your eigenvalue simulation");
155 }
void mooseError(Args &&... args) const
Definition: MooseObject.h:144
bool containsEigenKernel() const
Weather or not the system contains eigen kernels.
MooseEigenSystem & _eigen_sys

◆ declareRecoverableData() [1/2]

template<typename T >
T & Restartable::declareRecoverableData ( std::string  data_name)
protectedinherited

Declare a piece of data as "recoverable".

This means that in the event of a recovery this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)

Definition at line 269 of file Restartable.h.

270 {
271  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
272 
273  registerRecoverableDataOnApp(full_name);
274 
275  return declareRestartableDataWithContext<T>(data_name, nullptr);
276 }
std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:194
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191
void registerRecoverableDataOnApp(std::string name)
Helper function for actually registering the restartable data.
Definition: Restartable.C:54

◆ declareRecoverableData() [2/2]

template<typename T >
T & Restartable::declareRecoverableData ( std::string  data_name,
const T &  init_value 
)
protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
init_valueThe initial value of the data

Definition at line 280 of file Restartable.h.

281 {
282  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
283 
284  registerRecoverableDataOnApp(full_name);
285 
286  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
287 }
std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:194
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191
void registerRecoverableDataOnApp(std::string name)
Helper function for actually registering the restartable data.
Definition: Restartable.C:54

◆ declareRestartableData() [1/2]

template<typename T >
T & Restartable::declareRestartableData ( std::string  data_name)
protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)

Definition at line 202 of file Restartable.h.

203 {
204  return declareRestartableDataWithContext<T>(data_name, nullptr);
205 }

◆ declareRestartableData() [2/2]

template<typename T >
T & Restartable::declareRestartableData ( std::string  data_name,
const T &  init_value 
)
protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
init_valueThe initial value of the data

Definition at line 209 of file Restartable.h.

210 {
211  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
212 }

◆ declareRestartableDataWithContext() [1/2]

template<typename T >
T & Restartable::declareRestartableDataWithContext ( std::string  data_name,
void *  context 
)
protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
contextContext pointer that will be passed to the load and store functions

Definition at line 216 of file Restartable.h.

217 {
218  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
219  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
220  T & restartable_data_ref = data_ptr->get();
221 
222  registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid);
223 
224  return restartable_data_ref;
225 }
std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:194
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191
THREAD_ID _restartable_tid
The thread ID for this object.
Definition: Restartable.h:197
void registerRestartableDataOnApp(std::string name, std::unique_ptr< RestartableDataValue > data, THREAD_ID tid)
Helper function for actually registering the restartable data.
Definition: Restartable.C:46

◆ declareRestartableDataWithContext() [2/2]

template<typename T >
T & Restartable::declareRestartableDataWithContext ( std::string  data_name,
const T &  init_value,
void *  context 
)
protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
init_valueThe initial value of the data
contextContext pointer that will be passed to the load and store functions

Definition at line 229 of file Restartable.h.

232 {
233  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
234  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
235  data_ptr->set() = init_value;
236 
237  T & restartable_data_ref = data_ptr->get();
238  registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid);
239 
240  return restartable_data_ref;
241 }
std::string _restartable_system_name
The system name this object is in.
Definition: Restartable.h:194
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191
THREAD_ID _restartable_tid
The thread ID for this object.
Definition: Restartable.h:197
void registerRestartableDataOnApp(std::string name, std::unique_ptr< RestartableDataValue > data, THREAD_ID tid)
Helper function for actually registering the restartable data.
Definition: Restartable.C:46

◆ declareRestartableDataWithObjectName()

template<typename T >
T & Restartable::declareRestartableDataWithObjectName ( std::string  data_name,
std::string  object_name 
)
protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
object_nameA supplied name for the object that is declaring this data.

Definition at line 245 of file Restartable.h.

246 {
247  return declareRestartableDataWithObjectNameWithContext<T>(data_name, object_name, nullptr);
248 }

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T >
T & Restartable::declareRestartableDataWithObjectNameWithContext ( std::string  data_name,
std::string  object_name,
void *  context 
)
protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters
data_nameThe name of the data (usually just use the same name as the member variable)
object_nameA supplied name for the object that is declaring this data.
contextContext pointer that will be passed to the load and store functions

Definition at line 252 of file Restartable.h.

255 {
256  std::string old_name = _restartable_name;
257 
258  _restartable_name = object_name;
259 
260  T & value = declareRestartableDataWithContext<T>(data_name, context);
261 
262  _restartable_name = old_name;
263 
264  return value;
265 }
std::string _restartable_name
The name of the object.
Definition: Restartable.h:191

◆ eigenValue()

Real& EigenExecutionerBase::eigenValue ( )
inlineinherited

A method for returning the eigenvalue computed by the executioner.

Returns
A reference to the eigenvalue stored withing the executioner

Definition at line 121 of file EigenExecutionerBase.h.

121 { return _eigenvalue; }
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.

◆ eigenvalueOld()

const Real & EigenExecutionerBase::eigenvalueOld ( )
inherited

The old eigenvalue used by inverse power iterations.

Definition at line 45 of file EigenExecutionerBase.C.

Referenced by EigenKernel::EigenKernel().

46 {
47  return _source_integral_old;
48 }

◆ enabled()

virtual bool MooseObject::enabled ( ) const
inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 96 of file MooseObject.h.

Referenced by EigenKernel::enabled().

96 { return _enabled; }
const bool & _enabled
Reference to the "enable" InputParaemters, used by Controls for toggling on/off MooseObjects.
Definition: MooseObject.h:183

◆ execute()

void InversePowerMethod::execute ( )
overridevirtual

Pure virtual execute function MUST be overridden by children classes.

This is where the Executioner actually does it's work.

Implements Executioner.

Definition at line 79 of file InversePowerMethod.C.

80 {
81  if (_app.isRecovering())
82  return;
83 
84  preExecute();
85 
86  takeStep();
87 
88  postExecute();
89 }
virtual void takeStep()
virtual void preExecute()
Override this for actions that should take place before execution.
Definition: Executioner.C:216
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:174
virtual void postExecute() override
Override this for actions that should take place after the main solve.
bool isRecovering() const
Whether or not this is a "recover" calculation.
Definition: MooseApp.C:853

◆ feProblem()

FEProblemBase & Executioner::feProblem ( )
inherited

Return a reference to this Executioner's FEProblemBase instance.

Definition at line 243 of file Executioner.C.

Referenced by AlgebraicRelationshipManager::attachAlgebraicFunctorHelper(), and TransientMultiApp::restore().

244 {
245  return _fe_problem;
246 }
FEProblemBase & _fe_problem
Definition: Executioner.h:130

◆ getCheckedPointerParam()

template<typename T >
T MooseObject::getCheckedPointerParam ( const std::string &  name,
const std::string &  error_string = "" 
) const
inlineinherited

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 77 of file MooseObject.h.

78  {
79  return parameters().getCheckedPointerParam<T>(name, error_string);
80  }
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...
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:62
const std::string & name() const
Get the name of the object.
Definition: MooseObject.h:56

◆ getDefaultPostprocessorValue()

const PostprocessorValue & PostprocessorInterface::getDefaultPostprocessorValue ( const std::string &  name)
inherited

Return the default postprocessor value.

Parameters
nameThe name of the postprocessor parameter
Returns
A const reference to the default value

Definition at line 86 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel().

87 {
89 }
const InputParameters & _ppi_params
PostprocessorInterface Parameters.
const PostprocessorValue & getDefaultPostprocessorValue(const std::string &name, bool suppress_error=false) const
Get the default value for a postprocessor added with addPostprocessor.

◆ getMooseApp()

MooseApp& MooseObject::getMooseApp ( ) const
inlineinherited

Get the MooseApp this object is associated with.

Definition at line 91 of file MooseObject.h.

Referenced by RestartableDataIO::createBackup(), RestartableDataIO::deserializeRestartableData(), ConsoleUtils::outputMeshInformation(), Resurrector::restartRestartableData(), and RestartableDataIO::restoreBackup().

91 { return _app; }
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:174

◆ getParam()

template<typename T >
const T & MooseObject::getParam ( const std::string &  name) const
inherited

Retrieve a parameter for the object.

Parameters
nameThe name of the parameter
Returns
The value of the parameter

Definition at line 188 of file MooseObject.h.

Referenced by FEProblemBase::addMaterialHelper(), ConstraintWarehouse::addObject(), BicubicSplineFunction::BicubicSplineFunction(), Piecewise::buildFromXandY(), MultiApp::createApp(), DerivativeParsedMaterial::DerivativeParsedMaterial(), EigenKernel::EigenKernel(), FEProblemBase::FEProblemBase(), FieldSplitPreconditioner::FieldSplitPreconditioner(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), SideSetsBetweenSubdomainsGenerator::generate(), ExtraNodesetGenerator::generate(), MeshExtruderGenerator::generate(), SideSetsAroundSubdomainGenerator::generate(), GenericConstantRankTwoTensor::GenericConstantRankTwoTensor(), TimeSequenceStepper::init(), AttribThread::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), AdvancedOutput::initialSetup(), SideSetsBetweenSubdomains::modify(), AddExtraNodeset::modify(), MeshExtruder::modify(), SideSetsAroundSubdomain::modify(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterial::ParsedMaterial(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), and VectorOfPostprocessors::VectorOfPostprocessors().

189 {
190  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0));
191 }
static const T & getParamHelper(const std::string &name, const InputParameters &pars, const T *the_type)
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseObject.h:171
const std::string & name() const
Get the name of the object.
Definition: MooseObject.h:56

◆ getPostprocessorValue()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValue ( const std::string &  name)
inherited

Retrieve the value of a Postprocessor or one of it's old or older values.

Parameters
nameThe name of the Postprocessor parameter (see below)
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 23 of file PostprocessorInterface.C.

Referenced by GeneralUserObject::getPostprocessorValue(), and AuxKernel::getPostprocessorValue().

24 {
25  // Return the default if the Postprocessor does not exist and a default does, otherwise
26  // continue as usual
29  else
30  return _pi_feproblem.getPostprocessorValue(_ppi_params.get<PostprocessorName>(name));
31 }
bool hasPostprocessor(const std::string &name) const
Determine if the Postprocessor exists.
bool hasDefaultPostprocessorValue(const std::string &name) const
Returns true if a default PostprocessorValue is defined.
FEProblemBase & _pi_feproblem
Reference the the FEProblemBase class.
PostprocessorValue & getPostprocessorValue(const PostprocessorName &name)
Get a reference to the value associated with the postprocessor.
const InputParameters & _ppi_params
PostprocessorInterface Parameters.
const PostprocessorValue & getDefaultPostprocessorValue(const std::string &name, bool suppress_error=false) const
Get the default value for a postprocessor added with addPostprocessor.

◆ getPostprocessorValueByName()

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

Retrieve the value of the Postprocessor.

Parameters
namePostprocessor 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 56 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel(), GeneralUserObject::getPostprocessorValueByName(), AuxKernel::getPostprocessorValueByName(), and EigenExecutionerBase::inversePowerIteration().

57 {
59 }
FEProblemBase & _pi_feproblem
Reference the the FEProblemBase class.
PostprocessorValue & getPostprocessorValue(const PostprocessorName &name)
Get a reference to the value associated with the postprocessor.

◆ getPostprocessorValueOld()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOld ( const std::string &  name)
inherited

Definition at line 34 of file PostprocessorInterface.C.

35 {
36  // Return the default if the Postprocessor does not exist and a default does, otherwise
37  // continue as usual
40  else
41  return _pi_feproblem.getPostprocessorValueOld(_ppi_params.get<PostprocessorName>(name));
42 }
bool hasPostprocessor(const std::string &name) const
Determine if the Postprocessor exists.
bool hasDefaultPostprocessorValue(const std::string &name) const
Returns true if a default PostprocessorValue is defined.
PostprocessorValue & getPostprocessorValueOld(const std::string &name)
Get the reference to the old value of a post-processor.
FEProblemBase & _pi_feproblem
Reference the the FEProblemBase class.
const InputParameters & _ppi_params
PostprocessorInterface Parameters.
const PostprocessorValue & getDefaultPostprocessorValue(const std::string &name, bool suppress_error=false) const
Get the default value for a postprocessor added with addPostprocessor.

◆ getPostprocessorValueOldByName()

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

Definition at line 62 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel().

63 {
65 }
PostprocessorValue & getPostprocessorValueOld(const std::string &name)
Get the reference to the old value of a post-processor.
FEProblemBase & _pi_feproblem
Reference the the FEProblemBase class.

◆ getPostprocessorValueOlder()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOlder ( const std::string &  name)
inherited

Definition at line 45 of file PostprocessorInterface.C.

46 {
47  // Return the default if the Postprocessor does not exist and a default does, otherwise
48  // continue as usual
51  else
52  return _pi_feproblem.getPostprocessorValueOlder(_ppi_params.get<PostprocessorName>(name));
53 }
bool hasPostprocessor(const std::string &name) const
Determine if the Postprocessor exists.
bool hasDefaultPostprocessorValue(const std::string &name) const
Returns true if a default PostprocessorValue is defined.
FEProblemBase & _pi_feproblem
Reference the the FEProblemBase class.
PostprocessorValue & getPostprocessorValueOlder(const std::string &name)
Get the reference to the older value of a post-processor.
const InputParameters & _ppi_params
PostprocessorInterface Parameters.
const PostprocessorValue & getDefaultPostprocessorValue(const std::string &name, bool suppress_error=false) const
Get the default value for a postprocessor added with addPostprocessor.

◆ getPostprocessorValueOlderByName()

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

Definition at line 68 of file PostprocessorInterface.C.

69 {
71 }
FEProblemBase & _pi_feproblem
Reference the the FEProblemBase class.
PostprocessorValue & getPostprocessorValueOlder(const std::string &name)
Get the reference to the older value of a post-processor.

◆ getTimeStepperName()

std::string Executioner::getTimeStepperName ( )
virtualinherited

The name of the TimeStepper This is an empty string for non-Transient executioners.

Returns
A string of giving the TimeStepper name

Reimplemented in Transient.

Definition at line 249 of file Executioner.C.

Referenced by ConsoleUtils::outputExecutionInformation().

250 {
251  return std::string();
252 }

◆ getUserObject()

template<class T >
const T & UserObjectInterface::getUserObject ( const std::string &  name)
inherited

Get an user object with a given parameter name.

Parameters
nameThe name of the parameter key of the user object to retrieve
Returns
The user object with name associated with the parameter 'name'

Definition at line 81 of file UserObjectInterface.h.

82 {
83  unsigned int tid = needThreadedCopy(getUserObjectBase(name)) ? _uoi_tid : 0;
84  return _uoi_feproblem.getUserObject<T>(_uoi_params.get<UserObjectName>(name), tid);
85 }
T & getUserObject(const std::string &name, unsigned int tid=0) const
Get the user object by its name.
const InputParameters & _uoi_params
Parameters of the object with this interface.
FEProblemBase & _uoi_feproblem
Reference to the FEProblemBase instance.
THREAD_ID _uoi_tid
Thread ID.
const UserObject & getUserObjectBase(const std::string &name)
Get an user object with a given parameter name.
bool needThreadedCopy(const UserObject &uo) const
Check if the threaded copy of the user object is needed.

◆ getUserObjectBase()

const UserObject & UserObjectInterface::getUserObjectBase ( const std::string &  name)
inherited

Get an user object with a given parameter name.

Parameters
nameThe name of the parameter key of the user object to retrieve
Returns
The user object with name associated with the parameter 'name'

Definition at line 24 of file UserObjectInterface.C.

Referenced by UserObjectInterface::getUserObject(), InitialConditionBase::getUserObjectBase(), and AuxKernel::getUserObjectBase().

25 {
26  return _uoi_feproblem.getUserObjectBase(_uoi_params.get<UserObjectName>(name));
27 }
const UserObject & getUserObjectBase(const std::string &name) const
Get the user object by its name.
const InputParameters & _uoi_params
Parameters of the object with this interface.
FEProblemBase & _uoi_feproblem
Reference to the FEProblemBase instance.

◆ getUserObjectBaseByName()

const UserObject & UserObjectInterface::getUserObjectBaseByName ( const std::string &  name)
inherited

Get an user object with a given name.

Parameters
nameThe name of the user object to retrieve
Returns
The user object with the name

Definition at line 30 of file UserObjectInterface.C.

Referenced by UserObjectInterface::getUserObjectByName().

31 {
32  return _uoi_feproblem.getUserObjectBase(name);
33 }
const UserObject & getUserObjectBase(const std::string &name) const
Get the user object by its name.
FEProblemBase & _uoi_feproblem
Reference to the FEProblemBase instance.

◆ getUserObjectByName()

template<class T >
const T & UserObjectInterface::getUserObjectByName ( const std::string &  name)
inherited

Get an user object with a given name.

Parameters
nameThe name of the user object to retrieve
Returns
The user object with the name

Definition at line 89 of file UserObjectInterface.h.

90 {
91  unsigned int tid = needThreadedCopy(getUserObjectBaseByName(name)) ? _uoi_tid : 0;
92  return _uoi_feproblem.getUserObject<T>(name, tid);
93 }
T & getUserObject(const std::string &name, unsigned int tid=0) const
Get the user object by its name.
const UserObject & getUserObjectBaseByName(const std::string &name)
Get an user object with a given name.
FEProblemBase & _uoi_feproblem
Reference to the FEProblemBase instance.
THREAD_ID _uoi_tid
Thread ID.
bool needThreadedCopy(const UserObject &uo) const
Check if the threaded copy of the user object is needed.

◆ hasPostprocessor()

bool PostprocessorInterface::hasPostprocessor ( const std::string &  name) const
inherited

Determine if the Postprocessor exists.

Parameters
nameThe name of the Postprocessor parameter
Returns
True if the Postprocessor exists
See also
hasPostprocessorByName getPostprocessorValue

Definition at line 74 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel(), PostprocessorInterface::getPostprocessorValue(), PostprocessorInterface::getPostprocessorValueOld(), PostprocessorInterface::getPostprocessorValueOlder(), and TestSetupPostprocessorDataActionFunction::TestSetupPostprocessorDataActionFunction().

75 {
76  return _pi_feproblem.hasPostprocessor(_ppi_params.get<PostprocessorName>(name));
77 }
FEProblemBase & _pi_feproblem
Reference the the FEProblemBase class.
bool hasPostprocessor(const std::string &name)
Check existence of the postprocessor.
const InputParameters & _ppi_params
PostprocessorInterface Parameters.

◆ hasPostprocessorByName()

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

Determine if the Postprocessor exists.

Parameters
nameThe name of the Postprocessor
Returns
True if the Postprocessor exists
See also
hasPostprocessor getPostprocessorValueByName

Definition at line 80 of file PostprocessorInterface.C.

Referenced by VectorOfPostprocessors::VectorOfPostprocessors().

81 {
82  return _pi_feproblem.hasPostprocessor(name);
83 }
FEProblemBase & _pi_feproblem
Reference the the FEProblemBase class.
bool hasPostprocessor(const std::string &name)
Check existence of the postprocessor.

◆ init()

void InversePowerMethod::init ( )
overridevirtual

Initialize the executioner.

Reimplemented from EigenExecutionerBase.

Definition at line 59 of file InversePowerMethod.C.

60 {
61  if (_app.isRecovering())
62  {
63  _console << "\nCannot recover InversePowerMethod solves!\nExiting...\n" << std::endl;
64  return;
65  }
66 
68 
69  // Write the initial.
70  // Note: We need to tempararily change the system time to make the output system work properly.
71  _problem.timeStep() = 0;
72  Real t = _problem.time();
75  _problem.time() = t;
76 }
virtual Real & time() const
virtual int & timeStep() const
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:174
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
virtual void init() override
Initialize the executioner.
bool isRecovering() const
Whether or not this is a "recover" calculation.
Definition: MooseApp.C:853
virtual void outputStep(ExecFlagType type)
Output the current step.
const ExecFlagType EXEC_INITIAL

◆ inversePowerIteration()

bool EigenExecutionerBase::inversePowerIteration ( unsigned int  min_iter,
unsigned int  max_iter,
Real  pfactor,
bool  cheb_on,
Real  tol_eig,
bool  echo,
PostprocessorName  xdiff,
Real  tol_x,
Real &  k,
Real &  initial_res 
)
virtualinherited

Perform inverse power iterations with the initial guess of the solution.

Parameters
min_iterThe minimum number of power iterations.
max_iterThe maximum number of power iterations.
pfactorThe factor on reducing the residual norm of each power iteration.
cheb_onTo turn the Chebyshev acceleration on.
tol_eigTolerance on the difference of the eigenvalue of two successive iterations.
echoTrue to make screen printouts.
xdiffName of the postprocessor evaluating the difference of the solution norm of two successive iterations.
tol_xTolerance on the difference of the solution norm of two successive iterations.
kEigenvalue, input as the initial guess.
initial_resThe initial residual.
Returns
true solve converges, otherwise false.

Definition at line 158 of file EigenExecutionerBase.C.

Referenced by NonlinearEigen::init(), and takeStep().

168 {
169  mooseAssert(max_iter >= min_iter,
170  "Maximum number of power iterations must be greater than or equal to its minimum");
171  mooseAssert(pfactor > 0.0, "Invaid linear convergence tolerance");
172  mooseAssert(tol_eig > 0.0, "Invalid eigenvalue tolerance");
173  mooseAssert(tol_x > 0.0, "Invalid solution norm tolerance");
174 
175  // obtain the solution diff
176  const PostprocessorValue * solution_diff = NULL;
177  if (!xdiff.empty())
178  {
179  solution_diff = &getPostprocessorValueByName(xdiff);
180  const ExecFlagEnum & xdiff_exec = _problem.getUserObject<UserObject>(xdiff).getExecuteOnEnum();
181  if (!xdiff_exec.contains(EXEC_LINEAR))
182  mooseError("Postprocessor " + xdiff + " requires execute_on = 'linear'");
183  }
184 
185  // not perform any iteration when max_iter==0
186  if (max_iter == 0)
187  return true;
188 
189  // turn off nonlinear flag so that RHS kernels opterate on previous solutions
191 
192  // FIXME: currently power iteration use old and older solutions,
193  // so save old and older solutions before they are changed by the power iteration
195  if (_problem.getDisplacedProblem() != NULL)
196  _problem.getDisplacedProblem()->saveOldSolutions();
197 
198  // save solver control parameters to be modified by the power iteration
199  Real tol1 = _problem.es().parameters.get<Real>("linear solver tolerance");
200  unsigned int num1 =
201  _problem.es().parameters.get<unsigned int>("nonlinear solver maximum iterations");
202  Real tol2 = _problem.es().parameters.get<Real>("nonlinear solver relative residual tolerance");
203 
204  // every power iteration is a linear solve, so set nonlinear iteration number to one
205  _problem.es().parameters.set<Real>("linear solver tolerance") = pfactor;
206  // disable nonlinear convergence check
207  _problem.es().parameters.set<unsigned int>("nonlinear solver maximum iterations") = 1;
208  _problem.es().parameters.set<Real>("nonlinear solver relative residual tolerance") = 1 - 1e-8;
209 
210  if (echo)
211  {
212  _console << '\n';
213  _console << " Power iterations starts\n";
214  _console << " ________________________________________________________________________________ "
215  << std::endl;
216  }
217 
218  // some iteration variables
219  Chebyshev_Parameters chebyshev_parameters;
220 
221  std::vector<Real> keff_history;
222  std::vector<Real> diff_history;
223 
224  bool converged;
225 
226  unsigned int iter = 0;
227 
228  // power iteration loop...
229  // Note: |Bx|/k will stay constant one!
230  makeBXConsistent(k);
231  while (true)
232  {
233  if (echo)
234  _console << " Power iteration= " << iter << std::endl;
235 
236  // Important: we do not call _problem.advanceState() because we do not
237  // want to overwrite the old postprocessor values and old material
238  // properties in stateful materials.
241  if (_problem.getDisplacedProblem() != NULL)
242  {
243  _problem.getDisplacedProblem()->nlSys().copyOldSolutions();
244  _problem.getDisplacedProblem()->auxSys().copyOldSolutions();
245  }
246 
247  Real k_old = k;
249 
250  preIteration();
251  _problem.solve();
252  converged = _problem.converged();
253  if (!converged)
254  break;
255  postIteration();
256 
257  // save the initial residual
258  if (iter == 0)
260 
261  // update eigenvalue
263  _eigenvalue = k;
264 
265  if (echo)
266  {
267  // output on screen the convergence history only when we want to and MOOSE output system is
268  // not used
269  keff_history.push_back(k);
270  if (solution_diff)
271  diff_history.push_back(*solution_diff);
272 
273  std::stringstream ss;
274  if (solution_diff)
275  {
276  ss << '\n';
277  ss << " +================+=====================+=====================+\n";
278  ss << " | iteration | eigenvalue | solution_difference |\n";
279  ss << " +================+=====================+=====================+\n";
280  unsigned int j = 0;
281  if (keff_history.size() > 10)
282  {
283  ss << " : : : :\n";
284  j = keff_history.size() - 10;
285  }
286  for (; j < keff_history.size(); j++)
287  ss << " | " << std::setw(14) << j << " | " << std::setw(19) << std::scientific
288  << std::setprecision(8) << keff_history[j] << " | " << std::setw(19) << std::scientific
289  << std::setprecision(8) << diff_history[j] << " |\n";
290  ss << " +================+=====================+=====================+\n" << std::flush;
291  }
292  else
293  {
294  ss << '\n';
295  ss << " +================+=====================+\n";
296  ss << " | iteration | eigenvalue |\n";
297  ss << " +================+=====================+\n";
298  unsigned int j = 0;
299  if (keff_history.size() > 10)
300  {
301  ss << " : : :\n";
302  j = keff_history.size() - 10;
303  }
304  for (; j < keff_history.size(); j++)
305  ss << " | " << std::setw(14) << j << " | " << std::setw(19) << std::scientific
306  << std::setprecision(8) << keff_history[j] << " |\n";
307  ss << " +================+=====================+\n" << std::flush;
308  ss << std::endl;
309  }
310  _console << ss.str();
311  }
312 
313  // increment iteration number here
314  iter++;
315 
316  if (cheb_on)
317  {
318  chebyshev(chebyshev_parameters, iter, solution_diff);
319  if (echo)
320  _console << " Chebyshev step: " << chebyshev_parameters.icheb << std::endl;
321  }
322 
323  if (echo)
324  _console
325  << " ________________________________________________________________________________ "
326  << std::endl;
327 
328  // not perform any convergence check when number of iterations is less than min_iter
329  if (iter >= min_iter)
330  {
331  // no need to check convergence of the last iteration
332  if (iter != max_iter)
333  {
334  Real keff_error = fabs(k_old - k) / k;
335  if (keff_error > tol_eig)
336  converged = false;
337  if (solution_diff)
338  if (*solution_diff > tol_x)
339  converged = false;
340  if (converged)
341  break;
342  }
343  else
344  {
345  converged = false;
346  break;
347  }
348  }
349  }
350 
351  // restore parameters changed by the executioner
352  _problem.es().parameters.set<Real>("linear solver tolerance") = tol1;
353  _problem.es().parameters.set<unsigned int>("nonlinear solver maximum iterations") = num1;
354  _problem.es().parameters.set<Real>("nonlinear solver relative residual tolerance") = tol2;
355 
356  // FIXME: currently power iteration use old and older solutions, so restore them
358  if (_problem.getDisplacedProblem() != NULL)
359  _problem.getDisplacedProblem()->restoreOldSolutions();
360 
361  return converged;
362 }
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:25
T & getUserObject(const std::string &name, unsigned int tid=0) const
Get the user object by its name.
virtual void copyOldSolutions()
Shifts the solutions backwards in time.
Definition: SystemBase.C:986
NonlinearSystemBase & getNonlinearSystemBase()
virtual void makeBXConsistent(Real k)
Normalize solution so that |Bx| = k.
const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName &name)
Retrieve the value of the Postprocessor.
virtual void postIteration()
Override this for actions that should take place after linear solve of each inverse power iteration...
void mooseError(Args &&... args) const
Definition: MooseObject.h:144
virtual EquationSystems & es() override
bool contains(const std::string &value) const
Contains methods for seeing if a value is in the MultiMooseEnum.
virtual bool converged() override
void eigenKernelOnOld()
Ask eigenkernels to operate on old or current solution vectors.
virtual std::shared_ptr< DisplacedProblem > getDisplacedProblem()
Real PostprocessorValue
MOOSE typedefs.
Definition: MooseTypes.h:119
const ExecFlagType EXEC_LINEAR
AuxiliarySystem & getAuxiliarySystem()
void chebyshev(Chebyshev_Parameters &params, unsigned int iter, const PostprocessorValue *solution_diff)
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
virtual void restoreOldSolutions()
Restore old solutions from the backup vectors and deallocate them.
MooseEigenSystem & _eigen_sys
virtual void saveOldSolutions()
Allocate vectors and save old solutions into them.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
virtual void solve() override
Base class for user-specific data.
Definition: UserObject.h:38
virtual void preIteration()
Override this for actions that should take place before linear solve of each inverse power iteration...

◆ isParamValid()

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

Test if the supplied parameter is valid.

Parameters
nameThe name of the parameter to test

Definition at line 86 of file MooseObject.h.

Referenced by AdvancedOutput::AdvancedOutput(), BicubicSplineFunction::BicubicSplineFunction(), Piecewise::buildFromFile(), Piecewise::buildFromXandY(), DistributedGeneratedMesh::buildMesh(), GeneratedMesh::buildMesh(), CartesianMeshGenerator::CartesianMeshGenerator(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), CSVReader::CSVReader(), MultiAppNearestNodeTransfer::execute(), Exodus::Exodus(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), RenameBoundaryGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementSubdomainIDGenerator::generate(), ExtraNodesetGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshSideSetGenerator::generate(), RenameBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainMeshGenerator::generate(), MeshExtruderGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MultiAppNearestNodeTransfer::getLocalEntities(), MeshGenerator::getMesh(), MultiAppNearestNodeTransfer::getNearestNode(), IterationAdaptiveDT::init(), EigenExecutionerBase::init(), MooseMesh::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), SolutionAux::initialSetup(), MooseParsedVectorFunction::initialSetup(), Console::initialSetup(), Receiver::initialSetup(), SolutionFunction::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), AdvancedOutput::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), BreakBoundaryOnSubdomain::modify(), MeshExtruder::modify(), MeshSideSet::modify(), LowerDBlockFromSideset::modify(), AssignElementSubdomainID::modify(), ParsedSubdomainMeshModifier::modify(), RenameBlock::modify(), SubdomainBoundingBox::modify(), MooseMesh::MooseMesh(), EigenExecutionerBase::normalizeSolution(), Output::Output(), PetscOutput::PetscOutput(), Piecewise::Piecewise(), SolutionUserObject::readExodusII(), RenameBlock::RenameBlock(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), SolutionUserObject::SolutionUserObject(), and TimePeriod::TimePeriod().

86 { return _pars.isParamValid(name); }
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseObject.h:171
const std::string & name() const
Get the name of the object.
Definition: MooseObject.h:56
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ lastSolveConverged()

virtual bool InversePowerMethod::lastSolveConverged ( ) const
inlineoverridevirtual

Whether or not the last solve converged.

Implements Executioner.

Definition at line 30 of file InversePowerMethod.h.

Referenced by takeStep().

30 { return _last_solve_converged; }
bool _last_solve_converged
flag to indicate if inverse power iteration converged

◆ makeBXConsistent()

void EigenExecutionerBase::makeBXConsistent ( Real  k)
virtualinherited

Normalize solution so that |Bx| = k.

Definition at line 126 of file EigenExecutionerBase.C.

Referenced by EigenExecutionerBase::init(), EigenExecutionerBase::inversePowerIteration(), and EigenExecutionerBase::nonlinearSolve().

127 {
128  Real consistency_tolerance = 1e-10;
129 
130  // Scale the solution so that the postprocessor is equal to k.
131  // Note: all dependent objects of k must be evaluated on linear!
132  // We have a fix point loop here, in case the postprocessor is a nonlinear function of the scaling
133  // factor.
134  // FIXME: We have assumed this loop always converges.
135  while (std::fabs(k - _source_integral) > consistency_tolerance * std::fabs(k))
136  {
137  // On the first time entering, the _source_integral has been updated properly in
138  // FEProblemBase::initialSetup()
141  std::stringstream ss;
142  ss << std::fixed << std::setprecision(10) << _source_integral;
143  _console << "\n|Bx| = " << ss.str() << std::endl;
144  }
145 }
void scaleSystemSolution(SYSTEMTAG tag, Real scaling_factor)
Scale the solution vector.
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
const ExecFlagType EXEC_LINEAR
MooseEigenSystem & _eigen_sys
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.

◆ mooseDeprecated()

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

◆ mooseError()

template<typename... Args>
void MooseObject::mooseError ( Args &&...  args) const
inlineinherited

Definition at line 144 of file MooseObject.h.

Referenced by PetscExternalPartitioner::_do_partition(), GridPartitioner::_do_partition(), FEProblemBase::addConstraint(), FEProblemBase::addInitialCondition(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), FEProblemBase::addOutput(), DiracKernel::addPointWithValidId(), FEProblemBase::addPostprocessor(), MooseMesh::addQuadratureNode(), FEProblemBase::addVectorPostprocessor(), Output::advancedExecuteOn(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), DerivativeParsedMaterialHelper::assembleDerivatives(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BicubicSplineFunction::BicubicSplineFunction(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BoundsAux::BoundsAux(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), Piecewise::buildFromFile(), Piecewise::buildFromXandY(), Piecewise::buildFromXY(), TiledMesh::buildMesh(), FileMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), DistributedGeneratedMesh::buildMesh(), GeneratedMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildMeshBaseObject(), MooseMesh::buildRefinementMap(), MooseMesh::buildSideList(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), SubProblem::checkBoundaryMatProps(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), Material::checkExecutionStage(), BreakMeshByBlockBase::checkInputParameter(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), ActuallyExplicitEuler::checkLinearConvergence(), FEProblemBase::checkProblemIntegrity(), Material::checkStatefulSanity(), FEProblemBase::checkUserObjects(), LibmeshPartitioner::clone(), MooseMesh::clone(), ComparisonPostprocessor::comparisonIsTrue(), CompositeFunction::CompositeFunction(), ElementLpNormAux::compute(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), KernelBase::computeADOffDiagJacobian(), InterfaceKernel::computeElemNeighJacobian(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), HistogramVectorPostprocessor::computeHistogram(), EqualValueEmbeddedConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), KernelValue::computeQpResidual(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualType(), StatisticsVectorPostprocessor::computeStatValue(), Material::computeSubdomainProperties(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), ActuallyExplicitEuler::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), TimeStepper::constrainStep(), AuxKernel::coupledDot(), AuxKernel::coupledDotDu(), CoupledForce::CoupledForce(), DebugResidualAux::DebugResidualAux(), BicubicSplineFunction::derivative(), DerivativeSumMaterial::DerivativeSumMaterial(), DGKernel::DGKernel(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementQualityAux::ElementQualityAux(), MooseMesh::errorIfDistributedMesh(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppPostprocessorTransfer::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementQualityChecker::execute(), NodalValueSampler::execute(), PointValue::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), TimeExtremeValue::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFit::execute(), LeastSquaresFitHistory::execute(), FEProblemBase::executeControls(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), FileOutput::FileOutput(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), Transfer::find_sys(), BreakMeshByBlockBase::findFreeBoundaryId(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase::FunctionMaterialBase(), ParsedMaterialHelper::functionParse(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), GapValueAux::GapValueAux(), ElementSubdomainIDGenerator::generate(), ExtraNodesetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), GeneratedMeshGenerator::generate(), MeshExtruderGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), SpiralAnnularMeshGenerator::generate(), PatternedMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), RandomICBase::generateRandom(), GenericConstantMaterial::GenericConstantMaterial(), GenericFunctionMaterial::GenericFunctionMaterial(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), MooseMesh::getCoarseningMap(), Control::getControllableParameterByName(), FEProblemBase::getCoordSystem(), PiecewiseConstant::getDirection(), FEProblemBase::getDistribution(), ElementGenerator::getElemType(), MultiApp::getExecutioner(), FEProblemBase::getFunction(), SolutionUserObject::getLocalVarIndex(), AuxKernel::getMaterialProperty(), AuxKernel::getMaterialPropertyOld(), AuxKernel::getMaterialPropertyOlder(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), DistributedGeneratedMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMaxShapeFunctions(), AnnularMesh::getMinInDimension(), DistributedGeneratedMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MooseMesh::getMortarInterface(), MooseMesh::getMortarInterfaceByName(), MooseMesh::getNodeBlockIds(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearSystem(), MooseMesh::getPairedBoundaryMapping(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), MaterialStdVectorAux::getRealValue(), MooseMesh::getRefinementMap(), FEProblemBase::getSampler(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), MooseMesh::getSubdomainBoundaryIds(), MooseMesh::getSubdomainID(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), Residual::getValue(), PerformanceData::getValue(), PerfGraphData::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), AdvancedOutput::hasOutputHelper(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), IterationAdaptiveDT::init(), EigenExecutionerBase::init(), Transient::init(), MooseMesh::init(), FEProblemBase::init(), NumPicardIterations::initialize(), FullSolveMultiApp::initialSetup(), PiecewiseBase::initialSetup(), SolutionAux::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), SolutionFunction::initialSetup(), Exodus::initialSetup(), SolutionUserObject::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Material::initStatefulProperties(), Function::integral(), InterfaceKernel::InterfaceKernel(), InterfaceTimeKernel::InterfaceTimeKernel(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), LayeredSideIntegral::LayeredSideIntegral(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LinearCombinationFunction::LinearCombinationFunction(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MaterialRealTensorValueAux::MaterialRealTensorValueAux(), MaterialRealVectorValueAux::MaterialRealVectorValueAux(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), SubProblem::meshChanged(), MeshExtruder::MeshExtruder(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshSideSetGenerator::MeshSideSetGenerator(), SideSetsFromNormals::modify(), SideSetsFromPoints::modify(), BreakMeshByBlockBase::modify(), AddExtraNodeset::modify(), MeshExtruder::modify(), SmoothMesh::modify(), AssignElementSubdomainID::modify(), AddAllSideSetsByNormals::modify(), ElementDeleterBase::modify(), ParsedSubdomainMeshModifier::modify(), RenameBlock::modify(), ImageSubdomain::modify(), OrientedSubdomainBoundingBox::modify(), BoundingBoxNodeSet::modify(), AddSideSetsFromBoundingBox::modify(), SubdomainBoundingBox::modify(), MooseMesh::MooseMesh(), MultiAppMeshFunctionTransfer::MultiAppMeshFunctionTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), NearestNodeValueAux::NearestNodeValueAux(), RenameBlockGenerator::newBlockID(), RenameBlock::newBlockID(), RenameBlockGenerator::newBlockName(), RenameBlock::newBlockName(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), NodalScalarKernel::NodalScalarKernel(), NodalVariableValue::NodalVariableValue(), NumDOFs::NumDOFs(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), ElementSideNeighborLayers::operator()(), ElementPointNeighbors::operator()(), RelationshipManager::operator==(), XDA::output(), SolutionHistory::output(), Exodus::output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), MooseObject::paramError(), PiecewiseBilinear::parse(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PetscExternalPartitioner::PetscExternalPartitioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), Piecewise::Piecewise(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), SolutionUserObject::pointValueGradientWrapper(), SolutionUserObject::pointValueWrapper(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), LStableDirk4::postResidual(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), Predictor::Predictor(), SolutionUserObject::readExodusII(), SolutionUserObject::readXda(), EqualValueEmbeddedConstraint::reinitConstraint(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), RenameBlock::RenameBlock(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), ScalarComponentIC::ScalarComponentIC(), BicubicSplineFunction::secondDerivative(), FEProblemBase::setCoordSystem(), PiecewiseBase::setData(), EigenProblem::setEigenproblemType(), Sampler::setNumberOfRequiedRandomSeeds(), Exodus::setOutputDimensionInExodusWriter(), Split::setup(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideSetsFromNormals::SideSetsFromNormals(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPoints::SideSetsFromPoints(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObject::SolutionUserObject(), PicardSolve::solve(), ActuallyExplicitEuler::solve(), FullSolveMultiApp::solveStep(), UserObject::spatialValue(), SphericalAverage::SphericalAverage(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), StitchedMesh::StitchedMesh(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), Constraint::subdomainSetup(), Console::systemInfoFlags(), Terminator::Terminator(), TestSetupPostprocessorDataActionFunction::TestSetupPostprocessorDataActionFunction(), ThreadedGeneralUserObject::ThreadedGeneralUserObject(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), TiledMeshGenerator::TiledMeshGenerator(), Function::timeDerivative(), TimeExtremeValue::TimeExtremeValue(), TimePeriod::TimePeriod(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppCopyTransfer::transfer(), MultiAppMeshFunctionTransfer::transferVariable(), FEProblemBase::uDotDotOldRequested(), FEProblemBase::uDotOldRequested(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObject::updateExodusBracketingTimeIndices(), Axisymmetric2D3DSolutionFunction::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), VectorNodalBC::VectorNodalBC(), VectorOfPostprocessors::VectorOfPostprocessors(), VectorPostprocessorFunction::VectorPostprocessorFunction(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), VolumeHistogram::VolumeHistogram(), VTKOutput::VTKOutput(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

144  {
145  std::ostringstream oss;
146  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
147  std::string msg = oss.str();
148  callMooseErrorRaw(msg, &_app);
149  }
void mooseStreamAll(std::ostringstream &ss)
All of the following are not meant to be called directly - they are called by the normal macros (moos...
Definition: MooseError.C:87
void callMooseErrorRaw(std::string &msg, MooseApp *app)
Definition: MooseObject.C:57
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:174

◆ mooseInfo()

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

◆ mooseWarning()

template<typename... Args>
void MooseObject::mooseWarning ( Args &&...  args) const
inlineinherited

◆ name()

const std::string& MooseObject::name ( ) const
inlineinherited

Get the name of the object.

Returns
The name of the object

Definition at line 56 of file MooseObject.h.

Referenced by GridPartitioner::_do_partition(), FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADResidualMaterial(), Executioner::addAttributeReporter(), DumpObjectsProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarKernel(), DumpObjectsProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), DumpObjectsProblem::addDGKernel(), FEProblemBase::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addIndicator(), DumpObjectsProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), FEProblemBase::addInterfaceKernel(), DumpObjectsProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addMarker(), DumpObjectsProblem::addMaterial(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), MooseMesh::addMortarInterface(), FEProblemBase::addMultiApp(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVectorPostprocessor(), Output::advancedExecuteOn(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), DerivativeParsedMaterialHelper::assembleDerivatives(), AStableDirk4::AStableDirk4(), Function::average(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), FEProblemBase::checkDependMaterialsHelper(), Damper::checkMinDamping(), Material::checkStatefulSanity(), CompositeFunction::CompositeFunction(), Material::computeSubdomainProperties(), VectorPostprocessorVisualizationAux::computeValue(), AuxKernel::coupledCallback(), AuxKernel::coupledDot(), AuxKernel::coupledDotDu(), MultiApp::createApp(), FEProblemBase::declareVectorPostprocessorVector(), DOFMapOutput::demangle(), DerivativeSumMaterial::DerivativeSumMaterial(), DGKernel::DGKernel(), DumpObjectsProblem::dumpObjectHelper(), ElementValueSampler::ElementValueSampler(), MooseMesh::errorIfDistributedMesh(), AB2PredictorCorrector::estimateTimeError(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), StatisticsVectorPostprocessor::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), PointValue::execute(), MultiAppInterpolationTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), HistogramVectorPostprocessor::execute(), MultiAppCopyTransfer::execute(), Exodus::Exodus(), FileOutput::FileOutput(), MultiApp::fillPositions(), PointSamplerBase::finalize(), DerivativeParsedMaterialHelper::findMatPropDerivative(), FunctionDT::FunctionDT(), GeneralUserObject::GeneralUserObject(), LowerDBlockFromSidesetGenerator::generate(), StitchedMeshGenerator::generate(), Material::getADMaterialProperty(), MultiApp::getBoundingBox(), MooseObject::getCheckedPointerParam(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), MultiApp::getExecutioner(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SolutionUserObject::getLocalVarIndex(), Marker::getMarkerValue(), FEProblemBase::getMaterial(), NodalPatchRecovery::getMaterialProperty(), AuxKernel::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), AuxKernel::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), AuxKernel::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MeshGenerator::getMesh(), MooseMesh::getMortarInterfaceByName(), OutputWarehouse::getOutput(), MooseObject::getParam(), GeneralUserObject::getPostprocessorValue(), AuxKernel::getPostprocessorValue(), FEProblemBase::getPostprocessorValue(), GeneralUserObject::getPostprocessorValueByName(), AuxKernel::getPostprocessorValueByName(), FEProblemBase::getPostprocessorValueOld(), FEProblemBase::getPostprocessorValueOlder(), FEProblemBase::getSampler(), AuxKernel::getScatterVectorPostprocessorValue(), FEProblemBase::getScatterVectorPostprocessorValue(), AuxKernel::getScatterVectorPostprocessorValueByName(), FEProblemBase::getScatterVectorPostprocessorValueOld(), Transient::getTimeStepperName(), AuxKernel::getUserObject(), InitialConditionBase::getUserObject(), FEProblemBase::getUserObject(), InitialConditionBase::getUserObjectBase(), AuxKernel::getUserObjectBase(), FEProblemBase::getUserObjectBase(), AuxKernel::getUserObjectByName(), InitialConditionBase::getUserObjectByName(), GeneralUserObject::getVectorPostprocessorValue(), AuxKernel::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValue(), GeneralUserObject::getVectorPostprocessorValueByName(), AuxKernel::getVectorPostprocessorValueByName(), FEProblemBase::getVectorPostprocessorValueOld(), FEProblemBase::hasFunction(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasUserObject(), FEProblemBase::hasVectorPostprocessor(), FEProblemBase::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), CSVReader::initialize(), StatisticsVectorPostprocessor::initialize(), HistogramVectorPostprocessor::initialize(), MultiAppProjectionTransfer::initialSetup(), DerivativeFunctionMaterialBase::initialSetup(), SolutionUserObject::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPostprocessorData(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), Material::initStatefulProperties(), FEProblemBase::initVectorPostprocessorData(), Function::integral(), InterfaceKernel::InterfaceKernel(), MooseObject::isParamValid(), LinearCombinationFunction::LinearCombinationFunction(), Marker::Marker(), MatDiffusionBase< Real >::MatDiffusionBase(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshSideSetGenerator::MeshSideSetGenerator(), ElementDeleterBase::modify(), MooseVariableInterface< Real >::MooseVariableInterface(), NearestPointBase< LayeredAverage >::NearestPointBase(), NodalValueSampler::NodalValueSampler(), NodalVariableValue::NodalVariableValue(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), ConsoleUtils::outputOutputInformation(), Nemesis::outputPostprocessors(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PointSamplerBase::PointSamplerBase(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), Material::resetQpProperties(), Sampler::Sampler(), ScalarComponentIC::ScalarComponentIC(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), MooseMesh::setSubdomainName(), Split::setup(), TransientMultiApp::setupApp(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SideValueSampler::SideValueSampler(), TransientMultiApp::solveStep(), UserObject::spatialValue(), SphericalAverage::SphericalAverage(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), SubProblem::storeSubdomainZeroMatProp(), TaggingInterface::TaggingInterface(), ThreadedGeneralUserObject::ThreadedGeneralUserObject(), Function::timeDerivative(), VectorPostprocessorVisualizationAux::timestepSetup(), TransientMultiApp::TransientMultiApp(), MultiAppTransfer::variableIntegrityCheck(), and AdvancedOutput::wantOutput().

56 { return _name; }
const std::string & _name
The name of this object, reference to value stored in InputParameters.
Definition: MooseObject.h:180

◆ nonlinearSolve()

bool EigenExecutionerBase::nonlinearSolve ( Real  rel_tol,
Real  abs_tol,
Real  pfactor,
Real &  k 
)
virtualinherited

Perform nonlinear solve with the initial guess of the solution.

Parameters
rel_tolRelative tolerance on system residual.
abs_tolAbsolute tolerance on system residual.
pfactorThe factor on reducing the residual norm of each linear iteration.
kEigenvalue, input as the initial guess.
Returns
true solve converges, otherwise false.

Definition at line 562 of file EigenExecutionerBase.C.

Referenced by NonlinearEigen::takeStep().

563 {
564  makeBXConsistent(k);
565 
566  // turn on nonlinear flag so that eigen kernels opterate on the current solutions
568 
569  // set nonlinear solver controls
570  Real tol1 = _problem.es().parameters.get<Real>("nonlinear solver absolute residual tolerance");
571  Real tol2 = _problem.es().parameters.get<Real>("linear solver tolerance");
572  Real tol3 = _problem.es().parameters.get<Real>("nonlinear solver relative residual tolerance");
573 
574  _problem.es().parameters.set<Real>("nonlinear solver absolute residual tolerance") = abs_tol;
575  _problem.es().parameters.set<Real>("nonlinear solver relative residual tolerance") = rel_tol;
576  _problem.es().parameters.set<Real>("linear solver tolerance") = pfactor;
577 
578  // call nonlinear solve
579  _problem.solve();
580 
581  k = _source_integral;
582  _eigenvalue = k;
583 
584  _problem.es().parameters.set<Real>("nonlinear solver absolute residual tolerance") = tol1;
585  _problem.es().parameters.set<Real>("linear solver tolerance") = tol2;
586  _problem.es().parameters.set<Real>("nonlinear solver relative residual tolerance") = tol3;
587 
588  return _problem.converged();
589 }
virtual void makeBXConsistent(Real k)
Normalize solution so that |Bx| = k.
virtual EquationSystems & es() override
virtual bool converged() override
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
MooseEigenSystem & _eigen_sys
virtual void solve() override

◆ normalizeSolution()

Real EigenExecutionerBase::normalizeSolution ( bool  force = true)
virtualinherited

Normalize the solution vector based on the postprocessor value for normalization.

Parameters
forceForce the re-evaluation of the postprocessor for normalization. Returns the scaling factor just applied.

Definition at line 417 of file EigenExecutionerBase.C.

Referenced by EigenExecutionerBase::postExecute().

418 {
419  if (force)
421 
422  Real factor;
423  if (isParamValid("normal_factor"))
424  factor = getParam<Real>("normal_factor");
425  else
426  factor = _eigenvalue;
427  Real scaling = factor / _normalization;
428 
429  if (!MooseUtils::absoluteFuzzyEqual(scaling, 1.0))
430  {
431  // FIXME: we assume linear scaling here!
433  // update all aux variables and user objects
434 
435  for (const ExecFlagType & flag : _app.getExecuteOnEnum().items())
436  _problem.execute(flag);
437  }
438  return scaling;
439 }
void scaleSystemSolution(SYSTEMTAG tag, Real scaling_factor)
Scale the solution vector.
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:231
const ExecFlagEnum & getExecuteOnEnum() const
Return the app level ExecFlagEnum, this contains all the available flags for the app.
Definition: MooseApp.h:651
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
const std::set< ExecFlagType > & items() const
Reference the all the available items.
Definition: ExecFlagEnum.h:74
const Real & _normalization
Postprocessor for normalization.
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
Class for containing MooseEnum item information.
Definition: MooseEnumItem.h:22
MooseEigenSystem & _eigen_sys
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:174
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseObject.h:86
const ExecFlagType EXEC_INITIAL

◆ paramError()

template<typename... Args>
void MooseObject::paramError ( const std::string &  param,
Args...  args 
)
inlineinherited

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 105 of file MooseObject.h.

Referenced by ADIntegratedBCTempl< T, compute_stage >::ADIntegratedBCTempl(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), DGKernel::DGKernel(), ElementValueSampler::ElementValueSampler(), StackGenerator::generate(), StitchedMeshGenerator::generate(), MultiApp::init(), IntegratedBC::IntegratedBC(), Kernel::Kernel(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalValueSampler::NodalValueSampler(), RandomIC::RandomIC(), MultiAppCopyTransfer::transfer(), and TransientMultiApp::TransientMultiApp().

105  {
106  auto prefix = param + ": ";
107  if (!_pars.inputLocation(param).empty())
108  prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
109  mooseError(prefix, args...);
110  }
void mooseError(Args &&... args) const
Definition: MooseObject.h:144
const std::string & inputLocation(const std::string &param) const
Get/set a string representing the location in the input text the parameter originated from (i...
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseObject.h:171
const std::string & paramFullpath(const std::string &param) const
Get/set a string representing the full HIT parameter path from the input file (e.g.

◆ parameters()

const InputParameters& MooseObject::parameters ( ) const
inlineinherited

Get the parameters of the object.

Returns
The parameters of the object

Definition at line 62 of file MooseObject.h.

Referenced by FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADResidualMaterial(), DumpObjectsProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarKernel(), DumpObjectsProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), DumpObjectsProblem::addDGKernel(), FEProblemBase::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addIndicator(), DumpObjectsProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), FEProblemBase::addInterfaceKernel(), DumpObjectsProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), DumpObjectsProblem::addMaterial(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVectorPostprocessor(), AdvancedOutput::AdvancedOutput(), assemble_l2(), Moose::assemble_matrix(), AuxKernel::AuxKernel(), AuxScalarKernel::AuxScalarKernel(), BoundsAux::BoundsAux(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), Console::Console(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Executioner::Executioner(), Exodus::Exodus(), FEProblem::FEProblem(), GapValueAux::GapValueAux(), MooseObject::getCheckedPointerParam(), MooseMesh::init(), BlockRestrictable::initializeBlockRestrictable(), FEProblemBase::initNullSpaceVectors(), InterfaceKernel::InterfaceKernel(), isValid(), LayeredSideIntegral::LayeredSideIntegral(), MooseVariableInterface< Real >::MooseVariableInterface(), NearestPointBase< LayeredAverage >::NearestPointBase(), NodeFaceConstraint::NodeFaceConstraint(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), MultiAppProjectionTransfer::projectSolution(), RandomIC::RandomIC(), InputParameterWarehouse::removeInputParameters(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), DumpObjectsProblem::stringifyParameters(), and Transient::Transient().

62 { return _pars; }
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseObject.h:171

◆ paramInfo()

template<typename... Args>
void MooseObject::paramInfo ( const std::string &  param,
Args...  args 
)
inlineinherited

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 135 of file MooseObject.h.

Referenced by TransientMultiApp::TransientMultiApp().

136  {
137  auto prefix = param + ": ";
138  if (!_pars.inputLocation(param).empty())
139  prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
140  mooseInfo(prefix, args...);
141  }
const std::string & inputLocation(const std::string &param) const
Get/set a string representing the location in the input text the parameter originated from (i...
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseObject.h:171
void mooseInfo(Args &&... args) const
Definition: MooseObject.h:164
const std::string & paramFullpath(const std::string &param) const
Get/set a string representing the full HIT parameter path from the input file (e.g.

◆ paramWarning()

template<typename... Args>
void MooseObject::paramWarning ( const std::string &  param,
Args...  args 
)
inlineinherited

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 119 of file MooseObject.h.

120  {
121  auto prefix = param + ": ";
122  if (!_pars.inputLocation(param).empty())
123  prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
124  mooseWarning(prefix, args...);
125  }
void mooseWarning(Args &&... args) const
Definition: MooseObject.h:152
const std::string & inputLocation(const std::string &param) const
Get/set a string representing the location in the input text the parameter originated from (i...
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
Definition: MooseObject.h:171
const std::string & paramFullpath(const std::string &param) const
Get/set a string representing the full HIT parameter path from the input file (e.g.

◆ parentOutputPositionChanged()

virtual void Executioner::parentOutputPositionChanged ( )
inlinevirtualinherited

Can be used by subsclasses to call parentOutputPositionChanged() on the underlying FEProblemBase.

Reimplemented in Transient.

Definition at line 106 of file Executioner.h.

106 {}

◆ picardSolve()

PicardSolve& Executioner::picardSolve ( )
inlineinherited

Return underlining PicardSolve object.

Definition at line 114 of file Executioner.h.

Referenced by NumPicardIterations::getValue(), and TimeStepper::step().

114 { return _picard_solve; }
PicardSolve _picard_solve
Definition: Executioner.h:132

◆ postExecute()

void EigenExecutionerBase::postExecute ( )
overridevirtualinherited

Override this for actions that should take place after the main solve.

Reimplemented from Executioner.

Definition at line 375 of file EigenExecutionerBase.C.

Referenced by execute(), and NonlinearEigen::execute().

376 {
377  if (getParam<bool>("output_before_normalization"))
378  {
379  _problem.timeStep()++;
380  Real t = _problem.time();
383  _problem.time() = t;
384  }
385 
386  Real s = 1.0;
388  {
389  _console << " Cannot let the normalization postprocessor on custom.\n";
390  _console << " Normalization is abandoned!" << std::endl;
391  }
392  else
393  {
395  s = normalizeSolution(force);
396  if (!MooseUtils::absoluteFuzzyEqual(s, 1.0))
397  _console << " Solution is rescaled with factor " << s << " for normalization!" << std::endl;
398  }
399 
400  if ((!getParam<bool>("output_before_normalization")) || !MooseUtils::absoluteFuzzyEqual(s, 1.0))
401  {
402  _problem.timeStep()++;
403  Real t = _problem.time();
406  _problem.time() = t;
407  }
408 
409  {
410  TIME_SECTION(_final_timer)
413  }
414 }
virtual Real & time() const
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:231
const ExecFlagType EXEC_CUSTOM
const ExecFlagType EXEC_TIMESTEP_END
bool contains(const std::string &value) const
Contains methods for seeing if a value is in the MultiMooseEnum.
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
const ExecFlagType EXEC_LINEAR
virtual int & timeStep() const
virtual Real normalizeSolution(bool force=true)
Normalize the solution vector based on the postprocessor value for normalization. ...
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
const ExecFlagType EXEC_FINAL
virtual void outputStep(ExecFlagType type)
Output the current step.

◆ postIteration()

void EigenExecutionerBase::postIteration ( )
virtualinherited

Override this for actions that should take place after linear solve of each inverse power iteration.

Definition at line 370 of file EigenExecutionerBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

371 {
372 }

◆ postSolve()

void Executioner::postSolve ( )
virtualinherited

Override this for actions that should take place after execution.

Definition at line 231 of file Executioner.C.

Referenced by PicardSolve::solveStep(), NonlinearEigen::takeStep(), and takeStep().

232 {
233 }

◆ preExecute()

void Executioner::preExecute ( )
virtualinherited

Override this for actions that should take place before execution.

Reimplemented in Transient.

Definition at line 216 of file Executioner.C.

Referenced by execute(), NonlinearEigen::execute(), and Steady::execute().

217 {
218 }

◆ preIteration()

void EigenExecutionerBase::preIteration ( )
virtualinherited

Override this for actions that should take place before linear solve of each inverse power iteration.

Definition at line 365 of file EigenExecutionerBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

366 {
367 }

◆ preSolve()

void Executioner::preSolve ( )
virtualinherited

Override this for actions that should take place before execution.

Definition at line 226 of file Executioner.C.

Referenced by PicardSolve::solveStep(), NonlinearEigen::takeStep(), and takeStep().

227 {
228 }

◆ printEigenvalue()

void EigenExecutionerBase::printEigenvalue ( )
protectedvirtualinherited

Print eigenvalue.

Definition at line 442 of file EigenExecutionerBase.C.

Referenced by takeStep(), and NonlinearEigen::takeStep().

443 {
444  std::ostringstream ss;
445  ss << '\n';
446  ss << "*******************************************************\n";
447  ss << " Eigenvalue = " << std::fixed << std::setprecision(10) << _eigenvalue << '\n';
448  ss << "*******************************************************";
449 
450  _console << ss.str() << std::endl;
451 }
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.

◆ problem()

Problem & Executioner::problem ( )
virtualinherited

Deprecated: Return a reference to this Executioner's Problem instance.

Definition at line 236 of file Executioner.C.

Referenced by Executioner::addAttributeReporter().

237 {
238  mooseDoOnce(mooseWarning("This method is deprecated, use feProblem() instead"));
239  return _fe_problem;
240 }
void mooseWarning(Args &&... args) const
Definition: MooseObject.h:152
FEProblemBase & _fe_problem
Definition: Executioner.h:130

◆ registerTimedSection()

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

Call to register a named section for timing.

Parameters
section_nameThe name of the code section to be timed
levelThe 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 50 of file PerfGraphInterface.C.

51 {
52  if (_prefix != "")
53  return _perf_graph.registerSection(_prefix + "::" + section_name, level);
54  else
55  return _perf_graph.registerSection(section_name, level);
56 }
PerfGraph & _perf_graph
The performance graph to add to.
std::string _prefix
A prefix to use for all sections.
PerfID registerSection(const std::string &section_name, unsigned int level)
Registers a named section of code.
Definition: PerfGraph.C:42

◆ takeStep()

void InversePowerMethod::takeStep ( )
protectedvirtual

Definition at line 92 of file InversePowerMethod.C.

Referenced by execute().

93 {
94  // save the initial guess and mark a new time step
96 
97  preSolve();
98  Real initial_res;
100  _max_iter,
101  _pfactor,
102  _cheb_on,
104  true,
107  _eigenvalue,
108  initial_res);
109  postSolve();
110 
111  if (lastSolveConverged())
112  {
113  printEigenvalue();
116  }
117 }
const unsigned int & _min_iter
minimum number of power iterations
const Real & _pfactor
tolerance on each power iteration (always one nonlinear iteration)
virtual void onTimestepEnd() override
const ExecFlagType EXEC_TIMESTEP_END
virtual void advanceState()
Advance all of the state holding vectors / datastructures so that we can move to the next timestep...
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
const bool & _cheb_on
indicating if Chebyshev acceleration is turned on
const unsigned int & _max_iter
maximum number of power iterations
const PostprocessorName & _solution_diff_name
name of the postprocessor for evaluating |x-xprevious|; empty means that no postprocessor is provided...
const Real & _sol_check_tol
convergence tolerance on solution difference
bool _last_solve_converged
flag to indicate if inverse power iteration converged
virtual void preSolve()
Override this for actions that should take place before execution.
Definition: Executioner.C:226
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
virtual void printEigenvalue()
Print eigenvalue.
virtual bool lastSolveConverged() const override
Whether or not the last solve converged.
virtual void postSolve()
Override this for actions that should take place after execution.
Definition: Executioner.C:231
const Real & _eig_check_tol
convergence tolerance on eigenvalue
virtual bool inversePowerIteration(unsigned int min_iter, unsigned int max_iter, Real pfactor, bool cheb_on, Real tol_eig, bool echo, PostprocessorName xdiff, Real tol_x, Real &k, Real &initial_res)
Perform inverse power iterations with the initial guess of the solution.

◆ type()

const std::string& MooseObject::type ( ) const
inlineinherited

Get the type of this object.

Returns
the name of the type of this object

Definition at line 50 of file MooseObject.h.

Referenced by DumpObjectsProblem::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), DumpObjectsProblem::addAuxVariable(), DisplacedProblem::addAuxVariable(), FEProblemBase::addAuxVariable(), DumpObjectsProblem::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), DumpObjectsProblem::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), DumpObjectsProblem::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), DumpObjectsProblem::addKernel(), DumpObjectsProblem::addMaterial(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarVariable(), PhysicsBasedPreconditioner::addSystem(), FEProblemBase::addTimeIntegrator(), DumpObjectsProblem::addVariable(), DisplacedProblem::addVariable(), FEProblemBase::addVariable(), FEProblemBase::advanceMultiApps(), FEProblemBase::backupMultiApps(), MooseMesh::buildRefinementAndCoarseningMaps(), FEProblemBase::computeAuxiliaryKernels(), ElemElemConstraint::computeElemNeighJacobian(), InterfaceKernel::computeElemNeighJacobian(), DGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighResidual(), InterfaceKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), FEProblemBase::computeMultiAppsDT(), InterfaceKernel::computeOffDiagElemNeighJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), DGConvection::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), DGDiffusion::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), DGConvection::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), DGDiffusion::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), EqualValueEmbeddedConstraint::computeQpResidual(), FEProblemBase::computeUserObjects(), DisplacedProblem::createQRules(), FEProblemBase::createQRules(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), FEProblemBase::finishMultiAppStep(), ElementSubdomainIDGenerator::generate(), ElementGenerator::getElemType(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getTransfers(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), AdvancedOutput::initAvailableLists(), SolutionUserObject::initialSetup(), AdvancedOutput::initShowHideLists(), AssignElementSubdomainID::modify(), ControlOutput::output(), Gnuplot::output(), CSV::output(), Exodus::output(), Console::output(), Nemesis::output(), AdvancedOutput::output(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), FEProblemBase::restoreMultiApps(), FEProblemBase::setCoupling(), PerfGraphOutput::shouldOutput(), FileOutput::shouldOutput(), Output::shouldOutput(), AdvancedOutput::shouldOutput(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), and AdvancedOutput::wantOutput().

50 { return _type; }
const std::string & _type
The type of this object (the Class name)
Definition: MooseObject.h:177

Member Data Documentation

◆ _app

MooseApp& MooseObject::_app
protectedinherited

The MooseApp this object is associated with.

Definition at line 174 of file MooseObject.h.

Referenced by GridPartitioner::_do_partition(), AB2PredictorCorrector::AB2PredictorCorrector(), Executioner::addAttributeReporter(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addOutput(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), AlgebraicRelationshipManager::attachAlgebraicFunctorHelper(), RelationshipManager::attachRelationshipManagers(), ElementSideNeighborLayers::attachRelationshipManagersInternal(), ElementPointNeighbors::attachRelationshipManagersInternal(), FileMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), MooseMesh::buildMeshBaseObject(), FEProblemBase::checkNonlinearConvergence(), OversampleOutput::cloneMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), MultiApp::createApp(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), NonlinearEigen::execute(), execute(), Transient::execute(), Steady::execute(), FileOutput::FileOutput(), FEProblemBase::forceOutput(), MeshGenerator::getMesh(), MeshGenerator::getMeshByName(), MooseObject::getMooseApp(), init(), NonlinearEigen::init(), Transient::init(), Steady::init(), MooseMesh::init(), NumPicardIterations::initialize(), TimePeriod::initialSetup(), Console::initialSetup(), MultiApp::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutput(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), InversePowerMethod(), MooseObject::mooseError(), NonlinearEigen::NonlinearEigen(), EigenExecutionerBase::normalizeSolution(), PerfGraphOutput::output(), Tecplot::output(), Exodus::output(), Nemesis::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), MultiApp::parentOutputPositionChanged(), PerformanceData::PerformanceData(), PetscOutput::petscLinearOutput(), PetscOutput::petscNonlinearOutput(), FEProblemBase::projectSolution(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimePeriod::TimePeriod(), FEProblemBase::timestepSetup(), Transient::Transient(), and Console::write().

◆ _cheb_on

const bool& InversePowerMethod::_cheb_on
protected

indicating if Chebyshev acceleration is turned on

Definition at line 50 of file InversePowerMethod.h.

Referenced by takeStep().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console
inherited

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

Definition at line 32 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), SetupRecoverFileBaseAction::act(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), SimplePredictor::apply(), FEProblemBase::backupMultiApps(), FEProblemBase::checkProblemIntegrity(), IterationAdaptiveDT::computeAdaptiveDT(), Transient::computeConstrainedDT(), NonlinearSystemBase::computeDamping(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeResidualTags(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppCopyTransfer::execute(), Steady::execute(), MultiAppDTKUserObjectTransfer::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), FEProblemBase::FEProblemBase(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MultiApp::globalAppToLocal(), init(), NonlinearEigen::init(), Steady::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), Transient::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseObject::mooseDeprecated(), MooseObject::mooseInfo(), MooseObject::mooseWarning(), PerfGraphOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), EigenExecutionerBase::printEigenvalue(), MaterialPropertyDebugOutput::printMaterialMap(), SolutionTimeAdaptiveDT::rejectStep(), DT2::rejectStep(), FEProblemBase::restoreMultiApps(), SimplePredictor::shouldApply(), NonlinearSystem::solve(), PicardSolve::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), PicardSolve::solveStep(), DT2::step(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

◆ _eig_check_tol

const Real& InversePowerMethod::_eig_check_tol
protected

convergence tolerance on eigenvalue

Definition at line 44 of file InversePowerMethod.h.

Referenced by InversePowerMethod(), and takeStep().

◆ _eigen_sys

MooseEigenSystem& EigenExecutionerBase::_eigen_sys
protectedinherited

◆ _eigenvalue

Real& EigenExecutionerBase::_eigenvalue
protectedinherited

◆ _enabled

const bool& MooseObject::_enabled
protectedinherited

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

Definition at line 183 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _fe_problem

FEProblemBase& Executioner::_fe_problem
protectedinherited

◆ _final_timer

PerfID EigenExecutionerBase::_final_timer
protectedinherited

Definition at line 144 of file EigenExecutionerBase.h.

Referenced by EigenExecutionerBase::postExecute().

◆ _initial_residual_norm

Real Executioner::_initial_residual_norm
protectedinherited

Initial Residual Variables.

Definition at line 135 of file Executioner.h.

◆ _last_solve_converged

bool InversePowerMethod::_last_solve_converged
protected

flag to indicate if inverse power iteration converged

Definition at line 52 of file InversePowerMethod.h.

Referenced by lastSolveConverged(), and takeStep().

◆ _max_iter

const unsigned int& InversePowerMethod::_max_iter
protected

maximum number of power iterations

Definition at line 42 of file InversePowerMethod.h.

Referenced by InversePowerMethod(), and takeStep().

◆ _min_iter

const unsigned int& InversePowerMethod::_min_iter
protected

minimum number of power iterations

Definition at line 40 of file InversePowerMethod.h.

Referenced by InversePowerMethod(), and takeStep().

◆ _name

const std::string& MooseObject::_name
protectedinherited

◆ _norm_exec

ExecFlagEnum EigenExecutionerBase::_norm_exec
protectedinherited

◆ _normalization

const Real& EigenExecutionerBase::_normalization
protectedinherited

Postprocessor for normalization.

Definition at line 141 of file EigenExecutionerBase.h.

Referenced by EigenExecutionerBase::normalizeSolution().

◆ _old_initial_residual_norm

Real Executioner::_old_initial_residual_norm
protectedinherited

Definition at line 136 of file Executioner.h.

◆ _pars

const InputParameters& MooseObject::_pars
protectedinherited

◆ _perf_graph

PerfGraph& PerfGraphInterface::_perf_graph
protectedinherited

The performance graph to add to.

Definition at line 66 of file PerfGraphInterface.h.

Referenced by PerfGraphData::getValue(), and PerfGraphInterface::registerTimedSection().

◆ _pfactor

const Real& InversePowerMethod::_pfactor
protected

tolerance on each power iteration (always one nonlinear iteration)

Definition at line 48 of file InversePowerMethod.h.

Referenced by InversePowerMethod(), and takeStep().

◆ _pg_params

const InputParameters* PerfGraphInterface::_pg_params
protectedinherited

Params.

Definition at line 63 of file PerfGraphInterface.h.

◆ _picard_solve

PicardSolve Executioner::_picard_solve
protectedinherited

◆ _prefix

std::string PerfGraphInterface::_prefix
protectedinherited

A prefix to use for all sections.

Definition at line 69 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::registerTimedSection().

◆ _problem

FEProblemBase& EigenExecutionerBase::_problem
protectedinherited

◆ _restart_file_base

std::string Executioner::_restart_file_base
protectedinherited

Definition at line 139 of file Executioner.h.

Referenced by Steady::Steady(), and Transient::Transient().

◆ _sol_check_tol

const Real& InversePowerMethod::_sol_check_tol
protected

convergence tolerance on solution difference

Definition at line 46 of file InversePowerMethod.h.

Referenced by takeStep().

◆ _solution_diff

const PostprocessorValue* InversePowerMethod::_solution_diff
protected

postprocessor for evaluating |x-xprevious|

Definition at line 38 of file InversePowerMethod.h.

◆ _solution_diff_name

const PostprocessorName& InversePowerMethod::_solution_diff_name
protected

name of the postprocessor for evaluating |x-xprevious|; empty means that no postprocessor is provided and power iteration will not check convergence based on it

Definition at line 36 of file InversePowerMethod.h.

Referenced by takeStep().

◆ _source_integral

const Real& EigenExecutionerBase::_source_integral
protectedinherited

◆ _source_integral_old

Real EigenExecutionerBase::_source_integral_old
protectedinherited

◆ _splitting

std::vector<std::string> Executioner::_splitting
protectedinherited

Definition at line 142 of file Executioner.h.

Referenced by Steady::Steady(), and Transient::Transient().

◆ _type

const std::string& MooseObject::_type
protectedinherited

The type of this object (the Class name)

Definition at line 177 of file MooseObject.h.

Referenced by FEProblemBase::init(), and MooseObject::type().


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