www.mooseframework.org
Classes | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | List of all members
EigenExecutionerBase Class Referenceabstract

This class provides reusable routines for eigenvalue executioners. More...

#include <EigenExecutionerBase.h>

Inheritance diagram for EigenExecutionerBase:
[legend]

Classes

class  Chebyshev_Parameters
 

Public Member Functions

 EigenExecutionerBase (const InputParameters &parameters)
 Constructor. More...
 
virtual void init () override
 Initialize the executioner. 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 void 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 void 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 execute ()=0
 Pure virtual execute function MUST be overridden by children classes. 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...
 
virtual bool lastSolveConverged ()
 Whether or not the last solve converged. 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 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

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

This class provides reusable routines for eigenvalue executioners.

Definition at line 26 of file EigenExecutionerBase.h.

Constructor & Destructor Documentation

◆ EigenExecutionerBase()

EigenExecutionerBase::EigenExecutionerBase ( const InputParameters parameters)

Constructor.

Parameters
parametersThe parameters object holding data for the class to use.
Returns
Whether or not the solve was successful.

Definition at line 50 of file EigenExecutionerBase.C.

53  _eigen_sys(static_cast<MooseEigenSystem &>(_problem.getNonlinearSystemBase())),
54  _eigenvalue(declareRestartableData("eigenvalue", 1.0)),
57  _normalization(isParamValid("normalization")
58  ? getPostprocessorValue("normalization")
59  : getPostprocessorValue("bx_norm")), // use |Bx| for normalization by default
61 {
62  // FIXME: currently we have to use old and older solution vectors for power iteration.
63  // We will need 'step' in the future.
64  _problem.transient(true);
65 
66  // we want to tell the App about what our system time is (in case anyone else is interested).
67  Real system_time = getParam<Real>("time");
68  _app.setStartTime(system_time);
69 
70  // set the system time
71  _problem.time() = system_time;
72  _problem.timeOld() = system_time;
73 
74  // used for controlling screen print-out
75  _problem.timeStep() = 0;
76  _problem.dt() = 1.0;
77 }
PerfID registerTimedSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
virtual Real & time() const
Executioner(const InputParameters &parameters)
Constructor.
Definition: Executioner.C:99
NonlinearSystemBase & getNonlinearSystemBase()
const PostprocessorValue & getPostprocessorValue(const std::string &name)
Retrieve the value of a Postprocessor or one of it&#39;s old or older values.
void setStartTime(const Real time)
Set the starting time for the simulation.
Definition: MooseApp.C:1043
const InputParameters & parameters() const
Get the parameters of the object.
Definition: MooseObject.h:57
virtual int & timeStep() const
const Real & _normalization
Postprocessor for normalization.
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
MooseEigenSystem & _eigen_sys
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:171
virtual void transient(bool trans)
virtual Real & timeOld() const
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseObject.h:81
virtual Real & dt() const
FEProblemBase & _fe_problem
Definition: Executioner.h:123
T & declareRestartableData(std::string data_name)
Declare a piece of data as "restartable".
Definition: Restartable.h:202

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 210 of file Executioner.C.

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

213 {
214  FEProblemBase * problem = getCheckedPointerParam<FEProblemBase *>(
215  "_fe_problem_base",
216  "Failed to retrieve FEProblemBase when adding a attribute reporter in Executioner");
217  InputParameters params = _app.getFactory().getValidParams("ExecutionerAttributeReporter");
218  params.set<Real *>("value") = &attribute;
219  if (!execute_on.empty())
220  params.set<ExecFlagEnum>("execute_on") = execute_on;
221  problem->addPostprocessor("ExecutionerAttributeReporter", name, params);
222 }
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:279
virtual Problem & problem()
Deprecated: Return a reference to this Executioner&#39;s Problem instance.
Definition: Executioner.C:185
MooseApp & _app
The MooseApp this object is associated with.
Definition: MooseObject.h:171
const std::string & name() const
Get the name of the object.
Definition: MooseObject.h:51

◆ chebyshev()

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

Definition at line 460 of file EigenExecutionerBase.C.

Referenced by inversePowerIteration().

