MaterialPropertyLib Namespace Reference

Classes
class	Component
	This class defines components (substances). More...
struct	Water
class	MaterialSpatialDistributionMap
class	Medium
class	Phase
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	SaturationBrooksCorey
	A well known soil characteristics function. More...
class	SaturationExponential
	A simplistic soil characteristics function. More...
class	SaturationLiakopoulos
	A well known soil characteristics function. More...
class	SaturationVanGenuchten
	The van Genuchten capillary pressure model. More...
class	ClausiusClapeyron
struct	ZeroInitPropertyDataType
class	Constant
class	Curve
class	WaterVapourDensity
	A model for water vapour density in the unsaturated porous media. More...
class	DupuitPermeability
class	EffectiveThermalConductivityPorosityMixing
class	EmbeddedFracturePermeability
	Permeability model as proposed by Olivella&Alonso. More...
class	LinearWaterVapourLatentHeat
	An empirical function for the latent heat of vaporization of liquid water, which is given by [27] p.786f. More...
class	WaterVapourLatentHeatWithCriticalTemperature
	A latent heat model of vaporisation of water considering the critical temperature. More...
struct	ExponentData
class	Exponential
class	Function
class	GasPressureDependentPermeability
	A gas pressure dependent intrinsic permeability model. More...
class	IdealGasLaw
	Density function for ideal gases. More...
class	KozenyCarmanModel
	Kozeny-Carman equation. More...
struct	IndependentVariable
class	Linear
class	OrthotropicEmbeddedFracturePermeability
	Extended Permeability model based on Olivella&Alonso. More...
class	Parameter
class	PermeabilityMohrCoulombFailureIndexModel
	A failure index dependent permeability model [33]. More...
class	PermeabilityOrthotropicPowerLaw
class	PorosityFromMassBalance
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	RelPermLiakopoulos
	Relative permeability function for the wetting phase of the Liakopoulos experiment. More...
class	RelPermNonWettingPhaseVanGenuchtenMualem
class	RelPermUdell
class	RelPermUdellNonwettingPhase
class	RelPermVanGenuchten
class	SaturationDependentSwelling
class	SaturationDependentThermalConductivity
class	StrainDependentPermeability
	A strain dependent intrinsic permeability model. More...
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	TemperatureDependentDiffusion
class	SoilThermalConductivitySomerton
	A saturation dependent thermal conductivity model for soil. More...
class	TransportPorosityFromMassBalance
class	VapourDiffusionFEBEX
	FEBEX type Vapour diffusion. More...
class	VapourDiffusionPMQ
	The Penman-Millington-Quirk (PMQ) Vapour diffusion model. More...
class	Property
struct	FormEigenTensor
struct	FormEigenVector
struct	FormKelvinVectorFromThermalExpansivity
struct	GetSymmetricTensor

Typedefs
using	PropertyArray = std::array< std::unique_ptr< Property >, PropertyType::number_of_properties >
using	PropertyDataType = 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 > >
template<int GlobalDim>
using	SymmetricTensor = Eigen::Matrix< double, symmetric_tensor_size< GlobalDim >, 1 >
using	Pair = std::array< double, 2 >
using	Vector = std::array< double, 3 >
using	SymmTensor = std::array< double, 6 >
using	Tensor2d = std::array< double, 4 >
	Very simple 2d tensor data type for holding tensor components. More...
using	Tensor = std::array< double, 9 >
using	VariableType = std::variant< std::monostate, double, Vector, Eigen::Matrix< double, 4, 1 >, Eigen::Matrix< double, 6, 1 > >
using	VariableArray = std::array< VariableType, static_cast< int >(Variable::number_of_variables)>

Enumerations
enum	PropertyType : int {   acentric_factor , binary_interaction_coefficient , biot_coefficient , bishops_effective_stress ,   brooks_corey_exponent , bulk_modulus , capillary_pressure , critical_density ,   critical_pressure , critical_temperature , compressibility , concentration ,   decay_rate , density , diffusion , drhodT ,   effective_stress , entry_pressure , evaporation_enthalpy , fredlund_parameters ,   heat_capacity , latent_heat , longitudinal_dispersivity , molality ,   molar_mass , molar_volume , mole_fraction , molecular_diffusion ,   name , permeability , phase_velocity , pore_diffusion ,   poissons_ratio , porosity , reference_density , reference_temperature ,   reference_pressure , relative_permeability , relative_permeability_nonwetting_phase , residual_gas_saturation ,   residual_liquid_saturation , retardation_factor , saturation , saturation_micro ,   specific_heat_capacity , specific_latent_heat , storage , storage_contribution ,   swelling_stress_rate , thermal_conductivity , thermal_diffusion_enhancement_factor , thermal_expansivity ,   thermal_expansivity_contribution , thermal_longitudinal_dispersivity , thermal_osmosis_coefficient , thermal_transversal_dispersivity ,   transport_porosity , transversal_dispersivity , vapour_pressure , vapour_density ,   vapour_diffusion , viscosity , volume_fraction , youngs_modulus ,   number_of_properties }
enum class	Variable : int {   capillary_pressure , concentration , density , displacement ,   effective_pore_pressure , enthalpy_of_evaporation , equivalent_plastic_strain , grain_compressibility ,   liquid_phase_pressure , liquid_saturation , mechanical_strain , molar_mass ,   molar_fraction , phase_pressure , porosity , solid_grain_pressure ,   stress , temperature , total_strain , total_stress ,   transport_porosity , vapour_pressure , volumetric_strain , number_of_variables }

