MaterialPropertyLib Namespace Reference

Namespaces
namespace	anonymous_namespace{CreateFunction.cpp}
namespace	IAPWSIF97Region1
namespace	IAPWSIF97Region4

Classes
class	AverageMolarMass
class	BishopsPowerLaw
	Bishop's power law for effective stress. More...
class	BishopsSaturationCutoff
class	CapillaryPressureRegularizedVanGenuchten
	This class handles the computation of the capillary pressure, \( p_c(S_l) \), with the capillary pressure regularization. More...
class	CapillaryPressureVanGenuchten
	The van Genuchten capillary pressure model. More...
class	ClausiusClapeyron
class	Component
	This class defines components (substances). More...
class	Constant
struct	CubicLawPermeability
class	Curve
struct	D2ValueConfig
struct	D2ValueExpression
struct	DriftFluxState
class	DupuitPermeability
class	EffectiveThermalConductivityPorosityMixing
class	EmbeddedFracturePermeability
	Permeability model as proposed by Olivella&Alonso. More...
struct	ExponentData
class	Exponential
struct	FormEigenTensor
struct	FormEigenVector
struct	FormKelvinVector
class	Function
class	GasPressureDependentPermeability
	A gas pressure dependent intrinsic permeability model. More...
struct	GetSymmetricTensor
class	IdealGasLaw
	Density function for ideal gases. More...
class	IdealGasLawBinaryMixture
	Density function for binary ideal gases. More...
struct	IndependentVariable
class	KozenyCarmanModel
	Kozeny-Carman equation. More...
class	Linear
class	LinearSaturationSwellingStress
	This class defines a linear saturation rate dependent swelling stress model for the materials that swell strongly when water content increases. More...
class	LinearWaterVapourLatentHeat
	An empirical function for the latent heat of vaporization of liquid water, which is given by [37] p.786f. More...
class	LiquidViscosityVogels
class	MaterialSpatialDistributionMap
class	Medium
class	OrthotropicEmbeddedFracturePermeability
	Extended Permeability model based on Olivella&Alonso. More...
class	Parameter
class	PengRobinson
	Peng-Robinson equation of state. More...
class	PermeabilityMohrCoulombFailureIndexModel
	A failure index dependent permeability model [44]. More...
class	PermeabilityOrthotropicPowerLaw
struct	PerThreadData
class	Phase
class	PorosityFromMassBalance
class	Property
class	RelPermBrooksCorey
	Relative permeability function of the wetting phase proposed by Brooks&Corey. More...
class	RelPermBrooksCoreyNonwettingPhase
	Relative permeability function of the non-wetting phase proposed by Brooks&Corey. More...
class	RelPermGeneralizedPower
class	RelPermGeneralizedPowerNonwettingPhase
class	RelPermLiakopoulos
	Relative permeability function for the wetting phase of the Liakopoulos experiment. More...
class	RelPermNonWettingPhaseVanGenuchtenMualem
class	RelPermUdell
class	RelPermUdellNonwettingPhase
class	RelPermVanGenuchten
class	SaturationBrooksCorey
	A well known soil characteristics function. More...
class	SaturationDependentSwelling
class	SaturationExponential
	A simplistic soil characteristics function. More...
class	SaturationLiakopoulos
	A well known soil characteristics function. More...
class	SaturationLuMcCartney
	The Lu - Mc Cartney water retention behavior. More...
class	SaturationVanGenuchten
	The van Genuchten capillary pressure model. More...
class	SaturationVanGenuchtenWithVolumetricStrain
	A strain dependent bimodal water retention model. More...
class	SaturationWeightedThermalConductivity
	Saturation dependent thermal conductivity model for soil. More...
struct	ScalarCopyOp
class	Sigmoid
class	SpecificHeatCapacityWithLatentHeat
class	StrainDependentPermeability
	A strain dependent intrinsic permeability model. More...
class	TemperatureDependentDiffusion
class	TransportPorosityFromMassBalance
class	VapourDiffusionDeVries
	DeVries type Vapour diffusion. More...
class	VapourDiffusionFEBEX
	FEBEX type Vapour diffusion. More...
class	VapourDiffusionPMQ
	The Penman-Millington-Quirk (PMQ) Vapour diffusion model. More...
class	VariableArray
struct	VariablePair
class	VermaPruessModel
	Verma-Pruess equation [43]. More...
struct	VogelsViscosityConstantsCH4
struct	VogelsViscosityConstantsCO2
struct	VogelsViscosityConstantsWater
struct	VoidFractionQuadratic
class	VolumeFractionAverage
struct	Water
class	WaterDensityIAPWSIF97Region1
class	WaterEnthalpyIAPWSIF97Region1
struct	WaterLiquidDensityIAPWSIF97Region4
struct	WaterLiquidEnthalpyIAPWSIF97Region4
struct	WaterSaturationTemperatureIAPWSIF97Region4
class	WaterTemperatureIAPWSIF97Region1
class	WaterThermalConductivityIAPWS
	A class for thermal conductivity model that is defined by The International Association for the Properties of Water and Steam IAPWS (File accessed at 13.01.2023) - (Daucik and Dooley, 2011) More...
class	WaterVapourDensity
	A model for water vapour density in the unsaturated porous media. More...
class	WaterVapourDensityIAPWSIF97Region4
class	WaterVapourEnthalpyIAPWSIF97Region4
class	WaterVapourLatentHeatWithCriticalTemperature
	A latent heat model of vaporisation of water considering the critical temperature. More...
class	WaterViscosityIAPWS
	A class for viscosity model that is defined by The International Association for the Properties of Water and Steam IAPWS More...
struct	ZeroInitPropertyDataType

Typedefs
using	PropertyArray
using	StringOrVariable = std::variant<std::string, Variable>
using	PropertyDataType
template<int GlobalDim>
using	SymmetricTensor
template<int Dim>
using	Tensor = Eigen::Matrix<double, tensorSize(Dim), 1>
using	VariableType

Enumerations
enum class	PhaseName { Solid , AqueousLiquid , Gas , FrozenLiquid }
	Enumeration of phase types. More...
enum class	MeanType { ARITHMETIC_LINEAR , ARITHMETIC_SQUAREROOT , GEOMETRIC }
enum	PropertyType : int {   acentric_factor , binary_interaction_coefficient , biot_coefficient , bishops_effective_stress ,   brooks_corey_exponent , bulk_modulus , capillary_pressure , compressibility ,   concentration , critical_density , critical_pressure , critical_temperature ,   decay_rate , density , diffusion , drhodT ,   effective_stress , enthalpy , entry_pressure , evaporation_enthalpy ,   fredlund_parameters , frozen_liquid_saturation , heat_capacity , henry_coefficient ,   longitudinal_dispersivity , molality , molar_mass , molar_volume ,   mole_fraction , molecular_diffusion , name , permeability ,   phase_change_expansivity , phase_velocity , poissons_ratio , pore_diffusion ,   porosity , reference_density , reference_pressure , reference_temperature ,   relative_permeability , relative_permeability_nonwetting_phase , residual_gas_saturation , residual_liquid_saturation ,   retardation_factor , saturation , saturation_density , saturation_enthalpy ,   saturation_micro , saturation_temperature , specific_heat_capacity , specific_latent_heat ,   storage , storage_contribution , swelling_stress_rate , temperature ,   thermal_conductivity , thermal_diffusion_enhancement_factor , thermal_expansivity , thermal_expansivity_contribution ,   thermal_longitudinal_dispersivity , thermal_osmosis_coefficient , thermal_osmosis_permeability , thermal_transversal_dispersivity ,   tortuosity , transport_porosity , transversal_dispersivity , vapour_pressure ,   viscosity , volume_fraction , youngs_modulus , number_of_properties }
enum class	Variable : int {   capillary_pressure , concentration , deformation_gradient , density ,   effective_pore_pressure , enthalpy , enthalpy_of_evaporation , equivalent_plastic_strain ,   fracture_aperture , frozen_liquid_saturation , grain_compressibility , liquid_phase_pressure ,   liquid_saturation , mechanical_strain , molar_mass , molar_mass_derivative ,   molar_fraction , gas_phase_pressure , porosity , solid_grain_pressure ,   stress , temperature , total_strain , total_stress ,   transport_porosity , vapour_pressure , volumetric_mechanical_strain , volumetric_strain ,   number_of_variables }

