Modelica.Media.Incompressible.TableBased

Information

This is the base package for medium models of incompressible fluids based on tables. The minimal data to provide for a useful medium description is tables of density and heat capacity as functions of temperature.

It should be noted that incompressible media only have 1 state per control volume (usually T), but have both T and p as inputs for fully correct properties. The error of using only T-dependent properties is small, therefore a Boolean flag enthalpyOfT exists. If it is true, the enumeration Choices.independentVariables is set to Choices.independentVariables.T otherwise it is set to Choices.independentVariables.pT.

Using the package TableBased

To implement a new medium model, create a package that extends TableBased and provides one or more of the constant tables:

tableDensity        = [T, d];
tableHeatCapacity   = [T, Cp];
tableConductivity   = [T, lam];
tableViscosity      = [T, eta];
tableVaporPressure  = [T, pVap];

The table data is used to fit constant polynomials of order npol, the temperature data points do not need to be same for different properties. Properties like enthalpy, inner energy and entropy are calculated consistently from integrals and derivatives of d(T) and Cp(T). The minimal data for a useful medium model is thus density and heat capacity. Transport properties and vapor pressure are optional, if the data tables are empty the corresponding function calls can not be used.

Extends from Modelica.Media.Interfaces.PartialMedium (Partial medium properties (base package of all media packages)).

Package Content