Functions
template<typename ContainerMedium , typename ContainerSolid , typename ContainerLiquid >
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)
std::unique_ptr< Component >	newComponent (std::string const &component_name, bool &isCustomComponent)
template<typename Container >
void	checkRequiredProperties (Component const &c, Container const &required_properties)
std::vector< std::unique_ptr< Component > >	createComponents (int const geometry_dimension, std::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &curves)
std::unique_ptr< MaterialSpatialDistributionMap >	createMaterialSpatialDistributionMap (std::map< int, std::shared_ptr< Medium >> const &media, MeshLib::Mesh const &mesh)
std::unique_ptr< Medium >	createMedium (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::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 >> const &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 >> const &parameters, ParameterLib::CoordinateSystem const *const local_coordinate_system, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &curves)
Phase const &	fluidPhase (Medium const &medium)
	Returns a gas or aqueous liquid phase of the given medium. More...
template<typename Container >
void	checkRequiredProperties (Medium const &medium, Container const &required_properties)
template<typename Container >
void	checkRequiredProperties (Phase const &phase, Container 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< SaturationVanGenuchten >	createSaturationVanGenuchten (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< 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::unique_ptr< Exponential >	createExponential (BaseLib::ConfigTree const &config)
std::unique_ptr< Function >	createFunction (BaseLib::ConfigTree const &config)
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< 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 >	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< SaturationDependentThermalConductivity >	createSaturationDependentThermalConductivity (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 >	createWaterVapourDensity (BaseLib::ConfigTree const &config)
static double	saturatedVaporDensity (double const T)
	\(\rho_{vS}\) More...
static double	dsaturatedVaporDensitydT (double const T)
	\(\frac{\partial \rho_{vS}}{\partial T}\) More...
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 >	createWaterVapourLatentHeatWithCriticalTemperature (BaseLib::ConfigTree const &config)
template<typename T >
static std::vector< exprtk::expression< T > >	compileExpressions (exprtk::symbol_table< T > &symbol_table, std::vector< std::string > const &string_expressions)
static void	updateVariableValues (std::vector< std::pair< int, double * >> const &symbol_values, VariableArray const &variable_array)
static PropertyDataType	evaluateExpressions (std::vector< std::pair< int, double * >> const &symbol_values, VariableArray const &variable_array, std::vector< exprtk::expression< double >> const &expressions)
static std::vector< std::string >	collectVariables (std::vector< std::string > const &value_string_expressions, std::vector< std::pair< std::string, std::vector< std::string >>> const &dvalue_string_expressions)
std::unique_ptr< RelPermBrooksCorey >	createRelPermBrooksCorey (BaseLib::ConfigTree const &config)
std::unique_ptr< RelPermBrooksCoreyNonwettingPhase >	createRelPermBrooksCoreyNonwettingPhase (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)
std::unique_ptr< Property >	createLinearSaturationSwellingStress (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createSoilThermalConductivitySomerton (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 >	createVapourDiffusionFEBEX (BaseLib::ConfigTree const &config)
std::unique_ptr< Property >	createVapourDiffusionPMQ (BaseLib::ConfigTree const &config)
PropertyDataType	fromVector (std::vector< double > const &values)
void	overwriteExistingProperties (PropertyArray &properties, PropertyArray &new_properties, std::variant< Medium *, Phase *, Component * > scale_pointer)
PropertyType	convertStringToProperty (std::string const &string)
void	checkVanGenuchtenExponentRange (const double m)
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<int GlobalDim>
Eigen::Matrix< double, GlobalDim, GlobalDim >	formEigenTensor (MaterialPropertyLib::PropertyDataType const &values)
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<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 >	formKelvinVectorFromThermalExpansivity (MaterialPropertyLib::PropertyDataType const &values)
	A function to form a Kelvin vector from thermal expansivity for thermal strain. More...
template MathLib::KelvinVector::KelvinVectorType< 2 >	formKelvinVectorFromThermalExpansivity< 2 > (MaterialPropertyLib::PropertyDataType const &values)
template MathLib::KelvinVector::KelvinVectorType< 3 >	formKelvinVectorFromThermalExpansivity< 3 > (MaterialPropertyLib::PropertyDataType const &values)
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)
Variable	convertStringToVariable (std::string const &string)

Variables
constexpr double	T_c
	Critical temperature. More...
constexpr double	alpha = 1. / 8.
constexpr double	beta = 1. / 3.
constexpr double	Delta = 0.79 - beta
constexpr std::array	c
static const std::array< std::string, PropertyType::number_of_properties >	property_enum_to_string
static 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

Typedef Documentation

Pair

using MaterialPropertyLib::Pair = typedef std::array<double, 2>

Very simple vector data type for holding a pair of values.

Definition at line 24 of file VariableType.h.

PropertyArray

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

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 42 of file CreateProperty.h.

PropertyDataType

using MaterialPropertyLib::PropertyDataType = typedef 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> >

Definition at line 31 of file Property.h.

SymmetricTensor

template<int GlobalDim>

using MaterialPropertyLib::SymmetricTensor = typedef Eigen::Matrix<double, symmetric_tensor_size<GlobalDim>, 1>

Definition at line 26 of file GetSymmetricTensor.h.

SymmTensor

using MaterialPropertyLib::SymmTensor = typedef std::array<double, 6>

Simple symmetric tensor data type for holding xx, yy, zz, xy, xz, yz tensor components.

Definition at line 32 of file VariableType.h.

Tensor

using MaterialPropertyLib::Tensor = typedef std::array<double, 9>

Very simple tensor data type for holding tensor components.

Definition at line 39 of file VariableType.h.

Tensor2d

using MaterialPropertyLib::Tensor2d = typedef std::array<double, 4>

Very simple 2d tensor data type for holding tensor components.

Definition at line 35 of file VariableType.h.

VariableArray

using MaterialPropertyLib::VariableArray = typedef std::array<VariableType, static_cast<int>(Variable::number_of_variables)>

The VariableArray is a std::array of fixed size. Its size is determined by the Variable enumerator list. Data type of that array is defined by the VariableType definition.

Definition at line 107 of file VariableType.h.

VariableType

using MaterialPropertyLib::VariableType = typedef std::variant<std::monostate, double, Vector, Eigen::Matrix<double, 4, 1>, Eigen::Matrix<double, 6, 1> >

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

Definition at line 100 of file VariableType.h.

Vector

using MaterialPropertyLib::Vector = typedef std::array<double, 3>

Very simple vector data type for holding vector components.

Definition at line 28 of file VariableType.h.

Enumeration Type Documentation

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
critical_density
critical_pressure
critical_temperature
compressibility
concentration	used to specify decay rate of a substance.
decay_rate
density
diffusion
drhodT
effective_stress
entry_pressure
evaporation_enthalpy
fredlund_parameters
heat_capacity
latent_heat
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_velocity
pore_diffusion	ion diffusivity in the porous medium with account of the effect of tortuosity and connectivity.
poissons_ratio
porosity
reference_density
reference_temperature
reference_pressure
relative_permeability
relative_permeability_nonwetting_phase
residual_gas_saturation
residual_liquid_saturation
retardation_factor	specify retardation factor used in component transport process.
saturation
saturation_micro	capillary pressure saturation relationship for microstructure.
specific_heat_capacity
specific_latent_heat
storage
storage_contribution
swelling_stress_rate
thermal_conductivity
thermal_diffusion_enhancement_factor	Thermal diffusion enhancement factor for water vapor flow.
thermal_expansivity
thermal_expansivity_contribution
thermal_longitudinal_dispersivity
thermal_osmosis_coefficient
thermal_transversal_dispersivity
transport_porosity
transversal_dispersivity	used to compute the hydrodynamic dispersion tensor.
vapour_pressure
vapour_density
vapour_diffusion
viscosity
volume_fraction
youngs_modulus
number_of_properties

Definition at line 32 of file PropertyType.h.

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

Variable

enum MaterialPropertyLib::Variable : int

strong

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

Enumerator
capillary_pressure
concentration
density
displacement
effective_pore_pressure
enthalpy_of_evaporation
equivalent_plastic_strain
grain_compressibility
liquid_phase_pressure
liquid_saturation
mechanical_strain
molar_mass
molar_fraction
phase_pressure
porosity
solid_grain_pressure
stress
temperature
total_strain
total_stress
transport_porosity
vapour_pressure
volumetric_strain
number_of_variables

Definition at line 44 of file VariableType.h.

{
    capillary_pressure,
    concentration,
    density,
    displacement,
    effective_pore_pressure,
    enthalpy_of_evaporation,
    equivalent_plastic_strain,
    grain_compressibility,
    liquid_phase_pressure,
    liquid_saturation,
    mechanical_strain,
    molar_mass,
    molar_fraction,
    phase_pressure,
    porosity,
    solid_grain_pressure,
    stress,
    temperature,
    total_strain,
    total_stress,
    transport_porosity,
    vapour_pressure,
    volumetric_strain,
    number_of_variables
};

Function Documentation

checkMaterialSpatialDistributionMap()

template<typename ContainerMedium , typename ContainerSolid , typename ContainerLiquid >

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
	)

Definition at line 22 of file CheckMaterialSpatialDistributionMap.h.

{
    for (auto const& element : mesh.getElements())
    {
        auto const element_id = element->getID();
 
        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("AqueousLiquid"),
                required_properties_liquid_phase);
        }
        if (!required_properties_solid_phase.empty())
        {
            MaterialPropertyLib::checkRequiredProperties(
                medium.phase("Solid"), required_properties_solid_phase);
        }
    }
}

References checkRequiredProperties(), MeshLib::Mesh::getElements(), and MaterialPropertyLib::MaterialSpatialDistributionMap::getMedium().

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

checkRequiredProperties() [1/3]

template<typename Container >

void MaterialPropertyLib::checkRequiredProperties	(	Component const &	c,
		Container const &	required_properties
	)

Definition at line 96 of file Component.h.

{
    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 ProcessLib::TH2M::PhaseTransitionEvaporation::PhaseTransitionEvaporation(), ProcessLib::TH2M::PhaseTransitionModel::PhaseTransitionModel(), ProcessLib::TH2M::PhaseTransitionNone::PhaseTransitionNone(), checkMaterialSpatialDistributionMap(), ProcessLib::ComponentTransport::checkMPLProperties(), ProcessLib::RichardsComponentTransport::anonymous_namespace{CreateRichardsComponentTransportProcess.cpp}::checkMPLProperties(), ProcessLib::StokesFlow::anonymous_namespace{CreateStokesFlowProcess.cpp}::checkMPLProperties(), ProcessLib::RichardsMechanics::checkMPLProperties(), ProcessLib::ThermoMechanics::checkMPLProperties(), ProcessLib::ThermoRichardsFlow::checkMPLProperties(), ProcessLib::ThermoRichardsMechanics::checkMPLProperties(), and ProcessLib::HydroMechanics::createHydroMechanicsProcess().

checkRequiredProperties() [2/3]

template<typename Container >

void MaterialPropertyLib::checkRequiredProperties	(	Medium const &	medium,
		Container const &	required_properties
	)

Definition at line 104 of file Medium.h.

{
    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]

template<typename Container >

void MaterialPropertyLib::checkRequiredProperties	(	Phase const &	phase,
		Container const &	required_properties
	)

Definition at line 75 of file Phase.h.

{
    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], phase.name);
        }
    }
}

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