463 {
464  if (!solution_diff)
465  mooseError("solution diff is required for Chebyshev acceleration");
466 
467  if (chebyshev_parameters.lgac == 0)
468  {
469  if (chebyshev_parameters.icho == 0)
470  chebyshev_parameters.ratio = *solution_diff / chebyshev_parameters.flux_error_norm_old;
471  else
472  {
473  chebyshev_parameters.ratio = chebyshev_parameters.ratio_new;
474  chebyshev_parameters.icho = 0;
475  }
476 
477  if (iter > chebyshev_parameters.finit && chebyshev_parameters.ratio >= 0.4 &&
478  chebyshev_parameters.ratio <= 1)
479  {
480  chebyshev_parameters.lgac = 1;
481  chebyshev_parameters.icheb = 1;
482  chebyshev_parameters.error_begin = *solution_diff;
483  chebyshev_parameters.iter_begin = iter;
484  double alp = 2 / (2 - chebyshev_parameters.ratio);
485  std::vector<double> coef(2);
486  coef[0] = alp;
487  coef[1] = 1 - alp;
491  }
492  }
493  else
494  {
495  chebyshev_parameters.icheb++;
496  double gamma = acosh(2 / chebyshev_parameters.ratio - 1);
497  double alp = 4 / chebyshev_parameters.ratio *
498  std::cosh((chebyshev_parameters.icheb - 1) * gamma) /
499  std::cosh(chebyshev_parameters.icheb * gamma);
500  double beta = (1 - chebyshev_parameters.ratio / 2) * alp - 1;
501  /* if (iter<int(chebyshev_parameters.iter_begin+chebyshev_parameters.n_iter))
502  {
503  std::vector<double> coef(3);
504  coef[0] = alp;
505  coef[1] = 1-alp+beta;
506  coef[2] = -beta;
507  _eigen_sys.combineSystemSolution(NonlinearSystem::EIGEN, coef);
508  }
509  else
510  {*/
511  double gamma_new =
512  (*solution_diff / chebyshev_parameters.error_begin) *
513  (std::cosh((chebyshev_parameters.icheb - 1) * acosh(2 / chebyshev_parameters.ratio - 1)));
514  if (gamma_new < 1.0)
515  gamma_new = 1.0;
516 
517  chebyshev_parameters.ratio_new =
518  chebyshev_parameters.ratio / 2 *
519  (std::cosh(acosh(gamma_new) / (chebyshev_parameters.icheb - 1)) + 1);
520  if (gamma_new > 1.01)
521  {
522  chebyshev_parameters.lgac = 0;
523  // chebyshev_parameters.icheb = 0;
524  // if (chebyshev_parameters.icheb>30)
525  // {
526  if (chebyshev_parameters.icheb > 0)
527  {
528  chebyshev_parameters.icho = 1;
529  chebyshev_parameters.finit = iter;
530  }
531  else
532  {
533  chebyshev_parameters.icho = 0;
534  chebyshev_parameters.finit = iter + chebyshev_parameters.fsmooth;
535  }
536  }
537  else
538  {
539  std::vector<double> coef(3);
540  coef[0] = alp;
541  coef[1] = 1 - alp + beta;
542  coef[2] = -beta;
546  }
547  // }
548  }
549  chebyshev_parameters.flux_error_norm_old = *solution_diff;
550 }
void mooseError(Args &&... args) const
Definition: MooseObject.h:140
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 ( )
virtual

Make sure time kernel is not presented.

Definition at line 148 of file EigenExecutionerBase.C.

Referenced by 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:140
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 ( )
inline

A method for returning the eigenvalue computed by the executioner.

Returns
A reference to the eigenvalue stored withing the executioner

Definition at line 119 of file EigenExecutionerBase.h.

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

◆ eigenvalueOld()

const Real & EigenExecutionerBase::eigenvalueOld ( )

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

Referenced by EigenKernel::enabled().

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

◆ execute()

virtual void Executioner::execute ( )
pure virtualinherited

Pure virtual execute function MUST be overridden by children classes.

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

Implemented in Steady, Transient, Eigenvalue, InversePowerMethod, and NonlinearEigen.

Referenced by FullSolveMultiApp::solveStep().

◆ feProblem()

FEProblemBase & Executioner::feProblem ( )
inherited

Return a reference to this Executioner's FEProblemBase instance.