Name	Description
enthalpyOfT=true	true if enthalpy is approximated as a function of T only, (p-dependence neglected)
densityOfT=size(tableDensity, 1) > 1	true if density is a function of temperature
T_min	Minimum temperature valid for medium model
T_max	Maximum temperature valid for medium model
T0=273.15	reference Temperature
h0=0	reference enthalpy at T0, reference_p
s0=0	reference entropy at T0, reference_p
MM_const=0.1	Molar mass
npol=2	degree of polynomial used for fitting
neta=size(tableViscosity, 1)	number of data points for viscosity
tableDensity	Table for rho(T)
tableHeatCapacity	Table for Cp(T)
tableViscosity	Table for eta(T)
tableVaporPressure	Table for pVap(T)
tableConductivity	Table for lambda(T)
TinK	true if T[K],Kelvin used for table temperatures
hasDensity=not (size(tableDensity, 1) == 0)	true if table tableDensity is present
hasHeatCapacity=not (size(tableHeatCapacity, 1) == 0)	true if table tableHeatCapacity is present
hasViscosity=not (size(tableViscosity, 1) == 0)	true if table tableViscosity is present
hasVaporPressure=not (size(tableVaporPressure, 1) == 0)	true if table tableVaporPressure is present
invTK=if size(tableViscosity, 1) > 0 then invertTemp(tableViscosity[:, 1], TinK) else fill(0, 0)
poly_rho=if hasDensity then Poly.fitting(tableDensity[:, 1], tableDensity[:, 2], npol) else zeros(npol + 1)
poly_Cp=if hasHeatCapacity then Poly.fitting(tableHeatCapacity[:, 1], tableHeatCapacity[:, 2], npol) else zeros(npol + 1)
poly_eta=if hasViscosity then Poly.fitting(invTK, Math.log(tableViscosity[:, 2]), npol) else zeros(npol + 1)
poly_pVap=if hasVaporPressure then Poly.fitting(tableVaporPressure[:, 1], tableVaporPressure[:, 2], npol) else zeros(npol + 1)
poly_lam=if size(tableConductivity, 1) > 0 then Poly.fitting(tableConductivity[:, 1], tableConductivity[:, 2], npol) else zeros(npol + 1)
invertTemp	function to invert temperatures
BaseProperties	Base properties of T dependent medium
setState_pTX	Returns state record, given pressure and temperature
setState_dTX	Returns state record, given pressure and temperature
setState_pT	returns state record as function of p and T
setState_phX	Returns state record, given pressure and specific enthalpy
setState_ph	returns state record as function of p and h
setState_psX	Returns state record, given pressure and specific entropy
setState_ps	returns state record as function of p and s
setSmoothState	Return thermodynamic state so that it smoothly approximates: if x > 0 then state_a else state_b
specificHeatCapacityCv	Specific heat capacity at constant volume (or pressure) of medium
specificHeatCapacityCp	Specific heat capacity at constant volume (or pressure) of medium
dynamicViscosity	Return dynamic viscosity as a function of the thermodynamic state record
thermalConductivity	Return thermal conductivity as a function of the thermodynamic state record
s_T	compute specific entropy
specificEntropy	Return specific entropy as a function of the thermodynamic state record
h_T	Compute specific enthalpy from temperature
h_T_der	Compute specific enthalpy from temperature
h_pT	Compute specific enthalpy from pressure and temperature
density_T	Return density as function of temperature
temperature	Return temperature as a function of the thermodynamic state record
pressure	Return pressure as a function of the thermodynamic state record
density	Return density as a function of the thermodynamic state record
specificEnthalpy	Return specific enthalpy as a function of the thermodynamic state record
specificInternalEnergy	Return specific internal energy as a function of the thermodynamic state record
T_ph	Compute temperature from pressure and specific enthalpy
T_ps	Compute temperature from pressure and specific enthalpy
Polynomials_Temp	Temporary Functions operating on polynomials (including polynomial fitting); only to be used in Modelica.Media.Incompressible.TableBased
Inherited
ThermoStates	Enumeration type for independent variables
mediumName="unusablePartialMedium"	Name of the medium
substanceNames={mediumName}	Names of the mixture substances. Set substanceNames={mediumName} if only one substance.
extraPropertiesNames=fill("", 0)	Names of the additional (extra) transported properties. Set extraPropertiesNames=fill("",0) if unused
singleState	= true, if u and d are not a function of pressure
reducedX=true	= true if medium contains the equation sum(X) = 1.0; set reducedX=true if only one substance (see docu for details)
fixedX=false	= true if medium contains the equation X = reference_X
reference_p=101325	Reference pressure of Medium: default 1 atmosphere
reference_T=298.15	Reference temperature of Medium: default 25 deg Celsius
reference_X=fill(1/nX, nX)	Default mass fractions of medium
p_default=101325	Default value for pressure of medium (for initialization)
T_default=Modelica.SIunits.Conversions.from_degC(20)	Default value for temperature of medium (for initialization)
h_default=specificEnthalpy_pTX(p_default, T_default, X_default)	Default value for specific enthalpy of medium (for initialization)
X_default=reference_X	Default value for mass fractions of medium (for initialization)
nS=size(substanceNames, 1)	Number of substances
nX=nS	Number of mass fractions
nXi=if fixedX then 0 else if reducedX then nS - 1 else nS	Number of structurally independent mass fractions (see docu for details)
nC=size(extraPropertiesNames, 1)	Number of extra (outside of standard mass-balance) transported properties
FluidConstants	critical, triple, molecular and other standard data of fluid
ThermodynamicState	Minimal variable set that is available as input argument to every medium function
prandtlNumber	Return the Prandtl number
specificGibbsEnergy	Return specific Gibbs energy
specificHelmholtzEnergy	Return specific Helmholtz energy
heatCapacity_cp	alias for deprecated name
heatCapacity_cv	alias for deprecated name
isentropicExponent	Return isentropic exponent
isentropicEnthalpy	Return isentropic enthalpy
velocityOfSound	Return velocity of sound
isobaricExpansionCoefficient	Return overall the isobaric expansion coefficient beta
beta	alias for isobaricExpansionCoefficient for user convenience
isothermalCompressibility	Return overall the isothermal compressibility factor
kappa	alias of isothermalCompressibility for user convenience
density_derp_h	Return density derivative wrt pressure at const specific enthalpy
density_derh_p	Return density derivative wrt specific enthalpy at constant pressure
density_derp_T	Return density derivative wrt pressure at const temperature
density_derT_p	Return density derivative wrt temperature at constant pressure
density_derX	Return density derivative wrt mass fraction
molarMass	Return the molar mass of the medium
specificEnthalpy_pTX	Return specific enthalpy from p, T, and X or Xi
density_pTX	Return density from p, T, and X or Xi
temperature_phX	Return temperature from p, h, and X or Xi
density_phX	Return density from p, h, and X or Xi
temperature_psX	Return temperature from p,s, and X or Xi
density_psX	Return density from p, s, and X or Xi
specificEnthalpy_psX	Return specific enthalpy from p, s, and X or Xi
AbsolutePressure	Type for absolute pressure with medium specific attributes
Density	Type for density with medium specific attributes
DynamicViscosity	Type for dynamic viscosity with medium specific attributes
EnthalpyFlowRate	Type for enthalpy flow rate with medium specific attributes
MassFlowRate	Type for mass flow rate with medium specific attributes
MassFraction	Type for mass fraction with medium specific attributes
MoleFraction	Type for mole fraction with medium specific attributes
MolarMass	Type for molar mass with medium specific attributes
MolarVolume	Type for molar volume with medium specific attributes
IsentropicExponent	Type for isentropic exponent with medium specific attributes
SpecificEnergy	Type for specific energy with medium specific attributes
SpecificInternalEnergy	Type for specific internal energy with medium specific attributes
SpecificEnthalpy	Type for specific enthalpy with medium specific attributes
SpecificEntropy	Type for specific entropy with medium specific attributes
SpecificHeatCapacity	Type for specific heat capacity with medium specific attributes
SurfaceTension	Type for surface tension with medium specific attributes
Temperature	Type for temperature with medium specific attributes
ThermalConductivity	Type for thermal conductivity with medium specific attributes
PrandtlNumber	Type for Prandtl number with medium specific attributes
VelocityOfSound	Type for velocity of sound with medium specific attributes
ExtraProperty	Type for unspecified, mass-specific property transported by flow
CumulativeExtraProperty	Type for conserved integral of unspecified, mass specific property
ExtraPropertyFlowRate	Type for flow rate of unspecified, mass-specific property
IsobaricExpansionCoefficient	Type for isobaric expansion coefficient with medium specific attributes
DipoleMoment	Type for dipole moment with medium specific attributes
DerDensityByPressure	Type for partial derivative of density with resect to pressure with medium specific attributes
DerDensityByEnthalpy	Type for partial derivative of density with resect to enthalpy with medium specific attributes
DerEnthalpyByPressure	Type for partial derivative of enthalpy with resect to pressure with medium specific attributes
DerDensityByTemperature	Type for partial derivative of density with resect to temperature with medium specific attributes
Choices	Types, constants to define menu choices