checkSaturationRange()

void MaterialPropertyLib::checkSaturationRange

(

const double

Sl

)

Definition at line 24 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 18 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().

collectVariables()

static std::vector<std::string> MaterialPropertyLib::collectVariables ( std::vector< std::string > const &  value_string_expressions, std::vector< std::pair< std::string, std::vector< std::string >>> const &  dvalue_string_expressions  )

static

Definition at line 123 of file Function.cpp.

{
    std::vector<std::string> variables;
 
    auto collect_variables = [&](auto string_expressions)
    {
        for (auto const& string_expression : string_expressions)
        {
            if (!exprtk::collect_variables(string_expression, variables))
            {
                OGS_FATAL("Collecting variables didn't work.");
            }
        }
    };
 
    collect_variables(value_string_expressions);
    for (auto const& var_name_string_expression : dvalue_string_expressions)
    {
        collect_variables(var_name_string_expression.second);
    }
 
    BaseLib::makeVectorUnique(variables);
    return variables;
}

References BaseLib::makeVectorUnique(), and OGS_FATAL.

Referenced by MaterialPropertyLib::Function::Function().

compileExpressions()

template<typename T >

static std::vector<exprtk::expression<T> > MaterialPropertyLib::compileExpressions ( exprtk::symbol_table< T > &  symbol_table, std::vector< std::string > const &  string_expressions  )