Definition at line 192 of file Executioner.C.

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

193 {
194  return _fe_problem;
195 }
FEProblemBase & _fe_problem
Definition: Executioner.h:123

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

73  {
74  return parameters().getCheckedPointerParam<T>(name, error_string);
75  }
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:57
const std::string & name() const
Get the name of the object.
Definition: MooseObject.h:51

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

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

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

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

Referenced by FEProblemBase::addMaterialHelper(), ConstraintWarehouse::addObject(), BicubicSplineFunction::BicubicSplineFunction(), Piecewise::buildFromXandY(), 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().

186 {
187  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0));
188 }
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:168
const std::string & name() const
Get the name of the object.
Definition: MooseObject.h:51

◆ 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 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 198 of file Executioner.C.

Referenced by ConsoleUtils::outputExecutionInformation().

199 {
200  return std::string();
201 }

◆ 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 EigenExecutionerBase::init ( )
overridevirtual

Initialize the executioner.

Reimplemented from Executioner.

Reimplemented in InversePowerMethod, and NonlinearEigen.

Definition at line 80 of file EigenExecutionerBase.C.

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

81 {
84 
85  if (getParam<bool>("auto_initialization"))
86  {
87  // Initialize the solution of the eigen variables
88  // Note: initial conditions will override this if there is any by _problem.initialSetup()
90  }
93 
94  // check when the postprocessors are evaluated
95  const ExecFlagEnum & bx_exec =
96  _problem.getUserObject<UserObject>(getParam<PostprocessorName>("bx_norm")).getExecuteOnEnum();
97  if (!bx_exec.contains(EXEC_LINEAR))
98  mooseError("Postprocessor " + getParam<PostprocessorName>("bx_norm") +
99  " requires execute_on = 'linear'");
100 
101  if (isParamValid("normalization"))
102  _norm_exec = _problem.getUserObject<UserObject>(getParam<PostprocessorName>("normalization"))
103  .getExecuteOnEnum();
104  else
105  _norm_exec = bx_exec;
106 
107  // check if _source_integral has been evaluated during initialSetup()
108  if (!bx_exec.contains(EXEC_INITIAL))
110 
111  if (_source_integral == 0.0)
112  mooseError("|Bx| = 0!");
113 
114  // normalize solution to make |Bx|=_eigenvalue, _eigenvalue at this point has the initialized
115  // value
117 
118  if (_problem.getDisplacedProblem() != NULL)
119  _problem.getDisplacedProblem()->syncSolutions();
120 
121  /* a time step check point */
123 }
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 makeBXConsistent(Real k)
Normalize solution so that |Bx| = k.
virtual void onTimestepEnd() override
void mooseError(Args &&... args) const
Definition: MooseObject.h:140
virtual void checkIntegrity()
Make sure time kernel is not presented.
void buildSystemDoFIndices(SYSTEMTAG tag=ALL)
Build DoF indices for a system.
void initSystemSolution(SYSTEMTAG tag, Real v)
Initialize the solution vector with a constant value.
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
virtual std::shared_ptr< DisplacedProblem > getDisplacedProblem()
const ExecFlagEnum & getExecuteOnEnum() const
Return the execute on MultiMooseEnum for this object.
const ExecFlagType EXEC_LINEAR
Real & _eigenvalue
Storage for the eigenvalue computed by the executioner.
MooseEigenSystem & _eigen_sys
virtual void initialSetup()
void initSystemSolutionOld(SYSTEMTAG tag, Real v)
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseObject.h:81
Base class for user-specific data.
Definition: UserObject.h:38
const ExecFlagType EXEC_INITIAL

◆ inversePowerIteration()

void 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 
)
virtual

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.

Definition at line 158 of file EigenExecutionerBase.C.