Types and constants

  constant Boolean enthalpyOfT=true 
  "true if enthalpy is approximated as a function of T only, (p-dependence neglected)";

  constant Boolean densityOfT = size(tableDensity,1) > 1 
  "true if density is a function of temperature";

  constant Temperature T_min "Minimum temperature valid for medium model";

  constant Temperature T_max "Maximum temperature valid for medium model";

  constant Temperature T0=273.15 "reference Temperature";

  constant SpecificEnthalpy h0=0 "reference enthalpy at T0, reference_p";

  constant SpecificEntropy s0=0 "reference entropy at T0, reference_p";

  constant MolarMass MM_const=0.1 "Molar mass";

  constant Integer npol=2 "degree of polynomial used for fitting";

  constant Integer neta=size(tableViscosity,1) 
  "number of data points for viscosity";

  constant Real[:,:] tableDensity "Table for rho(T)";

  constant Real[:,:] tableHeatCapacity "Table for Cp(T)";

  constant Real[:,:] tableViscosity "Table for eta(T)";

  constant Real[:,:] tableVaporPressure "Table for pVap(T)";

  constant Real[:,:] tableConductivity "Table for lambda(T)";

  constant Boolean TinK "true if T[K],Kelvin used for table temperatures";

  constant Boolean hasDensity = not (size(tableDensity,1)==0) 
  "true if table tableDensity is present";

  constant Boolean hasHeatCapacity = not (size(tableHeatCapacity,1)==0) 
  "true if table tableHeatCapacity is present";

  constant Boolean hasViscosity = not (size(tableViscosity,1)==0) 
  "true if table tableViscosity is present";

  constant Boolean hasVaporPressure = not (size(tableVaporPressure,1)==0) 
  "true if table tableVaporPressure is present";

  final constant Real invTK[neta] = if size(tableViscosity,1) > 0 then 
      invertTemp(tableViscosity[:,1],TinK) else fill(0,0);

  final constant Real poly_rho[:] = if hasDensity then 
                                       Poly.fitting(tableDensity[:,1],tableDensity[:,2],npol) else 
                                         zeros(npol+1);

  final constant Real poly_Cp[:] = if hasHeatCapacity then 
                                       Poly.fitting(tableHeatCapacity[:,1],tableHeatCapacity[:,2],npol) else 
                                         zeros(npol+1);

  final constant Real poly_eta[:] = if hasViscosity then 
                                       Poly.fitting(invTK, Math.log(tableViscosity[:,2]),npol) else 
                                         zeros(npol+1);

  final constant Real poly_pVap[:] = if hasVaporPressure then 
                                       Poly.fitting(tableVaporPressure[:,1],tableVaporPressure[:,2],npol) else 
                                          zeros(npol+1);

  final constant Real poly_lam[:] = if size(tableConductivity,1)>0 then 
                                       Poly.fitting(tableConductivity[:,1],tableConductivity[:,2],npol) else 
                                         zeros(npol+1);

