416 lines
19 KiB
C#
416 lines
19 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using DTS.Common.Utilities.Logging;
|
||
|
||
namespace DTS.SensorDB
|
||
{
|
||
public class MeasurementUnit
|
||
{
|
||
private string _mainDisplayUnit;
|
||
public string MainDisplayUnit
|
||
{
|
||
get { return _mainDisplayUnit; }
|
||
set { _mainDisplayUnit = value; }
|
||
}
|
||
|
||
private string[] _alternateDisplayUnits;
|
||
public string[] AlternateDisplayUnits
|
||
{
|
||
get { return _alternateDisplayUnits; }
|
||
set { _alternateDisplayUnits = value; }
|
||
}
|
||
|
||
private string _dimension = "00";
|
||
public string Dimension
|
||
{
|
||
get { return _dimension; }
|
||
set { _dimension = value; }
|
||
}
|
||
public MeasurementUnit(string mainUnit, string[] alternateUnits, MeasurementUnit.UnitConversion[] conversions, string dimension)
|
||
{
|
||
MainDisplayUnit = mainUnit;
|
||
AlternateDisplayUnits = alternateUnits;
|
||
UnitConversions = conversions;
|
||
Dimension = dimension;
|
||
}
|
||
public MeasurementUnit(System.Xml.XmlElement node)
|
||
{
|
||
foreach (var childnode in node.ChildNodes)
|
||
{
|
||
System.Xml.XmlElement elem = childnode as System.Xml.XmlElement;
|
||
if (null == elem) { continue; }
|
||
try
|
||
{
|
||
switch (elem.Name)
|
||
{
|
||
case "MainDisplayUnit":
|
||
MainDisplayUnit = elem.InnerText;
|
||
break;
|
||
case "AlternateDisplayUnits":
|
||
{
|
||
var nodes = elem.GetElementsByTagName("String");
|
||
List<string> aunits = new List<string>();
|
||
foreach (var node2 in nodes)
|
||
{
|
||
System.Xml.XmlElement element = node2 as System.Xml.XmlElement;
|
||
if (null == element) { continue; }
|
||
try
|
||
{
|
||
aunits.Add(element.InnerText);
|
||
}
|
||
catch (System.Exception) { }
|
||
}
|
||
AlternateDisplayUnits = aunits.ToArray();
|
||
}
|
||
break;
|
||
case "Dimension":
|
||
{
|
||
Dimension = elem.InnerText;
|
||
}
|
||
break;
|
||
case "UnitConversions":
|
||
{
|
||
var nodes = elem.GetElementsByTagName("UnitConversion");
|
||
foreach (var node2 in nodes)
|
||
{
|
||
System.Xml.XmlElement element = node2 as System.Xml.XmlElement;
|
||
if (null == element) { continue; }
|
||
try
|
||
{
|
||
_unitConversions.Add(new UnitConversion(element));
|
||
}
|
||
catch (System.Exception) { }
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
System.Diagnostics.Trace.WriteLine("didn't handle " + elem.Name);
|
||
break;
|
||
}
|
||
}
|
||
catch (System.Exception ex)
|
||
{
|
||
APILogger.Log("Failed to parse xml", ex, elem.Name, elem.Value);
|
||
}
|
||
}
|
||
}
|
||
public bool UnitMatches(string unit)
|
||
{
|
||
unit = unit.Trim().ToLower();
|
||
if (MainDisplayUnit.ToLower() == unit) { return true; }
|
||
foreach (string aunit in AlternateDisplayUnits)
|
||
{
|
||
if (aunit.ToLower() == unit) { return true; }
|
||
}
|
||
return false;
|
||
}
|
||
|
||
public double GetScalerConversion(string newUnit)
|
||
{
|
||
return 1D; //6194 disable display units for the short term
|
||
//if (UnitMatches(newUnit)) { return 1D; }
|
||
//foreach (var uc in UnitConversions)
|
||
//{
|
||
// if (uc.UnitMatches(newUnit)) { return uc.Scaler; }
|
||
//}
|
||
//throw new InvalidCastException(string.Format("No conversion available from {0} to {1}", newUnit, MainDisplayUnit));
|
||
}
|
||
public double GetScalerConversionFrom(string oldUnit)
|
||
{
|
||
return 1D; //6194 disable display units for the short term
|
||
|
||
//if (UnitMatches(oldUnit)) { return 1D; }
|
||
//foreach (var uc in UnitConversions)
|
||
//{
|
||
// if (uc.UnitMatches(oldUnit)) { return 1D / uc.Scaler; }
|
||
//}
|
||
//throw new InvalidCastException(string.Format("No conversion available from {0} to {1}", oldUnit, MainDisplayUnit));
|
||
}
|
||
private List<UnitConversion> _unitConversions = new List<UnitConversion>();
|
||
|
||
public UnitConversion[] UnitConversions
|
||
{
|
||
get
|
||
{
|
||
return _unitConversions.ToArray();
|
||
}
|
||
set
|
||
{
|
||
if (null == value)
|
||
{
|
||
return;
|
||
}
|
||
_unitConversions = new List<UnitConversion>(value);
|
||
}
|
||
}
|
||
|
||
public class UnitConversion
|
||
{
|
||
private string _unit;
|
||
public string Unit { get { return _unit; } set { _unit = value; } }
|
||
|
||
private double _scaler;
|
||
public double Scaler { get { return _scaler; } set { _scaler = value; } }
|
||
|
||
public bool UnitMatches(string unit)
|
||
{
|
||
return (Unit.ToLower() == unit.Trim().ToLower());
|
||
}
|
||
public void WriteToXML(System.Xml.XmlWriter writer)
|
||
{
|
||
writer.WriteStartElement("UnitConversion");
|
||
DTS.DASLib.Service.XMLHelper.PutString(writer, "Unit", Unit);
|
||
DTS.DASLib.Service.XMLHelper.PutDouble(writer, "Scaler", Scaler);
|
||
writer.WriteEndElement();
|
||
}
|
||
public UnitConversion(string unit, double scaler) { Unit = unit; Scaler = scaler; }
|
||
public UnitConversion(System.Xml.XmlElement node)
|
||
{
|
||
foreach (var childnode in node.ChildNodes)
|
||
{
|
||
System.Xml.XmlElement elem = childnode as System.Xml.XmlElement;
|
||
if (null == elem) { continue; }
|
||
try
|
||
{
|
||
switch (elem.Name)
|
||
{
|
||
case "Unit":
|
||
Unit = elem.InnerText;
|
||
break;
|
||
case "Scaler":
|
||
Scaler = double.Parse(elem.InnerText, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture);
|
||
break;
|
||
default:
|
||
System.Diagnostics.Trace.WriteLine("didn't handle " + elem.Name);
|
||
break;
|
||
}
|
||
}
|
||
catch (System.Exception ex)
|
||
{
|
||
APILogger.Log("Failed to parse xml", ex, elem.Name, elem.Value);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
public void WriteToXML(System.Xml.XmlWriter writer)
|
||
{
|
||
writer.WriteStartElement("MeasurementUnit");
|
||
DTS.DASLib.Service.XMLHelper.PutString(writer, "MainDisplayUnit", MainDisplayUnit);
|
||
DTS.DASLib.Service.XMLHelper.PutString(writer, "Dimension", Dimension);
|
||
|
||
writer.WriteStartElement("AlternateDisplayUnits");
|
||
foreach (var unit in AlternateDisplayUnits)
|
||
{
|
||
writer.WriteStartElement("String");
|
||
writer.WriteValue(unit);
|
||
writer.WriteEndElement();
|
||
}
|
||
writer.WriteEndElement();
|
||
//DTS.DASLib.Service.XMLHelper.PutString(writer, "AlternateDisplayUnits", string.Join("×", AlternateDisplayUnits));
|
||
writer.WriteStartElement("UnitConversions");
|
||
foreach (var uc in UnitConversions) { uc.WriteToXML(writer); }
|
||
writer.WriteEndElement();
|
||
writer.WriteEndElement();
|
||
}
|
||
public override string ToString()
|
||
{
|
||
return MainDisplayUnit;
|
||
}
|
||
}
|
||
public class MeasurementUnitList
|
||
{
|
||
private static MeasurementUnitList _instance;
|
||
private static object MyLock = new object();
|
||
|
||
private Dictionary<string, MeasurementUnit> _units = new Dictionary<string, MeasurementUnit>();
|
||
private MeasurementUnit[] GetAllUnits() { return _units.Values.ToArray(); }
|
||
|
||
public static MeasurementUnit[] GetAllMeasurementUnits()
|
||
{
|
||
lock (MyLock)
|
||
{
|
||
if (null == _instance) { _instance = new MeasurementUnitList(); }
|
||
return _instance.GetAllUnits();
|
||
}
|
||
}
|
||
|
||
public static MeasurementUnit GetMeasurementUnit(string key)
|
||
{
|
||
lock (MyLock)
|
||
{
|
||
return new MeasurementUnit(key, null, null, null);
|
||
}
|
||
}
|
||
private MeasurementUnitList()
|
||
{
|
||
LoadAllMeasurementUnits();
|
||
}
|
||
public void SaveToXML()
|
||
{
|
||
|
||
StringBuilder sb = new StringBuilder();
|
||
System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
|
||
settings.OmitXmlDeclaration = false;
|
||
settings.Indent = true;
|
||
using (System.Xml.XmlWriter xmlWriter = System.Xml.XmlTextWriter.Create(sb, settings))
|
||
{
|
||
xmlWriter.WriteStartDocument(true);
|
||
xmlWriter.WriteStartElement("MeasurementUnits");
|
||
var e1 = _units.GetEnumerator();
|
||
while (e1.MoveNext())
|
||
{
|
||
e1.Current.Value.WriteToXML(xmlWriter);
|
||
}
|
||
xmlWriter.WriteEndElement();
|
||
xmlWriter.WriteEndDocument();
|
||
xmlWriter.Flush();
|
||
}
|
||
System.IO.File.WriteAllText(FILE_NAME, sb.ToString());
|
||
}
|
||
private void CreateDefaultMeasurementUnitsFile()
|
||
{
|
||
MeasurementUnit mu = new MeasurementUnit("g", new string[] { "g" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("m/sec^2", 9.80665D), new MeasurementUnit.UnitConversion("ft/s^2", 32.17405D)}, "AC");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("m/sec^2", new string[] { "m/sec^2", "m/s^2", "m/sec2", "m/s2" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("g", .101971621), new MeasurementUnit.UnitConversion("ft/s^2", 3.28084D),
|
||
new MeasurementUnit.UnitConversion("cm/s^2", 100D)}, "AC");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("deg", new string[] { "deg", "degree", "degrees", "°" }, new MeasurementUnit.UnitConversion[0], "AN");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("Nm", new string[] { "Nm", "N -m", "N-m" }, new MeasurementUnit.UnitConversion[0], "DC");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("mm", new string[] { "mm", "M-m", "M -m" }, new MeasurementUnit.UnitConversion[0], "DC");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("deg/sec", new string[] { "deg/sec", "degrees/sec", "d/sec", "deg/s" }, new MeasurementUnit.UnitConversion[0], "AA");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("kN", new string[] { "kn", "K-n", "k -n", "kilonewton" }, new MeasurementUnit.UnitConversion[]{
|
||
new MeasurementUnit.UnitConversion("N", 1000)
|
||
}, "FO");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("N", new string[] { "n", "newton" }, new MeasurementUnit.UnitConversion[]{
|
||
new MeasurementUnit.UnitConversion("kN", .001D)
|
||
}, "FO");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("ft/s^2", new string[] { "ft/s2", "ft/s^2", "ft/sec^2" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("cm/s^2", 30.48D), new MeasurementUnit.UnitConversion("m/sec^2", .3048D)}, "AC");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("cm/s^2", new string[] { "cm/s^2", "cm/s2", "cm/sec^2" }, new MeasurementUnit.UnitConversion[]{
|
||
new MeasurementUnit.UnitConversion("ft/s^2", .032808D), new MeasurementUnit.UnitConversion("m/sec^2", .01D)
|
||
}, "AC");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("Ampere", new string[] { "Amp", "Amper", "Amps" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("mAmp", 1000D)
|
||
}, "CU");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("mAmp", new string[] { "mAmp", "m Amp", "milliampere", "milliamp" }, new MeasurementUnit.UnitConversion[]{
|
||
new MeasurementUnit.UnitConversion("Ampere", .001D)}, "CU");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("A", new string[] { "Amp", "Ampere" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("mAmp", 1000)}, "CU");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("Hz", new string[] { "hertz", "cycle/sec", "cyc/s" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("kHz", .001D)}, "FR");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("kHz", new string[] { "kHertz", "kilohertz" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("Hz", 1000D)}, "FR");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("m", new string[] { "m", "Meter" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("mm", 100D)}, "DC");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("V", new string[] { "volt", "VO" }, new MeasurementUnit.UnitConversion[] {
|
||
new MeasurementUnit.UnitConversion("mV", 100D)}, "VO");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("mV", new string[] { "mv", "millivolt", "mVolt" }, new MeasurementUnit.UnitConversion[]{
|
||
new MeasurementUnit.UnitConversion("V", .001D)}, "VO");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("με", new string[] { "microstrain", "με", "micro strain" }, new MeasurementUnit.UnitConversion[0], "??");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("Pa", new string[] { "PA", "Pascal", "kg/m^2" }, new MeasurementUnit.UnitConversion[]{
|
||
new MeasurementUnit.UnitConversion("kPa", 1000D), new MeasurementUnit.UnitConversion("hPA", 100), new MeasurementUnit.UnitConversion("MPa", 1000000D)}
|
||
, "??");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
mu = new MeasurementUnit("kPa", new string[] { "KPA", "kilopascal", "KiloPascal" }, new MeasurementUnit.UnitConversion[]{
|
||
new MeasurementUnit.UnitConversion("Pa", 1D/1000D)}, "??");
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit)) { _units.Add(mu.MainDisplayUnit, mu); }
|
||
|
||
SaveToXML();
|
||
}
|
||
public static bool ContainsMeasurementUnit(string unit)
|
||
{
|
||
lock (MyLock)
|
||
{
|
||
if (null == _instance) { _instance = new MeasurementUnitList(); }
|
||
var units = from u in _instance.GetAllUnits() where u.UnitMatches(unit) select u;
|
||
if (units.Count() > 0) { return true; }
|
||
else { return false; }
|
||
}
|
||
}
|
||
private void LoadAllMeasurementUnits()
|
||
{
|
||
if (!System.IO.File.Exists(FILE_NAME))
|
||
{
|
||
CreateDefaultMeasurementUnitsFile();
|
||
}
|
||
else
|
||
{
|
||
System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
|
||
string xml = System.IO.File.ReadAllText(FILE_NAME);
|
||
doc.LoadXml(xml);
|
||
var nodes = doc.GetElementsByTagName("MeasurementUnits");
|
||
foreach (var node in nodes)
|
||
{
|
||
System.Xml.XmlElement element = node as System.Xml.XmlElement;
|
||
if (null == element) { continue; }
|
||
foreach (var childNode in element.GetElementsByTagName("MeasurementUnit"))
|
||
{
|
||
System.Xml.XmlElement elem = childNode as System.Xml.XmlElement;
|
||
if (null == elem) { continue; }
|
||
LoadMeasurementUnit(elem);
|
||
}
|
||
}
|
||
CreateDefaultMeasurementUnitsFile();
|
||
}
|
||
}
|
||
private const string FILE_NAME = "MeasurementUnits.xml";
|
||
private void LoadMeasurementUnit(System.Xml.XmlElement node)
|
||
{
|
||
try
|
||
{
|
||
MeasurementUnit mu = new MeasurementUnit(node);
|
||
if (!_units.ContainsKey(mu.MainDisplayUnit))
|
||
{
|
||
_units.Add(mu.MainDisplayUnit, mu);
|
||
}
|
||
else
|
||
{
|
||
_units[mu.MainDisplayUnit] = mu;
|
||
}
|
||
}
|
||
catch (System.Exception ex) { APILogger.Log("failed to get node from measurement unit db, ", ex); }
|
||
}
|
||
}
|
||
}
|