static

Definition at line 21 of file Function.cpp.

{
    exprtk::parser<T> parser;
 
    std::vector<exprtk::expression<T>> expressions(string_expressions.size());
    expressions.resize(string_expressions.size());
    for (unsigned i = 0; i < string_expressions.size(); ++i)
    {
        expressions[i].register_symbol_table(symbol_table);
        if (!parser.compile(string_expressions[i], expressions[i]))
        {
            OGS_FATAL("Error: {:s}\tExpression: {:s}\n",
                      parser.error(),
                      string_expressions[i]);
        }
    }
    return expressions;
}

References OGS_FATAL.

Referenced by MaterialPropertyLib::Function::Function().

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 18 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 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 VariableType enumerator.

Definition at line 19 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(), createCurve(), createExponential(), and createLinear().

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 18 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 15 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 15 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 20 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 20 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 18 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 >> const &	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 75 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, anonymous_namespace{CreateComponent.cpp}::createComponent(), 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

Definition at line 18 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);
    std::vector<double> const values =
        config.getConfigParameter<std::vector<double>>("value");
 
    return std::make_unique<Constant>(std::move(property_name),
                                      fromVector(values));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), fromVector(), 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 21 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);
    auto const 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__DupuitPermeability__parameter_name

Definition at line 19 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(), 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 17 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
	)

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

Definition at line 17 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.");
    }
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<EmbeddedFracturePermeability<2>>(
            std::move(property_name), n, n_const, k, b0, a, e0);
    }
    return std::make_unique<EmbeddedFracturePermeability<3>>(
        std::move(property_name), n, n_const, k, b0, a, e0);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), 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 18 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");
 
    MaterialPropertyLib::Variable 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

)

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

Definition at line 15 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);
 
    std::vector<std::string> value_expressions;
    auto const& value_config = config.getConfigSubtree("value");
 
    for (auto const& p : value_config.getConfigSubtreeList("expression"))
    {
        value_expressions.emplace_back(p.getValue<std::string>());
    }
 
    // 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");
 
        std::vector<std::string> expressions;
        for (auto const& p : dvalue_config.getConfigSubtreeList("expression"))
        {
            expressions.emplace_back(p.getValue<std::string>());
        }
        dvalue_expressions.emplace_back(std::move(variable_name),
                                        std::move(expressions));
    }
 
    return std::make_unique<MaterialPropertyLib::Function>(
        std::move(property_name), value_expressions, dvalue_expressions);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeList(), 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 26 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(), 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 18 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().

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__KozenyCarmanModel__initial_permeability

Input File Parameter:

properties__property__KozenyCarmanModel__initial_porosity

Definition at line 18 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(), 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

Definition at line 18 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");
 
        MaterialPropertyLib::Variable ivt =
            MaterialPropertyLib::convertStringToVariable(variable_name);
 
        MaterialPropertyLib::IndependentVariable iv{ivt, reference_condition,
                                                    slope};
 
        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 20 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 20 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().

createMaterialSpatialDistributionMap()

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

Definition at line 19 of file CreateMaterialSpatialDistributionMap.cpp.

{
    auto const material_ids = materialIDs(mesh);
 
    int const max_material_id =
        !material_ids
            ? 0
            : *std::max_element(begin(*material_ids), end(*material_ids));
 
    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 std::make_unique<MaterialSpatialDistributionMap>(media,
                                                            material_ids);
}