Modelica.Media.Incompressible.TableBased.invertTemp

Inputs

Type	Name	Default	Description
Real	table[:]		table temperature data
Boolean	Tink		flag for Celsius or Kelvin

Outputs

Type	Name	Description
Real	invTable[size(table, 1)]	inverted temperatures

Modelica definition

function invertTemp "function to invert temperatures"
  input Real[:] table "table temperature data";
  input Boolean Tink "flag for Celsius or Kelvin";
  output Real invTable[size(table,1)] "inverted temperatures";
algorithm 
  for i in 1:size(table,1) loop
    invTable[i] := if TinK then 1/table[i] else 1/Cv.from_degC(table[i]);
  end for;
end invertTemp;

Modelica.Media.Incompressible.TableBased.BaseProperties

Information

Note that the inner energy neglects the pressure dependence, which is only true for an incompressible medium with d = constant. The neglected term is p-reference_p)/rho*(T/rho)*(partial rho /partial T). This is very small for liquids due to proportionality to 1/d^2, but can be problematic for gases that are modeled incompressible.

It should be noted that incompressible media only have 1 state per control volume (usually T), but have both T and p as inputs for fully correct properties. The error of using only T-dependent properties is small, therefore a Boolean flag enthalpyOfT exists. If it is true, the enumeration Choices.independentVariables is set to Choices.independentVariables.T otherwise it is set to Choices.independentVariables.pT.

Enthalpy is never a function of T only (h = h(T) + (p-reference_p)/d), but the error is also small and non-linear systems can be avoided. In particular, non-linear systems are small and local as opposed to large and over all volumes.

Entropy is calculated as

  s = s0 + integral(Cp(T)/T,dt)

which is only exactly true for a fluid with constant density d=d0.

Extends from (Base properties (p, d, T, h, u, R, MM and, if applicable, X and Xi) of a medium).

Parameters

Type	Name	Default	Description
Temperature	T_start	298.15	initial temperature [K]
Boolean	standardOrderComponents	true	if true, and reducedX = true, the last element of X will be computed from the other ones
Pressure_bar	p_bar	Cv.to_bar(p)	Absolute pressure of medium in [bar] [bar]
Advanced
Boolean	preferredMediumStates	false	= true if StateSelect.prefer shall be used for the independent property variables of the medium

Modelica definition

redeclare model extends BaseProperties(
  final standardOrderComponents=true,
  p_bar=Cv.to_bar(p),
  T_degC(start = T_start-273.15)=Cv.to_degC(T),
  T(start = T_start,
    stateSelect=if preferredMediumStates then StateSelect.prefer else StateSelect.default)) 
  "Base properties of T dependent medium"
//  redeclare parameter SpecificHeatCapacity R=Modelica.Constants.R,

  SI.SpecificHeatCapacity cp "specific heat capacity";
  parameter SI.Temperature T_start = 298.15 "initial temperature";
equation 
  assert(hasDensity,"Medium " + mediumName +
                    " can not be used without assigning tableDensity.");
  assert(T >= T_min and T <= T_max, "Temperature T (= " + String(T) +
         " K) is not in the allowed range (" + String(T_min) +
         " K <= T <= " + String(T_max) + " K) required from medium model \""
         + mediumName + "\".");
  R = Modelica.Constants.R;
  cp = Poly.evaluate(poly_Cp,if TinK then T else T_degC);
  h = if enthalpyOfT then h_T(T) else  h_pT(p,T,densityOfT);
  if singleState then
    u = h_T(T) - reference_p/d;
  else
    u = h - p/d;
  end if;
  d = Poly.evaluate(poly_rho,if TinK then T else T_degC);
  state.T = T;
  state.p = p;
  MM = MM_const;
