OGS
MaterialLib::Fluid Namespace Reference

Namespaces

namespace  DimensionlessGibbsFreeEnergyRegion2
 

Classes

class  ConstantFluidProperty
 Constant fluid properties. More...
 
struct  DimensionLessGibbsFreeEnergyRegion1
 
class  FluidProperties
 Base class of fluid properties. More...
 
class  FluidPropertiesWithDensityDependentModels
 
class  FluidProperty
 Base class of fluid properties. More...
 
class  IdealGasLaw
 Fluid density by ideal gas law. More...
 
class  LinearConcentrationAndPressureDependentDensity
 
class  LinearConcentrationDependentDensity
 
class  LinearPressureDependentViscosity
 
class  LinearTemperatureDependentDensity
 Linear temperature dependent density model. More...
 
class  LiquidDensity
 
class  PrimaryVariableDependentFluidProperties
 
class  TemperatureDependentViscosity
 
class  VogelsLiquidDynamicViscosity
 
struct  VogelsViscosityConstantsCH4
 
struct  VogelsViscosityConstantsCO2
 
struct  VogelsViscosityConstantsWater
 
class  WaterVaporProperties
 

Enumerations

enum class  FluidPropertyType {
  Density = 0 , Viscosity = 1 , HeatCapacity = 2 , ThermalConductivity = 3 ,
  Concentration = 4 , number_of_property_types = 5
}
 Fluid property type. More...
 
enum class  PropertyVariableType {
  T = 0 , p = 1 , rho = p , C = 2 ,
  number_of_variables = 3
}
 Variable that determine the property. More...
 

Functions

static std::unique_ptr< FluidPropertycreateLiquidDensity (BaseLib::ConfigTree const &config)
 
static std::unique_ptr< FluidPropertycreateLinearTemperatureDependentDensity (BaseLib::ConfigTree const &config)
 
static std::unique_ptr< FluidPropertycreateLinearConcentrationDependentDensity (BaseLib::ConfigTree const &config)
 
static std::unique_ptr< FluidPropertycreateLinearConcentrationAndPressureDependentDensity (BaseLib::ConfigTree const &config)
 
std::unique_ptr< FluidPropertycreateFluidDensityModel (BaseLib::ConfigTree const &config)
 
std::unique_ptr< FluidPropertiescreateFluidProperties (BaseLib::ConfigTree const &config)
 
std::unique_ptr< FluidPropertycreateSpecificFluidHeatCapacityModel (BaseLib::ConfigTree const &config)
 
std::unique_ptr< FluidPropertycreateFluidThermalConductivityModel (BaseLib::ConfigTree const &config)
 
static std::unique_ptr< FluidPropertycreateLinearPressureDependentViscosity (BaseLib::ConfigTree const &config)
 
static std::unique_ptr< FluidPropertycreateTemperatureDependentViscosity (BaseLib::ConfigTree const &config)
 
std::unique_ptr< FluidPropertycreateViscosityModel (BaseLib::ConfigTree const &config)
 

Variables

const unsigned FluidPropertyTypeNumber
 
static const double ni [34]
 
static const double li [34]
 
static const double ji [34]
 
const unsigned PropertyVariableNumber
 
static const double temperature_0 = 373.15
 
static const double p_0 = 101325.0
 reference temperature in [K]
 
static const double h_wg = 2258000.0
 reference pressure
 

Enumeration Type Documentation

◆ FluidPropertyType

Fluid property type.

Enumerator
Density 
Viscosity 
HeatCapacity 
ThermalConductivity 
Concentration 
number_of_property_types 

Number of property types.

Definition at line 26 of file FluidProperties.h.

◆ PropertyVariableType

Variable that determine the property.

Enumerator

temperature.

pressure.

rho 

density. For some models, rho substitutes p

concentration.

number_of_variables 

Number of property variables.

Definition at line 20 of file PropertyVariableType.h.

21{
22 T = 0,
23 p = 1,
24 rho = p,
25 C = 2,
27};
@ rho
density. For some models, rho substitutes p
@ number_of_variables
Number of property variables.

Function Documentation

◆ createFluidDensityModel()

std::unique_ptr< FluidProperty > MaterialLib::Fluid::createFluidDensityModel ( BaseLib::ConfigTree const &  config)

Create a density model

