tbf/Common/Units.cs

///
/// Copyright (c) 2016-2021 Sensus Slovensko a.s.
///
using System;

namespace Common
{
    public enum Unit
    {
		[Description("---")]		None,

        [Description("imp.")]       pulse,
#if LANG_PL
        [Description("stopień")]    degree,
#else
        [Description("degree")]     degree,
#endif
        [Description("ml")]         ml,         ///   1 ml = 0.001 l
        [Description("l")]          l,          /// * 1 liter
        [Description("dm3")]        dm3,        ///   1 dm3 = 1 l
        [Description("US gal")]     USgal,      ///   1 US gallon = 3.78541178 l
        [Description("imper.gal")]  UKgal,      ///   1 imperial gallon = 4.54609 l
        [Description("cf")]         cf,         ///   1 cubic foot = 28.316846592 l
        [Description("m3")]         m3,         ///   1 m3 = 1000 l

        [Description("l/h")]        lph,        ///   1 l/h = 0.001 m3/h
        [Description("cf/h")]       cfph,       ///   1 cf/h = 0.028316846592 m3/h
        [Description("l/m")]        lpm,        ///   1 l/m = 60 l/h = 0.06 m3/h
        [Description("US gal/m")]   USgalpm,    ///   1 US gallon per minute = 0.2271247068 m3/h
        [Description("m3/h")]       m3ph,       /// * 1 m3/h
        [Description("l/s")]        lps,        ///   1 liter/s = 3.6 m3/h
        [Description("US gal/s")]   USgalps,    ///   1 US gallon per second = 13.627482408 m3/h
        [Description("m3/m")]       m3pm,       ///   1 m3/m = 60 m3/h
        [Description("cf/s")]       cfs,        ///   1 cubic foot per second = 101.9406477312 m3/h

        [Description("g")]          g,          ///   0.001 kg
        [Description("oz")]         oz,         ///   0.0283495231 kg
        [Description("lb")]         lb,         ///   0.45359237 kg
        [Description("kg")]         kg,         /// * 1 kilogram
        [Description("t")]          t,          ///   1000 kg

        [Description("ms")]         ms,         ///   1 ms = 0.001 s
        [Description("s")]          s,          /// * 1 second
        [Description("min")]        min,        ///   1 min = 60 s
        [Description("hr")]         hour,       ///   1 hour = 60 min = 3600 s

		[Description("°C")]         C,          /// * degree Celsius (°C)
        [Description("°F")]         F,          ///   degree Fahrenheit
        [Description("K")]          K,          ///   degree Kelvin

        [Description("Pa")]         Pa,         ///   1 Pa = 0.01 hPa
        [Description("hPa")]        hPa,        ///   1 hPa = 100 Pa
        [Description("mbar")]       mbar,       ///   1 mbar = 1 hPa = 100 Pa
        [Description("kPa")]        kPa,        ///   1 kPa = 10 hPa = 1000 Pa
        [Description("inHg")]       inHg,       ///   1 inHg = 33.864 hPa
        [Description("psi")]        psi,        ///   1 psi = 0.0689475729 bar
        [Description("bar")]        bar,        /// * 1 Bar = 1000 mbar = 0.1 MPa = 100000 Pa
        [Description("MPa")]        MPa,        ///   1 MPa = 10000 hPa

        [Description("R%")]         RPct,       /// * 1 R%

        [Description("promile")]    Promile,    ///   1 promile = 0.1 %
        [Description("%")]          Pct,        /// * 1 %

        [Description("mm")]         mm,         /// * 1 millimeter
        [Description("cm")]         cm,         ///   1 cm = 10 mm
        [Description("in")]         inch,       ///   1 inch = 25.4 mm
        [Description("dm")]         dm,         ///   1 dm = 100 mm
        [Description("ft")]         foot,       ///   1 foot = 304.8 mm
        [Description("yd")]         yard,       ///   1 yard = 914.4 mm
        [Description("m")]          m,          ///   1 m = 1000 mm