end BaseProperties;

Modelica.Media.Incompressible.TableBased.setState_pTX

Information

Inputs

Type	Name	Default	Description
AbsolutePressure	p		Pressure [Pa]
Temperature	T		Temperature [K]
MassFraction	X[:]	reference_X	Mass fractions [kg/kg]

Outputs

Type	Name	Description
ThermodynamicState	state	thermodynamic state record

Modelica definition

redeclare function extends setState_pTX 
  "Returns state record, given pressure and temperature"
algorithm 
  state := ThermodynamicState(p=p,T=T);
end setState_pTX;

Modelica.Media.Incompressible.TableBased.setState_dTX

Information

Inputs

Type	Name	Default	Description
Density	d		density [kg/m3]
Temperature	T		Temperature [K]
MassFraction	X[:]	reference_X	Mass fractions [kg/kg]

Outputs

Type	Name	Description
ThermodynamicState	state	thermodynamic state record

Modelica definition

redeclare function extends setState_dTX 
  "Returns state record, given pressure and temperature"
algorithm 
  assert(false, "for incompressible media with d(T) only, state can not be set from density and temperature");
end setState_dTX;

Modelica.Media.Incompressible.TableBased.setState_pT

Inputs

Type	Name	Default	Description
AbsolutePressure	p		pressure [Pa]
Temperature	T		temperature [K]

Outputs

Type	Name	Description
ThermodynamicState	state	thermodynamic state

Modelica definition

function setState_pT "returns state record as function of p and T"
  input AbsolutePressure p "pressure";
  input Temperature T "temperature";
  output ThermodynamicState state "thermodynamic state";
algorithm 
  state.T := T;
  state.p := p;
end setState_pT;

Modelica.Media.Incompressible.TableBased.setState_phX

Information

Inputs

Type	Name	Default	Description
AbsolutePressure	p		Pressure [Pa]
SpecificEnthalpy	h		Specific enthalpy [J/kg]
MassFraction	X[:]	reference_X	Mass fractions [kg/kg]

Outputs

Type	Name	Description
ThermodynamicState	state	thermodynamic state record

Modelica definition

redeclare function extends setState_phX 
  "Returns state record, given pressure and specific enthalpy"
algorithm 
  state :=ThermodynamicState(p=p,T=T_ph(p,h));
end setState_phX;

Modelica.Media.Incompressible.TableBased.setState_ph

Inputs

Type	Name	Default	Description
AbsolutePressure	p		pressure [Pa]
SpecificEnthalpy	h		specific enthalpy [J/kg]

Outputs

Type	Name	Description
ThermodynamicState	state	thermodynamic state

Modelica definition

function setState_ph "returns state record as function of p and h"
  input AbsolutePressure p "pressure";
  input SpecificEnthalpy h "specific enthalpy";
  output ThermodynamicState state "thermodynamic state";
algorithm 
  state :=ThermodynamicState(p=p,T=T_ph(p,h));
end setState_ph;

Modelica.Media.Incompressible.TableBased.setState_psX

Information

Inputs

Type	Name	Default	Description
AbsolutePressure	p		Pressure [Pa]
SpecificEntropy	s		Specific entropy [J/(kg.K)]
MassFraction	X[:]	reference_X	Mass fractions [kg/kg]

Outputs

Type	Name	Description
ThermodynamicState	state	thermodynamic state record

Modelica definition

redeclare function extends setState_psX 
  "Returns state record, given pressure and specific entropy"
algorithm 
  state :=ThermodynamicState(p=p,T=T_ps(p,s));
end setState_psX;

Modelica.Media.Incompressible.TableBased.setState_ps

Inputs

Type	Name	Default	Description
AbsolutePressure	p		pressure [Pa]
SpecificEntropy	s		specific entropy [J/(kg.K)]

Outputs