Referenced by NonlinearEigen::init(), and InversePowerMethod::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;
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  unsigned int iter = 0;
225 
226  // power iteration loop...
227  // Note: |Bx|/k will stay constant one!
228  makeBXConsistent(k);
229  while (true)
230  {
231  if (echo)
232  _console << " Power iteration= " << iter << std::endl;
233 
234  // Important: we do not call _problem.advanceState() because we do not
235  // want to overwrite the old postprocessor values and old material
236  // properties in stateful materials.
239  if (_problem.getDisplacedProblem() != NULL)
240  {
241  _problem.getDisplacedProblem()->nlSys().copyOldSolutions();
242  _problem.getDisplacedProblem()->auxSys().copyOldSolutions();
243  }
244 
245  Real k_old = k;
247 
248  preIteration();
249  _problem.solve();
250  postIteration();
251 
252  // save the initial residual
253  if (iter == 0)
255 
256  // update eigenvalue
258  _eigenvalue = k;
259 
260  if (echo)
261  {
262  // output on screen the convergence history only when we want to and MOOSE output system is
263  // not used
264  keff_history.push_back(k);
265  if (solution_diff)
266  diff_history.push_back(*solution_diff);
267 
268  std::stringstream ss;
269  if (solution_diff)
270  {
271  ss << '\n';
272  ss << " +================+=====================+=====================+\n";
273  ss << " | iteration | eigenvalue | solution_difference |\n";
274  ss << " +================+=====================+=====================+\n";
275  unsigned int j = 0;
276  if (keff_history.size() > 10)
277  {
278  ss << " : : : :\n";
279  j = keff_history.size() - 10;
280  }
281  for (; j < keff_history.size(); j++)
282  ss << " | " << std::setw(14) << j << " | " << std::setw(19) << std::scientific
283  << std::setprecision(8) << keff_history[j] << " | " << std::setw(19) << std::scientific
284  << std::setprecision(8) << diff_history[j] << " |\n";
285  ss << " +================+=====================+=====================+\n" << std::flush;
286  }
287  else
288  {
289  ss << '\n';
290  ss << " +================+=====================+\n";
291  ss << " | iteration | eigenvalue |\n";
292  ss << " +================+=====================+\n";
293  unsigned int j = 0;
294  if (keff_history.size() > 10)
295  {
296  ss << " : : :\n";
297  j = keff_history.size() - 10;
298  }
299  for (; j < keff_history.size(); j++)
300  ss << " | " << std::setw(14) << j << " | " << std::setw(19) << std::scientific
301  << std::setprecision(8) << keff_history[j] << " |\n";
302  ss << " +================+=====================+\n" << std::flush;
303  ss << std::endl;
304  }
305  _console << ss.str();
306  }
307 
308  // increment iteration number here
309  iter++;
310 
311  if (cheb_on)
312  {
313  chebyshev(chebyshev_parameters, iter, solution_diff);
314  if (echo)
315  _console << " Chebyshev step: " << chebyshev_parameters.icheb << std::endl;
316  }
317 
318  if (echo)
319  _console
320  << " ________________________________________________________________________________ "
321  << std::endl;
322 
323  // not perform any convergence check when number of iterations is less than min_iter
324  if (iter >= min_iter)
325  {
326  // no need to check convergence of the last iteration
327  if (iter != max_iter)
328  {
329  bool converged = true;
330  Real keff_error = fabs(k_old - k) / k;
331  if (keff_error > tol_eig)
332  converged = false;
333  if (solution_diff)
334  if (*solution_diff > tol_x)
335  converged = false;
336  if (converged)
337  break;
338  }
339  else
340  break;
341  }
342  }
343 
344  // restore parameters changed by the executioner
345  _problem.es().parameters.set<Real>("linear solver tolerance") = tol1;
346  _problem.es().parameters.set<unsigned int>("nonlinear solver maximum iterations") = num1;
347  _problem.es().parameters.set<Real>("nonlinear solver relative residual tolerance") = tol2;
348 
349  // FIXME: currently power iteration use old and older solutions, so restore them
351  if (_problem.getDisplacedProblem() != NULL)
352  _problem.getDisplacedProblem()->restoreOldSolutions();
353 }
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:971
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:140
virtual EquationSystems & es() override
bool contains(const std::string &value) const
Contains methods for seeing if a value is in the MultiMooseEnum.
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:85
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 81 of file MooseObject.h.

