/SharpProp

A simple, full-featured, lightweight, cross-platform CoolProp wrapper for C#

Primary LanguageC#MIT LicenseMIT

SharpProp

Build & Tests CodeQL NuGet Platform License Codecov

A simple, full-featured, lightweight, cross-platform CoolProp wrapper for C#.

Navigation

How to install

Add it via CLI:

dotnet add package SharpProp

Or go to NuGet Gallery | SharpProp for detailed instructions.

Unit safety

All calculations of thermophysical properties are unit safe (thanks to UnitsNet). This allows you to avoid errors associated with incorrect dimensions of quantities, and will help you save a lot of time on their search and elimination. In addition, you will be able to convert all values to many other dimensions without the slightest difficulty.

Project structure

  • Fluid class - an implementation of pure fluids and binary mixtures (IFluid interface).
  • Mixture class - an implementation of mixtures with pure fluids components (IMixture interface).
  • FluidsList enum - a list of all available fluids.
  • Input record - the inputs for the Fluid and Mixture classes (IKeyedInput<Parameters> interface).
  • HumidAir class - an implementation of real humid air (IHumidAir interface).
  • InputHumidAir record - the inputs for the HumidAir class (IKeyedInput<string> interface).

List of properties

If the required property is not present in the instance of the fluid, then you can add it by extending the Fluid, Mixture or HumidAir classes (see how to add other properties).

Properties of Fluid and Mixture instances

  • Compressibility - compressibility factor (dimensionless).
  • Conductivity - thermal conductivity (by default, W/m/K).
  • CriticalPressure - absolute pressure at the critical point (by default, kPa).
  • CriticalTemperature - temperature at the critical point (by default, °C).
  • Density - mass density (by default, kg/m3).
  • DynamicViscosity - dynamic viscosity (by default, mPa*s).
  • Enthalpy - mass specific enthalpy (by default, kJ/kg).
  • Entropy - mass specific entropy (by default, kJ/kg/K).
  • FreezingTemperature - temperature at the freezing point (for incompressible fluids) (by default, °C).
  • InternalEnergy - mass specific internal energy (by default, kJ/kg).
  • KinematicViscosity - kinematic viscosity (by default, cSt).
  • MaxPressure - maximum pressure limit (by default, kPa).
  • MaxTemperature - maximum temperature limit (by default, °C).
  • MinPressure - minimum pressure limit (by default, kPa).
  • MinTemperature - minimum temperature limit (by default, °C).
  • MolarMass - molar mass (by default, g/mol).
  • Phase - phase state (enum).
  • Prandtl - Prandtl number (dimensionless).
  • Pressure - absolute pressure (by default, kPa).
  • Quality - mass vapor quality (by default, %).
  • SoundSpeed - sound speed (by default, m/s).
  • SpecificHeat - mass specific constant pressure specific heat (by default, kJ/kg/K).
  • SpecificVolume - mass specific volume (by default, m3/kg).
  • SurfaceTension - surface tension (by default, N/m).
  • Temperature - temperature (by default, °C).
  • TriplePressure - absolute pressure at the triple point (by default, kPa).
  • TripleTemperature - temperature at the triple point (by default, °C).

Properties of HumidAir instances

  • Compressibility - compressibility factor (dimensionless).
  • Conductivity - thermal conductivity (by default, W/m/K).
  • Density - mass density per humid air unit (by default, kg/m3).
  • DewTemperature - dew-point temperature (by default, °C).
  • DynamicViscosity - dynamic viscosity (by default, mPa*s).
  • Enthalpy - mass specific enthalpy per humid air (by default, kJ/kg).
  • Entropy - mass specific entropy per humid air (by default, kJ/kg/K).
  • Humidity - absolute humidity ratio (by default, g/kg d.a.).
  • KinematicViscosity - kinematic viscosity (by default, cSt).
  • PartialPressure - partial pressure of water vapor (by default, kPa).
  • Prandtl - Prandtl number (dimensionless).
  • Pressure - absolute pressure (by default, kPa).
  • RelativeHumidity - relative humidity ratio (by default, %).
  • SpecificHeat - mass specific constant pressure specific heat per humid air (by default, kJ/kg/K).
  • SpecificVolume - mass specific volume per humid air unit (by default, m3/kg).
  • Temperature - dry-bulb temperature (by default, °C).
  • WetBulbTemperature - wet-bulb temperature (by default, °C).