Type	Name	Description
ThermodynamicState	state	thermodynamic state

Modelica definition

function setState_ps "returns state record as function of p and s"
  input AbsolutePressure p "pressure";
  input SpecificEntropy s "specific entropy";
  output ThermodynamicState state "thermodynamic state";
algorithm 
  state :=ThermodynamicState(p=p,T=T_ps(p,s));
end setState_ps;

Modelica.Media.Incompressible.TableBased.setSmoothState

Information

Inputs

Type	Name	Default	Description
Real	x		m_flow or dp
ThermodynamicState	state_a		Thermodynamic state if x > 0
ThermodynamicState	state_b		Thermodynamic state if x < 0
Real	x_small		Smooth transition in the region -x_small < x < x_small

Outputs

Type	Name	Description
ThermodynamicState	state	Smooth thermodynamic state for all x (continuous and differentiable)

Modelica definition

redeclare function extends setSmoothState 
  "Return thermodynamic state so that it smoothly approximates: if x > 0 then state_a else state_b"
algorithm 
  state :=ThermodynamicState(p=Media.Common.smoothStep(x, state_a.p, state_b.p, x_small),
                             T=Media.Common.smoothStep(x, state_a.T, state_b.T, x_small));
end setSmoothState;

Modelica.Media.Incompressible.TableBased.specificHeatCapacityCv

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
SpecificHeatCapacity	cv	Specific heat capacity at constant volume [J/(kg.K)]

Modelica definition

redeclare function extends specificHeatCapacityCv 
  "Specific heat capacity at constant volume (or pressure) of medium"

algorithm 
  assert(hasHeatCapacity,"Specific Heat Capacity, Cv, is not defined for medium "
                                         + mediumName + ".");
  cv := Poly.evaluate(poly_Cp,if TinK then state.T else state.T - 273.15);
end specificHeatCapacityCv;

Modelica.Media.Incompressible.TableBased.specificHeatCapacityCp

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
SpecificHeatCapacity	cp	Specific heat capacity at constant pressure [J/(kg.K)]

Modelica definition

redeclare function extends specificHeatCapacityCp 
  "Specific heat capacity at constant volume (or pressure) of medium"

algorithm 
  assert(hasHeatCapacity,"Specific Heat Capacity, Cv, is not defined for medium "
                                         + mediumName + ".");
  cp := Poly.evaluate(poly_Cp,if TinK then state.T else state.T - 273.15);
end specificHeatCapacityCp;

Modelica.Media.Incompressible.TableBased.dynamicViscosity

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
DynamicViscosity	eta	Dynamic viscosity [Pa.s]

Modelica definition

redeclare function extends dynamicViscosity 
  "Return dynamic viscosity as a function of the thermodynamic state record"

algorithm 
  assert(size(tableViscosity,1)>0,"DynamicViscosity, eta, is not defined for medium "
                                         + mediumName + ".");
  eta := Math.exp(Poly.evaluate(poly_eta, 1/state.T));
end dynamicViscosity;

Modelica.Media.Incompressible.TableBased.thermalConductivity

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
ThermalConductivity	lambda	Thermal conductivity [W/(m.K)]

Modelica definition

redeclare function extends thermalConductivity 
  "Return thermal conductivity as a function of the thermodynamic state record"

algorithm 
  assert(size(tableConductivity,1)>0,"ThermalConductivity, lambda, is not defined for medium "
                                         + mediumName + ".");
  lambda := Poly.evaluate(poly_lam,if TinK then state.T else Cv.to_degC(state.T));
end thermalConductivity;

Modelica.Media.Incompressible.TableBased.s_T

Inputs

Type	Name	Default	Description
Temperature	T		temperature [K]

Outputs

Type	Name	Description
SpecificEntropy	s	specific entropy [J/(kg.K)]

Modelica definition

function s_T "compute specific entropy"
  input Temperature T "temperature";
  output SpecificEntropy s "specific entropy";
algorithm 
  s := s0 + (if TinK then 
    Poly.integralValue(poly_Cp[1:npol],T, T0) else 
    Poly.integralValue(poly_Cp[1:npol],Cv.to_degC(T),Cv.to_degC(T0)))
    + Modelica.Math.log(T/T0)*
    Poly.evaluate(poly_Cp,if TinK then 0 else Modelica.Constants.T_zero);