Referenced by AdvancedOutput::AdvancedOutput(), BicubicSplineFunction::BicubicSplineFunction(), Piecewise::buildFromFile(), Piecewise::buildFromXandY(), DistributedGeneratedMesh::buildMesh(), GeneratedMesh::buildMesh(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), CSVReader::CSVReader(), MultiAppNearestNodeTransfer::execute(), Exodus::Exodus(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), RenameBoundaryGenerator::generate(), ElementSubdomainIDGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshSideSetGenerator::generate(), RenameBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainMeshGenerator::generate(), MeshExtruderGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), PatternedMeshGenerator::generate(), MultiAppNearestNodeTransfer::getLocalEntities(), MeshGenerator::getMesh(), MultiAppNearestNodeTransfer::getNearestNode(), init(), IterationAdaptiveDT::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(), normalizeSolution(), Output::Output(), PetscOutput::PetscOutput(), Piecewise::Piecewise(), SolutionUserObject::readExodusII(), RenameBlock::RenameBlock(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), SolutionUserObject::SolutionUserObject(), and TimePeriod::TimePeriod().

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

◆ lastSolveConverged()

bool Executioner::lastSolveConverged ( )
virtualinherited

Whether or not the last solve converged.

Reimplemented in Transient.

Definition at line 204 of file Executioner.C.

Referenced by Steady::execute(), FullSolveMultiApp::solveStep(), InversePowerMethod::takeStep(), and NonlinearEigen::takeStep().

205 {
206  return _fe_problem.converged();
207 }
virtual bool converged() override
FEProblemBase & _fe_problem
Definition: Executioner.h:123

◆ makeBXConsistent()

void EigenExecutionerBase::makeBXConsistent ( Real  k)
virtual

Normalize solution so that |Bx| = k.

Definition at line 126 of file EigenExecutionerBase.C.