        [Description("kg/m3")]      kgpm3,		/// * 1 kg/m3 = 0.001 kg/l
        [Description("kg/l")]       kgpl,		///   1 kg/l = 1000 kg/m3

        [Description("J")]          J,			/// * 1 Joul
        [Description("kJ")]         kJ,			///   1 kJ = 1000 J
        [Description("MJ")]         MJ,         ///   1 MJ = 1000000 J
        [Description("Wh")]         Wh,			///   1 Wh = 3600 J
        [Description("kWh")]        kWh,		///   1 kWh = 3600000 J
        [Description("MWh")]        MWh,		///   1 MWh = 3600000000 J

        [Description("uS/cm")]      uSpcm,      /// * 1 uS/cm
        [Description("mS/m")]       mSpm,       ///   1 mS/m = 10 uS/cm

#if LANG_PL
        [Description("imp/l")]       ppl,		/// * 1 pulse/l
        [Description("imp/dm3")]     ppdm3,		/// * 1 pulse/dm3
        [Description("stopień/l")]   degpl,		/// * 1 degree/l
        [Description("stopień/dm3")] degpdm3,	/// * 1 degree/dm3
        [Description("l/imp")]       lpp,		/// * 1 l/pulse
        [Description("dm3/imp")]     dm3pp,		/// * 1 dm3/pulse
        [Description("l/stopień")]   lpdeg,		/// * 1 l/degree
        [Description("dm3/stopień")] dm3pdeg,	/// * 1 dm3/degree
#else
        [Description("pulse/l")]    ppl,		/// * 1 pulse/l
        [Description("pulse/dm3")]  ppdm3,		///   1 pulse/dm3
        [Description("degree/l")]   degpl,		///   1 degree/l
        [Description("degree/dm3")] degpdm3,	///   1 degree/dm3
        [Description("l/pulse")]    lpp,		///   1 l/pulse
        [Description("dm3/pulse")]  dm3pp,		///   1 dm3/pulse
        [Description("l/degree")]   lpdeg,		///   1 l/degree
        [Description("dm3/degree")] dm3pdeg,	///   1 dm3/degree
#endif
        /// 
        [Description("pulse/kWh")]  ppkWh,		/// * 1 pulse/kWh
        [Description("kWh/pulse")]  kWhpp,		///   1 kWh/pulse
        
        ///
        [Description("A")]  A, /// *1 A
	    [Description("mA")] mA, /// 1 mA = 0.001 A
        ///
        [Description("V")]  V, /// *1 V
        [Description("mV")] mV, /// 1 mV = 0.001 V                     
                               
                                                
        Count
    }

	public enum Quantity
	{
        /// Quantities with units and conversions (double -> double)
#if LANG_DE
		[Description("Volumen")]			Volume,
		[Description("Durchfluss")]			Flow,
		[Description("Masse")]				Mass,
        [Description("Zeit")]				Time,
        [Description("Temperatur")]			Temperature,
		[Description("Druck")]				Pressure,
        [Description("Feuchtigkeit")]		Humidity,
        [Description("Fehler")]				Error,
		[Description("Länge")]				Length,
		[Description("Dichte")]				Density,
		[Description("Energie")]			Energy,
		[Description("Impulse")]			Pulses,
        [Description("Impulse/l")]			PulsePerLtr,
        [Description("Impulse/kWh")]		PulsePerKWh,
        [Description("Leitfähigkeit")]      Conductivity,