List of methods

For more information, see the XML documentation.

Methods of Fluid instances

  • Update - updates the state of the fluid.
  • Reset - resets all non-trivial properties.
  • SpecifyPhase - specify the phase state for all further calculations.
  • UnspecifyPhase - unspecify the phase state and go back to calculating it based on the inputs.
  • WithState - returns a new fluid instance with a defined state.
  • IsentropicCompressionTo - the process of isentropic compression to a given pressure.
  • CompressionTo - the process of compression to a given pressure.
  • IsenthalpicExpansionTo - the process of isenthalpic expansion to a given pressure.
  • IsentropicExpansionTo - the process of isentropic expansion to a given pressure.
  • ExpansionTo - the process of expansion to a given pressure.
  • CoolingTo - the process of cooling to a given temperature or enthalpy.
  • HeatingTo - the process of heating to a given temperature or enthalpy.
  • BubblePointAt - returns a bubble point at a given pressure or temperature.
  • DewPointAt - returns a dew point at a given pressure or temperature.
  • TwoPhasePointAt - returns a two-phase point at a given pressure.
  • Mixing - the mixing process.
  • Factory - returns a new fluid instance with no defined state.
  • Clone - performs deep (full) copy of the fluid instance.
  • AsJson - converts the fluid instance to a JSON string.

Methods of Mixture instances

  • Update - updates the state of the mixture.
  • Reset - resets all non-trivial properties.
  • SpecifyPhase - specify the phase state for all further calculations.
  • UnspecifyPhase - unspecify the phase state and go back to calculating it based on the inputs.
  • WithState - returns a new mixture instance with a defined state.
  • CoolingTo - the process of cooling to a given temperature.
  • HeatingTo - the process of heating to a given temperature.
  • Factory - returns a new mixture instance with no defined state.
  • Clone - performs deep (full) copy of the mixture instance.
  • AsJson - converts the mixture instance to a JSON string.

Methods of HumidAir instances

  • Update - updates the state of the humid air.
  • Reset - resets all properties.
  • WithState - returns a new humid air instance with a defined state.
  • DryCoolingTo - the process of cooling without dehumidification to a given temperature or enthalpy.
  • WetCoolingTo - the process of cooling with dehumidification to a given temperature or enthalpy and relative or absolute humidity ratio.
  • HeatingTo - the process of heating to a given temperature or enthalpy.
  • HumidificationByWaterTo - the process of humidification by water (isenthalpic) to a given relative or absolute humidity ratio.
  • HumidificationBySteamTo - the process of humidification by steam (isothermal) to a given relative or absolute humidity ratio.
  • Mixing - the mixing process.
  • Factory - returns a new humid air instance with no defined state.
  • Clone - performs deep (full) copy of the humid air instance.
  • AsJson - converts the humid air instance to a JSON string.

Examples

Pure fluids

To calculate the specific heat of saturated water vapor at 1 atm:

using SharpProp;
using UnitsNet.NumberExtensions.NumberToPressure;
using UnitsNet.Units;

var waterVapour = new Fluid(FluidsList.Water).DewPointAt((1).Atmospheres());
Console.WriteLine(waterVapour.SpecificHeat.JoulesPerKilogramKelvin);          // 2079.937085633241
Console.WriteLine(waterVapour.SpecificHeat);                                  // 2.08 kJ/kg·K
Console.WriteLine(
    waterVapour.SpecificHeat.ToUnit(SpecificEntropyUnit.CaloriePerGramKelvin) // 0.5 cal/g·K
);

Incompressible binary mixtures

To calculate the dynamic viscosity of propylene glycol aqueous solution with 60 % mass fraction at 100 kPa and -20 °C:

using SharpProp;
using UnitsNet.NumberExtensions.NumberToPressure;
using UnitsNet.NumberExtensions.NumberToRatio;
using UnitsNet.NumberExtensions.NumberToTemperature;
using UnitsNet.Units;