Parameters
configConfigTree object has a tag of <density>
Input File Parameter:
material__fluid__density__type
Input File Parameter:
material__fluid__density__type
Input File Parameter:
material__fluid__density__Constant__value
Input File Parameter:
material__fluid__density__type
Input File Parameter:
material__fluid__density__IdealGasLaw__molar_mass

Definition at line 125 of file CreateFluidDensityModel.cpp.

127{
129 auto const type = config.peekConfigParameter<std::string>("type");
130
131 if (type == "Constant")
132 {
134 config.checkConfigParameter("type", "Constant");
135 return std::make_unique<ConstantFluidProperty>(
137 config.getConfigParameter<double>("value"));
138 }
139 if (type == "LiquidDensity")
140 {
141 return createLiquidDensity(config);
142 }
143 if (type == "TemperatureDependent")
144 {
145 return createLinearTemperatureDependentDensity(config);
146 }
147 if (type == "ConcentrationDependent")
148 {
150 }
151 if (type == "ConcentrationAndPressureDependent")
152 {
154 }
155 if (type == "IdealGasLaw")
156 {
158 config.checkConfigParameter("type", "IdealGasLaw");
159 return std::make_unique<IdealGasLaw>(
161 config.getConfigParameter<double>("molar_mass"));
162 }
163
164 OGS_FATAL(
165 "The density type {:s} is unavailable.\n"
166 "The available types are: \n\tConstant, \n\tLiquidDensity, "
167 "\n\tTemperatureDependent, \n\tIdealGasLaw."
168 "\n\tWaterDensityIAPWSIF97Region1\n",
169 type.data());
170}
#define OGS_FATAL(...)
Definition: Error.h:26
static std::unique_ptr< FluidProperty > createLinearConcentrationDependentDensity(BaseLib::ConfigTree const &config)
static std::unique_ptr< FluidProperty > createLinearConcentrationAndPressureDependentDensity(BaseLib::ConfigTree const &config)

References BaseLib::ConfigTree::checkConfigParameter(), createLinearConcentrationAndPressureDependentDensity(), createLinearConcentrationDependentDensity(), createLinearTemperatureDependentDensity(), createLiquidDensity(), BaseLib::ConfigTree::getConfigParameter(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by createFluidProperties().

◆ createFluidProperties()

std::unique_ptr< FluidProperties > MaterialLib::Fluid::createFluidProperties ( BaseLib::ConfigTree const &  config)

Create an instance of class FluidProperties

Parameters
configConfigTree object has tags of <fluid>
Input File Parameter:
material__fluid__density
Input File Parameter:
material__fluid__viscosity
Input File Parameter:
material__fluid__specific_heat_capacity
Input File Parameter:
material__fluid__thermal_conductivity

Definition at line 29 of file CreateFluidProperties.cpp.

31{
33 auto const& rho_conf = config.getConfigSubtree("density");
34 auto liquid_density = MaterialLib::Fluid::createFluidDensityModel(rho_conf);
35
37 auto const& mu_conf = config.getConfigSubtree("viscosity");
38 auto viscosity = MaterialLib::Fluid::createViscosityModel(mu_conf);
39 const bool is_mu_density_dependent =
40 (viscosity->getName().find("density dependent") != std::string::npos);
41
42 bool is_cp_density_dependent = false;
43 std::unique_ptr<MaterialLib::Fluid::FluidProperty> specific_heat_capacity =
44 nullptr;
45 auto heat_capacity__opt_conf =
47 config.getConfigSubtreeOptional("specific_heat_capacity");
48 if (heat_capacity__opt_conf)
49 {
50 const auto& heat_capacity_conf = *heat_capacity__opt_conf;
51 specific_heat_capacity =
52 createSpecificFluidHeatCapacityModel(heat_capacity_conf);
53 is_cp_density_dependent =
54 (specific_heat_capacity->getName().find("density dependent") !=
55 std::string::npos);
56 }
57
58 bool is_KT_density_dependent = false;
59 std::unique_ptr<MaterialLib::Fluid::FluidProperty> thermal_conductivity =
60 nullptr;
61 auto const& thermal_conductivity_opt_conf =
63 config.getConfigSubtreeOptional("thermal_conductivity");
64 if (thermal_conductivity_opt_conf)
65 {
66 auto const& thermal_conductivity_conf = *thermal_conductivity_opt_conf;
67 thermal_conductivity =
69 thermal_conductivity_conf);
70 is_KT_density_dependent =
71 (specific_heat_capacity->getName().find("density dependent") !=
72 std::string::npos);
73 }
74
75 if (is_mu_density_dependent || is_cp_density_dependent ||
76 is_KT_density_dependent)
77 {
78 return std::make_unique<
80 std::move(liquid_density), std::move(viscosity),
81 std::move(specific_heat_capacity), std::move(thermal_conductivity),
82 is_mu_density_dependent, is_cp_density_dependent,
83 is_KT_density_dependent);
84 }
85
86 return std::make_unique<
88 std::move(liquid_density), std::move(viscosity),
89 std::move(specific_heat_capacity), std::move(thermal_conductivity));
90}
std::unique_ptr< FluidProperty > createFluidDensityModel(BaseLib::ConfigTree const &config)
std::unique_ptr< FluidProperty > createSpecificFluidHeatCapacityModel(BaseLib::ConfigTree const &config)
std::unique_ptr< FluidProperty > createFluidThermalConductivityModel(BaseLib::ConfigTree const &config)
std::unique_ptr< FluidProperty > createViscosityModel(BaseLib::ConfigTree const &config)

