InputParameters
validParams<NSMomentumInviscidSpecifiedNormalFlowBC>()
{
InputParameters params = validParams<NSMomentumInviscidBC>();
params.addClassDescription("Momentum equation boundary condition in which pressure is specified "
"(given) and the value of the convective part is allowed to vary (is "
"computed implicitly).");
params.addRequiredCoupledVar(NS::pressure, "pressure");
params.addRequiredParam<Real>(
"rhou_udotn", "The _component'th entry of the (rho*u)(u.n) vector for this boundary");
return params;
}
InputParameters
validParams<RigidBodyModesRZ>()
{
InputParameters params = validParams<NodalUserObject>();
params.addRequiredParam<std::vector<unsigned int>>(
"subspace_name", "FEProblemBase subspace containing RZ rigid body modes");
params.addRequiredParam<std::vector<unsigned int>>(
"subspace_indices", "Indices of FEProblemBase subspace vectors containg rigid body modes");
params.addRequiredCoupledVar("disp_r", "r-displacement");
params.addRequiredCoupledVar("disp_z", "z-displacement");
return params;
}
InputParameters validParams<NSMomentumInviscidFluxWithGradP>()
{
InputParameters params = validParams<NSKernel>();
// Coupled variables
params.addRequiredCoupledVar("pressure", "");
// Required parameters
params.addRequiredParam<Real>("component", "");
return params;
}
InputParameters validParams<INSChorinPredictor>()
{
InputParameters params = validParams<Kernel>();
// Coupled variables
params.addRequiredCoupledVar("u", "x-velocity");
params.addCoupledVar("v", "y-velocity"); // only required in 2D and 3D
params.addCoupledVar("w", "z-velocity"); // only required in 3D
// Make star also be required, even though we might not use it?
params.addRequiredCoupledVar("u_star", "star x-velocity");
params.addCoupledVar("v_star", "star y-velocity"); // only required in 2D and 3D
params.addCoupledVar("w_star", "star z-velocity"); // only required in 3D
// Required parameters
params.addRequiredParam<Real>("mu", "dynamic viscosity");
params.addRequiredParam<Real>("rho", "density");
params.addRequiredParam<unsigned>("component", "0,1,2 depending on if we are solving the x,y,z component of the Predictor equation");
params.addRequiredParam<std::string>("predictor_type", "One of: OLD, NEW, STAR. Indicates which velocity to use in the predictor.");
return params;
}
InputParameters validParams<NSMomentumInviscidFlux>()
{
InputParameters params = validParams<NSKernel>();
// Coupled variables
params.addRequiredCoupledVar("pressure", "");
// Required parameters
params.addRequiredParam<unsigned>("component", "0,1,2 depending on if we are solving the x,y,z component of the momentum equation");
return params;
}
InputParameters validParams<KKSCHBulk>()
{
InputParameters params = validParams<CHBulk>();
params.addClassDescription("KKS model kernel for the Bulk Cahn-Hilliard term. This operates on the concentration 'c' as the non-linear variable");
params.addRequiredParam<MaterialPropertyName>("fa_name", "Base name of the free energy function F (f_name in the corresponding derivative function material)");
params.addRequiredParam<MaterialPropertyName>("fb_name", "Base name of the free energy function F (f_name in the corresponding derivative function material)");
params.addRequiredCoupledVar("ca", "phase concentration corresponding to the non-linear variable of this kernel");
params.addRequiredCoupledVar("cb", "phase concentration corresponding to the non-linear variable of this kernel");
params.addCoupledVar("args_a", "Vector of additional arguments to Fa");
params.addParam<MaterialPropertyName>("h_name", "h", "Base name for the switching function h(eta)"); // TODO: everywhere else this is called just "h"
return params;
}
InputParameters
validParams<VectorMagnitudeAux>()
{
InputParameters params = validParams<AuxKernel>();
params.addClassDescription("Creates a field representing the magnitude of three coupled "
"variables using an Euclidean norm.");
params.addRequiredCoupledVar("x", "x-component of the vector");
params.addCoupledVar("y", "y-component of the vector");
params.addCoupledVar("z", "z-component of the vector");
return params;
}
InputParameters validParams<ComputeStrainBase>()
{
InputParameters params = validParams<Material>();
params.addRequiredCoupledVar("displacements", "The displacements appropriate for the simulation geometry and coordinate system");
params.addParam<std::string>("base_name", "Optional parameter that allows the user to define multiple mechanics material systems on the same block, i.e. for multiple phases");
params.addPrivateParam<bool>("stateful_displacements", false);
params.addParam<Real>("temperature_ref", 273, "Deprecated: Reference temperature for thermal expansion in K");
params.addCoupledVar("temperature", 273, "Decprecated: Temperature in Kelvin");
params.addParam<Real>("thermal_expansion_coeff", 0, "Deprecated: Thermal expansion coefficient in 1/K");
params.addParam<bool>("volumetric_locking_correction", true, "Flag to correct volumetric locking");
return params;
}
InputParameters validParams<INSSplitMomentum>()
{
InputParameters params = validParams<Kernel>();
// Coupled variables
params.addRequiredCoupledVar("u", "x-velocity");
params.addCoupledVar("v", "y-velocity"); // only required in 2D and 3D
params.addCoupledVar("w", "z-velocity"); // only required in 3D
params.addRequiredCoupledVar("a1", "x-acceleration");
params.addCoupledVar("a2", "y-acceleration"); // only required in 2D and 3D
params.addCoupledVar("a3", "z-acceleration"); // only required in 3D
// Required parameters
params.addRequiredParam<Real>("mu", "dynamic viscosity");
params.addRequiredParam<Real>("rho", "density");
params.addRequiredParam<RealVectorValue>("gravity", "Direction of the gravity vector");
params.addRequiredParam<unsigned>("component", "0,1,2 depending on if we are solving the x,y,z component of the momentum equation");
return params;
}
InputParameters
validParams<AdvectionBC>()
{
InputParameters params = validParams<IntegratedBC>();
params.addClassDescription("Boundary conditions for outflow/outflow of advected quantities:"
"\n phi * velocity * normal, where phi is the advected quantitiy");
params.addParam<bool>(
"outflow", true, "Determines if this BC is applied on inflow or outflow BCs");
params.addRequiredCoupledVar("velocity_vector",
"The components of the velocity vector up to problem dimension");
return params;
}
InputParameters validParams<NSEnergyInviscidSpecifiedNormalFlowBC>()
{
InputParameters params = validParams<NSEnergyInviscidBC>();
// Coupled variables
params.addRequiredCoupledVar("pressure", "");
// Required parameters
params.addRequiredParam<Real>("un", "The specified value of u.n for this boundary");
return params;
}
InputParameters
validParams<InterfaceOrientationMaterial>()
{
InputParameters params = validParams<Material>();
params.addParam<Real>(
"anisotropy_strength", 0.04, "Strength of the anisotropy (typically < 0.05)");
params.addParam<unsigned int>("mode_number", 6, "Mode number for anisotropy");
params.addParam<Real>("reference_angle", 90, "Reference angle for defining anistropy in degrees");
params.addParam<Real>("eps_bar", 0.01, "Average value of the interface parameter epsilon");
params.addRequiredCoupledVar("op", "Order parameter defining the solid phase");
return params;
}
InputParameters validParams<DiscreteNucleation>()
{
InputParameters params = validParams<DerivativeFunctionMaterialBase>();
params.addClassDescription("Free energy contribution for nucleating discrete particles");
params.addRequiredCoupledVar("op_names", "List of variables to force to a target concentration value");
params.addRequiredParam<UserObjectName>("map", "DiscreteNucleationMap user object");
params.addRequiredParam<std::vector<Real> >("op_values", "List of target concentration values");
params.addParam<Real>("penalty", 20.0, "Penalty factor for enforcing the target concentrations");
MooseEnum penalty_mode("MATCH MIN MAX", "MATCH");
params.addParam<MooseEnum>("penalty_mode", penalty_mode, "Match the target concentration or take it as a minimum or maximum concentration target");
return params;
}
InputParameters
validParams<NearestNodeValueAux>()
{
InputParameters params = validParams<AuxKernel>();
params.addClassDescription("Retrieves a field value from the closest node on the paired boundary "
"and stores it on this boundary or block.");
params.set<bool>("_dual_restrictable") = true;
params.addRequiredParam<BoundaryName>("paired_boundary", "The boundary to get the value from.");
params.addRequiredCoupledVar("paired_variable", "The variable to get the value of.");
params.set<bool>("use_displaced_mesh") = true;
return params;
}
InputParameters
validParams<ExampleShapeSideIntegratedBC>()
{
InputParameters params = validParams<NonlocalIntegratedBC>();
params.addRequiredParam<UserObjectName>(
"num_user_object", "ShapeSideUserObject for computing integral component in numerator.");
params.addRequiredParam<UserObjectName>(
"denom_user_object", "ShapeSideUserObject for computing integral component in denominator.");
params.addRequiredCoupledVar("v", "Charge species.");
params.addRequiredParam<Real>("Vb", "Initial potential applied to the boundary.");
return params;
}
InputParameters
validParams<PorousFlow1PhaseP>()
{
InputParameters params = validParams<PorousFlowVariableBase>();
params.addRequiredCoupledVar("porepressure",
"Variable that represents the porepressure of the single phase");
params.addParam<UserObjectName>("capillary_pressure",
"Name of the UserObject defining the capillary pressure");
params.addClassDescription("This Material is used for the fully saturated single-phase situation "
"where porepressure is the primary variable");
return params;
}
InputParameters validParams<NSMomentumInviscidSpecifiedNormalFlowBC>()
{
InputParameters params = validParams<NSMomentumInviscidBC>();
// Coupled variables
params.addRequiredCoupledVar("pressure", "");
// Required parameters
params.addRequiredParam<Real>("rhou_udotn", "The _component'th entry of the (rho*u)(u.n) vector for this boundary");
return params;
}
InputParameters
validParams<AEFVKernel>()
{
InputParameters params = validParams<DGKernel>();
params.addClassDescription(
"A dgkernel for the advection equation using a cell-centered finite volume method.");
MooseEnum component("concentration");
params.addParam<MooseEnum>("component", component, "Choose one of the equations");
params.addRequiredCoupledVar("u", "Name of the variable to use");
params.addRequiredParam<UserObjectName>("flux", "Name of the internal side flux object to use");
return params;
}
InputParameters
validParams<SwitchingFunctionConstraintEta>()
{
InputParameters params = validParams<Kernel>();
params.addClassDescription("Lagrange multiplier kernel to constrain the sum of all switching "
"functions in a multiphase system. This kernel acts on a "
"non-conserved order parameter eta_i.");
params.addParam<MaterialPropertyName>("h_name",
"Switching Function Materials that provides h(eta_i)");
params.addRequiredCoupledVar("lambda", "Lagrange multiplier");
return params;
}
InputParameters validParams<NSIntegratedBC>()
{
InputParameters params = validParams<IntegratedBC>();
// Coupled variables
params.addRequiredCoupledVar("u", "");
params.addRequiredCoupledVar("v", "");
params.addCoupledVar("w", ""); // only required in 3D
params.addRequiredCoupledVar("rho", "density");
params.addRequiredCoupledVar("rhou", "x-momentum");
params.addRequiredCoupledVar("rhov", "y-momentum");
params.addCoupledVar("rhow", "z-momentum"); // only required in 3D
params.addRequiredCoupledVar("rhoe", "energy");
// Required parameters
params.addRequiredParam<Real>("gamma", "Ratio of specific heats.");
params.addRequiredParam<Real>("R", "Gas constant.");
return params;
}
InputParameters
validParams<SideValueSampler>()
{
InputParameters params = validParams<SideVectorPostprocessor>();
params += validParams<SamplerBase>();
params.addRequiredCoupledVar(
"variable", "The names of the variables that this VectorPostprocessor operates on");
return params;
}
InputParameters validParams<PressureBasedViscosityCoefficient>()
{
InputParameters params = validParams<Material>();
// Pressure-based viscosity type
params.addParam<std::string>("pressure_based_visc_type", "JST", "Name of the pressure-based viscosity to use.");
// Coupled variable
params.addRequiredCoupledVar("h", "high/density");
params.addRequiredCoupledVar("hu", "x component of h*vec{u}");
params.addCoupledVar("hv", "y component of h*vec{u}");
params.addRequiredCoupledVar("press_laplace", "variable computing the laplace of pressure");
// Coupled aux variable
params.addRequiredCoupledVar("pressure", "pressure");
params.addRequiredCoupledVar("norm_velocity", "norm of the velocity");
// Pressure based parameter
params.addParam<Real>("Ce", 1., "Constant that multiplies the viscosity coefficient");
// Equation of state
params.addRequiredParam<UserObjectName>("eos", "Equation of state");
return params;
}
InputParameters
validParams<ScalarTagMatrixAux>()
{
InputParameters params = validParams<AuxScalarKernel>();
params.addParam<std::string>("matrix_tag", "TagName", "Tag Name this Aux works on");
params.addRequiredCoupledVar("v",
"The coupled variable whose components are coupled to AuxVariable");
params.addClassDescription("Couple a tag matrix, and return its nodal value");
return params;
}
InputParameters validParams<PFFracBulkRate>()
{
InputParameters params = validParams<KernelValue>();
params.addRequiredParam<Real>("l","Interface width");
params.addRequiredParam<Real>("visco","Viscosity parameter");
params.addRequiredCoupledVar("beta", "Auxiliary variable");
params.addCoupledVar("disp_x", "The x displacement");
params.addCoupledVar("disp_y", "The y displacement");
params.addCoupledVar("disp_z", "The z displacement");
return params;
}
InputParameters
validParams<AdvectiveFluxCalculatorConstantVelocity>()
{
InputParameters params = validParams<AdvectiveFluxCalculatorBase>();
params.addClassDescription(
"Compute K_ij (a measure of advective flux from node i to node j) "
"and R+ and R- (which quantify amount of antidiffusion to add) in the "
"Kuzmin-Turek FEM-TVD multidimensional scheme. Constant advective velocity is assumed");
params.addRequiredCoupledVar("u", "The variable that is being advected");
params.addRequiredParam<RealVectorValue>("velocity", "Velocity vector");
return params;
}
InputParameters
validParams<CoupledDirectionalMeshHeightInterpolation>()
{
InputParameters params = validParams<AuxKernel>();
params.addRequiredCoupledVar("coupled_var",
"The variable whose values are going to be interpolated.");
MooseEnum directions("x y z");
params.addRequiredParam<MooseEnum>("direction", directions, "The direction to interpolate in.");
return params;
}
InputParameters validParams<EelCMethod>()
{
InputParameters params = validParams<Kernel>();
// Coupled aux variables:
params.addRequiredCoupledVar("pressure", "pressure");
// Parameter for diffusion term:
params.addParam<double>("kappa", 1., "Parameter for diffusion term: kappa.");
// name of the pps computing max of eigenvalues:
params.addRequiredParam<std::string>("max_eig_pps", "pps computing the max of eigenvalues.");
params.addRequiredParam<std::string>("max_grad_pps", "pps computing the max of ||grad(P)||.");
return params;
}
InputParameters
validParams<Q2PPiecewiseLinearSink>()
{
InputParameters params = validParams<IntegratedBC>();
params.addRequiredParam<bool>(
"use_mobility",
"If true, then fluxes are multiplied by (density*permeability_nn/viscosity), "
"where the '_nn' indicates the component normal to the boundary. In this "
"case bare_flux is measured in Pa.s^-1. This can be used in conjunction "
"with use_relperm.");
params.addRequiredParam<bool>("use_relperm",
"If true, then fluxes are multiplied by relative "
"permeability. This can be used in conjunction "
"with use_mobility");
params.addRequiredParam<std::vector<Real>>(
"pressures", "Tuple of pressure values. Must be monotonically increasing.");
params.addRequiredParam<std::vector<Real>>(
"bare_fluxes",
"Tuple of flux values (measured in kg.m^-2.s^-1 for use_mobility=false, and "
"in Pa.s^-1 if use_mobility=true). This flux is OUT of the medium: hence "
"positive values of flux means this will be a SINK, while negative values "
"indicate this flux will be a SOURCE. A piecewise-linear fit is performed to "
"the (pressure,bare_fluxes) pairs to obtain the flux at any arbitrary "
"pressure, and the first or last bare_flux values are used if the quad-point "
"pressure falls outside this range.");
params.addParam<FunctionName>("multiplying_fcn",
1.0,
"If this function is provided, the flux "
"will be multiplied by this function. "
"This is useful for spatially or "
"temporally varying sinks");
params.addRequiredParam<UserObjectName>(
"fluid_density",
"A RichardsDensity UserObject that defines the fluid density as a function of pressure.");
params.addRequiredParam<UserObjectName>(
"fluid_relperm",
"A RichardsRelPerm UserObject (eg RichardsRelPermPower) that defines the "
"fluid relative permeability as a function of the saturation Variable.");
params.addRequiredCoupledVar("other_var",
"The other variable in the 2-phase system. If "
"Variable=porepressure, the other_var=saturation, and "
"vice-versa.");
params.addRequiredParam<bool>("var_is_porepressure",
"This flag is needed to correctly calculate the Jacobian entries. "
"If set to true, this Sink will extract fluid from the phase with "
"porepressure as its Variable (usually the liquid phase). If set "
"to false, this Sink will extract fluid from the phase with "
"saturation as its variable (usually the gas phase)");
params.addRequiredParam<Real>("fluid_viscosity", "The fluid dynamic viscosity");
params.addClassDescription("Sink of fluid, controlled by (pressure, bare_fluxes) interpolation. "
"This is for use in Q2P models");
return params;
}
InputParameters validParams<ComputeViscCoeff>()
{
InputParameters params = validParams<Material>();
// Viscosity type:
params.addParam<std::string>("viscosity_name", "FIRST_ORDER", "Name of the viscosity definition to use: set to FIRST_ORDER by default.");
params.addParam<std::string>("function_of_mach", "MACH", "Name of the Mach function to use.");
// Boolean for phase:
params.addParam<bool>("isLiquid", true, "the phase is liquid or not.");
params.addParam<bool>("isJumpOn", true, "use jump or gradients.");
// Bool for viscosity coefficient of void fraction equation:
params.addParam<bool>("isShock", false, "employ definition of the viscosity coefficient for weak shock.");
params.addParam<bool>("areViscEqual", false, "the viscosity coefficients are equal in the shock region.");
// Aux variables:
params.addRequiredCoupledVar("velocity_x", "x component of the velocity");
params.addCoupledVar("velocity_y", "y component of the velocity");
params.addCoupledVar("velocity_z", "z component of the velocity");
params.addRequiredCoupledVar("pressure", "pressure of the fluid");
params.addRequiredCoupledVar("density", "density of the fluid: rho");
params.addCoupledVar("vf_liquid", "liquid void fraction.");
params.addCoupledVar("area", 1., "area, cross-section.");
// Jumps:
params.addCoupledVar("jump_grad_press", "jump of pressure gradient");
params.addCoupledVar("jump_grad_dens", "jump of density gradient");
params.addCoupledVar("jump_grad_alpha", "jump of alpha gradient");
// Constant parameter:
params.addParam<double>("Cmax", 0.5, "Coefficient for first-order viscosity");
params.addParam<double>("Ce", 1., "Coefficient for residual");
params.addParam<double>("Cjump_liquid", 1., "Coefficient for jump for liquid phase");
params.addParam<double>("Cjump_gas", 1., "Coefficient for jump for gas phase");
params.addParam<double>("Calpha", 1., "Coefficient for alpha");
// Coefficients for 'sigma' function:
params.addParam<Real>("a_coeff", 4., "Coefficient for sigma function");
params.addParam<Real>("Mthres", 0.005, "Threshold Mach number");
// Userobject:
params.addRequiredParam<UserObjectName>("eos", "Equation of state");
// PPS names:
params.addParam<std::string>("rhov2_PPS_name", "name of the pps computing rho*vel*vel");
params.addRequiredParam<std::string>("alpha_PPS_name", "name of the pps for alpha");
return params;
}
InputParameters
validParams<INSDivergenceAux>()
{
InputParameters params = validParams<AuxKernel>();
params.addClassDescription("Computes h_min / |u|.");
// Coupled variables
params.addRequiredCoupledVar("u", "x-velocity");
params.addCoupledVar("v", "y-velocity"); // only required in 2D and 3D
params.addCoupledVar("w", "z-velocity"); // only required in 3D
return params;
}