References MeshLib::materialIDs(), and WARN().

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HeatConduction::createHeatConductionProcess(), ProcessLib::HeatTransportBHE::createHeatTransportBHEProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::LiquidFlow::createLiquidFlowProcess(), ProcessLib::RichardsComponentTransport::createRichardsComponentTransportProcess(), ProcessLib::RichardsFlow::createRichardsFlowProcess(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess(), ProcessLib::SteadyStateDiffusion::createSteadyStateDiffusion(), ProcessLib::StokesFlow::createStokesFlowProcess(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess(), ProcessLib::ThermoRichardsFlow::createThermoRichardsFlowProcess(), ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess(), and ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess().

createMedium()

std::unique_ptr< Medium > MaterialPropertyLib::createMedium	(	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::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 24 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>(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

Definition at line 17 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);
 
    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);
    }
    return std::make_unique<OrthotropicEmbeddedFracturePermeability<3>>(
        std::move(property_name), a_i, e_i0, n_i, k, phi_xy, phi_yz);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), 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 22 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(), BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::peekConfigParameter().

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 25 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(), 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 16 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 >> const &	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 91 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_name = phase->name](auto const& p)
                         { return p->name == phase_name; }) != phases.end())
        {
            OGS_FATAL("Found duplicates with the same phase name tag '{:s}'.",
                      phase->name);
        }
 
        phases.push_back(std::move(phase));
    }
 
    return phases;
}

References anonymous_namespace{CreatePhase.cpp}::createPhase(), and OGS_FATAL.

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 18 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(), 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 >> const &	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 286 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(), and anonymous_namespace{CreateProperty.cpp}::createProperty().

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 16 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");
    if (exponent <= 0.)
    {
        OGS_FATAL("Exponent 'lambda' must be positive.");
    }
 
    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(), OGS_FATAL, 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 20 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");
    if (exponent <= 0.)
    {
        OGS_FATAL("Exponent 'lambda' must be positive.");
    }
 
    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(), 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 16 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

Definition at line 20 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");
 
    return std::make_unique<RelPermNonWettingPhaseVanGenuchtenMualem>(
        property_name, residual_liquid_saturation, residual_gas_saturation,
        exponent, min_relative_permeability);
}

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().

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 18 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 17 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 16 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 16 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 16 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< SaturationDependentThermalConductivity > MaterialPropertyLib::createSaturationDependentThermalConductivity

(

BaseLib::ConfigTree const &

config

)

Input File Parameter:

properties__property__type

Input File Parameter:

properties__property__name

Input File Parameter:

properties__property__SaturationDependentThermalConductivity__dry

Input File Parameter:

properties__property__SaturationDependentThermalConductivity__wet

Definition at line 16 of file CreateSaturationDependentThermalConductivity.cpp.

{
    config.checkConfigParameter("type",
                                "SaturationDependentThermalConductivity");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create saturation dependent thermal_conductivity property {:s}.",
         property_name);
 
    auto const K_dry =
        config.getConfigParameter<double>("dry");
 
    auto const K_wet =
        config.getConfigParameter<double>("wet");
 
    return std::make_unique<
        MaterialPropertyLib::SaturationDependentThermalConductivity>(
        std::move(property_name), K_dry, K_wet);
}

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

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

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 16 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 16 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().

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__p_b

Definition at line 16 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");
    auto const exponent =
        config.getConfigParameter<double>("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, exponent, p_b);
}

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().

createSoilThermalConductivitySomerton()

std::unique_ptr< Property > MaterialPropertyLib::createSoilThermalConductivitySomerton	(	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__SoilThermalConductivitySomerton__dry_thermal_conductivity

Input File Parameter:

properties__property__SoilThermalConductivitySomerton__wet_thermal_conductivity

Definition at line 25 of file CreateSoilThermalConductivitySomerton.cpp.

{
    config.checkConfigParameter("type", "SoilThermalConductivitySomerton");
 
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create SoilThermalConductivitySomerton medium property");
 
    std::string const& dry_thermal_conductivity_parameter_name =
        config.getConfigParameter<std::string>("dry_thermal_conductivity");
    auto const& dry_thermal_conductivity = ParameterLib::findParameter<double>(
        dry_thermal_conductivity_parameter_name, parameters, 0, nullptr);
 
    std::string const& wet_thermal_conductivity_parameter_name =
        config.getConfigParameter<std::string>("wet_thermal_conductivity");
    auto const& wet_thermal_conductivity = ParameterLib::findParameter<double>(
        wet_thermal_conductivity_parameter_name, parameters, 0, nullptr);
 
    if (geometry_dimension == 1)
    {
        return std::make_unique<SoilThermalConductivitySomerton<1>>(
            std::move(property_name),
            dry_thermal_conductivity,
            wet_thermal_conductivity,
            local_coordinate_system);
    }
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<SoilThermalConductivitySomerton<2>>(
            std::move(property_name),
            dry_thermal_conductivity,
            wet_thermal_conductivity,
            local_coordinate_system);
    }
 
    return std::make_unique<SoilThermalConductivitySomerton<3>>(
        std::move(property_name),
        dry_thermal_conductivity,
        wet_thermal_conductivity,
        local_coordinate_system);
}

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 26 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(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

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

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 16 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(), 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 19 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(), 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__tortuosity

Definition at line 20 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");
 
    auto const tortuosity =
        config.getConfigParameter<double>("tortuosity");
 
    return std::make_unique<VapourDiffusionFEBEX>(std::move(property_name),
                                                  tortuosity);
}

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

