package nxm.sys.inc;

/** Index equivalent definitions of data Units codes. This defined the indicators which are used
    to specify:
    <ul>
      <li>The type of units a value has (e.g. time units vs frequency units). </li>
      <li>The type of computation domain to use (e.g. Cartesian domain vs spherical domain).</li>
    </ul>
    The units codes permitted within a BLUE file are not 100% consistent with
    some codes disallowed, discouraged, and/or deprecated in some versions of
    the applicable ICDs. NeXtMidas does not mark the codes as {@link Deprecated}
    since they may appear in older files and/or have been accidentally propagated
    from a file version that supported their use to one that didn't. <br>
    <br>
    The following table provides a summary of the support provided for the
    various units codes in the different file versions commonly encountered by NeXtMidas.
    <pre>
      Legend:
         X   - Supported
        (n)  - See notes
        AWP  - "Avoid Where Possible" per BLUE 1.0 ICD (non-SI units)
        DEP  - "Deprecated"           per Platinum ICD rev. 4

      CODE| IDENTIFIER                 | BLUE 1.x | PLATINUM
      ----+----------------------------+----------+---------
       -1 | unsupported                |          |   (1)
      ----+----------------------------+----------+---------
        0 | NONE                       |    X     |    X
        1 | TIME_S                     |    X     |   (2)
        2 | DELAY_S                    |    X     |    X
        3 | FREQUENCY_HZ               |    X     |    X
        4 | TIMECODE                   |    X     |   (3)
        5 | DISTANCE_M                 |    X     |    X
        6 | SPEED_M_S                  |    X     |    X
        7 | ACCELERATION_M_S2          |    X     |    X
        8 | JERK_M_S3                  |    X     |    X
        9 | DOPPLER_HZ                 |    X     |    X
      ----+----------------------------+----------+---------
       10 | DOPPLER_RATE_HZ_S          |    X     |    X
       11 | ENERGY_J                   |    X     |    X
       12 | POWER_W                    |    X     |    X
       13 | MASS_G                     |    X     |    X
       14 | VOLUME_L                   |    X     |    X
       15 | ANG_POWER_DEN_W_STER       |    X     |    X
       16 | INTEG_POWER_DEN_RAD_W_RAD  |    X     |    X
       17 | SPATIAL_POWER_DEN_W_M2     |    X     |    X
       18 | INTEG_POWER_DEN_W_M        |    X     |    X
       19 | SPECTRAL_POWER_DEN_W_MHZ   |    X     |    X
      ----+----------------------------+----------+---------
       20 | AMPLITUDE                  |    X     |
       21 | REAL                       |    X     |
       22 | IMAGINARY                  |    X     |
       23 | PHASE_RAD                  |    X     |
       24 | PHASE_DEG                  |    X     |
       25 | PHASE_CYCLES               |    X     |
       26 | TEN_LOG                    |    X     |
       27 | TWENTY_LOG                 |    X     |
       28 | MAGNITUDE                  |    X     |
       29 | FREQ_DIFF_HZ               |    X     |
      ----+----------------------------+----------+---------
       30 | UNKNOWN                    |    X     |    X
       31 | DIMENSIONLESS              |    X     |    X
       32 | COUNTS                     |    X     |   (4)
       33 | ANGLE_RAD                  |    X     |    X
       34 | ANGLE_DEG                  |    X     |    X
       35 | REL_POWER_DB               |    X     |    X
       36 | REL_POWER_DBM              |    X     |    X
       37 | REL_POWER_DBW              |    X     |   DEP
       38 | SOLID_ANGLE_STER           |    X     |    X
       39 | reserved                   |          |
      ----+----------------------------+----------+---------
       40 | DISTANCE_FT                |   AWP    |   DEP
       41 | DISTANCE_NMI               |    X     |    X
       42 | SPEED_FT_S                 |   AWP    |   DEP
       43 | SPEED_NMI_S                |    X     |   DEP
       44 | SPEED_KNOTS                |    X     |   DEP
       45 | ACCEL_FT_S2                |   AWP    |   DEP
       46 | ACCEL_NMI_S2               |    X     |   DEP
       47 | ACCEL_KNOTS_S              |    X     |   DEP
       48 | ACCEL_G                    |    X     |   DEP
       49 | JERK_G_S                   |    X     |   DEP
      ----+----------------------------+----------+---------
       50 | ROTATION_RPS               |    X     |   (5)
       51 | ROTATION_RPM               |    X     |   DEP
       52 | ANG_VEL_RAD_S              |    X     |    X
       53 | ANG_VEL_DEG_S              |    X     |   DEP
       54 | ANG_ACCEL_RAD_S2           |    X     |    X
       55 | ANG_ACCEL_DEG_S2           |    X     |   DEP
       56 | PERCENTAGE                 |   (6)    |    X
       57 | PRESSURE_PSI               |   (6)    |    X
       58 | reserved                   |    X     |
       59 | reserved                   |    X     |
      ----+----------------------------+----------+---------
       60 | LATITUDE_DEG               |    X     |   (7)
       61 | LONGITUDE_DEG              |    X     |   (7)
       62 | ALTITUDE_FT                |   AWP    |
       63 | ALTITUDE_M                 |    X     |   (8)
      ----+----------------------------+----------+---------
       64 | reserved                   |          |
       65 | reserved                   |          |
      ----+----------------------------+----------+---------
       66 | BAUD                       |    X     |
       67 | BIT_RATE                   |    X     |
       68 | POTENTIAL_DIFF             |    X     |
       69 | CURRENT                    |    X     |
       70 | RESISTANCE                 |    X     |
       71 | CAPACITANCE                |    X     |
       72 | INDUCTANCE                 |    X     |
      ----+----------------------------+----------+---------
       73 | TEMPERATURE                |    X     |
       74 | PRESSURE                   |    X     |
       75 | RELATIVE_POWER             |    X     |
       76 | RELATIVE_POWER_DENSE       |    X     |
       77 | reserved                   |          |
      ----+----------------------------+----------+---------
        : |    :                       |          |
      127 | reserved                   |          |
      ----+----------------------------+----------+---------

      Notes:
        (1) The Platinum ICD lists the code -1 as a deprecated alternate to {@link #NONE}.
            As values outside of 0..127 are explicitly prohibited in the BLUE 1.x ICD,
            adding -1 to NeXtMidas (or X-Midas) risks breaking existing functionality;
            as such this code is not supported in Midas.
        (2) Within a Platinum file {@link #TIME_S} when used with time-values data means seconds
            since a given epoch; within a BLUE 1.x file it means either time from 1950-01-01 or
            from the file's start time.
        (3) Although {@link #TIMECODE} is listed in the "BLUE Preferred Unit Codes" table of the
            Platinum ICD (rev. 4) its use is prohibited within respect to time-valued keywords by
            section 1.9 of the standard which mandates use of {@link #TIME_S} or {@link #COUNTS}.
        (4) Within a Platinum file {@link #COUNTS} when used with time-values data means explicitly
            means clock ticks since a given epoch; the BLUE 1.x ICD does not have this specificity
            (and this usage is rare within a BLUE 1.x file).
        (5) The Platinum ICD prefers to term this "Angular Velocity" in "Hz" rather than "Rotation"
            in "revolutions per sec"; since both describe the same physical measurement,
            NeXtMidas follows the usage in the BLUE 1.x ICD.
        (6) {@link #PERCENTAGE} and {@link #PRESSURE_PSI} were added to the BLUE 1.x ICD for
            compatibility with Platinum. Older versions of X-Midas and NeXtMidas do not support them.
        (7) The Platinum ICD does not support {@link #LATITUDE_DEG} or {@link #LONGITUDE_DEG}
            and explicitly requires use of {@link #ANGLE_DEG} for latitude/longitude values.
        (8) The Platinum ICD does not support {@link #ALTITUDE_M}, and explicitly requires use of
            {@link #DISTANCE_M} for most altitude values.
    </pre>
    @author Jeff Schoen
    @author J. Czechowski IV
    @version $Id: Units.java,v 1.24 2014/10/29 14:13:24 ntn Exp $
 */