end s_T;

Modelica.Media.Incompressible.TableBased.specificEntropy

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
SpecificEntropy	s	Specific entropy [J/(kg.K)]

Modelica definition

redeclare function extends specificEntropy "Return specific entropy
 as a function of the thermodynamic state record"

protected 
  Integer npol=size(poly_Cp,1)-1;
algorithm 
  assert(hasHeatCapacity,"Specific Entropy, s(T), is not defined for medium "
                                         + mediumName + ".");
  s := s_T(state.T);
end specificEntropy;

Modelica.Media.Incompressible.TableBased.h_T

Information

Inputs

Type	Name	Default	Description
Temperature	T		Temperature [K]

Outputs

Type	Name	Description
SpecificEnthalpy	h	Specific enthalpy at p, T [J/kg]

Modelica definition

function h_T "Compute specific enthalpy from temperature"
  annotation(derivative=h_T_der);
  import Modelica.SIunits.Conversions.to_degC;
  extends Modelica.Icons.Function;
  input SI.Temperature T "Temperature";
  output SI.SpecificEnthalpy h "Specific enthalpy at p, T";
algorithm 
  h :=h0 + Poly.integralValue(poly_Cp, if TinK then T else Cv.to_degC(T), if TinK then 
  T0 else Cv.to_degC(T0));
end h_T;

Modelica.Media.Incompressible.TableBased.h_T_der

Information

Inputs

Type	Name	Default	Description
Temperature	T		Temperature [K]
Real	dT		temperature derivative

Outputs

Type	Name	Description
Real	dh	derivative of Specific enthalpy at T

Modelica definition

function h_T_der "Compute specific enthalpy from temperature"
  import Modelica.SIunits.Conversions.to_degC;
  extends Modelica.Icons.Function;
  input SI.Temperature T "Temperature";
  input Real dT "temperature derivative";
  output Real dh "derivative of Specific enthalpy at T";
algorithm 
  dh :=Poly.evaluate(poly_Cp, if TinK then T else Cv.to_degC(T))*dT;
end h_T_der;

Modelica.Media.Incompressible.TableBased.h_pT

Information

Inputs

Type	Name	Default	Description
Pressure	p		Pressure [Pa]
Temperature	T		Temperature [K]
Boolean	densityOfT	false	include or neglect density derivative dependence of enthalpy

Outputs

Type	Name	Description
SpecificEnthalpy	h	Specific enthalpy at p, T [J/kg]

Modelica definition

function h_pT 
  "Compute specific enthalpy from pressure and temperature"
  import Modelica.SIunits.Conversions.to_degC;
  extends Modelica.Icons.Function;
  input SI.Pressure p "Pressure";
  input SI.Temperature T "Temperature";
  input Boolean densityOfT = false 
    "include or neglect density derivative dependence of enthalpy";
  output SI.SpecificEnthalpy h "Specific enthalpy at p, T";
algorithm 
  h :=h0 + Poly.integralValue(poly_Cp, if TinK then T else Cv.to_degC(T), if TinK then 
  T0 else Cv.to_degC(T0)) + (p - reference_p)/Poly.evaluate(poly_rho, if TinK then 
          T else Cv.to_degC(T))
    *(if densityOfT then (1 + T/Poly.evaluate(poly_rho, if TinK then T else Cv.to_degC(T))
  *Poly.derivativeValue(poly_rho,if TinK then T else Cv.to_degC(T))) else 1.0);
end h_pT;

Modelica.Media.Incompressible.TableBased.density_T

Inputs

Type	Name	Default	Description
Temperature	T		temperature [K]

Outputs

Type	Name	Description
Density	d	density [kg/m3]

Modelica definition

function density_T "Return density as function of temperature"

  input Temperature T "temperature";
  output Density d "density";
algorithm 
  d := Poly.evaluate(poly_rho,if TinK then T else Cv.to_degC(T));
end density_T;

Modelica.Media.Incompressible.TableBased.temperature

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
Temperature	T	Temperature [K]

Modelica definition

redeclare function extends temperature 
  "Return temperature as a function of the thermodynamic state record"
algorithm 
 T := state.T;