Referenced by init(), inversePowerIteration(), and 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 140 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(), AllSideSetsByNormalsGenerator::AllSideSetsByNormalsGenerator(), 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::buildRefinementMap(), MooseMesh::buildSideList(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), chebyshev(), SubProblem::checkBlockMatProps(), SubProblem::checkBoundaryMatProps(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), Material::checkExecutionStage(), BreakMeshByBlockBase::checkInputParameter(), Steady::checkIntegrity(), checkIntegrity(), ActuallyExplicitEuler::checkLinearConvergence(), FEProblemBase::checkProblemIntegrity(), Material::checkStatefulSanity(), FEProblemBase::checkUserObjects(), LibmeshPartitioner::clone(), MooseMesh::clone(), ComparisonPostprocessor::comparisonIsTrue(), CompositeFunction::CompositeFunction(), ElementLpNormAux::compute(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), InterfaceKernel::computeElemNeighJacobian(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), HistogramVectorPostprocessor::computeHistogram(), EqualValueEmbeddedConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualType(), StatisticsVectorPostprocessor::computeStatValue(), Material::computeSubdomainProperties(), BDF2::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::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(), PerflogDumper::execute(), MultiAppPostprocessorTransfer::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementQualityChecker::execute(), NodalValueSampler::execute(), MultiAppNearestNodeTransfer::execute(), PointValue::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), FindValueOnLine::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(), ExtraNodesetGenerator::generate(), ElementSubdomainIDGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), StitchedMeshGenerator::generate(), GeneratedMeshGenerator::generate(), MeshExtruderGenerator::generate(), SpiralAnnularMeshGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), PatternedMeshGenerator::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(), PerformanceData::getValue(), Residual::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(), init(), Transient::init(), MooseMesh::init(), FEProblemBase::init(), NumPicardIterations::initialize(), PiecewiseBase::initialSetup(), FullSolveMultiApp::initialSetup(), SolutionAux::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), Exodus::initialSetup(), SolutionFunction::initialSetup(), SolutionUserObject::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Material::initStatefulProperties(), Function::integral(), InterfaceKernel::InterfaceKernel(), InterfaceTimeKernel::InterfaceTimeKernel(), inversePowerIteration(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), 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(), AddExtraNodeset::modify(), MeshExtruder::modify(), BreakMeshByBlockBase::modify(), SmoothMesh::modify(), AssignElementSubdomainID::modify(), ElementDeleterBase::modify(), AddAllSideSetsByNormals::modify(), RenameBlock::modify(), ParsedSubdomainMeshModifier::modify(), ImageSubdomain::modify(), BoundingBoxNodeSet::modify(), OrientedSubdomainBoundingBox::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(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), Exodus::outputSetup(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), MooseObject::paramError(), PiecewiseBilinear::parse(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PatternedMesh::PatternedMesh(), 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::setOutputDimension(), Split::setup(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideSetsFromNormals::SideSetsFromNormals(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPoints::SideSetsFromPoints(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObject::SolutionUserObject(), 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(), Transient::Transient(), TransientMultiApp::TransientMultiApp(), 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().

141  {
142  std::ostringstream oss;
143  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
144  std::string msg = oss.str();
145  callMooseErrorRaw(msg, &_app);
146  }
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:171

◆ 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 51 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(), AllSideSetsByNormalsGenerator::AllSideSetsByNormalsGenerator(), 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(), MultiAppNearestNodeTransfer::execute(), PointValue::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppVectorPostprocessorTransfer::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(), FEProblemBase::getDistribution(), 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(), Exodus::setOutputDimension(), 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(), TiledMeshGenerator::TiledMeshGenerator(), Function::timeDerivative(), VectorPostprocessorVisualizationAux::timestepSetup(), TransientMultiApp::TransientMultiApp(), MultiAppTransfer::variableIntegrityCheck(), and AdvancedOutput::wantOutput().

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

◆ nonlinearSolve()

void EigenExecutionerBase::nonlinearSolve ( Real  rel_tol,
Real  abs_tol,
Real  pfactor,
Real &  k 
)
virtual

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.

Definition at line 553 of file EigenExecutionerBase.C.

Referenced by NonlinearEigen::takeStep().

554 {
555  makeBXConsistent(k);
556 
557  // turn on nonlinear flag so that eigen kernels opterate on the current solutions
559 
560  // set nonlinear solver controls
561  Real tol1 = _problem.es().parameters.get<Real>("nonlinear solver absolute residual tolerance");
562  Real tol2 = _problem.es().parameters.get<Real>("linear solver tolerance");
563  Real tol3 = _problem.es().parameters.get<Real>("nonlinear solver relative residual tolerance");
564 
565  _problem.es().parameters.set<Real>("nonlinear solver absolute residual tolerance") = abs_tol;
566  _problem.es().parameters.set<Real>("nonlinear solver relative residual tolerance") = rel_tol;
567  _problem.es().parameters.set<Real>("linear solver tolerance") = pfactor;
568 
569  // call nonlinear solve
570  _problem.solve();
571 
572  k = _source_integral;
573  _eigenvalue = k;
574 
575  _problem.es().parameters.set<Real>("nonlinear solver absolute residual tolerance") = tol1;
576  _problem.es().parameters.set<Real>("linear solver tolerance") = tol2;
577  _problem.es().parameters.set<Real>("nonlinear solver relative residual tolerance") = tol3;
578 }
virtual void makeBXConsistent(Real k)
Normalize solution so that |Bx| = k.
virtual EquationSystems & es() 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)
virtual

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 408 of file EigenExecutionerBase.C.

Referenced by postExecute().

409 {
410  if (force)
412 
413  Real factor;
414  if (isParamValid("normal_factor"))
415  factor = getParam<Real>("normal_factor");
416  else
417  factor = _eigenvalue;
418  Real scaling = factor / _normalization;
419 
420  if (!MooseUtils::absoluteFuzzyEqual(scaling, 1.0))
421  {
422  // FIXME: we assume linear scaling here!
424  // update all aux variables and user objects
425 
426  for (const ExecFlagType & flag : _app.getExecuteOnEnum().items())
427  _problem.execute(flag);
428  }
429  return scaling;
430 }
void scaleSystemSolution(SYSTEMTAG tag, Real scaling_factor)
Scale the solution vector.
const ExecFlagEnum & getExecuteOnEnum() const
Return the app level ExecFlagEnum, this contains all the available flags for the app.
Definition: MooseApp.h:647
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:171
bool absoluteFuzzyEqual(const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition: MooseObject.h:81
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 100 of file MooseObject.h.

Referenced by ADKernel< compute_stage >::ADKernel(), DGKernel::DGKernel(), ElementValueSampler::ElementValueSampler(), IntegratedBC::IntegratedBC(), Kernel::Kernel(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalValueSampler::NodalValueSampler(), RandomIC::RandomIC(), and MultiAppCopyTransfer::transfer().

101  {
102  auto prefix = param + ": ";
103  if (!_pars.inputLocation(param).empty())
104  prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
105  mooseError(prefix, args...);
106  }
void mooseError(Args &&... args) const
Definition: MooseObject.h:140
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:168
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 57 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(), 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().

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

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

132  {
133  auto prefix = param + ": ";
134  if (!_pars.inputLocation(param).empty())
135  prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
136  mooseInfo(prefix, args...);
137  }
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:168
void mooseInfo(Args &&... args) const
Definition: MooseObject.h:161
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 115 of file MooseObject.h.

116  {
117  auto prefix = param + ": ";
118  if (!_pars.inputLocation(param).empty())
119  prefix = _pars.inputLocation(param) + ": (" + _pars.paramFullpath(param) + "):\n";
120  mooseWarning(prefix, args...);
121  }
void mooseWarning(Args &&... args) const
Definition: MooseObject.h:149
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:168
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 105 of file Executioner.h.

105 {}

◆ postExecute()

void EigenExecutionerBase::postExecute ( )
overridevirtual

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

Reimplemented from Executioner.

Definition at line 366 of file EigenExecutionerBase.C.

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

367 {
368  if (getParam<bool>("output_before_normalization"))
369  {
370  _problem.timeStep()++;
371  Real t = _problem.time();
374  _problem.time() = t;
375  }
376 
377  Real s = 1.0;
379  {
380  _console << " Cannot let the normalization postprocessor on custom.\n";
381  _console << " Normalization is abandoned!" << std::endl;
382  }
383  else
384  {
386  s = normalizeSolution(force);
387  if (!MooseUtils::absoluteFuzzyEqual(s, 1.0))
388  _console << " Solution is rescaled with factor " << s << " for normalization!" << std::endl;
389  }
390 
391  if ((!getParam<bool>("output_before_normalization")) || !MooseUtils::absoluteFuzzyEqual(s, 1.0))
392  {
393  _problem.timeStep()++;
394  Real t = _problem.time();
397  _problem.time() = t;
398  }
399 
400  {
401  TIME_SECTION(_final_timer)
404  }
405 }
virtual Real & time() const
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
bool absoluteFuzzyEqual(const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
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 ( )
virtual

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

Definition at line 361 of file EigenExecutionerBase.C.

Referenced by inversePowerIteration().

362 {
363 }

◆ postSolve()

void Executioner::postSolve ( )
virtualinherited

Override this for actions that should take place after execution.

Definition at line 180 of file Executioner.C.

Referenced by Steady::execute(), Transient::solveStep(), InversePowerMethod::takeStep(), and NonlinearEigen::takeStep().

181 {
182 }

◆ preExecute()

void Executioner::preExecute ( )
virtualinherited

Override this for actions that should take place before execution.

Reimplemented in Transient.

Definition at line 165 of file Executioner.C.

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

166 {
167 }

◆ preIteration()

void EigenExecutionerBase::preIteration ( )
virtual

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

Definition at line 356 of file EigenExecutionerBase.C.

Referenced by inversePowerIteration().

357 {
358 }

◆ preSolve()

void Executioner::preSolve ( )
virtualinherited

Override this for actions that should take place before execution.

Definition at line 175 of file Executioner.C.

Referenced by Steady::execute(), Transient::solveStep(), InversePowerMethod::takeStep(), and NonlinearEigen::takeStep().

176 {
177 }

◆ printEigenvalue()

void EigenExecutionerBase::printEigenvalue ( )
protectedvirtual

Print eigenvalue.

Definition at line 433 of file EigenExecutionerBase.C.

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

434 {
435  std::ostringstream ss;
436  ss << '\n';
437  ss << "*******************************************************\n";
438  ss << " Eigenvalue = " << std::fixed << std::setprecision(10) << _eigenvalue << '\n';
439  ss << "*******************************************************";
440 
441  _console << ss.str() << std::endl;
442 }
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 185 of file Executioner.C.

Referenced by Executioner::addAttributeReporter().

186 {
187  mooseDoOnce(mooseWarning("This method is deprecated, use feProblem() instead"));
188  return _fe_problem;
189 }
void mooseWarning(Args &&... args) const
Definition: MooseObject.h:149
FEProblemBase & _fe_problem
Definition: Executioner.h:123

◆ 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:41

◆ 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 45 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(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), AdvancedOutput::initAvailableLists(), SolutionUserObject::initialSetup(), AdvancedOutput::initShowHideLists(), AssignElementSubdomainID::modify(), ControlOutput::output(), Gnuplot::output(), Exodus::output(), CSV::output(), Console::output(), Nemesis::output(), AdvancedOutput::output(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), FEProblemBase::restoreMultiApps(), FEProblemBase::setCoupling(), FileOutput::shouldOutput(), Output::shouldOutput(), AdvancedOutput::shouldOutput(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), and AdvancedOutput::wantOutput().

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

Member Data Documentation

◆ _app

MooseApp& MooseObject::_app
protectedinherited

The MooseApp this object is associated with.

Definition at line 171 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(), FEProblemBase::checkNonlinearConvergence(), OversampleOutput::cloneMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), MultiApp::createApp(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase(), EigenKernel::EigenKernel(), NonlinearEigen::execute(), InversePowerMethod::execute(), Transient::execute(), Steady::execute(), FileOutput::FileOutput(), FEProblemBase::forceOutput(), MeshGenerator::getMesh(), MeshGenerator::getMeshByName(), MooseObject::getMooseApp(), InversePowerMethod::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::InversePowerMethod(), MooseObject::mooseError(), MooseMesh::MooseMesh(), NonlinearEigen::NonlinearEigen(), 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().

◆ _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(), AB2PredictorCorrector::converged(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppCopyTransfer::execute(), Steady::execute(), MultiAppDTKUserObjectTransfer::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), FEProblemBase::FEProblemBase(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MultiApp::globalAppToLocal(), InversePowerMethod::init(), NonlinearEigen::init(), Steady::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initialSetup(), inversePowerIteration(), Transient::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), 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(), postExecute(), ActionWarehouse::printActionDependencySets(), printEigenvalue(), MaterialPropertyDebugOutput::printMaterialMap(), SolutionTimeAdaptiveDT::rejectStep(), DT2::rejectStep(), FEProblemBase::restoreMultiApps(), SimplePredictor::shouldApply(), NonlinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), Transient::solveStep(), DT2::step(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

◆ _eigen_sys

MooseEigenSystem& EigenExecutionerBase::_eigen_sys
protected

◆ _eigenvalue

Real& EigenExecutionerBase::_eigenvalue
protected

◆ _enabled

const bool& MooseObject::_enabled
protectedinherited

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

Definition at line 180 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _fe_problem

FEProblemBase& Executioner::_fe_problem
protectedinherited

◆ _final_timer

PerfID EigenExecutionerBase::_final_timer
protected

Definition at line 142 of file EigenExecutionerBase.h.

Referenced by postExecute().

◆ _initial_residual_norm

Real Executioner::_initial_residual_norm
protectedinherited

Initial Residual Variables.

Definition at line 126 of file Executioner.h.

◆ _name

const std::string& MooseObject::_name
protectedinherited

◆ _norm_exec

ExecFlagEnum EigenExecutionerBase::_norm_exec
protected

Definition at line 140 of file EigenExecutionerBase.h.

Referenced by init(), and postExecute().

◆ _normalization

const Real& EigenExecutionerBase::_normalization
protected

Postprocessor for normalization.

Definition at line 139 of file EigenExecutionerBase.h.

Referenced by normalizeSolution().

◆ _old_initial_residual_norm

Real Executioner::_old_initial_residual_norm
protectedinherited

Definition at line 127 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().

◆ _pg_params

const InputParameters* PerfGraphInterface::_pg_params
protectedinherited

Params.

Definition at line 63 of file PerfGraphInterface.h.

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

◆ _restart_file_base

std::string Executioner::_restart_file_base
protectedinherited

Definition at line 130 of file Executioner.h.

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

◆ _source_integral

const Real& EigenExecutionerBase::_source_integral
protected

◆ _source_integral_old

Real EigenExecutionerBase::_source_integral_old
protected

Definition at line 136 of file EigenExecutionerBase.h.

Referenced by eigenvalueOld(), and inversePowerIteration().

◆ _splitting

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

Definition at line 133 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 174 of file MooseObject.h.

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


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