        /// Quantities without units and conversions
        [Description("Nummer")]				Number,
        [Description("Text")]				String,
        [Description("Boolean")]			Boolean,
        [Description("Datum und Uhrzeit")]  DateTime,
        [Description("Aufgezählt")]         Enumerated,
        [Description("Strom")]              Current,
		[Description("Spannung")]           Voltage,
#elif LANG_PL
        [Description("Objętość")]			Volume,
		[Description("Przepływ")]           Flow,
		[Description("Masa")]				Mass,
        [Description("Czas")]				Time,
        [Description("Temperatura")]		Temperature,
		[Description("Ciśnienie")]			Pressure,
        [Description("Wilgotność")]			Humidity,
        [Description("Błąd")]				Error,
		[Description("Długość")]			Length,
		[Description("Gęstość")]			Density,
		[Description("Energia")]			Energy,
        [Description("Impulsy")]            Pulses,
        [Description("Impulsy/litr")]       PulsePerLtr,
        [Description("Impulsy/kWh")]		PulsePerKWh,
        [Description("Przewodność")]        Conductivity,

        /// Quantities without units and conversions
        [Description("Numer")]				Number,
        [Description("Tekst")]				String,
        [Description("Boolean")]			Boolean,
        [Description("Data i czas")]		DateTime,
        [Description("Wyliczone")]          Enumerated,
        [Description("Prąd")]               Current,
        [Description("Napięcie")]            Voltage,
#elif LANG_CS
		[Description("Objem")]				Volume,
		[Description("Průtok")]				Flow,
		[Description("Hmotnost")]           Mass,
        [Description("Čas")]				Time,
        [Description("Teplota")]			Temperature,
		[Description("Tlak")]				Pressure,
        [Description("Vlhkost")]			Humidity,
        [Description("Chyba")]				Error,
		[Description("Délka")]				Length,
		[Description("Hustota")]			Density,
		[Description("Energie")]			Energy,
		[Description("Pulzy")]				Pulses,
        [Description("Pulzy/litr")]			PulsePerLtr,
        [Description("Pulzy/kWh")]			PulsePerKWh,
        [Description("Vodivost")]           Conductivity,

        /// Quantities without units and conversions
        [Description("Počet")]				Number,
        [Description("Text")]				String,
        [Description("Boolean")]			Boolean,
        [Description("Datum a čas")]		DateTime,
        [Description("Vyjmenované")]        Enumerated,
		[Description("Proud")]				Current,
		[Description("Napětí")]            Voltage,
#elif LANG_IT
		[Description("Volume")]				Volume,
		[Description("Flusso")]				Flow,
		[Description("Massa")]              Mass,
        [Description("Tempo")]				Time,
        [Description("Temperatura")]	    Temperature,
		[Description("Pressione")]			Pressure,
        [Description("Umidità")]			Humidity,
        [Description("Errore")]				Error,
		[Description("Lungezza")]			Length,
		[Description("Densità")]			Density,
		[Description("Energia")]			Energy,
		[Description("Impulso")]			Pulses,
        [Description("Impulso/litro")]		PulsePerLtr,
        [Description("Impulso/kWh")]		PulsePerKWh,
        [Description("Conduttività")]       Conductivity,

        /// Quantities without units and conversions
        [Description("Numero")]				Number,
        [Description("Stringa")]			String,
        [Description("Boolean")]			Boolean,
        [Description("Data e ora")]		    DateTime,
        [Description("Enumerato")]          Enumerated,
		[Description("Corrente")]            Current,
		[Description("Voltaggio")]            Voltage,
#else
        [Description("Volume")]				Volume,
		[Description("Flow")]				Flow,
		[Description("Mass")]				Mass,
        [Description("Time")]				Time,
        [Description("Temperature")]		Temperature,
		[Description("Pressure")]			Pressure,
        [Description("Humidity")]			Humidity,
        [Description("Error")]				Error,
		[Description("Length")]				Length,
		[Description("Density")]			Density,
		[Description("Energy")]				Energy,
		[Description("Pulses")]				Pulses,
        [Description("Pulses/liter")]		PulsePerLtr,
        [Description("Pulses/kWh")]			PulsePerKWh,
        [Description("Conductivity")]       Conductivity,