References createFluidDensityModel(), createFluidThermalConductivityModel(), createSpecificFluidHeatCapacityModel(), createViscosityModel(), BaseLib::ConfigTree::getConfigSubtree(), and BaseLib::ConfigTree::getConfigSubtreeOptional().

◆ createFluidThermalConductivityModel()

std::unique_ptr< FluidProperty > MaterialLib::Fluid::createFluidThermalConductivityModel ( BaseLib::ConfigTree const &  config)

Create a thermal conductivity model

Parameters
configConfigTree object has a tag of <thermal_conductivity>
Input File Parameter:
material__fluid__thermal_conductivity__type
Input File Parameter:
material__fluid__thermal_conductivity__Constant__value

Definition at line 24 of file CreateFluidThermalConductivityModel.cpp.

26{
28 auto const type = config.getConfigParameter<std::string>("type");
29
30 if (type == "Constant")
31 {
32 return std::make_unique<ConstantFluidProperty>(
34 config.getConfigParameter<double>("value"));
35 }
36 // TODO: add more models
37
39 "The viscosity type {:s} is unavailable.\n"
40 "The available type is \n\tConstant\n",
41 type.data());
42}

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

Referenced by createFluidProperties().

◆ createLinearConcentrationAndPressureDependentDensity()

static std::unique_ptr< FluidProperty > MaterialLib::Fluid::createLinearConcentrationAndPressureDependentDensity ( BaseLib::ConfigTree const &  config)
static
Input File Parameter:
material__fluid__density__type
Input File Parameter:
material__fluid__density__ConcentrationAndPressureDependent__reference_density
Input File Parameter:
material__fluid__density__ConcentrationAndPressureDependent__reference_concentration
Input File Parameter:
material__fluid__density__ConcentrationAndPressureDependent__fluid_density_concentration_difference_ratio
Input File Parameter:
material__fluid__density__ConcentrationAndPressureDependent__reference_pressure
Input File Parameter:
material__fluid__density__ConcentrationAndPressureDependent__fluid_density_pressure_difference_ratio

Definition at line 94 of file CreateFluidDensityModel.cpp.

96{
98 config.checkConfigParameter("type", "ConcentrationAndPressureDependent");
99
100 const auto reference_density =
102 config.getConfigParameter<double>("reference_density");
103 const auto reference_concentration =
105 config.getConfigParameter<double>("reference_concentration");
106 const auto fluid_density_concentration_difference_ratio =
108 config.getConfigParameter<double>(
109 "fluid_density_concentration_difference_ratio");
110 const auto reference_pressure =
112 config.getConfigParameter<double>("reference_pressure");
113 const auto fluid_density_pressure_difference_ratio =
115 config.getConfigParameter<double>(
116 "fluid_density_pressure_difference_ratio");
117 return std::make_unique<LinearConcentrationAndPressureDependentDensity>(
118 reference_density,
119 reference_concentration,
120 fluid_density_concentration_difference_ratio,
121 reference_pressure,
122 fluid_density_pressure_difference_ratio);
123}

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