var propyleneGlycol = new Fluid(FluidsList.MPG, (60).Percent()).WithState(
    Input.Pressure((100).Kilopascals()),
    Input.Temperature((-20).DegreesCelsius())
);
Console.WriteLine(propyleneGlycol.DynamicViscosity?.PascalSeconds);      // 0.13907391053938878
Console.WriteLine(propyleneGlycol.DynamicViscosity);                     // 139.07 mPa·s
Console.WriteLine(
    propyleneGlycol.DynamicViscosity?.ToUnit(DynamicViscosityUnit.Poise) // 1.39 P
);

Mixtures

To calculate the density of ethanol aqueous solution (with ethanol 40 % mass fraction) at 200 kPa and 277.15 K:

using SharpProp;
using UnitsNet;
using UnitsNet.NumberExtensions.NumberToPressure;
using UnitsNet.NumberExtensions.NumberToRatio;
using UnitsNet.NumberExtensions.NumberToTemperature;
using UnitsNet.Units;

var mixture = new Mixture(
    new List<FluidsList> { FluidsList.Water, FluidsList.Ethanol },
    new List<Ratio> { (60).Percent(), (40).Percent() }
).WithState(
    Input.Pressure((200).Kilopascals()),
    Input.Temperature((277.15).Kelvins())
);
Console.WriteLine(mixture.Density.KilogramsPerCubicMeter);               // 883.3922771627759
Console.WriteLine(mixture.Density);                                      // 883.39 kg/m3
Console.WriteLine(mixture.Density.ToUnit(DensityUnit.GramPerDeciliter)); // 88.34 g/dl

Humid air

To calculate the wet bulb temperature of humid air at 300 m above sea level, 30 °C and 50 % relative humidity:

using SharpProp;
using UnitsNet.NumberExtensions.NumberToLength;
using UnitsNet.NumberExtensions.NumberToRelativeHumidity;
using UnitsNet.NumberExtensions.NumberToTemperature;
using UnitsNet.Units;

var humidAir = new HumidAir().WithState(
    InputHumidAir.Altitude((300).Meters()),
    InputHumidAir.Temperature((30).DegreesCelsius()),
    InputHumidAir.RelativeHumidity((50).Percent())
);
Console.WriteLine(humidAir.WetBulbTemperature.Kelvins);                  // 295.06756903366403
Console.WriteLine(humidAir.WetBulbTemperature);                          // 21.92 °C
Console.WriteLine(
    humidAir.WetBulbTemperature.ToUnit(TemperatureUnit.DegreeFahrenheit) // 71.45 °F
);

Equality of instances

You can simply determine the equality of Fluid, Mixture and HumidAir instances by its state. Just use the Equals method (not the equality operators: == and !=). Exactly the same way you can compare inputs (Input, InputHumidAir or any IKeyedInput record).

For example:

using SharpProp;
using UnitsNet.NumberExtensions.NumberToPressure;
using UnitsNet.NumberExtensions.NumberToRelativeHumidity;
using UnitsNet.NumberExtensions.NumberToTemperature;

var humidAir = new HumidAir().WithState(
    InputHumidAir.Pressure((1).Atmospheres()),
    InputHumidAir.Temperature((20).DegreesCelsius()),
    InputHumidAir.RelativeHumidity((50).Percent())
);
var sameHumidAir = new HumidAir().WithState(
    InputHumidAir.Pressure((101325).Pascals()),
    InputHumidAir.Temperature((293.15).Kelvins()),
    InputHumidAir.RelativeHumidity((50).Percent())
);
Console.WriteLine(humidAir.Equals(sameHumidAir)); // true

Converting to a JSON string

The Fluid, Mixture and HumidAir classes have the AsJson method, which converts the instance to a JSON string. For example, converting a Fluid instance to an indented JSON string:

using SharpProp;
using UnitsNet.NumberExtensions.NumberToTemperature;

var refrigerant = new Fluid(FluidsList.R32).DewPointAt((5).DegreesCelsius());
Console.WriteLine(refrigerant.AsJson());

As a result:

{
  "Name": "R32",
  "Fraction": {
    "Unit": "RatioUnit.Percent",
    "Value": 100.0
  },
  "Compressibility": 0.8266625877210833,
  "Conductivity": {
    "Unit": "ThermalConductivityUnit.WattPerMeterKelvin",
    "Value": 0.013435453854396475
  },
  "CriticalPressure": {
    "Unit": "PressureUnit.Kilopascal",
    "Value": 5782.0
  },
  "CriticalTemperature": {
    "Unit": "TemperatureUnit.DegreeCelsius",
    "Value": 78.10500000000002
  },
  "Density": {
    "Unit": "DensityUnit.KilogramPerCubicMeter",
    "Value": 25.89088151061046
  },
  "DynamicViscosity": {
    "Unit": "DynamicViscosityUnit.MillipascalSecond",
    "Value": 0.012606543144761657
  },
  "Enthalpy": {
    "Unit": "SpecificEnergyUnit.KilojoulePerKilogram",
    "Value": 516.1057800378023
  },
  "Entropy": {
    "Unit": "SpecificEntropyUnit.KilojoulePerKilogramKelvin",
    "Value": 2.1362654412978777
  },
  "FreezingTemperature": null,
  "InternalEnergy": {
    "Unit": "SpecificEnergyUnit.KilojoulePerKilogram",
    "Value": 479.35739743435374
  },
  "KinematicViscosity": {
    "Unit": "KinematicViscosityUnit.Centistokes",
    "Value": 0.48691054182899535
  },
  "MaxPressure": {
    "Unit": "PressureUnit.Kilopascal",
    "Value": 70000.0
  },
  "MaxTemperature": {
    "Unit": "TemperatureUnit.DegreeCelsius",
    "Value": 161.85000000000002
  },
  "MinPressure": {
    "Unit": "PressureUnit.Kilopascal",
    "Value": 0.04799989387605937
  },
  "MinTemperature": {
    "Unit": "TemperatureUnit.DegreeCelsius",
    "Value": -136.80999999999997
  },
  "MolarMass": {
    "Unit": "MolarMassUnit.GramPerMole",
    "Value": 52.024
  },
  "Phase": "TwoPhase",
  "Prandtl": 1.2252282243443504,
  "Pressure": {
    "Unit": "PressureUnit.Kilopascal",
    "Value": 951.448019691762
  },
  "Quality": {
    "Unit": "RatioUnit.Percent",
    "Value": 100.0
  },
  "SoundSpeed": {
    "Unit": "SpeedUnit.MeterPerSecond",
    "Value": 209.6337575990297
  },
  "SpecificHeat": {
    "Unit": "SpecificEntropyUnit.KilojoulePerKilogramKelvin",
    "Value": 1.3057899441785379
  },
  "SpecificVolume": {
    "Unit": "SpecificVolumeUnit.CubicMeterPerKilogram",
    "Value": 0.03862363664945844
  },
  "SurfaceTension": {
    "Unit": "ForcePerLengthUnit.NewtonPerMeter",
    "Value": 0.010110117241546162
  },
  "Temperature": {
    "Unit": "TemperatureUnit.DegreeCelsius",
    "Value": 5.0
  },
  "TriplePressure": {
    "Unit": "PressureUnit.Kilopascal",
    "Value": 0.04799989387605937
  },
  "TripleTemperature": {
    "Unit": "TemperatureUnit.DegreeCelsius",
    "Value": -136.80999999999997
  }
}

Deep cloning

The Fluid, Mixture and HumidAir classes have the Clone method, which performs a deep (full) copy of the instance:

using SharpProp;
using UnitsNet.NumberExtensions.NumberToPressure;
using UnitsNet.NumberExtensions.NumberToTemperature;

var origin = new Fluid(FluidsList.Water).WithState(
    Input.Pressure((1).Atmospheres()),
    Input.Temperature((20).DegreesCelsius())
);
var clone = origin.Clone();
Console.WriteLine(origin.Equals(clone)); // true
clone.Update(
    Input.Pressure((1).Atmospheres()),
    Input.Temperature((30).DegreesCelsius())
);
Console.WriteLine(origin.Equals(clone)); // false

Adding other properties

Adding other inputs