public interface Units {
  /** The comma-separated list of names for the different units. <b>Note that
      this list is incomplete; the proper way of getting the name associated
      with a units code is to use {@link nxm.sys.lib.DataFile#getUnitsName(int)}.</b>
      @deprecated Since NeXtMidas 3.5.2, use DataFile.getUnitsName(int) instead, this will be removed in the future.
   */
  @Deprecated // TODO: remove this in 3.9+
  String unitsList = "Time,Delay,Frequency,TimeCode,Distance,Speed,Acceleration";


  //////////////////////////////////////////////////////////////////////////////////////////////////
  // COMP TYPES FOR TYPE 5000 BLUE FILES
  //////////////////////////////////////////////////////////////////////////////////////////////////
  /** The comma-separated list of names for the type of measurement represented by the component.
      This is frequently used to indicate the coordinate system for positional fields. */
  String compTypeList = "Scalar,Cartesian,Spherical,Cylindric,Ellipsoid,Geodetic,,,,Matrix";

  /** Maps the units ID to its name, description, and real-world units. Example:
      <pre>
        COMP_TYPE_INFO[1][0] = Name (lowercase)  = "Scalar"   (required for backwards compatibility)
        COMP_TYPE_INFO[1][1] = Name (uppercase)  = "SCALAR"   (required for performance reasons)
      </pre>
      Note that the real-world units will be null where not applicable. If a given unit ID is
      undefined all values will be null.
   */
  @InternalUseOnly("since 3.5.2")
  String[][] COMP_TYPE_INFO = new String[][] {
        { "Undefined", "UNDEFINED" },
        { "Scalar",    "SCALAR"    },
        { "Cartesian", "CARTESIAN" },
        { "Spherical", "SPHERICAL" },
        { "Cylindric", "CYLINDRIC" },
        { "Ellipsoid", "ELLIPSOID" },
        { "Geodetic",  "GEODETIC"  },
        { null,        null        },
        { null,        null        },
        { null,        null        },
        { "Matrix",    "MATRIX"    }
  };