end temperature;

Modelica.Media.Incompressible.TableBased.pressure

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
AbsolutePressure	p	Pressure [Pa]

Modelica definition

redeclare function extends pressure 
  "Return pressure as a function of the thermodynamic state record"
algorithm 
 p := state.p;
end pressure;

Modelica.Media.Incompressible.TableBased.density

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
Density	d	Density [kg/m3]

Modelica definition

redeclare function extends density 
  "Return density as a function of the thermodynamic state record"
algorithm 
  d := Poly.evaluate(poly_rho,if TinK then state.T else Cv.to_degC(state.T));
end density;

Modelica.Media.Incompressible.TableBased.specificEnthalpy

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
SpecificEnthalpy	h	Specific enthalpy [J/kg]

Modelica definition

redeclare function extends specificEnthalpy 
  "Return specific enthalpy as a function of the thermodynamic state record"
algorithm 
  h := if enthalpyOfT then h_T(state.T) else h_pT(state.p,state.T);
end specificEnthalpy;

Modelica.Media.Incompressible.TableBased.specificInternalEnergy

Information

Inputs

Type	Name	Default	Description
ThermodynamicState	state		thermodynamic state record

Outputs

Type	Name	Description
SpecificEnergy	u	Specific internal energy [J/kg]

Modelica definition

redeclare function extends specificInternalEnergy 
  "Return specific internal energy as a function of the thermodynamic state record"
algorithm 
  u := if enthalpyOfT then h_T(state.T) else h_pT(state.p,state.T)
    - (if singleState then  reference_p/density(state) else state.p/density(state));
end specificInternalEnergy;

Modelica.Media.Incompressible.TableBased.T_ph

Inputs

Type	Name	Default	Description
AbsolutePressure	p		pressure [Pa]
SpecificEnthalpy	h		specific enthalpy [J/kg]

Outputs

Type	Name	Description
Temperature	T	temperature [K]

Modelica definition

function T_ph 
  "Compute temperature from pressure and specific enthalpy"
  input AbsolutePressure p "pressure";
  input SpecificEnthalpy h "specific enthalpy";
  output Temperature T "temperature";
protected 
  package Internal 
    "Solve h(T) for T with given h (use only indirectly via temperature_phX)"
    extends Modelica.Media.Common.OneNonLinearEquation;

    redeclare record extends f_nonlinear_Data 
      "superfluous record, fix later when better structure of inverse functions exists"
        constant Real[5] dummy = {1,2,3,4,5};
    end f_nonlinear_Data;

    redeclare function extends f_nonlinear 
      "p is smuggled in via vector"
    algorithm 
      y := if singleState then h_T(x) else h_pT(p,x);
    end f_nonlinear;

    // Dummy definition has to be added for current Dymola
    redeclare function extends solve
    end solve;
  end Internal;
algorithm 
 T := Internal.solve(h, T_min, T_max, p, {1}, Internal.f_nonlinear_Data());
end T_ph;

Modelica.Media.Incompressible.TableBased.T_ps

Inputs

Type	Name	Default	Description
AbsolutePressure	p		pressure [Pa]
SpecificEntropy	s		specific entropy [J/(kg.K)]

Outputs

Type	Name	Description
Temperature	T	temperature [K]

Modelica definition

function T_ps 
  "Compute temperature from pressure and specific enthalpy"
  input AbsolutePressure p "pressure";
  input SpecificEntropy s "specific entropy";
  output Temperature T "temperature";
protected 
  package Internal 
    "Solve h(T) for T with given h (use only indirectly via temperature_phX)"
    extends Modelica.Media.Common.OneNonLinearEquation;

    redeclare record extends f_nonlinear_Data 
      "superfluous record, fix later when better structure of inverse functions exists"
        constant Real[5] dummy = {1,2,3,4,5};
    end f_nonlinear_Data;

    redeclare function extends f_nonlinear 
      "p is smuggled in via vector"
    algorithm 
      y := s_T(x);
    end f_nonlinear;

    // Dummy definition has to be added for current Dymola
    redeclare function extends solve
    end solve;
  end Internal;
algorithm 
 T := Internal.solve(s, T_min, T_max, p, {1}, Internal.f_nonlinear_Data());
end T_ps;