        /// Quantities without units and conversions
        [Description("Number")]				Number,
        [Description("String")]				String,
        [Description("Boolean")]			Boolean,
        [Description("Date and time")]		DateTime,
        [Description("Enumerated")]         Enumerated,
		[Description("Current")]            Current,
		[Description("Voltage")]            Voltage,
#endif
        Count,
	}

    public static class Units
    {
        public static bool IsUnitless(Quantity quantity)
        {
            return quantity >= Quantity.Number;
        }

        public static bool IsDefaultUnit(Unit unit)
        {
            return unit == Unit.l || unit == Unit.m3ph || unit == Unit.kg || unit == Unit.s || unit == Unit.C ||
                   unit == Unit.bar || unit == Unit.RPct || unit == Unit.Pct || unit == Unit.mm || unit == Unit.kgpm3 ||
                   unit == Unit.J || unit == Unit.uSpcm || unit == Unit.ppl || unit == Unit.ppkWh || unit == Unit.A || 
                   unit == Unit.V;
        }

        public static bool IsQuantity(Unit unit, Quantity quantity)
        {
            return (quantity == GetQuantity(unit));
        }

        public static Quantity GetQuantity(Unit unit)
		{
            switch (unit)
            {
                case Unit.pulse:
                case Unit.degree:
                    return Quantity.Pulses;

                case Unit.ml:
                case Unit.l:
                case Unit.dm3:
                case Unit.USgal:
                case Unit.UKgal:
                case Unit.cf:
                case Unit.m3:
					return Quantity.Volume;

                case Unit.lph:
                case Unit.cfph:
                case Unit.lpm:
                case Unit.USgalpm:
                case Unit.m3ph:
                case Unit.lps:
                case Unit.USgalps:
                case Unit.m3pm:
                case Unit.cfs:
                    return Quantity.Flow;

                case Unit.g:
                case Unit.oz:
                case Unit.lb:
                case Unit.kg:
                case Unit.t:
					return Quantity.Mass;

                case Unit.ms:
                case Unit.s:
                case Unit.min:
                case Unit.hour:
                    return Quantity.Time;

                case Unit.C:
                case Unit.F:
                case Unit.K:
					return Quantity.Temperature;

                case Unit.Pa:
                case Unit.hPa:
                case Unit.mbar:
                case Unit.kPa:
                case Unit.inHg:
                case Unit.psi:
                case Unit.bar:
                case Unit.MPa:
                    return Quantity.Pressure;

                case Unit.RPct:
                    return Quantity.Humidity;

                case Unit.Promile:
                case Unit.Pct:
					return Quantity.Error;

                case Unit.mm:
                case Unit.cm:
                case Unit.inch:
                case Unit.dm:
                case Unit.foot:
                case Unit.yard:
                case Unit.m:
					return Quantity.Length;

				case Unit.kgpm3:
				case Unit.kgpl:
					return Quantity.Density;

				case Unit.J:
				case Unit.kJ:
                case Unit.MJ:
                case Unit.Wh:
				case Unit.kWh:
                case Unit.MWh:
                    return Quantity.Energy;

                case Unit.uSpcm:
                case Unit.mSpm:
                    return Quantity.Conductivity;

                case Unit.ppl:
                case Unit.ppdm3:
                case Unit.degpl:
                case Unit.degpdm3:
                case Unit.lpp:
                case Unit.dm3pp:
                case Unit.lpdeg:
                case Unit.dm3pdeg:
                    return Quantity.PulsePerLtr;

                case Unit.ppkWh:
                case Unit.kWhpp:
                    return Quantity.PulsePerKWh;
                
                case Unit.A:
                case Unit.mA:
		                return Quantity.Current;
                
                case Unit.V:
                case Unit.mV:
	                return Quantity.Voltage;

                default:
					return Quantity.Number;
            }
		}