  /** <b>Comp Type:</b> Indicates that the value is undefined with respect to coordinate system.<br>
      <br>
      <i>It is not uncommon to see {@link #NONE} used in situations where UNKNOWN is required.
         Although this is a semantic error, in the strictest sense, the code will function as
         expected since both constants have the same numeric value.</i>
   */
  int UNDEFINED = 0;
  /** <b>Comp Type:</b> Indicates that the value is a scalar quantity. */
  int SCALAR = 1;
  /** <b>Comp Type:</b> Indicates that the value is a Cartesian coordinate. */
  int CARTESIAN  = 2;
  /** <b>Comp Type:</b> Indicates that the value is a spherical coordinate. */
  int SPHERICAL  = 3;
  /** <b>Comp Type:</b> Indicates that the value is a cylindrical coordinate. */
  int CYLINDRIC  = 4;
  /** <b>Comp Type:</b> Indicates that the value is a ellipsoidal coordinate. */
  int ELLIPSOID  = 5;
  /** <b>Comp Type:</b> Indicates that the value is a geodetic coordinate. */
  int GEODETIC = 6;
  /** <b>Comp Type:</b> Indicates that the value is a matrix. */
  int MATRIX   = 10;


  //////////////////////////////////////////////////////////////////////////////////////////////////
  // EXPONENT NAMES & VALUES
  //////////////////////////////////////////////////////////////////////////////////////////////////
  /** Metric prefixes allowed in unit conversions for plots */
  String[] expNames = { "pico", "nano", "micro", "milli", "Kilo", "Mega", "Giga", "Tera" };
  /** Metric prefix abbreviations allowed in unit conversions for plots */
  char[] expAbbr = {'p','n','u','m','K','M','G','T'};
  /** Metric prefix exponent values allowed in unit conversions for plots */
  int[] expValues = {-12,-9,-6,-3,3,6,9,12};


