Big changes
This commit is contained in:
Duc
367
Source/TSRealLib/Common/Raytheon.Common/Units/Pressure.cs
Normal file
367
Source/TSRealLib/Common/Raytheon.Common/Units/Pressure.cs
Normal file
@@ -0,0 +1,367 @@
|
||||
//############################################################################//
|
||||
// RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION
|
||||
// PROPRIETARY TO RAYTHEON COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS
|
||||
// AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. DISCLOSURE TO
|
||||
// UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO
|
||||
// RAYTHEON COMPANY'S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS
|
||||
// CONTENTS SHALL BE FURNISHED OR DISCLOSED TO OR COPIED OR USED BY PERSONS
|
||||
// OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF RAYTHEON
|
||||
// COMPANY.
|
||||
//
|
||||
// THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S. GOVERNMENT
|
||||
//
|
||||
// UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
|
||||
//
|
||||
// WARNING: THIS DOCUMENT CONTAINS TECHNICAL DATA AND / OR TECHNOLOGY WHOSE
|
||||
// EXPORT OR DISCLOSURE TO NON-U.S. PERSONS, WHEREVER LOCATED, IS RESTRICTED
|
||||
// BY THE INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) (22 C.F.R. SECTION
|
||||
// 120-130) OR THE EXPORT ADMINISTRATION REGULATIONS (EAR) (15 C.F.R. SECTION
|
||||
// 730-774). THIS DOCUMENT CANNOT BE EXPORTED (E.G., PROVIDED TO A SUPPLIER
|
||||
// OUTSIDE OF THE UNITED STATES) OR DISCLOSED TO A NON-U.S. PERSON, WHEREVER
|
||||
// LOCATED, UNTIL A FINAL JURISDICTION AND CLASSIFICATION DETERMINATION HAS
|
||||
// BEEN COMPLETED AND APPROVED BY RAYTHEON, AND ANY REQUIRED U.S. GOVERNMENT
|
||||
// APPROVALS HAVE BEEN OBTAINED. VIOLATIONS ARE SUBJECT TO SEVERE CRIMINAL
|
||||
// PENALTIES.
|
||||
//
|
||||
// DOD 5220.22-M, INDUSTRIAL SECURITY MANUAL, CHAPTER 5, SECTION 1 THROUGH 9 :
|
||||
// FOR CLASSIFIED DOCUMENTS FOLLOW THE PROCEDURES IN OR DOD 5200.1-R,
|
||||
// INFORMATION SECURITY PROGRAM, CHAPTER 6. FOR UNCLASSIFIED, LIMITED DOCUMENTS
|
||||
// DESTROY BY ANY METHOD THAT WILL PREVENT DISCLOSURE OF CONTENTS OR
|
||||
// RECONSTRUCTION OF THE DOCUMENT.
|
||||
//############################################################################//
|
||||
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Runtime.Serialization;
|
||||
|
||||
namespace Raytheon.Units
|
||||
{
|
||||
/// <summary>
|
||||
/// This class represents a Pressure
|
||||
///
|
||||
/// It has no constructors. Instead, it provides multiple methods for creating objects of this
|
||||
/// type. Those methods are of the form FromXXX, where XXX is a unit (e.g. Pascal).
|
||||
///
|
||||
/// Properties (e.g. Pascal) are provided to convert the value to other units and return
|
||||
/// as type double.
|
||||
/// </summary>
|
||||
[Serializable]
|
||||
[DataContract]
|
||||
public class Pressure
|
||||
{
|
||||
public enum Unit
|
||||
{
|
||||
Bar,
|
||||
Millibar,
|
||||
Pascal,
|
||||
PSI
|
||||
}
|
||||
|
||||
public static IDictionary<Unit, List<string>> UnitAbbreviations = new Dictionary<Unit, List<string>>()
|
||||
{
|
||||
{Unit.Bar, new List<string>(){ "bar" } },
|
||||
{Unit.Millibar, new List<string>(){ "mbar" } },
|
||||
{Unit.Pascal, new List<string>(){ "Pa" } },
|
||||
{Unit.PSI, new List<string>(){ "PSI" } },
|
||||
};
|
||||
|
||||
private const Unit DefaultUnits = Unit.PSI;
|
||||
private const int PascalPerBar = 100000;
|
||||
private const double PascalPerPSI = 6894.75729;
|
||||
|
||||
[DataMember(Name = "Pascal", IsRequired = true)]
|
||||
private double _pressure; // Pascal
|
||||
|
||||
// map: unit => abbreviation, conversion method and property
|
||||
private static IDictionary<Unit, UnitInfo<Pressure>> _unitInfo = new Dictionary<Unit, UnitInfo<Pressure>>()
|
||||
{
|
||||
{ Unit.Bar, new UnitInfo<Pressure>(UnitAbbreviations[Unit.Bar], FromBar, typeof(Pressure).GetProperty("Bar").GetGetMethod()) },
|
||||
{ Unit.Millibar, new UnitInfo<Pressure>(UnitAbbreviations[Unit.Millibar], FromMillibar, typeof(Pressure).GetProperty("Millibar").GetGetMethod()) },
|
||||
{ Unit.Pascal, new UnitInfo<Pressure>(UnitAbbreviations[Unit.Pascal], FromPascal, typeof(Pressure).GetProperty("Pascal").GetGetMethod()) },
|
||||
{ Unit.PSI, new UnitInfo<Pressure>(UnitAbbreviations[Unit.PSI], FromPSI, typeof(Pressure).GetProperty("PSI").GetGetMethod()) }
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Prevents a default instance of the <see cref="Pressure"/> class from being created
|
||||
/// Use FromXXX methods to create objects of this type.
|
||||
/// </summary>
|
||||
private Pressure()
|
||||
{
|
||||
throw new InvalidOperationException("No one should be calling this, it is only here to prevent users from creating default object");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// ctor used by this class to create objects in FromXXX methods.
|
||||
/// </summary>
|
||||
/// <param name="pressure">The pressure - pascal</param>
|
||||
private Pressure(double pressure)
|
||||
{
|
||||
this._pressure = pressure;
|
||||
}
|
||||
|
||||
#region conversion properties
|
||||
public double Bar { get { return _pressure / PascalPerBar; } }
|
||||
|
||||
public double Millibar { get { return _pressure / PascalPerBar * 1000; } }
|
||||
|
||||
public double Pascal { get { return _pressure; } }
|
||||
|
||||
public double PSI { get { return _pressure / PascalPerPSI; } }
|
||||
#endregion
|
||||
|
||||
#region Creation Methods
|
||||
public static Pressure FromBar(double bars)
|
||||
{
|
||||
return new Pressure(bars * PascalPerBar);
|
||||
}
|
||||
|
||||
public static Pressure FromMillibar(double millibars)
|
||||
{
|
||||
return new Pressure(millibars * PascalPerBar / 1000);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns Pressure object interpreting passed value as Pascal
|
||||
/// </summary>
|
||||
/// <param name="Pressure">Pascal</param>
|
||||
/// <returns></returns>
|
||||
public static Pressure FromPascal(double pascal)
|
||||
{
|
||||
return new Pressure(pascal);
|
||||
}
|
||||
|
||||
public static Pressure FromPSI(double psi)
|
||||
{
|
||||
return new Pressure(psi * PascalPerPSI);
|
||||
}
|
||||
#endregion
|
||||
|
||||
public override bool Equals(object obj)
|
||||
{
|
||||
Pressure pressure = obj as Pressure;
|
||||
|
||||
return (pressure == null) ? false : (this._pressure == pressure._pressure);
|
||||
}
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
return _pressure.GetHashCode();
|
||||
}
|
||||
|
||||
#region Binary Operators
|
||||
// not implementing %, &, |, ^, <<, >>
|
||||
|
||||
|
||||
public static Pressure operator +(Pressure left, Pressure right)
|
||||
{
|
||||
if (null == left)
|
||||
{
|
||||
throw new ArgumentNullException("left", "Cannot add a null Pressure");
|
||||
}
|
||||
|
||||
if (null == right)
|
||||
{
|
||||
throw new ArgumentNullException("right", "Cannot add null Pressure");
|
||||
}
|
||||
|
||||
return new Pressure(left._pressure + right._pressure);
|
||||
}
|
||||
|
||||
|
||||
public static Pressure operator -(Pressure left, Pressure right)
|
||||
{
|
||||
if (null == left)
|
||||
{
|
||||
throw new ArgumentNullException("left", "Cannot add a null Pressure");
|
||||
}
|
||||
|
||||
if (null == right)
|
||||
{
|
||||
throw new ArgumentNullException("right", "Cannot add null Pressure");
|
||||
}
|
||||
|
||||
return new Pressure(left._pressure - right._pressure);
|
||||
}
|
||||
|
||||
|
||||
public static Pressure operator *(Pressure pressure, double scalar)
|
||||
{
|
||||
if (null == pressure)
|
||||
{
|
||||
throw new ArgumentNullException("pressure", "Cannot multiply a null Pressure");
|
||||
}
|
||||
|
||||
return new Pressure(pressure._pressure * scalar);
|
||||
}
|
||||
|
||||
|
||||
public static Pressure operator *(double scalar, Pressure pressure)
|
||||
{
|
||||
if (null == pressure)
|
||||
{
|
||||
throw new ArgumentNullException("pressure", "Cannot multiply a null Pressure");
|
||||
}
|
||||
|
||||
return new Pressure(scalar * pressure._pressure);
|
||||
}
|
||||
|
||||
|
||||
public static Pressure operator /(Pressure pressure, double scalar)
|
||||
{
|
||||
if (null == pressure)
|
||||
{
|
||||
throw new ArgumentNullException("pressure", "Cannot divide a null Pressure");
|
||||
}
|
||||
|
||||
if (0.0 == scalar)
|
||||
{
|
||||
throw new DivideByZeroException("Cannot divide Pressure by 0");
|
||||
}
|
||||
|
||||
return new Pressure(pressure._pressure / scalar);
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region comparison operators
|
||||
public static bool operator ==(Pressure left, Pressure right)
|
||||
{
|
||||
bool bReturn = false;
|
||||
if (object.ReferenceEquals(left, null))
|
||||
{
|
||||
if (object.ReferenceEquals(right, null))
|
||||
{
|
||||
//both are null, so we are ==
|
||||
bReturn = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!object.ReferenceEquals(left, null) &&
|
||||
!object.ReferenceEquals(right, null))
|
||||
{
|
||||
bReturn = left._pressure == right._pressure;
|
||||
}
|
||||
}
|
||||
return bReturn;
|
||||
}
|
||||
|
||||
public static bool operator !=(Pressure left, Pressure right)
|
||||
{
|
||||
return !(left == right);
|
||||
}
|
||||
|
||||
|
||||
public static bool operator <(Pressure left, Pressure right)
|
||||
{
|
||||
if (null == left)
|
||||
{
|
||||
throw new ArgumentNullException("left", "Cannot compare null Pressure");
|
||||
}
|
||||
|
||||
if (null == right)
|
||||
{
|
||||
throw new ArgumentNullException("right", "Cannot compare null Pressure");
|
||||
}
|
||||
|
||||
return (left._pressure < right._pressure);
|
||||
}
|
||||
|
||||
|
||||
public static bool operator >(Pressure left, Pressure right)
|
||||
{
|
||||
if (null == left)
|
||||
{
|
||||
throw new ArgumentNullException("left", "Cannot compare null Pressure");
|
||||
}
|
||||
|
||||
if (null == right)
|
||||
{
|
||||
throw new ArgumentNullException("right", "Cannot compare null Pressure");
|
||||
}
|
||||
|
||||
return (left._pressure > right._pressure);
|
||||
}
|
||||
|
||||
|
||||
public static bool operator <=(Pressure left, Pressure right)
|
||||
{
|
||||
if (null == left)
|
||||
{
|
||||
throw new ArgumentNullException("left", "Cannot compare null Pressure");
|
||||
}
|
||||
|
||||
if (null == right)
|
||||
{
|
||||
throw new ArgumentNullException("right", "Cannot compare null Pressure");
|
||||
}
|
||||
|
||||
return (left._pressure <= right._pressure);
|
||||
}
|
||||
|
||||
|
||||
public static bool operator >=(Pressure left, Pressure right)
|
||||
{
|
||||
if (null == left)
|
||||
{
|
||||
throw new ArgumentNullException("left", "Cannot compare null Pressure");
|
||||
}
|
||||
|
||||
if (null == right)
|
||||
{
|
||||
throw new ArgumentNullException("right", "Cannot compare null Pressure");
|
||||
}
|
||||
|
||||
return (left._pressure >= right._pressure);
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region parsing
|
||||
|
||||
public static Pressure Parse(string s)
|
||||
{
|
||||
return Common.Parse(s, _unitInfo);
|
||||
}
|
||||
|
||||
public static bool TryParse(string s, out Pressure value)
|
||||
{
|
||||
try
|
||||
{
|
||||
value = Pressure.Parse(s);
|
||||
return true;
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
value = null;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Returns a string appended with default units (e.g. "1.23 m/sec^2").
|
||||
/// </summary>
|
||||
/// <returns>
|
||||
/// A string that represents this instance
|
||||
/// </returns>
|
||||
public override string ToString()
|
||||
{
|
||||
return ToString(DefaultUnits);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// overload that returns a string appended with specified units (e.g. "1.23 ft/sec^2").
|
||||
/// </summary>
|
||||
/// <param name="units"></param>
|
||||
/// <returns></returns>
|
||||
public string ToString(Unit units)
|
||||
{
|
||||
double value = (double)_unitInfo[units].PropertyGetter.Invoke(this, null);
|
||||
|
||||
return $"{value} {_unitInfo[units].Abbreviation[0]}";
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user