		public static bool IsVolume(Unit unit)       { return IsQuantity(unit, Quantity.Volume); }
		public static bool IsFlow(Unit unit)         { return IsQuantity(unit, Quantity.Flow); }
        public static bool IsMass(Unit unit)         { return IsQuantity(unit, Quantity.Mass); }
        public static bool IsTime(Unit unit)         { return IsQuantity(unit, Quantity.Time); }
        public static bool IsTemperature(Unit unit)  { return IsQuantity(unit, Quantity.Temperature); }
		public static bool IsPressure(Unit unit)     { return IsQuantity(unit, Quantity.Pressure); }
        public static bool IsHumidity(Unit unit)     { return IsQuantity(unit, Quantity.Humidity); }
        public static bool IsError(Unit unit)        { return IsQuantity(unit, Quantity.Error); }
		public static bool IsLength(Unit unit)       { return IsQuantity(unit, Quantity.Length); }
		public static bool IsDensity(Unit unit)      { return IsQuantity(unit, Quantity.Density); }
		public static bool IsEnergy(Unit unit)       { return IsQuantity(unit, Quantity.Energy); }
        public static bool IsPulses(Unit unit)       { return IsQuantity(unit, Quantity.Pulses); }
        public static bool IsPulsePerLtr(Unit unit)  { return IsQuantity(unit, Quantity.PulsePerLtr); }
        public static bool IsPulsePerKWh(Unit unit)  { return IsQuantity(unit, Quantity.PulsePerKWh); }
        public static bool IsConductivity(Unit unit) { return IsQuantity(unit, Quantity.Conductivity); }
        public static bool IsCurrent(Unit unit) { return IsQuantity(unit, Quantity.Current); }
        public static bool IsVoltage(Unit unit) { return IsQuantity(unit, Quantity.Voltage); }



        public static float ConvertTo(Unit unit, float v)
        {
            return (float)ConvertTo(unit, (double)v);
        }

