Modelica.Media.Incompressible.TableBased

Incompressible medium properties based on tables

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

NameDescription
enthalpyOfT=truetrue if enthalpy is approximated as a function of T only, (p-dependence neglected)
densityOfT=size(tableDensity, 1) > 1true if density is a function of temperature
T_minMinimum temperature valid for medium model
T_maxMaximum temperature valid for medium model
T0=273.15reference Temperature
h0=0reference enthalpy at T0, reference_p
s0=0reference entropy at T0, reference_p
MM_const=0.1Molar mass
npol=2degree of polynomial used for fitting
neta=size(tableViscosity, 1)number of data points for viscosity
tableDensityTable for rho(T)
tableHeatCapacityTable for Cp(T)
tableViscosityTable for eta(T)
tableVaporPressureTable for pVap(T)
tableConductivityTable for lambda(T)
TinKtrue 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) 
Modelica.Media.Incompressible.TableBased.invertTemp invertTemp function to invert temperatures
Modelica.Media.Incompressible.TableBased.BaseProperties BaseProperties Base properties of T dependent medium
Modelica.Media.Incompressible.TableBased.setState_pTX setState_pTX Returns state record, given pressure and temperature
Modelica.Media.Incompressible.TableBased.setState_dTX setState_dTX Returns state record, given pressure and temperature
Modelica.Media.Incompressible.TableBased.setState_pT setState_pT returns state record as function of p and T
Modelica.Media.Incompressible.TableBased.setState_phX setState_phX Returns state record, given pressure and specific enthalpy
Modelica.Media.Incompressible.TableBased.setState_ph setState_ph returns state record as function of p and h
Modelica.Media.Incompressible.TableBased.setState_psX setState_psX Returns state record, given pressure and specific entropy
Modelica.Media.Incompressible.TableBased.setState_ps setState_ps returns state record as function of p and s
Modelica.Media.Incompressible.TableBased.setSmoothState setSmoothState Return thermodynamic state so that it smoothly approximates: if x > 0 then state_a else state_b
Modelica.Media.Incompressible.TableBased.specificHeatCapacityCv specificHeatCapacityCv Specific heat capacity at constant volume (or pressure) of medium
Modelica.Media.Incompressible.TableBased.specificHeatCapacityCp specificHeatCapacityCp Specific heat capacity at constant volume (or pressure) of medium
Modelica.Media.Incompressible.TableBased.dynamicViscosity dynamicViscosity Return dynamic viscosity as a function of the thermodynamic state record
Modelica.Media.Incompressible.TableBased.thermalConductivity thermalConductivity Return thermal conductivity as a function of the thermodynamic state record
Modelica.Media.Incompressible.TableBased.s_T s_T compute specific entropy
Modelica.Media.Incompressible.TableBased.specificEntropy specificEntropy Return specific entropy as a function of the thermodynamic state record
Modelica.Media.Incompressible.TableBased.h_T h_T Compute specific enthalpy from temperature
Modelica.Media.Incompressible.TableBased.h_T_der h_T_der Compute specific enthalpy from temperature
Modelica.Media.Incompressible.TableBased.h_pT h_pT Compute specific enthalpy from pressure and temperature
Modelica.Media.Incompressible.TableBased.density_T density_T Return density as function of temperature
Modelica.Media.Incompressible.TableBased.temperature temperature Return temperature as a function of the thermodynamic state record
Modelica.Media.Incompressible.TableBased.pressure pressure Return pressure as a function of the thermodynamic state record
Modelica.Media.Incompressible.TableBased.density density Return density as a function of the thermodynamic state record
Modelica.Media.Incompressible.TableBased.specificEnthalpy specificEnthalpy Return specific enthalpy as a function of the thermodynamic state record
Modelica.Media.Incompressible.TableBased.specificInternalEnergy specificInternalEnergy Return specific internal energy as a function of the thermodynamic state record
Modelica.Media.Incompressible.TableBased.T_ph T_ph Compute temperature from pressure and specific enthalpy
Modelica.Media.Incompressible.TableBased.T_ps T_ps Compute temperature from pressure and specific enthalpy
Modelica.Media.Incompressible.TableBased.Polynomials_Temp Polynomials_Temp Temporary Functions operating on polynomials (including polynomial fitting); only to be used in Modelica.Media.Incompressible.TableBased
Inherited
ThermoStatesEnumeration 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=101325Reference pressure of Medium: default 1 atmosphere
reference_T=298.15Reference temperature of Medium: default 25 deg Celsius
reference_X=fill(1/nX, nX)Default mass fractions of medium
p_default=101325Default 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_XDefault value for mass fractions of medium (for initialization)
nS=size(substanceNames, 1)Number of substances
nX=nSNumber of mass fractions
nXi=if fixedX then 0 else if reducedX then nS - 1 else nSNumber of structurally independent mass fractions (see docu for details)
nC=size(extraPropertiesNames, 1)Number of extra (outside of standard mass-balance) transported properties
C_nominal=1.0e-6*ones(nC)Default for the nominal values for the extra properties
Modelica.Media.Interfaces.PartialMedium.FluidConstants FluidConstants critical, triple, molecular and other standard data of fluid
Modelica.Media.Interfaces.PartialMedium.ThermodynamicState ThermodynamicState Minimal variable set that is available as input argument to every medium function
Modelica.Media.Interfaces.PartialMedium.prandtlNumber prandtlNumber Return the Prandtl number
Modelica.Media.Interfaces.PartialMedium.specificGibbsEnergy specificGibbsEnergy Return specific Gibbs energy
Modelica.Media.Interfaces.PartialMedium.specificHelmholtzEnergy specificHelmholtzEnergy Return specific Helmholtz energy
Modelica.Media.Interfaces.PartialMedium.heatCapacity_cp heatCapacity_cp alias for deprecated name
Modelica.Media.Interfaces.PartialMedium.heatCapacity_cv heatCapacity_cv alias for deprecated name
Modelica.Media.Interfaces.PartialMedium.isentropicExponent isentropicExponent Return isentropic exponent
Modelica.Media.Interfaces.PartialMedium.isentropicEnthalpy isentropicEnthalpy Return isentropic enthalpy
Modelica.Media.Interfaces.PartialMedium.velocityOfSound velocityOfSound Return velocity of sound
Modelica.Media.Interfaces.PartialMedium.isobaricExpansionCoefficient isobaricExpansionCoefficient Return overall the isobaric expansion coefficient beta
Modelica.Media.Interfaces.PartialMedium.beta beta alias for isobaricExpansionCoefficient for user convenience
Modelica.Media.Interfaces.PartialMedium.isothermalCompressibility isothermalCompressibility Return overall the isothermal compressibility factor
Modelica.Media.Interfaces.PartialMedium.kappa kappa alias of isothermalCompressibility for user convenience
Modelica.Media.Interfaces.PartialMedium.density_derp_h density_derp_h Return density derivative w.r.t. pressure at const specific enthalpy
Modelica.Media.Interfaces.PartialMedium.density_derh_p density_derh_p Return density derivative w.r.t. specific enthalpy at constant pressure
Modelica.Media.Interfaces.PartialMedium.density_derp_T density_derp_T Return density derivative w.r.t. pressure at const temperature
Modelica.Media.Interfaces.PartialMedium.density_derT_p density_derT_p Return density derivative w.r.t. temperature at constant pressure
Modelica.Media.Interfaces.PartialMedium.density_derX density_derX Return density derivative w.r.t. mass fraction
Modelica.Media.Interfaces.PartialMedium.molarMass molarMass Return the molar mass of the medium
Modelica.Media.Interfaces.PartialMedium.specificEnthalpy_pTX specificEnthalpy_pTX Return specific enthalpy from p, T, and X or Xi
Modelica.Media.Interfaces.PartialMedium.specificEntropy_pTX specificEntropy_pTX Return specific enthalpy from p, T, and X or Xi
Modelica.Media.Interfaces.PartialMedium.density_pTX density_pTX Return density from p, T, and X or Xi
Modelica.Media.Interfaces.PartialMedium.temperature_phX temperature_phX Return temperature from p, h, and X or Xi
Modelica.Media.Interfaces.PartialMedium.density_phX density_phX Return density from p, h, and X or Xi
Modelica.Media.Interfaces.PartialMedium.temperature_psX temperature_psX Return temperature from p,s, and X or Xi
Modelica.Media.Interfaces.PartialMedium.density_psX density_psX Return density from p, s, and X or Xi
Modelica.Media.Interfaces.PartialMedium.specificEnthalpy_psX 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
Modelica.Media.Interfaces.PartialMedium.Choices 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[:,2] tableDensity "Table for rho(T)";

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

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

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

  constant Real[:,2] 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

