InputParameters validParams<AuxScalarKernel>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<SetupInterface>();
params += validParams<MeshChangedInterface>();
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<Material>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<BlockRestrictable>();
params += validParams<BoundaryRestrictable>();
params += validParams<TransientInterface>();
params += validParams<RandomInterface>();
params += validParams<MaterialPropertyInterface>();
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.addParam<bool>("compute", true, "When false MOOSE will not call compute methods on this material, compute then must be called retrieving the Material object via MaterialPropertyInterface::getMaterial and calling the computeProerties method.");
// Outputs
params += validParams<OutputInterface>();
params.set<std::vector<OutputName> >("outputs") = std::vector<OutputName>(1, "none");
params.addParam<std::vector<std::string> >("output_properties", "List of material properties, from this material, to output (outputs must also be defined to an output type)");
params.addParamNamesToGroup("outputs output_properties", "Outputs");
params.addParamNamesToGroup("use_displaced_mesh", "Advanced");
params.registerBase("Material");
return params;
}
InputParameters validParams<CreateExecutionerAction>()
{
InputParameters params = validParams<MooseObjectAction>();
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", true, "Use the residual norm computed *before* PresetBCs are imposed in relative convergence check");
CreateExecutionerAction::populateCommonExecutionerParams(params);
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<Checkpoint>()
{
// Get the parameters from the base classes
InputParameters params = validParams<BasicOutput<FileOutput> >();
// Typical checkpoint options
params.addParam<unsigned int>("num_files", 2, "Number of the restart files to save");
params.addParam<std::string>("suffix", "cp", "This will be appended to the file_base to create the directory name for checkpoint files.");
// Advanced settings
params.addParam<bool>("binary", true, "Toggle the output of binary files");
params.addParamNamesToGroup("binary", "Advanced");
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<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<VTKOutput>()
{
InputParameters params = validParams<OversampleOutput>();
params += Output::enableOutputTypes("nodal elemental");
// Set default padding to 3
params.set<unsigned int>("padding") = 3;
// Add binary toggle
params.addParam<bool>("binary", false, "Set VTKOutput files to output in binary format");
params.addParamNamesToGroup("binary", "Advanced");
return params;
}
InputParameters validParams<Transient>()
{
InputParameters params = validParams<Executioner>();
std::vector<Real> sync_times(1);
sync_times[0] = -std::numeric_limits<Real>::max();
MooseEnum schemes("implicit-euler, explicit-euler, crank-nicolson, bdf2, rk-2", "implicit-euler");
params.addParam<Real>("start_time", 0.0, "The start time of the simulation");
params.addParam<Real>("end_time", 1.0e30, "The end time of the simulation");
params.addParam<Real>("dt", 1., "The timestep size between solves");
params.addParam<Real>("dtmin", 2.0e-14, "The minimum timestep size in an adaptive run");
params.addParam<Real>("dtmax", 1.0e30, "The maximum timestep size in an adaptive run");
params.addParam<bool>("reset_dt", false, "Use when restarting a calculation to force a change in dt.");
params.addParam<unsigned int>("num_steps", std::numeric_limits<unsigned int>::max(), "The number of timesteps in a transient run");
params.addParam<int> ("n_startup_steps", 0, "The number of timesteps during startup");
params.addParam<bool>("trans_ss_check", false, "Whether or not to check for steady state conditions");
params.addParam<Real>("ss_check_tol", 1.0e-08,"Whenever the relative residual changes by less than this the solution will be considered to be at steady state.");
params.addParam<Real>("ss_tmin", 0.0, "Minimum number of timesteps to take before checking for steady state conditions.");
params.addParam<std::vector<Real> >("sync_times", sync_times, "A list of times that will be solved for provided they are within the simulation time");
params.addParam<Real>("predictor_scale", "The scale factor for the predictor (can range from 0 to 1)");
params.addParam<std::vector<std::string> >("time_periods", "The names of periods");
params.addParam<std::vector<Real> >("time_period_starts", "The start times of time periods");
params.addParam<std::vector<Real> >("time_period_ends", "The end times of time periods");
params.addParam<bool>("abort_on_solve_fail", false, "abort if solve not converged rather than cut timestep");
params.addParam<MooseEnum>("scheme", schemes, "Time integration scheme used.");
params.addParam<Real>("timestep_tolerance", 2.0e-14, "the tolerance setting for final timestep size and sync times");
params.addParam<bool>("use_multiapp_dt", false, "If true then the dt for the simulation will be chosen by the MultiApps. If false (the default) then the minimum over the master dt and the MultiApps is used");
params.addParamNamesToGroup("start_time dtmin dtmax n_startup_steps trans_ss_check ss_check_tol ss_tmin sync_times time_t time_dt growth_factor predictor_scale use_AB2 use_littlef abort_on_solve_fail output_to_file file_name estimate_time_error timestep_tolerance use_multiapp_dt", "Advanced");
params.addParamNamesToGroup("time_periods time_period_starts time_period_ends", "Time Periods");
params.addParam<bool>("verbose", false, "Print detailed diagnostics on timestep calculation");
return params;
}
InputParameters
validParams<Exodus>()
{
// Get the base class parameters
InputParameters params = validParams<OversampleOutput>();
params += AdvancedOutput::enableOutputTypes("nodal elemental scalar postprocessor input");
// 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 (enabled by default "
"when 'use_displace = true', otherwise defaults to false");
// Select problem dimension for mesh output
params.addDeprecatedParam<bool>("use_problem_dimension",
"Use the problem dimension to the mesh output. "
"Set to false when outputting lower dimensional "
"meshes embedded in a higher dimensional space.",
"Use 'output_dimension = problem_dimension' instead.");
MooseEnum output_dimension("default 1 2 3 problem_dimension", "default");
params.addParam<MooseEnum>(
"output_dimension", output_dimension, "The dimension of the output file");
params.addParamNamesToGroup("output_dimension", "Advanced");
// Set the default padding to 3
params.set<unsigned int>("padding") = 3;
// Add description for the Exodus class
params.addClassDescription("Object for output data in the Exodus II format");
// Flag for overwriting at each timestep
params.addParam<bool>("overwrite",
false,
"When true the latest timestep will overwrite the "
"existing file, so only a single timestep exists.");
// Set outputting of the input to be on by default
params.set<ExecFlagEnum>("execute_input_on") = EXEC_INITIAL;
// Flag for outputting discontinuous data to Exodus
params.addParam<bool>(
"discontinuous", false, "Enables discontinuous output format for Exodus files.");
// Return the InputParameters
return params;
}
InputParameters validParams<Checkpoint>()
{
// Get the parameters from the base classes
InputParameters params = validParams<FileOutput>();
params += Output::disableOutputTypes(); // Checkpoint acts like a honey badger, it does what it wants; disable individual controls
// Typical checkpoint options
params.addParam<unsigned int>("num_files", 2, "Number of the restart files to save");
params.addParam<std::string>("suffix", "cp", "This will be appended to the file_base to create the directory name for checkpoint files.");
// Advanced settings
params.addParam<bool>("binary", true, "Toggle the output of binary files");
params.addParamNamesToGroup("binary", "Advanced");
return params;
}
InputParameters validParams<UserObject>()
{
InputParameters params = validParams<MooseObject>();
// Add the SetupInterface parameter, 'execute_on', and set it to a default of 'timestep'
params += validParams<SetupInterface>();
params.set<std::vector<MooseEnum> >("execute_on")[0] = "timestep";
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("UserObject");
return params;
}
InputParameters
validParams<OutputInterface>()
{
InputParameters params = emptyInputParameters();
params.addParam<std::vector<OutputName>>("outputs",
"Vector of output names were you would like "
"to restrict the output of variables(s) "
"associated with this object");
params.addParamNamesToGroup("outputs", "Advanced");
std::set<std::string> reserved = {"all", "none"};
params.setReservedValues("outputs", reserved);
return params;
}
InputParameters
validParams<SubProblem>()
{
InputParameters params = validParams<Problem>();
params.addPrivateParam<MooseMesh *>("mesh");
params.addParam<bool>(
"default_ghosting",
false,
"Whether or not to use libMesh's default amount of algebraic and geometric ghosting");
params.addParamNamesToGroup("default_ghosting", "Advanced");
return params;
}
InputParameters validParams<GMVOutput>()
{
// Get the base class parameters
InputParameters params = validParams<BasicOutput<OversampleOutput> >();
// Advanced file options
params.addParam<bool>("binary", true, "Output the file in binary format");
params.addParamNamesToGroup("binary", "Advanced");
// Add description for the GMVOutput class
params.addClassDescription("Object for outputting data in the GMV format");
// Return the InputParameters
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");
params.declareControllable("enable");
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<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();
for ( ; it != AppFactory::instance().registeredObjectsEnd(); ++it)
app_types_strings << it->first << " ";
MooseEnum app_types_options(app_types_strings.str(), "", true);
params.addRequiredParam<MooseEnum>("app_type", app_types_options, "The type of application to build (applications not registered can be loaded with dynamic libraries.");
params.addParam<std::string>("library_path", "", "Path to search for dynamic libraries (please avoid committing absolute paths in addition to MOOSE_LIBRARY_PATH)");
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<DerivativeSumMaterial>()
{
InputParameters params = validParams<DerivativeFunctionMaterialBase>();
params.addClassDescription("Meta-material to sum up multiple derivative materials");
params.addParam<std::vector<std::string> >("sum_materials", "Base name of the free energy function (used to name the material properties)");
//params.addParam<bool>("third_derivatives", true, "Calculate third derivatoves of the free energy");
// All arguments of the free energies being summed
params.addRequiredCoupledVar("args", "Arguments of the free energy functions being summed - use vector coupling");
params.addCoupledVar("displacement_gradients", "Vector of displacement gradient variables (see Modules/PhaseField/DisplacementGradients action)");
// Advanced arguments to construct a sum of the form \f$ c+\gamma\sum_iF_i \f$
params.addParam<std::vector<Real> >("prefactor", "Prefactor to multiply the sum term with.");
params.addParam<Real>("constant", 0.0, "Constant to be added to the prefactor multiplied sum.");
params.addParamNamesToGroup("prefactor constant", "Advanced");
return params;
}
InputParameters
validParams<CopyNodalVarsAction>()
{
InputParameters params = validParams<Action>();
params.addParam<std::string>(
"initial_from_file_timestep",
"LATEST",
"Gives the timestep (or \"LATEST\") for which to read a solution from a file "
"for a given variable. (Default: LATEST)");
params.addParam<std::string>(
"initial_from_file_var",
"Gives the name of a variable for which to read an initial condition from a mesh file");
params.addParamNamesToGroup("initial_from_file_timestep initial_from_file_var",
"Initial From File");
return params;
}
InputParameters validParams<Tecplot>()
{
// Get the base class parameters
InputParameters params = validParams<BasicOutput<OversampleOutput> >();
// Add binary toggle
params.addParam<bool>("binary", false, "Set Tecplot files to output in binary format");
params.addParamNamesToGroup("binary", "Advanced");
// Add optional parameter to turn on appending to ASCII files
params.addParam<bool>("ascii_append", false, "If true, append to an existing ASCII file rather than creating a new file each time");
// Add description for the Tecplot class
params.addClassDescription("Object for outputting data in the Tecplot format");
// Return the InputParameters
return params;
}
InputParameters
validParams<RankTwoAux>()
{
InputParameters params = validParams<NodalPatchRecovery>();
params.addClassDescription("Access a component of a RankTwoTensor");
params.addRequiredParam<MaterialPropertyName>("rank_two_tensor",
"The rank two material tensor name");
params.addRequiredRangeCheckedParam<unsigned int>(
"index_i",
"index_i >= 0 & index_i <= 2",
"The index i of ij for the tensor to output (0, 1, 2)");
params.addRequiredRangeCheckedParam<unsigned int>(
"index_j",
"index_j >= 0 & index_j <= 2",
"The index j of ij for the tensor to output (0, 1, 2)");
params.addParam<unsigned int>("selected_qp", "Evaluate the tensor at this specific quadpoint");
params.addParamNamesToGroup("selected_qp", "Advanced");
return params;
}
InputParameters
validParams<Marker>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<BlockRestrictable>();
params += validParams<OutputInterface>();
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("Marker");
return params;
}
InputParameters validParams<DiracKernel>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<MaterialPropertyInterface>();
params.addRequiredParam<NonlinearVariableName>("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.declareControllable("enable");
params.registerBase("DiracKernel");
return params;
}
InputParameters validParams<OversampleOutput>()
{
// Get the parameters from the parent object
InputParameters params = validParams<FileOutput>();
params.addParam<unsigned int>("refinements", 0, "Number of uniform refinements for oversampling (refinement levels beyond any uniform refinements)");
params.addParam<Point>("position", "Set a positional offset, this vector will get added to the nodal coordinates to move the domain.");
params.addParam<MeshFileName>("file", "The name of the mesh file to read, for oversampling");
// **** DEPRECATED AND REMOVED PARAMETERS ****
params.addDeprecatedParam<bool>("oversample", false, "Set to true to enable oversampling",
"This parameter is no longer active, simply set 'refinements' to a value greater than zero to evoke oversampling");
params.addDeprecatedParam<bool>("append_oversample", false, "Append '_oversample' to the output file base",
"This parameter is no longer operational, to append '_oversample' utilize the output block name or 'file_base'");
// 'Oversampling' Group
params.addParamNamesToGroup("refinements position file", "Oversampling");
return params;
}
InputParameters validParams<AddVariableAction>()
{
// Get MooseEnums for the possible order/family options for this variable
MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
// Define the general input options
InputParameters params = validParams<Action>();
params.addParam<MooseEnum>("family", families, "Specifies the family of FE shape functions to use for this variable");
params.addParam<MooseEnum>("order", orders, "Specifies the order of the FE shape function to use for this variable (additional orders not listed are allowed)");
params.addParam<Real>("initial_condition", 0.0, "Specifies the initial condition for this variable");
params.addParam<std::vector<SubdomainName> >("block", "The block id where this variable lives");
params.addParam<bool>("eigen", false, "True to make this variable an eigen variable");
// Advanced input options
params.addParam<Real>("scaling", 1.0, "Specifies a scaling factor to apply to this variable");
params.addParamNamesToGroup("scaling", "Advanced");
return params;
}
InputParameters
validParams<VectorPostprocessor>()
{
InputParameters params = validParams<UserObject>();
params += validParams<OutputInterface>();
params.addParam<bool>("contains_complete_history",
false,
"Set this flag to indicate that the values in all vectors declared by this "
"VPP represent a time history (e.g. with each invocation, new values are "
"added and old values are never removed). This changes the output so that "
"only a single file is output and updated with each invocation");
// VPPs can set this to true if their resulting vectors are naturally replicated in parallel
// setting this to true will keep MOOSE from unnecesarily broadcasting those vectors
params.addPrivateParam<bool>("_is_broadcast", false);
params.addParamNamesToGroup("outputs", "Advanced");
params.registerBase("VectorPostprocessor");
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 'output_on' input parameter for users to set
params.addParam<MultiMooseEnum>("output_on", Output::getExecuteOptions("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 'output_on' list
params.addParam<MultiMooseEnum>("additional_output_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 output_initial output_final sync_times sync_only start_time end_time ", "Timing");
// Output toggles
params.addParam<bool>("output_initial", false, "Request that the initial condition is output to the solution file");
params.addParam<bool>("output_timestep_end", true, "Request that data be output at the end of the timestep");
params.addParam<bool>("output_final", false, "Force the final time step to be output, regardless of output interval");
params.addParam<bool>("output_failed", false, "When true all time attempted time steps are output");
// **** DEPRECATED PARAMETERS ****
params.addDeprecatedParam<bool>("output_intermediate", true, "Request that all intermediate steps (not initial or final) are output", "Replace this output with 'output_timestep_end'");
// 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<NodalKernel>()
{
InputParameters params = validParams<MooseObject>();
params += validParams<TransientInterface>();
params += validParams<BlockRestrictable>();
params += validParams<RandomInterface>();
params.addRequiredParam<NonlinearVariableName>("variable", "The name of the variable that this boundary condition applies to");
params.addParam<std::vector<AuxVariableName> >("save_in", "The name of auxiliary variables to save this BC's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)");
params.addParam<std::vector<AuxVariableName> >("diag_save_in", "The name of auxiliary variables to save this BC's diagonal jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)");
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("NodalKernel");
return params;
}
InputParameters validParams<VTKOutput>()
{
InputParameters params = validParams<OversampleOutput>();
// Supress un-available parameters
params.suppressParameter<bool>("output_scalar_variables");
params.suppressParameter<bool>("output_postprocessors");
params.suppressParameter<bool>("output_vector_postprocessors");
params.suppressParameter<bool>("scalar_as_nodal");
params.suppressParameter<bool>("sequence");
params.suppressParameter<bool>("output_input");
// Set default padding to 3
params.set<unsigned int>("padding") = 3;
// Add binary toggle
params.addParam<bool>("binary", false, "Set VTKOutput files to output in binary format");
params.addParamNamesToGroup("binary", "Advanced");
return params;
}
InputParameters validParams<FeatureFloodCount>()
{
InputParameters params = validParams<GeneralPostprocessor>();
params.addRequiredCoupledVar("variable", "The variable(s) for which to find connected regions of interests, i.e. \"features\".");
params.addParam<Real>("threshold", 0.5, "The threshold value for which a new feature may be started");
params.addParam<Real>("connecting_threshold", "The threshold for which an existing feature may be extended (defaults to \"threshold\")");
params.addParam<bool>("use_single_map", true, "Determine whether information is tracked per coupled variable or consolidated into one (default: true)");
params.addParam<bool>("condense_map_info", false, "Determines whether we condense all the node values when in multimap mode (default: false)");
params.addParam<bool>("use_global_numbering", true, "Determine whether or not global numbers are used to label features on multiple maps (default: true)");
params.addParam<bool>("enable_var_coloring", false, "Instruct the Postprocessor to populate the variable index map.");
params.addParam<bool>("compute_halo_maps", false, "Instruct the Postprocessor to communicate proper halo information to all ranks");
params.addParam<bool>("compute_var_to_feature_map", false, "Instruct the Postprocessor to compute the active vars to features map");
params.addParam<bool>("use_less_than_threshold_comparison", true, "Controls whether features are defined to be less than or greater than the threshold value.");
params.set<bool>("use_displaced_mesh") = true;
params.addParamNamesToGroup("use_single_map condense_map_info use_global_numbering", "Advanced");
MooseEnum flood_type("NODAL ELEMENTAL", "ELEMENTAL");
params.addParam<MooseEnum>("flood_entity_type", flood_type, "Determines whether the flood algorithm runs on nodes or elements");
return params;
}