        public static double ConvertTo(Unit unit, double v)
        {
            switch (unit)
            {
                /// Volume: internal representation in l
                case Unit.ml:       return 1000 * v;            /// 1 ml = 0.001 l
                case Unit.USgal:    return 0.26417205 * v;      /// 1 gal(US) = 3.78541178 l
                case Unit.UKgal:    return 0.21996925 * v;      /// 1 gal(UK) = 4.54609 l
                case Unit.cf:       return 0.0353146667215 * v; /// 1 cubic foot = 28.316846592 l
                case Unit.m3:       return 0.001 * v;           /// 1 m3 = 1000 l

                /// Flow: internal representation in m3/h
                case Unit.lph:      return 1000 * v;            /// 1 l/h
                case Unit.cfph:     return 35.3146667214886 * v;/// 1 cf/h
                case Unit.lpm:      return v / 0.06;            /// 1 l/m
                case Unit.USgalpm:  return 4.40286754395493 * v;/// 1 US gallon per minute
                case Unit.lps:      return v / 3.6;             /// 1 l/s
                case Unit.USgalps:  return 0.0733811257326 * v; /// 1 US gallon per second
                case Unit.m3pm:     return v / 60;              /// 1 m3/m
                case Unit.cfs:      return 0.009809629644858 * v; /// 1 cubic foot per second

                /// Mass: internal representation in kg
                case Unit.g:        return 1000 * v;            /// 1 g = 0.001 kg
                case Unit.oz:       return 35.273962 * v;       /// 1 oz = 0.0283495231 kg
                case Unit.lb:       return 2.2046226 * v;       /// 1 lb = 0.45359237 kg
                case Unit.t:        return 0.001 * v;           /// 1 t = 1000 kg

                /// Time or duration: internal representation in seconds [s] 
                case Unit.ms:       return 1000 * v;
                case Unit.min:      return v / 60;
                case Unit.hour:     return v / 3600;

				/// Temperature: internal representation in °C
                case Unit.F:        return 1.8 * v + 32;        /// degree Fahrenheit
                case Unit.K:        return v + 273.15;          /// degree Kelvin

                /// Pressure: internal representation in  bar = 0.1 MPa
                case Unit.Pa:       return 100000 * v;          /// 1 hPa = 100 Pa
                case Unit.hPa:      return 1000 * v;            /// 1 hPa = 100 Pa
                case Unit.mbar:     return 1000 * v;            /// 1 mbar = 1 hPa = 100 Pa
                case Unit.kPa:      return 100 * v;             /// 1 kPa = 10 HPa
                case Unit.inHg:     return 29.53 * v;           /// 1 inHg =
                case Unit.psi:      return 14.5037738 * v;      /// 1 psi =
                case Unit.MPa:      return 0.1 * v;             /// 1 MPa = 10000 hPa

                /// Relative error: internal representation in %
                case Unit.Promile:  return 10 * v;              /// 1 promile = 0.1 %

                /// Diameter, length: internal representation in mm
                case Unit.cm:       return 0.1 * v;             /// 1 cm = 10 mm
                case Unit.inch:     return v / 25.4;            /// 1 inch = 25.4 mm
                case Unit.dm:       return 0.01 * v;            /// 1 dm = 100 mm
                case Unit.foot:     return v / 304.8;           /// 1 foot = 304.8 mm
                case Unit.yard:     return v / 914.4;           /// 1 yard = 914,4 mm
                case Unit.m:        return 0.001 * v;           /// 1 m = 1000 mm
                                                                
				/// Density: internal representation in kg/m3
				case Unit.kgpl:     return 0.001 * v;

				/// Energy, internal representation in Joul
				case Unit.kJ:       return 0.001 * v;           /// 1 kJ = 1000 J
                case Unit.MJ:       return 0.000001 * v;        /// 1 kJ = 1000000 J
                case Unit.Wh:       return v / 3600.0;          /// 1 Wh = 3600 J
				case Unit.kWh:      return v / 3600000.0;       /// 1 kWh = 3600000 J
                case Unit.MWh:      return v / 3600000000.0;    /// 1 MWh = 3600000000 J

                /// Electrical conductivity
                case Unit.mSpm:     return 0.1 * v;

                /// Invert pulses
                case Unit.kWhpp:
                case Unit.lpp:
                case Unit.dm3pp:
                case Unit.lpdeg:
                case Unit.dm3pdeg:  return (v <= float.Epsilon) ? 0 : 1/v;
                
                /// Current: internal representation in A
                case Unit.mA:       return 1000 * v;           /// 1000 mA = 1 A
                                                                
                /// Voltage: internal representation in V
                case Unit.mV:     return 1000 * v;				/// 1000 mV = 1 V


                default:            return v;                   /// Do not convert
            }
        }


        public static float ConvertFrom(Unit unit, float v)
        {
            return (float)ConvertFrom(unit, (double)v);
        }