  //////////////////////////////////////////////////////////////////////////////////////////////////
  // UNITS ID's FOR BLUE FILES
  //////////////////////////////////////////////////////////////////////////////////////////////////
  /** <span style="color:blue">No applicable units</span> */
  int NONE              =  0;
  /** Time (sec). <br>
      <br>
      <b>Platinum Files:</b> Within a Platinum file time-valued data with the units of
      TIME_S is provided in terms of seconds since the epoch (see also {@link #COUNTS}).
   */
  int TIME_S            =  1, TIME         =  1;
  /** Delay (sec) */
  int DELAY_S           =  2, DELAY        =  2;
  /** Frequency (Hz) */
  int FREQUENCY_HZ      =  3, FREQUENCY    =  3, FREQ =  3;
  /** Time-code. <br>
      <br>
      <b>Platinum Files:</b> Within a Platinum file time-valued data is required
      to use either {@link #TIME_S} or {@link #COUNTS}. <i>A number of buggy
      systems are known to specify a units of TIMECODE, though their usage of
      this is inconsistent with the the BLUE 1.0 use of TIMECODE.</i>
   */
  int TIMECODE                  =  4;
  /** Distance (m) */
  int DISTANCE_M                =  5, DISTANCE     =  5, DIST =  5;
  /** Speed (m/sec) */
  int SPEED_M_S                 =  6, SPEED        =  6;
  /** Acceleration (m/s^2) */
  int ACCELERATION_M_S2         =  7, ACCELERATION =  7, ACCEL =  7;
  /** Jerk (m/s^3) */
  int JERK_M_S3                 =  8, JERK         =  8;
  /** Doppler (Hz) */
  int DOPPLER_HZ                =  9, DOPPLER      =  9;
  /** Doppler Rate (Hz/s) */
  int DOPPLER_RATE_HZ_S         = 10, DOPPLER_RATE = 10;
  /** Energy (J) */
  int ENERGY_J                  = 11, ENERGY       = 11;
  /** Power (W) */
  int POWER_W                   = 12, POWER        = 12;
  /** Mass (g) */
  int MASS_G                    = 13, MASS         = 13;
  /** Volume (l) */
  int VOLUME_L                  = 14, VOLUME       = 14;
  /** Angular power density (W/ster) */
  int ANG_POWER_DEN_W_STER      = 15;
  /** Integrated power density (W/rad) */
  int INTEG_POWER_DEN_RAD_W_RAD = 16;
  /** Spatial power density (W/m^2) */
  int SPATIAL_POWER_DEN_W_M2    = 17;
  /** Integrated power density (W/m) */
  int INTEG_POWER_DEN_W_M       = 18;
  /** Spectral power density (W/MHz) */
  int SPECTRAL_POWER_DEN_W_MHZ  = 19;
  /** Amplitude */
  int AMPLITUDE                 = 20;
  /** Real */
  int REAL                      = 21;
  /** Imaginary */
  int IMAGINARY                 = 22;
  /** Phase (rad) */
  int PHASE_RAD                 = 23;
  /** Phase (deg) */
  int PHASE_DEG                 = 24;
  /** Phase (cycles) */
  int PHASE_CYCLES              = 25;
  /** 10*Log */
  int TEN_LOG                   = 26;
  /** 20*Log */
  int TWENTY_LOG                = 27;
  /** Magnitude */
  int MAGNITUDE                 = 28;
  /** Frequency difference (Hz) */
  int FREQ_DIFF_HZ              = 29, FREQ_DIFF    = 29;
  /** <span style="color:blue">Unknown units</span> */
  int UNKNOWN                   = 30;
  /** Dimensionless */
  int DIMENSIONLESS             = 31;
  /** Counts. <br>
      <br>
      <b>Platinum Files:</b> Within a Platinum file time-valued data with the
      units of COUNTS is provided in terms of clock ticks since the epoch (see
      also {@link #TIME_S}).
   */
  int COUNTS                    = 32;
  /** Angle (rad) */
  int ANGLE_RAD                 = 33;
  /** Angle (deg) */
  int ANGLE_DEG                 = 34;
  /** Relative power (dB) */
  int REL_POWER_DB              = 35;
  /** Relative power (dBm) */
  int REL_POWER_DBM             = 36;
  /** Relative power (dBW) */
  int REL_POWER_DBW             = 37;
  /** Solid angle (ster) */
  int SOLID_ANGLE_STER          = 38;
  //// 39 ////
  /** Distance (ft) */
  int DISTANCE_FT               = 40;
  /** Distance (nmi) */
  int DISTANCE_NMI              = 41;
  /** Speed (ft/sec) */
  int SPEED_FT_S                = 42;
  /** Speed (nmi/sec) */
  int SPEED_NMI_S               = 43;
  /** Speed (knots) */
  int SPEED_KNOTS               = 44;
  /** Acceleration (ft/s^2) */
  int ACCEL_FT_S2               = 45;
  /** Acceleration (nmi/s^2) */
  int ACCEL_NMI_S2              = 46;
  /** Acceleration (knots/s) */
  int ACCEL_KNOTS_S             = 47;
  /** Acceleration (G) */
  int ACCEL_G                   = 48;
  /** Jerk (G/sec) */
  int JERK_G_S                  = 49;
  /** Rotation (rps) */
  int ROTATION_RPS              = 50;
  /** Rotation (rpm) */
  int ROTATION_RPM              = 51;
  /** Angular velocity (rad/s) */
  int ANG_VEL_RAD_S             = 52;
  /** Angular velocity (deg/s) */
  int ANG_VEL_DEG_S             = 53;
  /** Angular acceleration (rad/s^2) */
  int ANG_ACCEL_RAD_S2          = 54;
  /** Angular acceleration (deg/s^2) */
  int ANG_ACCEL_DEG_S2          = 55;
  /** Percentage (%). Since NeXtMidas 3.3.0. */
  int PERCENTAGE                = 56;
  /** Pressure (PSI). Since NeXtMidas 3.3.0. */
  int PRESSURE_PSI              = 57;
  //// 58 ////
  //// 59 ////
  /** Latitude (deg) */
  int LATITUDE_DEG              = 60, LATITUDE  = 60, LAT = 60;
  /** Longitude (deg) */
  int LONGITUDE_DEG             = 61, LONGITUDE = 61, LON = 61;
  /** Altitude (ft) */
  int ALTITUDE_FT               = 62;
  /** Altitude (m) */
  int ALTITUDE_M                = 63, ALTITUDE  = 63, ALT = 63;
  /** Baud (symbols per second sym/s) */
  int BAUD                      = 66;
  /** Bit rate (bits per second bit/s) */
  int BIT_RATE                  = 67;
  /** Potential Difference in volts */
  int POTENTIAL_DIFF            = 68;
  /** Current in Volts */
  int CURRENT                   = 69;
  /** Resistance in ohms */
  int RESISTANCE                = 70;
  /** Capacitance in farads */
  int CAPACITANCE               = 71;
  /** Inductance in henries */
  int INDUCTANCE                = 72;
  /** Temperature in kelvin */
  int TEMPERATURE               = 73;
  /** Pressure in pascal */
  int PRESSURE                  = 74;
  /** Relative power (dBm referenced to isotropic source) dBmi */
  int RELATIVE_POWER            = 75;
  /** Relative power density (dBm referenced to isotropic source per hertz) dBmi/Hz*/
  int RELATIVE_POWER_DENSE      = 76;