Definition at line 20 of file CreateVapourDiffusionPMQ.cpp.

{
    config.checkConfigParameter("type", "VapourDiffusionPMQ");
    DBUG("Create VapourDiffusionPMQ phase property");
 
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    return std::make_unique<VapourDiffusionPMQ>(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 20 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().

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 20 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().

dsaturatedVaporDensitydT()

static double MaterialPropertyLib::dsaturatedVaporDensitydT ( double const  T )

static

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

Definition at line 29 of file WaterVapourDensity.cpp.

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

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

evaluateExpressions()

static PropertyDataType MaterialPropertyLib::evaluateExpressions ( std::vector< std::pair< int, double * >> const &  symbol_values, VariableArray const &  variable_array, std::vector< exprtk::expression< double >> const &  expressions  )

static

Definition at line 79 of file Function.cpp.

{
    updateVariableValues(symbol_values, variable_array);
 
    std::vector<double> result(expressions.size());
    std::transform(begin(expressions), end(expressions), begin(result),
                   [](auto const& e) { return e.value(); });
 
    switch (result.size())
    {
        case 1:
        {
            return result[0];
        }
        case 2:
        {
            return Eigen::Vector2d{result[0], result[1]};
        }
        case 3:
        {
            return Eigen::Vector3d{result[0], result[1], result[2]};
        }
        case 4:
        {
            Eigen::Matrix<double, 2, 2> m;
            m = Eigen::Map<Eigen::Matrix<double, 2, 2> const>(result.data(), 2,
                                                              2);
            return m;
        }
        case 9:
        {
            Eigen::Matrix<double, 3, 3> m;
            m = Eigen::Map<Eigen::Matrix<double, 3, 3> const>(result.data(), 3,
                                                              3);
            return m;
        }
    }
    OGS_FATAL("Cannot convert a vector of size {} to a PropertyDataType",
              result.size());
}

References OGS_FATAL, and updateVariableValues().

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

fluidPhase()

Phase const & MaterialPropertyLib::fluidPhase

(

Medium const &

medium

)

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

Definition at line 82 of file Medium.cpp.

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

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

Referenced by ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobianForPressureEquations(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), and ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtDarcyVelocity().

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 19 of file FormEffectiveThermalConductivity.cpp.

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

References porosity.

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
	)

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
	)

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
	)

formEigenTensor()

template<int GlobalDim>

Eigen::Matrix< double, GlobalDim, GlobalDim > MaterialPropertyLib::formEigenTensor

(

MaterialPropertyLib::PropertyDataType const &

values

)