Referenced by createFluidDensityModel().

◆ createLinearConcentrationDependentDensity()

static std::unique_ptr< FluidProperty > MaterialLib::Fluid::createLinearConcentrationDependentDensity ( BaseLib::ConfigTree const &  config)
static
Input File Parameter:
material__fluid__density__type
Input File Parameter:
material__fluid__density__ConcentrationDependent__reference_density
Input File Parameter:
material__fluid__density__ConcentrationDependent__reference_concentration
Input File Parameter:
material__fluid__density__ConcentrationDependent__fluid_density_difference_ratio

Definition at line 73 of file CreateFluidDensityModel.cpp.

75{
77 config.checkConfigParameter("type", "ConcentrationDependent");
78
79 const auto reference_density =
81 config.getConfigParameter<double>("reference_density");
82 const auto reference_concentration =
84 config.getConfigParameter<double>("reference_concentration");
85 const auto fluid_density_difference_ratio =
87 config.getConfigParameter<double>("fluid_density_difference_ratio");
88 return std::make_unique<LinearConcentrationDependentDensity>(
89 reference_density,
90 reference_concentration,
91 fluid_density_difference_ratio);
92}

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

Referenced by createFluidDensityModel().

◆ createLinearPressureDependentViscosity()

static std::unique_ptr< FluidProperty > MaterialLib::Fluid::createLinearPressureDependentViscosity ( BaseLib::ConfigTree const &  config)
static
Parameters
configConfigTree object which contains the input data including <type>LinearPressure</type> and it has a tag of <viscosity>
Input File Parameter:
material__fluid__viscosity__type
Input File Parameter:
material__fluid__viscosity__LinearPressure__mu0
Input File Parameter:
material__fluid__viscosity__LinearPressure__p0
Input File Parameter:
material__fluid__viscosity__LinearPressure__gamma

Definition at line 31 of file CreateViscosityModel.cpp.

33{
35 config.checkConfigParameter("type", "LinearPressure");
36
38 const auto mu0 = config.getConfigParameter<double>("mu0");
39
41 const auto p0 = config.getConfigParameter<double>("p0");
42
44 const auto gamma = config.getConfigParameter<double>("gamma");
45
46 return std::make_unique<LinearPressureDependentViscosity>(mu0, p0, gamma);
47}

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

Referenced by createViscosityModel().

◆ createLinearTemperatureDependentDensity()

static std::unique_ptr< FluidProperty > MaterialLib::Fluid::createLinearTemperatureDependentDensity ( BaseLib::ConfigTree const &  config)
static
Parameters
configConfigTree object which contains the input data <type>TemperatureDependent</type> and it has a tag of <density>
Input File Parameter:
material__fluid__density__type
Input File Parameter:
material__fluid__density__TemperatureDependent__rho0
Input File Parameter:
material__fluid__density__TemperatureDependent__temperature0
Input File Parameter:
material__fluid__density__TemperatureDependent__beta

Definition at line 58 of file CreateFluidDensityModel.cpp.

60{
62 config.checkConfigParameter("type", "TemperatureDependent");
63
65 const auto rho0 = config.getConfigParameter<double>("rho0");
67 const auto T0 = config.getConfigParameter<double>("temperature0");
69 const auto beta = config.getConfigParameter<double>("beta");
70 return std::make_unique<LinearTemperatureDependentDensity>(rho0, T0, beta);
71}

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

Referenced by createFluidDensityModel().

◆ createLiquidDensity()

static std::unique_ptr< FluidProperty > MaterialLib::Fluid::createLiquidDensity ( BaseLib::ConfigTree const &  config)
static
Parameters
configConfigTree object which contains the input data including <type>LiquidDensity</type> and it has a tag of <density>
Input File Parameter:
material__fluid__density__type
Input File Parameter:
material__fluid__density__LiquidDensity__beta
Input File Parameter:
material__fluid__density__LiquidDensity__rho0
Input File Parameter:
material__fluid__density__LiquidDensity__temperature0
Input File Parameter:
material__fluid__density__LiquidDensity__p0
Input File Parameter:
material__fluid__density__LiquidDensity__bulk_modulus

Definition at line 34 of file CreateFluidDensityModel.cpp.