Functions
template<typename ContainerMedium, typename ContainerSolid, typename ContainerLiquid, typename ContainerGas>
void	checkMaterialSpatialDistributionMap (MeshLib::Mesh const &mesh, MaterialPropertyLib::MaterialSpatialDistributionMap const &media_map, ContainerMedium const &required_properties_medium, ContainerSolid const &required_properties_solid_phase, ContainerLiquid const &required_properties_liquid_phase, ContainerGas const &required_properties_gas_phase)
void	checkRequiredProperties (Component const &c, std::span< PropertyType const > const required_properties)
std::unique_ptr< Component >	newComponent (std::string const &component_name, bool &isCustomComponent)
std::vector< std::unique_ptr< Component > >	createComponents (int const geometry_dimension, std::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
MaterialSpatialDistributionMap	createMaterialSpatialDistributionMap (std::map< int, std::shared_ptr< Medium > > const &media, MeshLib::Mesh const &mesh)
std::unique_ptr< Medium >	createMedium (int const material_id, int const geometry_dimension, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::vector< std::unique_ptr< Phase > >	createPhases (int const geometry_dimension, std::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::unique_ptr< PropertyArray >	createProperties (int const geometry_dimension, std::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
void	checkRequiredProperties (Medium const &medium, std::span< PropertyType const > const required_properties)
Phase const &	fluidPhase (Medium const &medium)
	Returns a gas or aqueous liquid phase of the given medium.
Phase const *	getOptionalPhase (Medium const &medium, PhaseName phase_name)
std::string_view	toString (PhaseName phase_name)
	Convert phase enum to its string representation.
PhaseName	fromString (std::string const &phase_name)
	Convert string to phase enum. Throws if invalid phase name.
void	checkRequiredProperties (Phase const &phase, std::span< PropertyType const > const required_properties)
void	checkSaturationRange (const double Sl)
std::unique_ptr< Property >	createCapillaryPressureRegularizedVanGenuchten (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createCapillaryPressureVanGenuchten (BaseLib::ConfigTree const &config)
std::unique_ptr< SaturationBrooksCorey >	createSaturationBrooksCorey (BaseLib::ConfigTree const &config)
std::unique_ptr< SaturationExponential >	createSaturationExponential (BaseLib::ConfigTree const &config)
std::unique_ptr< SaturationLiakopoulos >	createSaturationLiakopoulos (BaseLib::ConfigTree const &config)
std::unique_ptr< SaturationLuMcCartney >	createSaturationLuMcCartney (BaseLib::ConfigTree const &config)
std::unique_ptr< SaturationVanGenuchten >	createSaturationVanGenuchten (BaseLib::ConfigTree const &config)
std::unique_ptr< SaturationVanGenuchtenWithVolumetricStrain >	createSaturationVanGenuchtenWithVolumetricStrain (BaseLib::ConfigTree const &config)
std::unique_ptr< AverageMolarMass >	createAverageMolarMass (BaseLib::ConfigTree const &config)
std::unique_ptr< BishopsPowerLaw >	createBishopsPowerLaw (BaseLib::ConfigTree const &config)
std::unique_ptr< BishopsSaturationCutoff >	createBishopsSaturationCutoff (BaseLib::ConfigTree const &config)
std::unique_ptr< ClausiusClapeyron >	createClausiusClapeyron (BaseLib::ConfigTree const &config)
std::unique_ptr< Constant >	createConstant (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createCubicLawPermeability (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< Curve >	createCurve (BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::unique_ptr< DupuitPermeability >	createDupuitPermeability (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< Property >	createEffectiveThermalConductivityPorosityMixing (int const geometry_dimension, BaseLib::ConfigTree const &config, ParameterLib::CoordinateSystem const *const local_coordinate_system)
std::unique_ptr< Property >	createEmbeddedFracturePermeability (int const geometry_dimension, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< Exponential >	createExponential (BaseLib::ConfigTree const &config)
std::unique_ptr< Function >	createFunction (BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::unique_ptr< Property >	createGasPressureDependentPermeability (int const geometry_dimension, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system)
std::unique_ptr< IdealGasLaw >	createIdealGasLaw (BaseLib::ConfigTree const &config)
std::unique_ptr< IdealGasLawBinaryMixture >	createIdealGasLawBinaryMixture (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createKozenyCarmanModel (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< Linear >	createLinear (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createOrthotropicEmbeddedFracturePermeability (int const geometry_dimension, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< Parameter >	createParameterProperty (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< Property >	createPengRobinson (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createPermeabilityMohrCoulombFailureIndexModel (int const geometry_dimension, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system)
std::unique_ptr< Property >	createPermeabilityOrthotropicPowerLaw (BaseLib::ConfigTree const &config, ParameterLib::CoordinateSystem const *const local_coordinate_system)
std::unique_ptr< PorosityFromMassBalance >	createPorosityFromMassBalance (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< SaturationDependentSwelling >	createSaturationDependentSwelling (BaseLib::ConfigTree const &config, ParameterLib::CoordinateSystem const *const local_coordinate_system)
std::unique_ptr< Property >	createSaturationDependentThermalConductivity (BaseLib::ConfigTree const &config)
std::unique_ptr< Sigmoid >	createSigmoid (BaseLib::ConfigTree const &config)
	Create a Sigmoid property from XML configuration.
std::unique_ptr< SpecificHeatCapacityWithLatentHeat >	createSpecificHeatCapacityWithLatentHeat (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createStrainDependentPermeability (int const geometry_dimension, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system)
std::unique_ptr< Property >	createTemperatureDependentDiffusion (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< TransportPorosityFromMassBalance >	createTransportPorosityFromMassBalance (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< Property >	createVermaPruessModel (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< VolumeFractionAverage >	createVolumeFractionAverage (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterSaturationTemperatureIAPWSIF97Region4 (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterTemperatureIAPWSIF97Region1 (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterDensityIAPWSIF97Region1 (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterLiquidDensityIAPWSIF97Region4 (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterVapourDensity (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterVapourDensityIAPWSIF97Region4 (BaseLib::ConfigTree const &config)
static double	saturatedVaporDensity (double const T)
	\(\rho_{vS}\)
static double	dsaturatedVaporDensitydT (double const T)
	\(\frac{\partial \rho_{vS}}{\partial T}\)
static double	humidity (double const T, double const p, double const water_density)
std::unique_ptr< Property >	createLinearWaterVapourLatentHeat (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterEnthalpyIAPWSIF97Region1 (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterLiquidEnthalpyIAPWSIF97Region4 (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterVapourEnthalpyIAPWSIF97Region4 (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterVapourLatentHeatWithCriticalTemperature (BaseLib::ConfigTree const &config)
template<int D>
static exprtk::symbol_table< double >	createSymbolTable (std::vector< std::string > const &expression_symbol_names, bool const spatial_position_is_required, std::vector< std::string > const &used_curve_names, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, VariableArray &variable_array, std::map< std::string, ParameterLib::CurveWrapper > &curve_wrappers)
template<std::size_t N>
static std::array< double, N >	evaluateToArray (std::vector< exprtk::expression< double > > const &expressions)
static int	currentThreadId (std::string const &property_name, std::size_t const num_slots)
std::unique_ptr< RelPermBrooksCorey >	createRelPermBrooksCorey (BaseLib::ConfigTree const &config)
std::unique_ptr< RelPermBrooksCoreyNonwettingPhase >	createRelPermBrooksCoreyNonwettingPhase (BaseLib::ConfigTree const &config)
std::unique_ptr< RelPermGeneralizedPower >	createRelPermGeneralizedPower (BaseLib::ConfigTree const &config)
std::unique_ptr< RelPermGeneralizedPowerNonwettingPhase >	createRelPermGeneralizedPowerNonwettingPhase (BaseLib::ConfigTree const &config)
std::unique_ptr< RelPermLiakopoulos >	createRelPermLiakopoulos (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createRelPermNonWettingPhaseVanGenuchtenMualem (BaseLib::ConfigTree const &config)
std::unique_ptr< RelPermUdell >	createRelPermUdell (BaseLib::ConfigTree const &config)
std::unique_ptr< RelPermUdellNonwettingPhase >	createRelPermUdellNonwettingPhase (BaseLib::ConfigTree const &config)
std::unique_ptr< RelPermVanGenuchten >	createRelPermVanGenuchten (BaseLib::ConfigTree const &config)
double	computeVanGenuchtenMualemValue (const double S_L, const double S_L_r, const double S_L_max, const double m)
static std::optional< std::pair< double, double > >	normalizedState (double const f, double const lower_bound, double const upper_bound)
std::unique_ptr< Property >	createLinearSaturationSwellingStress (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createSaturationWeightedThermalConductivity (int const geometry_dimension, BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &parameters)
std::unique_ptr< Property >	createSoilThermalConductivitySomerton (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterThermalConductivityIAPWS (BaseLib::ConfigTree const &config)
template<MeanType MeanType>
double	computeAverage (const double, double const, double const)=delete
template<MeanType MeanType>
double	computeDAverage (const double, double const, double const)=delete
template<>
double	computeAverage< MeanType::ARITHMETIC_LINEAR > (const double S, double const k_dry, double const k_wet)
template<>
double	computeDAverage< MeanType::ARITHMETIC_LINEAR > (const double, double const k_dry, double const k_wet)
template<>
double	computeAverage< MeanType::ARITHMETIC_SQUAREROOT > (const double S, double const k_dry, double const k_wet)
template<>
double	computeDAverage< MeanType::ARITHMETIC_SQUAREROOT > (const double S, double const k_dry, double const k_wet)
template<>
double	computeAverage< MeanType::GEOMETRIC > (const double S, double const k_dry, double const k_wet)
template<>
double	computeDAverage< MeanType::GEOMETRIC > (const double S, double const k_dry, double const k_wet)
static double	computeBarLambda0Factor (const double barT)
static std::array< double, 5 >	computeSeriesFactorTForLambda1 (const double barT)
static std::array< double, 6 >	computeSeriesFactorRhoForLambda1 (const double bar_rho)
static double	computeBarLambda1Factor (const std::array< double, 5 > &series_factorT, const std::array< double, 6 > &series_factorRho)
static double	computedBarLambda_dbarT (const double barT, double bar_rho)
static double	computedBarLambda_dbarRho (const double barT, double bar_rho)
std::unique_ptr< Property >	createVapourDiffusionDeVries (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createVapourDiffusionFEBEX (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createVapourDiffusionPMQ (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createLiquidViscosityVogels (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createWaterViscosityIAPWS (BaseLib::ConfigTree const &config)
static double	computeBarMu0Factor (const double barT)
static std::array< double, 6 >	computeSeriesFactorTForMu1 (const double barT)
static std::array< double, 7 >	computeSeriesFactorRhoForMu1 (const double bar_rho)
static double	computeBarMu1Factor (const std::array< double, 6 > &series_factorT, const std::array< double, 7 > &series_factorRho)
static double	computedBarMu_dbarT (const double barT, double bar_rho)
static double	computedBarMu_dbarRho (const double barT, double bar_rho)
double	computeTemperature (double const pi, double const eta)
PropertyDataType	fromVector (std::vector< double > const &values)
template<std::size_t N>
PropertyDataType	fromArray (std::array< double, N > const &values)
void	overwriteExistingProperties (PropertyArray &properties, PropertyArray &new_properties, std::variant< Medium *, Phase *, Component * > scale_pointer)
void	updatePropertiesForAllPhases (PropertyArray &properties, std::vector< std::unique_ptr< Phase > > const &phases)
PropertyType	convertStringToProperty (std::string const &string)
void	checkMPLPhasesForSinglePhaseFlow (MeshLib::Mesh const &mesh, MaterialPropertyLib::MaterialSpatialDistributionMap const &media_map)
void	checkVanGenuchtenExponentRange (const double m)
static double	closureSlipParameter (DriftFluxState const &state)
static DriftFluxState	alignDriftWithFlow (DriftFluxState const &state)
double	alignedDriftFluxVelocity (double const u_gu, double const v_mix)
double	driftFluxProfileParameter (double const dryness)
VoidFractionQuadratic	voidFractionQuadratic (DriftFluxState const &state)
double	voidFractionResidual (double const alpha, DriftFluxState const &state)
std::string	voidFractionClosureDiagnostics (DriftFluxState const &state)
double	driftFluxVelocity (double const dryness, double const temperature, double const vapour_water_density, double const liquid_water_density)
DriftFluxState	driftFluxState (double const dryness, double const temperature, double const vapour_water_density, double const liquid_water_density, double const v_mix)
std::optional< double >	computeVapourVoidFraction (DriftFluxState const &state)
double	mixtureSlipParameter (double const alpha, DriftFluxState const &state)
template<int GlobalDim>
Eigen::Matrix< double, GlobalDim, GlobalDim >	formEffectiveThermalConductivity (MaterialPropertyLib::PropertyDataType const &solid_thermal_conductivity, const double fluid_thermal_conductivity, const double porosity)
template Eigen::Matrix< double, 1, 1 >	formEffectiveThermalConductivity< 1 > (MaterialPropertyLib::PropertyDataType const &solid_thermal_conductivity, const double fluid_thermal_conductivity, const double porosity)
template Eigen::Matrix< double, 2, 2 >	formEffectiveThermalConductivity< 2 > (MaterialPropertyLib::PropertyDataType const &solid_thermal_conductivity, const double fluid_thermal_conductivity, const double porosity)
template Eigen::Matrix< double, 3, 3 >	formEffectiveThermalConductivity< 3 > (MaterialPropertyLib::PropertyDataType const &solid_thermal_conductivity, const double fluid_thermal_conductivity, const double porosity)
template Eigen::Matrix< double, 1, 1 >	formEigenTensor< 1 > (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 2, 2 >	formEigenTensor< 2 > (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 3, 3 >	formEigenTensor< 3 > (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 4, 4 >	formEigenTensor< 4 > (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 6, 6 >	formEigenTensor< 6 > (MaterialPropertyLib::PropertyDataType const &values)
template<int GlobalDim>
constexpr Eigen::Matrix< double, GlobalDim, GlobalDim >	formEigenTensor (MaterialPropertyLib::PropertyDataType const &values)
template<int GlobalDim>
Eigen::Matrix< double, GlobalDim, 1 >	formEigenVector (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 1, 1 >	formEigenVector< 1 > (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 2, 1 >	formEigenVector< 2 > (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 3, 1 >	formEigenVector< 3 > (MaterialPropertyLib::PropertyDataType const &values)
template<int GlobalDim>
MathLib::KelvinVector::KelvinVectorType< GlobalDim >	formKelvinVector (MaterialPropertyLib::PropertyDataType const &values)
	A function to form a Kelvin vector from strain or stress alike property like thermal expansivity for thermal strain.
template MathLib::KelvinVector::KelvinVectorType< 2 >	formKelvinVector< 2 > (MaterialPropertyLib::PropertyDataType const &values)
template MathLib::KelvinVector::KelvinVectorType< 3 >	formKelvinVector< 3 > (MaterialPropertyLib::PropertyDataType const &values)
double	getFluidDensity (double const t, double const dt, ParameterLib::SpatialPosition const &pos, Phase const &fluid_phase, VariableArray &vars)
	It computes fluid density for single phase flow model.
std::tuple< double, double >	getFluidDensityAndViscosity (double const t, double const dt, ParameterLib::SpatialPosition const &pos, Phase const &fluid_phase, VariableArray &vars)
	It computes fluid density and viscosity for single phase flow model.
double	getLiquidThermalExpansivity (Phase const &phase, VariableArray const &vars, const double density, ParameterLib::SpatialPosition const &pos, double const t, double const dt)
template<int GlobalDim>
SymmetricTensor< GlobalDim >	getSymmetricTensor (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 4, 1 >	getSymmetricTensor< 2 > (MaterialPropertyLib::PropertyDataType const &values)
template Eigen::Matrix< double, 6, 1 >	getSymmetricTensor< 3 > (MaterialPropertyLib::PropertyDataType const &values)
double	steamDryness (double const enthalpy, double const h_sat_liquid, double const h_sat_vapour)
constexpr int	tensorSize (int dim)
	See Tensor type for details.
Variable	convertStringToVariable (std::string const &string)
static VariableArray::VariablePointer	dropConst (VariableArray::VariablePointerConst const const_pointer)

Variables
const MaterialLib::Fluid::DimensionLessGibbsFreeEnergyRegion1	gibbs_free_energy_
static constexpr double	ref_T_ = 1386
	reference temperature in K.
static constexpr double	ref_p_ = 1.653e7
	reference pressure in Pa.
constexpr double	T_c
	Critical temperature.
constexpr double	alpha = 1. / 8.
constexpr double	beta = 1. / 3.
constexpr double	Delta = 0.79 - beta
constexpr std::array	c
static constexpr double	max_exp_argument
static constexpr double	unused_dt = std::numeric_limits<double>::quiet_NaN()
static const double	Li [5]
static const double	Lij [5][6]
static const double	Hi [4] = {1.67752, 2.20462, 0.6366564, -0.241605}
static const double	Hij [6][7]
static constexpr std::array	n_T
static constexpr std::array	I_T
static constexpr std::array	J_T
static const std::array< std::string, PropertyType::number_of_properties >	property_enum_to_string
static constexpr const char	error_info []
template<int GlobalDim>
constexpr int	symmetric_tensor_size
static const std::array< std::string, static_cast< int >(Variable::number_of_variables)>	variable_enum_to_string
static const VariableArray	EmptyVariableArray {}

Typedef Documentation

PropertyArray

typedef std::array< std::unique_ptr< Property >, PropertyType::number_of_properties > MaterialPropertyLib::PropertyArray

Initial value:

 
    std::array<std::unique_ptr<Property>, PropertyType::number_of_properties>

This data type is based on a std::array. It can hold pointers to objects of class Property or its inheritors. The size of this array is determined by the number of entries of the PropertyType enumerator.

Definition at line 34 of file CreateProperty.h.

PropertyDataType

using MaterialPropertyLib::PropertyDataType

Initial value:

 
    std::variant<double, Eigen::Matrix<double, 2, 1>,
                 Eigen::Matrix<double, 3, 1>, Eigen::Matrix<double, 2, 2>,
                 Eigen::Matrix<double, 3, 3>, Eigen::Matrix<double, 4, 1>,
                 Eigen::Matrix<double, 6, 1>, Eigen::MatrixXd>

Definition at line 24 of file MaterialLib/MPL/Property.h.

StringOrVariable

typedef std::variant< std::string, Variable > MaterialPropertyLib::StringOrVariable = std::variant<std::string, Variable>

Definition at line 12 of file Curve.h.

SymmetricTensor

template<int GlobalDim>

using MaterialPropertyLib::SymmetricTensor

Initial value:

 
    Eigen::Matrix<double, symmetric_tensor_size<GlobalDim>, 1>

Definition at line 18 of file GetSymmetricTensor.h.

Tensor

template<int Dim>

using MaterialPropertyLib::Tensor = Eigen::Matrix<double, tensorSize(Dim), 1>

The tensor's components in 3D case are ordered in the usual way: (1,1), (1,2), (1,3) (2,1), (2,2), (2,3) (3,1), (3,2), (3,3).

For the 2D case the 2x2 block is as usual and is followed by the (3,3) component: (1,1), (1,2), (2,1), (2,2), (3,3).

For the 1D case only the diagonal is stored: (1,1), (2,2), (3,3).

Definition at line 46 of file Tensor.h.

VariableType

using MaterialPropertyLib::VariableType

Initial value:

 std::variant<std::monostate,
                                  double,
                                  Eigen::Vector<double, 4>,
                                  Eigen::Vector<double, 5>,
                                  Eigen::Vector<double, 6>,
                                  Eigen::Vector<double, 9>>

Data type for primary variables, designed to contain both scalar and vector data.

Definition at line 86 of file VariableType.h.

Enumeration Type Documentation

MeanType

enum class MaterialPropertyLib::MeanType

strong

Enumerator
ARITHMETIC_LINEAR
ARITHMETIC_SQUAREROOT
GEOMETRIC

Definition at line 20 of file SaturationWeightedThermalConductivity.h.

{
    ARITHMETIC_LINEAR,
    ARITHMETIC_SQUAREROOT,
    GEOMETRIC
};

PhaseName

enum class MaterialPropertyLib::PhaseName

strong

Enumeration of phase types.

Enumerator
Solid
AqueousLiquid
Gas
FrozenLiquid

Definition at line 18 of file Phase.h.

{
    Solid,
    AqueousLiquid,
    Gas,
    FrozenLiquid
};

PropertyType

enum MaterialPropertyLib::PropertyType : int

PropertyType is an enumerator list of all known properties of a substance. This includes all properties on all scales (i.e. component, phase, and medium scales). It is used as an index for the PropertyArray of the materials. If a necessary property is not in the list, simply add a new one in alphabetical order (of course, except for the last entry). Please note that any of these entries must also appear in below convert functions.

Enumerator
acentric_factor
binary_interaction_coefficient
biot_coefficient
bishops_effective_stress
brooks_corey_exponent
bulk_modulus
capillary_pressure
compressibility
concentration	used to specify decay rate of a substance.
critical_density
critical_pressure
critical_temperature
decay_rate
density
diffusion
drhodT
effective_stress
enthalpy
entry_pressure
evaporation_enthalpy
fredlund_parameters
frozen_liquid_saturation	frozen liquid (ice) saturation, i.e. the fraction of the pore space occupied by ice. The corresponding volume fraction is this value times the porosity.
heat_capacity
henry_coefficient
longitudinal_dispersivity	used to compute the hydrodynamic dispersion tensor.
molality
molar_mass
molar_volume
mole_fraction
molecular_diffusion	ion diffusivity in free water.
name
permeability
phase_change_expansivity
phase_velocity
poissons_ratio
pore_diffusion	ion diffusivity in the porous medium with account of the effect of tortuosity and connectivity.
porosity
reference_density
reference_pressure
reference_temperature
relative_permeability
relative_permeability_nonwetting_phase
residual_gas_saturation
residual_liquid_saturation
retardation_factor	specify retardation factor used in component transport process.
saturation
saturation_density
saturation_enthalpy
saturation_micro	capillary pressure saturation relationship for microstructure.
saturation_temperature
specific_heat_capacity
specific_latent_heat
storage
storage_contribution
swelling_stress_rate
temperature
thermal_conductivity
thermal_diffusion_enhancement_factor	Thermal diffusion enhancement factor for water vapor flow.
thermal_expansivity	The thermal expansivity corresponds to the linear thermal expansion coefficient for a solid and to the volumetric thermal expansion coefficient for a fluid
thermal_expansivity_contribution
thermal_longitudinal_dispersivity
thermal_osmosis_coefficient
thermal_osmosis_permeability	Scalar thermo-osmotic permeability \(\epsilon_T\) in Pa/K, the pore pressure gradient equivalent to a unit temperature gradient. It parametrises the thermo-osmotic coefficient as \(k_T = \epsilon_T k / \mu\), see ProcessLib::getThermoOsmoticCoefficient(); use it instead of, not next to, thermal_osmosis_coefficient.
thermal_transversal_dispersivity
tortuosity
transport_porosity
transversal_dispersivity	used to compute the hydrodynamic dispersion tensor.
vapour_pressure
viscosity
volume_fraction
youngs_modulus
number_of_properties

Definition at line 23 of file PropertyType.h.

{
    acentric_factor,
    binary_interaction_coefficient,
    biot_coefficient,
    bishops_effective_stress,
    brooks_corey_exponent,
    bulk_modulus,
    capillary_pressure,
    compressibility,
    concentration,
    critical_density,
    critical_pressure,
    critical_temperature,
    decay_rate,
    density,
    diffusion,
    drhodT,
    effective_stress,
    enthalpy,
    entry_pressure,
    evaporation_enthalpy,
    fredlund_parameters,
    frozen_liquid_saturation,
    heat_capacity,
    henry_coefficient,
    longitudinal_dispersivity,
    molality,
    molar_mass,
    molar_volume,
    mole_fraction,
    molecular_diffusion,
    name,
    permeability,
    phase_change_expansivity,
    phase_velocity,
    poissons_ratio,
    pore_diffusion,
    porosity,
    reference_density,
    reference_pressure,
    reference_temperature,
    relative_permeability,
    relative_permeability_nonwetting_phase,
    residual_gas_saturation,
    residual_liquid_saturation,
    retardation_factor,
    saturation,
    saturation_density,
    saturation_enthalpy,
    saturation_micro,
    saturation_temperature,
    specific_heat_capacity,
    specific_latent_heat,
    storage,
    storage_contribution,
    swelling_stress_rate,
    temperature,
    thermal_conductivity,
    thermal_diffusion_enhancement_factor,
    thermal_expansivity,
    thermal_expansivity_contribution,
    thermal_longitudinal_dispersivity,
    thermal_osmosis_coefficient,
    thermal_osmosis_permeability,
    thermal_transversal_dispersivity,
    tortuosity,
    transport_porosity,
    transversal_dispersivity,
    vapour_pressure,
    viscosity,
    volume_fraction,
    youngs_modulus,
    number_of_properties
};

Variable

enum class MaterialPropertyLib::Variable : int

strong

Enum Variable is simply a list of all commonly used variables. If the variable of your choice is missing, simply add it somewhere at the list, but above the last entry.

Enumerator
capillary_pressure
concentration
deformation_gradient
density
effective_pore_pressure
enthalpy
enthalpy_of_evaporation
equivalent_plastic_strain
fracture_aperture
frozen_liquid_saturation
grain_compressibility
liquid_phase_pressure
liquid_saturation
mechanical_strain
molar_mass
molar_mass_derivative
molar_fraction
gas_phase_pressure
porosity
solid_grain_pressure
stress
temperature
total_strain
total_stress
transport_porosity
vapour_pressure
volumetric_mechanical_strain
volumetric_strain
number_of_variables

Definition at line 20 of file VariableType.h.

{
    capillary_pressure,
    concentration,
    deformation_gradient,
    density,
    effective_pore_pressure,
    enthalpy,
    enthalpy_of_evaporation,
    equivalent_plastic_strain,
    fracture_aperture,
    frozen_liquid_saturation,
    grain_compressibility,
    liquid_phase_pressure,
    liquid_saturation,
    mechanical_strain,
    molar_mass,
    molar_mass_derivative,
    molar_fraction,
    gas_phase_pressure,
    porosity,
    solid_grain_pressure,
    stress,
    temperature,
    total_strain,
    total_stress,
    transport_porosity,
    vapour_pressure,
    volumetric_mechanical_strain,
    volumetric_strain,
    number_of_variables
};

Function Documentation

alignDriftWithFlow()

DriftFluxState MaterialPropertyLib::alignDriftWithFlow ( DriftFluxState const & state )

static

The same state with the drift aligned with the mixture flow, which is the closure computeVapourVoidFraction() actually solves.

Definition at line 28 of file DriftFluxModel.cpp.

{
    DriftFluxState aligned = state;
    aligned.u_gu = alignedDriftFluxVelocity(state.u_gu, state.v_mix);
    return aligned;
}

References alignedDriftFluxVelocity(), MaterialPropertyLib::DriftFluxState::u_gu, and MaterialPropertyLib::DriftFluxState::v_mix.

Referenced by computeVapourVoidFraction(), and voidFractionClosureDiagnostics().

alignedDriftFluxVelocity()

double MaterialPropertyLib::alignedDriftFluxVelocity	(	double const	u_gu,
		double const	v_mix )

Drift flux velocity aligned with the mixture flow, \(\operatorname{sign}(v)\, u_{gu}\). The Rouhani-Axelsson closure is derived for co-current flow and has no admissible solution for backflow with a drift velocity that is fixed in the gravity frame, see computeVapourVoidFraction() for the reasoning.

Every use of the drift flux velocity next to a void fraction obtained from that closure, in particular the slip momentum term of the mixture, has to use the same aligned value: the void fraction is even in the mixture velocity, so a raw drift flux velocity leaves the slip term inconsistent with it and lets the term vanish at the finite backflow velocity \(v = -u_{gu} / (C_0 - 1)\).

Definition at line 35 of file DriftFluxModel.cpp.

{
    return std::copysign(u_gu, v_mix);
}

Referenced by alignDriftWithFlow(), and driftFluxState().

checkMaterialSpatialDistributionMap()

template<typename ContainerMedium, typename ContainerSolid, typename ContainerLiquid, typename ContainerGas>

void MaterialPropertyLib::checkMaterialSpatialDistributionMap	(	MeshLib::Mesh const &	mesh,
		MaterialPropertyLib::MaterialSpatialDistributionMap const &	media_map,
		ContainerMedium const &	required_properties_medium,
		ContainerSolid const &	required_properties_solid_phase,
		ContainerLiquid const &	required_properties_liquid_phase,
		ContainerGas const &	required_properties_gas_phase )

Definition at line 16 of file CheckMaterialSpatialDistributionMap.h.

{
    for (auto const element_id : mesh.getElements() | MeshLib::views::ids)
    {
        auto const& medium = *media_map.getMedium(element_id);
        if (!required_properties_medium.empty())
        {
            MaterialPropertyLib::checkRequiredProperties(
                medium, required_properties_medium);
        }
        if (!required_properties_liquid_phase.empty())
        {
            MaterialPropertyLib::checkRequiredProperties(
                medium.phase(PhaseName::AqueousLiquid),
                required_properties_liquid_phase);
        }
        if (!required_properties_gas_phase.empty())
        {
            MaterialPropertyLib::checkRequiredProperties(
                medium.phase(PhaseName::Gas), required_properties_gas_phase);
        }
        if (!required_properties_solid_phase.empty())
        {
            MaterialPropertyLib::checkRequiredProperties(
                medium.phase(PhaseName::Solid),
                required_properties_solid_phase);
        }
    }
}

References AqueousLiquid, checkRequiredProperties(), Gas, MeshLib::Mesh::getElements(), MaterialPropertyLib::MaterialSpatialDistributionMap::getMedium(), MeshLib::views::ids, and Solid.

Referenced by ProcessLib::HeatConduction::checkMPLProperties(), ProcessLib::HT::checkMPLProperties(), ProcessLib::RichardsFlow::checkMPLProperties(), ProcessLib::SteadyStateDiffusion::checkMPLProperties(), and ProcessLib::WellboreSimulator::checkMPLProperties().

checkMPLPhasesForSinglePhaseFlow()

void MaterialPropertyLib::checkMPLPhasesForSinglePhaseFlow	(	MeshLib::Mesh const &	mesh,
		MaterialPropertyLib::MaterialSpatialDistributionMap const &	media_map )

Definition at line 17 of file CheckMPLPhasesForSinglePhaseFlow.cpp.

{
    // Check all of the elements have a medium defined.
    ranges::for_each(mesh.getElements() | MeshLib::views::ids,
                     [&](auto const& element_id)
                     { media_map.checkElementHasMedium(element_id); });
 
    // Collect phases of all elements...
    auto all_phases =
        media_map.media() |
        ranges::views::transform([&](auto const& medium)
                                 { return &fluidPhase(*medium); }) |
        ranges::to_vector;
 
    assert(!all_phases.empty());
 
    // ... and check if any of the phases are different by type.
    if (ranges::any_of(all_phases,
                       [p0 = all_phases.front()](auto const* const p)
                       { return p->phaseName != p0->phaseName; }))
    {
        OGS_FATAL(
            "You are mixing liquid and gas phases in your model domain. OGS "
            "does not yet know how to handle this.");
    }
}

References fluidPhase(), MeshLib::Mesh::getElements(), MeshLib::views::ids, MaterialPropertyLib::MaterialSpatialDistributionMap::media(), and OGS_FATAL.

Referenced by ProcessLib::LiquidFlow::checkMPLProperties(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), and ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess().

checkRequiredProperties() [1/3]

void MaterialPropertyLib::checkRequiredProperties	(	Component const &	c,
		std::span< PropertyType const > const	required_properties )

Definition at line 51 of file Component.cpp.

{
    for (auto const& p : required_properties)
    {
        if (!c.hasProperty(p))
        {
            OGS_FATAL("The property '{:s}' is missing in the component '{:s}'.",
                      property_enum_to_string[p], c.name);
        }
    }
}

References c, OGS_FATAL, and property_enum_to_string.

Referenced by checkMaterialSpatialDistributionMap().

checkRequiredProperties() [2/3]

void MaterialPropertyLib::checkRequiredProperties	(	Medium const &	medium,
		std::span< PropertyType const > const	required_properties )

Definition at line 80 of file Medium.cpp.

{
    for (auto const& p : required_properties)
    {
        if (!medium.hasProperty(p))
        {
            OGS_FATAL(
                "The property '{:s}' is missing in the medium definition.",
                property_enum_to_string[p]);
        }
    }
}

References MaterialPropertyLib::Medium::hasProperty(), OGS_FATAL, and property_enum_to_string.

checkRequiredProperties() [3/3]

void MaterialPropertyLib::checkRequiredProperties	(	Phase const &	phase,
		std::span< PropertyType const > const	required_properties )

Definition at line 112 of file Phase.cpp.

{
    for (auto const& p : required_properties)
    {
        if (!phase.hasProperty(p))
        {
            OGS_FATAL("The property '{:s}' is missing in the {:s} phase.",
                      property_enum_to_string[p], toString(phase.phaseName));
        }
    }
}

References MaterialPropertyLib::Phase::hasProperty(), OGS_FATAL, MaterialPropertyLib::Phase::phaseName, property_enum_to_string, and toString().

checkSaturationRange()

void MaterialPropertyLib::checkSaturationRange

(

const double

Sl

)

Definition at line 16 of file CapillaryPressureRegularizedVanGenuchten.cpp.

{
    if (Sl < 0 || Sl > 1)
    {
        OGS_FATAL("The saturation of {:e} is out of its range of [0, 1]", Sl);
    }
}

References OGS_FATAL.

Referenced by MaterialPropertyLib::CapillaryPressureRegularizedVanGenuchten::dValue(), and MaterialPropertyLib::CapillaryPressureRegularizedVanGenuchten::value().

checkVanGenuchtenExponentRange()

void MaterialPropertyLib::checkVanGenuchtenExponentRange

(

const double

m

)

Definition at line 10 of file CheckVanGenuchtenExponentRange.cpp.

{
    if (m <= 0 || m >= 1)
    {
        OGS_FATAL(
            "The exponent value m = {:e} of van Genuchten saturation model, is "
            "out of its range of(0, 1) ",
            m);
    }
}

References OGS_FATAL.

Referenced by MaterialPropertyLib::CapillaryPressureRegularizedVanGenuchten::CapillaryPressureRegularizedVanGenuchten(), and MaterialPropertyLib::RelPermNonWettingPhaseVanGenuchtenMualem::RelPermNonWettingPhaseVanGenuchtenMualem().

closureSlipParameter()

double MaterialPropertyLib::closureSlipParameter ( DriftFluxState const & state )

static

Slip parameter \(S = C_0 (x + (1 - x) \rho_v / \rho_l)\) of the drift-flux closure, see computeVapourVoidFraction().

Definition at line 19 of file DriftFluxModel.cpp.

{
    return state.C_0 *
           (state.dryness + (1 - state.dryness) * state.vapour_water_density /
                                state.liquid_water_density);
}

References MaterialPropertyLib::DriftFluxState::C_0, MaterialPropertyLib::DriftFluxState::dryness, MaterialPropertyLib::DriftFluxState::liquid_water_density, and MaterialPropertyLib::DriftFluxState::vapour_water_density.

Referenced by computeVapourVoidFraction(), voidFractionClosureDiagnostics(), voidFractionQuadratic(), and voidFractionResidual().

computeAverage()

template<MeanType MeanType>

double MaterialPropertyLib::computeAverage ( const double , double const , double const  )

delete

Referenced by MaterialPropertyLib::SaturationWeightedThermalConductivity< MeantType, GlobalDimension >::value().

computeAverage< MeanType::ARITHMETIC_LINEAR >()

template<>

double MaterialPropertyLib::computeAverage< MeanType::ARITHMETIC_LINEAR >	(	const double	S,
		double const	k_dry,
		double const	k_wet )

Definition at line 30 of file SaturationWeightedThermalConductivity.cpp.

{
    return k_dry * (1.0 - S) + k_wet * S;
}

computeAverage< MeanType::ARITHMETIC_SQUAREROOT >()

template<>

double MaterialPropertyLib::computeAverage< MeanType::ARITHMETIC_SQUAREROOT >	(	const double	S,
		double const	k_dry,
		double const	k_wet )

Definition at line 46 of file SaturationWeightedThermalConductivity.cpp.

{
    return k_dry + std::sqrt(S) * (k_wet - k_dry);
}

computeAverage< MeanType::GEOMETRIC >()

template<>

double MaterialPropertyLib::computeAverage< MeanType::GEOMETRIC >	(	const double	S,
		double const	k_dry,
		double const	k_wet )

Definition at line 62 of file SaturationWeightedThermalConductivity.cpp.

{
    return k_dry * std::pow(k_wet / k_dry, S);
}

computeBarLambda0Factor()

double MaterialPropertyLib::computeBarLambda0Factor ( const double barT )

static

Definition at line 80 of file WaterThermalConductivityIAPWS.cpp.

{
    double sum_val = 0.;
    double barT_i = 1.;
    for (double value : Li)
    {
        sum_val += (value / barT_i);
        barT_i *= barT;
    }
    return sum_val;
}

References Li.

Referenced by computedBarLambda_dbarRho(), computedBarLambda_dbarT(), and MaterialPropertyLib::WaterThermalConductivityIAPWS::value().

computeBarLambda1Factor()

double MaterialPropertyLib::computeBarLambda1Factor ( const std::array< double, 5 > & series_factorT, const std::array< double, 6 > & series_factorRho )

static

Definition at line 117 of file WaterThermalConductivityIAPWS.cpp.

{
    double sum_val = 0.;
    for (int i = 0; i < 5; i++)
    {
        double sum_val_j = 0;
        for (int j = 0; j < 6; j++)
        {
            sum_val_j += Lij[i][j] * series_factorRho[j];
        }
        sum_val += series_factorT[i] * sum_val_j;
    }
 
    return sum_val;
}

References Lij.

Referenced by computedBarLambda_dbarRho(), computedBarLambda_dbarT(), and MaterialPropertyLib::WaterThermalConductivityIAPWS::value().

computeBarMu0Factor()

double MaterialPropertyLib::computeBarMu0Factor ( const double barT )

static

Definition at line 73 of file WaterViscosityIAPWS.cpp.

{
    double sum_val = 0.;
    double barT_i = 1.;
    for (double value : Hi)
    {
        sum_val += (value / barT_i);
        barT_i *= barT;
    }
    return sum_val;
}

References Hi.

Referenced by computedBarMu_dbarRho(), computedBarMu_dbarT(), and MaterialPropertyLib::WaterViscosityIAPWS::value().

computeBarMu1Factor()

double MaterialPropertyLib::computeBarMu1Factor ( const std::array< double, 6 > & series_factorT, const std::array< double, 7 > & series_factorRho )

static

Definition at line 110 of file WaterViscosityIAPWS.cpp.

{
    double sum_val = 0.;
    for (int i = 0; i < 6; i++)
    {
        double sum_val_j = 0;
        for (int j = 0; j < 7; j++)
        {
            sum_val_j += Hij[i][j] * series_factorRho[j];
        }
        sum_val += series_factorT[i] * sum_val_j;
    }
 
    return sum_val;
}

References Hij.

Referenced by computedBarMu_dbarRho(), computedBarMu_dbarT(), and MaterialPropertyLib::WaterViscosityIAPWS::value().

computeDAverage()

template<MeanType MeanType>

double MaterialPropertyLib::computeDAverage ( const double , double const , double const  )

delete

Referenced by MaterialPropertyLib::SaturationWeightedThermalConductivity< MeantType, GlobalDimension >::dValue().

computeDAverage< MeanType::ARITHMETIC_LINEAR >()

template<>

double MaterialPropertyLib::computeDAverage< MeanType::ARITHMETIC_LINEAR >	(	const double	,
		double const	k_dry,
		double const	k_wet )

Definition at line 38 of file SaturationWeightedThermalConductivity.cpp.

{
    return k_wet - k_dry;
}

computeDAverage< MeanType::ARITHMETIC_SQUAREROOT >()

template<>

double MaterialPropertyLib::computeDAverage< MeanType::ARITHMETIC_SQUAREROOT >	(	const double	S,
		double const	k_dry,
		double const	k_wet )

Definition at line 54 of file SaturationWeightedThermalConductivity.cpp.

{
    return 0.5 * (k_wet - k_dry) / std::sqrt(S);
}

computeDAverage< MeanType::GEOMETRIC >()

template<>

double MaterialPropertyLib::computeDAverage< MeanType::GEOMETRIC >	(	const double	S,
		double const	k_dry,
		double const	k_wet )

Definition at line 69 of file SaturationWeightedThermalConductivity.cpp.

{
    return k_dry * std::pow(k_wet / k_dry, S) * std::log(k_wet / k_dry);
}

computedBarLambda_dbarRho()

double MaterialPropertyLib::computedBarLambda_dbarRho ( const double barT, double bar_rho )

static

Definition at line 176 of file WaterThermalConductivityIAPWS.cpp.

{
    const auto& series_factorT = computeSeriesFactorTForLambda1(barT);
    const auto& series_factorRho = computeSeriesFactorRhoForLambda1(bar_rho);
 
    double dlambda1_factor_dbar_rho = 0.0;
    for (int i = 0; i < 5; i++)
    {
        double sum_val_j = 0;
        for (int j = 1; j < 6; j++)
        {
            sum_val_j +=
                static_cast<double>(j) * Lij[i][j] * series_factorRho[j - 1];
        }
        dlambda1_factor_dbar_rho += series_factorT[i] * sum_val_j;
    }
 
    const double lambda0 = std::sqrt(barT) / computeBarLambda0Factor(barT);
 
    const double lambda1_factor =
        computeBarLambda1Factor(series_factorT, series_factorRho);
    return lambda0 * std::exp(bar_rho * lambda1_factor) *
           (lambda1_factor + bar_rho * dlambda1_factor_dbar_rho);
}

References computeBarLambda0Factor(), computeBarLambda1Factor(), computeSeriesFactorRhoForLambda1(), computeSeriesFactorTForLambda1(), and Lij.

Referenced by MaterialPropertyLib::WaterThermalConductivityIAPWS::dValue().

computedBarLambda_dbarT()

double MaterialPropertyLib::computedBarLambda_dbarT ( const double barT, double bar_rho )

static

Definition at line 134 of file WaterThermalConductivityIAPWS.cpp.

{
    const double lambda0_factor = computeBarLambda0Factor(barT);
    const double sqrt_barT = std::sqrt(barT);
 
    double dlambda0_factor_dbarT = 0.0;
    double barT_i = barT * barT;
    for (int i = 1; i < 5; i++)
    {
        dlambda0_factor_dbarT -= static_cast<double>(i) * (Li[i] / barT_i);
        barT_i *= barT;
    }
 
    const double dbar_lambda0_dbarT =
        0.5 / (lambda0_factor * sqrt_barT) -
        sqrt_barT * dlambda0_factor_dbarT / (lambda0_factor * lambda0_factor);
 
    const auto& series_factorT = computeSeriesFactorTForLambda1(barT);
    const auto& series_factorRho = computeSeriesFactorRhoForLambda1(bar_rho);
 
    double dlambda1_factor_dbarT = 0.0;
    for (int i = 1; i < 5; i++)
    {
        double sum_val_j = 0;
        for (int j = 0; j < 6; j++)
        {
            sum_val_j += Lij[i][j] * series_factorRho[j];
        }
        dlambda1_factor_dbarT -= static_cast<double>(i) *
                                 series_factorT[i - 1] * sum_val_j /
                                 (barT * barT);
    }
 
    const double lambda1_factor =
        computeBarLambda1Factor(series_factorT, series_factorRho);
    const double dbar_lambda1_dbarT =
        bar_rho * std::exp(bar_rho * lambda1_factor) * dlambda1_factor_dbarT;
 
    return dbar_lambda0_dbarT * std::exp(bar_rho * lambda1_factor) +
           dbar_lambda1_dbarT * sqrt_barT / lambda0_factor;
}

References computeBarLambda0Factor(), computeBarLambda1Factor(), computeSeriesFactorRhoForLambda1(), computeSeriesFactorTForLambda1(), Li, and Lij.

Referenced by MaterialPropertyLib::WaterThermalConductivityIAPWS::dValue().

computedBarMu_dbarRho()

double MaterialPropertyLib::computedBarMu_dbarRho ( const double barT, double bar_rho )

static

Definition at line 168 of file WaterViscosityIAPWS.cpp.

{
    const auto& series_factorT = computeSeriesFactorTForMu1(barT);
    const auto& series_factorRho = computeSeriesFactorRhoForMu1(bar_rho);
 
    double dmu1_factor_dbar_rho = 0.0;
    for (int i = 0; i < 6; i++)
    {
        double sum_val_j = 0;
        for (int j = 1; j < 7; j++)
        {
            sum_val_j +=
                static_cast<double>(j) * Hij[i][j] * series_factorRho[j - 1];
        }
        dmu1_factor_dbar_rho += series_factorT[i] * sum_val_j;
    }
 
    const double mu0 = 100. * std::sqrt(barT) / computeBarMu0Factor(barT);
 
    const double mu1_factor =
        computeBarMu1Factor(series_factorT, series_factorRho);
    return mu0 * std::exp(bar_rho * mu1_factor) *
           (mu1_factor + bar_rho * dmu1_factor_dbar_rho);
}

References computeBarMu0Factor(), computeBarMu1Factor(), computeSeriesFactorRhoForMu1(), computeSeriesFactorTForMu1(), and Hij.

Referenced by MaterialPropertyLib::WaterViscosityIAPWS::dValue().

computedBarMu_dbarT()

double MaterialPropertyLib::computedBarMu_dbarT ( const double barT, double bar_rho )

static

Definition at line 127 of file WaterViscosityIAPWS.cpp.

{
    const double mu0_factor = computeBarMu0Factor(barT);
    const double sqrt_barT = std::sqrt(barT);
 
    double dmu0_factor_dbarT = 0.0;
    double barT_i = barT * barT;
    for (int i = 1; i < 4; i++)
    {
        dmu0_factor_dbarT -= static_cast<double>(i) * (Hi[i] / barT_i);
        barT_i *= barT;
    }
 
    const double dbar_mu0_dbarT =
        50. / (mu0_factor * sqrt_barT) -
        100. * sqrt_barT * dmu0_factor_dbarT / (mu0_factor * mu0_factor);
 
    const auto& series_factorT = computeSeriesFactorTForMu1(barT);
    const auto& series_factorRho = computeSeriesFactorRhoForMu1(bar_rho);
 
    double dmu1_factor_dbarT = 0.0;
    for (int i = 1; i < 6; i++)
    {
        double sum_val_j = 0;
        for (int j = 0; j < 7; j++)
        {
            sum_val_j += Hij[i][j] * series_factorRho[j];
        }
        dmu1_factor_dbarT -= static_cast<double>(i) * series_factorT[i - 1] *
                             sum_val_j / (barT * barT);
    }
 
    const double mu1_factor =
        computeBarMu1Factor(series_factorT, series_factorRho);
    const double dbar_mu1_dbarT =
        bar_rho * std::exp(bar_rho * mu1_factor) * dmu1_factor_dbarT;
 
    return dbar_mu0_dbarT * std::exp(bar_rho * mu1_factor) +
           dbar_mu1_dbarT * 100. * sqrt_barT / mu0_factor;
}

References computeBarMu0Factor(), computeBarMu1Factor(), computeSeriesFactorRhoForMu1(), computeSeriesFactorTForMu1(), Hi, and Hij.

Referenced by MaterialPropertyLib::WaterViscosityIAPWS::dValue().

computeSeriesFactorRhoForLambda1()

std::array< double, 6 > MaterialPropertyLib::computeSeriesFactorRhoForLambda1 ( const double bar_rho )

static

Definition at line 105 of file WaterThermalConductivityIAPWS.cpp.

{
    std::array<double, 6> series_factorRho{};
    series_factorRho[0] = 1.;
    for (int i = 1; i < 6; i++)
    {
        series_factorRho[i] = series_factorRho[i - 1] * (bar_rho - 1.0);
    }
 
    return series_factorRho;
}

Referenced by computedBarLambda_dbarRho(), computedBarLambda_dbarT(), and MaterialPropertyLib::WaterThermalConductivityIAPWS::value().

computeSeriesFactorRhoForMu1()

std::array< double, 7 > MaterialPropertyLib::computeSeriesFactorRhoForMu1 ( const double bar_rho )

static

Definition at line 98 of file WaterViscosityIAPWS.cpp.

{
    std::array<double, 7> series_factorRho{};
    series_factorRho[0] = 1.;
    for (int i = 1; i < 7; i++)
    {
        series_factorRho[i] = series_factorRho[i - 1] * (bar_rho - 1.0);
    }
 
    return series_factorRho;
}

Referenced by computedBarMu_dbarRho(), computedBarMu_dbarT(), and MaterialPropertyLib::WaterViscosityIAPWS::value().

computeSeriesFactorTForLambda1()

std::array< double, 5 > MaterialPropertyLib::computeSeriesFactorTForLambda1 ( const double barT )

static

Definition at line 92 of file WaterThermalConductivityIAPWS.cpp.

{
    std::array<double, 5> series_factorT{};
    series_factorT[0] = 1.;
    const double barT_fac = 1 / barT - 1.0;
    for (int i = 1; i < 5; i++)
    {
        series_factorT[i] = series_factorT[i - 1] * barT_fac;
    }
 
    return series_factorT;
}

Referenced by computedBarLambda_dbarRho(), computedBarLambda_dbarT(), and MaterialPropertyLib::WaterThermalConductivityIAPWS::value().

computeSeriesFactorTForMu1()

std::array< double, 6 > MaterialPropertyLib::computeSeriesFactorTForMu1 ( const double barT )

static

Definition at line 85 of file WaterViscosityIAPWS.cpp.

{
    std::array<double, 6> series_factorT{};
    series_factorT[0] = 1.;
    const double barT_fac = 1 / barT - 1.0;
    for (int i = 1; i < 6; i++)
    {
        series_factorT[i] = series_factorT[i - 1] * barT_fac;
    }
 
    return series_factorT;
}

Referenced by computedBarMu_dbarRho(), computedBarMu_dbarT(), and MaterialPropertyLib::WaterViscosityIAPWS::value().

computeTemperature()

double MaterialPropertyLib::computeTemperature	(	double const	pi,
		double const	eta )

Definition at line 27 of file WaterTemperatureIAPWSIF97Region1.cpp.

{
    double val = 0.;
    for (int i = 0; i < 20; i++)
    {
        val += n_T[i] * std::pow(pi, I_T[i]) * std::pow(eta + 1, J_T[i]);
    }
 
    return val;
}

References I_T, J_T, and n_T.

Referenced by MaterialPropertyLib::WaterTemperatureIAPWSIF97Region1::value().

computeVanGenuchtenMualemValue()

double MaterialPropertyLib::computeVanGenuchtenMualemValue	(	const double	S_L,
		const double	S_L_r,
		const double	S_L_max,
		const double	m )

Definition at line 17 of file RelPermNonWettingPhaseVanGenuchtenMualem.cpp.

{
    const double Se = (S_L - S_L_r) / (S_L_max - S_L_r);
    return std::sqrt(1.0 - Se) * std::pow(1.0 - std::pow(Se, 1.0 / m), 2.0 * m);
}

Referenced by MaterialPropertyLib::RelPermNonWettingPhaseVanGenuchtenMualem::computeSaturationForMinimumRelativePermeability(), and MaterialPropertyLib::RelPermNonWettingPhaseVanGenuchtenMualem::value().

computeVapourVoidFraction()

std::optional< double > MaterialPropertyLib::computeVapourVoidFraction

(

DriftFluxState const &

state

)

Vapour void fraction of the Rouhani-Axelsson drift-flux closure, see Rouhani, Z., and E. Axelsson. "Calculation of volume void fraction in a subcooled and quality region." International Journal of Heat and Mass Transfer 17 (1970): 383-393.

With the mixture density \(\rho_m = \alpha \rho_v + (1 - \alpha) \rho_l\) and the mass flux \(G = \rho_m v\) the closure reads

\[ G (x - \alpha S) - \alpha \rho_v u_{gu} = 0, \quad S = C_0 \left(x + (1 - x) \frac{\rho_v}{\rho_l}\right), \]

which is a quadratic equation in \(\alpha\) because \(\rho_m\) depends on \(\alpha\) linearly.

For co-current upflow, \(v > 0\) and \(0 < x < 1\), the residual is positive at \(\alpha = 0\) and negative at \(\alpha = 1\), hence a root exists, and it is the only root in the admissible interval \([0, \min(1, x / S)]\). The bound \(x / S\) is the homogeneous void fraction divided by the profile parameter and is at most one as long as \(C_0 \ge 1\), which is what driftFluxProfileParameter() gives; the minimum keeps the returned volume fraction below one for a profile parameter below one as well. As long as the phase densities are ordered, \(\rho_l > \rho_v\), the parabola opens upwards and the second root is larger than one. Where the two densities cross, in the immediate vicinity of the critical point, it opens downwards and both roots can lie below one, which is why the root is selected by testing the admissible interval rather than by its position.

The correlation is derived for co-current flow. Written with a drift velocity that is fixed in the gravity frame it has no admissible solution for backflow, \(v < 0\): the denominator \(S G + \rho_v u_{gu}\) of the closure changes sign, so the void fraction has a pole and leaves \([0, 1]\). The drift velocity is therefore aligned with the mixture flow, \(u_{gu} \to \operatorname{sign}(v)\, u_{gu}\), which makes the residual odd under \(v \to -v\) and hence the void fraction an even function of the mixture velocity. Existence and uniqueness above then hold for every mixture velocity, and \(\alpha \sim |v|\) near \(v = 0\), that is the void fraction is continuous but not differentiable where the flow reverses. They hold for the exact closure; the arithmetic that implements it reports no admissible root once the mixture velocity is small enough that the coefficients of the quadratic underflow, below some \(10^{-160}\) m/s, which is answered by a retreat like any other state without a root. A mixture at rest, \(v = 0\) exactly, is resolved by continuity instead, see below.

The kink at \(v = 0\) could be removed by scaling the drift velocity with \(v / \sqrt{v^2 + u_{gu}^2}\), using the drift velocity itself as the velocity scale so that no tuning parameter is introduced. This is not done because it changes the void fraction in the whole band \(|v| \lesssim u_{gu}\); what the kink does to the convergence of the global Newton solver has not been investigated.

Solves the closure in closed form and returns the root in the admissible interval, or no value if the closure has no admissible solution for the given state.

A mixture at rest without drift, \(v = 0\) and \(u_{gu} = 0\), leaves every coefficient of the quadratic zero and the closure is satisfied by every void fraction. It is resolved by continuity: without drift the closure reads \(x = \alpha S\) for every non-zero mixture velocity, independently of it, so the limit is the profile slip alone, \(\alpha = x / S\).

Single phase states, \(x \le 0\) and \(x \ge 1\), return \(0\) and \(1\) without looking at the state, in particular without looking at the density of the absent phase.

For a two-phase state it throws NumLib::AssemblyException for a non-positive phase density and for a non-finite dryness, mixture velocity, drift flux velocity, or profile parameter: all of those follow the solution iterate, so the assembly is aborted rather than the run ended.

What the abort leads to is up to the nonlinear solver, and both of them answer it the same way: the Newton and the Picard solver each catch NumLib::AssemblyException, end the nonlinear iteration and let the time stepping repeat the step with a smaller time step size, with the state of the closure reported.

Parameters

state

the state of the closure.

Returns

The vapour void fraction, dimensionless, or no value if the closure has no admissible solution for that state.

Definition at line 140 of file DriftFluxModel.cpp.

{
    auto const& [dryness, vapour_water_density, liquid_water_density, v_mix,
                 C_0, u_gu] = state;
 
    // Single phase states are exact, no closure is needed. They are settled
    // before the state validation below because the density of the absent
    // phase does not enter the result: it is the one evaluated far off the
    // saturation line and hence the one that may be non-positive, and a pure
    // liquid or pure vapour section must not abort the assembly for it. A NaN
    // dryness satisfies neither comparison and reaches the validation.
    if (dryness <= 0)
    {
        return 0.;
    }
    if (dryness >= 1)
    {
        return 1.;
    }
 
    // All arguments are computed from the current solution iterate, so a
    // non-physical value is a diverging global Newton step, not a broken
    // input. Aborting the assembly ends the nonlinear iteration and lets the
    // time stepping repeat the step under either solver, whereas OGS_FATAL
    // would end the run; see the documentation of this function.
    //
    // The phase densities are evaluated on the IAPWS-IF97 region 4 saturation
    // line, which is extrapolated outside of its pressure range 611.213 Pa to
    // 22.064 MPa and then may return non-positive or NaN values. The negated
    // comparison is deliberate; `density <= 0` lets a NaN density pass.
    if (!(liquid_water_density > 0) || !(vapour_water_density > 0))
    {
        throw NumLib::AssemblyException(fmt::format(
            "Non-positive phase density in the vapour void fraction closure: "
            "liquid density {:g} kg/m^3, vapour density {:g} kg/m^3.",
            liquid_water_density, vapour_water_density));
    }
    if (!std::isfinite(dryness) || !std::isfinite(v_mix) ||
        !std::isfinite(u_gu) || !std::isfinite(C_0))
    {
        throw NumLib::AssemblyException(fmt::format(
            "Non-finite state in the vapour void fraction closure: dryness "
            "{:g}, mixture velocity {:g} m/s, drift flux velocity {:g} m/s, "
            "profile parameter {:g}.",
            dryness, v_mix, u_gu, C_0));
    }
 
    double const S = closureSlipParameter(state);
 
    // Upper bound of the admissible interval. The slip transports vapour out
    // of the control volume, so the void fraction stays below the homogeneous
    // one, alpha <= dryness / S <= alpha_homogeneous. That bound is at most
    // one for a profile parameter of at least one, which is what the
    // Rouhani-Axelsson correlation of driftFluxProfileParameter() gives. A
    // profile parameter below one describes a void profile peaking at the
    // wall rather than at the centre; the bound then exceeds one and the
    // volume fraction of the vapour, which cannot, hence the minimum.
    double const alpha_max = std::min(1., dryness / S);
 
    // The drift is aligned with the mixture flow, see above.
    auto const [a, b, c] = voidFractionQuadratic(alignDriftWithFlow(state));
 
    // The quadratic degenerates to a linear equation at vanishing mixture
    // velocity and at the critical point, where both phase densities coincide.
    // The tolerance is relative, to the linear coefficient below and to
    // b^2 for the discriminant, and some tens of machine epsilons, 45 of
    // them: that is the scale on which the coefficients, each a difference
    // of products of the closure state, lose their last digits, while a
    // quadratic whose leading coefficient is that much smaller than the linear
    // one has its small root within the accuracy of the linear solve anyway.
    constexpr double degeneracy_tolerance = 1e-14;
 
    // A root and the bound alpha_max are computed by different expressions, so
    // a root that coincides with the bound can come out just outside of it.
    // Roots are therefore accepted with a tolerance and clamped afterwards.
    // The tolerance is about the square root of the machine epsilon, which is
    // the accuracy a root of a quadratic is worth near a double root, where the
    // root shifts with the square root of the perturbation of the
    // coefficients.
    constexpr double interval_tolerance = 1e-8;
 
    auto const admissible = [&](double const alpha) -> std::optional<double>
    {
        double const tolerance = interval_tolerance * std::max(1., alpha_max);
        // The negated comparisons are deliberate; the plain form lets a NaN
        // root through to the clamp below, which returns it as an admissible
        // void fraction.
        if (!(alpha >= -tolerance) || !(alpha <= alpha_max + tolerance))
        {
            return std::nullopt;
        }
        return std::clamp(alpha, 0., alpha_max);
    };
 
    if (std::abs(a) <= degeneracy_tolerance * std::abs(b))
    {
        if (b == 0)
        {
            // Every coefficient vanishes, which for a validated two-phase
            // state happens exactly for a mixture at rest without drift, that
            // is v_mix = 0 and u_gu = 0. The closure then holds for every void
            // fraction. Retreating would not resolve it, because repeating the
            // time step does not change the velocity of the current iterate,
            // so the value is taken from the limit instead: without drift the
            // closure reads x = alpha S for every non-zero mixture velocity,
            // independently of it, hence alpha = x / S = alpha_max, the
            // profile slip alone.
            if (c == 0)
            {
                return admissible(alpha_max);
            }
            return std::nullopt;
        }
        return admissible(-c / b);
    }
 
    // Both terms underflow to zero for a mixture velocity in the subnormal
    // range, which loses the small root and is reported as no admissible root
    // rather than as a wrong one. Rescaling the coefficients would avoid it,
    // at the price of perturbing the rounding of every reachable state, and
    // the velocities in question are some 1e-160 m/s.
    double discriminant = b * b - 4 * a * c;
    if (discriminant < 0)
    {
        // A double root cannot be distinguished from a pair of complex roots
        // within the accuracy of the cancelling difference above.
        if (discriminant < -degeneracy_tolerance * b * b)
        {
            return std::nullopt;
        }
        discriminant = 0;
    }
 
    // Stable roots: the direct formula loses the small root to cancellation
    // whenever 4 a c is small compared to b^2, which is the case for small
    // dryness.
    double const q = -0.5 * (b + std::copysign(std::sqrt(discriminant), b));
    if (q == 0)
    {
        return admissible(0.);
    }
 
    // The smaller root is the one continuous with the single phase limit
    // alpha(dryness -> 0) = 0.
    double const root_1 = q / a;
    double const root_2 = c / q;
 
    auto const first = admissible(std::min(root_1, root_2));
    return first ? first : admissible(std::max(root_1, root_2));
}

References alignDriftWithFlow(), alpha, c, closureSlipParameter(), and voidFractionQuadratic().

Referenced by ProcessLib::WellboreCompensateNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), and ProcessLib::WellboreSimulator::WellboreSimulatorFEM< ShapeFunction, GlobalDim >::assemble().

convertStringToProperty()

PropertyType MaterialPropertyLib::convertStringToProperty

(

std::string const &

string

)

This function converts a string (e.g. a string from the configuration-tree) into one of the entries of the PropertyType enumerator.

Definition at line 12 of file PropertyType.cpp.

{
    for (int i = 0; i < static_cast<int>(PropertyType::number_of_properties);
         ++i)
    {
        if (boost::iequals(string, property_enum_to_string[i]))
        {
            return static_cast<PropertyType>(i);
        }
    }
 
    OGS_FATAL(
        "The property name '{:s}' does not correspond to any known property",
        string);
}

References number_of_properties, OGS_FATAL, and property_enum_to_string.

Referenced by MaterialPropertyLib::VolumeFractionAverage::VolumeFractionAverage(), and createProperties().

convertStringToVariable()

Variable MaterialPropertyLib::convertStringToVariable

(

std::string const &

string

)

This function converts a string (e.g. a string from the configuration-tree) into one of the entries of the Variable enumerator.

Definition at line 20 of file VariableType.cpp.

{
    for (int i = 0; i < static_cast<int>(Variable::number_of_variables); ++i)
    {
        if (boost::iequals(string, variable_enum_to_string[i]))
        {
            return static_cast<Variable>(i);
        }
    }
 
    OGS_FATAL(
        "The variable name '{:s}' does not correspond to any known variable",
        string);
}

References number_of_variables, OGS_FATAL, and variable_enum_to_string.

Referenced by MaterialPropertyLib::Function::Function(), MaterialPropertyLib::PerThreadData::compileExpressions(), createCurve(), createExponential(), createLinear(), createSigmoid(), and createSymbolTable().

createAverageMolarMass()

std::unique_ptr< AverageMolarMass > MaterialPropertyLib::createAverageMolarMass

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__AverageMolarMass

Definition at line 9 of file CreateAverageMolarMass.cpp.

{
    config.checkConfigParameter("type", "AverageMolarMass");

    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create AverageMolarMass medium property");
    return std::make_unique<AverageMolarMass>(std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createBishopsPowerLaw()

std::unique_ptr< BishopsPowerLaw > MaterialPropertyLib::createBishopsPowerLaw

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__BishopsPowerLaw__exponent

Definition at line 9 of file CreateBishopsPowerLaw.cpp.

{
    config.checkConfigParameter("type", "BishopsPowerLaw");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create BishopsPowerLaw property {:s}.", property_name);
 
    auto const exponent =
        config.getConfigParameter<double>("exponent");
 
    return std::make_unique<MaterialPropertyLib::BishopsPowerLaw>(
        std::move(property_name), exponent);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createBishopsSaturationCutoff()

std::unique_ptr< BishopsSaturationCutoff > MaterialPropertyLib::createBishopsSaturationCutoff

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__BishopsSaturationCutoff__cutoff_value

Definition at line 9 of file CreateBishopsSaturationCutoff.cpp.

{
    config.checkConfigParameter("type", "BishopsSaturationCutoff");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create BishopsSaturationCutoff property {:s}.", property_name);
 
    auto const cutoff_value =
        config.getConfigParameter<double>("cutoff_value");
 
    return std::make_unique<MaterialPropertyLib::BishopsSaturationCutoff>(
        std::move(property_name), cutoff_value);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createCapillaryPressureRegularizedVanGenuchten()

std::unique_ptr< Property > MaterialPropertyLib::createCapillaryPressureRegularizedVanGenuchten

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__CapillaryPressureRegularizedVanGenuchten__residual_liquid_saturation

Input File Parameter

properties__property__CapillaryPressureRegularizedVanGenuchten__residual_gas_saturation

Input File Parameter

properties__property__CapillaryPressureRegularizedVanGenuchten__exponent

Input File Parameter

properties__property__CapillaryPressureRegularizedVanGenuchten__p_b

Definition at line 12 of file CreateCapillaryPressureRegularizedVanGenuchten.cpp.

{
    config.checkConfigParameter("type",
                                "CapillaryPressureRegularizedVanGenuchten");
 
    DBUG("Create CapillaryPressureRegularizedVanGenuchten medium property");
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const maximum_liquid_saturation =
        1.0 -
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const exponent =
        config.getConfigParameter<double>("exponent");
    auto const p_b =
        config.getConfigParameter<double>("p_b");
 
    return std::make_unique<CapillaryPressureRegularizedVanGenuchten>(
        residual_liquid_saturation, maximum_liquid_saturation, exponent, p_b);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createCapillaryPressureVanGenuchten()

std::unique_ptr< Property > MaterialPropertyLib::createCapillaryPressureVanGenuchten

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__CapillaryPressureVanGenuchten__residual_liquid_saturation

Input File Parameter

properties__property__CapillaryPressureVanGenuchten__residual_gas_saturation

Input File Parameter

properties__property__CapillaryPressureVanGenuchten__exponent

Input File Parameter

properties__property__CapillaryPressureVanGenuchten__p_b

Input File Parameter

properties__property__CapillaryPressureVanGenuchten__maximum_capillary_pressure

Definition at line 12 of file CreateCapillaryPressureVanGenuchten.cpp.

{
    config.checkConfigParameter("type", "CapillaryPressureVanGenuchten");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create CapillaryPressureVanGenuchten medium property {:s}.",
         property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const exponent =
        config.getConfigParameter<double>("exponent");
    auto const p_b =
        config.getConfigParameter<double>("p_b");
    auto const maximum_capillary_pressure =
        config.getConfigParameter<double>("maximum_capillary_pressure");
 
    return std::make_unique<CapillaryPressureVanGenuchten>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, exponent, p_b, maximum_capillary_pressure);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createClausiusClapeyron()

std::unique_ptr< ClausiusClapeyron > MaterialPropertyLib::createClausiusClapeyron

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__ClausiusClapeyron__triple_temperature

Input File Parameter

properties__property__ClausiusClapeyron__triple_pressure

Input File Parameter

properties__property__ClausiusClapeyron__critical_temperature

Input File Parameter

properties__property__ClausiusClapeyron__critical_pressure

Input File Parameter

properties__property__ClausiusClapeyron__reference_temperature

Input File Parameter

properties__property__ClausiusClapeyron__reference_pressure

Input File Parameter

properties__property__ClausiusClapeyron

Definition at line 9 of file CreateClausiusClapeyron.cpp.

{
    config.checkConfigParameter("type", "ClausiusClapeyron");

    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create ClausiusClapeyron property {:s}.", property_name);
 
    auto const triple_temperature =
        config.getConfigParameter<double>("triple_temperature");
 
    auto const triple_pressure =
        config.getConfigParameter<double>("triple_pressure");
 
    auto const critical_temperature =
        config.getConfigParameter<double>("critical_temperature");
 
    auto const critical_pressure =
        config.getConfigParameter<double>("critical_pressure");
 
    auto const ref_temperature =
        config.getConfigParameter<double>("reference_temperature");
 
    auto const ref_pressure =
        config.getConfigParameter<double>("reference_pressure");

    return std::make_unique<ClausiusClapeyron>(
        std::move(property_name), triple_temperature, triple_pressure,
        critical_temperature, critical_pressure, ref_temperature, ref_pressure);
}

References BaseLib::ConfigTree::checkConfigParameter(), critical_pressure, critical_temperature, DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createComponents()

std::vector< std::unique_ptr< Component > > MaterialPropertyLib::createComponents	(	int const	geometry_dimension,
		std::optional< BaseLib::ConfigTree > const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &	parameters,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

The method creates components based on config subtree.

Just like a phase, a component can have a name. But, in this case, the name has an important task. If a name is given, a specific component class referring to that name with corresponding physical material properties is created. Assigning a name is optional; If no name is given, a custom component without predefined properties is created.

Input File Parameter

prj__media__medium__phases__phase__components__component

Definition at line 67 of file CreateComponent.cpp.

{
    if (!config)
    {
        return {};
    }
 
    std::vector<std::unique_ptr<Component>> components;
    for (
        auto const& component_config :
        config->getConfigSubtreeList("component"))
    {
        auto component =
            createComponent(geometry_dimension, component_config, parameters,
                            local_coordinate_system, curves);
 
        if (std::find_if(components.begin(),
                         components.end(),
                         [component_name = component->name](auto const& c) {
                             return c->name == component_name;
                         }) != components.end())
        {
            OGS_FATAL(
                "Found duplicates with the same component name tag '{:s}'.",
                component->name);
        }
 
        components.push_back(std::move(component));
    }
 
    return components;
}

References c, and OGS_FATAL.

Referenced by anonymous_namespace{CreatePhase.cpp}::createPhase().

createConstant()

std::unique_ptr< Constant > MaterialPropertyLib::createConstant

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__Constant__value

Input File Parameter

properties__property__Constant__values

Definition at line 9 of file CreateConstant.cpp.

{
    config.checkConfigParameter("type", "Constant");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create Constant property {:s}.", property_name);
    auto const value_data =
        config.getConfigParameterOptional<std::vector<double>>("value");
 
    auto const values_data =
        config.getConfigParameterOptional<std::vector<double>>("values");
 
    if ((value_data) && (values_data))
    {
        OGS_FATAL(
            "Both the value and the values tags were given.\n\
             Please give only one of them.");
    }
 
    std::vector<double> values;
 
    if (value_data)
    {
        values = *value_data;
    }
    else if (values_data)
    {
        values = *values_data;
    }
 
    if (values.empty())
    {
        OGS_FATAL("No value(s) was(were) provided.");
    }
 
    DBUG("Using following values for the constant parameter:");
    for (double const v : values)
    {
        (void)v;  // unused value if building w/o DBUG output.
        DBUG("\t{:g}", v);
    }
 
    return std::make_unique<Constant>(std::move(property_name),
                                      fromVector(values));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), fromVector(), BaseLib::ConfigTree::getConfigParameterOptional(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createCubicLawPermeability()

std::unique_ptr< Property > MaterialPropertyLib::createCubicLawPermeability	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__CubicLawPermeability__fracture_aperture

Definition at line 15 of file CreateCubicLawPermeability.cpp.

{
    config.checkConfigParameter("type", "CubicLawPermeability");
    DBUG("Create CubicLaw Permeability model");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    auto const fracture_aperture_name =
        config.getConfigParameter<std::string>("fracture_aperture", "");
 
    ParameterLib::Parameter<double>* b =
        fracture_aperture_name == ""
            ? nullptr
            : &ParameterLib::findParameter<double>(
                  fracture_aperture_name, parameters, 0, nullptr);
 
    return std::make_unique<CubicLawPermeability>(std::move(property_name), b);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createCurve()

std::unique_ptr< Curve > MaterialPropertyLib::createCurve	(	BaseLib::ConfigTree const &	config,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__Curve__curve

Input File Parameter

properties__property__Curve__independent_variable

Definition at line 16 of file CreateCurve.cpp.

{
    config.checkConfigParameter("type", "Curve");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create Curve {:s}.", property_name);

    auto curve_name = config.getConfigParameter<std::string>("curve");
    DBUG("Using curve '{:s}'", curve_name);
 
    auto const& curve =
        *BaseLib::getOrError(curves, curve_name, "Could not find curve.");
 
    auto const independent_variable_string =
        config.getConfigParameter<std::string>("independent_variable");
    DBUG("Using independent_variable '{:s}'", independent_variable_string);
 
    static const std::unordered_set<std::string> filter_not_variables = {
        "t", "x", "y", "z"};
    MaterialPropertyLib::StringOrVariable independent_variable;
    if (filter_not_variables.contains(independent_variable_string))
    {
        independent_variable = independent_variable_string;
    }
    else
    {
        independent_variable = MaterialPropertyLib::convertStringToVariable(
            independent_variable_string);
    }
 
    return std::make_unique<Curve>(
        std::move(property_name), independent_variable, curve);
}

References BaseLib::ConfigTree::checkConfigParameter(), convertStringToVariable(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::getOrError(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createDupuitPermeability()

std::unique_ptr< DupuitPermeability > MaterialPropertyLib::createDupuitPermeability	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__Dupuit__parameter_name

Definition at line 12 of file CreateDupuitPermeability.cpp.

{
    config.checkConfigParameter("type", "Dupuit");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create DupuitPermeability property {:s}.", property_name);
 
    std::string const& parameter_name =
        config.getConfigParameter<std::string>("parameter_name");
    auto const& parameter = ParameterLib::findParameter<double>(
        parameter_name, parameters, 0, nullptr);
    return std::make_unique<MaterialPropertyLib::DupuitPermeability>(
        std::move(property_name), parameter);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createEffectiveThermalConductivityPorosityMixing()

std::unique_ptr< Property > MaterialPropertyLib::createEffectiveThermalConductivityPorosityMixing	(	int const	geometry_dimension,
		BaseLib::ConfigTree const &	config,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__EffectiveThermalConductivityPorosityMixing

Definition at line 11 of file CreateEffectiveThermalConductivityPorosityMixing.cpp.

{
    config.checkConfigParameter("type",
                                "EffectiveThermalConductivityPorosityMixing");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG(
        "Create effective thermal_conductivity property from porosity mixing "
        "{:s}.",
        property_name);
 
    if (geometry_dimension == 1)
    {
        return std::make_unique<
            MaterialPropertyLib::EffectiveThermalConductivityPorosityMixing<1>>(
            std::move(property_name), local_coordinate_system);
    }
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<
            MaterialPropertyLib::EffectiveThermalConductivityPorosityMixing<2>>(
            std::move(property_name), local_coordinate_system);
    }
    return std::make_unique<
        MaterialPropertyLib::EffectiveThermalConductivityPorosityMixing<3>>(
        std::move(property_name), local_coordinate_system);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createEmbeddedFracturePermeability()

std::unique_ptr< Property > MaterialPropertyLib::createEmbeddedFracturePermeability	(	int const	geometry_dimension,
		BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__EmbeddedFracturePermeability__intrinsic_permeability

Input File Parameter

properties__property__EmbeddedFracturePermeability__initial_aperture

Input File Parameter

properties__property__EmbeddedFracturePermeability__mean_frac_distance

Input File Parameter

properties__property__EmbeddedFracturePermeability__threshold_strain

Input File Parameter

properties__property__EmbeddedFracturePermeability__fracture_normal

Input File Parameter

properties__property__EmbeddedFracturePermeability__fracture_rotation_xy

Input File Parameter

properties__property__EmbeddedFracturePermeability__fracture_rotation_yz

Input File Parameter

properties__property__EmbeddedFracturePermeability__jacobian_factor

Definition at line 10 of file CreateEmbeddedFracturePermeability.cpp.

{
    if ((geometry_dimension != 2) && (geometry_dimension != 3))
    {
        OGS_FATAL(
            "The EmbeddedFracturePermeability is implemented only for 2D or 3D "
            "problems");
    }

    config.checkConfigParameter("type", "EmbeddedFracturePermeability");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create EmbeddedFracturePermeability medium property");
 
    auto const k =
        config.getConfigParameter<double>("intrinsic_permeability");
 
    auto const b0 =
        config.getConfigParameter<double>("initial_aperture");
 
    auto const a =
        config.getConfigParameter<double>("mean_frac_distance");
 
    auto const e0 =
        config.getConfigParameter<double>("threshold_strain");
 
    bool n_const = false;
    Eigen::Matrix<double, 3, 1> n;
    if (auto const n_ptr =
        config.getConfigParameterOptional<std::vector<double>>(
            "fracture_normal"))
    {
        if ((*n_ptr).size() != 3)
        {
            OGS_FATAL(
                "The size of the fracture normal vector must be 3, but is %d.",
                (*n_ptr).size());
        }
        DBUG("Using constant fracture normal vector.");
        std::copy_n((*n_ptr).data(), 3, n.data());
        n_const = true;
        n /= n.norm();
    }
    else
    {
        DBUG(
            "No constant fracture normal was given. By default it will be "
            "determined as the third principal stress vector.");
    }
 
    std::string const fracture_rotation_xy_param_name =
        config.getConfigParameter<std::string>("fracture_rotation_xy");
 
    auto const& phi_xy = ParameterLib::findParameter<double>(
        fracture_rotation_xy_param_name, parameters, 0, nullptr);
 
    std::string const fracture_rotation_yz_param_name =
        config.getConfigParameter<std::string>("fracture_rotation_yz");
 
    auto const& phi_yz = ParameterLib::findParameter<double>(
        fracture_rotation_yz_param_name, parameters, 0, nullptr);
 
    auto const jf =
        config.getConfigParameter<double>("jacobian_factor", 0.);
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<EmbeddedFracturePermeability<2>>(
            std::move(property_name), n, n_const, k, b0, a, e0, phi_xy, phi_yz,
            jf);
    }
    return std::make_unique<EmbeddedFracturePermeability<3>>(
        std::move(property_name), n, n_const, k, b0, a, e0, phi_xy, phi_yz, jf);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createExponential()

std::unique_ptr< Exponential > MaterialPropertyLib::createExponential

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__Exponential__reference_value

Input File Parameter

properties__property__Exponential__exponent

Input File Parameter

properties__property__Exponential__exponent__variable_name

Input File Parameter

properties__property__Exponential__exponent__reference_condition

Input File Parameter

properties__property__Exponential__exponent__factor

Input File Parameter

properties__property__Exponential__offset

Definition at line 11 of file CreateExponential.cpp.

{
    config.checkConfigParameter("type", "Exponential");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create Exponential property {:s}.", property_name);
    auto const reference_value =
        config.getConfigParameter<double>("reference_value");
 
    auto const& exponent_data_config =
        config.getConfigSubtree("exponent");
 
    auto const& variable_name =
        exponent_data_config.getConfigParameter<std::string>("variable_name");
    auto const reference_condition =
        exponent_data_config.getConfigParameter<double>("reference_condition");
    auto const factor =
        exponent_data_config.getConfigParameter<double>("factor");
 
    auto const offset =
        config.getConfigParameter<double>("offset");
 
    static const std::unordered_set<std::string> filter_not_variables = {
        "t", "x", "y", "z"};
    MaterialPropertyLib::StringOrVariable exp_data_type;
    if (filter_not_variables.contains(variable_name))
    {
        exp_data_type = variable_name;
    }
    else
    {
        exp_data_type =
            MaterialPropertyLib::convertStringToVariable(variable_name);
    }
 
    MaterialPropertyLib::ExponentData const exp_data{
        exp_data_type, reference_condition, factor};
 
    return std::make_unique<MaterialPropertyLib::Exponential>(
        std::move(property_name), offset, reference_value, exp_data);
}

References BaseLib::ConfigTree::checkConfigParameter(), convertStringToVariable(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createFunction()

std::unique_ptr< Function > MaterialPropertyLib::createFunction	(	BaseLib::ConfigTree const &	config,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__Function__value

Input File Parameter

properties__property__Function__value__expression

Input File Parameter

properties__property__Function__dvalue

Input File Parameter

properties__property__Function__dvalue__variable_name

Input File Parameter

properties__property__Function__dvalue__expression

Input File Parameter

properties__property__Function__d2value

Input File Parameter

properties__property__Function__d2value__variable_name

Input File Parameter

properties__property__Function__d2value__expression

Definition at line 30 of file CreateFunction.cpp.

{
    config.checkConfigParameter("type", "Function");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create Function property {:s}.", property_name);

    auto const& value_config = config.getConfigSubtree("value");
 
    auto const value_expressions = parseExpressionList(
        value_config.getConfigSubtreeList("expression"));
 
    // For each derivative a name of the variable and the list of expressions.
    std::vector<std::pair<std::string, std::vector<std::string>>>
        dvalue_expressions;
    for (auto const& dvalue_config : config.getConfigSubtreeList("dvalue"))
    {
        auto variable_name =
            dvalue_config.getConfigParameter<std::string>("variable_name");
 
        auto expressions = parseExpressionList(
            dvalue_config.getConfigSubtreeList("expression"));
 
        dvalue_expressions.emplace_back(std::move(variable_name),
                                        std::move(expressions));
    }
 
    // For each second derivative: two variable names and expression list.
    std::vector<D2ValueConfig> d2value_expressions;
    for (auto const& d2value_config : config.getConfigSubtreeList("d2value"))
    {
        auto variable_names_range =
            d2value_config.getConfigParameterList<std::string>("variable_name");
 
        std::vector<std::string> variable_names(variable_names_range.begin(),
                                                variable_names_range.end());
 
        if (variable_names.size() != 2)
        {
            OGS_FATAL(
                "Function property '{}': each <d2value> block must contain "
                "exactly two <variable_name> entries, but {:d} were given.",
                property_name, variable_names.size());
        }
 
        auto expressions = parseExpressionList(
            d2value_config.getConfigSubtreeList("expression"));
 
        d2value_expressions.emplace_back(std::move(variable_names[0]),
                                         std::move(variable_names[1]),
                                         std::move(expressions));
    }
 
    return std::make_unique<MaterialPropertyLib::Function>(
        std::move(property_name),
        value_expressions,
        dvalue_expressions,
        d2value_expressions,
        curves);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeList(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createGasPressureDependentPermeability()

std::unique_ptr< Property > MaterialPropertyLib::createGasPressureDependentPermeability	(	int const	geometry_dimension,
		BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__GasPressureDependentPermeability__initial_permeability

Input File Parameter

properties__property__GasPressureDependentPermeability__a1

Input File Parameter

properties__property__GasPressureDependentPermeability__a2

Input File Parameter

properties__property__GasPressureDependentPermeability__pressure_threshold

Input File Parameter

properties__property__GasPressureDependentPermeability__minimum_permeability

Input File Parameter

properties__property__GasPressureDependentPermeability__maximum_permeability

Definition at line 18 of file CreateGasPressureDependentPermeability.cpp.

{
    if ((geometry_dimension != 2) && (geometry_dimension != 3))
    {
        OGS_FATAL(
            "The GasPressureDependentPermeability is implemented only for 2D "
            "or 3D problems");
    }

    config.checkConfigParameter("type", "GasPressureDependentPermeability");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create GasPressureDependentPermeability property {:s}.",
         property_name);
 
    std::string const& parameter_name =
        config.getConfigParameter<std::string>("initial_permeability");
    auto const& parameter_k0 = ParameterLib::findParameter<double>(
        parameter_name, parameters, 0, nullptr);
 
    auto const a1 =
        config.getConfigParameter<double>("a1");
    auto const a2 =
        config.getConfigParameter<double>("a2");
    auto const pressure_threshold =
        config.getConfigParameter<double>("pressure_threshold");
    auto const minimum_permeability =
        config.getConfigParameter<double>("minimum_permeability");
    auto const maximum_permeability =
        config.getConfigParameter<double>("maximum_permeability");
 
    if (minimum_permeability > maximum_permeability)
    {
        OGS_FATAL(
            "The value of minimum_permeability of {:e} is larger that the "
            "value of maximum_permeability of {:e} in "
            "GasPressureDependentPermeability",
            minimum_permeability, maximum_permeability);
    }
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<GasPressureDependentPermeability<2>>(
            std::move(property_name), parameter_k0, a1, a2, pressure_threshold,
            minimum_permeability, maximum_permeability,
            local_coordinate_system);
    }
 
    return std::make_unique<GasPressureDependentPermeability<3>>(
        std::move(property_name), parameter_k0, a1, a2, pressure_threshold,
        minimum_permeability, maximum_permeability, local_coordinate_system);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createIdealGasLaw()

std::unique_ptr< IdealGasLaw > MaterialPropertyLib::createIdealGasLaw

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__IdealGasLaw

Definition at line 9 of file CreateIdealGasLaw.cpp.

{
    config.checkConfigParameter("type", "IdealGasLaw");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create IdealGasLaw medium property {:s}.", property_name);
    return std::make_unique<IdealGasLaw>(std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createIdealGasLawBinaryMixture()

std::unique_ptr< IdealGasLawBinaryMixture > MaterialPropertyLib::createIdealGasLawBinaryMixture

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__IdealGasLawBinaryMixture

Definition at line 9 of file CreateIdealGasLawBinaryMixture.cpp.

{
    config.checkConfigParameter("type", "IdealGasLawBinaryMixture");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create IdealGasLawBinaryMixture medium property {:s}.",
         property_name);

    return std::make_unique<IdealGasLawBinaryMixture>(std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createKozenyCarmanModel()

std::unique_ptr< Property > MaterialPropertyLib::createKozenyCarmanModel	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__KozenyCarman__initial_permeability

Input File Parameter

properties__property__KozenyCarman__initial_porosity

Definition at line 12 of file CreateKozenyCarmanModel.cpp.

{
    config.checkConfigParameter("type", "KozenyCarman");
    DBUG("Create Kozeny-Carman model.");
 
    auto const& k0 = ParameterLib::findParameter<double>(
        config.getConfigParameter<std::string>("initial_permeability"),
        parameters, 0, nullptr);
 
    auto const& phi0 = ParameterLib::findParameter<double>(
        config.getConfigParameter<std::string>("initial_porosity"), parameters,
        1, nullptr);
 
    return std::make_unique<KozenyCarmanModel>(k0, phi0);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), and BaseLib::ConfigTree::getConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createLinear()

std::unique_ptr< Linear > MaterialPropertyLib::createLinear

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__Linear__reference_value

Input File Parameter

properties__property__Linear__independent_variable

Input File Parameter

properties__property__Linear__independent_variable__variable_name

Input File Parameter

properties__property__Linear__independent_variable__reference_condition

Input File Parameter

properties__property__Linear__independent_variable__slope

Input File Parameter

properties__property__Linear__independent_variable__min

Input File Parameter

properties__property__Linear__independent_variable__max

Definition at line 11 of file CreateLinear.cpp.

{
    config.checkConfigParameter("type", "Linear");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create Linear property {:s}.", property_name);
    auto const reference_value =
        config.getConfigParameter<double>("reference_value");
 
    std::vector<MaterialPropertyLib::IndependentVariable> ivs;
    for (auto const& independent_variable_config :
         config.getConfigSubtreeList("independent_variable"))
    {
        auto const& variable_name =
            independent_variable_config.getConfigParameter<std::string>(
                "variable_name");
        auto const reference_condition =
            independent_variable_config.getConfigParameter<double>(
                "reference_condition");
        auto const slope =
            independent_variable_config.getConfigParameter<double>("slope");
 
        auto const min =
            independent_variable_config.getConfigParameterOptional<double>(
                "min");
 
        auto const max =
            independent_variable_config.getConfigParameterOptional<double>(
                "max");
 
        static const std::unordered_set<std::string> filter_not_variables = {
            "t", "x", "y", "z"};
        MaterialPropertyLib::StringOrVariable ivt;
        if (!filter_not_variables.contains(variable_name))
        {
            ivt = MaterialPropertyLib::convertStringToVariable(variable_name);
        }
        else
        {
            ivt = variable_name;
        }
 
        MaterialPropertyLib::IndependentVariable iv{ivt, reference_condition,
                                                    slope, min, max};
 
        ivs.push_back(std::move(iv));
    }
 
    return std::make_unique<MaterialPropertyLib::Linear>(
        std::move(property_name), reference_value, ivs);
}

References BaseLib::ConfigTree::checkConfigParameter(), convertStringToVariable(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtreeList(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createLinearSaturationSwellingStress()

std::unique_ptr< Property > MaterialPropertyLib::createLinearSaturationSwellingStress

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__LinearSaturationSwellingStress__coefficient

Input File Parameter

properties__property__LinearSaturationSwellingStress__reference_saturation

Definition at line 12 of file CreateLinearSaturationSwellingStress.cpp.

{
    config.checkConfigParameter("type", "LinearSaturationSwellingStress");

    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create LinearSaturationSwellingStress phase property {:s}.",
         property_name);
 
    auto const coefficient =
        config.getConfigParameter<double>("coefficient");
 
    auto const reference_saturation =
        config.getConfigParameter<double>("reference_saturation");
 
    return std::make_unique<LinearSaturationSwellingStress>(
        property_name, coefficient, reference_saturation);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createLinearWaterVapourLatentHeat()

std::unique_ptr< Property > MaterialPropertyLib::createLinearWaterVapourLatentHeat

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__LinearWaterVapourLatentHeat

Definition at line 12 of file CreateLinearWaterVapourLatentHeat.cpp.

{
    config.checkConfigParameter("type", "LinearWaterVapourLatentHeat");
    DBUG("Create LinearWaterVapourLatentHeat phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<LinearWaterVapourLatentHeat>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createLiquidViscosityVogels()

std::unique_ptr< Property > MaterialPropertyLib::createLiquidViscosityVogels

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__LiquidViscosityVogels__liquid_type

Input File Parameter

properties__property__LiquidViscosityVogels__liquid_type

Input File Parameter

properties__property__LiquidViscosityVogels__liquid_type

Input File Parameter

properties__property__LiquidViscosityVogels__liquid_type

Definition at line 12 of file CreateLiquidViscosityVogels.cpp.

{
    config.checkConfigParameter("type", "LiquidViscosityVogels");
    INFO("Using Vogels model, which gives viscosity in SI unit, Pa s");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    auto const fluid_type =
        config.peekConfigParameter<std::string>("liquid_type");
 
    if (fluid_type == "Water")
    {
        config.checkConfigParameter("liquid_type", "Water");
 
        const VogelsViscosityConstantsWater constants;
        return std::make_unique<
            LiquidViscosityVogels<VogelsViscosityConstantsWater>>(
            std::move(property_name), std::move(constants));
    }
    if (fluid_type == "CO2")
    {
        config.checkConfigParameter("liquid_type", "CO2");
        const VogelsViscosityConstantsCO2 constants;
        return std::make_unique<
            LiquidViscosityVogels<VogelsViscosityConstantsCO2>>(
            std::move(property_name), std::move(constants));
    }
    if (fluid_type == "CH4")
    {
        config.checkConfigParameter("liquid_type", "CH4");
        const VogelsViscosityConstantsCH4 constants;
        return std::make_unique<
            LiquidViscosityVogels<VogelsViscosityConstantsCH4>>(
            std::move(property_name), std::move(constants));
    }
    OGS_FATAL(
        "The fluid type {:s} for Vogels model is unavailable.\n"
        "The available fluid types are Water, CO2 and CH4\n",
        fluid_type.data());
}

References BaseLib::ConfigTree::checkConfigParameter(), INFO(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createMaterialSpatialDistributionMap()

MaterialSpatialDistributionMap MaterialPropertyLib::createMaterialSpatialDistributionMap	(	std::map< int, std::shared_ptr< Medium > > const &	media,
		MeshLib::Mesh const &	mesh )

Definition at line 11 of file CreateMaterialSpatialDistributionMap.cpp.

{
    auto const material_ids = materialIDs(mesh);
 
    int const max_material_id = !material_ids ? 0 : ranges::max(*material_ids);
 
    if (!material_ids && media.size() > 1)
    {
        OGS_FATAL(
            "More than one porous medium definition (namely {}) is present in "
            "the project file, but no MaterialIDs are present in the bulk "
            "mesh.",
            media.size());
    }
 
    if (max_material_id > static_cast<int>(media.size() - 1))
    {
        WARN(
            "The maximum value of MaterialIDs in mesh is {:d}. As the given "
            "number of porous media definitions in the project file is {:d}, "
            "the maximum value of MaterialIDs in mesh must be {:d} (index "
            "starts with zero).",
            max_material_id, media.size(), max_material_id - 1);
    }
 
    if (max_material_id < static_cast<int>(media.size() - 1))
    {
        WARN(
            "There are {:d} porous medium definitions in the project file but "
            "only {:d} different values in the MaterialIDs vector/data_array "
            "in the mesh.",
            media.size(), max_material_id - 1);
    }
    return {media, material_ids};
}

References OGS_FATAL, and WARN().

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HeatConduction::createHeatConductionProcess(), ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess(), ProcessLib::HMPhaseField::createHMPhaseFieldProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LargeDeformation::createLargeDeformationProcess(), ProcessLib::LiquidFlow::createLiquidFlowProcess(), ProcessLib::RichardsComponentTransport::createRichardsComponentTransportProcess(), ProcessLib::RichardsFlow::createRichardsFlowProcess(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess(), ProcessLib::SmallDeformation::createSmallDeformationProcess(), ProcessLib::SteadyStateDiffusion::createSteadyStateDiffusion(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::createThermalTwoPhaseFlowWithPPProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess(), ProcessLib::ThermoRichardsFlow::createThermoRichardsFlowProcess(), ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcessStage2(), ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess(), ProcessLib::createWellboreCompensateNeumannBoundaryCondition(), and ProcessLib::WellboreSimulator::createWellboreSimulatorProcess().

createMedium()

std::unique_ptr< Medium > MaterialPropertyLib::createMedium	(	int const	material_id,
		int const	geometry_dimension,
		BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &	parameters,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

This function parses the "phases" and "properties" subtrees of the config tree and calls create methods for the phase vector and the properties array. Medium properties are optional. If not defined, default properties are assigned.

Input File Parameter

prj__media__medium__phases

Input File Parameter

prj__media__medium__properties

Definition at line 15 of file CreateMedium.cpp.

{
    // Parsing the phases
    // Properties of phases may be not required in all the cases.
    auto&& phases = createPhases(geometry_dimension,
                                 config.getConfigSubtreeOptional("phases"),
                                 parameters, local_coordinate_system, curves);
 
    // Parsing medium properties, overwriting the defaults.
    auto&& properties =
        createProperties(geometry_dimension,
                         config.getConfigSubtreeOptional("properties"),
                         parameters, local_coordinate_system, curves);
 
    if (phases.empty() && !properties)
    {
        OGS_FATAL("Neither tag <phases> nor tag <properties> has been found.");
    }
 
    return std::make_unique<Medium>(material_id, std::move(phases),
                                    std::move(properties));
}

References createPhases(), createProperties(), BaseLib::ConfigTree::getConfigSubtreeOptional(), and OGS_FATAL.

Referenced by ProjectData::parseMedia().

createOrthotropicEmbeddedFracturePermeability()

std::unique_ptr< Property > MaterialPropertyLib::createOrthotropicEmbeddedFracturePermeability	(	int const	geometry_dimension,
		BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__OrthotropicEmbeddedFracturePermeability__mean_frac_distances

Input File Parameter

properties__property__OrthotropicEmbeddedFracturePermeability__threshold_strains

Input File Parameter

properties__property__OrthotropicEmbeddedFracturePermeability__fracture_normals

Input File Parameter

properties__property__OrthotropicEmbeddedFracturePermeability__intrinsic_permeability

Input File Parameter

properties__property__OrthotropicEmbeddedFracturePermeability__fracture_rotation_xy

Input File Parameter

properties__property__OrthotropicEmbeddedFracturePermeability__fracture_rotation_yz

Input File Parameter

properties__property__OrthotropicEmbeddedFracturePermeability__jacobian_factor

Definition at line 12 of file CreateOrthotropicEmbeddedFracturePermeability.cpp.

{
    if ((geometry_dimension != 2) && (geometry_dimension != 3))
    {
        OGS_FATAL(
            "The OrthotropicEmbeddedFracturePermeability is implemented only "
            "for 2D or 3D problems");
    }

    config.checkConfigParameter("type",
                                "OrthotropicEmbeddedFracturePermeability");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create OrthotropicEmbeddedFracturePermeability medium property");
 
    auto const a_i =
        config.getConfigParameter<std::vector<double>>("mean_frac_distances");
    if (a_i.size() != 3)
    {
        OGS_FATAL(
            "The size of the mean fracture distances vector must be 3, but is "
            "{}.",
            a_i.size());
    }
 
    auto const e_i0 =
        config.getConfigParameter<std::vector<double>>("threshold_strains");
    if (e_i0.size() != 3)
    {
        OGS_FATAL(
            "The size of the mean threshold strains vector must be 3, but is "
            "{}.",
            e_i0.size());
    }
 
    auto const n =
        config.getConfigParameter<std::vector<double>>("fracture_normals");
    if (n.size() != 6)
    {
        OGS_FATAL(
            "The size of the fracture normals vector must be 6, but is {}.",
            n.size());
    }
    Eigen::Vector3d const n1 = Eigen::Vector3d({n[0], n[1], n[2]}).normalized();
    Eigen::Vector3d const n2 = Eigen::Vector3d({n[3], n[4], n[5]}).normalized();
 
    if (n1.dot(n2) > std::numeric_limits<double>::epsilon())
    {
        OGS_FATAL(
            "The given fracture normals are not orthogonal. Please provide two "
            "orthogonal fracture normals");
    }
 
    Eigen::Matrix3d const n_i =
        (Eigen::Matrix3d() << n1, n2, n1.cross(n2)).finished();
 
    std::string const intrinsic_permeability_param_name =
        config.getConfigParameter<std::string>("intrinsic_permeability");
 
    auto const& k = ParameterLib::findParameter<double>(
        intrinsic_permeability_param_name, parameters, 0, nullptr);
 
    std::string const fracture_rotation_xy_param_name =
        config.getConfigParameter<std::string>("fracture_rotation_xy");
 
    auto const& phi_xy = ParameterLib::findParameter<double>(
        fracture_rotation_xy_param_name, parameters, 0, nullptr);
 
    std::string const fracture_rotation_yz_param_name =
        config.getConfigParameter<std::string>("fracture_rotation_yz");
 
    auto const& phi_yz = ParameterLib::findParameter<double>(
        fracture_rotation_yz_param_name, parameters, 0, nullptr);
 
    auto const jf =
        config.getConfigParameter<double>("jacobian_factor", 0.);
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<OrthotropicEmbeddedFracturePermeability<2>>(
            std::move(property_name), a_i, e_i0, n_i, k, phi_xy, phi_yz, jf);
    }
    return std::make_unique<OrthotropicEmbeddedFracturePermeability<3>>(
        std::move(property_name), a_i, e_i0, n_i, k, phi_xy, phi_yz, jf);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createParameterProperty()

std::unique_ptr< Parameter > MaterialPropertyLib::createParameterProperty	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__Parameter__parameter_name

Definition at line 13 of file CreateParameter.cpp.

{
    config.checkConfigParameter("type", "Parameter");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create Parameter property {:s}.", property_name);
 
    std::string const& parameter_name =
        config.getConfigParameter<std::string>("parameter_name");
    auto const& parameter = ParameterLib::findParameter<double>(
        parameter_name, parameters, 0, nullptr);
    return std::make_unique<MaterialPropertyLib::Parameter>(
        std::move(property_name), parameter);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createPengRobinson()

std::unique_ptr< Property > MaterialPropertyLib::createPengRobinson

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__PengRobinson__critical_temperature

Input File Parameter

properties__property__PengRobinson__critical_pressure

Input File Parameter

properties__property__PengRobinson__acentric_factor

Definition at line 12 of file CreatePengRobinson.cpp.

{
    config.checkConfigParameter("type", "PengRobinson");
    DBUG("Create PengRobinson EOS.");
 
    auto const Tc =
        config.getConfigParameter<double>("critical_temperature");
 
    auto const pc =
        config.getConfigParameter<double>("critical_pressure");
 
    auto const omega =
        config.getConfigParameter<double>("acentric_factor");
 
    return std::make_unique<PengRobinson>(Tc, pc, omega);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::getConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createPermeabilityMohrCoulombFailureIndexModel()

std::unique_ptr< Property > MaterialPropertyLib::createPermeabilityMohrCoulombFailureIndexModel	(	int const	geometry_dimension,
		BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__PermeabilityMohrCoulombFailureIndexModel__initial_permeability

Input File Parameter

properties__property__PermeabilityMohrCoulombFailureIndexModel__reference_permeability

Input File Parameter

properties__property__PermeabilityMohrCoulombFailureIndexModel__fitting_factor

Input File Parameter

properties__property__PermeabilityMohrCoulombFailureIndexModel__cohesion

Input File Parameter

properties__property__PermeabilityMohrCoulombFailureIndexModel__friction_angle

Input File Parameter

properties__property__PermeabilityMohrCoulombFailureIndexModel__maximum_permeability

Input File Parameter

properties__property__PermeabilityMohrCoulombFailureIndexModel__tensile_strength_parameter

Definition at line 17 of file CreatePermeabilityMohrCoulombFailureIndexModel.cpp.

{
    if ((geometry_dimension != 2) && (geometry_dimension != 3))
    {
        OGS_FATAL(
            "The PermeabilityMohrCoulombFailureIndexModel is implemented only "
            "for 2D or 3D problems");
    }

    config.checkConfigParameter("type",
                                "PermeabilityMohrCoulombFailureIndexModel");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create PermeabilityMohrCoulombFailureIndexModel property {:s}.",
         property_name);
 
    std::string const& parameter_name =
        config.getConfigParameter<std::string>("initial_permeability");
    auto const& parameter_k0 = ParameterLib::findParameter<double>(
        parameter_name, parameters, 0, nullptr);
 
    auto const kr =
        config.getConfigParameter<double>("reference_permeability");
    auto const b =
        config.getConfigParameter<double>("fitting_factor");
    auto const c =
        config.getConfigParameter<double>("cohesion");
    auto const phi =
        config.getConfigParameter<double>("friction_angle");
    auto const max_k =
        config.getConfigParameter<double>("maximum_permeability");
    auto const t_sigma_max =
        config.getConfigParameter<double>("tensile_strength_parameter");
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<PermeabilityMohrCoulombFailureIndexModel<2>>(
            std::move(property_name), parameter_k0, kr, b, c, phi, max_k,
            t_sigma_max, local_coordinate_system);
    }
 
    return std::make_unique<PermeabilityMohrCoulombFailureIndexModel<3>>(
        std::move(property_name), parameter_k0, kr, b, c, phi, max_k,
        t_sigma_max, local_coordinate_system);
}

References c, BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createPermeabilityOrthotropicPowerLaw()

std::unique_ptr< Property > MaterialPropertyLib::createPermeabilityOrthotropicPowerLaw	(	BaseLib::ConfigTree const &	config,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__PermeabilityOrthotropicPowerLaw__intrinsic_permeabilities

Input File Parameter

properties__property__PermeabilityOrthotropicPowerLaw__exponents

Definition at line 10 of file CreatePermeabilityOrthotropicPowerLaw.cpp.

{
    config.checkConfigParameter("type", "PermeabilityOrthotropicPowerLaw");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create PermeabilityOrthotropicPowerLaw solid phase property {:s}.",
         property_name);
 
    auto const intrinsic_permeabilities =
        config.getConfigParameter<std::vector<double>>(
            "intrinsic_permeabilities");
 
    if (intrinsic_permeabilities.size() != 3 &&
        intrinsic_permeabilities.size() != 2)
    {
        OGS_FATAL(
            "The number of intrinsic permeabilities must be two or three, but "
            "{:d} were given.",
            intrinsic_permeabilities.size());
    }
 
    auto const exponents =
        config.getConfigParameter<std::vector<double>>("exponents");
 
    if (exponents.size() != 3 && exponents.size() != 2)
    {
        OGS_FATAL(
            "The number of exponents must be two or three, but {:d} were "
            "given.",
            exponents.size());
    }
 
    if (intrinsic_permeabilities.size() != exponents.size())
    {
        OGS_FATAL(
            "The number of intrinsic permeabilities and exponents must be "
            "equal, but they are {:d} and {:d}, respectively.",
            intrinsic_permeabilities.size(), exponents.size());
    }
 
    if (exponents.size() == 2)
    {
        return std::make_unique<PermeabilityOrthotropicPowerLaw<2>>(
            std::move(property_name),
            std::array<double, 2>{intrinsic_permeabilities[0],
                                  intrinsic_permeabilities[1]},
            std::array<double, 2>{exponents[0], exponents[1]},
            local_coordinate_system);
    }
    if (exponents.size() == 3)
    {
        return std::make_unique<PermeabilityOrthotropicPowerLaw<3>>(
            std::move(property_name),
            std::array<double, 3>{intrinsic_permeabilities[0],
                                  intrinsic_permeabilities[1],
                                  intrinsic_permeabilities[2]},
            std::array<double, 3>{exponents[0], exponents[1], exponents[2]},
            local_coordinate_system);
    }
    OGS_FATAL(
        "Could not create PermeabilityOrthotropicPowerLaw material model.");
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createPhases()

std::vector< std::unique_ptr< Phase > > MaterialPropertyLib::createPhases	(	int const	geometry_dimension,
		std::optional< BaseLib::ConfigTree > const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &	parameters,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

A method that parses the phase details and stores them in the private phases_ member.

This method creates the phases of the medium. Unlike a medium, a phase may have a name. However, this is silly at the moment since this name still has no effect (except of some benefits in regard of readability). Phase components are required (a phase consists of at least one component). Phase properties are optional. If not given, default properties are assigned. These default properties average the component properties, weighted by mole fraction.

Input File Parameter

prj__media__medium__phases__phase

Definition at line 72 of file CreatePhase.cpp.

{
    if (!config)
    {
        return {};
    }
 
    std::vector<std::unique_ptr<Phase>> phases;
 
    for (auto phase_config :
         config->getConfigSubtreeList("phase"))
    {
        auto phase = createPhase(geometry_dimension, phase_config, parameters,
                                 local_coordinate_system, curves);
 
        if (std::find_if(phases.begin(),
                         phases.end(),
                         [phase_type = phase->phaseName](auto const& p)
                         { return p->phaseName == phase_type; }) !=
            phases.end())
        {
            OGS_FATAL("Found duplicates with the same phase name tag '{:s}'.",
                      toString(phase->phaseName));
        }
 
        phases.push_back(std::move(phase));
    }
 
    return phases;
}

References OGS_FATAL, and toString().

Referenced by createMedium().

createPorosityFromMassBalance()

std::unique_ptr< PorosityFromMassBalance > MaterialPropertyLib::createPorosityFromMassBalance	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__PorosityFromMassBalance__initial_porosity

Input File Parameter

properties__property__PorosityFromMassBalance__minimal_porosity

Input File Parameter

properties__property__PorosityFromMassBalance__maximal_porosity

Definition at line 12 of file CreatePorosityFromMassBalance.cpp.

{
    config.checkConfigParameter("type", "PorosityFromMassBalance");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create PorosityFromMassBalance medium property {:s}.", property_name);
 
    std::string const& parameter_name =
        config.getConfigParameter<std::string>("initial_porosity");
    auto const& initial_porosity = ParameterLib::findParameter<double>(
        parameter_name, parameters, 0, nullptr);

    auto const& phi_min = config.getConfigParameter<double>("minimal_porosity");

    auto const& phi_max = config.getConfigParameter<double>("maximal_porosity");
 
    return std::make_unique<PorosityFromMassBalance>(
        std::move(property_name), initial_porosity, phi_min, phi_max);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createProperties()

std::unique_ptr< PropertyArray > MaterialPropertyLib::createProperties	(	int const	geometry_dimension,
		std::optional< BaseLib::ConfigTree > const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &	parameters,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

The method reads the 'properties' tag in the prj-file and creates component properties accordingly.

First, a new property iy created based on the specified property type. Then, the property name is evaluated and the property is copied into the properties array.

Input File Parameter

properties__property

Input File Parameter

properties__property__name

Definition at line 390 of file CreateProperty.cpp.

{
    if (!config)
    {
        return nullptr;
    }

    auto const& property_configs = config->getConfigSubtreeList("property");
    if (property_configs.empty())
    {
        return nullptr;
    }
 
    auto properties = std::make_unique<PropertyArray>();
 
    for (auto property_config : property_configs)
    {
        // Parsing the property name:
        auto const property_name =
            property_config.getConfigParameter<std::string>("name");
        // Create a new property based on the configuration subtree:
        auto property =
            createProperty(geometry_dimension, property_config, parameters,
                           local_coordinate_system, curves);
 
        // Insert the new property at the right position into the components
        // private PropertyArray:
        (*properties)[convertStringToProperty(property_name)] =
            std::move(property);
    }
    return properties;
}

References convertStringToProperty().

Referenced by anonymous_namespace{CreateComponent.cpp}::createComponent(), createMedium(), and anonymous_namespace{CreatePhase.cpp}::createPhase().

createRelPermBrooksCorey()

std::unique_ptr< RelPermBrooksCorey > MaterialPropertyLib::createRelPermBrooksCorey

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelPermBrooksCorey__residual_liquid_saturation

Input File Parameter

properties__property__RelPermBrooksCorey__residual_gas_saturation

Input File Parameter

properties__property__RelPermBrooksCorey__min_relative_permeability

Input File Parameter

properties__property__RelPermBrooksCorey__lambda

Definition at line 9 of file CreateRelPermBrooksCorey.cpp.

{
    config.checkConfigParameter("type", "RelPermBrooksCorey");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create RelPermBrooksCorey medium property {:s}.", property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const min_relative_permeability =
        config.getConfigParameter<double>("min_relative_permeability");
    auto const exponent =
        config.getConfigParameter<double>("lambda");
 
    // Parameter ranges are validated in the RelPermBrooksCorey constructor.
    return std::make_unique<RelPermBrooksCorey>(std::move(property_name),
                                                residual_liquid_saturation,
                                                residual_gas_saturation,
                                                min_relative_permeability,
                                                exponent);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createRelPermBrooksCoreyNonwettingPhase()

std::unique_ptr< RelPermBrooksCoreyNonwettingPhase > MaterialPropertyLib::createRelPermBrooksCoreyNonwettingPhase

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelPermBrooksCoreyNonwettingPhase__residual_liquid_saturation

Input File Parameter

properties__property__RelPermBrooksCoreyNonwettingPhase__residual_gas_saturation

Input File Parameter

properties__property__RelPermBrooksCoreyNonwettingPhase__min_relative_permeability

Input File Parameter

properties__property__RelPermBrooksCoreyNonwettingPhase__lambda

Definition at line 12 of file CreateRelPermBrooksCoreyNonwettingPhase.cpp.

{
    config.checkConfigParameter("type", "RelPermBrooksCoreyNonwettingPhase");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create RelPermBrooksCoreyNonwettingPhase medium property {:s}.",
         property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const min_relative_permeability =
        config.getConfigParameter<double>("min_relative_permeability");
    auto const exponent =
        config.getConfigParameter<double>("lambda");
 
    // Parameter ranges are validated in the
    // RelPermBrooksCoreyNonwettingPhase constructor.
    return std::make_unique<RelPermBrooksCoreyNonwettingPhase>(
        std::move(property_name),
        residual_liquid_saturation,
        residual_gas_saturation,
        min_relative_permeability,
        exponent);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createRelPermGeneralizedPower()

std::unique_ptr< RelPermGeneralizedPower > MaterialPropertyLib::createRelPermGeneralizedPower

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPower__residual_liquid_saturation

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPower__residual_gas_saturation

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPower__min_relative_permeability

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPower__enhancement_factor

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPower__exponent

Definition at line 9 of file CreateRelPermGeneralizedPower.cpp.

{
    config.checkConfigParameter("type", "RelativePermeabilityGeneralizedPower");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create RelPermGeneralizedPower medium property {:s}.", property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const min_relative_permeability =
        config.getConfigParameter<double>("min_relative_permeability");
    double const a =
        config.getConfigParameter<double>("enhancement_factor", 1);
    double const lambda =
        config.getConfigParameter<double>("exponent", 1);
 
    if (min_relative_permeability < 0)
    {
        OGS_FATAL("Minimal relative permeability must be non-negative.");
    }
 
    return std::make_unique<RelPermGeneralizedPower>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, min_relative_permeability, a, lambda);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createRelPermGeneralizedPowerNonwettingPhase()

std::unique_ptr< RelPermGeneralizedPowerNonwettingPhase > MaterialPropertyLib::createRelPermGeneralizedPowerNonwettingPhase

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPowerNonwettingPhase__residual_liquid_saturation

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPowerNonwettingPhase__residual_gas_saturation

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPowerNonwettingPhase__min_relative_permeability

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPowerNonwettingPhase__enhancement_factor

Input File Parameter

properties__property__RelativePermeabilityGeneralizedPowerNonwettingPhase__exponent

Definition at line 10 of file CreateRelPermGeneralizedPowerNonwettingPhase.cpp.

{
    config.checkConfigParameter(
        "type", "RelativePermeabilityGeneralizedPowerNonwettingPhase");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create RelPermGeneralizedPowerNonwettingPhase medium property {:s}.",
         property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const min_relative_permeability =
        config.getConfigParameter<double>("min_relative_permeability");
    double const a =
        config.getConfigParameter<double>("enhancement_factor", 1000);
    double const lambda =
        config.getConfigParameter<double>("exponent", 0.8);
 
    if (min_relative_permeability < 0)
    {
        OGS_FATAL("Minimal relative permeability must be non-negative.");
    }
 
    return std::make_unique<RelPermGeneralizedPowerNonwettingPhase>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, min_relative_permeability, a, lambda);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createRelPermLiakopoulos()

std::unique_ptr< RelPermLiakopoulos > MaterialPropertyLib::createRelPermLiakopoulos

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelPermLiakopoulos

Definition at line 9 of file CreateRelPermLiakopoulos.cpp.

{
    config.checkConfigParameter("type", "RelPermLiakopoulos");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create RelPermLiakopoulos medium property {:s}.", property_name);

    return std::make_unique<RelPermLiakopoulos>(std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createRelPermNonWettingPhaseVanGenuchtenMualem()

std::unique_ptr< Property > MaterialPropertyLib::createRelPermNonWettingPhaseVanGenuchtenMualem

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelativePermeabilityNonWettingPhaseVanGenuchtenMualem__residual_liquid_saturation

Input File Parameter

properties__property__RelativePermeabilityNonWettingPhaseVanGenuchtenMualem__residual_gas_saturation

Input File Parameter

properties__property__RelativePermeabilityNonWettingPhaseVanGenuchtenMualem__exponent

Input File Parameter

properties__property__RelativePermeabilityNonWettingPhaseVanGenuchtenMualem__min_relative_permeability

Input File Parameter

properties__property__RelativePermeabilityNonWettingPhaseVanGenuchtenMualem__enhancement_factor

Definition at line 12 of file CreateRelPermNonWettingPhaseVanGenuchtenMualem.cpp.

{
    config.checkConfigParameter(
        "type", "RelativePermeabilityNonWettingPhaseVanGenuchtenMualem");
    DBUG("Create RelPermNonWettingPhaseVanGenuchtenMualem medium property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
 
    auto const exponent =
        config.getConfigParameter<double>("exponent");
 
    auto const min_relative_permeability =
        config.getConfigParameter<double>("min_relative_permeability");
    double const a =
        config.getConfigParameter<double>("enhancement_factor", 1.0);
 
    if (min_relative_permeability <= 0.0 || min_relative_permeability > 1.0)
    {
        OGS_FATAL(
            "The value for min_relative_permeability of "
            "RelativePermeabilityNonWettingPhaseVanGenuchtenMualem is {:g}, "
            "which falls outside of the range of (0, 1]",
            min_relative_permeability);
    }
    if (a < 0 || !std::isfinite(a))
    {
        OGS_FATAL(
            "The value of the enhancement_factor for the nonwetting relative "
            "permeability must be non-negative and finite."
            "The value is {:g}, which is out of bounds.",
            a);
    }
 
    return std::make_unique<RelPermNonWettingPhaseVanGenuchtenMualem>(
        property_name, residual_liquid_saturation, residual_gas_saturation,
        exponent, min_relative_permeability, a);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createRelPermUdell()

std::unique_ptr< RelPermUdell > MaterialPropertyLib::createRelPermUdell

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelativePermeabilityUdell__residual_liquid_saturation

Input File Parameter

properties__property__RelativePermeabilityUdell__residual_gas_saturation

Input File Parameter

properties__property__RelativePermeabilityUdell__min_relative_permeability

Definition at line 9 of file CreateRelPermUdell.cpp.

{
    config.checkConfigParameter("type", "RelativePermeabilityUdell");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create RelPermUdell medium property {:s}.", property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const min_relative_permeability =
        config.getConfigParameter<double>("min_relative_permeability");
 
    if (min_relative_permeability < 0)
    {
        OGS_FATAL("Minimal relative permeability must be non-negative.");
    }
 
    return std::make_unique<RelPermUdell>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, min_relative_permeability);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createRelPermUdellNonwettingPhase()

std::unique_ptr< RelPermUdellNonwettingPhase > MaterialPropertyLib::createRelPermUdellNonwettingPhase

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelativePermeabilityUdellNonwettingPhase__residual_liquid_saturation

Input File Parameter

properties__property__RelativePermeabilityUdellNonwettingPhase__residual_gas_saturation

Input File Parameter

properties__property__RelativePermeabilityUdellNonwettingPhase__min_relative_permeability

Definition at line 9 of file CreateRelPermUdellNonwettingPhase.cpp.

{
    config.checkConfigParameter("type",
                                "RelativePermeabilityUdellNonwettingPhase");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create RelPermUdellNonwettingPhase medium property {:s}.",
         property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const min_relative_permeability =
        config.getConfigParameter<double>("min_relative_permeability");
 
    if (min_relative_permeability < 0)
    {
        OGS_FATAL("Minimal relative permeability must be non-negative.");
    }
 
    return std::make_unique<RelPermUdellNonwettingPhase>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, min_relative_permeability);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createRelPermVanGenuchten()

std::unique_ptr< RelPermVanGenuchten > MaterialPropertyLib::createRelPermVanGenuchten

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__RelativePermeabilityVanGenuchten__residual_liquid_saturation

Input File Parameter

properties__property__RelativePermeabilityVanGenuchten__residual_gas_saturation

Input File Parameter

properties__property__RelativePermeabilityVanGenuchten__minimum_relative_permeability_liquid

Input File Parameter

properties__property__RelativePermeabilityVanGenuchten__exponent

Definition at line 9 of file CreateRelPermVanGenuchten.cpp.

{
    config.checkConfigParameter("type", "RelativePermeabilityVanGenuchten");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create RelativePermeabilityVanGenuchten medium property {:s}.",
         property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const min_relative_permeability_liquid =
        config.getConfigParameter<double>(
            "minimum_relative_permeability_liquid");
    auto const exponent =
        config.getConfigParameter<double>("exponent");
    if (exponent <= 0. || exponent >= 1.)
    {
        OGS_FATAL("Exponent must be in the (0, 1) range.");
    }
 
    return std::make_unique<RelPermVanGenuchten>(
        std::move(property_name),
        residual_liquid_saturation,
        residual_gas_saturation,
        min_relative_permeability_liquid,
        exponent);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSaturationBrooksCorey()

std::unique_ptr< SaturationBrooksCorey > MaterialPropertyLib::createSaturationBrooksCorey

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SaturationBrooksCorey__residual_liquid_saturation

Input File Parameter

properties__property__SaturationBrooksCorey__residual_gas_saturation

Input File Parameter

properties__property__SaturationBrooksCorey__lambda

Input File Parameter

properties__property__SaturationBrooksCorey__entry_pressure

Definition at line 9 of file CreateSaturationBrooksCorey.cpp.

{
    config.checkConfigParameter("type", "SaturationBrooksCorey");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create SaturationBrooksCorey medium property {:s}.", property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const exponent =
        config.getConfigParameter<double>("lambda");
    auto const entry_pressure =
        config.getConfigParameter<double>("entry_pressure");
 
    return std::make_unique<SaturationBrooksCorey>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, exponent, entry_pressure);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), entry_pressure, BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSaturationDependentSwelling()

std::unique_ptr< SaturationDependentSwelling > MaterialPropertyLib::createSaturationDependentSwelling	(	BaseLib::ConfigTree const &	config,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SaturationDependentSwelling__swelling_pressures

Input File Parameter

properties__property__SaturationDependentSwelling__exponents

Input File Parameter

properties__property__SaturationDependentSwelling__lower_saturation_limit

Input File Parameter

properties__property__SaturationDependentSwelling__upper_saturation_limit

Definition at line 10 of file CreateSaturationDependentSwelling.cpp.

{
    config.checkConfigParameter("type", "SaturationDependentSwelling");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create SaturationDependentSwelling solid phase property {:s}.",
         property_name);
 
    auto const swelling_pressures =
        config.getConfigParameter<std::vector<double>>("swelling_pressures");
 
    if (swelling_pressures.size() != 3)
    {
        OGS_FATAL(
            "The number of swelling pressures must be three, but {:d} were "
            "given.",
            swelling_pressures.size());
    }
 
    auto const exponents =
        config.getConfigParameter<std::vector<double>>("exponents");
 
    if (exponents.size() != 3)
    {
        OGS_FATAL("The number of exponents must be three, but {:d} were given.",
                  exponents.size());
    }
 
    if (swelling_pressures.size() != exponents.size())
    {
        OGS_FATAL(
            "The number of swelling pressures and exponents must be equal, but "
            "they are {:d} and {:d}, respectively.",
            swelling_pressures.size(), exponents.size());
    }
 
    auto const lower_saturation_limit =
        config.getConfigParameter<double>("lower_saturation_limit");
 
    auto const upper_saturation_limit =
        config.getConfigParameter<double>("upper_saturation_limit");
 
    return std::make_unique<SaturationDependentSwelling>(
        std::move(property_name),
        std::array<double, 3>{swelling_pressures[0], swelling_pressures[1],
                              swelling_pressures[2]},
        std::array<double, 3>{exponents[0], exponents[1], exponents[2]},
        lower_saturation_limit, upper_saturation_limit,
        local_coordinate_system);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSaturationDependentThermalConductivity()

std::unique_ptr< Property > MaterialPropertyLib::createSaturationDependentThermalConductivity

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Definition at line 8 of file CreateSaturationDependentThermalConductivity.cpp.

{
    config.checkConfigParameter("type",
                                "SaturationDependentThermalConductivity");
 
    OGS_FATAL(
        "The MPL property SaturationDependentThermalConductivity is "
        "deprecated. Please use SaturationWeightedThermalConductivity "
        "instead.");
}

References BaseLib::ConfigTree::checkConfigParameter(), and OGS_FATAL.

createSaturationExponential()

std::unique_ptr< SaturationExponential > MaterialPropertyLib::createSaturationExponential

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SaturationExponential__residual_liquid_saturation

Input File Parameter

properties__property__SaturationExponential__residual_gas_saturation

Input File Parameter

properties__property__SaturationExponential__maximum_capillary_pressure

Input File Parameter

properties__property__SaturationExponential__exponent

Definition at line 9 of file CreateSaturationExponential.cpp.

{
    config.checkConfigParameter("type", "SaturationExponential");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create SaturationExponential medium property {:s}.", property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const p_cap_max =
        config.getConfigParameter<double>("maximum_capillary_pressure");
    auto const exponent =
        config.getConfigParameter<double>("exponent");
 
    return std::make_unique<SaturationExponential>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, p_cap_max, exponent);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSaturationLiakopoulos()

std::unique_ptr< SaturationLiakopoulos > MaterialPropertyLib::createSaturationLiakopoulos

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SaturationLiakopoulos

Definition at line 9 of file CreateSaturationLiakopoulos.cpp.

{
    config.checkConfigParameter("type", "SaturationLiakopoulos");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create SaturationLiakopoulos medium property {:s}.", property_name);

    return std::make_unique<SaturationLiakopoulos>(std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSaturationLuMcCartney()

std::unique_ptr< SaturationLuMcCartney > MaterialPropertyLib::createSaturationLuMcCartney

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SaturationLuMcCartney__material

Definition at line 8 of file CreateSaturationLuMcCartney.cpp.

{
    config.checkConfigParameter("type", "SaturationLuMcCartney");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create SaturationLuMcCartney medium property {:s}.", property_name);
 
    auto const material =
        config.getConfigParameter<std::string>("material");
 
    return std::make_unique<SaturationLuMcCartney>(std::move(property_name),
                                                   material);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSaturationVanGenuchten()

std::unique_ptr< SaturationVanGenuchten > MaterialPropertyLib::createSaturationVanGenuchten

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SaturationVanGenuchten__residual_liquid_saturation

Input File Parameter

properties__property__SaturationVanGenuchten__residual_gas_saturation

Input File Parameter

properties__property__SaturationVanGenuchten__exponent

Input File Parameter

properties__property__SaturationVanGenuchten__pressure_exponent

Input File Parameter

properties__property__SaturationVanGenuchten__saturation_exponent

Input File Parameter

properties__property__SaturationVanGenuchten__p_b

Definition at line 9 of file CreateSaturationVanGenuchten.cpp.

{
    config.checkConfigParameter("type", "SaturationVanGenuchten");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create SaturationVanGenuchten medium property {:s}.", property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
 
    double pressure_exponent;
    double saturation_exponent;
    if (auto const optional_exponent =
        config.getConfigParameterOptional<double>("exponent"))
    {
        pressure_exponent = *optional_exponent;
        saturation_exponent = 1.0 / (1.0 - pressure_exponent);
    }
    else
    {
        pressure_exponent =
            config.getConfigParameter<double>("pressure_exponent");
        saturation_exponent =
            config.getConfigParameter<double>("saturation_exponent");
    }

    auto const p_b = config.getConfigParameter<double>("p_b");
 
    return std::make_unique<SaturationVanGenuchten>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, pressure_exponent, saturation_exponent, p_b);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSaturationVanGenuchtenWithVolumetricStrain()

std::unique_ptr< SaturationVanGenuchtenWithVolumetricStrain > MaterialPropertyLib::createSaturationVanGenuchtenWithVolumetricStrain

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SaturationVanGenuchtenWithVolumetricStrain__residual_liquid_saturation

Input File Parameter

properties__property__SaturationVanGenuchtenWithVolumetricStrain__residual_gas_saturation

Input File Parameter

properties__property__SaturationVanGenuchtenWithVolumetricStrain__exponent

Input File Parameter

properties__property__SaturationVanGenuchtenWithVolumetricStrain__p_b

Input File Parameter

properties__property__SaturationVanGenuchtenWithVolumetricStrain__e_0

Input File Parameter

properties__property__SaturationVanGenuchtenWithVolumetricStrain__e_m

Input File Parameter

properties__property__SaturationVanGenuchtenWithVolumetricStrain__a

Input File Parameter

properties__property__SaturationVanGenuchtenWithVolumetricStrain__d_diff

Definition at line 10 of file CreateSaturationVanGenuchtenWithVolumetricStrain.cpp.

{
    config.checkConfigParameter("type",
                                "SaturationVanGenuchtenWithVolumetricStrain");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG(
        "Create SaturationVanGenuchtenWithVolumetricStrain medium property "
        "{:s}.",
        property_name);
 
    auto const residual_liquid_saturation =
        config.getConfigParameter<double>("residual_liquid_saturation");
    auto const residual_gas_saturation =
        config.getConfigParameter<double>("residual_gas_saturation");
    auto const exponent =
        config.getConfigParameter<double>("exponent");
    auto const p_b = config.getConfigParameter<double>("p_b");
    auto const e_0 =
        config.getConfigParameter<double>("e_0");
    auto const e_m =
        config.getConfigParameter<double>("e_m");
    auto const a =
        config.getConfigParameter<double>("a");
    auto const d_diff =
        config.getConfigParameter<double>("d_diff");
 
    return std::make_unique<SaturationVanGenuchtenWithVolumetricStrain>(
        std::move(property_name), residual_liquid_saturation,
        residual_gas_saturation, exponent, p_b, e_0, e_m, a, d_diff);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::peekConfigParameter(), residual_gas_saturation, and residual_liquid_saturation.

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSaturationWeightedThermalConductivity()

std::unique_ptr< Property > MaterialPropertyLib::createSaturationWeightedThermalConductivity	(	int const	geometry_dimension,
		BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SaturationWeightedThermalConductivity__dry_thermal_conductivity

Input File Parameter

properties__property__SaturationWeightedThermalConductivity__wet_thermal_conductivity

Input File Parameter

properties__property__SaturationWeightedThermalConductivity__dry_thermal_conductivity

Input File Parameter

properties__property__SaturationWeightedThermalConductivity__wet_thermal_conductivity

Input File Parameter

properties__property__SaturationWeightedThermalConductivity__mean_type

Definition at line 34 of file CreateSaturationWeightedThermalConductivity.cpp.

{
    config.checkConfigParameter("type",
                                "SaturationWeightedThermalConductivity");

    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create SaturationWeightedThermalConductivity medium property");
 
    std::string const& dry_thermal_conductivity_parameter_or_value =
        config.getConfigParameter<std::string>("dry_thermal_conductivity");
 
    std::string const& wet_thermal_conductivity_parameter_or_value =
        config.getConfigParameter<std::string>("wet_thermal_conductivity");
 
    auto& dry_thermal_conductivity =
        ParameterLib::getNamedOrCreateInlineParameter(
            dry_thermal_conductivity_parameter_or_value, parameters,
            property_name, "dry_inline");
 
    auto& wet_thermal_conductivity =
        ParameterLib::getNamedOrCreateInlineParameter(
            wet_thermal_conductivity_parameter_or_value, parameters,
            property_name, "wet_inline");
 
    std::string const& mean_type_str =
        config.getConfigParameter<std::string>("mean_type");
 
    const std::map<std::string, MeanType> mean_type_map{
        {"arithmetic_linear", MeanType::ARITHMETIC_LINEAR},
        {"arithmetic_squareroot", MeanType::ARITHMETIC_SQUAREROOT},
        {"geometric", MeanType::GEOMETRIC}};
    MeanType const& mean_type = BaseLib::getOrError(
        mean_type_map, mean_type_str,
        "Specified mean type for the thermal conductivity could not be found.");
 
    std::map<
        std::pair<MeanType, int>,
        std::unique_ptr<Property> (*)(
            std::string /*name*/,
            ParameterLib::Parameter<double> const& /*dry_thermal_conductivity*/,
            ParameterLib::Parameter<
                double> const& /*wet_thermal_conductivity*/)>
        map_dim_and_mean_to_creator;
 
    // initialize the map
    {
        using namespace boost::mp11;
        using Dims = mp_list<mp_int<1>, mp_int<2>, mp_int<3>>;
        using Means = mp_list<
            std::integral_constant<MeanType, MeanType::ARITHMETIC_LINEAR>,
            std::integral_constant<MeanType, MeanType::ARITHMETIC_SQUAREROOT>,
            std::integral_constant<MeanType, MeanType::GEOMETRIC>>;
        using DimsAndMeanTypes =
            mp_product<mp_list, Dims,
                       Means>;  // Cartesian product of Dims and Means.
 
        mp_for_each<DimsAndMeanTypes>(
            [&map_dim_and_mean_to_creator]<typename Dim, typename Mean>(
                mp_list<Dim, Mean>)
            {
                map_dim_and_mean_to_creator.emplace(
                    std::pair{Mean::value, Dim::value},
                    &::createSaturationWeightedThermalConductivity<Mean::value,
                                                                   Dim::value>);
            });
    }
 
    auto const it = map_dim_and_mean_to_creator.find(
        std::pair{mean_type, geometry_dimension});
 
    if (it == map_dim_and_mean_to_creator.end())
    {
        OGS_FATAL(
            "Cannot create a SaturationWeightedThermalConductivity model for "
            "dimension {} and mean type {}",
            geometry_dimension, mean_type_str);
    }
 
    auto* creator = it->second;
    return creator(std::move(property_name),
                   dry_thermal_conductivity,
                   wet_thermal_conductivity);
}

References ARITHMETIC_LINEAR, ARITHMETIC_SQUAREROOT, BaseLib::ConfigTree::checkConfigParameter(), createSaturationWeightedThermalConductivity(), DBUG(), GEOMETRIC, BaseLib::ConfigTree::getConfigParameter(), ParameterLib::getNamedOrCreateInlineParameter(), BaseLib::getOrError(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty(), and createSaturationWeightedThermalConductivity().

createSigmoid()

std::unique_ptr< Sigmoid > MaterialPropertyLib::createSigmoid

(

BaseLib::ConfigTree const &

config

)

Create a Sigmoid property from XML configuration.

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__Sigmoid__steepness

Input File Parameter

properties__property__Sigmoid__midpoint

Input File Parameter

properties__property__Sigmoid__lower_bound

Input File Parameter

properties__property__Sigmoid__upper_bound

Input File Parameter

properties__property__Sigmoid__independent_variable

Definition at line 13 of file CreateSigmoid.cpp.

{
    config.checkConfigParameter("type", "Sigmoid");

    auto const name = config.peekConfigParameter<std::string>("name");
    DBUG("Create sigmoid property '{:s}'.", name);
 
    auto const steepness =
        config.getConfigParameter<double>("steepness");
 
    auto const midpoint =
        config.getConfigParameter<double>("midpoint");
 
    auto const lower_bound =
        config.getConfigParameter<double>("lower_bound");
 
    auto const upper_bound =
        config.getConfigParameter<double>("upper_bound");
 
    // Parse independent variable
    auto const independent_variable_str =
        config.getConfigParameter<std::string>("independent_variable");
 
    // Spatial/temporal coordinates not yet supported; would need to
    // reintroduce a SpatialTemporalVariable and dispatch in value().
    if (std::ranges::any_of(std::array{"t", "x", "y", "z"},
                            [&](const char* v)
                            { return independent_variable_str == v; }))
 
    {
        OGS_FATAL(
            "In the sigmoid property '{:s}', the spatial/temporal independent "
            "variable '{:s}' is not supported yet. Use a material variable "
            "instead. See CreateSigmoid.cpp for how to re-enable "
            "spatial/temporal independent variables.",
            name, independent_variable_str);
    }
 
    auto const independent_variable =
        convertStringToVariable(independent_variable_str);
 
    return std::make_unique<Sigmoid>(name, steepness, midpoint, lower_bound,
                                     upper_bound, independent_variable);
}

References BaseLib::ConfigTree::checkConfigParameter(), convertStringToVariable(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), name, OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSoilThermalConductivitySomerton()

std::unique_ptr< Property > MaterialPropertyLib::createSoilThermalConductivitySomerton

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Definition at line 11 of file CreateSoilThermalConductivitySomerton.cpp.

{
    config.checkConfigParameter("type", "SoilThermalConductivitySomerton");
 
    OGS_FATAL(
        "The MPL property SoilThermalConductivitySomerton is "
        "deprecated. Please use SaturationWeightedThermalConductivity "
        "instead.");
}

References BaseLib::ConfigTree::checkConfigParameter(), and OGS_FATAL.

createSpecificHeatCapacityWithLatentHeat()

std::unique_ptr< SpecificHeatCapacityWithLatentHeat > MaterialPropertyLib::createSpecificHeatCapacityWithLatentHeat

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__SpecificHeatCapacityWithLatentHeat__specific_latent_heat

Definition at line 13 of file CreateSpecificHeatCapacityWithLatentHeat.cpp.

{
    config.checkConfigParameter("type", "SpecificHeatCapacityWithLatentHeat");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create temperature dependent specific heat capacity {:s}.",
         property_name);
 
    auto const l =
        config.getConfigParameter<double>("specific_latent_heat");
 
    return std::make_unique<
        MaterialPropertyLib::SpecificHeatCapacityWithLatentHeat>(
        std::move(property_name), l);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createStrainDependentPermeability()

std::unique_ptr< Property > MaterialPropertyLib::createStrainDependentPermeability	(	int const	geometry_dimension,
		BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		ParameterLib::CoordinateSystem const *const	local_coordinate_system )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__StrainDependentPermeability__initial_permeability

Input File Parameter

properties__property__StrainDependentPermeability__b1

Input File Parameter

properties__property__StrainDependentPermeability__b2

Input File Parameter

properties__property__StrainDependentPermeability__b3

Input File Parameter

properties__property__StrainDependentPermeability__minimum_permeability

Input File Parameter

properties__property__StrainDependentPermeability__maximum_permeability

Definition at line 18 of file CreateStrainDependentPermeability.cpp.

{
    if ((geometry_dimension != 2) && (geometry_dimension != 3))
    {
        OGS_FATAL(
            "The StrainDependentPermeability is implemented only for 2D or 3D "
            "problems");
    }

    config.checkConfigParameter("type", "StrainDependentPermeability");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create StrainDependentPermeability property {:s}.", property_name);
 
    std::string const& parameter_name =
        config.getConfigParameter<std::string>("initial_permeability");
    auto const& parameter_k0 = ParameterLib::findParameter<double>(
        parameter_name, parameters, 0, nullptr);
 
    auto const b1 =
        config.getConfigParameter<double>("b1");
    auto const b2 =
        config.getConfigParameter<double>("b2");
    auto const b3 =
        config.getConfigParameter<double>("b3");
    auto const minimum_permeability =
        config.getConfigParameter<double>("minimum_permeability");
    auto const maximum_permeability =
        config.getConfigParameter<double>("maximum_permeability");
 
    if (minimum_permeability > maximum_permeability)
    {
        OGS_FATAL(
            "The value of minimum_permeability of {:e} is larger that the "
            "value of maximum_permeability of {:e} in "
            "StrainDependentPermeability",
            minimum_permeability, maximum_permeability);
    }
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<StrainDependentPermeability<2>>(
            std::move(property_name), parameter_k0, b1, b2, b3,
            minimum_permeability, maximum_permeability,
            local_coordinate_system);
    }
 
    return std::make_unique<StrainDependentPermeability<3>>(
        std::move(property_name), parameter_k0, b1, b2, b3,
        minimum_permeability, maximum_permeability, local_coordinate_system);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createSymbolTable()

template<int D>

exprtk::symbol_table< double > MaterialPropertyLib::createSymbolTable ( std::vector< std::string > const & expression_symbol_names, bool const spatial_position_is_required, std::vector< std::string > const & used_curve_names, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const & curves, VariableArray & variable_array, std::map< std::string, ParameterLib::CurveWrapper > & curve_wrappers )

static

Creates a symbol table for one MPL Function thread, registering standard variables (t, x, y, z), VariableArray fields, and curve wrappers. variable_array and curve_wrappers are members of the owning PerThreadData and must already be at their final address.

Definition at line 66 of file Function.cpp.

{
    auto symbol_table =
        ParameterLib::createBaseSymbolTable(spatial_position_is_required);
 
    std::unordered_set<std::string> curve_name_set(used_curve_names.begin(),
                                                   used_curve_names.end());
 
    for (auto const& v : expression_symbol_names)
    {
        if (ParameterLib::isBuiltinSymbol(v) || curve_name_set.contains(v))
        {
            continue;
        }
 
        auto add_scalar = [&v, &symbol_table](double& value)
        { symbol_table.add_variable(v, value); };
 
        auto add_vector =
            [&v, &symbol_table](double* ptr, std::size_t const size)
        { symbol_table.add_vector(v, ptr, size); };
 
        auto add_any_variable = BaseLib::Overloaded{
            [&add_scalar](VariableArray::Scalar* address)
            { add_scalar(*address); },
            [&add_vector](VariableArray::KelvinVector* address)
            {
                auto constexpr size =
                    MathLib::KelvinVector::kelvin_vector_dimensions(D);
                auto& result =
                    address->template emplace<Eigen::Matrix<double, size, 1>>();
                add_vector(result.data(), size);
            },
            [&add_vector](VariableArray::DeformationGradient* address)
            {
                auto constexpr size = MathLib::VectorizedTensor::size(D);
                auto& result =
                    address->template emplace<Eigen::Matrix<double, size, 1>>();
                add_vector(result.data(), size);
            }};
 
        Variable const variable = convertStringToVariable(v);
        variable_array.visitVariable(add_any_variable, variable);
    }
 
    ParameterLib::registerCurveWrappers(symbol_table, used_curve_names, curves,
                                        curve_wrappers);
    return symbol_table;
}

References convertStringToVariable(), ParameterLib::createBaseSymbolTable(), ParameterLib::isBuiltinSymbol(), MathLib::KelvinVector::kelvin_vector_dimensions(), ParameterLib::registerCurveWrappers(), MathLib::VectorizedTensor::size(), and MaterialPropertyLib::VariableArray::visitVariable().

Referenced by MaterialPropertyLib::PerThreadData::PerThreadData().

createTemperatureDependentDiffusion()

std::unique_ptr< Property > MaterialPropertyLib::createTemperatureDependentDiffusion	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__TemperatureDependentDiffusion__reference_diffusion

Input File Parameter

properties__property__TemperatureDependentDiffusion__activation_energy

Input File Parameter

properties__property__TemperatureDependentDiffusion__reference_temperature

Definition at line 10 of file CreateTemperatureDependentDiffusion.cpp.

{
    config.checkConfigParameter("type", "TemperatureDependentDiffusion");
 
    auto const& D0 = ParameterLib::findParameter<double>(
        config.getConfigParameter<std::string>("reference_diffusion"),
        parameters, 0, nullptr);
 
    auto const Ea =
        config.getConfigParameter<double>("activation_energy");
 
    auto const T0 =
        config.getConfigParameter<double>("reference_temperature");
 
    return std::make_unique<TemperatureDependentDiffusion>(D0, Ea, T0);
}

References BaseLib::ConfigTree::checkConfigParameter(), ParameterLib::findParameter(), and BaseLib::ConfigTree::getConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createTransportPorosityFromMassBalance()

std::unique_ptr< TransportPorosityFromMassBalance > MaterialPropertyLib::createTransportPorosityFromMassBalance	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__TransportPorosityFromMassBalance__initial_porosity

Input File Parameter

properties__property__TransportPorosityFromMassBalance__minimal_porosity

Input File Parameter

properties__property__TransportPorosityFromMassBalance__maximal_porosity

Definition at line 13 of file CreateTransportPorosityFromMassBalance.cpp.

{
    config.checkConfigParameter("type", "TransportPorosityFromMassBalance");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create TransportPorosityFromMassBalance medium property {:s}.",
         property_name);
 
    std::string const& parameter_name =
        config.getConfigParameter<std::string>("initial_porosity");
    auto const& initial_porosity = ParameterLib::findParameter<double>(
        parameter_name, parameters, 0, nullptr);

    auto const& phi_min = config.getConfigParameter<double>("minimal_porosity");

    auto const& phi_max = config.getConfigParameter<double>("maximal_porosity");
 
    return std::make_unique<TransportPorosityFromMassBalance>(
        std::move(property_name), initial_porosity, phi_min, phi_max);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createVapourDiffusionDeVries()

std::unique_ptr< Property > MaterialPropertyLib::createVapourDiffusionDeVries

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__VapourDiffusionDeVries__base_diffusion_coefficient

Input File Parameter

properties__property__VapourDiffusionDeVries__exponent

Definition at line 12 of file CreateVapourDiffusionDeVries.cpp.

{
    config.checkConfigParameter("type", "VapourDiffusionDeVries");
    DBUG("Create VapourDiffusionDeVries phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    double const base_diffusion_coefficient =
        config.getConfigParameter<double>("base_diffusion_coefficient", 5.9e-6);
 
    double const exponent =
        config.getConfigParameter<double>("exponent", 2.3);
 
    return std::make_unique<VapourDiffusionDeVries>(
        std::move(property_name), base_diffusion_coefficient, exponent);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createVapourDiffusionFEBEX()

std::unique_ptr< Property > MaterialPropertyLib::createVapourDiffusionFEBEX

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__VapourDiffusionFEBEX__base_diffusion_coefficient

Input File Parameter

properties__property__VapourDiffusionFEBEX__exponent

Definition at line 12 of file CreateVapourDiffusionFEBEX.cpp.

{
    config.checkConfigParameter("type", "VapourDiffusionFEBEX");
    DBUG("Create VapourDiffusionFEBEX phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    double const base_diffusion_coefficient =
        config.getConfigParameter<double>("base_diffusion_coefficient",
                                          2.16e-5);
 
    double const exponent =
        config.getConfigParameter<double>("exponent", 1.8);
 
    return std::make_unique<VapourDiffusionFEBEX>(
        std::move(property_name), base_diffusion_coefficient, exponent);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createVapourDiffusionPMQ()

std::unique_ptr< Property > MaterialPropertyLib::createVapourDiffusionPMQ

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__VapourDiffusionPMQ__base_diffusion_coefficient

Input File Parameter

properties__property__VapourDiffusionPMQ__exponent

Input File Parameter

properties__property__VapourDiffusionPMQ

Definition at line 12 of file CreateVapourDiffusionPMQ.cpp.

{
    config.checkConfigParameter("type", "VapourDiffusionPMQ");
    DBUG("Create VapourDiffusionPMQ phase property");

    auto property_name = config.peekConfigParameter<std::string>("name");
 
    double const base_diffusion_coefficient =
        config.getConfigParameter<double>("base_diffusion_coefficient",
                                          2.16e-5);
 
    double const exponent =
        config.getConfigParameter<double>("exponent", 1.8);

    return std::make_unique<VapourDiffusionPMQ>(
        std::move(property_name), base_diffusion_coefficient, exponent);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createVermaPruessModel()

std::unique_ptr< Property > MaterialPropertyLib::createVermaPruessModel	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

properties__property__type

Input File Parameter

properties__property__VermaPruessModel__initial_permeability

Input File Parameter

properties__property__VermaPruessModel__initial_porosity

Input File Parameter

properties__property__VermaPruessModel__critical_porosity

Input File Parameter

properties__property__VermaPruessModel__exponent

Definition at line 12 of file CreateVermaPruessModel.cpp.

{
    config.checkConfigParameter("type", "VermaPruess");
    DBUG("Create Verma-Pruess model.");
 
    auto const& k0 = ParameterLib::findParameter<double>(
        config.getConfigParameter<std::string>("initial_permeability"),
        parameters, 0, nullptr);
 
    auto const& phi0 = ParameterLib::findParameter<double>(
        config.getConfigParameter<std::string>("initial_porosity"), parameters,
        1, nullptr);
 
    auto const& phi_c = ParameterLib::findParameter<double>(
        config.getConfigParameter<std::string>("critical_porosity"), parameters,
        1, nullptr);
 
    auto const& n = ParameterLib::findParameter<double>(
        config.getConfigParameter<std::string>("exponent"), parameters, 1,
        nullptr);
 
    return std::make_unique<VermaPruessModel>(k0, phi0, phi_c, n);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), ParameterLib::findParameter(), and BaseLib::ConfigTree::getConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createVolumeFractionAverage()

std::unique_ptr< VolumeFractionAverage > MaterialPropertyLib::createVolumeFractionAverage

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__VolumeFractionAverage

Definition at line 9 of file CreateVolumeFractionAverage.cpp.

{
    config.checkConfigParameter("type", "VolumeFractionAverage");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    DBUG("Create volume fraction average {:s}.", property_name);
 
    // no input parameters required here (taken from phase properties)
 
    return std::make_unique<MaterialPropertyLib::VolumeFractionAverage>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterDensityIAPWSIF97Region1()

std::unique_ptr< Property > MaterialPropertyLib::createWaterDensityIAPWSIF97Region1

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterDensityIAPWSIF97Region1

Definition at line 12 of file CreateWaterDensityIAPWSIF97Region1.cpp.

{
    config.checkConfigParameter("type", "WaterDensityIAPWSIF97Region1");
    DBUG("Create WaterDensityIAPWSIF97Region1 phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterDensityIAPWSIF97Region1>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterEnthalpyIAPWSIF97Region1()

std::unique_ptr< Property > MaterialPropertyLib::createWaterEnthalpyIAPWSIF97Region1

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterEnthalpyIAPWSIF97Region1

Definition at line 12 of file CreateWaterEnthalpyIAPWSIF97Region1.cpp.

{
    config.checkConfigParameter("type", "WaterEnthalpyIAPWSIF97Region1");
    DBUG("Create WaterEnthalpyIAPWSIF97Region1 phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterEnthalpyIAPWSIF97Region1>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterLiquidDensityIAPWSIF97Region4()

std::unique_ptr< Property > MaterialPropertyLib::createWaterLiquidDensityIAPWSIF97Region4

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterLiquidDensityIAPWSIF97Region4

Definition at line 12 of file CreateWaterLiquidDensityIAPWSIF97Region4.cpp.

{
    config.checkConfigParameter("type", "WaterLiquidDensityIAPWSIF97Region4");
    DBUG("Create WaterLiquidDensityIAPWSIF97Region4 phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterLiquidDensityIAPWSIF97Region4>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterLiquidEnthalpyIAPWSIF97Region4()

std::unique_ptr< Property > MaterialPropertyLib::createWaterLiquidEnthalpyIAPWSIF97Region4

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterLiquidEnthalpyIAPWSIF97Region4

Definition at line 12 of file CreateWaterLiquidEnthalpyIAPWSIF97Region4.cpp.

{
    config.checkConfigParameter("type", "WaterLiquidEnthalpyIAPWSIF97Region4");
    DBUG("Create WaterLiquidEnthalpyIAPWSIF97Region4 phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterLiquidEnthalpyIAPWSIF97Region4>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterSaturationTemperatureIAPWSIF97Region4()

std::unique_ptr< Property > MaterialPropertyLib::createWaterSaturationTemperatureIAPWSIF97Region4

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterSaturationTemperatureIAPWSIF97Region4

Definition at line 12 of file CreateWaterSaturationTemperatureIAPWSIF97Region4.cpp.

{
    config.checkConfigParameter("type",
                                "WaterSaturationTemperatureIAPWSIF97Region4");
    DBUG("Create WaterSaturationTemperatureIAPWSIF97Region4 phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterSaturationTemperatureIAPWSIF97Region4>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterTemperatureIAPWSIF97Region1()

std::unique_ptr< Property > MaterialPropertyLib::createWaterTemperatureIAPWSIF97Region1

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterTemperatureIAPWSIF97Region1

Definition at line 12 of file CreateWaterTemperatureIAPWSIF97Region1.cpp.

{
    config.checkConfigParameter("type", "WaterTemperatureIAPWSIF97Region1");
    DBUG("Create WaterTemperatureIAPWSIF97Region1 phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterTemperatureIAPWSIF97Region1>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterThermalConductivityIAPWS()

std::unique_ptr< Property > MaterialPropertyLib::createWaterThermalConductivityIAPWS

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterThermalConductivityIAPWS

Definition at line 12 of file CreateWaterThermalConductivityIAPWS.cpp.

{
    config.checkConfigParameter("type", "WaterThermalConductivityIAPWS");
    DBUG("Create WaterThermalConductivityIAPWS phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterThermalConductivityIAPWS>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterVapourDensity()

std::unique_ptr< Property > MaterialPropertyLib::createWaterVapourDensity

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterVapourDensity

Definition at line 12 of file CreateWaterVapourDensity.cpp.

{
    config.checkConfigParameter("type", "WaterVapourDensity");
    DBUG("Create WaterVapourDensity phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterVapourDensity>(std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterVapourDensityIAPWSIF97Region4()

std::unique_ptr< Property > MaterialPropertyLib::createWaterVapourDensityIAPWSIF97Region4

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterVapourDensityIAPWSIF97Region4

Definition at line 12 of file CreateWaterVapourDensityIAPWSIF97Region4.cpp.

{
    config.checkConfigParameter("type", "WaterVapourDensityIAPWSIF97Region4");
    DBUG("Create WaterVapourDensityIAPWSIF97Region4 phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterVapourDensityIAPWSIF97Region4>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterVapourEnthalpyIAPWSIF97Region4()

std::unique_ptr< Property > MaterialPropertyLib::createWaterVapourEnthalpyIAPWSIF97Region4

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterVapourEnthalpyIAPWSIF97Region4

Definition at line 12 of file CreateWaterVapourEnthalpyIAPWSIF97Region4.cpp.

{
    config.checkConfigParameter("type", "WaterVapourEnthalpyIAPWSIF97Region4");
    DBUG("Create WaterVapourEnthalpyIAPWSIF97Region4 phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterVapourEnthalpyIAPWSIF97Region4>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterVapourLatentHeatWithCriticalTemperature()

std::unique_ptr< Property > MaterialPropertyLib::createWaterVapourLatentHeatWithCriticalTemperature

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterVapourLatentHeatWithCriticalTemperature

Definition at line 12 of file CreateWaterVapourLatentHeatWithCriticalTemperature.cpp.

{
    config.checkConfigParameter("type",
                                "WaterVapourLatentHeatWithCriticalTemperature");
    DBUG("Create WaterVapourLatentHeatWithCriticalTemperature phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterVapourLatentHeatWithCriticalTemperature>(
        std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

createWaterViscosityIAPWS()

std::unique_ptr< Property > MaterialPropertyLib::createWaterViscosityIAPWS

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

properties__property__type

Input File Parameter

properties__property__name

Input File Parameter

properties__property__WaterViscosityIAPWS

Definition at line 12 of file CreateWaterViscosityIAPWS.cpp.

{
    config.checkConfigParameter("type", "WaterViscosityIAPWS");
    DBUG("Create WaterViscosityIAPWS phase property");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");

    return std::make_unique<WaterViscosityIAPWS>(std::move(property_name));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::ConfigTree::peekConfigParameter().

Referenced by anonymous_namespace{CreateProperty.cpp}::createProperty().

currentThreadId()

int MaterialPropertyLib::currentThreadId ( std::string const & property_name, std::size_t const num_slots )

static

OpenMP thread id validated against the number of allocated per-thread data slots. OGS_FATAL if the id exceeds the allocation.

Definition at line 661 of file Function.cpp.

{
#ifdef _OPENMP
    int const thread_id = omp_get_thread_num();
#else
    int const thread_id = 0;
#endif
    if (thread_id >= static_cast<int>(num_slots))
    {
        OGS_FATAL(
            "In Function-type property '{:s}' evaluation the OMP-thread with "
            "id {:d} exceeds the number of allocated threads {:d}.",
            property_name, thread_id, num_slots);
    }
    return thread_id;
}

References OGS_FATAL.

Referenced by MaterialPropertyLib::Function::d2Value(), MaterialPropertyLib::Function::dValue(), and MaterialPropertyLib::Function::value().

driftFluxProfileParameter()

double MaterialPropertyLib::driftFluxProfileParameter

(

double const

dryness

)

Profile parameter \(C_0\) of the Rouhani-Axelsson drift-flux closure, the flow-weighted ratio of the cross-sectional averages that accounts for the non-uniform void and velocity profiles over the well cross-section.

Note

Like driftFluxVelocity(), the correlation is derived for vertical flow and carries no inclination correction. In an inclined well the phases segregate towards the high side of the cross-section, which changes the void profile the parameter stands for.

Parameters

dryness

the vapour mass fraction, dimensionless.

Returns

The profile parameter, dimensionless.

Definition at line 40 of file DriftFluxModel.cpp.

{
    return 1 + 0.12 * (1 - dryness);
}

Referenced by driftFluxState().

driftFluxState()

DriftFluxState MaterialPropertyLib::driftFluxState	(	double const	dryness,
		double const	temperature,
		double const	vapour_water_density,
		double const	liquid_water_density,
		double const	v_mix )

State of the drift-flux closure for a two-phase water mixture, assembled from the quantities a local assembler has at an integration point. The profile parameter and the drift flux velocity are not independent inputs: they follow from the same dryness, temperature and phase densities through driftFluxProfileParameter() and driftFluxVelocity(), and the drift has to be the one aligned with the mixture flow, see alignedDriftFluxVelocity(). Composing them here keeps every caller on the same closure.

Parameters

dryness	the vapour mass fraction, dimensionless.
temperature	in K.
vapour_water_density	in kg/m^3.
liquid_water_density	in kg/m^3.
v_mix	the mixture velocity in m/s.

Returns

The state, with its profile parameter and its aligned drift flux velocity.

Definition at line 124 of file DriftFluxModel.cpp.

{
    return {.dryness = dryness,
            .vapour_water_density = vapour_water_density,
            .liquid_water_density = liquid_water_density,
            .v_mix = v_mix,
            .C_0 = driftFluxProfileParameter(dryness),
            .u_gu = alignedDriftFluxVelocity(
                driftFluxVelocity(dryness, temperature, vapour_water_density,
                                  liquid_water_density),
                v_mix)};
}

References alignedDriftFluxVelocity(), driftFluxProfileParameter(), driftFluxVelocity(), and temperature.

Referenced by ProcessLib::WellboreCompensateNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), and ProcessLib::WellboreSimulator::WellboreSimulatorFEM< ShapeFunction, GlobalDim >::assemble().

driftFluxVelocity()

double MaterialPropertyLib::driftFluxVelocity	(	double const	dryness,
		double const	temperature,
		double const	vapour_water_density,
		double const	liquid_water_density )

Drift flux velocity \(u_{gu}\) of the Rouhani-Axelsson closure, from the surface tension of the IAPWS correlation, see Cooper, J. R., and R. B. Dooley. "IAPWS release on surface tension of ordinary water substance." International Association for the Properties of Water and Steam (1994).

Both the surface tension correlation and the buoyancy driving the drift are capped at zero at the critical point, where the two phases become identical: beyond it the reduced temperature is negative and the phase densities cross, and std::pow of a negative base with the non-integer exponents of the two correlations is NaN, which would travel into the void fraction closure. Newton iterates do reach that range, so both are capped rather than assumed positive.

Note

The correlation is Harmathy's terminal rise velocity of a bubble in a quiescent liquid and is derived for vertical flow. It carries no inclination correction: the drift is the same for a vertical and for an inclined well, although the buoyancy driving it acts along the vertical and only its component \(g \cos\theta\) along the well axis, with the inclination \(\theta\) measured from the vertical, drives an axial drift. The value returned here is therefore an overestimate for an inclined well and stays at its full vertical value for a horizontal one, where the axial drift should vanish. A caller that projects its body force onto the well axis, as ProcessLib::WellboreSimulator does, is inconsistent with this closure unless the well is vertical. Correlations with an inclination correction exist, for instance Hasan, A. R., and C. S. Kabir. "A study of multiphase flow behavior in vertical wells." SPE Production Engineering 3 (1988): 263-272, but would need the inclination as a further argument.

Parameters

dryness	the vapour mass fraction, dimensionless.
temperature	in K.
vapour_water_density	in kg/m^3.
liquid_water_density	in kg/m^3.

Returns

The drift flux velocity in m/s.

Definition at line 93 of file DriftFluxModel.cpp.

{
    // The rounded value the original implementation of this closure used, not
    // standard gravity, whose defined value is 9.80665 m/s^2. It stays rounded
    // because sharpening it would move every existing two-phase result, and it
    // stays local because a rounded stand-in is not the physical constant and
    // so does not belong in PhysicalConstant.h beside the critical point.
    constexpr double gravity = 9.81;  // m/s^2
 
    // Both caps are written as comparisons rather than with std::max, which
    // returns its first argument for a NaN second one and would hand out a
    // finite drift flux velocity for a non-finite state. The NaN is kept so
    // that computeVapourVoidFraction() sees it and aborts the assembly.
    double const temperature_ratio =
        1 - temperature /
                MaterialLib::PhysicalConstant::CriticalPoint::TemperatureWater;
    double const reduced_temperature =
        temperature_ratio < 0 ? 0. : temperature_ratio;
    double const sigma_gl = 0.2358 * std::pow(reduced_temperature, 1.256) *
                            (1 - 0.625 * reduced_temperature);
 
    double const buoyancy =
        gravity * sigma_gl * (liquid_water_density - vapour_water_density);
    double const drift_buoyancy = buoyancy < 0 ? 0. : buoyancy;
 
    return 1.18 * (1 - dryness) * std::sqrt(std::sqrt(drift_buoyancy)) /
           std::sqrt(liquid_water_density);
}

References temperature, and MaterialLib::PhysicalConstant::CriticalPoint::TemperatureWater.

Referenced by driftFluxState().

dropConst()

VariableArray::VariablePointer MaterialPropertyLib::dropConst ( VariableArray::VariablePointerConst const const_pointer )

static

Definition at line 104 of file VariableType.cpp.

{
    return std::visit(
        []<typename T>(T const* ptr) -> VariableArray::VariablePointer
        { return const_cast<T*>(ptr); },
        const_pointer);
}

Referenced by MaterialPropertyLib::VariableArray::address_of().

dsaturatedVaporDensitydT()

double MaterialPropertyLib::dsaturatedVaporDensitydT ( double const T )

static

\(\frac{\partial \rho_{vS}}{\partial T}\)

Definition at line 21 of file WaterVapourDensity.cpp.

{
    return 4.9759 * std::exp(19.819 - 4975.9 / T) / (T * T);
}

Referenced by MaterialPropertyLib::WaterVapourDensity::dValue().

evaluateToArray()

template<std::size_t N>

std::array< double, N > MaterialPropertyLib::evaluateToArray ( std::vector< exprtk::expression< double > > const & expressions )

static

Helper to get fixed-size array from expressions for known sizes. This avoids heap allocation.

Definition at line 508 of file Function.cpp.

{
    std::array<double, N> result{};
    for (std::size_t i = 0; i < N; ++i)
    {
        result[i] = expressions[i].value();
    }
    return result;
}

Referenced by MaterialPropertyLib::PerThreadData::evaluate().

fluidPhase()

Phase const & MaterialPropertyLib::fluidPhase

(

Medium const &

medium

)

Returns a gas or aqueous liquid phase of the given medium.

Definition at line 95 of file Medium.cpp.

{
    if (medium.hasPhase(PhaseName::Gas))
    {
        return medium.phase(PhaseName::Gas);
    }
    if (medium.hasPhase(PhaseName::AqueousLiquid))
    {
        return medium.phase(PhaseName::AqueousLiquid);
    }
    OGS_FATAL(
        "Neither Gas nor AqueousLiquid phase is available for the medium, but "
        "a fluid phase was requested.");
}

References AqueousLiquid, Gas, MaterialPropertyLib::Medium::hasPhase(), OGS_FATAL, and MaterialPropertyLib::Medium::phase().

Referenced by checkMPLPhasesForSinglePhaseFlow(), and ProcessLib::Common::HydraulicProcess::checkVolumeBalanceEquationSetting().

formEffectiveThermalConductivity()

template<int GlobalDim>

Eigen::Matrix< double, GlobalDim, GlobalDim > MaterialPropertyLib::formEffectiveThermalConductivity	(	MaterialPropertyLib::PropertyDataType const &	solid_thermal_conductivity,
		const double	fluid_thermal_conductivity,
		const double	porosity )

Definition at line 11 of file FormEffectiveThermalConductivity.cpp.

{
    return (1.0 - porosity) *
               formEigenTensor<GlobalDim>(solid_thermal_conductivity) +
           porosity * fluid_thermal_conductivity *
               Eigen::Matrix<double, GlobalDim, GlobalDim>::Identity();
}

References formEigenTensor(), and porosity.

Referenced by ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::assemble().

formEffectiveThermalConductivity< 1 >()

template Eigen::Matrix< double, 1, 1 > MaterialPropertyLib::formEffectiveThermalConductivity< 1 >	(	MaterialPropertyLib::PropertyDataType const &	solid_thermal_conductivity,
		const double	fluid_thermal_conductivity,
		const double	porosity )

References porosity.

formEffectiveThermalConductivity< 2 >()

template Eigen::Matrix< double, 2, 2 > MaterialPropertyLib::formEffectiveThermalConductivity< 2 >	(	MaterialPropertyLib::PropertyDataType const &	solid_thermal_conductivity,
		const double	fluid_thermal_conductivity,
		const double	porosity )

References porosity.

formEffectiveThermalConductivity< 3 >()

template Eigen::Matrix< double, 3, 3 > MaterialPropertyLib::formEffectiveThermalConductivity< 3 >	(	MaterialPropertyLib::PropertyDataType const &	solid_thermal_conductivity,
		const double	fluid_thermal_conductivity,
		const double	porosity )

References porosity.

formEigenTensor()

template<int GlobalDim>

Eigen::Matrix< double, GlobalDim, GlobalDim > MaterialPropertyLib::formEigenTensor ( MaterialPropertyLib::PropertyDataType const & values )

constexpr

Definition at line 163 of file FormEigenTensor.h.

{
    return std::visit(FormEigenTensor<GlobalDim>(), values);
}

Referenced by ProcessLib::HeatConduction::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::HT::MonolithicHTFEM< ShapeFunction, GlobalDim >::assemble(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::RichardsComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assemble(), ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleBlockMatrices(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleBlockMatricesWithJacobian(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleComponentTransportEquation(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleHeatTransportEquation(), ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::assembleHeatTransportEquation(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleHydraulicEquation(), ProcessLib::HT::StaggeredHTFEM< ShapeFunction, GlobalDim >::assembleHydraulicEquation(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::assembleMatrixAndVector(), ProcessLib::HeatConduction::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleWithJacobian(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assembleWithJacobian(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleWithJacobianComponentTransportEquation(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianEvalConstitutiveSetting(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForHeatConductionEquations(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianForPressureEquations(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleWithJacobianHydraulicEquation(), ProcessLib::HMPhaseField::HMPhaseFieldLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianHydroEquations(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::calculateIntPtDarcyVelocity(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::computeProjectedDarcyVelocity(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::computeSecondaryVariableConcrete(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::computeSecondaryVariableConcrete(), ProcessLib::TH2M::ConstitutiveRelations::ThermalConductivityModel< DisplacementDim >::dEval(), MaterialPropertyLib::EffectiveThermalConductivityPorosityMixing< GlobalDim >::dValue(), ProcessLib::TH2M::ConstitutiveRelations::PermeabilityModel< DisplacementDim >::eval(), ProcessLib::TH2M::ConstitutiveRelations::SwellingModel< DisplacementDim >::eval(), ProcessLib::TH2M::ConstitutiveRelations::ThermalConductivityModel< DisplacementDim >::eval(), ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::SwellingModel< DisplacementDim >::eval(), ProcessLib::ThermoRichardsMechanics::PermeabilityModel< DisplacementDim >::eval(), ProcessLib::ThermoRichardsMechanics::TRMHeatStorageAndFluxModel< DisplacementDim >::eval(), formEffectiveThermalConductivity(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, GlobalDim >::getFlux(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::getIntPtDarcyVelocity(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::RichardsComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::RichardsFlow::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::SteadyStateDiffusion::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getIntPtDarcyVelocityLocal(), ProcessLib::HeatConduction::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtHeatFlux(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtMolarFlux(), ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getThermalConductivityDispersivity(), ProcessLib::HT::HTFEM< ShapeFunction, GlobalDim >::getThermalConductivityDispersivity(), ProcessLib::getThermoOsmoticCoefficient(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::postTimestepConcreteWithBlockVectors(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveRelations(), ProcessLib::RichardsMechanics::updateSwellingStressAndVolumetricStrain(), and MaterialPropertyLib::EffectiveThermalConductivityPorosityMixing< GlobalDim >::value().

formEigenTensor< 1 >()

template Eigen::Matrix< double, 1, 1 > MaterialPropertyLib::formEigenTensor< 1 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

formEigenTensor< 2 >()

template Eigen::Matrix< double, 2, 2 > MaterialPropertyLib::formEigenTensor< 2 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

formEigenTensor< 3 >()

template Eigen::Matrix< double, 3, 3 > MaterialPropertyLib::formEigenTensor< 3 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::assemble(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assembleWithJacobian(), MaterialPropertyLib::EmbeddedFracturePermeability< DisplacementDim >::dValue(), MaterialPropertyLib::EmbeddedFracturePermeability< DisplacementDim >::value(), and MaterialPropertyLib::PermeabilityMohrCoulombFailureIndexModel< DisplacementDim >::value().

formEigenTensor< 4 >()

template Eigen::Matrix< double, 4, 4 > MaterialPropertyLib::formEigenTensor< 4 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

formEigenTensor< 6 >()

template Eigen::Matrix< double, 6, 6 > MaterialPropertyLib::formEigenTensor< 6 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

formEigenVector()

template<int GlobalDim>

Eigen::Matrix< double, GlobalDim, 1 > MaterialPropertyLib::formEigenVector

(

MaterialPropertyLib::PropertyDataType const &

values

)

Definition at line 98 of file FormEigenVector.cpp.

{
    return std::visit(FormEigenVector<GlobalDim>(), values);
}

formEigenVector< 1 >()

template Eigen::Matrix< double, 1, 1 > MaterialPropertyLib::formEigenVector< 1 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

formEigenVector< 2 >()

template Eigen::Matrix< double, 2, 1 > MaterialPropertyLib::formEigenVector< 2 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

formEigenVector< 3 >()

template Eigen::Matrix< double, 3, 1 > MaterialPropertyLib::formEigenVector< 3 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

Referenced by ProcessLib::ThermoRichardsFlow::SimplifiedElasticityModel::bulkCompressibilityFromYoungsModulus(), ProcessLib::ThermoRichardsFlow::UniaxialElasticityModel::storageContribution(), and ProcessLib::ThermoRichardsFlow::UniaxialElasticityModel::thermalExpansivityContribution().

formKelvinVector()

template<int GlobalDim>

MathLib::KelvinVector::KelvinVectorType< GlobalDim > MaterialPropertyLib::formKelvinVector

(

MaterialPropertyLib::PropertyDataType const &

values

)

A function to form a Kelvin vector from strain or stress alike property like thermal expansivity for thermal strain.

It takes either a scalar number for isotropic thermal expansion or a three element vector or a 3 x 3 matrix for anisotropic properties, to get a Kelvin vector for strain or stress.

Parameters

values

e.g., Thermal expansivity, which can be scalar number, a three element vector or a 3 x 3 matrix.

Returns

Kelvin vector type property.

Definition at line 74 of file FormKelvinVector.cpp.

{
    return std::visit(FormKelvinVector<GlobalDim>(), values);
}

Referenced by ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::TH2M::ConstitutiveRelations::SolidThermalExpansionModel< DisplacementDim >::eval(), ProcessLib::ThermoRichardsMechanics::SolidThermalExpansionModel< DisplacementDim >::eval(), and ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveRelations().

formKelvinVector< 2 >()

template MathLib::KelvinVector::KelvinVectorType< 2 > MaterialPropertyLib::formKelvinVector< 2 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

formKelvinVector< 3 >()

template MathLib::KelvinVector::KelvinVectorType< 3 > MaterialPropertyLib::formKelvinVector< 3 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

fromArray()

template<std::size_t N>

PropertyDataType MaterialPropertyLib::fromArray

(

std::array< double, N > const &

values

)

Conversion of a fixed-size array to PropertyDataType.

Supported sizes: 1, 2, 3, 4, 6, 9 - same semantics as fromVector().

Attention

This method cannot distinguish between 2x2 matrix and 4x1 vector.

Note

4-element arrays map to Eigen::Matrix2d (row-major), 9-element arrays map to Eigen::Matrix3d (row-major).

Definition at line 49 of file MaterialLib/MPL/Property.h.

{
    if constexpr (N == 1)
    {
        return values[0];
    }
    else if constexpr (N == 2)
    {
        return Eigen::Vector2d{values[0], values[1]};
    }
    else if constexpr (N == 3)
    {
        return Eigen::Vector3d{values[0], values[1], values[2]};
    }
    else if constexpr (N == 4)
    {
        using M = Eigen::Matrix2d;
        using MRM = Eigen::Matrix<double, 2, 2, Eigen::RowMajor>;
        return M{Eigen::Map<MRM const>{values.data(), 2, 2}};
    }
    else if constexpr (N == 6)
    {
        using M = Eigen::Matrix<double, 6, 1>;
        return M{Eigen::Map<M const>{values.data(), 6}};
    }
    else if constexpr (N == 9)
    {
        using M = Eigen::Matrix3d;
        using MRM = Eigen::Matrix<double, 3, 3, Eigen::RowMajor>;
        return M{Eigen::Map<MRM const>{values.data(), 3, 3}};
    }
    else
    {
        static_assert(false, "Unsupported array size for fromArray.");
    }
}

Referenced by MaterialPropertyLib::PerThreadData::evaluate().

fromString()

PhaseName MaterialPropertyLib::fromString ( std::string const & phase_name )

nodiscard

Convert string to phase enum. Throws if invalid phase name.

Definition at line 29 of file Phase.cpp.

{
    if (phase_name == "Solid")
    {
        return PhaseName::Solid;
    }
    if (phase_name == "AqueousLiquid")
    {
        return PhaseName::AqueousLiquid;
    }
    if (phase_name == "Gas")
    {
        return PhaseName::Gas;
    }
    if (phase_name == "FrozenLiquid")
    {
        return PhaseName::FrozenLiquid;
    }
    OGS_FATAL("Unknown phase name '{}'", phase_name);
}

References AqueousLiquid, FrozenLiquid, Gas, OGS_FATAL, and Solid.

Referenced by anonymous_namespace{CreatePhase.cpp}::createPhase(), anonymous_namespace{PhaseTransition.cpp}::findComponentIndex(), and anonymous_namespace{PhaseTransition.cpp}::numberOfComponents().

fromVector()

PropertyDataType MaterialPropertyLib::fromVector

(

std::vector< double > const &

values

)

Conversion of a vector to PropertyDataType for different sizes of the vector.

Attention

This method cannot distinguish between 2x2 matrix and 4x1 vector.

Note

If the values vector stores all elements of a 2x2 or 3x3 matrix (i.e. the general case for 2x2 and 3x3 matrices), it is assumed to be in row major storage order.

Definition at line 14 of file MaterialLib/MPL/Property.cpp.

{
    switch (values.size())
    {
        case 1:
        {
            return values[0];
        }
        case 2:
        {
            return Eigen::Vector2d{values[0], values[1]};
        }
        case 3:
        {
            return Eigen::Vector3d{values[0], values[1], values[2]};
        }
        case 4:
        {
            using M = Eigen::Matrix2d;
            // the values vector is in row major order
            using MRM = Eigen::Matrix<double, 2, 2, Eigen::RowMajor>;
            return M{Eigen::Map<MRM const>{values.data(), 2, 2}};
        }
        case 6:
        {
            // Symmetric Tensor - xx, yy, zz, xy, xz, yz
            using M = Eigen::Matrix<double, 6, 1>;
            return M{Eigen::Map<M const>{values.data(), 6}};
        }
        case 9:
        {
            using M = Eigen::Matrix3d;
            // the values vector is in row major order
            using MRM = Eigen::Matrix<double, 3, 3, Eigen::RowMajor>;
            return M{Eigen::Map<MRM const>{values.data(), 3, 3}};
        }
        default:
        {
            OGS_FATAL(
                "Conversion of a {:d}-vector to PropertyDataType is not "
                "implemented.",
                values.size());
        }
    }
}

References OGS_FATAL.

Referenced by createConstant(), MaterialPropertyLib::OrthotropicEmbeddedFracturePermeability< DisplacementDim >::dValue(), MaterialPropertyLib::SaturationWeightedThermalConductivity< MeantType, GlobalDimension >::dValue(), MaterialPropertyLib::PorosityFromMassBalance::initialValue(), MaterialPropertyLib::TransportPorosityFromMassBalance::initialValue(), MaterialPropertyLib::DupuitPermeability::value(), MaterialPropertyLib::GasPressureDependentPermeability< DisplacementDim >::value(), MaterialPropertyLib::KozenyCarmanModel::value(), MaterialPropertyLib::OrthotropicEmbeddedFracturePermeability< DisplacementDim >::value(), MaterialPropertyLib::Parameter::value(), MaterialPropertyLib::Parameter::value(), MaterialPropertyLib::PermeabilityMohrCoulombFailureIndexModel< DisplacementDim >::value(), MaterialPropertyLib::SaturationWeightedThermalConductivity< MeantType, GlobalDimension >::value(), MaterialPropertyLib::StrainDependentPermeability< DisplacementDim >::value(), MaterialPropertyLib::TemperatureDependentDiffusion::value(), and MaterialPropertyLib::VermaPruessModel::value().

getFluidDensity()

double MaterialPropertyLib::getFluidDensity	(	double const	t,
		double const	dt,
		ParameterLib::SpatialPosition const &	pos,
		Phase const &	fluid_phase,
		VariableArray &	vars )

It computes fluid density for single phase flow model.

Definition at line 13 of file GetFluidDensityAndViscosity.cpp.

{
    // Compute density:
    // Quick workaround: If fluid density is described as ideal gas, then
    // the molar mass must be passed to the MPL::IdealGasLaw via the
    // variable_array and the fluid must have the property
    // MPL::PropertyType::molar_mass. For other density models (e.g.
    // Constant), it is not mandatory to specify the molar mass.
    if (fluid_phase.hasProperty(MaterialPropertyLib::PropertyType::molar_mass))
    {
        vars.molar_mass =
            fluid_phase.property(MaterialPropertyLib::PropertyType::molar_mass)
                .template value<double>(vars, pos, t, dt);
    }
 
    return fluid_phase[MaterialPropertyLib::PropertyType::density]
        .template value<double>(vars, pos, t, dt);
}

References density, MaterialPropertyLib::Phase::hasProperty(), molar_mass, MaterialPropertyLib::VariableArray::molar_mass, and MaterialPropertyLib::Phase::property().

Referenced by ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianForDeformationEquations(), and getFluidDensityAndViscosity().

getFluidDensityAndViscosity()

std::tuple< double, double > MaterialPropertyLib::getFluidDensityAndViscosity	(	double const	t,
		double const	dt,
		ParameterLib::SpatialPosition const &	pos,
		MaterialPropertyLib::Phase const &	fluid_phase,
		MaterialPropertyLib::VariableArray &	vars )

It computes fluid density and viscosity for single phase flow model.

Definition at line 34 of file GetFluidDensityAndViscosity.cpp.

{
    auto const fluid_density = getFluidDensity(t, dt, pos, fluid_phase, vars);
 
    assert(fluid_density > 0.);
    vars.density = fluid_density;
 
    auto const viscosity =
        fluid_phase[MaterialPropertyLib::PropertyType::viscosity]
            .template value<double>(vars, pos, t, dt);
 
    return {fluid_density, viscosity};
}

References MaterialPropertyLib::VariableArray::density, getFluidDensity(), and viscosity.

Referenced by ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::assembleMatrixAndVector(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobian(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::assembleWithJacobianForPressureEquations(), ProcessLib::LiquidFlow::LiquidFlowLocalAssembler< ShapeFunction, GlobalDim >::computeProjectedDarcyVelocity(), and ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::getIntPtDarcyVelocity().

getLiquidThermalExpansivity()

double MaterialPropertyLib::getLiquidThermalExpansivity	(	Phase const &	phase,
		VariableArray const &	vars,
		const double	density,
		ParameterLib::SpatialPosition const &	pos,
		double const	t,
		double const	dt )

It gets the thermal expansion coefficient.

If the the thermal expansion coefficient is given in the project file via the media property of thermal_expansivity, e.g

*     <property>
*       <name>thermal_expansivity</name>
*       <type>Constant</type>
*       <value>2.07e-4</value>
*     </property>
* 

it returns the value of the given property. Otherwise it returns the value computed from the density model by the following formula

\[ (\frac{\partial \rho}{\partial T})/\rho \]

where \(\rho\) is the density, \(T\) is the temperature.

Definition at line 12 of file GetLiquidThermalExpansivity.cpp.

{
    // The thermal expansivity is explicitly given in the project file.
    if (phase.hasProperty(
            MaterialPropertyLib::PropertyType::thermal_expansivity))
    {
        return phase
            .property(MaterialPropertyLib::PropertyType::thermal_expansivity)
            .template value<double>(vars, pos, t, dt);
    }
 
    // The thermal expansivity calculated by the density model directly.
    return (density == 0.0)
               ? 0.0
               : -phase.property(MaterialPropertyLib::PropertyType::density)
                         .template dValue<double>(
                             vars, MaterialPropertyLib::Variable::temperature,
                             pos, t, dt) /
                     density;
}

References density, MaterialPropertyLib::Phase::hasProperty(), MaterialPropertyLib::Phase::property(), temperature, and thermal_expansivity.

Referenced by ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assemble(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, GlobalDim >::assembleWithJacobian(), ProcessLib::ThermoRichardsMechanics::FluidThermalExpansionModel< DisplacementDim >::eval(), and ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::updateConstitutiveRelations().

getOptionalPhase()

Phase const * MaterialPropertyLib::getOptionalPhase	(	Medium const &	medium,
		PhaseName	phase_name )

Returns a pointer to the phase with the given type, or nullptr if the phase does not exist in the medium.

Definition at line 110 of file Medium.cpp.

{
    return medium.hasPhase(phase_name) ? &medium.phase(phase_name) : nullptr;
}

References MaterialPropertyLib::Medium::hasPhase(), and MaterialPropertyLib::Medium::phase().

Referenced by MaterialPropertyLib::EffectiveThermalConductivityPorosityMixing< GlobalDim >::dValue(), ProcessLib::ThermoRichardsMechanics::TRMVaporDiffusionModel< DisplacementDim >::eval(), and MaterialPropertyLib::EffectiveThermalConductivityPorosityMixing< GlobalDim >::value().

getSymmetricTensor()

template<int GlobalDim>

SymmetricTensor< GlobalDim > MaterialPropertyLib::getSymmetricTensor

(

MaterialPropertyLib::PropertyDataType const &

values

)

Definition at line 99 of file GetSymmetricTensor.cpp.

{
    return std::visit(GetSymmetricTensor<GlobalDim>(), values);
}

Referenced by ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::computeSecondaryVariableConcrete().

getSymmetricTensor< 2 >()

template Eigen::Matrix< double, 4, 1 > MaterialPropertyLib::getSymmetricTensor< 2 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

getSymmetricTensor< 3 >()

template Eigen::Matrix< double, 6, 1 > MaterialPropertyLib::getSymmetricTensor< 3 >

(

MaterialPropertyLib::PropertyDataType const &

values

)

humidity()

double MaterialPropertyLib::humidity ( double const T, double const p, double const water_density )

static

Definition at line 26 of file WaterVapourDensity.cpp.

{
    return std::exp(
        p / (MaterialLib::PhysicalConstant::SpecificGasConstant::WaterVapour *
             T * water_density));
}

References MaterialLib::PhysicalConstant::SpecificGasConstant::WaterVapour.

Referenced by MaterialPropertyLib::WaterVapourDensity::dValue(), and MaterialPropertyLib::WaterVapourDensity::value().

mixtureSlipParameter()

double MaterialPropertyLib::mixtureSlipParameter	(	double const	alpha,
		DriftFluxState const &	state )

Slip parameter \(\gamma\) of the two-phase mixture, the momentum flux carried by the relative motion of the phases, see Akbar, Somaieh, N. Fathianpour, and Rafid Al Khoury. "A finite element model for high enthalpy two-phase flow in geothermal wellbores." Renewable Energy 94 (2016): 223-236.

\[ \gamma = \frac{\alpha \rho_l \rho_v \rho_m}{(1 - \alpha) \left(\alpha C_0 \rho_v + (1 - \alpha C_0) \rho_l\right)^2} \left((C_0 - 1) v + u_{gu}\right)^2 \]

with the mixture density \(\rho_m = \alpha \rho_v + (1 - \alpha) \rho_l\).

A void fraction of one, which computeVapourVoidFraction() returns at a dryness of one, would divide by zero. There is no liquid phase left to slip against and the limit is zero slip: both the liquid fraction \(1 - \alpha\) and the bracket \((C_0 - 1) v + u_{gu}\) vanish linearly in \(1 - x\), and the bracket enters squared, so the quotient is of the order of \(1 - x\).

The dryness of state does not enter; the void fraction it leads to is passed instead.

Parameters

alpha	the vapour void fraction, dimensionless.
state	the state of the closure the void fraction was solved from.

Returns

The slip parameter in Pa; it is a momentum flux and enters the momentum balance next to \(\rho_m v^2\).

Definition at line 291 of file DriftFluxModel.cpp.

{
    // The zero slip limit at a void fraction of one, see the documentation of
    // this function.
    if (alpha == 1)
    {
        return 0.;
    }
 
    double const rho_v = state.vapour_water_density;
    double const rho_l = state.liquid_water_density;
    double const C_0 = state.C_0;
 
    double const rho_mix = alpha * rho_v + (1 - alpha) * rho_l;
 
    return alpha * rho_l * rho_v * rho_mix / (1 - alpha) /
           std::pow((alpha * C_0 * rho_v + (1 - alpha * C_0) * rho_l), 2) *
           std::pow((C_0 - 1) * state.v_mix + state.u_gu, 2);
}

References alpha, MaterialPropertyLib::DriftFluxState::C_0, MaterialPropertyLib::DriftFluxState::liquid_water_density, MaterialPropertyLib::DriftFluxState::u_gu, MaterialPropertyLib::DriftFluxState::v_mix, and MaterialPropertyLib::DriftFluxState::vapour_water_density.

Referenced by ProcessLib::WellboreCompensateNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), and ProcessLib::WellboreSimulator::WellboreSimulatorFEM< ShapeFunction, GlobalDim >::assemble().

newComponent()

std::unique_ptr< Component > MaterialPropertyLib::newComponent	(	std::string const &	component_name,
		bool &	isCustomComponent )

Method for creating a new component based on the specified component name.

This function creates a new component based on the (optional) component name that is given in the prj-file.

The method evaluates the string in the 'name'-object and calls the constructors of the derived component classes (if found) or that of the base class (if no name is specified).

References c.

normalizedState()

std::optional< std::pair< double, double > > MaterialPropertyLib::normalizedState ( double const f, double const lower_bound, double const upper_bound )

static

Definition at line 27 of file Sigmoid.cpp.

{
    double const range = upper_bound - lower_bound;
    double const f_normalized = f - lower_bound;
 
    if (f_normalized <= 0.0 || f_normalized >= range)
    {
        return std::nullopt;
    }
    return std::pair{f_normalized, range};
}

Referenced by MaterialPropertyLib::Sigmoid::d2Value(), and MaterialPropertyLib::Sigmoid::dValue().

overwriteExistingProperties()

void MaterialPropertyLib::overwriteExistingProperties ( PropertyArray & properties, PropertyArray & new_properties, std::variant< Medium *, Phase *, Component * > scale_pointer )

inline

Definition at line 361 of file MaterialLib/MPL/Property.h.

{
    for (std::size_t i = 0; i < properties.size(); ++i)
    {
        if (new_properties[i] != nullptr)
        {
            properties[i] = std::move(new_properties[i]);
            properties[i]->setScale(scale_pointer);
        }
    }
}

Referenced by MaterialPropertyLib::Component::Component(), MaterialPropertyLib::Medium::Medium(), and MaterialPropertyLib::Phase::Phase().

saturatedVaporDensity()

double MaterialPropertyLib::saturatedVaporDensity ( double const T )

static

\(\rho_{vS}\)

Definition at line 15 of file WaterVapourDensity.cpp.

{
    return 1.0e-3 * std::exp(19.819 - 4975.9 / T);
}

Referenced by MaterialPropertyLib::WaterVapourDensity::dValue(), and MaterialPropertyLib::WaterVapourDensity::value().

steamDryness()

double MaterialPropertyLib::steamDryness	(	double const	enthalpy,
		double const	h_sat_liquid,
		double const	h_sat_vapour )

Steam dryness \(x\), the vapour mass fraction, from the specific enthalpy of the mixture and the saturation enthalpies of the two phases.

The dryness is capped at the two ends of the two-phase range, but the two caps do not carry the same weight.

Below the range, \(h < h_l\), the state is subcooled liquid. The callers detect it as a dryness of zero and then re-evaluate the liquid density and the temperature off the saturation line, so the cap only removes a negative vapour mass fraction from an otherwise fully represented state.

Above the range, \(h > h_v\), the state is superheated steam and there is no counterpart: the mixture is described by the saturation line alone, so such a section keeps the saturation temperature and the saturation vapour density, and its superheat is lost rather than represented. The cap is still applied, because the drift-flux closure is only defined on \([0, 1]\), but it is reported so that it does not pass silently.

A non-finite ratio, which the saturation enthalpies produce where they coincide at the critical point, passes through both caps unchanged and is rejected by the closure that consumes the dryness.

Definition at line 10 of file SteamDryness.cpp.

{
    double const dryness =
        (enthalpy - h_sat_liquid) / (h_sat_vapour - h_sat_liquid);
 
    if (dryness > 1)
    {
        WARN(
            "Specific enthalpy {:g} J/kg exceeds the saturation enthalpy of "
            "the vapour phase, {:g} J/kg. The steam is superheated, which the "
            "saturated mixture cannot represent: the section is evaluated at "
            "the saturation temperature and with the saturation vapour "
            "density.",
            enthalpy, h_sat_vapour);
        return 1.;
    }
    if (dryness < 0)
    {
        return 0.;
    }
    return dryness;
}

References enthalpy, and WARN().

Referenced by ProcessLib::WellboreCompensateNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), and ProcessLib::WellboreSimulator::WellboreSimulatorFEM< ShapeFunction, GlobalDim >::assemble().

tensorSize()

int MaterialPropertyLib::tensorSize ( int dim )

constexpr

See Tensor type for details.

Definition at line 13 of file Tensor.h.

{
    if (dim == 1)
    {
        return 3;  // Diagonal entries.
    }
    if (dim == 2)
    {
        return 5;  // 2x2 matrix and the 3rd diagonal entry.
    }
    if (dim == 3)
    {
        return 9;  // Full 3x3 matrix.
    }
    OGS_FATAL("Tensor size for dimension {} is not defined.", dim);
}

References OGS_FATAL.

Referenced by ProcessLib::LargeDeformation::computeSigmaGeom(), MaterialLib::Solids::MFront::Variable< Derived >::rows(), and MaterialLib::Solids::MFront::OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations >::size().

toString()

std::string_view MaterialPropertyLib::toString ( PhaseName phase_name )

nodiscard

Convert phase enum to its string representation.

Definition at line 13 of file Phase.cpp.

{
    switch (phase_name)
    {
        case PhaseName::Solid:
            return "Solid";
        case PhaseName::AqueousLiquid:
            return "AqueousLiquid";
        case PhaseName::Gas:
            return "Gas";
        case PhaseName::FrozenLiquid:
            return "FrozenLiquid";
    }
    OGS_FATAL("Unknown phase name");
}

References AqueousLiquid, FrozenLiquid, Gas, OGS_FATAL, and Solid.

Referenced by checkRequiredProperties(), MaterialPropertyLib::SaturationDependentSwelling::checkScale(), anonymous_namespace{CreatePhase.cpp}::createPhase(), createPhases(), MaterialPropertyLib::Phase::description(), MaterialPropertyLib::Medium::phase(), and MaterialPropertyLib::VolumeFractionAverage::setProperties().

updatePropertiesForAllPhases()

void MaterialPropertyLib::updatePropertiesForAllPhases ( PropertyArray & properties, std::vector< std::unique_ptr< Phase > > const & phases )

inline

Definition at line 377 of file MaterialLib/MPL/Property.h.

{
    for (auto& p : properties)
    {
        if (p != nullptr)
        {
            p->setProperties(phases);
        }
    }
}

Referenced by MaterialPropertyLib::Medium::Medium().

voidFractionClosureDiagnostics()

std::string MaterialPropertyLib::voidFractionClosureDiagnostics

(

DriftFluxState const &

state

)

State of the drift-flux closure and its residuals at the ends of the admissible interval \([0, x / S]\), formatted for the message of an assembly aborted because computeVapourVoidFraction() found no admissible void fraction. The residuals are reported for the closure and the interval that computeVapourVoidFraction() actually solves on, that is with the drift aligned with the mixture flow and up to \(x / S\) rather than one.

The caller prepends its own context, the process or boundary condition, the element, and the primary variables it has at hand.

Parameters

state

the state of the closure, reported with its residuals.

Definition at line 69 of file DriftFluxModel.cpp.

{
    DriftFluxState const aligned = alignDriftWithFlow(state);
 
    // computeVapourVoidFraction() accepts a root only from [0, alpha_max], so
    // the sign change has to be reported over that interval. Over [0, 1] it
    // says nothing: the second root of the closure is always larger than one,
    // and the residual changes sign between alpha_max and one whenever the
    // admissible interval holds no root at all.
    double const alpha_max =
        std::min(1., aligned.dryness / closureSlipParameter(aligned));
 
    return fmt::format(
        "dryness {:g}, liquid density {:g} kg/m^3, vapour density {:g} kg/m^3, "
        "profile parameter {:g}, aligned drift flux velocity {:g} m/s. The "
        "closure residual is {:g} at a void fraction of zero and {:g} at the "
        "upper bound {:g} of the admissible interval; a root exists in between "
        "only if the two have opposite signs.",
        aligned.dryness, aligned.liquid_water_density,
        aligned.vapour_water_density, aligned.C_0, aligned.u_gu,
        voidFractionResidual(0., aligned),
        voidFractionResidual(alpha_max, aligned), alpha_max);
}

References alignDriftWithFlow(), MaterialPropertyLib::DriftFluxState::C_0, closureSlipParameter(), MaterialPropertyLib::DriftFluxState::dryness, MaterialPropertyLib::DriftFluxState::liquid_water_density, MaterialPropertyLib::DriftFluxState::u_gu, MaterialPropertyLib::DriftFluxState::vapour_water_density, and voidFractionResidual().

Referenced by ProcessLib::WellboreCompensateNeumannBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), and ProcessLib::WellboreSimulator::WellboreSimulatorFEM< ShapeFunction, GlobalDim >::assemble().

voidFractionQuadratic()

VoidFractionQuadratic MaterialPropertyLib::voidFractionQuadratic

(

DriftFluxState const &

state

)

Coefficients of the drift-flux closure written as a quadratic equation in the void fraction, see computeVapourVoidFraction().

Parameters

state

the state of the closure.

Returns

The coefficients, each in kg/(m^2 s).

Definition at line 45 of file DriftFluxModel.cpp.

{
    double const S = closureSlipParameter(state);
    double const delta =
        state.vapour_water_density - state.liquid_water_density;
 
    return {
        -S * delta * state.v_mix,
        state.v_mix * (state.dryness * delta - S * state.liquid_water_density) -
            state.vapour_water_density * state.u_gu,
        state.dryness * state.v_mix * state.liquid_water_density};
}

References closureSlipParameter(), MaterialPropertyLib::DriftFluxState::dryness, MaterialPropertyLib::DriftFluxState::liquid_water_density, MaterialPropertyLib::DriftFluxState::u_gu, MaterialPropertyLib::DriftFluxState::v_mix, and MaterialPropertyLib::DriftFluxState::vapour_water_density.

Referenced by computeVapourVoidFraction().

voidFractionResidual()

double MaterialPropertyLib::voidFractionResidual	(	double const	alpha,
		DriftFluxState const &	state )

Residual of the drift-flux closure. Kept for testing and for the residuals reported with a non-solvable state; the void fraction itself is computed in closed form.

Parameters

alpha	the vapour void fraction, dimensionless.
state	the state of the closure.

Returns

The residual in kg^2/(m^5 s), the mass flux of the closure times the liquid density it is written with.

Definition at line 58 of file DriftFluxModel.cpp.

{
    double const rho_mix = alpha * state.vapour_water_density +
                           (1 - alpha) * state.liquid_water_density;
    double const S = closureSlipParameter(state);
 
    return state.liquid_water_density *
           (rho_mix * state.v_mix * (state.dryness - alpha * S) -
            alpha * state.vapour_water_density * state.u_gu);
}

References alpha, closureSlipParameter(), MaterialPropertyLib::DriftFluxState::dryness, MaterialPropertyLib::DriftFluxState::liquid_water_density, MaterialPropertyLib::DriftFluxState::u_gu, MaterialPropertyLib::DriftFluxState::v_mix, and MaterialPropertyLib::DriftFluxState::vapour_water_density.

Referenced by voidFractionClosureDiagnostics().

Variable Documentation

alpha

double MaterialPropertyLib::alpha = 1. / 8.

constexpr

Definition at line 18 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

Referenced by MaterialPropertyLib::SaturationLuMcCartney::capillary_water_content(), computeVapourVoidFraction(), MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::dValue(), mixtureSlipParameter(), MaterialPropertyLib::PengRobinson::value(), MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::value(), and voidFractionResidual().

beta

double MaterialPropertyLib::beta = 1. / 3.

constexpr

Definition at line 19 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

Referenced by MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::dValue(), MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::value(), and MaterialPropertyLib::IAPWSIF97Region4::waterSaturationTemperature().

c

std::array MaterialPropertyLib::c

constexpr

Initial value:

= {1989.41582,    11178.45586,  26923.68994,
                          -28989.28947,  -19797.03646, 28403.32283,
                          -30382.306422, 15210.380}

Definition at line 22 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

                       {1989.41582,    11178.45586,  26923.68994,
                          -28989.28947,  -19797.03646, 28403.32283,
                          -30382.306422, 15210.380};

Referenced by MaterialPropertyLib::PermeabilityMohrCoulombFailureIndexModel< DisplacementDim >::PermeabilityMohrCoulombFailureIndexModel(), checkRequiredProperties(), computeVapourVoidFraction(), createComponents(), createPermeabilityMohrCoulombFailureIndexModel(), MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::dValue(), newComponent(), MaterialPropertyLib::SaturationLuMcCartney::psi_max(), MaterialPropertyLib::AverageMolarMass::value(), MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::value(), and MaterialPropertyLib::SaturationLuMcCartney::zeta_s().

Delta

double MaterialPropertyLib::Delta = 0.79 - beta

constexpr

Definition at line 20 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

Referenced by MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::dValue(), and MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::value().

EmptyVariableArray

const VariableArray MaterialPropertyLib::EmptyVariableArray {}

static

Definition at line 202 of file VariableType.h.

{};

Referenced by MaterialPropertyLib::Property::dValue(), MaterialPropertyLib::Property::initialValue(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, DisplacementDim >::postNonLinearSolverConcrete(), and MaterialPropertyLib::Property::value().

error_info

const char MaterialPropertyLib::error_info[]

staticconstexpr

Initial value:

=
    "The conversion to a Kelvin vector of correct dimensionality is ambiguous."
    "Please use a scalar number for isotropic properties, a three element "
    "array or a 3 x 3 matrix for anisotropic properties."

Definition at line 10 of file FormKelvinVector.cpp.

Referenced by MaterialPropertyLib::FormKelvinVector< GlobalDim >::operator()(), MaterialPropertyLib::FormKelvinVector< GlobalDim >::operator()(), MaterialPropertyLib::FormKelvinVector< GlobalDim >::operator()(), MaterialPropertyLib::FormKelvinVector< GlobalDim >::operator()(), and MaterialPropertyLib::FormKelvinVector< GlobalDim >::operator()().

gibbs_free_energy_

const MaterialLib::Fluid::DimensionLessGibbsFreeEnergyRegion1 MaterialPropertyLib::gibbs_free_energy_

Definition at line 16 of file WaterEnthalpyIAPWSIF97Region1.cpp.

Referenced by MaterialPropertyLib::WaterEnthalpyIAPWSIF97Region1::dValue(), MaterialPropertyLib::WaterEnthalpyIAPWSIF97Region1::value(), MaterialPropertyLib::WaterLiquidDensityIAPWSIF97Region4::value(), and MaterialPropertyLib::WaterLiquidEnthalpyIAPWSIF97Region4::value().

Hi

const double MaterialPropertyLib::Hi[4] = {1.67752, 2.20462, 0.6366564, -0.241605}

static

Definition at line 13 of file WaterViscosityIAPWS.cpp.

{1.67752, 2.20462, 0.6366564, -0.241605};

Referenced by computeBarMu0Factor(), and computedBarMu_dbarT().

Hij

const double MaterialPropertyLib::Hij[6][7]

static

Initial value:

= {
    {0.520094, 0.222531, -0.281378, 0.161913, -0.0325372, 0, 0},
    {0.0850895, 0.999115, -0.906851, 0.257399, 0, 0, 0},
    {-1.08374, 1.88797, -0.772479, 0, 0, 0, 0},
    {-0.289555, 1.26613, -0.489837, 0, 0.0698452, 0, -0.00435673},
    {0, 0, -0.25704, 0, 0, 0.00872102, 0},
    {0, 0.120573, 0, 0, 0, 0, -0.000593264}}

Definition at line 14 of file WaterViscosityIAPWS.cpp.

                                {
    {0.520094, 0.222531, -0.281378, 0.161913, -0.0325372, 0, 0},
    {0.0850895, 0.999115, -0.906851, 0.257399, 0, 0, 0},
    {-1.08374, 1.88797, -0.772479, 0, 0, 0, 0},
    {-0.289555, 1.26613, -0.489837, 0, 0.0698452, 0, -0.00435673},
    {0, 0, -0.25704, 0, 0, 0.00872102, 0},
    {0, 0.120573, 0, 0, 0, 0, -0.000593264}};

Referenced by computeBarMu1Factor(), computedBarMu_dbarRho(), and computedBarMu_dbarT().

I_T

std::array MaterialPropertyLib::I_T

staticconstexpr

Initial value:

= {0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
                                   1, 1, 1, 2, 2, 3, 3, 4, 5, 6}

Definition at line 21 of file WaterTemperatureIAPWSIF97Region1.cpp.

                                {0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
                                   1, 1, 1, 2, 2, 3, 3, 4, 5, 6};

Referenced by computeTemperature().

J_T

std::array MaterialPropertyLib::J_T

staticconstexpr

Initial value:

= {0, 1,  2,  6,  22, 32, 0,  1,  2,  3,
                                   4, 10, 32, 10, 32, 10, 32, 32, 32, 32}

Definition at line 24 of file WaterTemperatureIAPWSIF97Region1.cpp.

                                {0, 1,  2,  6,  22, 32, 0,  1,  2,  3,
                                   4, 10, 32, 10, 32, 10, 32, 32, 32, 32};

Referenced by computeTemperature().

Li

const double MaterialPropertyLib::Li[5]

static

Initial value:

= {2.443221e-3, 1.323095e-2, 6.770357e-3,
                             -3.454586e-3, 4.096266e-4}

Definition at line 14 of file WaterThermalConductivityIAPWS.cpp.

                            {2.443221e-3, 1.323095e-2, 6.770357e-3,
                             -3.454586e-3, 4.096266e-4};

Referenced by computeBarLambda0Factor(), and computedBarLambda_dbarT().

Lij

const double MaterialPropertyLib::Lij[5][6]

static

Initial value:

= {
    {1.60397357, -0.646013523, 0.111443906, 0.102997357, -0.0504123634,
     0.00609859258},
    {2.33771842, -2.78843778, 1.53616167, -0.463045512, 0.0832827019,
     -0.00719201245},
    {2.19650529, -4.54580785, 3.55777244, -1.40944978, 0.275418278,
     -0.0205938816},
    {-1.21051378, 1.60812989, -0.621178141, 0.0716373224, 0, 0},
    {-2.7203370, 4.57586331, -3.18369245, 1.1168348, -0.19268305, 0.012913842}}

Definition at line 16 of file WaterThermalConductivityIAPWS.cpp.

                                {
    {1.60397357, -0.646013523, 0.111443906, 0.102997357, -0.0504123634,
     0.00609859258},
    {2.33771842, -2.78843778, 1.53616167, -0.463045512, 0.0832827019,
     -0.00719201245},
    {2.19650529, -4.54580785, 3.55777244, -1.40944978, 0.275418278,
     -0.0205938816},
    {-1.21051378, 1.60812989, -0.621178141, 0.0716373224, 0, 0},
    {-2.7203370, 4.57586331, -3.18369245, 1.1168348, -0.19268305, 0.012913842}};

Referenced by computeBarLambda1Factor(), computedBarLambda_dbarRho(), and computedBarLambda_dbarT().

max_exp_argument

double MaterialPropertyLib::max_exp_argument

staticconstexpr

Initial value:

=
    std::numeric_limits<double>::max_exponent * std::numbers::ln2

Definition at line 17 of file Sigmoid.cpp.

Referenced by MaterialPropertyLib::Sigmoid::value().

n_T

std::array MaterialPropertyLib::n_T

staticconstexpr

Initial value:

= {
    -0.23872489924521e3,  0.40421188637945e3,   0.11349746881718e3,
    -0.58457616048039e1,  -0.15285482413140e-3, -0.10866707695377e-5,
    -0.13391744872602e2,  0.43211039183559e2,   -0.54010067170506e2,
    0.30535892203916e2,   -0.65964749423638e1,  0.93965400878363e-2,
    0.11573647505340e-6,  -0.25858641282073e-4, -0.40644363084799e-8,
    0.66456186191635e-7,  0.80670734103027e-10, -0.93477771213947e-12,
    0.58265442020601e-14, -0.15020185953503e-16}

Definition at line 12 of file WaterTemperatureIAPWSIF97Region1.cpp.

                                {
    -0.23872489924521e3,  0.40421188637945e3,   0.11349746881718e3,
    -0.58457616048039e1,  -0.15285482413140e-3, -0.10866707695377e-5,
    -0.13391744872602e2,  0.43211039183559e2,   -0.54010067170506e2,
    0.30535892203916e2,   -0.65964749423638e1,  0.93965400878363e-2,
    0.11573647505340e-6,  -0.25858641282073e-4, -0.40644363084799e-8,
    0.66456186191635e-7,  0.80670734103027e-10, -0.93477771213947e-12,
    0.58265442020601e-14, -0.15020185953503e-16};

Referenced by computeTemperature().

property_enum_to_string

const std::array<std::string, PropertyType::number_of_properties> MaterialPropertyLib::property_enum_to_string

static

Definition at line 120 of file PropertyType.h.

                           {{"acentric_factor",
                             "binary_interaction_coefficient",
                             "biot_coefficient",
                             "bishops_effective_stress",
                             "brooks_corey_exponent",
                             "bulk_modulus",
                             "capillary_pressure",
                             "compressibility",
                             "concentration",
                             "critical_density",
                             "critical_pressure",
                             "critical_temperature",
                             "decay_rate",
                             "density",
                             "diffusion",
                             "drhodT",
                             "effective_stress",
                             "enthalpy",
                             "entry_pressure",
                             "evaporation_enthalpy",
                             "fredlund_parameters",
                             "frozen_liquid_saturation",
                             "heat_capacity",
                             "henry_coefficient",
                             "longitudinal_dispersivity",
                             "molality",
                             "molar_mass",
                             "molar_volume",
                             "mole_fraction",
                             "molecular_diffusion",
                             "name",
                             "permeability",
                             "phase_change_expansivity",
                             "phase_velocity",
                             "poissons_ratio",
                             "pore_diffusion",
                             "porosity",
                             "reference_density",
                             "reference_pressure",
                             "reference_temperature",
                             "relative_permeability",
                             "relative_permeability_nonwetting_phase",
                             "residual_gas_saturation",
                             "residual_liquid_saturation",
                             "retardation_factor",
                             "saturation",
                             "saturation_density",
                             "saturation_enthalpy",
                             "saturation_micro",
                             "saturation_temperature",
                             "specific_heat_capacity",
                             "specific_latent_heat",
                             "storage",
                             "storage_contribution",
                             "swelling_stress_rate",
                             "temperature",
                             "thermal_conductivity",
                             "thermal_diffusion_enhancement_factor",
                             "thermal_expansivity",
                             "thermal_expansivity_contribution",
                             "thermal_longitudinal_dispersivity",
                             "thermal_osmosis_coefficient",
                             "thermal_osmosis_permeability",
                             "thermal_transversal_dispersivity",
                             "tortuosity",
                             "transport_porosity",
                             "transversal_dispersivity",
                             "vapour_pressure",
                             "viscosity",
                             "volume_fraction",
                             "youngs_modulus"}};

Referenced by checkRequiredProperties(), checkRequiredProperties(), checkRequiredProperties(), ProcessLib::checkThermoOsmosisProperties(), convertStringToProperty(), anonymous_namespace{PhaseTransition.cpp}::findComponentIndex(), MaterialPropertyLib::Component::property(), MaterialPropertyLib::Medium::property(), MaterialPropertyLib::Phase::property(), and MaterialPropertyLib::VolumeFractionAverage::setProperties().

ref_p_

double MaterialPropertyLib::ref_p_ = 1.653e7

staticconstexpr

reference pressure in Pa.

Definition at line 19 of file WaterEnthalpyIAPWSIF97Region1.cpp.

Referenced by MaterialPropertyLib::WaterEnthalpyIAPWSIF97Region1::dValue(), MaterialPropertyLib::WaterEnthalpyIAPWSIF97Region1::value(), MaterialPropertyLib::WaterLiquidDensityIAPWSIF97Region4::value(), MaterialPropertyLib::WaterLiquidEnthalpyIAPWSIF97Region4::value(), MaterialPropertyLib::WaterTemperatureIAPWSIF97Region1::value(), MaterialPropertyLib::WaterVapourDensityIAPWSIF97Region4::value(), and MaterialPropertyLib::WaterVapourEnthalpyIAPWSIF97Region4::value().

ref_T_

double MaterialPropertyLib::ref_T_ = 1386

staticconstexpr

reference temperature in K.

Definition at line 18 of file WaterEnthalpyIAPWSIF97Region1.cpp.

Referenced by MaterialPropertyLib::WaterEnthalpyIAPWSIF97Region1::dValue(), MaterialPropertyLib::WaterEnthalpyIAPWSIF97Region1::value(), MaterialPropertyLib::WaterLiquidDensityIAPWSIF97Region4::value(), MaterialPropertyLib::WaterLiquidEnthalpyIAPWSIF97Region4::value(), MaterialPropertyLib::WaterVapourDensityIAPWSIF97Region4::value(), and MaterialPropertyLib::WaterVapourEnthalpyIAPWSIF97Region4::value().

symmetric_tensor_size

template<int GlobalDim>

int MaterialPropertyLib::symmetric_tensor_size

constexpr

Initial value:

=
    MathLib::KelvinVector::kelvin_vector_dimensions(GlobalDim)

Definition at line 14 of file GetSymmetricTensor.h.

T_c

double MaterialPropertyLib::T_c

constexpr

Initial value:

=
    373.92 + MaterialLib::PhysicalConstant::CelsiusZeroInKelvin

Critical temperature.

Definition at line 16 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

Referenced by MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::dValue(), and MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::value().

unused_dt

double MaterialPropertyLib::unused_dt = std::numeric_limits<double>::quiet_NaN()

staticconstexpr

Definition at line 22 of file Sigmoid.cpp.

Referenced by MaterialPropertyLib::Sigmoid::d2Value(), and MaterialPropertyLib::Sigmoid::dValue().

variable_enum_to_string

const std::array<std::string, static_cast<int>(Variable::number_of_variables)> MaterialPropertyLib::variable_enum_to_string

static

Initial value:

{{"capillary_pressure",
                             "concentration",
                             "deformation_gradient",
                             "density",
                             "effective_pore_pressure",
                             "enthalpy",
                             "enthalpy_of_evaporation",
                             "equivalent_plastic_strain",
                             "fracture_aperture",
                             "frozen_liquid_saturation",
                             "grain_compressibility",
                             "liquid_phase_pressure",
                             "liquid_saturation",
                             "mechanical_strain",
                             "molar_mass",
                             "molar_mass_derivative",
                             "molar_fraction",
                             "gas_phase_pressure",
                             "porosity",
                             "solid_grain_pressure",
                             "stress",
                             "temperature",
                             "total_strain",
                             "total_stress",
                             "transport_porosity",
                             "vapour_pressure",
                             "volumetric_mechanical_strain",
                             "volumetric_strain"}}

Definition at line 55 of file VariableType.h.

                           {{"capillary_pressure",
                             "concentration",
                             "deformation_gradient",
                             "density",
                             "effective_pore_pressure",
                             "enthalpy",
                             "enthalpy_of_evaporation",
                             "equivalent_plastic_strain",
                             "fracture_aperture",
                             "frozen_liquid_saturation",
                             "grain_compressibility",
                             "liquid_phase_pressure",
                             "liquid_saturation",
                             "mechanical_strain",
                             "molar_mass",
                             "molar_mass_derivative",
                             "molar_fraction",
                             "gas_phase_pressure",
                             "porosity",
                             "solid_grain_pressure",
                             "stress",
                             "temperature",
                             "total_strain",
                             "total_stress",
                             "transport_porosity",
                             "vapour_pressure",
                             "volumetric_mechanical_strain",
                             "volumetric_strain"}};

Referenced by MaterialPropertyLib::ScalarCopyOp::apply(), convertStringToVariable(), MaterialPropertyLib::Function::d2Value(), MaterialPropertyLib::Function::dValue(), and MaterialPropertyLib::PerThreadData::updateNonScalarVariables().