function to invert temperatures

Inputs

TypeNameDefaultDescription
Realtable[:] table temperature data
BooleanTink flag for Celsius or Kelvin

Outputs

TypeNameDescription
RealinvTable[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 Modelica.Media.Incompressible.TableBased.BaseProperties

Base properties of T dependent medium

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

TypeNameDefaultDescription
TemperatureT_start298.15initial temperature [K]
BooleanstandardOrderComponentstrueif true, and reducedX = true, the last element of X will be computed from the other ones
Pressure_barp_barCv.to_bar(p)Absolute pressure of medium in [bar] [bar]
Advanced
BooleanpreferredMediumStatesfalse= 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 Modelica.Media.Incompressible.TableBased.setState_pTX

Returns state record, given pressure and temperature

Information

Extends from (Return thermodynamic state as function of p, T and composition X or Xi).

Inputs

TypeNameDefaultDescription
AbsolutePressurep Pressure [Pa]
TemperatureT Temperature [K]
MassFractionX[:]reference_XMass fractions [kg/kg]

Outputs

TypeNameDescription
ThermodynamicStatestatethermodynamic 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 Modelica.Media.Incompressible.TableBased.setState_dTX

Returns state record, given pressure and temperature

Information

Extends from (Return thermodynamic state as function of d, T and composition X or Xi).

Inputs

TypeNameDefaultDescription
Densityd density [kg/m3]
TemperatureT Temperature [K]
MassFractionX[:]reference_XMass fractions [kg/kg]

Outputs

TypeNameDescription
ThermodynamicStatestatethermodynamic 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

returns state record as function of p and T

Inputs

TypeNameDefaultDescription
AbsolutePressurep pressure [Pa]
TemperatureT temperature [K]

Outputs

TypeNameDescription
ThermodynamicStatestatethermodynamic 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 Modelica.Media.Incompressible.TableBased.setState_phX

Returns state record, given pressure and specific enthalpy

Information

Extends from (Return thermodynamic state as function of p, h and composition X or Xi).

Inputs

TypeNameDefaultDescription
AbsolutePressurep Pressure [Pa]
SpecificEnthalpyh Specific enthalpy [J/kg]
MassFractionX[:]reference_XMass fractions [kg/kg]

Outputs

TypeNameDescription
ThermodynamicStatestatethermodynamic 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

returns state record as function of p and h

Inputs

TypeNameDefaultDescription
AbsolutePressurep pressure [Pa]
SpecificEnthalpyh specific enthalpy [J/kg]

Outputs

TypeNameDescription
ThermodynamicStatestatethermodynamic 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 Modelica.Media.Incompressible.TableBased.setState_psX

Returns state record, given pressure and specific entropy

Information

Extends from (Return thermodynamic state as function of p, s and composition X or Xi).

Inputs

TypeNameDefaultDescription
AbsolutePressurep Pressure [Pa]
SpecificEntropys Specific entropy [J/(kg.K)]
MassFractionX[:]reference_XMass fractions [kg/kg]

Outputs

TypeNameDescription
ThermodynamicStatestatethermodynamic 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

returns state record as function of p and s

Inputs

TypeNameDefaultDescription
AbsolutePressurep pressure [Pa]
SpecificEntropys specific entropy [J/(kg.K)]

Outputs

TypeNameDescription
ThermodynamicStatestatethermodynamic 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 Modelica.Media.Incompressible.TableBased.setSmoothState

Return thermodynamic state so that it smoothly approximates: if x > 0 then state_a else state_b

Information

Extends from (Return thermodynamic state so that it smoothly approximates: if x > 0 then state_a else state_b).

Inputs

TypeNameDefaultDescription
Realx m_flow or dp
ThermodynamicStatestate_a Thermodynamic state if x > 0
ThermodynamicStatestate_b Thermodynamic state if x < 0
Realx_small Smooth transition in the region -x_small < x < x_small

Outputs

TypeNameDescription
ThermodynamicStatestateSmooth 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 Modelica.Media.Incompressible.TableBased.specificHeatCapacityCv

Specific heat capacity at constant volume (or pressure) of medium

Information

Extends from (Return specific heat capacity at constant volume).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
SpecificHeatCapacitycvSpecific 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 Modelica.Media.Incompressible.TableBased.specificHeatCapacityCp

Specific heat capacity at constant volume (or pressure) of medium

Information

Extends from (Return specific heat capacity at constant pressure).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
SpecificHeatCapacitycpSpecific 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 Modelica.Media.Incompressible.TableBased.dynamicViscosity

Return dynamic viscosity as a function of the thermodynamic state record

Information

Extends from (Return dynamic viscosity).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
DynamicViscosityetaDynamic 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 Modelica.Media.Incompressible.TableBased.thermalConductivity

Return thermal conductivity as a function of the thermodynamic state record

Information

Extends from (Return thermal conductivity).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
ThermalConductivitylambdaThermal 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

compute specific entropy

Inputs

TypeNameDefaultDescription
TemperatureT temperature [K]

Outputs

TypeNameDescription
SpecificEntropysspecific 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 Modelica.Media.Incompressible.TableBased.specificEntropy

Return specific entropy as a function of the thermodynamic state record

Information

Extends from (Return specific entropy).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
SpecificEntropysSpecific 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 Modelica.Media.Incompressible.TableBased.h_T

Compute specific enthalpy from temperature

Information

Extends from Modelica.Icons.Function (Icon for functions).

Inputs

TypeNameDefaultDescription
TemperatureT Temperature [K]

Outputs

TypeNameDescription
SpecificEnthalpyhSpecific 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 Modelica.Media.Incompressible.TableBased.h_T_der

Compute specific enthalpy from temperature

Information

Extends from Modelica.Icons.Function (Icon for functions).

Inputs

TypeNameDefaultDescription
TemperatureT Temperature [K]
RealdT temperature derivative

Outputs

TypeNameDescription
Realdhderivative 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 Modelica.Media.Incompressible.TableBased.h_pT

Compute specific enthalpy from pressure and temperature

Information

Extends from Modelica.Icons.Function (Icon for functions).

Inputs

TypeNameDefaultDescription
Pressurep Pressure [Pa]
TemperatureT Temperature [K]
BooleandensityOfTfalseinclude or neglect density derivative dependence of enthalpy

Outputs

TypeNameDescription
SpecificEnthalpyhSpecific 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

Return density as function of temperature

Inputs

TypeNameDefaultDescription
TemperatureT temperature [K]

Outputs

TypeNameDescription
Densityddensity [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 Modelica.Media.Incompressible.TableBased.temperature

Return temperature as a function of the thermodynamic state record

Information

Extends from (Return temperature).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
TemperatureTTemperature [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 Modelica.Media.Incompressible.TableBased.pressure

Return pressure as a function of the thermodynamic state record

Information

Extends from (Return pressure).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
AbsolutePressurepPressure [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 Modelica.Media.Incompressible.TableBased.density

Return density as a function of the thermodynamic state record

Information

Extends from (Return density).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
DensitydDensity [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 Modelica.Media.Incompressible.TableBased.specificEnthalpy

Return specific enthalpy as a function of the thermodynamic state record

Information

Extends from (Return specific enthalpy).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
SpecificEnthalpyhSpecific 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 Modelica.Media.Incompressible.TableBased.specificInternalEnergy

Return specific internal energy as a function of the thermodynamic state record

Information

Extends from (Return specific internal energy).

Inputs

TypeNameDefaultDescription
ThermodynamicStatestate thermodynamic state record

Outputs

TypeNameDescription
SpecificEnergyuSpecific 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

Compute temperature from pressure and specific enthalpy

Inputs

TypeNameDefaultDescription
AbsolutePressurep pressure [Pa]
SpecificEnthalpyh specific enthalpy [J/kg]

Outputs

TypeNameDescription
TemperatureTtemperature [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

Compute temperature from pressure and specific enthalpy

Inputs

TypeNameDefaultDescription
AbsolutePressurep pressure [Pa]
SpecificEntropys specific entropy [J/(kg.K)]

Outputs

TypeNameDescription
TemperatureTtemperature [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;

Automatically generated Fri Nov 12 16:31:34 2010.