  /** Maps the units ID to its name, description, and real-world units. Example:
      <pre>
        UNITS_INFO[1][0] = Units Name       = "TIME_S"
        UNITS_INFO[1][1] = Description      = "Time"
        UNITS_INFO[1][2] = Real-World Units = "sec"
      </pre>
      Note that the real-world units will be null where not applicable. If a given unit ID is
      undefined all values will be null.
   */
  @InternalUseOnly("since 3.5.2")
  String[][] UNITS_INFO = new String[][]
      { { "NONE",                        "None",                     null      }, // 0
        { "TIME_S",                      "Time",                     "sec"     },
        { "DELAY_S",                     "Delay",                    "sec"     },
        { "FREQUENCY_HZ",                "Frequency",                "Hz"      },
        { "TIMECODE",                    "Time-code",                null      },
        { "DISTANCE_M",                  "Distance",                 "m"       },
        { "SPEED_M_S",                   "Speed",                    "m/sec"   },
        { "ACCELERATION_M_S2",           "Acceleration",             "m/s^2"   },
        { "JERK_M_S3",                   "Jerk",                     "m/s^3"   },
        { "DOPPLER_HZ",                  "Doppler",                  "Hz"      },
        { "DOPPLER_RATE_HZ_S",           "Doppler Rate",             "Hz/s"    }, // 10
        { "ENERGY_J",                    "Energy",                   "J"       },
        { "POWER_W",                     "Power",                    "W"       },
        { "MASS_G",                      "Mass",                     "g"       },
        { "VOLUME_L",                    "Volume",                   "l"       },
        { "ANG_POWER_DEN_W_STER",        "Angular power density",    "W/ster"  },
        { "INTEG_POWER_DEN_RAD_W_RAD",   "Integrated power density", "W/rad"   },
        { "SPATIAL_POWER_DEN_W_M2",      "Spatial power density",    "W/m^2"   },
        { "INTEG_POWER_DEN_W_M",         "Integrated power density", "W/m"     },
        { "SPECTRAL_POWER_DEN_W_MHZ",    "Spectral power density",   "W/MHz"   },
        { "AMPLITUDE",                   "Amplitude",                null      }, // 20
        { "REAL",                        "Real",                     null      },
        { "IMAGINARY",                   "Imaginary",                null      },
        { "PHASE_RAD",                   "Phase",                    "rad"     },
        { "PHASE_DEG",                   "Phase",                    "deg"     },
        { "PHASE_CYCLES",                "Phase",                    "cycles"  },
        { "TEN_LOG",                     "10Log",                    null      },
        { "TWENTY_LOG",                  "20Log",                    null      },
        { "MAGNITUDE",                   "Magnitude",                null      },
        { "FREQ_DIFF_HZ",                "Freq difference",          "Hz"      },
        { "UNKNOWN",                     "Unknown units",            null      }, // 30
        { "DIMENSIONLESS",               "Dimensionless",            null      },
        { "COUNTS",                      "Counts",                   null      },
        { "ANGLE_RAD",                   "Angle",                    "rad"     },
        { "ANGLE_DEG",                   "Angle",                    "deg"     },
        { "REL_POWER_DB",                "Relative power",           "dB"      },
        { "REL_POWER_DBM",               "Relative power",           "dBm"     },
        { "REL_POWER_DBW",               "Relative power",           "dBW"     },
        { "SOLID_ANGLE_STER",            "Solid angle",              "ster"    },
        { null,                          null,                       null      }, // 39
        { "DISTANCE_FT",                 "Distance",                 "ft"      }, // 40
        { "DISTANCE_NMI",                "Distance",                 "nmi"     },
        { "SPEED_FT_S",                  "Speed",                    "ft/sec"  },
        { "SPEED_NMI_S",                 "Speed",                    "nmi/sec" },
        { "SPEED_KNOTS",                 "Speed",                    "knots"   },
        { "ACCEL_FT_S2",                 "Acceleration",             "ft/s^2"  },
        { "ACCEL_NMI_S2",                "Acceleration",             "nmi/s^2" },
        { "ACCEL_KNOTS_S",               "Acceleration",             "knots/s" },
        { "ACCEL_G",                     "Acceleration",             "G"       },
        { "JERK_G_S",                    "Jerk",                     "G/sec"   },
        { "ROTATION_RPS",                "Rotation",                 "rps"     }, // 50
        { "ROTATION_RPM",                "Rotation",                 "rpm"     },
        { "ANG_VEL_RAD_S",               "Angular vel",              "rad/s"   },
        { "ANG_VEL_DEG_S",               "Angular vel",              "deg/s"   },
        { "ANG_ACCEL_RAD_S2",            "Angular accel",            "rad/s^2" },
        { "ANG_ACCEL_DEG_S2",            "Angular accel",            "deg/s^2" },
        { "PERCENTAGE",                  "Precentage",               "%"       }, // 56 since 3.3.0
        { "PRESSURE_PSI",                "Pressure",                 "PSI"     }, // 57 since 3.3.0
        { null,                          null,                       null      }, // 58
        { null,                          null,                       null      }, // 59
        { "LATITUDE_DEG",                "Latitude",                 "deg"     }, // 60
        { "LONGITUDE_DEG",               "Longitude",                "deg"     },
        { "ALTITUDE_FT",                 "Altitude",                 "ft"      },
        { "ALTITUDE_M",                  "Altitude",                 "m"       },
        { null,                          null,                       null      },
        { null,                          null,                       null      }, // 65
        { "BAUD",                        "BAUD",                     "sym/s"   },
        { "BIT_RATE",                    "Bit Rate",                 "bit/s"   },
        { "POTENTIAL_DIFF",              "Potential Difference",     "V"       },
        { "CURRENT",                     "Current",                  "A"       },
        { "RESISTANCE",                  "Resistance",               "ohms"    }, // 70
        { "CAPACITANCE",                 "Capacitance",              "F"       },
        { "INDUCTANCE",                  "Inductance",               "H"       },
        { "TEMPERATURE",                 "Temperature",              "K"       },
        { "PRESSURE",                    "Pressure",                 "Pa"      },
        { "RELATIVE_POWER",              "Relative power",           "dBmi"    }, // 75
        { "RELATIVE_POWER_DENSE",        "Relative power density",   "dBmi/Hz" },
        };

