InputParameters validParams<GluedContactConstraint>()
{
MooseEnum orders("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<SparsityBasedContactConstraint>();
params.addRequiredParam<BoundaryName>("boundary", "The master boundary");
params.addRequiredParam<BoundaryName>("slave", "The slave boundary");
params.addRequiredParam<unsigned int>("component", "An integer corresponding to the direction the variable this kernel acts in. (0 for x, 1 for y, 2 for z)");
params.addCoupledVar("disp_x", "The x displacement");
params.addCoupledVar("disp_y", "The y displacement");
params.addCoupledVar("disp_z", "The z displacement");
params.addRequiredCoupledVar("nodal_area", "The nodal area");
params.addParam<std::string>("model", "frictionless", "The contact model to use");
params.set<bool>("use_displaced_mesh") = true;
params.addParam<Real>("penalty", 1e8, "The penalty to apply. This can vary depending on the stiffness of your materials");
params.addParam<Real>("friction_coefficient", 0, "The friction coefficient");
params.addParam<Real>("tangential_tolerance", "Tangential distance to extend edges of contact surfaces");
params.addParam<Real>("normal_smoothing_distance", "Distance from edge in parametric coordinates over which to smooth contact normal");
params.addParam<std::string>("normal_smoothing_method","Method to use to smooth normals (edge_based|nodal_normal_based)");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.addParam<Real>("tension_release", 0.0, "Tension release threshold. A node in contact will not be released if its tensile load is below this value. Must be positive.");
params.addParam<std::string>("formulation", "default", "The contact formulation");
return params;
}
InputParameters validParams<ContactAction>()
{
MooseEnum orders("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST");
MooseEnum formulation("DEFAULT KINEMATIC PENALTY AUGMENTED_LAGRANGE", "DEFAULT");
MooseEnum system("DiracKernel Constraint", "DiracKernel");
InputParameters params = validParams<Action>();
params.addRequiredParam<BoundaryName>("master", "The master surface");
params.addRequiredParam<BoundaryName>("slave", "The slave surface");
params.addRequiredParam<NonlinearVariableName>("disp_x", "The x displacement");
params.addParam<NonlinearVariableName>("disp_y", "", "The y displacement");
params.addParam<NonlinearVariableName>("disp_z", "", "The z displacement");
params.addParam<Real>("penalty", 1e8, "The penalty to apply. This can vary depending on the stiffness of your materials");
params.addParam<Real>("friction_coefficient", 0, "The friction coefficient");
params.addParam<Real>("tension_release", 0.0, "Tension release threshold. A node in contact will not be released if its tensile load is below this value. No tension release if negative.");
params.addParam<std::string>("model", "frictionless", "The contact model to use");
params.addParam<Real>("tangential_tolerance", "Tangential distance to extend edges of contact surfaces");
params.addParam<Real>("capture_tolerance", 0, "Normal distance from surface within which nodes are captured");
params.addParam<Real>("normal_smoothing_distance", "Distance from edge in parametric coordinates over which to smooth contact normal");
params.addParam<std::string>("normal_smoothing_method","Method to use to smooth normals (edge_based|nodal_normal_based)");
params.addParam<MooseEnum>("order", orders, "The finite element order: FIRST, SECOND, etc.");
params.addParam<MooseEnum>("formulation", formulation, "The contact formulation: default, penalty, augmented_lagrange");
params.addParam<MooseEnum>("system", system, "System to use for constraint enforcement. Options are: " + system.getRawNames());
return params;
}
InputParameters validParams<GapConductance>()
{
MooseEnum orders("FIRST, SECOND, THIRD, FOURTH", "FIRST");
InputParameters params = validParams<Material>();
params.addParam<std::string>("appended_property_name", "", "Name appended to material properties to make them unique");
params.addRequiredCoupledVar("variable", "Temperature variable");
// Node based
params.addCoupledVar("gap_distance", "Distance across the gap");
params.addCoupledVar("gap_temp", "Temperature on the other side of the gap");
params.addParam<Real>("gap_conductivity", 1.0, "The thermal conductivity of the gap material");
params.addParam<FunctionName>("gap_conductivity_function", "Thermal conductivity of the gap material as a function. Multiplied by gap_conductivity.");
params.addCoupledVar("gap_conductivity_function_variable", "Variable to be used in the gap_conductivity_function in place of time");
// Quadrature based
params.addParam<bool>("quadrature", false, "Whether or not to do quadrature point based gap heat transfer. If this is true then gap_distance and gap_temp should NOT be provided (and will be ignored); however, paired_boundary and variable are then required.");
params.addParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.addParam<bool>("warnings", false, "Whether to output warning messages concerning nodes not being found");
// Common
params.addParam<Real>("min_gap", 1e-6, "A minimum gap size");
params.addParam<Real>("max_gap", 1e6, "A maximum gap size");
params.addParam<Real>("stefan_boltzmann", 5.669e-8, "The Stefan-Boltzmann constant");
params.addParam<Real>("emissivity_1", 0.0, "The emissivity of the fuel surface");
params.addParam<Real>("emissivity_2", 0.0, "The emissivity of the cladding surface");
params.addParam<bool>("use_displaced_mesh", true, "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.");
return params;
}
InputParameters
validParams<ConservedAction>()
{
InputParameters params = validParams<Action>();
params.addClassDescription(
"Set up the variable(s) and the kernels needed for a conserved phase field variable."
" Note that for a direct solve, the element family and order are overwritten with hermite "
"and third.");
MooseEnum solves("DIRECT REVERSE_SPLIT FORWARD_SPLIT");
params.addRequiredParam<MooseEnum>("solve_type", solves, "Split or direct solve?");
// Get MooseEnums for the possible order/family options for this variable
MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
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");
params.addParam<Real>("scaling", 1.0, "Specifies a scaling factor to apply to this variable");
params.addParam<bool>("implicit", true, "Whether kernels are implicit or not");
params.addParam<bool>(
"use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
params.addParamNamesToGroup("scaling implicit use_displaced_mesh", "Advanced");
params.addRequiredParam<MaterialPropertyName>("mobility", "The mobility used with the kernel");
params.addParam<std::vector<VariableName>>("args",
"Vector of variable arguments this kernel depends on");
params.addRequiredParam<MaterialPropertyName>(
"free_energy", "Base name of the free energy function F defined in a free energy material");
params.addRequiredParam<MaterialPropertyName>("kappa", "The kappa used with the kernel");
return params;
}
InputParameters validParams<GapHeatTransfer>()
{
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<IntegratedBC>();
params.addParam<std::string>("appended_property_name", "", "Name appended to material properties to make them unique");
// Common
params.addParam<Real>("min_gap", 1.0e-6, "A minimum gap size");
params.addParam<Real>("max_gap", 1.0e6, "A maximum gap size");
MooseEnum coord_types("default XYZ", "default");
params.addParam<MooseEnum>("coord_type", coord_types, "Gap calculation type (default or XYZ).");
// Quadrature based
params.addParam<bool>("quadrature", false, "Whether or not to do Quadrature point based gap heat transfer. If this is true then gap_distance and gap_temp should NOT be provided (and will be ignored) however paired_boundary IS then required.");
params.addParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.addParam<bool>("warnings", false, "Whether to output warning messages concerning nodes not being found");
// Node based options
params.addCoupledVar("gap_distance", "Distance across the gap");
params.addCoupledVar("gap_temp", "Temperature on the other side of the gap");
return params;
}
InputParameters validParams<MechanicalContactConstraint>()
{
MooseEnum orders("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<NodeFaceConstraint>();
params.addRequiredParam<BoundaryName>("boundary", "The master boundary");
params.addRequiredParam<BoundaryName>("slave", "The slave boundary");
params.addRequiredParam<unsigned int>("component", "An integer corresponding to the direction the variable this kernel acts in. (0 for x, 1 for y, 2 for z)");
params.addCoupledVar("disp_x", "The x displacement");
params.addCoupledVar("disp_y", "The y displacement");
params.addCoupledVar("disp_z", "The z displacement");
params.addRequiredCoupledVar("nodal_area", "The nodal area");
params.addParam<std::string>("model", "frictionless", "The contact model to use");
params.set<bool>("use_displaced_mesh") = true;
params.addParam<Real>("penalty", 1e8, "The penalty to apply. This can vary depending on the stiffness of your materials");
params.addParam<Real>("friction_coefficient", 0, "The friction coefficient");
params.addParam<Real>("tangential_tolerance", "Tangential distance to extend edges of contact surfaces");
params.addParam<Real>("capture_tolerance", 0, "Normal distance from surface within which nodes are captured");
params.addParam<Real>("normal_smoothing_distance", "Distance from edge in parametric coordinates over which to smooth contact normal");
params.addParam<std::string>("normal_smoothing_method","Method to use to smooth normals (edge_based|nodal_normal_based)");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.addParam<Real>("tension_release", 0.0, "Tension release threshold. A node in contact will not be released if its tensile load is below this value. No tension release if negative.");
params.addParam<std::string>("formulation", "default", "The contact formulation");
params.addParam<bool>("normalize_penalty", false, "Whether to normalize the penalty parameter with the nodal area for penalty contact.");
params.addParam<bool>("master_slave_jacobian", true, "Whether to include jacobian entries coupling master and slave nodes.");
params.addParam<bool>("connected_slave_nodes_jacobian", true, "Whether to include jacobian entries coupling nodes connected to slave nodes.");
params.addParam<bool>("non_displacement_variables_jacobian", true, "Whether to include jacobian entries coupling with variables that are not displacement variables.");
return params;
}
InputParameters validParams<GapHeatTransfer>()
{
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<IntegratedBC>();
params.addParam<std::string>("appended_property_name", "", "Name appended to material properties to make them unique");
// Common
params.addParam<Real>("min_gap", 1.0e-6, "A minimum gap size");
params.addParam<Real>("max_gap", 1.0e6, "A maximum gap size");
//Deprecated parameter
MooseEnum coord_types("default XYZ cyl", "default");
params.addDeprecatedParam<MooseEnum>("coord_type", coord_types, "Gap calculation type (default or XYZ).","The functionality of this parameter is replaced by 'gap_geometry_type'.");
MooseEnum gap_geom_types("PLATE CYLINDER SPHERE");
params.addParam<MooseEnum>("gap_geometry_type", gap_geom_types, "Gap calculation type. Choices are: "+gap_geom_types.getRawNames());
params.addParam<RealVectorValue>("cylinder_axis_point_1", "Start point for line defining cylindrical axis");
params.addParam<RealVectorValue>("cylinder_axis_point_2", "End point for line defining cylindrical axis");
params.addParam<RealVectorValue>("sphere_origin", "Origin for sphere geometry");
// Quadrature based
params.addParam<bool>("quadrature", false, "Whether or not to do Quadrature point based gap heat transfer. If this is true then gap_distance and gap_temp should NOT be provided (and will be ignored) however paired_boundary IS then required.");
params.addParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.addParam<bool>("warnings", false, "Whether to output warning messages concerning nodes not being found");
// Node based options
params.addCoupledVar("gap_distance", "Distance across the gap");
params.addCoupledVar("gap_temp", "Temperature on the other side of the gap");
return params;
}
InputParameters validParams<PenetrationAux>()
{
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<AuxKernel>();
params.addRequiredParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
params.addParam<Real>("tangential_tolerance", "Tangential distance to extend edges of contact surfaces");
params.addParam<Real>("normal_smoothing_distance", "Distance from edge in parametric coordinates over which to smooth contact normal");
params.addParam<std::string>("normal_smoothing_method","Method to use to smooth normals (edge_based|nodal_normal_based)");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.set<bool>("use_displaced_mesh") = true;
// To avoid creating a conversion routine we will list the enumeration options in the same order as the class-based enum.
// Care must be taken to ensure that this list stays in sync with the enum in the .h file.
MooseEnum quantity(
"distance tangential_distance normal_x normal_y normal_z closest_point_x closest_point_y "
"closest_point_z element_id side incremental_slip_magnitude incremental_slip_x "
"incremental_slip_y incremental_slip_z accumulated_slip force_x force_y force_z "
"normal_force_magnitude normal_force_x normal_force_y normal_force_z tangential_force_magnitude "
"tangential_force_x tangential_force_y tangential_force_z frictional_energy lagrange_multiplier "
"mechanical_status", "distance");
params.addParam<MooseEnum>("quantity", quantity, "The quantity to recover from the available penetration information");
return params;
}
Stokhos::TensorProductBasis<ordinal_type, value_type, ordering_type>::
TensorProductBasis(
const Teuchos::Array< Teuchos::RCP<const OneDOrthogPolyBasis<ordinal_type, value_type> > >& bases_,
const value_type& sparse_tol_,
const Stokhos::MultiIndex<ordinal_type>& index,
const ordering_type& coeff_compare) :
p(0),
d(bases_.size()),
sz(0),
bases(bases_),
sparse_tol(sparse_tol_),
max_orders(d),
basis_set(coeff_compare),
norms()
{
// Resize bases for given index if necessary
if (index.dimension() > 0) {
for (ordinal_type i=0; i<d; i++) {
if (index[i] != bases[i]->order())
bases[i] = bases[i]->cloneWithOrder(index[i]);
}
}
// Compute largest order
for (ordinal_type i=0; i<d; i++) {
max_orders[i] = bases[i]->order();
if (max_orders[i] > p)
p = max_orders[i];
}
// Compute basis terms
MultiIndex<ordinal_type> orders(d);
for (ordinal_type i=0; i<d; ++i)
orders[i] = bases[i]->order();
TensorProductIndexSet<ordinal_type> index_set(orders);
ProductBasisUtils::buildProductBasis(index_set, basis_set, basis_map);
sz = basis_map.size();
// Compute norms
norms.resize(sz);
value_type nrm;
for (ordinal_type k=0; k<sz; k++) {
nrm = value_type(1.0);
for (ordinal_type i=0; i<d; i++)
nrm = nrm * bases[i]->norm_squared(basis_map[k][i]);
norms[k] = nrm;
}
// Create name
name = "Tensor product basis (";
for (ordinal_type i=0; i<d-1; i++)
name += bases[i]->getName() + ", ";
name += bases[d-1]->getName() + ")";
// Allocate array for basis evaluation
basis_eval_tmp.resize(d);
for (ordinal_type j=0; j<d; j++)
basis_eval_tmp[j].resize(max_orders[j]+1);
}
InputParameters validParams<ContactPressureVarAction>()
{
MooseEnum orders("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<Action>();
params.addParam<MooseEnum>("order", orders, "The finite element order: " + orders.getRawNames());
return params;
}
InputParameters validParams<ContactPenetrationVarAction>()
{
MooseEnum orders("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<Action>();
params.addParam<MooseEnum>("order", orders, "The finite element order: FIRST, SECOND, etc.");
return params;
}
void testSamplingCommon(Project &p, Func samplingFunc) {
vector<vector<int>> orders(10);
for(int i=0; i<10; i++) {
orders[i] = samplingFunc(p);
ASSERT_TRUE(p.isOrderFeasible(orders[i]));
}
ASSERT_TRUE(any_of(orders.begin(), orders.end(), [&p](vector<int> &order) { return !equal(order.begin(), order.end(), p.topOrder.begin(), p.topOrder.end()); }));
}
InputParameters validParams<ContactPenetrationAuxAction>()
{
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<Action>();
params.addRequiredParam<BoundaryName>("master", "The master surface");
params.addRequiredParam<BoundaryName>("slave", "The slave surface");
params.addParam<MooseEnum>("order", orders, "The finite element order: FIRST, SECOND, etc.");
return params;
}
InputParameters validParams<AddLotsOfDiffusion>()
{
MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
InputParameters params = validParams<AddVariableAction>();
params.addRequiredParam<unsigned int>("number", "The number of variables to add");
return params;
}
InputParameters validParams<ContactPressureAuxAction>()
{
MooseEnum orders("FIRST, SECOND, THIRD, FOURTH", "FIRST");
InputParameters params = validParams<Action>();
params.addRequiredParam<BoundaryName>("master", "The master surface");
params.addRequiredParam<BoundaryName>("slave", "The slave surface");
params.addParam<MooseEnum>("order", orders, "The finite element order: " + orders.getRawNames());
return params;
}
InputParameters validParams<NodalAreaAction>()
{
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<Action>();
params.addParam<BoundaryName>("slave", "The slave surface");
// Set this action to build "NodalArea"
params.set<std::string>("type") = "NodalArea";
return params;
}
InputParameters
validParams<ContactPressureAux>()
{
InputParameters params = validParams<AuxKernel>();
params.addRequiredCoupledVar("nodal_area", "The nodal area");
params.addRequiredParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
params.set<ExecFlagEnum>("execute_on") = EXEC_NONLINEAR;
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
params.addParam<MooseEnum>("order", orders, "The finite element order: " + orders.getRawNames());
return params;
}
// Build a list of orders available for the selected structure.
static std::vector<AVORDER> buildStructureOrderList(STRUCTURE *psStructure)
{
ASSERT_OR_RETURN(std::vector<AVORDER>(), StructIsFactory(psStructure), "BuildStructureOrderList: structure is not a factory");
//this can be hard-coded!
std::vector<AVORDER> orders(2);
orders[0].OrderIndex = 0;//DSO_REPAIR_LEVEL;
orders[1].OrderIndex = 1;//DSO_ATTACK_LEVEL;
return orders;
}
InputParameters validParams<AddNodalNormalsAction>()
{
InputParameters params = validParams<Action>();
// Initialize the 'boundary' input option to default to any boundary
std::vector<BoundaryName> everywhere(1, "ANY_BOUNDARY_ID");
params.addParam<std::vector<BoundaryName> >("boundary", everywhere, "The boundary ID or name where the normals will be computed");
params.addParam<BoundaryName>("corner_boundary", "boundary ID or name with nodes at 'corners'");
MooseEnum orders("FIRST, SECOND", "FIRST");
params.addParam<MooseEnum>("order", orders, "Specifies the order of variables that hold the nodal normals. Needs to match the order of the mesh");
return params;
}
InputParameters validParams<AddAuxVariableAction>()
{
MooseEnum families(AddAuxVariableAction::getAuxVariableFamilies());
MooseEnum orders(AddAuxVariableAction::getAuxVariableOrders());
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");
return params;
}
// Build a list of orders available for the selected structure.
static std::vector<AVORDER> buildStructureOrderList(STRUCTURE *psStructure)
{
//only valid for Factories (at the moment)
ASSERT_OR_RETURN(std::vector<AVORDER>(), StructIsFactory(psStructure), "BuildStructureOrderList: structure is not a factory");
//this can be hard-coded!
std::vector<AVORDER> orders(4);
orders[0].OrderIndex = 1;//DSO_REPAIR_LEVEL;
orders[1].OrderIndex = 2;//DSO_ATTACK_LEVEL;
orders[2].OrderIndex = 5;//DSO_HALTTYPE;
return orders;
}
InputParameters validParams<AddLotsOfAuxVariablesAction>()
{
MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
InputParameters params = validParams<Action>();
params.addRequiredParam<unsigned int>("number", "The number of variables to add");
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");
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");
return params;
}
InputParameters validParams<NodeFaceConstraint>()
{
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<Constraint>();
params.addRequiredParam<BoundaryName>("slave", "The boundary ID associated with the slave side");
params.addRequiredParam<BoundaryName>("master", "The boundary ID associated with the master side");
params.addParam<Real>("tangential_tolerance", "Tangential distance to extend edges of contact surfaces");
params.addParam<Real>("normal_smoothing_distance", "Distance from edge in parametric coordinates over which to smooth contact normal");
params.addParam<std::string>("normal_smoothing_method","Method to use to smooth normals (edge_based|nodal_normal_based)");
params.addParam<MooseEnum>("order", orders, "The finite element order used for projections");
params.addRequiredCoupledVar("master_variable", "The variable on the master side of the domain");
return params;
}
InputParameters
validParams<AddLotsOfCoeffDiffusion>()
{
MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
InputParameters params = validParams<AddVariableAction>();
// params.addRequiredParam<unsigned int>("number", "The number of variables to add");
params.addRequiredParam<std::vector<NonlinearVariableName>>(
"variables", "The names of the variables for which CoeffDiffusion kernels should be added");
// params.addRequiredParam<std::vector<std::string> >("diffusion_coeffs", "The names of the
// diffusion coefficients used in the kernels.");
return params;
}
InputParameters validParams<GapHeatPointSourceMaster>()
{
MooseEnum orders("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<DiracKernel>();
params.addRequiredParam<BoundaryName>("boundary", "The master boundary");
params.addRequiredParam<BoundaryName>("slave", "The slave boundary");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.set<bool>("use_displaced_mesh") = true;
params.addParam<Real>("tangential_tolerance", "Tangential distance to extend edges of contact surfaces");
params.addParam<Real>("normal_smoothing_distance", "Distance from edge in parametric coordinates over which to smooth contact normal");
params.addParam<std::string>("normal_smoothing_method","Method to use to smooth normals (edge_based|nodal_normal_based)");
return params;
}
InputParameters validParams<GapValueAux>()
{
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<AuxKernel>();
params.set<bool>("_dual_restrictable") = true;
params.addRequiredParam<BoundaryName>("paired_boundary", "The boundary on the other side of a gap.");
params.addRequiredParam<VariableName>("paired_variable", "The variable to get the value of.");
params.set<bool>("use_displaced_mesh") = true;
params.addParam<Real>("tangential_tolerance", "Tangential distance to extend edges of contact surfaces");
params.addParam<Real>("normal_smoothing_distance", "Distance from edge in parametric coordinates over which to smooth contact normal");
params.addParam<std::string>("normal_smoothing_method","Method to use to smooth normals (edge_based|nodal_normal_based)");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.addParam<bool>("warnings", false, "Whether to output warning messages concerning nodes not being found");
return params;
}
InputParameters
validParams<AddLotsOfPotentialDrivenArtificialDiff>()
{
MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
InputParameters params = validParams<AddVariableAction>();
params.addRequiredParam<std::vector<NonlinearVariableName>>(
"variables",
"The names of the variables for which PotentialDrivenArtificialDiff kernels should be added");
params.addRequiredParam<std::vector<VariableName>>(
"potential", "A dummy vector that holds the potential to couple in for advection");
params.addParam<Real>(
"delta", 0.5, "Used for determining the amount of artificial diffusion to add.");
return params;
}
InputParameters validParams<MultiAppProjectionTransfer>()
{
InputParameters params = validParams<MultiAppTransfer>();
params.addRequiredParam<AuxVariableName>("variable", "The auxiliary variable to store the transferred values in.");
params.addRequiredParam<VariableName>("source_variable", "The variable to transfer from.");
MooseEnum proj_type("l2", "l2");
params.addParam<MooseEnum>("proj_type", proj_type, "The type of the projection.");
MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
params.addParam<MooseEnum>("family", families, "Specifies the family of FE shape functions to use for this variable");
MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
params.addParam<MooseEnum>("order", orders, "Specifies the order of the FE shape function to use for this variable (additional orders not listed are allowed)");
return params;
}
InputParameters validParams<GapConductance>()
{
MooseEnum orders("FIRST SECOND THIRD FOURTH", "FIRST");
InputParameters params = validParams<Material>();
params.addParam<std::string>("appended_property_name", "", "Name appended to material properties to make them unique");
params.addRequiredCoupledVar("variable", "Temperature variable");
// Node based
params.addCoupledVar("gap_distance", "Distance across the gap");
params.addCoupledVar("gap_temp", "Temperature on the other side of the gap");
params.addParam<Real>("gap_conductivity", 1.0, "The thermal conductivity of the gap material");
params.addParam<FunctionName>("gap_conductivity_function", "Thermal conductivity of the gap material as a function. Multiplied by gap_conductivity.");
params.addCoupledVar("gap_conductivity_function_variable", "Variable to be used in the gap_conductivity_function in place of time");
// Quadrature based
params.addParam<bool>("quadrature", false, "Whether or not to do quadrature point based gap heat transfer. If this is true then gap_distance and gap_temp should NOT be provided (and will be ignored); however, paired_boundary and variable are then required.");
params.addParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
params.addParam<MooseEnum>("order", orders, "The finite element order");
params.addParam<bool>("warnings", false, "Whether to output warning messages concerning nodes not being found");
// Common
params.addRangeCheckedParam<Real>("min_gap", 1e-6, "min_gap>=0", "A minimum gap (denominator) size");
params.addRangeCheckedParam<Real>("max_gap", 1e6, "max_gap>=0", "A maximum gap (denominator) size");
//Deprecated parameter
MooseEnum coord_types("default XYZ");
params.addDeprecatedParam<MooseEnum>("coord_type", coord_types, "Gap calculation type (default or XYZ).","The functionality of this parameter is replaced by 'gap_geometry_type'.");
MooseEnum gap_geom_types("PLATE CYLINDER SPHERE");
params.addParam<MooseEnum>("gap_geometry_type", gap_geom_types, "Gap calculation type. Choices are: "+gap_geom_types.getRawNames());
params.addParam<RealVectorValue>("cylinder_axis_point_1", "Start point for line defining cylindrical axis");
params.addParam<RealVectorValue>("cylinder_axis_point_2", "End point for line defining cylindrical axis");
params.addParam<RealVectorValue>("sphere_origin", "Origin for sphere geometry");
params.addParam<Real>("stefan_boltzmann", 5.669e-8, "The Stefan-Boltzmann constant");
params.addRangeCheckedParam<Real>("emissivity_1", 0.0, "emissivity_1>=0 & emissivity_1<=1", "The emissivity of the fuel surface");
params.addRangeCheckedParam<Real>("emissivity_2", 0.0, "emissivity_2>=0 & emissivity_2<=1", "The emissivity of the cladding surface");
params.addParam<bool>("use_displaced_mesh", true, "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.");
return params;
}
InputParameters
validParams<GapConductance>()
{
InputParameters params = validParams<Material>();
params += GapConductance::actionParameters();
params.addRequiredCoupledVar("variable", "Temperature variable");
// Node based
params.addCoupledVar("gap_distance", "Distance across the gap");
params.addCoupledVar("gap_temp", "Temperature on the other side of the gap");
params.addParam<Real>("gap_conductivity", 1.0, "The thermal conductivity of the gap material");
params.addParam<FunctionName>(
"gap_conductivity_function",
"Thermal conductivity of the gap material as a function. Multiplied by gap_conductivity.");
params.addCoupledVar("gap_conductivity_function_variable",
"Variable to be used in the gap_conductivity_function in place of time");
// Quadrature based
params.addParam<bool>("quadrature",
false,
"Whether or not to do quadrature point based gap heat "
"transfer. If this is true then gap_distance and "
"gap_temp should NOT be provided (and will be "
"ignored); however, paired_boundary and variable are "
"then required.");
params.addParam<BoundaryName>("paired_boundary", "The boundary to be penetrated");
params.addParam<Real>("stefan_boltzmann", 5.669e-8, "The Stefan-Boltzmann constant");
params.addParam<bool>("use_displaced_mesh",
true,
"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>(
"warnings", false, "Whether to output warning messages concerning nodes not being found");
MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
params.addParam<MooseEnum>("order", orders, "The finite element order");
return params;
}
