NewmarkAccelAux::NewmarkAccelAux(const std::string & name, InputParameters parameters) :
AuxKernel(name, parameters),
_disp_old(coupledValueOld("displacement")),
_disp(coupledValue("displacement")),
_vel_old(coupledValueOld("velocity")),
_beta(getParam<Real>("beta"))
{
}
PresetAcceleration::PresetAcceleration(const InputParameters & parameters)
: PresetNodalBC(parameters),
_u_old(valueOld()),
_scale_factor(parameters.get<Real>("scale_factor")),
_function(getFunction("function")),
_vel_old(coupledValueOld("velocity")),
_accel_old(coupledValueOld("acceleration")),
_beta(getParam<Real>("beta"))
{
}
ElectricEnergy::ElectricEnergy(const std::string & name, InputParameters parameters) :
ElementIntegralPostprocessor(name, parameters),
_polar_x(coupledValueOld("polar_x")),
_polar_y(coupledValueOld("polar_y")),
_polar_z(coupledValueOld("polar_z")),
_potential_grad(coupledGradient("potential")),
_permittivity(getParam<Real>("permittivity")),
_len_scale(getParam<Real>("len_scale"))
{
}
INSChorinPredictor::INSChorinPredictor(const InputParameters & parameters) :
Kernel(parameters),
// Current velocities
_u_vel(coupledValue("u")),
_v_vel(_mesh.dimension() >= 2 ? coupledValue("v") : _zero),
_w_vel(_mesh.dimension() == 3 ? coupledValue("w") : _zero),
// Old velocities
_u_vel_old(coupledValueOld("u")),
_v_vel_old(_mesh.dimension() >= 2 ? coupledValueOld("v") : _zero),
_w_vel_old(_mesh.dimension() == 3 ? coupledValueOld("w") : _zero),
// Star velocities
_u_vel_star(coupledValue("u_star")),
_v_vel_star(_mesh.dimension() >= 2 ? coupledValue("v_star") : _zero),
_w_vel_star(_mesh.dimension() == 3 ? coupledValue("w_star") : _zero),
// Velocity Gradients
_grad_u_vel(coupledGradient("u")),
_grad_v_vel(_mesh.dimension() >= 2 ? coupledGradient("v") : _grad_zero),
_grad_w_vel(_mesh.dimension() == 3 ? coupledGradient("w") : _grad_zero),
// Old Velocity Gradients
_grad_u_vel_old(coupledGradientOld("u")),
_grad_v_vel_old(_mesh.dimension() >= 2 ? coupledGradientOld("v") : _grad_zero),
_grad_w_vel_old(_mesh.dimension() == 3 ? coupledGradientOld("w") : _grad_zero),
// Star Velocity Gradients
_grad_u_vel_star(coupledGradient("u_star")),
_grad_v_vel_star(_mesh.dimension() >= 2 ? coupledGradient("v_star") : _grad_zero),
_grad_w_vel_star(_mesh.dimension() == 3 ? coupledGradient("w_star") : _grad_zero),
// Variable numberings
_u_vel_var_number(coupled("u")),
_v_vel_var_number(_mesh.dimension() >= 2 ? coupled("v") : libMesh::invalid_uint),
_w_vel_var_number(_mesh.dimension() == 3 ? coupled("w") : libMesh::invalid_uint),
// Star velocity numberings
_u_vel_star_var_number(coupled("u_star")),
_v_vel_star_var_number(_mesh.dimension() >= 2 ? coupled("v_star") : libMesh::invalid_uint),
_w_vel_star_var_number(_mesh.dimension() == 3 ? coupled("w_star") : libMesh::invalid_uint),
// Required parameters
_mu(getParam<Real>("mu")),
_rho(getParam<Real>("rho")),
_component(getParam<unsigned>("component")),
_predictor_type(getParam<std::string>("predictor_type")),
_predictor_enum("OLD, NEW, STAR, INVALID", _predictor_type)
{
}
RichardsPorepressureNames::RichardsPorepressureNames(const std::string & name, InputParameters parameters) :
GeneralUserObject(name, parameters),
Coupleable(parameters, false),
ZeroInterface(parameters),
_num_p(coupledComponents("porepressure_vars")),
_the_names(std::string())
{
unsigned int max_moose_var_num_seen(0);
_moose_var_num.resize(_num_p);
_moose_var_value.resize(_num_p);
_moose_var_value_old.resize(_num_p);
_moose_grad_var.resize(_num_p);
_moose_raw_var.resize(_num_p);
for (unsigned int i=0 ; i<_num_p; ++i)
{
_moose_var_num[i] = coupled("porepressure_vars", i);
max_moose_var_num_seen = (max_moose_var_num_seen > _moose_var_num[i] ? max_moose_var_num_seen : _moose_var_num[i]);
_moose_var_value[i] = &coupledValue("porepressure_vars", i); // coupledValue returns a reference (an alias) to a VariableValue, and the & turns it into a pointer
_moose_var_value_old[i] = (_is_transient ? &coupledValueOld("porepressure_vars", i) : &_zero);
_moose_grad_var[i] = &coupledGradient("porepressure_vars", i);
_moose_raw_var[i] = getVar("porepressure_vars", i);
_the_names += getVar("porepressure_vars", i)->name() + " ";
}
_the_names.erase(_the_names.end() - 1, _the_names.end()); // remove trailing space
_pressure_var_num.resize(max_moose_var_num_seen + 1);
for (unsigned int i=0 ; i<max_moose_var_num_seen+1 ; ++i)
_pressure_var_num[i] = _num_p; // NOTE: indicates that i is not a porepressure variable
for (unsigned int i=0 ; i<_num_p; ++i)
_pressure_var_num[_moose_var_num[i]] = i;
}
// DEPRECATED CONSTRUCTOR
NewmarkVelAux::NewmarkVelAux(const std::string & deprecated_name, InputParameters parameters) :
AuxKernel(deprecated_name, parameters),
_accel_old(coupledValueOld("acceleration")),
_accel(coupledValue("acceleration")),
_gamma(getParam<Real>("gamma"))
{
}
NewmarkVelAux::NewmarkVelAux(const InputParameters & parameters)
: AuxKernel(parameters),
_accel_old(coupledValueOld("acceleration")),
_accel(coupledValue("acceleration")),
_gamma(getParam<Real>("gamma"))
{
}
ComputeThermalExpansionEigenStrain::ComputeThermalExpansionEigenStrain(const InputParameters & parameters) :
ComputeStressFreeStrainBase(parameters),
_temperature(coupledValue("Temperature")),
_has_incremental_strain(hasMaterialProperty<RankTwoTensor>(_base_name + "strain_increment")),
_temperature_old(_has_incremental_strain ? & coupledValueOld("Temperature") : NULL),
_thermal_expansion_coeff(getParam<Real>("thermal_expansion_coefficient")),
_stress_free_reference_temperature(getParam<Real>("stress_free_reference_temperature"))
{
}
ComputeIncrementalSmallStrain::ComputeIncrementalSmallStrain(const InputParameters & parameters) :
ComputeSmallStrain(parameters),
_strain_rate(declareProperty<RankTwoTensor>(_base_name + "strain_rate")),
_strain_increment(declareProperty<RankTwoTensor>(_base_name + "strain_increment")),
_total_strain_old(declarePropertyOld<RankTwoTensor>("total_strain")),
_rotation_increment(declareProperty<RankTwoTensor>(_base_name + "rotation_increment")),
_deformation_gradient(declareProperty<RankTwoTensor>(_base_name + "deformation_gradient")),
_stress_free_strain_increment(getDefaultMaterialProperty<RankTwoTensor>(_base_name + "stress_free_strain_increment")),
_T_old(coupledValueOld("temperature"))
{
}
NonlinearRZ::NonlinearRZ( SolidModel & solid_model,
const std::string & name,
const InputParameters & parameters )
:Nonlinear( solid_model, name, parameters ),
_grad_disp_r(coupledGradient("disp_r")),
_grad_disp_z(coupledGradient("disp_z")),
_grad_disp_r_old(coupledGradientOld("disp_r")),
_grad_disp_z_old(coupledGradientOld("disp_z")),
_disp_r(coupledValue("disp_r")),
_disp_r_old(coupledValueOld("disp_r"))
{
}
NonDimensionalEntropyViscosityCoefficient::NonDimensionalEntropyViscosityCoefficient(const InputParameters & parameters) :
Material(parameters),
// Boolean
_is_dmsl_form(getParam<bool>("is_dimensional_form")),
// Coupled variables:
_rho(coupledValue("rho")),
_rho_old(coupledValueOld("rho")),
_rho_older(coupledValueOlder("rho")),
_grad_rho(coupledGradient("rho")),
_rhou(coupledValue("rhou")),
_eps(isCoupled("epsilon") ? coupledValue("epsilon") : _zero),
_eps_old(isCoupled("epsilon") ? coupledValueOld("epsilon") : _zero),
_eps_older(isCoupled("epsilon") ? coupledValueOlder("epsilon") : _zero),
_grad_eps(isCoupled("epsilon") ? coupledGradient("epsilon") : _grad_zero),
// Coupled aux variables
_press(coupledValue("pressure")),
_press_old(coupledValueOld("pressure")),
_press_older(coupledValueOlder("pressure")),
_grad_press(coupledGradient("pressure")),
// Jump values:
_jump_press(isCoupled("jump_press") ? coupledValue("jump_press") : _zero),
_jump_dens(isCoupled("jump_dens") ? coupledValue("jump_dens") : _zero),
// Declare material properties for viscosity coefficients.
_kappa(declareProperty<Real>("kappa")),
_kappa_max(declareProperty<Real>("kappa_max")),
// Parameters
_Cjump(getParam<double>("Cjump")),
_is_first_order_viscosity(getParam<bool>("is_first_order_viscosity")),
_use_jumps(getParam<bool>("use_jumps")),
// UserObject:
_eos(getUserObject<EquationOfState>("eos")),
// Userobject computing the ICs
_ics(getUserObject<ComputeICsRadHydro>("ics")),
// Non-dimensional number Po
_Po(_is_dmsl_form ? 1. : _ics.P())
{
if (_Cjump < 0.)
mooseError(this->name() << ": the coefficient Cjump has to be positive.");
}
NonlinearRZ::NonlinearRZ( SolidModel & solid_model,
const std::string & name,
const InputParameters & parameters )
:Nonlinear( solid_model, name, parameters ),
_grad_disp_r(coupledGradient("disp_r")),
_grad_disp_z(coupledGradient("disp_z")),
_grad_disp_r_old(coupledGradientOld("disp_r")),
_grad_disp_z_old(coupledGradientOld("disp_z")),
_disp_r(coupledValue("disp_r")),
_disp_r_old(coupledValueOld("disp_r")),
_volumetric_locking_correction(_solid_model.getParam<bool>("volumetric_locking_correction"))
{
}
OneDEntropyViscosityMethod::OneDEntropyViscosityMethod(const InputParameters & parameters) :
AuxKernel(parameters),
_rhoA(coupledValue("rhoA")),
_rhouA(coupledValue("rhouA")),
_rhoEA(coupledValue("rhoEA")),
_press(coupledValue("pressure")),
_press_old(coupledValueOld("pressure")),
_press_older(coupledValueOlder("pressure")),
_press_grad(coupledGradient("pressure")),
_rho(coupledValue("rho")),
_rho_old(coupledValueOld("rho")),
_rho_older(coupledValueOlder("rho")),
_rho_grad(coupledGradient("rho")),
_press_jump(coupledValue("press_jump")),
_rho_jump(coupledValue("rho_jump")),
_area(coupledValue("area")),
_eos(getUserObject<OneDEquationOfState>("eos")),
_vel_average(getParam<std::string>("velocity_average")),
_Cejump(getParam<Real>("Cejump")),
_Ce(getParam<Real>("Ce")),
_Cmax(getParam<Real>("Cmax")),
_norm_type(getParam<bool>("norm_type"))
{}
PorousFlowDesorpedMassTimeDerivative::PorousFlowDesorpedMassTimeDerivative(
const InputParameters & parameters)
: TimeKernel(parameters),
_dictator(getUserObject<PorousFlowDictator>("PorousFlowDictator")),
_conc_var_number(coupled("conc_var")),
_conc(coupledValue("conc_var")),
_conc_old(coupledValueOld("conc_var")),
_porosity(getMaterialProperty<Real>("PorousFlow_porosity_qp")),
_porosity_old(getMaterialPropertyOld<Real>("PorousFlow_porosity_qp")),
_dporosity_dvar(getMaterialProperty<std::vector<Real>>("dPorousFlow_porosity_qp_dvar")),
_dporosity_dgradvar(
getMaterialProperty<std::vector<RealGradient>>("dPorousFlow_porosity_qp_dgradvar"))
{
}
ComputeAxisymmetric1DIncrementalStrain::ComputeAxisymmetric1DIncrementalStrain(
const InputParameters & parameters)
: Compute1DIncrementalStrain(parameters),
_disp_old_0(coupledValueOld("displacements", 0)),
_subblock_id_provider(isParamValid("subblock_index_provider")
? &getUserObject<SubblockIndexProvider>("subblock_index_provider")
: nullptr),
_has_out_of_plane_strain(isParamValid("out_of_plane_strain")),
_out_of_plane_strain(_has_out_of_plane_strain ? coupledValue("out_of_plane_strain") : _zero),
_out_of_plane_strain_old(_has_out_of_plane_strain ? coupledValueOld("out_of_plane_strain")
: _zero),
_has_scalar_out_of_plane_strain(isParamValid("scalar_out_of_plane_strain")),
_nscalar_strains(
_has_scalar_out_of_plane_strain ? coupledScalarComponents("scalar_out_of_plane_strain") : 0)
{
if (_has_out_of_plane_strain && _has_scalar_out_of_plane_strain)
mooseError("Must define only one of out_of_plane_strain or scalar_out_of_plane_strain");
if (!_has_out_of_plane_strain && !_has_scalar_out_of_plane_strain)
mooseError("Must define either out_of_plane_strain or scalar_out_of_plane_strain");
// in case when the provided scalar_out_of_plane_strain is not a coupled
// scalar variable, still set _nscalar_strains = 1 but return its default value 0
if (coupledScalarComponents("scalar_out_of_plane_strain") == 0)
_nscalar_strains = 1;
if (_has_scalar_out_of_plane_strain)
{
_scalar_out_of_plane_strain.resize(_nscalar_strains);
_scalar_out_of_plane_strain_old.resize(_nscalar_strains);
for (unsigned int i = 0; i < _nscalar_strains; ++i)
{
_scalar_out_of_plane_strain[i] = &coupledScalarValue("scalar_out_of_plane_strain", i);
_scalar_out_of_plane_strain_old[i] = &coupledScalarValueOld("scalar_out_of_plane_strain", i);
}
}
}
CoupledBEKinetic::CoupledBEKinetic(const InputParameters & parameters)
: TimeDerivative(parameters),
_porosity(getMaterialProperty<Real>("porosity")),
_weight(getParam<std::vector<Real>>("weight"))
{
const unsigned int n = coupledComponents("v");
_vals.resize(n);
_vals_old.resize(n);
for (unsigned int i = 0; i < n; ++i)
{
_vals[i] = &coupledValue("v", i);
_vals_old[i] = &coupledValueOld("v", i);
}
}
ComputeFiniteStrain::ComputeFiniteStrain(const InputParameters & parameters) :
ComputeStrainBase(parameters),
_strain_rate(declareProperty<RankTwoTensor>(_base_name + "strain_rate")),
_strain_increment(declareProperty<RankTwoTensor>(_base_name + "strain_increment")),
_mechanical_strain_old(declarePropertyOld<RankTwoTensor>(_base_name + "mechanical_strain")),
_total_strain_old(declarePropertyOld<RankTwoTensor>(_base_name + "total_strain")),
_rotation_increment(declareProperty<RankTwoTensor>(_base_name + "rotation_increment")),
_deformation_gradient(declareProperty<RankTwoTensor>(_base_name + "deformation_gradient")),
_deformation_gradient_old(declarePropertyOld<RankTwoTensor>(_base_name + "deformation_gradient")),
_stress_free_strain_increment(getDefaultMaterialProperty<RankTwoTensor>(_base_name + "stress_free_strain_increment")),
_T_old(coupledValueOld("temperature")), //Deprecated, use ComputeThermalExpansionEigenStrain instead
_current_elem_volume(_assembly.elemVolume()),
_Fhat(_fe_problem.getMaxQps())
{
}
ComputeThermalExpansionEigenStrain::ComputeThermalExpansionEigenStrain(const InputParameters & parameters) :
ComputeStressFreeStrainBase(parameters),
_temperature(coupledValue("temperature")),
_has_incremental_strain(hasMaterialProperty<RankTwoTensor>(_base_name + "strain_increment")),
_temperature_old(_has_incremental_strain ? & coupledValueOld("temperature") : NULL),
_thermal_expansion_coeff(getParam<Real>("thermal_expansion_coeff")),
_thermal_expansion_tensor(declareProperty<RankTwoTensor>(_base_name + "_thermal_expansion_tensor")),
_step_one(declareRestartableData<bool>("step_one", true))
{
if (isParamValid("stress_free_temperature"))
_stress_free_temperature = getParam<Real>("stress_free_temperature");
else if (isParamValid("stress_free_reference_temperature"))
_stress_free_temperature = getParam<Real>("stress_free_reference_temperature");
else
mooseError("Please specify 'stress_free_temperature'.");
}
NonlinearPlaneStrain::NonlinearPlaneStrain( SolidModel & solid_model,
const std::string & name,
const InputParameters & parameters )
:Nonlinear( solid_model, name, parameters ),
ScalarCoupleable(parameters),
_grad_disp_x(coupledGradient("disp_x")),
_grad_disp_y(coupledGradient("disp_y")),
_have_strain_zz(isCoupled("strain_zz")),
_strain_zz(_have_strain_zz?coupledValue("strain_zz"):_zero),
_have_scalar_strain_zz(isCoupledScalar("scalar_strain_zz")),
_scalar_strain_zz(_have_scalar_strain_zz?coupledScalarValue("scalar_strain_zz"):_zero),
_grad_disp_x_old(coupledGradientOld("disp_x")),
_grad_disp_y_old(coupledGradientOld("disp_y")),
_strain_zz_old(_have_strain_zz?coupledValueOld("strain_zz"):_zero),
_scalar_strain_zz_old(_have_scalar_strain_zz?coupledScalarValueOld("scalar_strain_zz"):_zero)
{
}
CoupledBEKinetic::CoupledBEKinetic(const std::string & name, InputParameters parameters)
:Kernel(name,parameters),
_porosity(getMaterialProperty<Real>("porosity")),
_weight(getParam<std::vector<Real> >("weight"))
{
int n = coupledComponents("v");
// _vars.resize(n);
_vals.resize(n);
_vals_old.resize(n);
for (unsigned int i=0; i<_vals.size(); ++i)
{
// _vars[i] = coupled("v", i);
_vals[i] = &coupledValue("v", i);
_vals_old[i] = &coupledValueOld("v", i);
}
}
ComputePlaneIncrementalStrain::ComputePlaneIncrementalStrain(const InputParameters & parameters)
: Compute2DIncrementalStrain(parameters),
_scalar_out_of_plane_strain_coupled(isCoupledScalar("scalar_out_of_plane_strain")),
_scalar_out_of_plane_strain(_scalar_out_of_plane_strain_coupled
? coupledScalarValue("scalar_out_of_plane_strain")
: _zero),
_scalar_out_of_plane_strain_old(_scalar_out_of_plane_strain_coupled
? coupledScalarValueOld("scalar_out_of_plane_strain")
: _zero),
_out_of_plane_strain_coupled(isCoupled("out_of_plane_strain")),
_out_of_plane_strain(_out_of_plane_strain_coupled ? coupledValue("out_of_plane_strain")
: _zero),
_out_of_plane_strain_old(_out_of_plane_strain_coupled ? coupledValueOld("out_of_plane_strain")
: _zero)
{
if (_out_of_plane_strain_coupled && _scalar_out_of_plane_strain_coupled)
mooseError("Must define only one of out_of_plane_strain or scalar_out_of_plane_strain");
}
Q2PMaterial::Q2PMaterial(const InputParameters & parameters) :
Material(parameters),
_material_por(getParam<Real>("mat_porosity")),
_por_change(coupledValue("por_change")),
_por_change_old(isCoupled("por_change") ? coupledValueOld("por_change") : _zero),
_material_perm(getParam<RealTensorValue>("mat_permeability")),
_material_gravity(getParam<RealVectorValue>("gravity")),
_porosity_old(declareProperty<Real>("porosity_old")),
_porosity(declareProperty<Real>("porosity")),
_permeability(declareProperty<RealTensorValue>("permeability")),
_gravity(declareProperty<RealVectorValue>("gravity"))
{
if (isCoupled("perm_change") && (coupledComponents("perm_change") != LIBMESH_DIM*LIBMESH_DIM))
mooseError(LIBMESH_DIM*LIBMESH_DIM << " components of perm_change must be given to a Q2PMaterial. You supplied " << coupledComponents("perm_change") << "\n");
_perm_change.resize(LIBMESH_DIM*LIBMESH_DIM);
for (unsigned int i = 0; i < LIBMESH_DIM*LIBMESH_DIM; ++i)
_perm_change[i] = (isCoupled("perm_change")? &coupledValue("perm_change", i) : &_zero); // coupledValue returns a reference (an alias) to a VariableValue, and the & turns it into a pointer
}
ComputeCosseratIncrementalSmallStrain::ComputeCosseratIncrementalSmallStrain(const InputParameters & parameters) :
ComputeIncrementalStrainBase(parameters),
_curvature(declareProperty<RankTwoTensor>("curvature")),
_nrots(coupledComponents("Cosserat_rotations")),
_wc(_nrots),
_wc_old(_nrots),
_grad_wc(_nrots),
_grad_wc_old(_nrots),
_curvature_old(declarePropertyOld<RankTwoTensor>("curvature")),
_curvature_increment(declareProperty<RankTwoTensor>("curvature_increment"))
{
if (_nrots != 3)
mooseError("ComputeCosseratSmallStrain: This Material is only defined for 3-dimensional simulations so 3 Cosserat rotation variables are needed");
for (unsigned i = 0; i < _nrots; ++i)
{
_wc[i] = &coupledValue("Cosserat_rotations", i);
_wc_old[i] = &coupledValueOld("Cosserat_rotations", i);
_grad_wc[i] = &coupledGradient("Cosserat_rotations", i);
_grad_wc_old[i] = &coupledGradientOld("Cosserat_rotations", i);
}
}
CoupledBEEquilibriumSub::CoupledBEEquilibriumSub(const InputParameters & parameters) :
Kernel(parameters),
_weight(getParam<Real>("weight")),
_log_k(getParam<Real>("log_k")),
_sto_u(getParam<Real>("sto_u")),
_sto_v(getParam<std::vector<Real> >("sto_v")),
_porosity(getMaterialProperty<Real>("porosity")),
_u_old(valueOld())
{
const unsigned int n = coupledComponents("v");
_vars.resize(n);
_v_vals.resize(n);
_v_vals_old.resize(n);
for (unsigned int i=0; i < n; ++i)
{
_vars[i] = coupled("v", i);
_v_vals[i] = &coupledValue("v", i);
_v_vals_old[i] = & coupledValueOld("v", i);
}
}
ConstitutiveModel::ConstitutiveModel(const InputParameters & parameters)
:Material(parameters),
_has_temp(isCoupled("temp")),
_temperature(_has_temp ? coupledValue("temp") : _zero),
_temperature_old(_has_temp ? coupledValueOld("temp") : _zero),
_alpha(parameters.isParamValid("thermal_expansion") ? getParam<Real>("thermal_expansion") : 0.),
_alpha_function(parameters.isParamValid("thermal_expansion_function") ? &getFunction("thermal_expansion_function") : NULL),
_has_stress_free_temp(isParamValid("stress_free_temperature")),
_stress_free_temp(_has_stress_free_temp ? getParam<Real>("stress_free_temperature") : 0.0),
_ref_temp(0.0)
{
if (parameters.isParamValid("thermal_expansion_function_type"))
{
if (!_alpha_function)
mooseError("thermal_expansion_function_type can only be set when thermal_expansion_function is used");
MooseEnum tec = getParam<MooseEnum>("thermal_expansion_function_type");
if (tec == "mean")
_mean_alpha_function = true;
else if (tec == "instantaneous")
_mean_alpha_function = false;
else
mooseError("Invalid option for thermal_expansion_function_type");
}
else
_mean_alpha_function = false;
if (parameters.isParamValid("thermal_expansion_reference_temperature"))
{
if (!_alpha_function)
mooseError("thermal_expansion_reference_temperature can only be set when thermal_expansion_function is used");
if (!_mean_alpha_function)
mooseError("thermal_expansion_reference_temperature can only be set when thermal_expansion_function_type = mean");
_ref_temp = getParam<Real>("thermal_expansion_reference_temperature");
if (!_has_temp)
mooseError("Cannot specify thermal_expansion_reference_temperature without coupling to temperature");
}
else if (_mean_alpha_function)
mooseError("Must specify thermal_expansion_reference_temperature if thermal_expansion_function_type = mean");
}
LowMachPreconditioner::LowMachPreconditioner(const InputParameters & parameters) :
Kernel(parameters),
// Coupled auxilary variables
_rhoA(coupledValue("rhoA")),
_rhouA_x(coupledValue("rhouA_x")),
_rhouA_y(_mesh.dimension()>=2 ? coupledValue("rhouA_y") : _zero),
_rhouA_z(_mesh.dimension()==3 ? coupledValue("rhouA_z") : _zero),
_pressure_old(coupledValueOld("pressure")),
_pressure_older(coupledValueOlder("pressure")),
_area(coupledValue("area")),
// Equation of state:
_eos(getUserObject<EquationOfState>("eos")),
// Parameters:
_Mach_ref(getParam<Real>("Mach_nb_ref")),
// Parameters for jacobian:
_rhoA_nb(coupled("rhoA")),
_rhouA_x_nb(coupled("rhouA_x")),
_rhouA_y_nb(isCoupled("rhouA_y") ? coupled("rhouA_y") : -1),
_rhouA_z_nb(isCoupled("rhouA_z") ? coupled("rhouA_z") : -1)
{}
RichardsMaterial::RichardsMaterial(const std::string & name,
InputParameters parameters) :
Material(name, parameters),
_material_por(getParam<Real>("mat_porosity")),
_por_change(isCoupled("por_change") ? &coupledValue("por_change") : &_zero), // coupledValue returns a reference (an alias) to a VariableValue, and the & turns it into a pointer
_por_change_old(isCoupled("por_change") ? &coupledValueOld("por_change") : &_zero),
_material_perm(getParam<RealTensorValue>("mat_permeability")),
_material_viscosity(getParam<std::vector<Real> >("viscosity")),
_pp_name_UO(getUserObject<RichardsPorepressureNames>("porepressureNames_UO")),
_num_p(_pp_name_UO.num_pp()),
// FOLLOWING IS FOR SUPG
_material_gravity(getParam<RealVectorValue>("gravity")),
_trace_perm(_material_perm.tr()),
// Declare that this material is going to provide a Real
// valued property named "porosity", etc, that Kernels can use.
_porosity(declareProperty<Real>("porosity")),
_porosity_old(declareProperty<Real>("porosity_old")),
_permeability(declareProperty<RealTensorValue>("permeability")),
_viscosity(declareProperty<std::vector<Real> >("viscosity")),
_gravity(declareProperty<RealVectorValue>("gravity")),
_density_old(declareProperty<std::vector<Real> >("density_old")),
_density(declareProperty<std::vector<Real> >("density")),
_ddensity(declareProperty<std::vector<Real> >("ddensity")),
_d2density(declareProperty<std::vector<Real> >("d2density")),
_seff_old(declareProperty<std::vector<Real> >("s_eff_old")),
_seff(declareProperty<std::vector<Real> >("s_eff")),
_dseff(declareProperty<std::vector<std::vector<Real> > >("ds_eff")),
_d2seff(declareProperty<std::vector<std::vector<std::vector<Real> > > >("d2s_eff")),
_sat_old(declareProperty<std::vector<Real> >("sat_old")),
_sat(declareProperty<std::vector<Real> >("sat")),
_dsat(declareProperty<std::vector<std::vector<Real> > >("dsat")),
_d2sat(declareProperty<std::vector<std::vector<std::vector<Real> > > >("d2sat")),
_rel_perm(declareProperty<std::vector<Real> >("rel_perm")),
_drel_perm(declareProperty<std::vector<Real> >("drel_perm")),
_d2rel_perm(declareProperty<std::vector<Real> >("d2rel_perm")),
_tauvel_SUPG(declareProperty<std::vector<RealVectorValue> >("tauvel_SUPG")),
_dtauvel_SUPG_dgradp(declareProperty<std::vector<RealTensorValue> >("dtauvel_SUPG_dgradp")),
_dtauvel_SUPG_dp(declareProperty<std::vector<RealVectorValue> >("dtauvel_SUPG_dp"))
{
// Need to add the variables that the user object is coupled to as dependencies so MOOSE will compute them
{
const std::vector<MooseVariable *> & coupled_vars = _pp_name_UO.getCoupledMooseVars();
for(unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
if (_material_por <= 0 || _material_por >= 1)
mooseError("Porosity set to " << _material_por << " but it must be between 0 and 1");
if (isCoupled("perm_change") && (coupledComponents("perm_change") != 9))
mooseError("9 components of perm_change must be given to a RichardsMaterial. You supplied " << coupledComponents("perm_change") << "\n");
_perm_change.resize(9);
for (unsigned int i=0 ; i<9 ; ++i)
_perm_change[i] = (isCoupled("perm_change")? &coupledValue("perm_change", i) : &_zero); // coupledValue returns a reference (an alias) to a VariableValue, and the & turns it into a pointer
_pressure_vals.resize(_num_p);
_pressure_old_vals.resize(_num_p);
_material_relperm_UO.resize(_num_p);
_material_seff_UO.resize(_num_p);
_material_sat_UO.resize(_num_p);
_material_density_UO.resize(_num_p);
_material_SUPG_UO.resize(_num_p);
_grad_p.resize(_num_p);
for (unsigned int i=0 ; i<_num_p; ++i)
{
// DON'T WANT "pressure_vars" at all since pp_name_UO contains the same info
//_pressure_vals[i] = &coupledValue("pressure_vars", i); // coupled value returns a reference
//_pressure_old_vals[i] = (_is_transient ? &coupledValueOld("pressure_vars", i) : &_zero);
//_grad_p[i] = &coupledGradient("pressure_vars", i);
_pressure_vals[i] = _pp_name_UO.pp_vals(i);
_pressure_old_vals[i] = _pp_name_UO.pp_vals_old(i);
_grad_p[i] = _pp_name_UO.grad_pp(i);
// in the following. first get the userobject names that were inputted, then get the i_th one of these, then get the actual userobject that this corresponds to, then finally & gives pointer to RichardsRelPerm object.
_material_relperm_UO[i] = &getUserObjectByName<RichardsRelPerm>(getParam<std::vector<UserObjectName> >("relperm_UO")[i]);
_material_seff_UO[i] = &getUserObjectByName<RichardsSeff>(getParam<std::vector<UserObjectName> >("seff_UO")[i]);
_material_sat_UO[i] = &getUserObjectByName<RichardsSat>(getParam<std::vector<UserObjectName> >("sat_UO")[i]);
_material_density_UO[i] = &getUserObjectByName<RichardsDensity>(getParam<std::vector<UserObjectName> >("density_UO")[i]);
_material_SUPG_UO[i] = &getUserObjectByName<RichardsSUPG>(getParam<std::vector<UserObjectName> >("SUPG_UO")[i]);
}
}
// DEPRECATED CONSTRUCTOR
NodalMaxVarChange::NodalMaxVarChange(const std::string & deprecated_name, InputParameters parameters) :
NodalVariablePostprocessor(deprecated_name, parameters),
_u_old(coupledValueOld("variable")),
_value(-std::numeric_limits<Real>::max())
{
}
NodalMaxVarChange::NodalMaxVarChange(const InputParameters & parameters) :
NodalVariablePostprocessor(parameters),
_u_old(coupledValueOld("variable")),
_value(-std::numeric_limits<Real>::max())
{
}
ComputeRSphericalIncrementalStrain::ComputeRSphericalIncrementalStrain(const InputParameters & parameters) :
ComputeIncrementalSmallStrain(parameters),
_disp_old_0(coupledValueOld("displacements", 0))
{
}