36{
38 config.checkConfigParameter("type", "LiquidDensity");
39
41 const auto beta = config.getConfigParameter<double>("beta");
43 const auto rho0 = config.getConfigParameter<double>("rho0");
45 const auto T0 = config.getConfigParameter<double>("temperature0");
47 const auto p0 = config.getConfigParameter<double>("p0");
49 const auto E = config.getConfigParameter<double>("bulk_modulus");
50 return std::make_unique<LiquidDensity>(beta, rho0, T0, p0, E);
51}

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

Referenced by createFluidDensityModel().

◆ createSpecificFluidHeatCapacityModel()

std::unique_ptr< FluidProperty > MaterialLib::Fluid::createSpecificFluidHeatCapacityModel ( BaseLib::ConfigTree const &  config)

Create a specific heat capacity model

Parameters
configConfigTree object has a tag of <specific_heat_capacity>
Input File Parameter:
material__fluid__specific_heat_capacity__type
Input File Parameter:
material__fluid__specific_heat_capacity__Constant__value

Definition at line 24 of file CreateSpecificFluidHeatCapacityModel.cpp.

26{
28 auto const type = config.getConfigParameter<std::string>("type");
29
30 if (type == "Constant")
31 {
32 return std::make_unique<ConstantFluidProperty>(
34 config.getConfigParameter<double>("value"));
35 }
36 // TODO: add more models
37
39 "The specific heat capacity type {:s} is unavailable.\n"
40 "The available type is \n\tConstant\n",
41 type.data());
42}

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

Referenced by createFluidProperties().

◆ createTemperatureDependentViscosity()

static std::unique_ptr< FluidProperty > MaterialLib::Fluid::createTemperatureDependentViscosity ( BaseLib::ConfigTree const &  config)
static
Parameters
configConfigTree object which contains the input data <type>TemperatureDependent</type> and it has a tag of <viscosity>
Input File Parameter:
material__fluid__viscosity__type
Input File Parameter:
material__fluid__viscosity__TemperatureDependent__mu0
Input File Parameter:
material__fluid__viscosity__TemperatureDependent__tc
Input File Parameter:
material__fluid__viscosity__TemperatureDependent__tv

Definition at line 54 of file CreateViscosityModel.cpp.

56{
58 config.checkConfigParameter("type", "TemperatureDependent");
59
61 const auto mu0 = config.getConfigParameter<double>("mu0");
62
64 const auto Tc = config.getConfigParameter<double>("tc");
65
67 const auto Tv = config.getConfigParameter<double>("tv");
68
69 return std::make_unique<TemperatureDependentViscosity>(mu0, Tc, Tv);
70}

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

Referenced by createViscosityModel().

◆ createViscosityModel()

std::unique_ptr< FluidProperty > MaterialLib::Fluid::createViscosityModel ( BaseLib::ConfigTree const &  config)

Create a viscosity model

Parameters
configConfigTree object has a tag of <viscosity>
Input File Parameter:
material__fluid__viscosity__type
Input File Parameter:
material__fluid__viscosity__type
Input File Parameter:
material__fluid__viscosity__Constant__value
Input File Parameter:
material__fluid__viscosity__type
Input File Parameter:
material__fluid__viscosity__Vogels__liquid_type
Input File Parameter:
material__fluid__viscosity__Vogels__liquid_type
Input File Parameter:
material__fluid__viscosity__Vogels__liquid_type
Input File Parameter:
material__fluid__viscosity__Vogels__liquid_type

Definition at line 72 of file CreateViscosityModel.cpp.

