public void ComparisonOperators()
{
TemperatureDelta oneKelvin = TemperatureDelta.FromKelvins(1);
TemperatureDelta twoKelvins = TemperatureDelta.FromKelvins(2);
Assert.True(oneKelvin < twoKelvins);
Assert.True(oneKelvin <= twoKelvins);
Assert.True(twoKelvins > oneKelvin);
Assert.True(twoKelvins >= oneKelvin);
Assert.False(oneKelvin > twoKelvins);
Assert.False(oneKelvin >= twoKelvins);
Assert.False(twoKelvins < oneKelvin);
Assert.False(twoKelvins <= oneKelvin);
}
public void EqualityOperators()
{
var a = TemperatureDelta.FromKelvins(1);
var b = TemperatureDelta.FromKelvins(2);
// ReSharper disable EqualExpressionComparison
Assert.True(a == a);
Assert.False(a != a);
Assert.True(a != b);
Assert.False(a == b);
Assert.False(a == null);
Assert.False(null == a);
// ReSharper restore EqualExpressionComparison
}
public void ToUnit()
{
var kelvin = TemperatureDelta.FromKelvins(1);
var degreecelsiusQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeCelsius);
AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, (double)degreecelsiusQuantity.Value, DegreesCelsiusTolerance);
Assert.Equal(TemperatureDeltaUnit.DegreeCelsius, degreecelsiusQuantity.Unit);
var degreedelisleQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeDelisle);
AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, (double)degreedelisleQuantity.Value, DegreesDelisleTolerance);
Assert.Equal(TemperatureDeltaUnit.DegreeDelisle, degreedelisleQuantity.Unit);
var degreefahrenheitQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeFahrenheit);
AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, (double)degreefahrenheitQuantity.Value, DegreesFahrenheitTolerance);
Assert.Equal(TemperatureDeltaUnit.DegreeFahrenheit, degreefahrenheitQuantity.Unit);
var degreenewtonQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeNewton);
AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, (double)degreenewtonQuantity.Value, DegreesNewtonTolerance);
Assert.Equal(TemperatureDeltaUnit.DegreeNewton, degreenewtonQuantity.Unit);
var degreerankineQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeRankine);
AssertEx.EqualTolerance(DegreesRankineInOneKelvin, (double)degreerankineQuantity.Value, DegreesRankineTolerance);
Assert.Equal(TemperatureDeltaUnit.DegreeRankine, degreerankineQuantity.Unit);
var degreereaumurQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeReaumur);
AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, (double)degreereaumurQuantity.Value, DegreesReaumurTolerance);
Assert.Equal(TemperatureDeltaUnit.DegreeReaumur, degreereaumurQuantity.Unit);
var degreeroemerQuantity = kelvin.ToUnit(TemperatureDeltaUnit.DegreeRoemer);
AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, (double)degreeroemerQuantity.Value, DegreesRoemerTolerance);
Assert.Equal(TemperatureDeltaUnit.DegreeRoemer, degreeroemerQuantity.Unit);
var kelvinQuantity = kelvin.ToUnit(TemperatureDeltaUnit.Kelvin);
AssertEx.EqualTolerance(KelvinsInOneKelvin, (double)kelvinQuantity.Value, KelvinsTolerance);
Assert.Equal(TemperatureDeltaUnit.Kelvin, kelvinQuantity.Unit);
}
public void ConversionRoundTrip()
{
TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
AssertEx.EqualTolerance(1, TemperatureDelta.FromCentidegreesCelsius(kelvin.CentidegreesCelsius).Kelvins, CentidegreesCelsiusTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDecidegreesCelsius(kelvin.DecidegreesCelsius).Kelvins, DecidegreesCelsiusTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromHectodegreesCelsius(kelvin.HectodegreesCelsius).Kelvins, HectodegreesCelsiusTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromKilodegreesCelsius(kelvin.KilodegreesCelsius).Kelvins, KilodegreesCelsiusTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromMicrodegreesCelsius(kelvin.MicrodegreesCelsius).Kelvins, MicrodegreesCelsiusTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins, MillidegreesCelsiusTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromNanodegreesCelsius(kelvin.NanodegreesCelsius).Kelvins, NanodegreesCelsiusTolerance);
}
public void As()
{
var kelvin = TemperatureDelta.FromKelvins(1);
AssertEx.EqualTolerance(CentidegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.CentidegreeCelsius), CentidegreesCelsiusTolerance);
AssertEx.EqualTolerance(DecidegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.DecidegreeCelsius), DecidegreesCelsiusTolerance);
AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeCelsius), DegreesCelsiusTolerance);
AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeDelisle), DegreesDelisleTolerance);
AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeFahrenheit), DegreesFahrenheitTolerance);
AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeNewton), DegreesNewtonTolerance);
AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRankine), DegreesRankineTolerance);
AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeReaumur), DegreesReaumurTolerance);
AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRoemer), DegreesRoemerTolerance);
AssertEx.EqualTolerance(HectodegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.HectodegreeCelsius), HectodegreesCelsiusTolerance);
AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.As(TemperatureDeltaUnit.Kelvin), KelvinsTolerance);
AssertEx.EqualTolerance(KilodegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.KilodegreeCelsius), KilodegreesCelsiusTolerance);
AssertEx.EqualTolerance(MicrodegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.MicrodegreeCelsius), MicrodegreesCelsiusTolerance);
AssertEx.EqualTolerance(MillidegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.MillidegreeCelsius), MillidegreesCelsiusTolerance);
AssertEx.EqualTolerance(NanodegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.NanodegreeCelsius), NanodegreesCelsiusTolerance);
}
public void KelvinToTemperatureDeltaUnits()
{
TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
AssertEx.EqualTolerance(CentidegreesCelsiusInOneKelvin, kelvin.CentidegreesCelsius, CentidegreesCelsiusTolerance);
AssertEx.EqualTolerance(DecidegreesCelsiusInOneKelvin, kelvin.DecidegreesCelsius, DecidegreesCelsiusTolerance);
AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.DegreesCelsius, DegreesCelsiusTolerance);
AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.DegreesDelisle, DegreesDelisleTolerance);
AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.DegreesFahrenheit, DegreesFahrenheitTolerance);
AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.DegreesNewton, DegreesNewtonTolerance);
AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.DegreesRankine, DegreesRankineTolerance);
AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.DegreesReaumur, DegreesReaumurTolerance);
AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.DegreesRoemer, DegreesRoemerTolerance);
AssertEx.EqualTolerance(HectodegreesCelsiusInOneKelvin, kelvin.HectodegreesCelsius, HectodegreesCelsiusTolerance);
AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.Kelvins, KelvinsTolerance);
AssertEx.EqualTolerance(KilodegreesCelsiusInOneKelvin, kelvin.KilodegreesCelsius, KilodegreesCelsiusTolerance);
AssertEx.EqualTolerance(MicrodegreesCelsiusInOneKelvin, kelvin.MicrodegreesCelsius, MicrodegreesCelsiusTolerance);
AssertEx.EqualTolerance(MillidegreesCelsiusInOneKelvin, kelvin.MillidegreesCelsius, MillidegreesCelsiusTolerance);
AssertEx.EqualTolerance(NanodegreesCelsiusInOneKelvin, kelvin.NanodegreesCelsius, NanodegreesCelsiusTolerance);
}
public void As()
{
var kelvin = TemperatureDelta.FromKelvins(1);
AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeCelsius), DegreesCelsiusTolerance);
AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeCelsiusDelta), DegreesCelsiusDeltaTolerance);
AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeDelisle), DegreesDelisleTolerance);
AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeDelisleDelta), DegreesDelisleDeltaTolerance);
AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeFahrenheit), DegreesFahrenheitTolerance);
AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeFahrenheitDelta), DegreesFahrenheitDeltaTolerance);
AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeNewton), DegreesNewtonTolerance);
AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeNewtonDelta), DegreesNewtonDeltaTolerance);
AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRankine), DegreesRankineTolerance);
AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRankineDelta), DegreesRankineDeltaTolerance);
AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeReaumur), DegreesReaumurTolerance);
AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeReaumurDelta), DegreesReaumurDeltaTolerance);
AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRoemer), DegreesRoemerTolerance);
AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.DegreeRoemerDelta), DegreesRoemerDeltaTolerance);
AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.As(TemperatureDeltaUnit.Kelvin), KelvinsTolerance);
AssertEx.EqualTolerance(KelvinsDeltaInOneKelvin, kelvin.As(TemperatureDeltaUnit.KelvinDelta), KelvinsDeltaTolerance);
}
public void ConversionRoundTrip()
{
TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsiusDelta(kelvin.DegreesCelsiusDelta).Kelvins, DegreesCelsiusDeltaTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisleDelta(kelvin.DegreesDelisleDelta).Kelvins, DegreesDelisleDeltaTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheitDelta(kelvin.DegreesFahrenheitDelta).Kelvins, DegreesFahrenheitDeltaTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewtonDelta(kelvin.DegreesNewtonDelta).Kelvins, DegreesNewtonDeltaTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankineDelta(kelvin.DegreesRankineDelta).Kelvins, DegreesRankineDeltaTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumurDelta(kelvin.DegreesReaumurDelta).Kelvins, DegreesReaumurDeltaTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemerDelta(kelvin.DegreesRoemerDelta).Kelvins, DegreesRoemerDeltaTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvinsDelta(kelvin.KelvinsDelta).Kelvins, KelvinsDeltaTolerance);
}
public void KelvinToTemperatureDeltaUnits()
{
TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
AssertEx.EqualTolerance(DegreesCelsiusInOneKelvin, kelvin.DegreesCelsius, DegreesCelsiusTolerance);
AssertEx.EqualTolerance(DegreesCelsiusDeltaInOneKelvin, kelvin.DegreesCelsiusDelta, DegreesCelsiusDeltaTolerance);
AssertEx.EqualTolerance(DegreesDelisleInOneKelvin, kelvin.DegreesDelisle, DegreesDelisleTolerance);
AssertEx.EqualTolerance(DegreesDelisleDeltaInOneKelvin, kelvin.DegreesDelisleDelta, DegreesDelisleDeltaTolerance);
AssertEx.EqualTolerance(DegreesFahrenheitInOneKelvin, kelvin.DegreesFahrenheit, DegreesFahrenheitTolerance);
AssertEx.EqualTolerance(DegreesFahrenheitDeltaInOneKelvin, kelvin.DegreesFahrenheitDelta, DegreesFahrenheitDeltaTolerance);
AssertEx.EqualTolerance(DegreesNewtonInOneKelvin, kelvin.DegreesNewton, DegreesNewtonTolerance);
AssertEx.EqualTolerance(DegreesNewtonDeltaInOneKelvin, kelvin.DegreesNewtonDelta, DegreesNewtonDeltaTolerance);
AssertEx.EqualTolerance(DegreesRankineInOneKelvin, kelvin.DegreesRankine, DegreesRankineTolerance);
AssertEx.EqualTolerance(DegreesRankineDeltaInOneKelvin, kelvin.DegreesRankineDelta, DegreesRankineDeltaTolerance);
AssertEx.EqualTolerance(DegreesReaumurInOneKelvin, kelvin.DegreesReaumur, DegreesReaumurTolerance);
AssertEx.EqualTolerance(DegreesReaumurDeltaInOneKelvin, kelvin.DegreesReaumurDelta, DegreesReaumurDeltaTolerance);
AssertEx.EqualTolerance(DegreesRoemerInOneKelvin, kelvin.DegreesRoemer, DegreesRoemerTolerance);
AssertEx.EqualTolerance(DegreesRoemerDeltaInOneKelvin, kelvin.DegreesRoemerDelta, DegreesRoemerDeltaTolerance);
AssertEx.EqualTolerance(KelvinsInOneKelvin, kelvin.Kelvins, KelvinsTolerance);
AssertEx.EqualTolerance(KelvinsDeltaInOneKelvin, kelvin.KelvinsDelta, KelvinsDeltaTolerance);
}
/// <inheritdoc cref="TemperatureDelta.FromKelvins(double)"/> public static TemperatureDelta Kelvins(this decimal value) => TemperatureDelta.FromKelvins(Convert.ToDouble(value));
/// <inheritdoc cref="TemperatureDelta.FromKelvins(double)"/> public static TemperatureDelta Kelvins(this double value) => TemperatureDelta.FromKelvins(value);
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
{
var quantity = TemperatureDelta.FromKelvins(value);
Assert.Equal(TemperatureDelta.FromKelvins(-value), -quantity);
}
public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
}
public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal(TemperatureDelta.Info, Convert.ChangeType(quantity, typeof(QuantityInfo)));
}
public void Convert_ChangeType_UnitType_EqualsUnit()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(TemperatureDeltaUnit)));
}
public void Convert_ToUInt64_EqualsValueAsSameType()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
}
public void Convert_ChangeType_SelfType_EqualsSelf()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(TemperatureDelta)));
}
public void ToString_NullArgs_ThrowsArgumentNullException()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Throws <ArgumentNullException>(() => quantity.ToString(null, "g", null));
}
public void Convert_ChangeType_QuantityType_EqualsQuantityType()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal(QuantityType.TemperatureDelta, Convert.ChangeType(quantity, typeof(QuantityType)));
}
public void ToString_NullProvider_EqualsCurrentUICulture()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g"));
}
public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal(TemperatureDelta.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
}
public void Convert_ToDateTime_ThrowsInvalidCastException()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity));
}
public void GetHashCode_Equals()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal(new { TemperatureDelta.Info.Name, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
}
public void Convert_ToDecimal_EqualsValueAsSameType()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity));
}
public Form1()
{
//Starting up frontpage
InitializeComponent();
//Starting LOGPH diagram
Plot_LogPH LOGPH = new Plot_LogPH(MyChart, FluidList.Ammonia);
PlotXY XYChart = new PlotXY(MyChartXY);
//Playing around with a normal XY Graph
XYChart.Plot(Power.FromKilowatts(10), MassFlow.FromKilogramsPerSecond(1));
XYChart.Plot(Power.FromKilowatts(11), MassFlow.FromKilogramsPerSecond(1.2));
XYChart.Plot(Power.FromKilowatts(12), MassFlow.FromKilogramsPerSecond(1.6));
XYChart.Plot(Power.FromKilowatts(13), MassFlow.FromKilogramsPerSecond(1.7));
XYChart.Plot(Power.FromKilowatts(14), MassFlow.FromKilogramsPerSecond(1.8));
XYChart.Plot(Power.FromKilowatts(15), MassFlow.FromKilogramsPerSecond(1.9));
XYChart.Plot(Power.FromKilowatts(17), MassFlow.FromKilogramsPerSecond(2));
XYChart.Plot(Power.FromKilowatts(21), MassFlow.FromKilogramsPerSecond(2.8));
XYChart.Plot(Power.FromKilowatts(25), MassFlow.FromKilogramsPerSecond(3));
LOGPH.PlotLogPH();
Fluid Vand = new Fluid(FluidList.Water);
//Compressor calculations
Fluid CompressorInlet = new Fluid(FluidList.Ammonia);
Fluid CompressorOutlet = new Fluid(FluidList.Ammonia);
Fluid CompressorOutletH2s = new Fluid(FluidList.Ammonia);
//Giving the inlet guess on its condition
CompressorInlet.UpdatePX(Pressure.FromBars(5), 1);
LOGPH.Plot(CompressorInlet);
//Calculating the outlet af compressor
//This is h1
SpecificEnergy h1 = CompressorInlet.Enthalpy;
//Updating output refrigerant with the high pressure and the entropy(from input)
CompressorOutletH2s.UpdatePS(Pressure.FromBars(30), CompressorInlet.Entropy);
LOGPH.Plot(CompressorOutletH2s);
//Setting h2s from output-refrigerant
SpecificEnergy H2s = CompressorOutletH2s.Enthalpy;
//Compressor calculation
SpecificEnergy h2 = ((H2s - h1) / 0.80) + h1;
//Compressor outlet condition
CompressorOutlet.UpdatePH(CompressorOutletH2s.Pressure, h2);
LOGPH.Plot(CompressorOutlet);
//Plot Compressor as lines
LOGPH.Plot(CompressorInlet, CompressorOutlet);
//Creating a condensator
Fluid CondenserInlet = new Fluid(FluidList.Ammonia);
Fluid CondenserOutlet = new Fluid(FluidList.Ammonia);
//The inlet of the condenser is the same as compressor outlet
CondenserInlet.Copy(CompressorOutlet);
//Condensator outlet
CondenserOutlet.UpdatePX(CondenserInlet.Pressure, 0);
//Plot Condensator as lines
LOGPH.Plot(CondenserInlet, CondenserOutlet);
//Creating a Expansion valve
Fluid ValveInlet = new Fluid(FluidList.Ammonia);
Fluid ValveOutlet = new Fluid(FluidList.Ammonia);
//The inlet of the valve is the same as condens outlet
ValveInlet.Copy(CondenserOutlet);
//Expansion valve drops the pressure down but keeps the Enthalpy
ValveOutlet.UpdatePH(CompressorInlet.Pressure, ValveInlet.Enthalpy);
//Plot Valve as lines
LOGPH.Plot(ValveInlet, ValveOutlet);
//Creating an Evaporator
Fluid EvaporatorInlet = new Fluid(FluidList.Ammonia);
Fluid EvaporatorOutlet = new Fluid(FluidList.Ammonia);
//The inlet of the valve is the same as condens outlet
EvaporatorInlet.Copy(ValveOutlet);
//Creating a superheat of 10°C
EvaporatorOutlet.UpdatePT(EvaporatorInlet.Pressure, EvaporatorInlet.Tsat + TemperatureDelta.FromKelvins(10));
//Plot Valve as lines
LOGPH.Plot(EvaporatorInlet, EvaporatorOutlet);
//Telling the compressor that it is connected to the evaporator
CompressorInlet.Copy(EvaporatorOutlet);
//Calculations
//Can we find the power input to the compressor?
//Setting a massflow
MassFlow MassflowCompressor = MassFlow.FromKilogramsPerSecond(0.45);
//Power = Massflow * (H2 - H1)
Power PowerToCompressor = MassflowCompressor * (CompressorOutlet.Enthalpy - CompressorInlet.Enthalpy);
//Print it to Debug screen without telling it in what unit we want to see it
Debug.Print(PowerToCompressor.ToString());
//Giving it a unit to display it in
Debug.Print(PowerToCompressor.ToUnit(PowerUnit.Kilowatt).ToString());
///What if we want to calculation an equation that the unit-system cant handle?
//!Beware!: Normally you should let the UnitSystem handle the units because it checks the units for you
// and it puts out an error if you have messed up the units.
// Sometimes the unitsystem give you an error even though the equation is correct and then you have to
// do this to bypass the unitsystem and then you have to handle the units yourself!
//The Stefan - Boltzmann Constant
double σ = 5.6703 * 10E-8; //(W / m2K4)
Temperature TempOfBlackBody = Temperature.FromDegreesCelsius(20);
Area AreaOfBody = Area.FromSquareMeters(0.634);
//q = σ * T^4 * A
Power RadiationPower = Power.FromWatts(σ * Math.Pow(TempOfBlackBody.Kelvins, 4) * AreaOfBody.SquareMeters);
//Display result
Debug.Print(RadiationPower.ToUnit(PowerUnit.Kilowatt).ToString());
//Example: Putting code in Class to make it easyier to reuse
//New instance of a compressor
Compressor Comp1 = new Compressor(FluidList.Ammonia);
//Settings for the compressor
Comp1.DischargePressure = Pressure.FromBars(60);
Comp1.EtaI = 0.80;
Comp1.EtaV = 0.80;
//Giving the compressor en inlet condition
Comp1.Inlet.UpdatePX(Pressure.FromBars(20), 1);
//Calling the compressor calculations
Comp1.DoCalculation();
//Plotting the result
LOGPH.Plot(Comp1.Inlet, Comp1.Outlet);
}
public void Convert_ToInt32_EqualsValueAsSameType()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity));
}
/// <inheritdoc cref="TemperatureDelta.FromKelvins(double?)"/> public static TemperatureDelta?Kelvins(this float?value) => TemperatureDelta.FromKelvins(value);
public void Convert_ToSingle_EqualsValueAsSameType()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
}
/// <inheritdoc cref="TemperatureDelta.FromKelvins(double?)"/> public static TemperatureDelta?Kelvins(this decimal?value) => TemperatureDelta.FromKelvins(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void Convert_ToString_EqualsToString()
{
var quantity = TemperatureDelta.FromKelvins(1.0);
Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
}
