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)) { }