Definition at line 103 of file FormEigenTensor.cpp.

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

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::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble(), ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction, IntegrationMethod >::assemble(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assembleWithJacobian(), MaterialPropertyLib::EmbeddedFracturePermeability< DisplacementDim >::dValue(), MaterialPropertyLib::OrthotropicEmbeddedFracturePermeability< DisplacementDim >::dValue(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::updateConstitutiveVariables(), MaterialPropertyLib::EmbeddedFracturePermeability< DisplacementDim >::value(), and MaterialPropertyLib::PermeabilityMohrCoulombFailureIndexModel< DisplacementDim >::value().

formEigenVector()

template<int GlobalDim>

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

(

MaterialPropertyLib::PropertyDataType const &

values

)

Definition at line 82 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().

formKelvinVectorFromThermalExpansivity()

template<int GlobalDim>

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

(

MaterialPropertyLib::PropertyDataType const &

values

)

A function to form a Kelvin vector from thermal expansivity for thermal strain.

It takes the thermal expansivity, either a scalar number for isotropic thermal expansion or a three element vector for anisotropic thermal expansion, to get a Kelvin vector for thermal strain.

Parameters

values

Thermal expansivity, which can be scalar number or a three element vector.

Returns

Thermal expansivity in Kelvin vector type.

Definition at line 77 of file FormKelvinVectorFromThermalExpansivity.cpp.

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

formKelvinVectorFromThermalExpansivity< 2 >()

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

(

MaterialPropertyLib::PropertyDataType const &

values

)

formKelvinVectorFromThermalExpansivity< 3 >()

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

(

MaterialPropertyLib::PropertyDataType const &

values

)

fromVector()

PropertyDataType MaterialPropertyLib::fromVector

(

std::vector< double > const &

values

)

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

Attention

It cannot distinguish between 2x2 matrix and 4x1 vector.

Definition at line 23 of file 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;
            return M{Eigen::Map<M 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;
            return M{Eigen::Map<M 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::SoilThermalConductivitySomerton< GlobalDimension >::dValue(), MaterialPropertyLib::PorosityFromMassBalance::initialValue(), MaterialPropertyLib::TransportPorosityFromMassBalance::initialValue(), MaterialPropertyLib::DupuitPermeability::value(), MaterialPropertyLib::KozenyCarmanModel::value(), MaterialPropertyLib::GasPressureDependentPermeability< DisplacementDim >::value(), MaterialPropertyLib::OrthotropicEmbeddedFracturePermeability< DisplacementDim >::value(), MaterialPropertyLib::Parameter::value(), MaterialPropertyLib::PermeabilityMohrCoulombFailureIndexModel< DisplacementDim >::value(), MaterialPropertyLib::StrainDependentPermeability< DisplacementDim >::value(), MaterialPropertyLib::SoilThermalConductivitySomerton< GlobalDimension >::value(), and MaterialPropertyLib::TemperatureDependentDiffusion::value().

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 21 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, IntegrationMethod, GlobalDim >::assemble(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assembleWithJacobian(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian().

getSymmetricTensor()

template<int GlobalDim>

SymmetricTensor< GlobalDim > MaterialPropertyLib::getSymmetricTensor

(

MaterialPropertyLib::PropertyDataType const &

values

)

Definition at line 87 of file GetSymmetricTensor.cpp.

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

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()

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

static

Definition at line 34 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().

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).

overwriteExistingProperties()

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

inline

Definition at line 311 of file 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()

static double MaterialPropertyLib::saturatedVaporDensity ( double const  T )

static

\(\rho_{vS}\)

Definition at line 23 of file WaterVapourDensity.cpp.

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

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

updateVariableValues()

static void MaterialPropertyLib::updateVariableValues ( std::vector< std::pair< int, double * >> const &  symbol_values, VariableArray const &  variable_array  )

static

Definition at line 42 of file Function.cpp.

{
    for (auto& index_value_ptr_pair : symbol_values)
    {
        auto const index = index_value_ptr_pair.first;
 
        double* value_ptr = index_value_ptr_pair.second;
        std::visit(
            [&value_ptr, &index](auto&& v)
            {
                using T = std::decay_t<decltype(v)>;
                if constexpr (std::is_same_v<T, std::monostate>)
                {
                    OGS_FATAL(
                        "Function property: variable {:s} value needed for "
                        "evaluation of the expression was not set by the "
                        "caller.",
                        variable_enum_to_string[index]);
                }
                else if constexpr (std::is_same_v<T, double>)
                {
                    *value_ptr = v;
                }
                else
                {
                    OGS_FATAL(
                        "Function property: not implemented handling for a "
                        "type {:s} of variable {:s}.",
                        typeid(T).name(), variable_enum_to_string[index]);
                }
            },
            variable_array[index]);
    }
}

References name, OGS_FATAL, and variable_enum_to_string.

Referenced by evaluateExpressions().

Variable Documentation

alpha

constexpr double MaterialPropertyLib::alpha = 1. / 8.

constexpr

Definition at line 26 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assemble(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble(), ProcessLib::RobinBoundaryConditionLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerFracture< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, GlobalDim >::assembleBlockMatricesWithJacobian(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, GlobalDim >::assembleBlockMatricesWithJacobian(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assembleWithJacobian(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobianForDeformationEquations(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobianForHeatConductionEquations(), MathLib::barycentricPointInTriangle(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculatedSwdP(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculatedSwdX(), ProcessLib::TES::TESFEMReactionAdaptorAdsorption::checkBounds(), ProcessLib::RichardsMechanics::RichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcrete(), MaterialLib::Solids::Ehlers::createEhlers(), ProcessLib::createRobinBoundaryCondition(), MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::dValue(), ProcessLib::HydroMechanics::HydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtDarcyVelocity(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::getIntPtDarcyVelocity(), ParameterLib::TimeDependentHeterogeneousParameter::operator()(), ProcessLib::ThermoMechanicalPhaseField::IntegrationPointData< BMatricesType, ShapeMatrixType, DisplacementDim >::updateConstitutiveRelation(), ProcessLib::RichardsMechanics::updateSwellingStressAndVolumetricStrain(), and MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::value().

beta

constexpr double MaterialPropertyLib::beta = 1. / 3.

constexpr

Definition at line 27 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

Referenced by ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), MathLib::barycentricPointInTriangle(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculatedSwdP(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoMaterialProperties::calculatedSwdX(), MaterialLib::Solids::Ehlers::createEhlers(), MaterialLib::Fluid::createLinearTemperatureDependentDensity(), MaterialLib::Fluid::createLiquidDensity(), MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(), ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowPrhoMaterialProperties(), MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::dValue(), and MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::value().

c

constexpr 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 30 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

Referenced by MathLib::LinearIntervalInterpolation< NUMERIC_TYPE >::LinearIntervalInterpolation(), VtkPointsSource::VtkPointsSource(), VtkPolylinesSource::VtkPolylinesSource(), VtkStationSource::VtkStationSource(), VtkSurfacesSource::VtkSurfacesSource(), GeoLib::OctTree< POINT, MAX_POINTS >::~OctTree(), FileIO::Gocad::GocadSGridReader::addFaceSetQuad(), DetailWindow::addList(), GeoLib::OctTree< POINT, MAX_POINTS >::addPoint(), GeoLib::OctTree< POINT, MAX_POINTS >::addPoint_(), MathLib::addToMatrix(), MathLib::applyKnownSolution(), ProcessLib::TES::TESLocalAssemblerInner< Traits >::assembleIntegrationPoint(), ProcessLib::ThermoMechanics::ThermoMechanicsLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobianForHeatConductionEquations(), MathLib::barycentricPointInTriangle(), MathLib::calcTetrahedronVolume(), MathLib::calcTriangleArea(), ModelTest::checkChildren(), checkRequiredProperties(), GeoLib::Triangle::containsPoint(), createComponents(), NumLib::MeshComponentMap::createParallelMeshComponentMap(), createPermeabilityMohrCoulombFailureIndexModel(), NumLib::MeshComponentMap::createSerialMeshComponentMap(), MathLib::dividedByPlane(), anonymous_namespace{CompareJacobiansJacobianAssembler.cpp}::dump_py(), MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::dValue(), NumLib::SerialExecutor::executeDereferenced(), NumLib::LocalLinearLeastSquaresExtrapolator::extrapolate(), ProcessLib::TH2M::findComponentIndex(), MathLib::gaussPointInTriangle(), MathLib::getAngle(), VtkVisPipeline::getBGColor(), ChemistryLib::PhreeqcIOData::PhreeqcIO::getComponentList(), Adsorption::AdsorptionReaction::getEquilibriumVapourPressure(), Adsorption::AdsorptionReaction::getEvaporationEnthalpy(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), NumLib::getIndices(), ChemistryLib::PhreeqcIOData::PhreeqcIO::getIntPtProcessSolutions(), VtkCompositeElementSelectionFilter::GetLookupTable(), NumLib::LocalToGlobalIndexMap::getNumberOfElementComponents(), NumLib::LocalToGlobalIndexMap::getNumberOfElementDOF(), ExactPredicates::getOrientation2d(), ExactPredicates::getOrientation2dFast(), GeoLib::Grid< POINT >::getPntVecsOfGridCellsIntersectingCube(), MeshLib::ProjectPointOnMesh::getProjectedElement(), MathLib::Nonlinear::RegulaFalsi< SubType, Function >::getResult(), NumLib::getRowColumnIndices(), VtkCompositeColorByHeightFilter::init(), MathLib::initGLTet3X(), MathLib::isCoplanar(), GeoLib::SurfaceGrid::isPointInSurface(), MathLib::isPointInTetrahedron(), MathLib::isPointInTriangle(), MathLib::isPointInTriangleXY(), GeoLib::lineSegmentIntersect(), GeoLib::lineSegmentIntersect2d(), main(), markFaults(), anonymous_namespace{MFront.cpp}::MFrontToOGS(), anonymous_namespace{TESLocalAssembler-impl.h}::ogs5OutMat(), anonymous_namespace{MFront.cpp}::OGSToMFront(), ParameterLib::CurveScaledParameter< T >::operator()(), ParameterLib::MeshElementParameter< T >::operator()(), ParameterLib::MeshNodeParameter< T >::operator()(), ParameterLib::RandomFieldMeshElementParameter< T >::operator()(), FileIO::Gocad::IndexCalculator::operator()(), FileIO::Gocad::operator<<(), MathLib::orientation3d(), StratBar::paint(), FileIO::Gocad::GocadSGridReader::parseFaceSet(), ModelTest::rowsAboutToBeInserted(), ModelTest::rowsAboutToBeRemoved(), ModelTest::rowsInserted(), ModelTest::rowsRemoved(), DiagramList::setColor(), MeshLib::MeshElementGrid::sortElementInGridCells(), splitMaterialIdString(), GeoLib::OctTree< POINT, MAX_POINTS >::splitNode(), MathLib::Nonlinear::RegulaFalsi< SubType, Function >::step(), BaseLib::swapEndianness(), testTriangleIntersectingAABB(), NumLib::SerialExecutor::transformDereferenced(), GeoLib::triangleLineIntersection(), DiagramList::truncateToRange(), ProcessLib::TH2M::TH2MLocalAssembler< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, DisplacementDim >::updateConstitutiveVariables(), MaterialPropertyLib::AverageMolarMass::value(), and MaterialPropertyLib::WaterVapourLatentHeatWithCriticalTemperature::value().

Delta

constexpr double MaterialPropertyLib::Delta = 0.79 - beta

constexpr

Definition at line 28 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

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

error_info

const char MaterialPropertyLib::error_info[]

static

Initial value:

=
    "The thermal expansivity can only be either a scalar number for isotropic "
    "thermal expansion or a three element array for anisotropic thermal "
    "expansion."

Definition at line 18 of file FormKelvinVectorFromThermalExpansivity.cpp.

Referenced by MaterialPropertyLib::FormKelvinVectorFromThermalExpansivity< GlobalDim >::operator()().

property_enum_to_string

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

static

Definition at line 111 of file PropertyType.h.

Referenced by checkRequiredProperties(), convertStringToProperty(), ProcessLib::TH2M::findComponentIndex(), MaterialPropertyLib::Component::property(), MaterialPropertyLib::Medium::property(), and MaterialPropertyLib::Phase::property().

symmetric_tensor_size

template<int GlobalDim>

constexpr int MaterialPropertyLib::symmetric_tensor_size

constexpr

Initial value:

=
    MathLib::KelvinVector::kelvin_vector_dimensions(GlobalDim)

Definition at line 22 of file GetSymmetricTensor.h.

T_c

constexpr double MaterialPropertyLib::T_c

constexpr

Initial value:

=
    373.92 + MaterialLib::PhysicalConstant::CelsiusZeroInKelvin

Critical temperature.

Definition at line 24 of file WaterVapourLatentHeatWithCriticalTemperature.cpp.

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

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",
                             "density",
                             "displacement",
                             "effective_pore_pressure",
                             "enthalpy_of_evaporation",
                             "equivalent_plastic_strain",
                             "grain_compressibility",
                             "liquid_phase_pressure",
                             "liquid_saturation",
                             "mechanical_strain",
                             "molar_mass",
                             "molar_fraction",
                             "phase_pressure",
                             "porosity",
                             "solid_grain_pressure",
                             "stress",
                             "temperature",
                             "total_strain",
                             "total_stress",
                             "transport_porosity",
                             "vapour_pressure",
                             "volumetric_strain"}}

Definition at line 74 of file VariableType.h.

Referenced by convertStringToVariable(), MaterialPropertyLib::Function::dValue(), and updateVariableValues().