74{
76 auto const type = config.peekConfigParameter<std::string>("type");
77
78 if (type == "Constant")
79 {
81 config.checkConfigParameter("type", "Constant");
82 return std::make_unique<ConstantFluidProperty>(
84 config.getConfigParameter<double>("value"));
85 }
86 if (type == "LinearPressure")
87 {
88 return createLinearPressureDependentViscosity(config);
89 }
90 if (type == "TemperatureDependent")
91 {
92 return createTemperatureDependentViscosity(config);
93 }
94 if (type == "Vogels")
95 {
97 config.checkConfigParameter("type", "Vogels");
98
99 INFO("Using Vogels model, which gives viscosity in SI unit, Pa s");
100 auto const fluid_type =
102 config.peekConfigParameter<std::string>("liquid_type");
103 if (fluid_type == "Water")
104 {
106 config.checkConfigParameter("liquid_type", "Water");
107
108 const VogelsViscosityConstantsWater constants;
109 return std::make_unique<
110 VogelsLiquidDynamicViscosity<VogelsViscosityConstantsWater>>(
111 constants);
112 }
113 if (fluid_type == "CO2")
114 {
116 config.checkConfigParameter("liquid_type", "CO2");
117 const VogelsViscosityConstantsCO2 constants;
118 return std::make_unique<
119 VogelsLiquidDynamicViscosity<VogelsViscosityConstantsCO2>>(
120 constants);
121 }
122 if (fluid_type == "CH4")
123 {
125 config.checkConfigParameter("liquid_type", "CH4");
126 const VogelsViscosityConstantsCH4 constants;
127 return std::make_unique<
128 VogelsLiquidDynamicViscosity<VogelsViscosityConstantsCH4>>(
129 constants);
130 }
131
132 OGS_FATAL(
133 "The fluid type {:s} for Vogels model is unavailable.\n"
134 "The available fluid types are Water, CO2 and CH4\n",
135 fluid_type.data());
136 }
137
138 OGS_FATAL(
139 "The viscosity type {:s} is unavailable.\n"
140 "The available types are \n\tConstant, \n\tLinearPressure "
141 "\n\tTemperatureDependent, \n\tVogels\n",
142 type.data());
143}
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition: Logging.h:35

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

Referenced by createFluidProperties().

Variable Documentation

◆ FluidPropertyTypeNumber

const unsigned MaterialLib::Fluid::FluidPropertyTypeNumber
Initial value:
=
static_cast<unsigned>(FluidPropertyType::number_of_property_types)

Definition at line 36 of file FluidProperties.h.

◆ h_wg

◆ ji

◆ li

◆ ni

const double MaterialLib::Fluid::ni[34]
static
Initial value:
= {
1.4632971213167E-01, -8.4548187169114E-01, -3.7563603672040E+00,
3.3855169168385E+00, -9.5791963387872E-01, 1.5772038513228E-01,
-1.6616417199501E-02, 8.1214629983568E-04, 2.8319080123804E-04,
-6.0706301565874E-04, -1.8990068218419E-02, -3.2529748770505E-02,
-2.1841717175414E-02, -5.2838357969930E-05, -4.7184321073267E-04,
-3.0001780793026E-04, 4.7661393906987E-05, -4.4141845330846E-06,
-7.2694996297594E-16, -3.1679644845054E-05, -2.8270797985312E-06,
-8.5205128120103E-10, -2.2425281908000E-06, -6.5171222895601E-07,
-1.4341729937924E-13, -4.0516996860117E-07, -1.2734301741641E-09,
-1.7424871230634E-10, -6.8762131295531E-19, 1.4478307828521E-20,
2.6335781662795E-23, -1.1947622640071E-23, 1.8228094581404E-24,
-9.35370872924580E-26}

Definition at line 23 of file DimensionLessGibbsFreeEnergyRegion1.cpp.

Referenced by MaterialLib::Fluid::DimensionLessGibbsFreeEnergyRegion1::get_dgamma_dpi(), MaterialLib::Fluid::DimensionLessGibbsFreeEnergyRegion1::get_dgamma_dpi_dpi(), MaterialLib::Fluid::DimensionLessGibbsFreeEnergyRegion1::get_dgamma_dtau(), MaterialLib::Fluid::DimensionLessGibbsFreeEnergyRegion1::get_dgamma_dtau_dpi(), MaterialLib::Fluid::DimensionLessGibbsFreeEnergyRegion1::get_dgamma_dtau_dtau(), and MaterialLib::Fluid::DimensionLessGibbsFreeEnergyRegion1::get_gamma().

◆ p_0

const double MaterialLib::Fluid::p_0 = 101325.0
static

◆ PropertyVariableNumber

const unsigned MaterialLib::Fluid::PropertyVariableNumber
Initial value:
=
static_cast<unsigned>(PropertyVariableType::number_of_variables)

Definition at line 29 of file PropertyVariableType.h.

◆ temperature_0

const double MaterialLib::Fluid::temperature_0 = 373.15
static