InputParameters validParams<Split>()
{
InputParameters params = validParams<MooseObject>();
params.addParam<std::vector<NonlinearVariableName> >("vars", "Variables Split operates on (omitting this implies \"all variables\"");
params.addParam<std::vector<SubdomainName> >("blocks", "Mesh blocks Split operates on (omitting this implies \"all blocks\"");
params.addParam<std::vector<BoundaryName> >("sides", "Sidesets Split operates on (omitting this implies \"no sidesets\"");
params.addParam<std::vector<BoundaryName> >("unsides", "Sidesets Split excludes (omitting this implies \"do not exclude any sidesets\"");
params.addParam<std::vector<std::string> >("splitting", "The names of the splits (subsystems) in the decomposition of this split");
MooseEnum SplittingTypeEnum("additive multiplicative symmetric_multiplicative schur", "additive");
params.addParam<MooseEnum>("splitting_type", SplittingTypeEnum, "Split decomposition type");
MooseEnum SchurTypeEnum("full upper lower", "full");
params.addParam<MooseEnum>("schur_type", SchurTypeEnum, "Type of Schur complement");
/**
* Which preconditioning matrix to use with S = D - CA^{-1}B
* 'Self' means use S to build the preconditioner.
* limited choices here: PCNONE and PCLSC in PETSc
* 'D' means the lower-right block in splitting J = [A B; C D]
*/
MooseEnum SchurPreEnum("S Sp A11", "S");
params.addParam<MooseEnum>("schur_pre", SchurPreEnum, "Type of Schur complement preconditioner matrix");
MooseEnum SchurAInvEnum("diag lump", "diag");
params.addParam<MooseEnum>("schur_ainv", SchurAInvEnum, "Type of approximation to inv(A) used when forming S = D - C inv(A) B");
params.addParam<MultiMooseEnum>("petsc_options", Moose::PetscSupport::getCommonPetscFlags(), "PETSc flags for the FieldSplit solver");
params.addParam<MultiMooseEnum>("petsc_options_iname", Moose::PetscSupport::getCommonPetscKeys(), "PETSc option names for the FieldSplit solver");
params.addParam<std::vector<std::string> >("petsc_options_value", "PETSc option values for the FieldSplit solver");
params.registerBase("Split");
return params;
}
InputParameters
validParams<FluidProperties>()
{
InputParameters params = validParams<GeneralUserObject>();
params.registerBase("FluidProperties");
return params;
}
InputParameters
validParams<MeshGenerator>()
{
InputParameters params = validParams<MooseObject>();
params.registerBase("MeshGenerator");
return params;
}
InputParameters validParams<EigenKernel>()
{
InputParameters params = validParams<KernelBase>();
params.addParam<bool>("eigen", true, "Use for eigenvalue problem (true) or source problem (false)");
params.addParam<PostprocessorName>("eigen_postprocessor", 1.0, "The name of the postprocessor that provides the eigenvalue.");
params.registerBase("EigenKernel");
return params;
}
InputParameters validParams<MeshModifier>()
{
InputParameters params = validParams<MooseObject>();
params.registerBase("MeshModifier");
return params;
}
InputParameters validParams<Function>()
{
InputParameters params = validParams<MooseObject>();
params.registerBase("Function");
return params;
}
InputParameters validParams<ScalarInitialCondition>()
{
InputParameters params = validParams<MooseObject>();
params.addParam<VariableName>("variable", "The variable this initial condition is supposed to provide values for.");
params.registerBase("ScalarInitialCondition");
return params;
}
InputParameters validParams<Postprocessor>()
{
InputParameters params = validParams<UserObject>();
params += validParams<OutputInterface>();
params.addParamNamesToGroup("outputs", "Advanced");
params.registerBase("Postprocessor");
return params;
}
InputParameters validParams<Predictor>()
{
InputParameters params = validParams<MooseObject>();
params.addRequiredParam<Real>("scale", "The scale factor for the predictor (can range from 0 to 1)");
params.registerBase("Predictor");
return params;
}
InputParameters validParams<TimeStepper>()
{
InputParameters params = validParams<MooseObject>();
params.addParam<bool>("reset_dt", false, "Use when restarting a calculation to force a change in dt.");
params.registerBase("TimeStepper");
return params;
}
InputParameters
validParams<Problem>()
{
InputParameters params = emptyInputParameters();
params += validParams<MooseObject>();
params.registerBase("Problem");
return params;
}
InputParameters validParams<Output>()
{
// Get the parameters from the parent object
InputParameters params = validParams<MooseObject>();
// General options
params.addParam<bool>("output_input", false, "Output the input file");
params.addParam<bool>("output_system_information", true, "Toggles the display of the system information prior to the solve");
// Hide/show variable output options
params.addParam<std::vector<VariableName> >("hide", "A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names).");
params.addParam<std::vector<VariableName> >("show", "A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names).");
// Enable/disable output types
params.addParam<bool>("output_nodal_variables", true, "Enable/disable the output of nodal nonlinear variables");
params.addParam<bool>("output_elemental_variables", true, "Enable/disable the output of elemental nonlinear variables");
params.addParam<bool>("output_scalar_variables", true, "Enable/disable the output of aux scalar variables");
params.addParam<bool>("output_postprocessors", true, "Enable/disable the output of postprocessors");
params.addParam<bool>("output_vector_postprocessors", true, "Enable/disable the output of VectorPostprocessors");
// Displaced Mesh options
params.addParam<bool>("use_displaced", false, "Enable/disable the use of the displaced mesh for outputting");
// Enable sequential file output (do not set default, the use_displace criteria relies on isParamValid, see Constructor)
params.addParam<bool>("sequence", "Enable/disable sequential file output (enable by default when 'use_displace = true', otherwise defaults to false");
// Control for outputting elemental variables as nodal variables
params.addParam<bool>("elemental_as_nodal", false, "Output elemental nonlinear variables as nodal");
params.addParam<bool>("scalar_as_nodal", false, "Output scalar variables as nodal");
// Output intervals and timing
params.addParam<bool>("output_initial", false, "Request that the initial condition is output to the solution file");
params.addParam<bool>("output_intermediate", true, "Request that all intermediate steps (not initial or final) are output");
params.addParam<bool>("output_final", false, "Force the final time step to be output, regardless of output interval");
params.addParam<unsigned int>("interval", 1, "The interval at which time steps are output to the solution file");
params.addParam<bool>("output_failed", false, "When true all time attempted time steps are output");
params.addParam<std::vector<Real> >("sync_times", "Times at which the output and solution is forced to occur");
params.addParam<bool>("sync_only", false, "Only export results at sync times");
params.addParam<Real>("start_time", "Time at which this output object begins to operate");
params.addParam<Real>("end_time", "Time at which this output object stop operating");
params.addParam<Real>("time_tolerance", 1e-14, "Time tolerance utilized checking start and end times");
// 'Timing' group
params.addParamNamesToGroup("time_tolerance interval output_initial output_final sync_times sync_only start_time end_time ", "Timing");
// 'Variables' Group
params.addParamNamesToGroup("hide show output_nonlinear_variables output_postprocessors output_vector_postprocessors output_scalar_variables output_elemental_variables output_nodal_variables scalar_as_nodal elemental_as_nodal", "Variables");
// Add a private parameter for indicating if it was created with short-cut syntax
params.addPrivateParam<bool>("_built_by_moose", false);
// Register this class as base class
params.registerBase("Output");
return params;
}
InputParameters validParams<VectorPostprocessor>()
{
InputParameters params = validParams<UserObject>();
params.addParamNamesToGroup("outputs", "Advanced");
params.addParam<std::vector<OutputName> >("outputs", "Vector of output names were you would like to restrict the output of this VectorPostprocessor (empty outputs to all)");
params.addPrivateParam<VectorPostprocessorData *>("_vector_postprocessor_data");
params.registerBase("VectorPostprocessor");
return params;
}
InputParameters validParams<OutputBase>()
{
/* NOTE:
* The validParams from each output object is merged with the valdParams from CommonOutputAction. In order for the
* common parameters to be applied correctly any parameter that is a common parameter (e.g., output_initial) MUST NOT
* set a default value, this is because the default is extracted from the common parameters when the output object
* is being created within AddOutputAction. */
// Get the parameters from the parent object
InputParameters params = validParams<MooseObject>();
// General options
params.addParam<bool>("output_input", false, "Output the input file");
params.addParam<bool>("output_system_information", true, "Toggles the display of the system information prior to the solve");
// Hide/show variable output options
params.addParam<std::vector<VariableName> >("hide", "A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names).");
params.addParam<std::vector<VariableName> >("show", "A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names).");
// Enable/disable output types
params.addParam<bool>("output_nodal_variables", true, "Enable/disable the output of nodal nonlinear variables");
params.addParam<bool>("output_elemental_variables", true, "Enable/disable the output of elemental nonlinear variables");
params.addParam<bool>("output_scalar_variables", true, "Enable/disable the output of aux scalar variables");
params.addParam<bool>("output_postprocessors", true, "Enable/disable the output of postprocessors");
// Displaced Mesh options
params.addParam<bool>("use_displaced", false, "Enable/disable the use of the displaced mesh for outputing");
// Enable sequential file output
params.addParam<bool>("sequence", "Enable/disable sequential file output (enable by default when 'use_displace = true', otherwise defaults to false");
// Control for outputing elemental variables as nodal variables
params.addParam<bool>("elemental_as_nodal", false, "Output elemental nonlinear variables as nodal");
params.addParam<bool>("scalar_as_nodal", false, "Output scalar variables as nodal");
// Output intervals and timing
params.addParam<bool>("output_initial", "Request that the initial condition is output to the solution file");
params.addParam<bool>("output_final", "Force the final timestep to be output, regardless of output interval");
params.addParam<unsigned int>("interval", "The interval at which timesteps are output to the solution file");
params.addParam<bool>("output_failed", false, "When true all time attempted time steps are output");
params.addParam<std::vector<Real> >("sync_times", "Times at which the output and solution is forced to occur");
params.addParam<bool>("sync_only", false, "Only export results at sync times");
// 'Timing' group
params.addParamNamesToGroup("interval output_initial output_final sync_times sync_only", "Timing");
// 'Variables' Group
params.addParamNamesToGroup("hide show output_nonlinear_variables output_postprocessors output_scalar_variables output_elemental_variables output_nodal_variables scalar_as_nodal elemental_as_nodal", "Variables");
// Register this class as base class
params.registerBase("OutputBase");
return params;
}
InputParameters validParams<AuxScalarKernel>()
{
InputParameters params = validParams<MooseObject>();
params.addRequiredParam<AuxVariableName>("variable", "The name of the variable that this kernel operates on");
params.addParam<bool>("use_displaced_mesh", false, "Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.");
params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
params.registerBase("AuxScalarKernel");
return params;
}
InputParameters validParams<MoosePreconditioner>()
{
InputParameters params = validParams<MooseObject>();
params.addPrivateParam<FEProblem *>("_fe_problem");
MooseEnum pc_side("left right symmetric", "right");
params.addParam<MooseEnum>("pc_side", pc_side, "Preconditioning side");
params.registerBase("MoosePreconditioner");
return params;
}
InputParameters validParams<Control>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<TransientInterface>();
params += validParams<SetupInterface>();
params += validParams<FunctionInterface>();
params.registerBase("Control");
params.set<MultiMooseEnum>("execute_on") = Control::getExecuteOptions();
return params;
}
InputParameters validParams<MultiApp>()
{
InputParameters params = validParams<MooseObject>();
params.addParam<bool>("use_displaced_mesh", false, "Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.");
params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
std::ostringstream app_types_strings;
registeredMooseAppIterator it = AppFactory::instance().registeredObjectsBegin();
while (it != AppFactory::instance().registeredObjectsEnd())
{
app_types_strings << it->first;
++it;
if (it != AppFactory::instance().registeredObjectsEnd())
app_types_strings<< ", ";
}
MooseEnum app_types_options(app_types_strings.str());
params.addRequiredParam<MooseEnum>("app_type", app_types_options, "The type of application to build.");
params.addParam<std::vector<Point> >("positions", "The positions of the App locations. Each set of 3 values will represent a Point. Either this must be supplied or 'positions_file'");
params.addParam<FileName>("positions_file", "A filename that should be looked in for positions. Each set of 3 values in that file will represent a Point. Either this must be supplied or 'positions'");
params.addRequiredParam<std::vector<std::string> >("input_files", "The input file for each App. If this parameter only contains one input file it will be used for all of the Apps.");
params.addParam<Real>("bounding_box_inflation", 0.01, "Relative amount to 'inflate' the bounding box of this MultiApp.");
params.addPrivateParam<MPI_Comm>("_mpi_comm");
MultiMooseEnum execute_options(SetupInterface::getExecuteOptions());
execute_options = "timestep_begin"; // set the default
params.addParam<MultiMooseEnum>("execute_on", execute_options, "Set to (linear|nonlinear|timestep_end|timestep_begin|custom) to execute only at that moment");
params.addParam<unsigned int>("max_procs_per_app", std::numeric_limits<unsigned int>::max(), "Maximum number of processors to give to each App in this MultiApp. Useful for restricting small solves to just a few procs so they don't get spread out");
params.addParam<bool>("output_in_position", false, "If true this will cause the output from the MultiApp to be 'moved' by its position vector");
params.addParam<Real>("reset_time", std::numeric_limits<Real>::max(), "The time at which to reset Apps given by the 'reset_apps' parameter. Resetting an App means that it is destroyed and recreated, possibly modeling the insertion of 'new' material for that app.");
params.addParam<std::vector<unsigned int> >("reset_apps", "The Apps that will be reset when 'reset_time' is hit. These are the App 'numbers' starting with 0 corresponding to the order of the App positions. Resetting an App means that it is destroyed and recreated, possibly modeling the insertion of 'new' material for that app.");
params.addParam<Real>("move_time", std::numeric_limits<Real>::max(), "The time at which Apps designated by move_apps are moved to move_positions.");
params.addParam<std::vector<unsigned int> >("move_apps", "Apps, designated by their 'numbers' starting with 0 corresponding to the order of the App positions, to be moved at move_time to move_positions");
params.addParam<std::vector<Point> >("move_positions", "The positions corresponding to each move_app.");
params.registerBase("MultiApp");
return params;
}
InputParameters validParams<MeshModifier>()
{
InputParameters params = validParams<MooseObject>();
params.addParam<std::vector<std::string> >("depends_on", "The MeshModifiers that this modifier relies upon (i.e. must execute before this one)");
params.addParam<bool>("force_prepare", false,
"Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier "
"to force preperation between modifiers where they might be needed.");
params.registerBase("MeshModifier");
return params;
}
InputParameters validParams<InitialCondition>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<BlockRestrictable>();
params += validParams<BoundaryRestrictable>();
params.addRequiredParam<VariableName>("variable", "The variable this initial condition is supposed to provide values for.");
params.registerBase("InitialCondition");
return params;
}
InputParameters validParams<Indicator>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<BlockRestrictable>();
params.addParam<bool>("use_displaced_mesh", false, "Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.");
params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
params.registerBase("Indicator");
return params;
}
InputParameters validParams<DGKernel>()
{
InputParameters params = validParams<MooseObject>();
params.addRequiredParam<NonlinearVariableName>("variable", "The name of the variable that this boundary condition applies to");
params.addPrivateParam<BoundaryID>("_boundary_id", DGKernel::InternalBndId);
params.addParam<bool>("use_displaced_mesh", false, "Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.");
params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
params.registerBase("DGKernel");
return params;
}
InputParameters validParams<Transfer>()
{
InputParameters params = validParams<MooseObject>();
params.addParam<bool>("use_displaced_mesh", false, "Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.");
// Add the SetupInterface parameter, 'execute_on', and set it to a default of 'timestep_begin'
params += validParams<SetupInterface>();
params.set<MultiMooseEnum>("execute_on") = "timestep_begin";
params.registerBase("Transfer");
params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
return params;
}
InputParameters validParams<Executioner>()
{
InputParameters params = validParams<MooseObject>();
params.addParam<FileNameNoExtension>("restart_file_base", "", "File base name used for restart");
params.registerBase("Executioner");
params.addParamNamesToGroup("restart_file_base", "Restart");
params.addParam<std::vector<std::string> >("splitting", "Top-level splitting defining a hierarchical decomposition into subsystems to help the solver.");
return params;
}
InputParameters
validParams<Executioner>()
{
InputParameters params = validParams<MooseObject>();
params.addDeprecatedParam<FileNameNoExtension>(
"restart_file_base",
"",
"File base name used for restart",
"Please use \"Problem/restart_file_base\" instead");
params.registerBase("Executioner");
params.addParamNamesToGroup("restart_file_base", "Restart");
params.addParam<std::vector<std::string>>("splitting",
"Top-level splitting defining a "
"hierarchical decomposition into "
"subsystems to help the solver.");
// Default Solver Behavior
#ifdef LIBMESH_HAVE_PETSC
params += Moose::PetscSupport::getPetscValidParams();
#endif // LIBMESH_HAVE_PETSC
// Add slepc options
#ifdef LIBMESH_HAVE_SLEPC
params += Moose::SlepcSupport::getSlepcValidParams();
#endif
params.addParam<Real>("l_tol", 1.0e-5, "Linear Tolerance");
params.addParam<Real>("l_abs_step_tol", -1, "Linear Absolute Step Tolerance");
params.addParam<unsigned int>("l_max_its", 10000, "Max Linear Iterations");
params.addParam<unsigned int>("nl_max_its", 50, "Max Nonlinear Iterations");
params.addParam<unsigned int>("nl_max_funcs", 10000, "Max Nonlinear solver function evaluations");
params.addParam<Real>("nl_abs_tol", 1.0e-50, "Nonlinear Absolute Tolerance");
params.addParam<Real>("nl_rel_tol", 1.0e-8, "Nonlinear Relative Tolerance");
params.addParam<Real>("nl_abs_step_tol", 1.0e-50, "Nonlinear Absolute step Tolerance");
params.addParam<Real>("nl_rel_step_tol", 1.0e-50, "Nonlinear Relative step Tolerance");
params.addParam<bool>("no_fe_reinit", false, "Specifies whether or not to reinitialize FEs");
params.addParam<bool>("compute_initial_residual_before_preset_bcs",
false,
"Use the residual norm computed *before* PresetBCs are imposed in relative "
"convergence check");
params.addParamNamesToGroup("l_tol l_abs_step_tol l_max_its nl_max_its nl_max_funcs "
"nl_abs_tol nl_rel_tol nl_abs_step_tol nl_rel_step_tol "
"compute_initial_residual_before_preset_bcs",
"Solver");
params.addParamNamesToGroup("no_fe_reinit", "Advanced");
return params;
}
InputParameters validParams<Constraint>()
{
InputParameters params = validParams<MooseObject>();
// Add the SetupInterface parameter, 'execute_on', default is 'linear'
params += validParams<SetupInterface>();
params.addRequiredParam<NonlinearVariableName>("variable", "The name of the variable that this constraint is applied to.");
params.addParam<bool>("use_displaced_mesh", false, "Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.");
params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
params.registerBase("Constraint");
return params;
}
InputParameters validParams<BoundaryCondition>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<TransientInterface>();
params += validParams<BoundaryRestrictableRequired>();
params.addRequiredParam<NonlinearVariableName>("variable", "The name of the variable that this boundary condition applies to");
params.addParam<bool>("use_displaced_mesh", false, "Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.");
params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
params.registerBase("BoundaryCondition");
return params;
}
InputParameters validParams<MoosePreconditioner>()
{
InputParameters params = validParams<MooseObject>();
params.addPrivateParam<FEProblemBase *>("_fe_problem_base");
MooseEnum pc_side("left right symmetric", "right");
params.addParam<MooseEnum>("pc_side", pc_side, "Preconditioning side");
params.registerBase("MoosePreconditioner");
#ifdef LIBMESH_HAVE_PETSC
params += Moose::PetscSupport::getPetscValidParams();
#endif //LIBMESH_HAVE_PETSC
return params;
}
InputParameters
validParams<Output>()
{
// Get the parameters from the parent object
InputParameters params = validParams<MooseObject>();
// Displaced Mesh options
params.addParam<bool>(
"use_displaced", false, "Enable/disable the use of the displaced mesh for outputting");
// Output intervals and timing
params.addParam<unsigned int>(
"interval", 1, "The interval at which time steps are output to the solution file");
params.addParam<std::vector<Real>>("sync_times",
"Times at which the output and solution is forced to occur");
params.addParam<bool>("sync_only", false, "Only export results at sync times");
params.addParam<Real>("start_time", "Time at which this output object begins to operate");
params.addParam<Real>("end_time", "Time at which this output object stop operating");
params.addParam<Real>(
"time_tolerance", 1e-14, "Time tolerance utilized checking start and end times");
// Add the 'execute_on' input parameter for users to set
params.addParam<MultiMooseEnum>("execute_on",
Output::getExecuteOptions("initial timestep_end"),
"Set to "
"(none|initial|linear|nonlinear|timestep_end|timestep_begin|"
"final|failed|custom) to execute only at that moment");
// Add ability to append to the 'execute_on' list
params.addParam<MultiMooseEnum>("additional_execute_on",
Output::getExecuteOptions(),
"This list of output flags is added to the existing flags "
"(initial|linear|nonlinear|timestep_end|timestep_begin|final|"
"failed|custom) to execute only at that moment");
// 'Timing' group
params.addParamNamesToGroup("time_tolerance interval sync_times sync_only start_time end_time ",
"Timing");
// Add a private parameter for indicating if it was created with short-cut syntax
params.addPrivateParam<bool>("_built_by_moose", false);
// Register this class as base class
params.declareControllable("enable");
params.registerBase("Output");
return params;
}
InputParameters
validParams<NSNoPenetrationBC>()
{
InputParameters params = validParams<MooseObject>();
params.addClassDescription(
"This class facilitates adding solid wall 'no penetration' BCs for the Euler equations.");
params.addRequiredParam<std::vector<BoundaryName>>(
"boundary", "The list of boundary IDs from the mesh where this boundary condition applies");
params.addRequiredParam<UserObjectName>("fluid_properties",
"The name of the user object for fluid properties");
// Must be called from every base MOOSE system to create linkage with the Action system.
params.registerBase("NSNoPenetrationBC");
return params;
}
