PorousFlow2PhasePP::PorousFlow2PhasePP(const InputParameters & parameters)
: PorousFlowVariableBase(parameters),
_phase0_porepressure(_nodal_material ? coupledNodalValue("phase0_porepressure")
: coupledValue("phase0_porepressure")),
_phase0_gradp_qp(coupledGradient("phase0_porepressure")),
_phase0_porepressure_varnum(coupled("phase0_porepressure")),
_p0var(_dictator.isPorousFlowVariable(_phase0_porepressure_varnum)
? _dictator.porousFlowVariableNum(_phase0_porepressure_varnum)
: 0),
_phase1_porepressure(_nodal_material ? coupledNodalValue("phase1_porepressure")
: coupledValue("phase1_porepressure")),
_phase1_gradp_qp(coupledGradient("phase1_porepressure")),
_phase1_porepressure_varnum(coupled("phase1_porepressure")),
_p1var(_dictator.isPorousFlowVariable(_phase1_porepressure_varnum)
? _dictator.porousFlowVariableNum(_phase1_porepressure_varnum)
: 0),
_pc_uo(parameters.isParamSetByUser("capillary_pressure")
? &getUserObject<PorousFlowCapillaryPressure>("capillary_pressure")
: nullptr)
{
if (_num_phases != 2)
mooseError("The Dictator announces that the number of phases is ",
_dictator.numPhases(),
" whereas PorousFlow2PhasePP can only be used for 2-phase simulation. When you "
"have an efficient government, you have a dictatorship.");
}
PorousFlow2PhasePS::PorousFlow2PhasePS(const InputParameters & parameters)
: PorousFlowVariableBase(parameters),
_phase0_porepressure(_nodal_material ? coupledNodalValue("phase0_porepressure")
: coupledValue("phase0_porepressure")),
_phase0_gradp_qp(coupledGradient("phase0_porepressure")),
_phase0_porepressure_varnum(coupled("phase0_porepressure")),
_pvar(_dictator.isPorousFlowVariable(_phase0_porepressure_varnum)
? _dictator.porousFlowVariableNum(_phase0_porepressure_varnum)
: 0),
_phase1_saturation(_nodal_material ? coupledNodalValue("phase1_saturation")
: coupledValue("phase1_saturation")),
_phase1_grads_qp(coupledGradient("phase1_saturation")),
_phase1_saturation_varnum(coupled("phase1_saturation")),
_svar(_dictator.isPorousFlowVariable(_phase1_saturation_varnum)
? _dictator.porousFlowVariableNum(_phase1_saturation_varnum)
: 0),
_sat_lr(getParam<Real>("sat_lr")),
_dseff_ds(1.0 / (1.0 - _sat_lr)),
_pc_uo(parameters.isParamSetByUser("capillary_pressure")
? &getUserObject<PorousFlowCapillaryPressure>("capillary_pressure")
: nullptr)
{
if (_dictator.numPhases() != 2)
mooseError("The Dictator proclaims that the number of phases is ",
_dictator.numPhases(),
" whereas PorousFlow2PhasePS can only be used for 2-phase simulation. Be aware "
"that the Dictator has noted your mistake.");
}
StatefulTest::StatefulTest(const InputParameters & parameters)
: Material(parameters),
_coupled_val(isParamValid("coupled") ? &coupledNodalValue("coupled") : nullptr),
_prop_names(getParam<std::vector<std::string>>("prop_names")),
_prop_values(getParam<std::vector<Real>>("prop_values"))
{
unsigned int num_names = _prop_names.size();
unsigned int num_values = _prop_values.size();
if (num_names != num_values)
mooseError(
"Number of prop_names must match the number of prop_values for StatefulTest material!");
_num_props = num_names;
_properties.resize(num_names);
_properties_old.resize(num_names);
_properties_older.resize(num_names);
for (unsigned int i = 0; i < _num_props; ++i)
{
_properties[i] = &declareProperty<Real>(_prop_names[i]);
_properties_old[i] = &getMaterialPropertyOld<Real>(_prop_names[i]);
_properties_older[i] = &getMaterialPropertyOlder<Real>(_prop_names[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));
}
PorousFlowVariableBase::PorousFlowVariableBase(const InputParameters & parameters) :
DerivativeMaterialInterface<Material>(parameters),
_dictator(getUserObject<PorousFlowDictator>("PorousFlowDictator")),
_num_phases(_dictator.numPhases()),
_num_components(_dictator.numComponents()),
_num_pf_vars(_dictator.numVariables()),
_temperature_nodal_var(coupledNodalValue("temperature")),
_temperature_qp_var(coupledValue("temperature")),
_temperature_varnum(coupled("temperature")),
_porepressure_nodal(declareProperty<std::vector<Real> >("PorousFlow_porepressure_nodal")),
_porepressure_nodal_old(declarePropertyOld<std::vector<Real> >("PorousFlow_porepressure_nodal")),
_porepressure_qp(declareProperty<std::vector<Real> >("PorousFlow_porepressure_qp")),
_gradp_qp(declareProperty<std::vector<RealGradient> >("PorousFlow_grad_porepressure_qp")),
_dporepressure_nodal_dvar(declareProperty<std::vector<std::vector<Real> > >("dPorousFlow_porepressure_nodal_dvar")),
_dporepressure_qp_dvar(declareProperty<std::vector<std::vector<Real> > >("dPorousFlow_porepressure_qp_dvar")),
_dgradp_qp_dgradv(declareProperty<std::vector<std::vector<Real> > >("dPorousFlow_grad_porepressure_qp_dgradvar")),
_dgradp_qp_dv(declareProperty<std::vector<std::vector<RealGradient> > >("dPorousFlow_grad_porepressure_qp_dvar")),
_saturation_nodal(declareProperty<std::vector<Real> >("PorousFlow_saturation_nodal")),
_saturation_nodal_old(declarePropertyOld<std::vector<Real> >("PorousFlow_saturation_nodal")),
_saturation_qp(declareProperty<std::vector<Real> >("PorousFlow_saturation_qp")),
_grads_qp(declareProperty<std::vector<RealGradient> >("PorousFlow_grad_saturation_qp")),
_dsaturation_nodal_dvar(declareProperty<std::vector<std::vector<Real> > >("dPorousFlow_saturation_nodal_dvar")),
_dsaturation_qp_dvar(declareProperty<std::vector<std::vector<Real> > >("dPorousFlow_saturation_qp_dvar")),
_dgrads_qp_dgradv(declareProperty<std::vector<std::vector<Real> > >("dPorousFlow_grad_saturation_qp_dgradvar")),
_dgrads_qp_dv(declareProperty<std::vector<std::vector<RealGradient> > >("dPorousFlow_grad_saturation_qp_dv")),
_temperature_nodal(declareProperty<std::vector<Real> >("PorousFlow_temperature_nodal")),
_temperature_qp(declareProperty<std::vector<Real> >("PorousFlow_temperature_qp")),
_dtemperature_nodal_dvar(declareProperty<std::vector<std::vector<Real> > >("dPorousFlow_temperature_nodal_dvar")),
_dtemperature_qp_dvar(declareProperty<std::vector<std::vector<Real> > >("dPorousFlow_temperature_qp_dvar"))
{
}
PorousFlowTemperature::PorousFlowTemperature(const InputParameters & parameters)
: DerivativeMaterialInterface<PorousFlowMaterial>(parameters),
_num_pf_vars(_dictator.numVariables()),
_temperature_var(_nodal_material ? coupledNodalValue("temperature")
: coupledValue("temperature")),
_grad_temperature_var(_nodal_material ? nullptr : &coupledGradient("temperature")),
_temperature_is_PF(_dictator.isPorousFlowVariable(coupled("temperature"))),
_t_var_num(_temperature_is_PF ? _dictator.porousFlowVariableNum(coupled("temperature")) : 0),
_temperature(_nodal_material ? declareProperty<Real>("PorousFlow_temperature_nodal")
: declareProperty<Real>("PorousFlow_temperature_qp")),
_dtemperature_dvar(
_nodal_material ? declareProperty<std::vector<Real>>("dPorousFlow_temperature_nodal_dvar")
: declareProperty<std::vector<Real>>("dPorousFlow_temperature_qp_dvar")),
_grad_temperature(_nodal_material
? nullptr
: &declareProperty<RealGradient>("PorousFlow_grad_temperature_qp")),
_dgrad_temperature_dgradv(_nodal_material ? nullptr
: &declareProperty<std::vector<Real>>(
"dPorousFlow_grad_temperature_qp_dgradvar")),
_dgrad_temperature_dv(_nodal_material ? nullptr
: &declareProperty<std::vector<RealGradient>>(
"dPorousFlow_grad_temperature_qp_dvar"))
{
}
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);
}
}
StatefulTest::StatefulTest(const InputParameters & parameters) :
Material(parameters),
_thermal_conductivity(declareProperty<Real>("thermal_conductivity")),
_thermal_conductivity_old(declarePropertyOld<Real>("thermal_conductivity")),
_thermal_conductivity_older(declarePropertyOlder<Real>("thermal_conductivity")),
_coupled_val(isParamValid("coupled") ? &coupledNodalValue("coupled") : nullptr)
{
}
Q2PNodalMass::Q2PNodalMass(const InputParameters & parameters) :
TimeKernel(parameters),
_density(getUserObject<RichardsDensity>("fluid_density")),
_other_var_nodal(coupledNodalValue("other_var")),
_other_var_num(coupled("other_var")),
_var_is_pp(getParam<bool>("var_is_porepressure")),
_porosity(getMaterialProperty<Real>("porosity"))
{
}
PorousFlow2PhasePP::PorousFlow2PhasePP(const InputParameters & parameters) :
PorousFlowVariableBase(parameters),
_phase0_porepressure_nodal(coupledNodalValue("phase0_porepressure")),
_phase0_porepressure_qp(coupledValue("phase0_porepressure")),
_phase0_gradp_qp(coupledGradient("phase0_porepressure")),
_phase0_porepressure_varnum(coupled("phase0_porepressure")),
_p0var(_dictator_UO.isPorousFlowVariable(_phase0_porepressure_varnum) ? _dictator_UO.porousFlowVariableNum(_phase0_porepressure_varnum) : 0),
_phase1_porepressure_nodal(coupledNodalValue("phase1_porepressure")),
_phase1_porepressure_qp(coupledValue("phase1_porepressure")),
_phase1_gradp_qp(coupledGradient("phase1_porepressure")),
_phase1_porepressure_varnum(coupled("phase1_porepressure")),
_p1var(_dictator_UO.isPorousFlowVariable(_phase1_porepressure_varnum) ? _dictator_UO.porousFlowVariableNum(_phase1_porepressure_varnum) : 0),
_tvar(_dictator_UO.isPorousFlowVariable(_temperature_varnum) ? _dictator_UO.porousFlowVariableNum(_temperature_varnum) : 0)
{
if (_dictator_UO.numPhases() != 2)
mooseError("The Dictator announces that the number of phases is " << _dictator_UO.numPhases() << " whereas PorousFlow2PhasePP can only be used for 2-phase simulation. When you have an efficient government, you have a dictatorship.");
}
PorousFlow2PhasePS::PorousFlow2PhasePS(const InputParameters & parameters) :
PorousFlowVariableBase(parameters),
_phase0_porepressure_nodal(coupledNodalValue("phase0_porepressure")),
_phase0_porepressure_qp(coupledValue("phase0_porepressure")),
_phase0_gradp_qp(coupledGradient("phase0_porepressure")),
_phase0_porepressure_varnum(coupled("phase0_porepressure")),
_pvar(_dictator.isPorousFlowVariable(_phase0_porepressure_varnum) ? _dictator.porousFlowVariableNum(_phase0_porepressure_varnum) : 0),
_phase1_saturation_nodal(coupledNodalValue("phase1_saturation")),
_phase1_saturation_qp(coupledValue("phase1_saturation")),
_phase1_grads_qp(coupledGradient("phase1_saturation")),
_phase1_saturation_varnum(coupled("phase1_saturation")),
_svar(_dictator.isPorousFlowVariable(_phase1_saturation_varnum) ? _dictator.porousFlowVariableNum(_phase1_saturation_varnum) : 0),
_tvar(_dictator.isPorousFlowVariable(_temperature_varnum) ? _dictator.porousFlowVariableNum(_temperature_varnum) : 0),
_pc(getParam<Real>("pc"))
{
if (_dictator.numPhases() != 2)
mooseError("The Dictator proclaims that the number of phases is " << _dictator.numPhases() << " whereas PorousFlow2PhasePS can only be used for 2-phase simulation. Be aware that the Dictator has noted your mistake.");
}
Q2PPorepressureFlux::Q2PPorepressureFlux(const InputParameters & parameters)
: Kernel(parameters),
_density(getUserObject<RichardsDensity>("fluid_density")),
_sat(coupledNodalValue("saturation_variable")),
_sat_var(coupled("saturation_variable")),
_relperm(getUserObject<RichardsRelPerm>("fluid_relperm")),
_viscosity(getParam<Real>("fluid_viscosity")),
_gravity(getMaterialProperty<RealVectorValue>("gravity")),
_permeability(getMaterialProperty<RealTensorValue>("permeability")),
_num_nodes(0),
_mobility(0),
_dmobility_dp(0),
_dmobility_ds(0)
{
}
PorousFlow1PhaseFullySaturated::PorousFlow1PhaseFullySaturated(const InputParameters & parameters)
: PorousFlowVariableBase(parameters),
_porepressure_var(_nodal_material ? coupledNodalValue("porepressure")
: coupledValue("porepressure")),
_gradp_qp_var(coupledGradient("porepressure")),
_porepressure_varnum(coupled("porepressure")),
_p_var_num(_dictator.isPorousFlowVariable(_porepressure_varnum)
? _dictator.porousFlowVariableNum(_porepressure_varnum)
: 0)
{
if (_num_phases != 1)
mooseError("The Dictator proclaims that the number of phases is ",
_dictator.numPhases(),
" whereas PorousFlow1PhaseFullySaturated can only be used for 1-phase simulations."
" Be aware that the Dictator has noted your mistake.");
}
PorousFlowBrine::PorousFlowBrine(const InputParameters & parameters) :
PorousFlowFluidPropertiesBase(parameters),
_density_nodal(declareProperty<Real>("PorousFlow_fluid_phase_density" + _phase)),
_density_nodal_old(declarePropertyOld<Real>("PorousFlow_fluid_phase_density" + _phase)),
_ddensity_nodal_dp(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_density" + _phase, _pressure_variable_name)),
_ddensity_nodal_dT(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_density" + _phase, _temperature_variable_name)),
_density_qp(declareProperty<Real>("PorousFlow_fluid_phase_density_qp" + _phase)),
_ddensity_qp_dp(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_density_qp" + _phase, _pressure_variable_name)),
_ddensity_qp_dT(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_density_qp" + _phase, _temperature_variable_name)),
_viscosity_nodal(declareProperty<Real>("PorousFlow_viscosity" + _phase)),
_dviscosity_nodal_dp(declarePropertyDerivative<Real>("PorousFlow_viscosity" + _phase, _pressure_variable_name)),
_dviscosity_nodal_dT(declarePropertyDerivative<Real>("PorousFlow_viscosity" + _phase, _temperature_variable_name)),
_internal_energy_nodal(declareProperty<Real>("PorousFlow_fluid_phase_internal_energy_nodal" + _phase)),
_internal_energy_nodal_old(declarePropertyOld<Real>("PorousFlow_fluid_phase_internal_energy_nodal" + _phase)),
_dinternal_energy_nodal_dp(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_internal_energy_nodal" + _phase, _pressure_variable_name)),
_dinternal_energy_nodal_dT(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_internal_energy_nodal" + _phase, _temperature_variable_name)),
_internal_energy_qp(declareProperty<Real>("PorousFlow_fluid_phase_internal_energy_qp" + _phase)),
_dinternal_energy_qp_dp(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_internal_energy_qp" + _phase, _pressure_variable_name)),
_dinternal_energy_qp_dT(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_internal_energy_qp" + _phase, _temperature_variable_name)),
_enthalpy_nodal(declareProperty<Real>("PorousFlow_fluid_phase_enthalpy_nodal" + _phase)),
_enthalpy_nodal_old(declarePropertyOld<Real>("PorousFlow_fluid_phase_enthalpy_nodal" + _phase)),
_denthalpy_nodal_dp(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_enthalpy_nodal" + _phase, _pressure_variable_name)),
_denthalpy_nodal_dT(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_enthalpy_nodal" + _phase, _temperature_variable_name)),
_enthalpy_qp(declareProperty<Real>("PorousFlow_fluid_phase_enthalpy_qp" + _phase)),
_denthalpy_qp_dp(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_enthalpy_qp" + _phase, _pressure_variable_name)),
_denthalpy_qp_dT(declarePropertyDerivative<Real>("PorousFlow_fluid_phase_enthalpy_qp" + _phase, _temperature_variable_name)),
_xnacl_nodal(coupledNodalValue("xnacl")),
_xnacl_qp(coupledValue("xnacl"))
{
// BrineFluidProperties UserObject
std::string brine_name = name() + ":brine";
{
std::string class_name = "BrineFluidProperties";
InputParameters params = _app.getFactory().getValidParams(class_name);
_fe_problem.addUserObject(class_name, brine_name, params);
}
_brine_fp = &_fe_problem.getUserObject<BrineFluidProperties>(brine_name);
// Water properties UserObject
_water_fp = &_brine_fp->getComponent(BrineFluidProperties::WATER);
}
Q2PBorehole::Q2PBorehole(const InputParameters & parameters)
: PeacemanBorehole(parameters),
_density(getUserObject<RichardsDensity>("fluid_density")),
_relperm(getUserObject<RichardsRelPerm>("fluid_relperm")),
_other_var_nodal(coupledNodalValue("other_var")),
_other_var_num(coupled("other_var")),
_var_is_pp(getParam<bool>("var_is_porepressure")),
_viscosity(getParam<Real>("fluid_viscosity")),
_permeability(getMaterialProperty<RealTensorValue>("permeability")),
_num_nodes(0),
_pp(0),
_sat(0),
_mobility(0),
_dmobility_dp(0),
_dmobility_ds(0)
{
}
PorousFlow1PhaseMD_Gaussian::PorousFlow1PhaseMD_Gaussian(const InputParameters & parameters) :
PorousFlowVariableBase(parameters),
_al(getParam<Real>("al")),
_al2(std::pow(_al, 2)),
_logdens0(std::log(getParam<Real>("density_P0"))),
_bulk(getParam<Real>("bulk_modulus")),
_recip_bulk(1.0/_al/_bulk),
_recip_bulk2(std::pow(_recip_bulk, 2)),
_md_nodal_var(coupledNodalValue("mass_density")),
_md_qp_var(coupledValue("mass_density")),
_gradmd_qp_var(coupledGradient("mass_density")),
_md_varnum(coupled("mass_density")),
_pvar(_dictator_UO.isPorousFlowVariable(_md_varnum) ? _dictator_UO.porousFlowVariableNum(_md_varnum) : 0)
{
if (_dictator_UO.numPhases() != 1)
mooseError("The Dictator proclaims that the number of phases is " << _dictator_UO.numPhases() << " whereas PorousFlow1PhaseMD_Gaussian can only be used for 1-phase simulations. Be aware that the Dictator has noted your mistake.");
}
PorousFlow1PhaseP::PorousFlow1PhaseP(const InputParameters & parameters)
: PorousFlowVariableBase(parameters),
_porepressure_var(_nodal_material ? coupledNodalValue("porepressure")
: coupledValue("porepressure")),
_gradp_qp_var(coupledGradient("porepressure")),
_porepressure_varnum(coupled("porepressure")),
_p_var_num(_dictator.isPorousFlowVariable(_porepressure_varnum)
? _dictator.porousFlowVariableNum(_porepressure_varnum)
: 0),
_pc_uo(parameters.isParamSetByUser("capillary_pressure")
? &getUserObject<PorousFlowCapillaryPressure>("capillary_pressure")
: nullptr)
{
if (_num_phases != 1)
mooseError("The Dictator proclaims that the number of phases is ",
_dictator.numPhases(),
" whereas PorousFlow1PhaseP can only be used for 1-phase simulations. Be aware "
"that the Dictator has noted your mistake.");
}
Q2PPiecewiseLinearSink::Q2PPiecewiseLinearSink(const InputParameters & parameters)
: IntegratedBC(parameters),
_use_mobility(getParam<bool>("use_mobility")),
_use_relperm(getParam<bool>("use_relperm")),
_sink_func(getParam<std::vector<Real>>("pressures"),
getParam<std::vector<Real>>("bare_fluxes")),
_m_func(getFunction("multiplying_fcn")),
_density(getUserObject<RichardsDensity>("fluid_density")),
_relperm(getUserObject<RichardsRelPerm>("fluid_relperm")),
_other_var_nodal(coupledNodalValue("other_var")),
_other_var_num(coupled("other_var")),
_var_is_pp(getParam<bool>("var_is_porepressure")),
_viscosity(getParam<Real>("fluid_viscosity")),
_permeability(getMaterialProperty<RealTensorValue>("permeability")),
_num_nodes(0),
_pp(0),
_sat(0),
_nodal_density(0),
_dnodal_density_dp(0),
_nodal_relperm(0),
_dnodal_relperm_ds(0)
{
}
RichardsVarNames::RichardsVarNames(const std::string & name, InputParameters parameters) :
GeneralUserObject(name, parameters),
Coupleable(parameters, false),
ZeroInterface(parameters),
_num_v(coupledComponents("richards_vars")),
_the_names(std::string()),
_var_types(getParam<MooseEnum>("var_types"))
{
unsigned int max_moose_var_num_seen = 0;
_moose_var_num.resize(_num_v);
_moose_var_value.resize(_num_v);
_moose_var_value_old.resize(_num_v);
_moose_nodal_var_value.resize(_num_v);
_moose_nodal_var_value_old.resize(_num_v);
_moose_grad_var.resize(_num_v);
_moose_raw_var.resize(_num_v);
for (unsigned int i = 0; i < _num_v; ++i)
{
_moose_var_num[i] = coupled("richards_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("richards_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("richards_vars", i) : &_zero);
_moose_nodal_var_value[i] = &coupledNodalValue("richards_vars", i); // coupledNodalValue returns a reference (an alias) to a VariableValue, and the & turns it into a pointer
_moose_nodal_var_value_old[i] = (_is_transient ? &coupledNodalValueOld("richards_vars", i) : &_zero);
_moose_grad_var[i] = &coupledGradient("richards_vars", i);
_moose_raw_var[i] = getVar("richards_vars", i);
_the_names += getVar("richards_vars", i)->name() + " ";
}
_the_names.erase(_the_names.end() - 1, _the_names.end()); // remove trailing space
_ps_var_num.resize(max_moose_var_num_seen + 1);
for (unsigned int i = 0 ; i < max_moose_var_num_seen + 1 ; ++i)
_ps_var_num[i] = _num_v; // NOTE: indicates that i is not a richards variable
for (unsigned int i=0 ; i<_num_v; ++i)
_ps_var_num[_moose_var_num[i]] = i;
}
PorousFlowAqueousPreDisChemistry::PorousFlowAqueousPreDisChemistry(
const InputParameters & parameters)
: PorousFlowMaterialVectorBase(parameters),
_porosity_old(_nodal_material ? getMaterialPropertyOld<Real>("PorousFlow_porosity_nodal")
: getMaterialPropertyOld<Real>("PorousFlow_porosity_qp")),
_aq_ph(_dictator.aqueousPhaseNumber()),
_saturation(_nodal_material
? getMaterialProperty<std::vector<Real>>("PorousFlow_saturation_nodal")
: getMaterialProperty<std::vector<Real>>("PorousFlow_saturation_qp")),
_temperature(_nodal_material ? getMaterialProperty<Real>("PorousFlow_temperature_nodal")
: getMaterialProperty<Real>("PorousFlow_temperature_qp")),
_dtemperature_dvar(
_nodal_material
? getMaterialProperty<std::vector<Real>>("dPorousFlow_temperature_nodal_dvar")
: getMaterialProperty<std::vector<Real>>("dPorousFlow_temperature_qp_dvar")),
_num_primary(coupledComponents("primary_concentrations")),
_num_reactions(getParam<unsigned>("num_reactions")),
_equilibrium_constants_as_log10(getParam<bool>("equilibrium_constants_as_log10")),
_num_equilibrium_constants(coupledComponents("equilibrium_constants")),
_equilibrium_constants(_num_equilibrium_constants),
_primary_activity_coefficients(getParam<std::vector<Real>>("primary_activity_coefficients")),
_reactions(getParam<std::vector<Real>>("reactions")),
_sec_conc_old(
_nodal_material
? getMaterialPropertyOld<std::vector<Real>>("PorousFlow_mineral_concentration_nodal")
: getMaterialPropertyOld<std::vector<Real>>("PorousFlow_mineral_concentration_qp")),
_mineral_sat(_num_reactions),
_bounded_rate(_num_reactions),
_reaction_rate(
_nodal_material
? declareProperty<std::vector<Real>>("PorousFlow_mineral_reaction_rate_nodal")
: declareProperty<std::vector<Real>>("PorousFlow_mineral_reaction_rate_qp")),
_dreaction_rate_dvar(_nodal_material ? declareProperty<std::vector<std::vector<Real>>>(
"dPorousFlow_mineral_reaction_rate_nodal_dvar")
: declareProperty<std::vector<std::vector<Real>>>(
"dPorousFlow_mineral_reaction_rate_qp_dvar")),
_r_area(getParam<std::vector<Real>>("specific_reactive_surface_area")),
_molar_volume(getParam<std::vector<Real>>("molar_volume")),
_ref_kconst(getParam<std::vector<Real>>("kinetic_rate_constant")),
_e_act(getParam<std::vector<Real>>("activation_energy")),
_gas_const(getParam<Real>("gas_constant")),
_one_over_ref_temp(1.0 / getParam<Real>("reference_temperature")),
_theta_exponent(isParamValid("theta_exponent") ? getParam<std::vector<Real>>("theta_exponent")
: std::vector<Real>(_num_reactions, 1.0)),
_eta_exponent(isParamValid("eta_exponent") ? getParam<std::vector<Real>>("eta_exponent")
: std::vector<Real>(_num_reactions, 1.0))
{
if (_dictator.numPhases() < 1)
mooseError("PorousFlowAqueousPreDisChemistry: The number of fluid phases must not be zero");
if (_num_primary != _num_components - 1)
mooseError("PorousFlowAqueousPreDisChemistry: The number of mass_fraction_vars is ",
_num_components,
" which must be one greater than the number of primary concentrations (which is ",
_num_primary,
")");
// correct number of equilibrium constants
if (_num_equilibrium_constants != _num_reactions)
mooseError("PorousFlowAqueousPreDisChemistry: The number of equilibrium constants is ",
_num_equilibrium_constants,
" which must be equal to the number of reactions (",
_num_reactions,
")");
// correct number of activity coefficients
if (_primary_activity_coefficients.size() != _num_primary)
mooseError("PorousFlowAqueousPreDisChemistry: The number of primary activity "
"coefficients is ",
_primary_activity_coefficients.size(),
" which must be equal to the number of primary species (",
_num_primary,
")");
// correct number of stoichiometry coefficients
if (_reactions.size() != _num_reactions * _num_primary)
mooseError("PorousFlowAqueousPreDisChemistry: The number of stoichiometric "
"coefficients specified in 'reactions' (",
_reactions.size(),
") must be equal to the number of reactions (",
_num_reactions,
") multiplied by the number of primary species (",
_num_primary,
")");
if (_r_area.size() != _num_reactions)
mooseError("PorousFlowAqueousPreDisChemistry: The number of specific reactive "
"surface areas provided is ",
_r_area.size(),
" which must be equal to the number of reactions (",
_num_reactions,
")");
if (_ref_kconst.size() != _num_reactions)
mooseError("PorousFlowAqueousPreDisChemistry: The number of kinetic rate constants is ",
_ref_kconst.size(),
" which must be equal to the number of reactions (",
_num_reactions,
")");
if (_e_act.size() != _num_reactions)
mooseError("PorousFlowAqueousPreDisChemistry: The number of activation energies is ",
_e_act.size(),
" which must be equal to the number of reactions (",
_num_reactions,
")");
if (_molar_volume.size() != _num_reactions)
mooseError("PorousFlowAqueousPreDisChemistry: The number of molar volumes is ",
_molar_volume.size(),
" which must be equal to the number of reactions (",
_num_reactions,
")");
if (_theta_exponent.size() != _num_reactions)
mooseError("PorousFlowAqueousPreDisChemistry: The number of theta exponents is ",
_theta_exponent.size(),
" which must be equal to the number of reactions (",
_num_reactions,
")");
if (_eta_exponent.size() != _num_reactions)
mooseError("PorousFlowAqueousPreDisChemistry: The number of eta exponents is ",
_eta_exponent.size(),
" which must be equal to the number of reactions (",
_num_reactions,
")");
if (_num_reactions != _dictator.numAqueousKinetic())
mooseError("PorousFlowAqueousPreDisChemistry: You have specified the number of "
"reactions to be ",
_num_reactions,
" but the Dictator knows that the number of aqueous kinetic "
"(precipitation-dissolution) reactions is ",
_dictator.numAqueousKinetic());
_primary_var_num.resize(_num_primary);
_primary.resize(_num_primary);
for (unsigned i = 0; i < _num_primary; ++i)
{
_primary_var_num[i] = coupled("primary_concentrations", i);
_primary[i] = (_nodal_material ? &coupledNodalValue("primary_concentrations", i)
: &coupledValue("primary_concentrations", i));
}
for (unsigned i = 0; i < _num_equilibrium_constants; ++i)
_equilibrium_constants[i] = (_nodal_material ? &coupledNodalValue("equilibrium_constants", i)
: &coupledValue("equilibrium_constants", i));
}