  /** Maps the units abbreviation to its ID. Example:
      <pre>
        UNITS_ABBR[n][0] = Units Name (String)
        UNITS_ABBR[n][1] = ID (Integer)
      </pre>
   */
  @InternalUseOnly("since 3.5.2")
  Object[][] UNITS_ABBR = new Object[][]
      { { "TIME",         Integer.valueOf(TIME)         },
        { "DELAY",        Integer.valueOf(DELAY)        },
        { "FREQUENCY",    Integer.valueOf(FREQUENCY)    },
        { "FREQ",         Integer.valueOf(FREQ)         },
        { "DISTANCE",     Integer.valueOf(DISTANCE)     },
        { "DIST",         Integer.valueOf(DIST)         },
        { "SPEED",        Integer.valueOf(SPEED)        },
        { "ACCELERATION", Integer.valueOf(ACCELERATION) },
        { "ACCEL",        Integer.valueOf(ACCEL)        },
        { "JERK",         Integer.valueOf(JERK)         },
        { "DOPPLER",      Integer.valueOf(DOPPLER)      },
        { "DOPPLER_RATE", Integer.valueOf(DOPPLER_RATE) },
        { "ENERGY",       Integer.valueOf(ENERGY)       },
        { "POWER",        Integer.valueOf(POWER)        },
        { "MASS",         Integer.valueOf(MASS)         },
        { "VOLUME",       Integer.valueOf(VOLUME)       },
        { "FREQ_DIFF",    Integer.valueOf(FREQ_DIFF)    },
        { "LATITUDE",     Integer.valueOf(LATITUDE)     },
        { "LAT",          Integer.valueOf(LAT)          },
        { "LONGITUDE",    Integer.valueOf(LONGITUDE)    },
        { "LON",          Integer.valueOf(LON)          },
        { "ALTITUDE",     Integer.valueOf(ALTITUDE)     },
        { "ALT",          Integer.valueOf(ALT)          } };
} // end interface Units