        public static double ConvertFrom(Unit unit, double v)
        {
            switch (unit)
            {
                /// Volume: internal representation in l
                case Unit.ml:       return 0.001 * v;           /// 0.001 l
                case Unit.USgal:    return 3.78541178 * v;      /// 1 gal(US) = 3.78541178 l
                case Unit.UKgal:    return 4.54609 * v;         /// 1 gal(UK) = 4.54609 l
                case Unit.cf:       return 28.316846592 * v;    /// 1 cubic foot = 28.316846592 l
                case Unit.m3:       return 1000 * v;            /// 1000 l

                /// Flow: internal representation in m3/h
                case Unit.lph:      return 0.001 * v;           /// 1 l/h
                case Unit.cfph:     return 0.028316846592 * v;  /// 1 cf/h
                case Unit.lpm:      return 0.06 * v;            /// 1 l/m
                case Unit.USgalpm:  return 0.2271247068 * v;    /// 1 US gallon per minute
                case Unit.lps:      return 3.6 * v;             /// 1 l/s
                case Unit.USgalps:  return 13.627482408 * v;    /// 1 US gallon per second
                case Unit.m3pm:     return 60 * v;              /// 1 m3/m
                case Unit.cfs:      return 101.9406477312 * v;  /// 1 cubic foot per second

                /// Mass: internal representation in kg
                case Unit.g:        return 0.001 * v;           /// 1 g = 0.001 kg
                case Unit.oz:       return 0.0283495231 * v;    /// 1 oz = 0.0283495231 kg
                case Unit.lb:       return 0.45359237 * v;      /// 1 lb = 0.45359237 kg
                case Unit.t:        return 1000 * v;            /// 1 t = 1000 kg

                /// Time or duration: internal representation in seconds [s] 
                case Unit.ms:       return 0.001 * v;
                case Unit.min:      return 60 * v;
                case Unit.hour:     return 3600 * v;

				/// Temperature: internal representation in °C
                case Unit.F:        return 5 * (v - 32) / 9;    /// degree Fahrenheit
                case Unit.K:        return v - 273.15;          /// degree Kelvin

                /// Pressure: internal representation in  bar = 0.1 MPa
                case Unit.Pa:       return 0.00001 * v;         /// 1 hPa = 100 Pa
                case Unit.hPa:      return 0.001 * v;           /// 1 hPa = 100 Pa
                case Unit.mbar:     return 0.001 * v;           /// 1 mbar = 1 hPa = 100 Pa
                case Unit.kPa:      return 0.01 * v;            /// 1 kPa = 10 HPa
                case Unit.inHg:     return 0.033864 * v;        /// 1 inHg = 33.864 hPa
                case Unit.psi:      return 0.0689475729 * v;    /// 1 psi = 0.0689475729 bar
                case Unit.MPa:      return 10 * v;              /// 1 MPa = 10000 hPa

                /// Relative error: internal representation in %
                case Unit.Promile:  return 0.1 * v;             /// 1 promile = 0.1 %

                /// Diameter, length: internal representation in mm
                case Unit.cm:       return 10 * v;              /// 1 cm = 10 mm
                case Unit.inch:     return 25.4 * v;            /// 1 inch = 25.4 mm
                case Unit.dm:       return 100 * v;             /// 1 dm = 100 mm
                case Unit.foot:     return 304.8 * v;           /// 1 foot = 304.8 mm
                case Unit.yard:     return 914.4 * v;           /// 1 yard = 914,4 mm
                case Unit.m:        return 1000 * v;            /// 1 m = 1000 mm

				/// Density: internal representation in kg/m3
				case Unit.kgpl:     return 1000 * v;

				/// Energy, internal representation in Joul
				case Unit.kJ:		return 1000 * v;            /// 1 kJ = 1000 J
                case Unit.MJ:       return 1000000 * v;         /// 1 kJ = 1000000 J
                case Unit.Wh:       return 3600 * v;            /// 1 Wh = 3600 J
				case Unit.kWh:		return 3600000 * v;         /// 1 kWh = 3600000 J
                case Unit.MWh:      return 3600000000 * v;      /// 1 kWh = 3600000000 J

                /// Electrical conductivity
                case Unit.mSpm:     return 10 * v;
                
                /// Current: internal representation in A
                case Unit.mA:       return 0.001 * v;           /// 1 mA = 0.001 A
                                                                
                /// Voltage: internal representation in V
                case Unit.mV:     return 0.001 * v;				/// 1 mV = 0.001 V

                /// Invert
                case Unit.kWhpp:
                case Unit.lpp:
                case Unit.dm3pp:
                case Unit.lpdeg:
                case Unit.dm3pdeg:  return (v <= float.Epsilon) ? 0 : 1/v;

                default:            return v;                   /// Do not convert
            }
        }

        /// <summary>
        /// Converts a string to a unit
        /// </summary>
        /// <param name="description">Unit description string</param>
        /// <returns>Converted unit or Unit.None if not recognized</returns>
        public static Unit FromDescription(string description)
        {
            for (Unit unit = 0; unit < Unit.Count; unit++)
            {
                if (unit.ToDescription() == description) return unit;
            }

            return Unit.None;
        }
	}
}