BubbleBase::BubbleBase(const InputParameters & parameters)
:Kernel(parameters),
_names(getParam<std::vector<VariableName> >("coupled_conc")),
_this_var(getParam<NonlinearVariableName>("variable")),
_atoms(getParam<std::vector<Real> >("coupled_atoms")),
_widths(getParam<std::vector<Real> >("coupled_widths"))
{
_G = coupledComponents("coupled_conc");
if ( _G != coupledComponents("coupled_rad") )
mooseError("From BubbleBase: The number of coupled concentrations does not match coupled radii.");
if ( _G != _atoms.size() )
mooseError("From BubbleBase: The number of coupled concentrations does not match atom sizes list.");
for ( unsigned int i=0; i<_G; ++i )
{
_c.push_back( &coupledValue("coupled_conc", i) );
_r.push_back( &coupledValue("coupled_rad", i) );
}
// Determine which group current kernel acts on
_g = -1;
for ( unsigned int i=0; i<_G; ++i )
{
if ( _names[i].compare(_this_var) == 0 )
{
_g = i;
break;
}
}
if (_g == -1)
mooseError("From BubbleBase: Variable not found in coupled_conc list. Check the list.");
mooseDoOnce( displayBubbleInfo() );
}
SphericalAverage::SphericalAverage(const InputParameters & parameters)
: ElementVectorPostprocessor(parameters),
_nbins(getParam<unsigned int>("bin_number")),
_radius(getParam<Real>("radius")),
_deltaR(_radius / _nbins),
_nvals(coupledComponents("variable")),
_values(_nvals),
_empty_bin_value(getParam<Real>("empty_bin_value")),
_bin_center(declareVector("radius")),
_counts(_nbins),
_average(_nvals)
{
if (coupledComponents("variable") != 1)
mooseError("SphericalAverage works on exactly one coupled variable");
// Note: We associate the local variable "i" with nbins and "j" with nvals throughout.
// couple variables initialize vectors
for (auto j = beginIndex(_average); j < _nvals; ++j)
{
_values[j] = &coupledValue("variable", j);
_average[j] = &declareVector(getVar("variable", j)->name());
}
// initialize the bin center value vector
_bin_center.resize(_nbins);
for (auto i = beginIndex(_counts); i < _nbins; ++i)
_bin_center[i] = (i + 0.5) * _deltaR;
}
AqueousEquilibriumRxnAux::AqueousEquilibriumRxnAux(const InputParameters & parameters)
: AuxKernel(parameters),
_log_k(coupledValue("log_k")),
_sto_v(getParam<std::vector<Real>>("sto_v")),
_gamma_eq(coupledValue("gamma"))
{
const unsigned int n = coupledComponents("v");
// Check that the correct number of stoichiometric coefficients have been provided
if (_sto_v.size() != n)
mooseError("The number of stoichiometric coefficients in sto_v is not equal to the number of "
"coupled species in ",
_name);
// Check that the correct number of activity coefficients have been provided (if applicable)
if (isCoupled("gamma_v"))
if (coupledComponents("gamma_v") != n)
mooseError("The number of activity coefficients in gamma_v is not equal to the number of "
"coupled species in ",
_name);
_vals.resize(n);
_gamma_v.resize(n);
for (unsigned int i = 0; i < n; ++i)
{
_vals[i] = &coupledValue("v", i);
// If gamma_v has been supplied, use those values, but if not, use the default value
_gamma_v[i] = (isCoupled("gamma_v") ? &coupledValue("gamma_v", i) : &coupledValue("gamma_v"));
}
}
OptionallyVectorCoupledForce::OptionallyVectorCoupledForce(const InputParameters & parameters)
: Kernel(parameters)
{
_v_var.resize(coupledComponents("v"));
_v.resize(coupledComponents("v"));
for (unsigned int j = 0; j < coupledComponents("v"); ++j)
{
_v_var[j] = coupled("v", j);
_v[j] = &coupledValue("v", j);
}
}
ComputeInterfaceStress::ComputeInterfaceStress(const InputParameters & parameters)
: Material(parameters),
_nvar(coupledComponents("v")),
_grad_v(_nvar),
_op_range(getParam<std::vector<Real>>("op_range")),
_stress(getParam<std::vector<Real>>("stress")),
_planar_stress(
declareProperty<RankTwoTensor>(getParam<MaterialPropertyName>("planar_stress_name")))
{
if (_stress.size() == 1)
_stress.assign(_nvar, _stress[0]);
if (_stress.size() != _nvar)
paramError("stress", "Supply either one single stress or one per order parameter");
if (_op_range.size() == 1)
_op_range.assign(_nvar, _op_range[0]);
if (_op_range.size() != _nvar)
paramError("op_range", "Supply either one single op_range or one per order parameter");
for (MooseIndex(_grad_v) i = 0; i < _nvar; ++i)
{
_grad_v[i] = &coupledGradient("v", i);
_stress[i] /= _op_range[i];
}
}
GlobalStrainUserObject::GlobalStrainUserObject(const InputParameters & parameters)
: ElementUserObject(parameters),
_base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
_Cijkl(getMaterialProperty<RankFourTensor>(_base_name + "elasticity_tensor")),
_stress(getMaterialProperty<RankTwoTensor>(_base_name + "stress")),
_dim(_mesh.dimension()),
_ndisp(coupledComponents("displacements")),
_disp_var(_ndisp),
_periodic_dir()
{
for (unsigned int i = 0; i < _ndisp; ++i)
_disp_var[i] = coupled("displacements", i);
for (unsigned int dir = 0; dir < _dim; ++dir)
{
_periodic_dir(dir) = _mesh.isTranslatedPeriodic(_disp_var[0], dir);
for (unsigned int i = 1; i < _ndisp; ++i)
if (_mesh.isTranslatedPeriodic(_disp_var[i], dir) != _periodic_dir(dir))
mooseError("All the displacement components in a particular direction should have same "
"periodicity.");
}
if (isParamValid("applied_stress_tensor"))
_applied_stress_tensor.fillFromInputVector(
getParam<std::vector<Real>>("applied_stress_tensor"));
else
_applied_stress_tensor.zero();
}
CosseratLinearElasticMaterial::CosseratLinearElasticMaterial(const InputParameters & parameters) :
TensorMechanicsMaterial(parameters),
_curvature(declareProperty<RankTwoTensor>("curvature")),
_stress_couple(declareProperty<RankTwoTensor>("couple_stress")),
_elastic_flexural_rigidity_tensor(declareProperty<RankFourTensor>("elastic_flexural_rigidity_tensor")),
_Jacobian_mult_couple(declareProperty<RankFourTensor>("couple_Jacobian_mult")),
_Bijkl_vector(getParam<std::vector<Real> >("B_ijkl")),
_Bijkl(),
_T(coupledValue("T")),
_thermal_expansion_coeff(getParam<Real>("thermal_expansion_coeff")),
_T0(getParam<Real>("T0")),
_applied_strain_vector(getParam<std::vector<Real> >("applied_strain_vector")),
_nrots(coupledComponents("Cosserat_rotations")),
_wc(_nrots),
_grad_wc(_nrots),
_fill_method_bending(getParam<MooseEnum>("fill_method_bending"))
{
if (_nrots != 3)
mooseError("CosseratLinearElasticMaterial: 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);
_grad_wc[i] = &coupledGradient("Cosserat_rotations", i);
}
//Initialize applied strain tensor from input vector
if (_applied_strain_vector.size() == 6)
_applied_strain_tensor.fillFromInputVector(_applied_strain_vector);
else
_applied_strain_tensor.zero();
_Bijkl.fillFromInputVector(_Bijkl_vector, (RankFourTensor::FillMethod)(int)_fill_method_bending);
}
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;
}
ExternalForceDensityMaterial::ExternalForceDensityMaterial(const InputParameters & parameters)
: DerivativeMaterialInterface<Material>(parameters),
_force_x(getFunction("force_x")),
_force_y(getFunction("force_y")),
_force_z(getFunction("force_z")),
_c(coupledValue("c")),
_c_name(getVar("c", 0)->name()),
_k(getParam<Real>("k")),
_op_num(coupledComponents(
"etas")), // determine number of grains from the number of names passed in.
_vals(_op_num), // Size variable arrays
_vals_name(_op_num),
_dF(declareProperty<std::vector<RealGradient>>("force_density_ext")),
_dFdc(declarePropertyDerivative<std::vector<RealGradient>>("force_density_ext", _c_name)),
_dFdeta(_op_num)
{
// Loop through grains and load coupled variables into the arrays
for (unsigned int i = 0; i < _op_num; ++i)
{
_vals[i] = &coupledValue("etas", i);
_vals_name[i] = getVar("etas", i)->name();
_dFdeta[i] =
&declarePropertyDerivative<std::vector<RealGradient>>("force_density_ext", _vals_name[i]);
}
}
ComputeVariableEigenstrain::ComputeVariableEigenstrain(const InputParameters & parameters) :
ComputeEigenstrain(parameters),
_num_args(coupledComponents("args")),
_dprefactor(_num_args),
_d2prefactor(_num_args),
_delastic_strain(_num_args),
_d2elastic_strain(_num_args)
{
// fetch prerequisite derivatives and build elastic_strain derivatives and cross-derivatives
for (unsigned int i = 0; i < _num_args; ++i)
{
const VariableName & iname = getVar("args", i)->name();
_dprefactor[i] = &getMaterialPropertyDerivative<Real>("prefactor", iname);
_delastic_strain[i] = &declarePropertyDerivative<RankTwoTensor>(_base_name + "elastic_strain", iname);
_d2prefactor[i].resize(_num_args);
_d2elastic_strain[i].resize(_num_args);
for (unsigned int j = i; j < _num_args; ++j)
{
const VariableName & jname = getVar("args", j)->name();
_d2prefactor[i][j] = &getMaterialPropertyDerivative<Real>("prefactor", iname, jname);
_d2elastic_strain[i][j] = &declarePropertyDerivative<RankTwoTensor>(_base_name + "elastic_strain", iname, jname);
}
}
}
NucleationLocationUserObject::NucleationLocationUserObject(const InputParameters & parameters) :
ElementUserObject(parameters),
_mesh(_subproblem.mesh()),
//_coupled_probability(coupledValue("coupled_aux")),
_n_coupled_aux(getParam<int>("n_coupled_aux")),
_dwell_time(getParam<Real>("dwell_time")),
_num_orientations(getParam<int>("num_orientations")),
_boundary_width(getParam<Real>("boundary_width")),
_random_seed(getParam<int>("random_seed")),
// _counter(0),
//make restartable
_counter(declareRestartableData<int>("counter", 0)),
_phase_gen_index(std::numeric_limits<unsigned int>::max()),
// _nuclei(0),
//make restartable
_nuclei(declareRestartableData<std::vector<Nucleus> >("nuclei")),
//_old_nucleus_list_size(0),
//make restartable
_old_nucleus_list_size(declareRestartableData<unsigned int>("old_nucleus_list_size", 0)),
_has_new_nucleus(false),
_master_random(-1000),
_slave_random(-100)
{
if(_n_coupled_aux != coupledComponents("coupled_aux_vars"))
mooseError("Please specify the correct # of coupled probabilities (NucleationLocationUserObject).");
_coupled_probability.resize(_n_coupled_aux);
for(unsigned int i=0; i<_n_coupled_aux; i++)
_coupled_probability[i] = &coupledValue("coupled_aux_vars", i);
}
PorousFlowDictator::PorousFlowDictator(const InputParameters & parameters)
: GeneralUserObject(parameters),
Coupleable(this, false),
_num_variables(coupledComponents("porous_flow_vars")),
_num_phases(getParam<unsigned int>("number_fluid_phases")),
_num_components(getParam<unsigned int>("number_fluid_components"))
{
_moose_var_num.resize(_num_variables);
for (unsigned int i = 0; i < _num_variables; ++i)
_moose_var_num[i] = coupled("porous_flow_vars", i);
_pf_var_num.assign(_fe_problem.getNonlinearSystemBase().nVariables(),
_num_variables); // Note: the _num_variables assignment indicates that "this is
// not a PorousFlow variable"
for (unsigned int i = 0; i < _num_variables; ++i)
if (_moose_var_num[i] < _pf_var_num.size())
_pf_var_num[_moose_var_num[i]] = i;
else
// should not couple AuxVariables to the Dictator (Jacobian entries are not calculated for
// them)
mooseError("PorousFlowDictator: AuxVariables variables must not be coupled into the Dictator "
"for this is against specification #1984. Variable number ",
i,
" is an AuxVariable.");
}
PorousFlowMassFraction::PorousFlowMassFraction(const InputParameters & parameters) :
DerivativeMaterialInterface<Material>(parameters),
_dictator_UO(getUserObject<PorousFlowDictator>("PorousFlowDictator_UO")),
_num_phases(_dictator_UO.numPhases()),
_num_components(_dictator_UO.numComponents()),
_mass_frac(declareProperty<std::vector<std::vector<Real> > >("PorousFlow_mass_frac")),
_mass_frac_old(declarePropertyOld<std::vector<std::vector<Real> > >("PorousFlow_mass_frac")),
_grad_mass_frac(declareProperty<std::vector<std::vector<RealGradient> > >("PorousFlow_grad_mass_frac")),
_dmass_frac_dvar(declareProperty<std::vector<std::vector<std::vector<Real> > > >("dPorousFlow_mass_frac_dvar")),
_yaqi_hacky(false),
_num_passed_mf_vars(coupledComponents("mass_fraction_vars"))
{
if (_num_phases < 1 || _num_components < 1)
mooseError("PorousFlowMassFraction: The Dictator proclaims that the number of phases is " << _num_phases << " and the number of components is " << _num_components << ", and stipulates that you should not use PorousFlowMassFraction in this case");
if (_num_passed_mf_vars != _num_phases*(_num_components - 1))
mooseError("PorousFlowMassFraction: The number of mass_fraction_vars is " << _num_passed_mf_vars << " which must be equal to the Dictator's num_phases (" << _num_phases << ") multiplied by num_components-1 (" << _num_components - 1 << ")");
_mf_vars_num.resize(_num_passed_mf_vars);
_mf_vars.resize(_num_passed_mf_vars);
_grad_mf_vars.resize(_num_passed_mf_vars);
for (unsigned i = 0; i < _num_passed_mf_vars; ++i)
{
_mf_vars_num[i] = coupled("mass_fraction_vars", i);
_mf_vars[i] = &coupledNodalValue("mass_fraction_vars", i);
_grad_mf_vars[i] = &coupledGradient("mass_fraction_vars", i);
}
}
GlobalDisplacementAux::GlobalDisplacementAux(const InputParameters & parameters)
: AuxKernel(parameters),
_scalar_global_strain(coupledScalarValue("scalar_global_strain")),
_component(getParam<unsigned int>("component")),
_output_global_disp(getParam<bool>("output_global_displacement")),
_pst(getUserObject<GlobalStrainUserObjectInterface>("global_strain_uo")),
_periodic_dir(_pst.getPeriodicDirections()),
_dim(_mesh.dimension()),
_ndisp(coupledComponents("displacements")),
_disp(_ndisp)
{
if (!isNodal())
paramError("variable", "GlobalDisplacementAux must be used on a nodal auxiliary variable");
if (_component >= _dim)
paramError("component",
"The component ",
_component,
" does not exist for ",
_dim,
" dimensional problems");
for (unsigned int i = 0; i < _ndisp; ++i)
_disp[i] = &coupledValue("displacements", i);
}
SwitchingFunctionConstraintLagrange::SwitchingFunctionConstraintLagrange(const std::string & name, InputParameters parameters) :
DerivativeMaterialInterface<Kernel>(name, parameters),
_h_names(getParam<std::vector<std::string> >("h_names")),
_num_h(_h_names.size()),
_h(_num_h),
_dh(_num_h),
_number_of_nl_variables(_fe_problem.getNonlinearSystem().nVariables()),
_j_eta(_number_of_nl_variables, -1),
_epsilon(getParam<Real>("epsilon"))
{
// parameter check. We need exactly one eta per h
if (_num_h != coupledComponents("etas"))
mooseError("Need to pass in as many h_names as etas in SwitchingFunctionConstraintLagrange kernel " << name);
// fetch switching functions (for the residual) and h derivatives (for the Jacobian)
for (unsigned int i = 0; i < _num_h; ++i)
{
_h[i] = &getMaterialProperty<Real>(_h_names[i]);
_dh[i] = &getMaterialPropertyDerivative<Real>(_h_names[i], getVar("etas", i)->name());
// generate the lookup table from j_var -> eta index
unsigned int num = coupled("etas", i);
if (num < _number_of_nl_variables)
_j_eta[num] = i;
}
}
StressDivergenceTensors::StressDivergenceTensors(const InputParameters & parameters)
: ALEKernel(parameters),
_base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
_use_finite_deform_jacobian(getParam<bool>("use_finite_deform_jacobian")),
_stress(getMaterialPropertyByName<RankTwoTensor>(_base_name + "stress")),
_Jacobian_mult(getMaterialPropertyByName<RankFourTensor>(_base_name + "Jacobian_mult")),
_component(getParam<unsigned int>("component")),
_ndisp(coupledComponents("displacements")),
_disp_var(_ndisp),
_temp_coupled(isCoupled("temperature")),
_temp_var(_temp_coupled ? coupled("temperature") : 0),
_avg_grad_test(_test.size(), std::vector<Real>(3, 0.0)),
_avg_grad_phi(_phi.size(), std::vector<Real>(3, 0.0)),
_volumetric_locking_correction(getParam<bool>("volumetric_locking_correction"))
{
for (unsigned int i = 0; i < _ndisp; ++i)
_disp_var[i] = coupled("displacements", i);
// Checking for consistency between mesh size and length of the provided displacements vector
if (_ndisp != _mesh.dimension())
mooseError("The number of displacement variables supplied must match the mesh dimension.");
if (_use_finite_deform_jacobian)
{
_deformation_gradient =
&getMaterialProperty<RankTwoTensor>(_base_name + "deformation_gradient");
_deformation_gradient_old =
&getMaterialPropertyOld<RankTwoTensor>(_base_name + "deformation_gradient");
_rotation_increment = &getMaterialProperty<RankTwoTensor>(_base_name + "rotation_increment");
}
// Error if volumetic locking correction is turned on for 1D problems
if (_ndisp == 1 && _volumetric_locking_correction)
mooseError("Volumetric locking correction should be set to false for 1-D problems.");
}
CHPrecipMatrixElasticity::CHPrecipMatrixElasticity(const InputParameters & parameters)
: SplitCHCRes(parameters),
_elasticity_tensor(getMaterialProperty<RankFourTensor>("elasticity_tensor")),
_dn_elasticity_tensor(getMaterialProperty<std::vector<RankFourTensor> >("dn_elasticity_tensor")),
_elastic_strain(getMaterialProperty<RankTwoTensor>("elastic_strain")),
_dc_misfit_strain(getMaterialProperty<RankTwoTensor>("dc_misfit_strain")),
_dn_misfit_strain(getMaterialProperty<std::vector<RankTwoTensor> >("dn_misfit_strain")),
_dcdn_misfit_strain(getMaterialProperty<std::vector<RankTwoTensor> >("dcdn_misfit_strain")),
_scaling_factor(getParam<Real>("scaling_factor")),
_n_OP_vars(getParam<int>("n_OP_vars")),
_w_var(coupled("w")),
_T_var(coupled("T"))
{
if(_n_OP_vars != coupledComponents("OP_var_names"))
mooseError("Please match the number of orientation variants to coupled OPs (ACCoupledCalphad).");
_n_var.resize(_n_OP_vars);
_OP.resize(_n_OP_vars);
for (unsigned int i=0; i<_n_OP_vars; i++)
{
_n_var[i] = coupled("OP_var_names", i);
_OP[i] = &coupledValue("OP_var_names", i);
}
}
CoupledConvectionReactionSub::CoupledConvectionReactionSub(const std::string & name, InputParameters parameters)
// You must call the constructor of the base class first
:Kernel(name,parameters),
// coupledGradient will give us a reference to the gradient of another
// variable in the computation. We are going to use the gradient of p
// to calculate our velocity vector.
_weight(getParam<Real>("weight")),
_log_k (getParam<Real>("log_k")),
_sto_u(getParam<Real>("sto_u")),
_sto_v(getParam<std::vector<Real> >("sto_v")),
_cond(getMaterialProperty<Real>("conductivity")),
_grad_p(coupledGradient("p"))
{
int n = coupledComponents("v");
_vars.resize(n);
_vals.resize(n);
_grad_vals.resize(n);
for (unsigned int i=0; i<_vals.size(); ++i)
{
_vars[i] = coupled("v", i);
_vals[i] = &coupledValue("v", i);
_grad_vals[i] = &coupledGradient("v", i);
}
}
PorousFlowAqueousPreDisMineral::PorousFlowAqueousPreDisMineral(const InputParameters & parameters)
: PorousFlowMaterialVectorBase(parameters),
_num_reactions(_dictator.numAqueousKinetic()),
_sec_conc(_nodal_material
? declareProperty<std::vector<Real>>("PorousFlow_mineral_concentration_nodal")
: declareProperty<std::vector<Real>>("PorousFlow_mineral_concentration_qp")),
_porosity_old(_nodal_material ? getMaterialPropertyOld<Real>("PorousFlow_porosity_nodal")
: getMaterialPropertyOld<Real>("PorousFlow_porosity_qp")),
_sec_conc_old(
_nodal_material
? getMaterialPropertyOld<std::vector<Real>>("PorousFlow_mineral_concentration_nodal")
: getMaterialPropertyOld<std::vector<Real>>("PorousFlow_mineral_concentration_qp")),
_reaction_rate(
_nodal_material
? getMaterialProperty<std::vector<Real>>("PorousFlow_mineral_reaction_rate_nodal")
: getMaterialProperty<std::vector<Real>>("PorousFlow_mineral_reaction_rate_qp")),
_initial_conc_supplied(isParamValid("initial_concentrations")),
_num_initial_conc(_initial_conc_supplied ? coupledComponents("initial_concentrations")
: _num_reactions)
{
if (_num_initial_conc != _dictator.numAqueousKinetic())
mooseError("PorousFlowAqueousPreDisMineral: The number of initial concentrations is ",
_num_initial_conc,
" but the Dictator knows that the number of aqueous kinetic "
"(precipitation-dissolution) reactions is ",
_dictator.numAqueousKinetic());
_initial_conc.resize(_num_initial_conc);
if (_initial_conc_supplied)
for (unsigned r = 0; r < _num_reactions; ++r)
_initial_conc[r] = (_nodal_material ? &coupledNodalValue("initial_concentrations", r)
: &coupledValue("initial_concentrations", r));
}
GapHeatTransfer::GapHeatTransfer(const InputParameters & parameters)
: IntegratedBC(parameters),
_gap_geometry_params_set(false),
_gap_geometry_type(GapConductance::PLATE),
_quadrature(getParam<bool>("quadrature")),
_slave_flux(!_quadrature ? &_sys.getVector("slave_flux") : NULL),
_gap_conductance(getMaterialProperty<Real>("gap_conductance" +
getParam<std::string>("appended_property_name"))),
_gap_conductance_dT(getMaterialProperty<Real>(
"gap_conductance" + getParam<std::string>("appended_property_name") + "_dT")),
_min_gap(getParam<Real>("min_gap")),
_max_gap(getParam<Real>("max_gap")),
_gap_temp(0),
_gap_distance(std::numeric_limits<Real>::max()),
_edge_multiplier(1.0),
_has_info(false),
_disp_vars(3, libMesh::invalid_uint),
_gap_distance_value(_quadrature ? _zero : coupledValue("gap_distance")),
_gap_temp_value(_quadrature ? _zero : coupledValue("gap_temp")),
_penetration_locator(
!_quadrature ? NULL
: &getQuadraturePenetrationLocator(
parameters.get<BoundaryName>("paired_boundary"),
getParam<std::vector<BoundaryName>>("boundary")[0],
Utility::string_to_enum<Order>(parameters.get<MooseEnum>("order")))),
_warnings(getParam<bool>("warnings"))
{
if (isParamValid("displacements"))
{
// modern parameter scheme for displacements
for (unsigned int i = 0; i < coupledComponents("displacements"); ++i)
_disp_vars[i] = coupled("displacements", i);
}
else
{
// Legacy parameter scheme for displacements
if (isParamValid("disp_x"))
_disp_vars[0] = coupled("disp_x");
if (isParamValid("disp_y"))
_disp_vars[1] = coupled("disp_y");
if (isParamValid("disp_z"))
_disp_vars[2] = coupled("disp_z");
// TODO: these are only used in one Bison test. Deprecate soon!
}
if (_quadrature)
{
if (!parameters.isParamValid("paired_boundary"))
mooseError(std::string("No 'paired_boundary' provided for ") + _name);
}
else
{
if (!isCoupled("gap_distance"))
mooseError(std::string("No 'gap_distance' provided for ") + _name);
if (!isCoupled("gap_temp"))
mooseError(std::string("No 'gap_temp' provided for ") + _name);
}
}
WaterSaturationTemperatureAux::WaterSaturationTemperatureAux(const std::string & name, InputParameters parameters)
:AuxKernel(name, parameters),
_p(coupledValue("pressure"))
{
int n = coupledComponents("concentration");
_vals.resize(n);
for (unsigned int i=0; i<_vals.size(); ++i)
_vals[i] = & coupledValue("concentration", i);
}
BndsCalcAux::BndsCalcAux(const InputParameters & parameters) :
AuxKernel(parameters)
{
_ncrys = coupledComponents("v");
_vals.resize(_ncrys);
for (unsigned int i=0; i < _ncrys; ++i)
_vals[i] = &coupledValue("v", i);
}
BndsCalcAux::BndsCalcAux(const std::string & name, InputParameters parameters) :
AuxKernel(name, AddV(parameters) )
{
_ncrys = coupledComponents("v");
_vals.resize(_ncrys);
for (unsigned int i=0; i < _ncrys; ++i)
_vals[i] = &coupledValue("v", i);
}
Density::Density(const InputParameters & parameters)
: Material(parameters),
_is_coupled(true),
_disp_r(isCoupled("displacements") ? coupledValue("displacements", 0)
: (isCoupled("disp_r") ? coupledValue("disp_r") : _zero)),
_orig_density(getParam<Real>("density")),
_density(declareProperty<Real>("density")),
_density_old(declarePropertyOld<Real>("density"))
{
// new parameter scheme
if (isCoupled("displacements"))
{
// get coordinate system
_coord_system = getBlockCoordSystem();
// get coupled gradients
const unsigned int ndisp = coupledComponents("displacements");
_grad_disp.resize(ndisp);
for (unsigned int i = 0; i < ndisp; ++i)
_grad_disp[i] = &coupledGradient("displacements", i);
// fill remaining components with zero
_grad_disp.resize(3, &_grad_zero);
}
// old deprecated parameters
else if (isCoupled("disp_x") || isCoupled("disp_r"))
{
// guess(!) coordinate system
if (isCoupled("disp_r"))
{
if (isCoupled("disp_z"))
_coord_system = Moose::COORD_RZ;
else
_coord_system = Moose::COORD_RSPHERICAL;
}
else
_coord_system = Moose::COORD_XYZ;
// couple gradients
_grad_disp = {
isCoupled("disp_x") ? &coupledGradient("disp_x")
: (isCoupled("disp_r") ? &coupledGradient("disp_r") : &_grad_zero),
isCoupled("disp_y") ? &coupledGradient("disp_y")
: (isCoupled("disp_z") ? &coupledGradient("disp_z") : &_grad_zero),
_coord_system != Moose::COORD_RZ && isCoupled("disp_z") ? &coupledGradient("disp_z")
: &_grad_zero};
}
// no coupling
else
{
_is_coupled = false;
// TODO: We should deprecate this case and have the user use a GenericConstantMaterial for this
}
}
RichardsSeffAux::RichardsSeffAux(const std::string & name, InputParameters parameters) :
AuxKernel(name, parameters),
_seff_UO(getUserObject<RichardsSeff>("seff_UO"))
{
int n = coupledComponents("pressure_vars");
_pressure_vals.resize(n);
for (int i=0 ; i<n; ++i)
_pressure_vals[i] = &coupledValue("pressure_vars", i);
}
AqueousEquilibriumRxnAux::AqueousEquilibriumRxnAux(const InputParameters & parameters) :
AuxKernel(parameters),
_log_k(getParam<Real>("log_k")),
_sto_v(getParam<std::vector<Real> >("sto_v"))
{
int n = coupledComponents("v");
_vals.resize(n);
for (unsigned int i=0; i<_vals.size(); ++i)
_vals[i] = &coupledValue("v", i);
}
MultipleUpdateElemAux::MultipleUpdateElemAux(const InputParameters & parameters) :
AuxKernel(parameters),
_n_vars(coupledComponents("vars"))
{
for (unsigned int i=0; i<_n_vars; i++)
{
_vars.push_back(getVar("vars", i));
if (_vars[i]->isNodal()) mooseError("variables have to be elemental");
}
if (isNodal()) mooseError("variable have to be elemental");
}
ComputeGrainCenterUserObject::ComputeGrainCenterUserObject(const InputParameters & parameters) :
ElementUserObject(parameters),
_ncrys(coupledComponents("etas")), //determine number of grains from the number of names passed in. Note this is the actual number -1
_vals(_ncrys), //Size variable arrays
_ncomp(4*_ncrys),
_grain_data(_ncomp),
_grain_volumes(_ncrys),
_grain_centers(_ncrys)
{
for (unsigned int i = 0; i < _ncrys; ++i)
_vals[i] = &coupledValue("etas", i);
}
AdvectionBC::AdvectionBC(const InputParameters & parameters)
: IntegratedBC(parameters), _dim(_mesh.dimension()), _outflow(getParam<bool>("outflow"))
{
// check if # components matches mesh's dim
if (_dim != coupledComponents("velocity_vector"))
paramError("velocity_vector",
"Number of components of velocity_vector must match mesh dimension");
_velocity.resize(_dim);
for (unsigned int j = 0; j < _dim; ++j)
_velocity[j] = &coupledValue("velocity_vector", j);
}
ACGrGrMulti::ACGrGrMulti(const InputParameters & parameters) :
ACGrGrBase(parameters),
_gamma_names(getParam<std::vector<MaterialPropertyName> >("gamma_names")),
_num_j(_gamma_names.size()),
_prop_gammas(_num_j)
{
// check passed in parameter vectors
if (_num_j != coupledComponents("v") )
mooseError("Need to pass in as many gamma_names as coupled variables in v in ACGrGrMulti" << name());
for (unsigned int n = 0; n < _num_j; ++n)
_prop_gammas[n] = &getMaterialPropertyByName<Real>(_gamma_names[n]);
}
