368 lines
12 KiB
C#
368 lines
12 KiB
C#
//############################################################################//
|
|
// 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]}";
|
|
}
|
|
}
|
|
}
|