// Suppress IDE0022:Use block body for methods -- short extension methods may be declared with expression bodies
#pragma warning disable IDE0022 

using System;
using System.Linq;
using System.Text;

namespace Volpe.Cafe
{
    #region <<< Fuel and Powertrain Type enums >>>

    /// <summary>
    /// Specifies the fuel type used by a vehicle. For flex-fuel or multi-fuel vehicles, multiple fuel types may be
    /// combined.
    /// </summary>
    [Serializable, Flags]
    public enum FuelType
    {
        //--------------------------------------------------------------------------------------//
        // ** WARNING **                                                                        //
        //                                                                                      //
        // Do not change the coding of the variable names defined in this enumeration.          //
        //                                                                                      //
        // Changing the values of this enum constants may render parts of the model unusable.   //
        //                                                                                      //
        //--------------------------------------------------------------------------------------//

        /// <summary>Specifies that the fuel type of a vehicle is unknown or undefined.</summary>
        None = 0,

        //----- liquid fuel types -----
        /// <summary>Specifies that the vehicle runs on Gasoline fuel.</summary>
        Gasoline = 1,
        /// <summary>Specifies that the vehicle runs on E85 fuel (blend of 85% Ethanol, 15% Gasoline).</summary>
        Ethanol85 = 8,
        /// <summary>Specifies that the vehicle runs on Diesel fuel.</summary>
        Diesel = 16,

        //----- GEG fuel types -----
        /// <summary>Specifies that the vehicle runs on Electricity.</summary>
        Electricity = 256,
        /// <summary>Specifies that the vehicle runs on Hydrogen fuel.</summary>
        Hydrogen = 512,
        /// <summary>Specifies that the vehicle runs on Compressed Natural Gas fuel.</summary>
        CNG = 1024,

        //----- dual-/multi-fuel types -----
        /// <summary>Specifies that the vehicle runs on Gasoline and Ethanol-85 fuels.</summary>
        GasolineE85 = Gasoline | Ethanol85,
        /// <summary>Specifies that the vehicle runs on Gasoline fuel and on Electricity.</summary>
        GasolineElectric = Gasoline | Electricity,
        /// <summary>Specifies that the vehicle runs on Diesel fuel and on Electricity.</summary>
        DieselElectric = Diesel | Electricity,

        //----- composite fuel types -----
        /// <summary>Specifies a combination of all available fuel types.</summary>
        All = Gasoline | Ethanol85 | Diesel |
              Electricity | Hydrogen | CNG
    }

    /// <summary>
    /// Specifies the vehicle's hybrid/electric type.
    /// </summary>
    [Serializable]
    public enum HEVType
    {
        /// <summary>Specifies a combination of all available HEV types.</summary>
        /// <remarks>This value is useful for reporting purposes.</remarks>
        All = -1,

        /// <summary>Specifies a vehicle with a conventional powertrain.</summary>
        Conventional = 0,

        /// <summary>Specifies a mild hybrid-electric vehicle (MHEV).</summary>
        MildHybrid = 1,
        /// <summary>Specifies a strong hybrid-electric vehicle (SHEV).</summary>
        StrongHybrid = 2,
        /// <summary>Specifies a plug-in hybrid-electric vehicle (PHEV).</summary>
        PlugInHybrid = 3,
        /// <summary>Specifies an extended range electric vehicle (EREV).</summary>
        ExtendedRangeEV = 4,
        /// <summary>Specifies a battery-electric vehicle (BEV).</summary>
        BatteryElectric = 5,
        /// <summary>Specifies a fuel cell vehicle (FCV).</summary>
        FuelCell = 6
    }

    #endregion

    #region <<< Vehicle Classification enums >>>

    /// <summary>
    /// Specifies the CAFE regulatory class assignment of a vehicle.
    /// </summary>
    [Serializable]
    public enum RegulatoryClass
    {
        /// <summary>Specifies that the vehicle's regulatory class is unknown or undefined.</summary>
        None = 0,

        //----- individual classes -----
        /// <summary>Specifies that the vehicle is regulated using domestic passenger car standards.</summary>
        DomesticCar = 1,
        /// <summary>Specifies that the vehicle is regulated using imported passenger car standards.</summary>
        ImportedCar = 2,
        /// <summary>Specifies that the vehicle is regulated using the light truck standards.</summary>
        LightTruck = 3,
        /// <summary>Specifies that the vehicle is regulated using the heavy-duty pickup and van standards.</summary>
        HDPUV = 4,

        //----- aggregate classification -----
        /// <summary>Specifies a combination of all available passenger car regulatory classes.</summary>
        AllPassengerCar = 21,
        /// <summary>Specifies a combination of all available light duty regulatory classes.</summary>
        AllLightDuty = 22,
        /// <summary>Specifies a combination of all available regulatory classes.</summary>
        /// <remarks>This value is useful for reporting purposes.</remarks>
        All = 31,
    }

    /// <summary>
    /// Specifies the safety class assignment of a vehicle.
    /// </summary>
    [Serializable]
    public enum SafetyClass
    {
        /// <summary>Specifies that the vehicle's safety class is unknown or undefined.</summary>
        None = 0,

        /// <summary>Specifies a "PC" safety class.</summary>
        PC = 1,
        /// <summary>Specifies a "LT/SUV" safety class.</summary>
        LT = 2,
        /// <summary>Specifies a "CUV/Minivan" safety class.</summary>
        CM = 3
    }

    /// <summary>
    /// Specifies the vehicle's classification.
    /// </summary>
    [Serializable]
    public enum VehicleClass
    {
        /// <summary>Specifies a combination of all available vehicle classes.</summary>
        /// <remarks>This value is useful for reporting purposes.</remarks>
        All = -1,
        /// <summary>Specifies that the vehicle's class is unknown or undefined.</summary>
        None = 0,

        //----- individual classes -----
        /// <summary>Specifies a light duty passenger vehicle.</summary>
        LDV = 1,
        /// <summary>
        /// Specifies a class-1 light duty truck, with a gross vehicle weight rating (GVWR) ranging from 0 to 6,000
        /// pounds.
        /// </summary>
        LDT1 = 2,
        /// <summary>
        /// Specifies a class-2a light duty truck, with a gross vehicle weight rating (GVWR) ranging from 6,001 to
        /// 8,500 pounds.
        /// </summary>
        LDT2a = 3,
        /// <summary>
        /// Specifies a class-2b light duty truck, with a gross vehicle weight rating (GVWR) ranging from 8,501 to
        /// 10,000 pounds.
        /// </summary>
        LDT2b = 4,
        /// <summary>
        /// Specifies a class-3 light duty truck, with a gross vehicle weight rating (GVWR) ranging from 10,001 to
        /// 14,000 pounds.
        /// </summary>
        LDT3 = 5,

        //----- aggregate classification (for binning) -----
        /// <summary>
        /// Specifies a joint vehicle classification for vehicles that are classified as either a class-1 light duty
        /// truck, with a gross vehicle weight rating (GVWR) ranging from 0 to 6,000 pounds, or a class-2a light duty
        /// truck, with a gross vehicle weight rating (GVWR) ranging from 6,001 to 8,500 pounds.
        /// </summary>
        LDT12a = 101,
        /// <summary>
        /// Specifies a joint vehicle classification for vehicles that are classified as either a class-2b light duty
        /// truck, with a gross vehicle weight rating (GVWR) ranging from 8,501 to 10,000 pounds, or a class-3 light
        /// duty truck, with a gross vehicle weight rating (GVWR) ranging from 10,001 to 14,000 pounds.
        /// </summary>
        LDT2b3 = 102,
    }

    /// <summary>
    /// Specifies the vehicle's body style.
    /// </summary>
    [Serializable]
    public enum VehicleStyle
    {
        /// <summary>Specifies that the vehicle's style is unknown or undefined.</summary>
        None = 0,

        //----- styles for individual vehicles -----
        /// <summary>Specifies a convertible passenger car.</summary>
        Convertible = 1,
        /// <summary>Specifies a coupe passenger car.</summary>
        Coupe = 2,
        /// <summary>Specifies a hatchback passenger car.</summary>
        Hatchback = 3,
        /// <summary>Specifies a sedan passenger car.</summary>
        Sedan = 4,
        /// <summary>Specifies a wagon passenger car.</summary>
        Wagon = 5,

        /// <summary>Specifies a light duty sport utility vehicle.</summary>
        SportUtility = 6,
        /// <summary>Specifies a light duty minivan.</summary>
        Minivan = 7,
        /// <summary>Specifies a light duty van.</summary>
        Van = 8,
        /// <summary>Specifies a light duty passenger van.</summary>
        PassengerVan = 9,
        /// <summary>Specifies a light duty cargo van.</summary>
        CargoVan = 10,
        /// <summary>Specifies a light-duty pickup truck.</summary>
        Pickup = 11,

        /// <summary>Specifies a class 2b/3 sport utility vehicle.</summary>
        FleetSuv = 21,
        /// <summary>Specifies a class 2b/3 work van.</summary>
        WorkVan = 22,
        /// <summary>Specifies a class 2b/3 work truck.</summary>
        WorkTruck = 23,
        /// <summary>Specifies a class 2b/3 chassis cab truck.</summary>
        ChassisCab = 24,
        /// <summary>Specifies a class 2b/3 cutaway van/truck.</summary>
        Cutaway = 25,

        //----- styles for binning vehicle categories -----
        /// <summary>Specifies a generic vehicle category used to represent passenger cars.</summary>
        GenericCar = 101,
        /// <summary>Specifies a generic vehicle category used to represent light duty vans and SUVs.</summary>
        GenericVanSUV = 102,
        /// <summary>Specifies a generic vehicle category used to represent light duty pickup trucks.</summary>
        GenericPickup = 103,
        /// <summary>Specifies a generic vehicle category used to represent class 2b/3 vehicles.</summary>
        Generic2b3 = 104
    }

    /// <summary>
    /// Specifies the technology class assignment of a vehicle.
    /// </summary>
    [Serializable]
    public enum TechnologyClass
    {
        /// <summary>Specifies that the vehicle's technology class is unknown or undefined.</summary>
        None = 0,

        //----- light duty vehicle technology classes -----
        /// <summary>Specifies a technology class for small cars.</summary>
        SmallCar = 1,
        /// <summary>Specifies a technology class for small performance cars.</summary>
        SmallCarPerf,
        /// <summary>Specifies a technology class for midsize cars.</summary>
        MedCar,
        /// <summary>Specifies a technology class for midsize performance cars.</summary>
        MedCarPerf,
        /// <summary>Specifies a technology class for small SUVs.</summary>
        SmallSUV,
        /// <summary>Specifies a technology class for small performance SUVs.</summary>
        SmallSUVPerf,
        /// <summary>Specifies a technology class for midsize SUVs.</summary>
        MedSUV,
        /// <summary>Specifies a technology class for midsize performance SUVs.</summary>
        MedSUVPerf,
        /// <summary>Specifies a technology class for pickup trucks.</summary>
        Pickup,
        /// <summary>Specifies a technology class for "high technology" pickup trucks.</summary>
        PickupHT,

        //----- 2b/3 vehicle technology classes -----
        /// <summary>Specifies a technology class for class-2B pickup trucks.</summary>
        Pickup2b,
        /// <summary>Specifies a technology class for class-2B vans.</summary>
        Van2b,
        /// <summary>Specifies a technology class for class-3 pickup trucks.</summary>
        Pickup3,
        /// <summary>Specifies a technology class for class-3 vans.</summary>
        Van3
    }

    /// <summary>
    /// Specifies the engine technology class assignment of a vehicle.
    /// </summary>
    [Serializable]
    public enum EngineTechnologyClass
    {
        /// <summary>Specifies that the vehicle's engine technology class is unknown or undefined.</summary>
        None = 0,

        //===== light-duty engine classes =====
        //----- DOHC engine classes -----
        /// <summary>Specifies an engine technology class for DOHC engines with 2 cylinders and 1 bank.</summary>
        DOHC_2C1B = 1,
        /// <summary>Specifies an engine technology class for DOHC engines with 3 cylinders and 1 bank.</summary>
        DOHC_3C1B,
        /// <summary>Specifies an engine technology class for DOHC engines with 4 cylinders and 1 bank.</summary>
        DOHC_4C1B,
        /// <summary>Specifies an engine technology class for DOHC engines with 4 cylinders and 1 bank.</summary>
        DOHC_4C1B_L,
        /// <summary>Specifies an engine technology class for DOHC engines with 4 cylinders and 2 banks.</summary>
        DOHC_4C2B,
        /// <summary>Specifies an engine technology class for DOHC engines with 4 cylinders and 2 banks.</summary>
        DOHC_4C2B_L,
        /// <summary>Specifies an engine technology class for DOHC engines with 5 cylinders and 1 bank.</summary>
        DOHC_5C1B,
        /// <summary>Specifies an engine technology class for DOHC engines with 6 cylinders and 1 bank.</summary>
        DOHC_6C1B,
        /// <summary>Specifies an engine technology class for DOHC engines with 6 cylinders and 2 banks.</summary>
        DOHC_6C2B,
        /// <summary>Specifies an engine technology class for DOHC engines with 8 cylinders and 2 bank.</summary>
        DOHC_8C2B,
        /// <summary>Specifies an engine technology class for DOHC engines with 10 cylinders and 2 banks.</summary>
        DOHC_10C2B,
        /// <summary>Specifies an engine technology class for DOHC engines with 12 cylinders and 2 banks.</summary>
        DOHC_12C2B,
        /// <summary>Specifies an engine technology class for DOHC engines with 12 cylinders and 4 banks.</summary>
        DOHC_12C4B,
        /// <summary>Specifies an engine technology class for DOHC engines with 16 cylinders and 4 banks.</summary>
        DOHC_16C4B,

        //----- SOHC engine classes -----
        /// <summary>Specifies an engine technology class for SOHC engines with 2 cylinders and 1 bank.</summary>
        SOHC_2C1B,
        /// <summary>Specifies an engine technology class for SOHC engines with 3 cylinders and 1 bank.</summary>
        SOHC_3C1B,
        /// <summary>Specifies an engine technology class for SOHC engines with 4 cylinders and 1 bank.</summary>
        SOHC_4C1B,
        /// <summary>Specifies an engine technology class for SOHC engines with 4 cylinders and 1 bank.</summary>
        SOHC_4C1B_L,
        /// <summary>Specifies an engine technology class for SOHC engines with 4 cylinders and 2 banks.</summary>
        SOHC_4C2B,
        /// <summary>Specifies an engine technology class for SOHC engines with 5 cylinders and 1 bank.</summary>
        SOHC_5C1B,
        /// <summary>Specifies an engine technology class for SOHC engines with 6 cylinders and 1 bank.</summary>
        SOHC_6C1B,
        /// <summary>Specifies an engine technology class for SOHC engines with 6 cylinders and 2 banks.</summary>
        SOHC_6C2B,
        /// <summary>Specifies an engine technology class for SOHC engines with 8 cylinders and 2 banks.</summary>
        SOHC_8C2B,
        /// <summary>Specifies an engine technology class for SOHC engines with 10 cylinders and 2 banks.</summary>
        SOHC_10C2B,
        /// <summary>Specifies an engine technology class for SOHC engines with 12 cylinders and 2 banks.</summary>
        SOHC_12C2B,
        /// <summary>Specifies an engine technology class for SOHC engines with 12 cylinders and 4 banks.</summary>
        SOHC_12C4B,
        /// <summary>Specifies an engine technology class for SOHC engines with 16 cylinders and 4 banks.</summary>
        SOHC_16C4B,

        //----- OHV engine classes -----
        /// <summary>Specifies an engine technology class for OHV engines with 6 cylinders and 1 bank.</summary>
        OHV_6C1B,
        /// <summary>Specifies an engine technology class for OHV engines with 6 cylinders and 2 banks.</summary>
        OHV_6C2B,
        /// <summary>Specifies an engine technology class for OHV engines with 8 cylinders and 2 banks.</summary>
        OHV_8C2B,
        /// <summary>Specifies an engine technology class for OHV engines with 10 cylinders and 2 banks.</summary>
        OHV_10C2B,

        //===== 2b/3 engine classes =====
        //----- DOHC engine classes -----
        /// <summary>Specifies a 2b/3 engine technology class for DOHC engines with 4 cylinders and 1 bank.</summary>
        DOHC_4C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for DOHC engines with 4 cylinders and 2 banks.</summary>
        DOHC_4C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for DOHC engines with 5 cylinders and 1 bank.</summary>
        DOHC_5C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for DOHC engines with 6 cylinders and 1 bank.</summary>
        DOHC_6C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for DOHC engines with 6 cylinders and 2 banks.</summary>
        DOHC_6C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for DOHC engines with 8 cylinders and 2 bank.</summary>
        DOHC_8C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for DOHC engines with 10 cylinders and 2 banks.</summary>
        DOHC_10C2B_2b3,

        //----- SOHC engine classes -----
        /// <summary>Specifies a 2b/3 engine technology class for SOHC engines with 4 cylinders and 1 bank.</summary>
        SOHC_4C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for SOHC engines with 4 cylinders and 2 banks.</summary>
        SOHC_4C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for SOHC engines with 5 cylinders and 1 bank.</summary>
        SOHC_5C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for SOHC engines with 6 cylinders and 1 bank.</summary>
        SOHC_6C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for SOHC engines with 6 cylinders and 2 banks.</summary>
        SOHC_6C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for SOHC engines with 8 cylinders and 2 bank.</summary>
        SOHC_8C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for SOHC engines with 10 cylinders and 2 banks.</summary>
        SOHC_10C2B_2b3,

        //----- OHV engine classes -----
        /// <summary>Specifies a 2b/3 engine technology class for OHV engines with 4 cylinders and 1 bank.</summary>
        OHV_4C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for OHV engines with 4 cylinders and 2 banks.</summary>
        OHV_4C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for OHV engines with 5 cylinders and 1 bank.</summary>
        OHV_5C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for OHV engines with 6 cylinders and 1 bank.</summary>
        OHV_6C1B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for OHV engines with 6 cylinders and 2 banks.</summary>
        OHV_6C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for OHV engines with 8 cylinders and 2 bank.</summary>
        OHV_8C2B_2b3,
        /// <summary>Specifies a 2b/3 engine technology class for OHV engines with 10 cylinders and 2 banks.</summary>
        OHV_10C2B_2b3
    }

    #endregion

    #region <<< Technology Information enums >>>
    //*** The following enums are reserved for future expansion and may not be currently in use. ***

    /// <summary>
    /// Specifies the application level of a technology, whether the technology is vehicle-level, which applies
    /// directly to individual vehicles, or platform, engine, or transmission-level, which applies all vehicles that
    /// share a common platform, engine, or transmission.
    /// </summary>
    [Serializable]
    public enum TechnologyApplicationLevel
    {
        /// <summary>
        /// Specifies a default application level of technology. This value should typically be used during analysis to
        /// consider all available technologies based on the underlying component being evaluated (vehicle, platform,
        /// engine, or transmissions). For vehicles, all technologies will be considered, whereas for platforms,
        /// engines, and transmissions, only the technologies applicable to that component will be used.
        /// </summary>
        Default = 0,

        /// <summary>
        /// Specifies a vehicle-level technology that applies directly to individual vehicles.
        /// </summary>
        Vehicle,
        /// <summary>
        /// Specifies a platform-level technology that applies to all vehicles that share a common platform.
        /// </summary>
        Platform,
        /// <summary>
        /// Specifies an engine-level technology that applies to all vehicles that share a common engine.
        /// </summary>
        Engine,
        /// <summary>
        /// Specifies a transmission-level technology that applies to all vehicles that share a common transmission.
        /// </summary>
        Transmission
    }

    /// <summary>
    /// Specifies the application schedule of a technology, whether the technology can be applied only during a
    /// vehicle's redesign, during a vehicle's refresh or redesign, or at any time.
    /// </summary>
    [Serializable]
    public enum TechnologySchedule
    {
        /// <summary>
        /// Specifies that the technology cannot be applied during model. This value typically signifies a
        /// baseline-only technology.
        /// </summary>
        None = 0,

        /// <summary>Specifies that the technology can be applied at any time.</summary>
        Anytime,
        /// <summary>Specifies that the technology can be applied during a vehicle's refresh or redesign.</summary>
        RefreshBased,
        /// <summary>Specifies that the technology can be applied only during a vehicle's redesign.</summary>
        RedesignBased
    }

    /// <summary>
    /// Specifies a cost-multiplier applicable to a technology.
    /// </summary>
    [Serializable]
    public enum TechnologyCostMultiplier
    {
        /// <summary>Specifies that the technology does not have an associated cost-multiplier.</summary>
        None = 0,

        /// <summary>Specifies that the technology costs are computed on a per-pound basis.</summary>
        CostPerPound,
        /// <summary>Specifies that the technology costs are computed on a per-bank basis.</summary>
        CostPerBank,
        /// <summary>Specifies that the technology costs are computed on a per-cylinder basis.</summary>
        CostPerCylinder
    }

    /// <summary>
    /// Specifies the technology's applicability and utilization state on a vehicle, platform, engine, or transmission.
    /// </summary>
    [Serializable, Flags]
    public enum TechnologyState
    {
        /// <summary>Specifies that the technology is unavailable for application during modeling.</summary>
        Unavailable = 0,
        /// <summary>Specifies that the technology is available for application during modeling.</summary>
        Available = 1,
        /// <summary>
        /// Specifies that the technology is set as used on a vehicle, platform, engine, or transmission.
        /// </summary>
        Used = 2,
        /// <summary>
        /// Specifies that the technology is set as inherited on a vehicle, platform, engine, or transmission.
        /// </summary>
        Inherited = 4,
        /// <summary>
        /// Specifies that the technology is set as superseded on a vehicle, platform, engine, or transmission.
        /// </summary>
        Superseded = 8
    }

    #endregion

    #region <<< Compliance and Effects Modeling enums >>>

    /// <summary>
    /// Specifies whether the model should enforce NHTSA's CAFE program or EPA's CO-2 program when evaluating a
    /// manufacturer's compliance state.
    /// </summary>
    [Serializable]
    public enum ComplianceProgram
    {
        /// <summary>Specifies that the manufacturers should comply with NHTSA's CAFE standards.</summary>
        CAFE = 0,
        /// <summary>Specifies that the manufacturers should comply with EPA's CO-2 standards.</summary>
        CO2 = 1,
        /// <summary>
        /// Specifies that the manufacturers should comply with NHTSA's CAFE standards and with EPA's CO-2 standards
        /// simultaneously.
        /// </summary>
        CAFEAndCO2 = 2
    }

    /// <summary>
    /// Specifies whether to use low, average, high, or very high estimates for modeling.
    /// </summary>
    /// <remarks>
    /// Applicable to CO-2 costs and fatality rates.
    /// </remarks>
    [Serializable]
    public enum Estimates
    {
        /// <summary>Specifies that the low estimates should be used for modeling.</summary>
        Low = 0,
        /// <summary>Specifies that the average estimates should be used for modeling.</summary>
        /// <remarks>The average estimates should be the default option for most settings.</remarks>
        Average = 1,
        /// <summary>Specifies that the high estimates should be used for modeling.</summary>
        High = 2,
        /// <summary>Specifies that the very high estimates should be used for modeling.</summary>
        VeryHigh = 3
    }

    /// <summary>
    /// Specifies a pollutant for which vehicle upstream and tailpipe emissions are calculated.
    /// </summary>
    [Serializable]
    public enum Pollutant
    {
        //----- emissions for effects modeling -----
        /// <summary>Specifies the Carbon Monoxide pollutant.</summary>
        CO = 0,
        /// <summary>Specifies the Volatile Organic Compound pollutant.</summary>
        VOC = 1,
        /// <summary>Specifies the Nitrogen Oxides pollutant.</summary>
        NOx = 2,
        /// <summary>Specifies the Sulfur Dioxide pollutant.</summary>
        SO2 = 3,
        /// <summary>Specifies the Particulate Matter (diameter of ~2.5 micrometers) pollutant.</summary>
        PM = 4,
        /// <summary>Specifies the Carbon Dioxide pollutant.</summary>
        CO2 = 5,
        /// <summary>Specifies the Methane pollutant.</summary>
        CH4 = 6,
        /// <summary>Specifies the Nitrous Oxide pollutant.</summary>
        N2O = 7,

        //----- additional emissions for EIS modeling -----
        /// <summary>Specifies the Acetaldehyde pollutant.</summary>
        Acetaldehyde = 8,
        /// <summary>Specifies the Acrolein pollutant.</summary>
        Acrolein = 9,
        /// <summary>Specifies the Benzene pollutant.</summary>
        Benzene = 10,
        /// <summary>Specifies the 1,3-Butadiene pollutant.</summary>
        Butadiene = 11,
        /// <summary>Specifies the Formaldehyde pollutant.</summary>
        Formaldehyde = 12,
        /// <summary>Specifies the Diesel Particulate Matter (diameter of ~10 micrometers) pollutant.</summary>
        DPM10 = 13
    }

    /// <summary>
    /// Specifies the discount rate at which the dollar value of a benefit or cost is reduced when its receipt or
    /// payment is postponed by one additional year into the future.
    /// </summary>
    [Serializable]
    public enum DiscountRate
    {
        /// <summary>Specifies a 3% discount rate.</summary>
        DR3 = 3,
        /// <summary>Specifies a 7% discount rate.</summary>
        DR7 = 7
    }

    /// <summary>
    /// Specifies the health impacts associated with emission damage arising from various pollutants.
    /// </summary>
    [Serializable]
    public enum EmissionHealthImpact
    {
        /// <summary>
        /// Specifies an estimate of premature deaths associated with air pollution exposure.
        /// </summary>
        PrematureDeaths = 0,
        ///// <summary>
        ///// Specifies a low estimate of premature deaths associated with air pollution exposure.
        ///// </summary>
        //PrematureDeathsLow = 0,
        ///// <summary>
        ///// Specifies a high estimate of premature deaths associated with air pollution exposure.
        ///// </summary>
        //PrematureDeathsHigh,
        /// <summary>
        /// Specifies an estimate of respiratory emergency room visits resulting from air pollution exposure.
        /// </summary>
        RespiratoryEmergencyRoomVisits,
        /// <summary>
        /// Specifies an estimate of acute bronchitis incidents resulting from air pollution exposure.
        /// </summary>
        AcuteBronchitis,
        /// <summary>
        /// Specifies an estimate of lower respiratory symptoms resulting from air pollution exposure.
        /// </summary>
        LowerRespiratorySymptoms,
        /// <summary>
        /// Specifies an estimate of upper respiratory symptoms resulting from air pollution exposure.
        /// </summary>
        UpperRespiratorySymptoms,
        /// <summary>
        /// Specifies an estimate of minor restricted activity days resulting from air pollution exposure.
        /// </summary>
        MinorRestrictedActivityDays,
        /// <summary>
        /// Specifies an estimate of work loss days resulting from air pollution exposure.
        /// </summary>
        WorkLossDays,
        /// <summary>
        /// Specifies an estimate of asthma exacerbation resulting from air pollution exposure.
        /// </summary>
        AsthmaExacerbation,
        /// <summary>
        /// Specifies an estimate of cardiovascular hospital admissions resulting from air pollution exposure.
        /// </summary>
        CardiovascularHospitalAdmissions,
        /// <summary>
        /// Specifies an estimate of respiratory hospital admissions resulting from air pollution exposure.
        /// </summary>
        RespiratoryHospitalAdmissions,
        /// <summary>
        /// Specifies an estimate of non-fatal heart attacks resulting from air pollution exposure.
        /// </summary>
        NonFatalHeartAttacksPeters,
        /// <summary>
        /// Specifies an estimate of non-fatal heart attacks resulting from air pollution exposure.
        /// </summary>
        NonFatalHeartAttacksOthers
    }

    #endregion

    #region <<< Helper Classes >>>

    /// <summary>
    /// Defines array constants corresponding to the <see cref="FuelType"/>s supported by the various data objects used
    /// within the modeling system.
    /// </summary>
    [Serializable]
    public static class FuelTypes
    {
        internal const int GasolineIndex = 0;
        internal const int Ethanol85Index = 1;
        internal const int DieselIndex = 2;
        internal const int ElectricityIndex = 3;
        internal const int HydrogenIndex = 4;
        internal const int CngIndex = 5;

        /// <summary>Defines the <see cref="FuelType"/>s supported by the modeling system.</summary>
        public static readonly FuelType[] List = { FuelType.Gasoline,
                                                   FuelType.Ethanol85,
                                                   FuelType.Diesel,
                                                   FuelType.Electricity,
                                                   FuelType.Hydrogen,
                                                   FuelType.CNG };

        /// <summary>Defines the friendly names for each of the supported <see cref="FuelType"/>s.</summary>
        public static readonly string[] Names = { "Gasoline",
                                                  "Ethanol-85%",
                                                  "Diesel",
                                                  "Electricity",
                                                  "Hydrogen",
                                                  "Compressed Natural Gas" };

        /// <summary>
        /// Defines the acronyms (useful for reporting) for each of the supported <see cref="FuelType"/>s.
        /// </summary>
        public static readonly string[] Acronyms = { "G",
                                                     "E85",
                                                     "D",
                                                     "E",
                                                     "H",
                                                     "CNG" };

        /// <summary>
        /// Defines the list of <see cref="FuelType"/> filters (including aggregate fuels) that the modeling system
        /// will use when generating reports.
        /// </summary>
        /// <remarks>
        /// The <see cref="ReportingList"/> and <see cref="ReportingNames"/> arrays define the greatest level of
        /// disaggregation (and aggregation) that the various modeling reports will include. In some cases, not all
        /// fuel types defined in these arrays will be reported. For example, if the vehicle data does not include any
        /// CNG vehicles, the CNG fuel type will be omitted from reporting.
        /// </remarks>
        public static readonly FuelType[] ReportingList = { FuelType.Gasoline,
                                                            FuelType.Ethanol85,
                                                            FuelType.Diesel,
                                                            FuelType.Electricity,
                                                            FuelType.Hydrogen,
                                                            FuelType.CNG,
                                                            FuelType.All };

        /// <summary>
        /// Defines the friendly names for each of the <see cref="FuelType"/> filters (including aggregate fuels) that
        /// the modeling system will use when generating reports.
        /// </summary>
        /// <remarks>
        /// The <see cref="ReportingList"/> and <see cref="ReportingNames"/> arrays define the greatest level of
        /// disaggregation (and aggregation) that the various modeling reports will include. In some cases, not all
        /// fuel types defined in these arrays will be reported. For example, if the vehicle data does not include any
        /// CNG vehicles, the CNG fuel type will be omitted from reporting.
        /// </remarks>
        public static readonly string[] ReportingNames = { "Gasoline",
                                                           "E85",
                                                           "Diesel",
                                                           "Electricity",
                                                           "Hydrogen",
                                                           "CNG",
                                                           "TOTAL" };
    }

    /// <summary>
    /// Defines array constants corresponding to the <see cref="RegulatoryClass"/>es supported by the various data
    /// objects used within the modeling system.
    /// </summary>
    [Serializable]
    public static class RegClasses
    {
        // "list" indexes
        internal const int DomesticCarIndex = 0;
        internal const int ImportedCarIndex = 1;
        internal const int LightTruckIndex = 2;
        internal const int HdpuvIndex = 3;

        // "alt-list" indexes
        internal const int AltPassengerCarIndex = 0;
        internal const int AltLightTruckIndex = 1;
        internal const int AltHdpuvIndex = 2;

        /// <summary>Defines the <see cref="RegulatoryClass"/>es supported by the modeling system.</summary>
        public static readonly RegulatoryClass[] List = { RegulatoryClass.DomesticCar,
                                                          RegulatoryClass.ImportedCar,
                                                          RegulatoryClass.LightTruck,
                                                          RegulatoryClass.HDPUV };

        /// <summary>Defines the friendly names for each of the supported <see cref="RegulatoryClass"/>es.</summary>
        public static readonly string[] Names = { "Domestic Car",
                                                  "Imported Car",
                                                  "Light Truck",
                                                  "HDPUV" };

        /// <summary>
        /// Defines the acronyms (useful for reporting) for each of the supported <see cref="RegulatoryClass"/>es.
        /// </summary>
        public static readonly string[] Acronyms = { "DC",
                                                     "IC",
                                                     "LT",
                                                     "HDPUV" };

        /// <summary>
        /// Defines an alternative list of the <see cref="RegulatoryClass"/>es supported by the modeling system, where
        /// the domestic and imported cars are represented by a single passenger car regulatory class.
        /// </summary>
        public static readonly RegulatoryClass[] AltList = { RegulatoryClass.AllPassengerCar,
                                                             RegulatoryClass.LightTruck,
                                                             RegulatoryClass.HDPUV };

        /// <summary>
        /// Defines an alternative list of the friendly names for each of the supported
        /// <see cref="RegulatoryClass"/>es.
        /// </summary>
        public static readonly string[] AltNames = { "Passenger Car",
                                                     "Light Truck",
                                                     "HDPUV" };

        /// <summary>
        /// Defines an alternative list of the acronyms (useful for reporting) for each of the supported
        /// <see cref="RegulatoryClass"/>es.
        /// </summary>
        public static readonly string[] AltAcronyms = { "PC",
                                                        "LT",
                                                        "HDPUV" };

        /// <summary>
        /// Defines the list of <see cref="RegulatoryClass"/> filters (including aggregate classes) that the modeling
        /// system will use when generating reports.
        /// </summary>
        /// <remarks>
        /// The <see cref="ReportingList"/> and <see cref="ReportingNames"/> arrays define the greatest level of
        /// disaggregation (and aggregation) that the various modeling reports will include. In some cases, not all
        /// regulatory classes defined in these arrays will be reported. For example, if the vehicle data does not
        /// include any HDPUV vehicles, the HDPUV regulatory class will be omitted from reporting.
        /// </remarks>
        public static readonly RegulatoryClass[] ReportingList = { RegulatoryClass.DomesticCar,
                                                                   RegulatoryClass.ImportedCar,
                                                                   RegulatoryClass.AllPassengerCar,
                                                                   RegulatoryClass.LightTruck,
                                                                   RegulatoryClass.AllLightDuty,
                                                                   RegulatoryClass.HDPUV,
                                                                   RegulatoryClass.All };

        /// <summary>
        /// Defines the friendly names for each of the <see cref="RegulatoryClass"/> filters (including aggregate
        /// classes) that the modeling system will use when generating reports.
        /// </summary>
        /// <remarks>
        /// The <see cref="ReportingList"/> and <see cref="ReportingNames"/> arrays define the greatest level of
        /// disaggregation (and aggregation) that the various modeling reports will include. In some cases, not all
        /// regulatory classes defined in these arrays will be reported. For example, if the vehicle data does not
        /// include any HDPUV vehicles, the HDPUV regulatory class will be omitted from reporting.
        /// </remarks>
        public static readonly string[] ReportingNames = { "Domestic Car",
                                                           "Imported Car",
                                                           "Passenger Car",
                                                           "Light Truck",
                                                           "LD Total",
                                                           "HDPUV",
                                                           "TOTAL" };
    }

    /// <summary>
    /// Defines array constants corresponding to the <see cref="SafetyClass"/>es supported by the various data objects
    /// used within the modeling system.
    /// </summary>
    [Serializable]
    public static class SafetyClasses
    {
        internal const int PcIndex = 0;
        internal const int LtIndex = 1;
        internal const int CmIndex = 2;

        /// <summary>Defines the <see cref="SafetyClass"/>es supported by the modeling system.</summary>
        public static readonly SafetyClass[] List = { SafetyClass.PC,
                                                      SafetyClass.LT,
                                                      SafetyClass.CM };

        /// <summary>Defines the friendly names for each of the supported <see cref="SafetyClass"/>es.</summary>
        public static readonly string[] Names = { "PC",
                                                  "LT",
                                                  "CM" };
    }

    /// <summary>
    /// Defines array constants corresponding to the <see cref="VehicleClass"/>es supported by the various data objects
    /// used within the modeling system.
    /// </summary>
    [Serializable]
    public static class VehicleClasses
    {
        internal const int LdvIndex = 0;
        internal const int Ldt12aIndex = 1;
        internal const int Ldt2b3Index = 2;

        /// <summary>Defines the <see cref="VehicleClass"/>es supported by the modeling system.</summary>
        public static readonly VehicleClass[] List = { VehicleClass.LDV,
                                                       VehicleClass.LDT1,
                                                       VehicleClass.LDT2a,
                                                       VehicleClass.LDT2b,
                                                       VehicleClass.LDT3 };

        /// <summary>Defines the friendly names for each of the supported <see cref="VehicleClass"/>es.</summary>
        public static readonly string[] Names = { "LDV",
                                                  "LDT1",
                                                  "LDT2a",
                                                  "LDT2b",
                                                  "LDT3" };

        /// <summary>
        /// Defines an alternative list of the <see cref="VehicleClass"/>es supported by the modeling system, where
        /// the LDT1 and LDT2a classes are represented by a LDT12a class, while LDT2b and LDT3 classes are represented
        /// by a LDT2b3 class.
        /// </summary>
        public static readonly VehicleClass[] AltList = { VehicleClass.LDV,
                                                          VehicleClass.LDT12a,
                                                          VehicleClass.LDT2b3 };

        /// <summary>
        /// Defines an alternative list of the friendly names for each of the supported <see cref="VehicleClass"/>es.
        /// </summary>
        public static readonly string[] AltNames = { "LDV",
                                                     "LDT12a",
                                                     "LDT2b3" };
    }

    /// <summary>
    /// Defines array constants corresponding to the <see cref="VehicleStyle"/>s supported by the various data objects
    /// used within the modeling system.
    /// </summary>
    [Serializable]
    public static class VehicleStyles
    {
        internal const int GenericCarIndex = 0;
        internal const int GenericVanSuvIndex = 1;
        internal const int GenericPickupIndex = 2;
        internal const int Generic2b3Index = 3;

        /// <summary>Defines the <see cref="VehicleStyle"/>s supported by the modeling system.</summary>
        public static readonly VehicleStyle[] List = { // light duty cars
                                                       VehicleStyle.Convertible,
                                                       VehicleStyle.Coupe,
                                                       VehicleStyle.Hatchback,
                                                       VehicleStyle.Sedan,
                                                       VehicleStyle.Wagon,
                                                       // light duty SUVs, vans, trucks
                                                       VehicleStyle.SportUtility,
                                                       VehicleStyle.Minivan,
                                                       VehicleStyle.Van,
                                                       VehicleStyle.PassengerVan,
                                                       VehicleStyle.CargoVan,
                                                       VehicleStyle.Pickup,
                                                       // class 2b/3 vehicles
                                                       VehicleStyle.FleetSuv,
                                                       VehicleStyle.WorkVan,
                                                       VehicleStyle.WorkTruck,
                                                       VehicleStyle.ChassisCab,
                                                       VehicleStyle.Cutaway };

        /// <summary>Defines the friendly names for each of the supported <see cref="VehicleStyle"/>s.</summary>
        public static readonly string[] Names = { // light duty cars
                                                  "Convertible",
                                                  "Coupe",
                                                  "Hatchback",
                                                  "Sedan",
                                                  "Wagon",
                                                  // light duty SUVs, vans, trucks
                                                  "Sport Utility",
                                                  "Minivan",
                                                  "Van",
                                                  "Passenger Van",
                                                  "Cargo Van",
                                                  "Pickup",
                                                  // class 2b/3 vehicles
                                                  "Fleet SUV",
                                                  "Work Van",
                                                  "Work Truck",
                                                  "Chassis Cab",
                                                  "Cutaway" };

        /// <summary>
        /// Defines an alternative list of the <see cref="VehicleStyle"/>s supported by the modeling system, where
        /// only the generic vehicle styles (e.g., "GenericCar") are used to represent multiple other styles.
        /// </summary>
        public static readonly VehicleStyle[] AltList = { VehicleStyle.GenericCar,
                                                          VehicleStyle.GenericVanSUV,
                                                          VehicleStyle.GenericPickup,
                                                          VehicleStyle.Generic2b3 };

        /// <summary>
        /// Defines an alternative list of the friendly names for each of the supported <see cref="VehicleStyle"/>s.
        /// </summary>
        public static readonly string[] AltNames = { "Cars",
                                                     "Vans/SUVs",
                                                     "Pickups",
                                                     "2b/3 Vehicles" };

    }

    /// <summary>
    /// Defines array constants corresponding to the <see cref="TechnologyClass"/>es and
    /// <see cref="EngineTechnologyClass"/> supported by the various data objects used within the modeling system.
    /// </summary>
    [Serializable]
    public static class TechnologyClasses
    {
        /// <summary>Defines the <see cref="TechnologyClass"/>es supported by the modeling system.</summary>
        public static readonly TechnologyClass[] List = {
                                        // light duty tech classes
                                        TechnologyClass.SmallCar,
                                        TechnologyClass.SmallCarPerf,
                                        TechnologyClass.MedCar,
                                        TechnologyClass.MedCarPerf,
                                        TechnologyClass.SmallSUV,
                                        TechnologyClass.SmallSUVPerf,
                                        TechnologyClass.MedSUV,
                                        TechnologyClass.MedSUVPerf,
                                        TechnologyClass.Pickup,
                                        TechnologyClass.PickupHT,
                                        // 2b/3 tech classes
                                        TechnologyClass.Pickup2b,
                                        TechnologyClass.Van2b,
                                        TechnologyClass.Pickup3,
                                        TechnologyClass.Van3 };

        /// <summary>Defines the friendly names for each of the supported <see cref="TechnologyClass"/>es.</summary>
        public static readonly string[] Names = {
                                        // light duty tech classes
                                        "SmallCar",
                                        "SmallCarPerf",
                                        "MedCar",
                                        "MedCarPerf",
                                        "SmallSUV",
                                        "SmallSUVPerf",
                                        "MedSUV",
                                        "MedSUVPerf",
                                        "Pickup",
                                        "PickupHT",
                                        // 2b/3 tech classes
                                        "Pickup2b",
                                        "Van2b",
                                        "Pickup3",
                                        "Van3" };

        /// <summary>Defines the <see cref="EngineTechnologyClass"/>es supported by the modeling system.</summary>
        public static readonly EngineTechnologyClass[] EngineList = {
                                        //--- light-duty engine classes ---
                                        // DOHC engine classes
                                        EngineTechnologyClass.DOHC_2C1B,
                                        EngineTechnologyClass.DOHC_3C1B,
                                        EngineTechnologyClass.DOHC_4C1B,
                                        EngineTechnologyClass.DOHC_4C1B_L,
                                        EngineTechnologyClass.DOHC_4C2B,
                                        EngineTechnologyClass.DOHC_4C2B_L,
                                        EngineTechnologyClass.DOHC_5C1B,
                                        EngineTechnologyClass.DOHC_6C1B,
                                        EngineTechnologyClass.DOHC_6C2B,
                                        EngineTechnologyClass.DOHC_8C2B,
                                        EngineTechnologyClass.DOHC_10C2B,
                                        EngineTechnologyClass.DOHC_12C2B,
                                        EngineTechnologyClass.DOHC_12C4B,
                                        EngineTechnologyClass.DOHC_16C4B,
                                        // SOHC engine classes
                                        EngineTechnologyClass.SOHC_2C1B,
                                        EngineTechnologyClass.SOHC_3C1B,
                                        EngineTechnologyClass.SOHC_4C1B,
                                        EngineTechnologyClass.SOHC_4C1B_L,
                                        EngineTechnologyClass.SOHC_4C2B,
                                        EngineTechnologyClass.SOHC_5C1B,
                                        EngineTechnologyClass.SOHC_6C1B,
                                        EngineTechnologyClass.SOHC_6C2B,
                                        EngineTechnologyClass.SOHC_8C2B,
                                        EngineTechnologyClass.SOHC_10C2B,
                                        EngineTechnologyClass.SOHC_12C2B,
                                        EngineTechnologyClass.SOHC_12C4B,
                                        EngineTechnologyClass.SOHC_16C4B,
                                        // OHV engine classes
                                        EngineTechnologyClass.OHV_6C1B,
                                        EngineTechnologyClass.OHV_6C2B,
                                        EngineTechnologyClass.OHV_8C2B,
                                        EngineTechnologyClass.OHV_10C2B,

                                        //--- 2b/3 engine classes ---
                                        // DOHC engine classes
                                        EngineTechnologyClass.DOHC_4C1B_2b3,
                                        EngineTechnologyClass.DOHC_4C2B_2b3,
                                        EngineTechnologyClass.DOHC_5C1B_2b3,
                                        EngineTechnologyClass.DOHC_6C1B_2b3,
                                        EngineTechnologyClass.DOHC_6C2B_2b3,
                                        EngineTechnologyClass.DOHC_8C2B_2b3,
                                        EngineTechnologyClass.DOHC_10C2B_2b3,
                                        // SOHC engine classes
                                        EngineTechnologyClass.SOHC_4C1B_2b3,
                                        EngineTechnologyClass.SOHC_4C2B_2b3,
                                        EngineTechnologyClass.SOHC_5C1B_2b3,
                                        EngineTechnologyClass.SOHC_6C1B_2b3,
                                        EngineTechnologyClass.SOHC_6C2B_2b3,
                                        EngineTechnologyClass.SOHC_8C2B_2b3,
                                        EngineTechnologyClass.SOHC_10C2B_2b3,
                                        // OHV engine classes
                                        EngineTechnologyClass.OHV_4C1B_2b3,
                                        EngineTechnologyClass.OHV_4C2B_2b3,
                                        EngineTechnologyClass.OHV_5C1B_2b3,
                                        EngineTechnologyClass.OHV_6C1B_2b3,
                                        EngineTechnologyClass.OHV_6C2B_2b3,
                                        EngineTechnologyClass.OHV_8C2B_2b3,
                                        EngineTechnologyClass.OHV_10C2B_2b3 };

        /// <summary>
        /// Defines the friendly names for each of the supported <see cref="EngineTechnologyClass"/>es.
        /// </summary>
        public static readonly string[] EngineNames = {
                                        //--- light-duty engine classes ---
                                        // DOHC engine classes
                                        "2C1B", "3C1B", "4C1B", "4C1B_L", "4C2B", "4C2B_L",
                                        "5C1B", "6C1B", "6C2B", "8C2B",
                                        "10C2B", "12C2B", "12C4B", "16C4B",
                                        // SOHC engine classes
                                        "2C1B_SOHC", "3C1B_SOHC", "4C1B_SOHC", "4C1B_L_SOHC", "4C2B_SOHC",
                                        "5C1B_SOHC", "6C1B_SOHC", "6C2B_SOHC", "8C2B_SOHC",
                                        "10C2B_SOHC", "12C2B_SOHC", "12C4B_SOHC", "16C4B_SOHC",
                                        // OHV engine classes
                                        "6C1B_OHV", "6C2B_OHV", "8C2B_OHV", "10C2B_OHV",

                                        //--- 2b/3 engine classes ---
                                        // DOHC engine classes
                                        "4C1B_2b3", "4C2B_2b3", "5C1B_2b3",
                                        "6C1B_2b3", "6C2B_2b3", "8C2B_2b3", "10C2B_2b3",
                                        // SOHC engine classes
                                        "4C1B_SOHC_2b3", "4C2B_SOHC_2b3", "5C1B_SOHC_2b3",
                                        "6C1B_SOHC_2b3", "6C2B_SOHC_2b3", "8C2B_SOHC_2b3", "10C2B_SOHC_2b3",
                                        // OHV engine classes
                                        "4C1B_OHV_2b3", "4C2B_OHV_2b3", "5C1B_OHV_2b3",
                                        "6C1B_OHV_2b3", "6C2B_OHV_2b3", "8C2B_OHV_2b3", "10C2B_OHV_2b3" };
    }

    /// <summary>
    /// Defines array constants corresponding to the <see cref="Estimates"/> supported for calculating emissions
    /// attributed to the various greenhouse gas (GHG) emissions.
    /// </summary>
    [Serializable]
    public static class GhgEstimates
    {
        /// <summary>Defines the GHG <see cref="Estimates"/> supported by the modeling system.</summary>
        public static readonly Estimates[] List = { Estimates.Low,
                                                    Estimates.Average,
                                                    Estimates.High,
                                                    Estimates.VeryHigh };
    }

    /// <summary>
    /// Defines array constants corresponding to the <see cref="Pollutant"/>s supported by the various data objects
    /// used within the modeling system.
    /// </summary>
    [Serializable]
    public static class Pollutants
    {
        /// <summary>Defines the <see cref="Pollutant"/>s supported by the modeling system.</summary>
        public static readonly Pollutant[] List = { // emissions for effects modeling
                                                    Pollutant.CO,
                                                    Pollutant.VOC,
                                                    Pollutant.NOx,
                                                    Pollutant.SO2,
                                                    Pollutant.PM,
                                                    Pollutant.CO2,
                                                    Pollutant.CH4,
                                                    Pollutant.N2O,
                                                    // additional emissions for EIS modeling
                                                    Pollutant.Acetaldehyde,
                                                    Pollutant.Acrolein,
                                                    Pollutant.Benzene,
                                                    Pollutant.Butadiene,
                                                    Pollutant.Formaldehyde,
                                                    Pollutant.DPM10 };

        /// <summary>Defines the friendly names for each of the supported <see cref="Pollutant"/>s.</summary>
        public static readonly string[] Names = { // emissions for effects modeling
                                                  "CO",
                                                  "VOC",
                                                  "NOx",
                                                  "SO2",
                                                  "PM",
                                                  "CO2",
                                                  "CH4",
                                                  "N2O",
                                                  // additional emissions for EIS modeling
                                                  "Acetaldehyde",
                                                  "Acrolein",
                                                  "Benzene",
                                                  "Butadiene",
                                                  "Formaldehyde",
                                                  "DPM10" };

        /// <summary>
        /// Defines the <see cref="Pollutant"/>s supported by the modeling system, for which the system monetizes
        /// emission damage. The monetized list of pollutants consists of the first eight elements from
        /// <see cref="List"/>.
        /// </summary>
        public static readonly Pollutant[] MonetizedList = List.Take(8).ToArray();

        /// <summary>Defines the friendly names for each of the supported <see cref="Pollutant"/>s, for which the
        /// system monetizes emission damage. The monetized names of pollutants consists of the first eight elements
        /// from <see cref="Names"/>.
        /// </summary>
        public static readonly string[] MonetizedNames = Names.Take(8).ToArray();
    }

    /// <summary>
    /// Defines array constants corresponding to the <see cref="EmissionHealthImpact"/>s supported by the various data
    /// objects used within the modeling system.
    /// </summary>
    [Serializable]
    public static class HealthImpacts
    {
        /// <summary>
        /// Defines the <see cref="EmissionHealthImpact"/>s supported by the modeling system.
        /// </summary>
        public static readonly EmissionHealthImpact[] List = {
                                        EmissionHealthImpact.PrematureDeaths,
                                        //EmissionHealthImpact.PrematureDeathsLow,
                                        //EmissionHealthImpact.PrematureDeathsHigh,
                                        EmissionHealthImpact.RespiratoryEmergencyRoomVisits,
                                        EmissionHealthImpact.AcuteBronchitis,
                                        EmissionHealthImpact.LowerRespiratorySymptoms,
                                        EmissionHealthImpact.UpperRespiratorySymptoms,
                                        EmissionHealthImpact.MinorRestrictedActivityDays,
                                        EmissionHealthImpact.WorkLossDays,
                                        EmissionHealthImpact.AsthmaExacerbation,
                                        EmissionHealthImpact.CardiovascularHospitalAdmissions,
                                        EmissionHealthImpact.RespiratoryHospitalAdmissions,
                                        EmissionHealthImpact.NonFatalHeartAttacksPeters,
                                        EmissionHealthImpact.NonFatalHeartAttacksOthers };

        /// <summary>
        /// Defines the friendly names for each of the supported <see cref="EmissionHealthImpact"/>s.
        /// </summary>
        public static readonly string[] Names = {
                                        "Premature Deaths",
                                        //"Premature Deaths Low",
                                        //"Premature Deaths High",
                                        "Respiratory Emergency Room Visits",
                                        "Acute Bronchitis",
                                        "Lower Respiratory Symptoms",
                                        "Upper Respiratory Symptoms",
                                        "Minor Restricted Activity Days",
                                        "Work Loss Days",
                                        "Asthma Exacerbation",
                                        "Cardiovascular Hospital Admissions",
                                        "Respiratory Hospital Admissions",
                                        "Non-Fatal Heart Attacks (Peters)",
                                        "Non-Fatal Heart Attacks (All Others)" };
    }

    /// <summary>
    /// Provides extension methods for various enumerations.
    /// </summary>
    [Serializable]
    public static class EnumExtensions
    {
        #region < Enum FuelType >

        /// <summary>
        /// Returns an integer index that represents the location of the specified <see cref="FuelType"/> within the
        /// <see cref="FuelTypes.List"/>, <see cref="FuelTypes.Names"/>, and <see cref="FuelTypes.Acronyms"/> arrays.
        /// </summary>
        public static int GetListIndex(this FuelType fuelType)
        {
            switch (fuelType) {
                case FuelType.Gasoline: return FuelTypes.GasolineIndex;
                case FuelType.Ethanol85: return FuelTypes.Ethanol85Index;
                case FuelType.Diesel: return FuelTypes.DieselIndex;
                case FuelType.Electricity: return FuelTypes.ElectricityIndex;
                case FuelType.Hydrogen: return FuelTypes.HydrogenIndex;
                case FuelType.CNG: return FuelTypes.CngIndex;

                // unknown
                default:
                    return -1;
            }
        }

        /// <summary>
        /// Determines whether the specified <see cref="FuelType"/> instance contains the specified
        /// <see cref="FuelType"/> value.
        /// </summary>
        /// <param name="src">The containing <see cref="FuelType"/> value to test against.</param>
        /// <param name="value">The value to test.</param>
        /// <returns>
        /// true, if the specified value is fully contained within this <see cref="FuelType"/>;
        /// false, otherwise.
        /// </returns>
        public static bool Contains(this FuelType src, FuelType value)
        {
            return (src & value) == value;
        }

        /// <summary>
        /// Determines whether the specified <see cref="FuelType"/> instance represents a non-liquid fuel type,
        /// denominated using gasoline-equivalent gallons (GEG). Presently, the following fuel types are GEG:
        /// <see cref="FuelType.Electricity"/>, <see cref="FuelType.Hydrogen"/>, and <see cref="FuelType.CNG"/>.
        /// </summary>
        /// <param name="src">The <see cref="FuelType"/> value to test.</param>
        /// <returns>
        /// true, if the specified value represents a non-liquid fuel type, denominated using gasoline-equivalent
        /// gallons; false, if the specified value represents a liquid fuel.
        /// </returns>
        public static bool IsGEGFuel(this FuelType src)
        {
            return (src == FuelType.Electricity
                 || src == FuelType.Hydrogen
                 || src == FuelType.CNG);
        }

        /// <summary>
        /// Converts this <see cref="FuelType"/> value to a string equivalent, using associated fuel type acronyms.
        /// </summary>
        /// <param name="src">The <see cref="FuelType"/> value to convert.</param>
        /// <param name="engineFuelOnly">
        ///     true, to only consider engine fuel types and ignore others; false, to consider all fuel types.
        /// </param>
        /// <returns>A string equivalent of the <see cref="FuelType"/> value.</returns>
        public static string ToAcronymString(this FuelType src, bool engineFuelOnly = false)
        {
            if (src == FuelType.None) {
                return "None";
            }

            var sb = new StringBuilder(8);
            for (int i = 0; i < FuelTypes.List.Length; i++) {
                FuelType fuel = FuelTypes.List[i];
                if (engineFuelOnly && (fuel == FuelType.Hydrogen || fuel == FuelType.Electricity)) {
                    continue;
                }
                if ((src & fuel) == fuel) {
                    sb.Append(FuelTypes.Acronyms[i]);
                    sb.Append("+");
                }
            }
            return sb.ToString(0, sb.Length - 1);
        }

        #endregion

        #region < Enum HEVType >

        /// <summary>
        /// Converts the specified <see cref="HEVType"/> value to its equivalent string representation, optionally
        /// using the abbreviations for non-conventional powertrains.
        /// </summary>
        /// <param name="src">The <see cref="HEVType"/> value to convert.</param>
        /// <param name="getAbbr">
        ///     true, to return abbreviations for non-conventional powertrains; false, to return full names.
        /// </param>
        /// <returns>A string equivalent of the <see cref="HEVType"/> value.</returns>
        public static string ToString(this HEVType src, bool getAbbr = false)
        {
            if (!getAbbr) {
                return src.ToString();
            }

            switch (src) {
                case HEVType.Conventional   : return "Conventional";
                case HEVType.MildHybrid     : return "MHEV";
                case HEVType.StrongHybrid   : return "SHEV";
                case HEVType.PlugInHybrid   : return "PHEV";
                case HEVType.ExtendedRangeEV: return "EREV";
                case HEVType.BatteryElectric: return "BEV";
                case HEVType.FuelCell       : return "FCV";

                default:
                    return "Undefined";
            }
        }

        /// <summary>
        /// Determines whether the specified <see cref="HEVType"/> instance is <see cref="HEVType.Conventional"/>.
        /// </summary>
        public static bool IsConventional(this HEVType src)
        {
            return (src == HEVType.Conventional);
        }

        /// <summary>
        /// Determines whether the specified <see cref="HEVType"/> instance is
        ///     <see cref="HEVType.StrongHybrid"/>,
        ///     <see cref="HEVType.PlugInHybrid"/>,
        ///     <see cref="HEVType.ExtendedRangeEV"/>,
        ///     <see cref="HEVType.BatteryElectric"/>, or
        ///     <see cref="HEVType.FuelCell"/>.
        /// </summary>
        public static bool IsShevAndLater(this HEVType src)
        {
            // note: do not call IsZev() from here, as ZEV definitions may change
            return (src == HEVType.StrongHybrid
                 || src.IsPhevOrErev()
                 || src.IsBevOrFcv());
        }

        /// <summary>
        /// Determines whether the specified <see cref="HEVType"/> instance represents a zero-emissions vehicle.
        /// That is, whether the specified <see cref="HEVType"/> instance is
        ///     <see cref="HEVType.PlugInHybrid"/>,
        ///     <see cref="HEVType.ExtendedRangeEV"/>,
        ///     <see cref="HEVType.BatteryElectric"/>, or
        ///     <see cref="HEVType.FuelCell"/>.
        /// </summary>
        public static bool IsZev(this HEVType src)
        {
            return (src.IsPhevOrErev() || src.IsBevOrFcv());
        }

        /// <summary>
        /// Determines whether the specified <see cref="HEVType"/> instance is
        ///     <see cref="HEVType.PlugInHybrid"/> or
        ///     <see cref="HEVType.ExtendedRangeEV"/>.
        /// </summary>
        public static bool IsPhevOrErev(this HEVType src)
        {
            return (src == HEVType.PlugInHybrid || src == HEVType.ExtendedRangeEV);
        }

        /// <summary>
        /// Determines whether the specified <see cref="HEVType"/> instance is
        ///     <see cref="HEVType.BatteryElectric"/> or
        ///     <see cref="HEVType.FuelCell"/>.
        /// </summary>
        public static bool IsBevOrFcv(this HEVType src)
        {
            return (src == HEVType.BatteryElectric || src == HEVType.FuelCell);
        }

        #endregion

        #region < Enum RegulatoryClass >

        /// <summary>
        /// Returns an integer index that represents the location of the specified <see cref="RegulatoryClass"/> within
        /// the <see cref="RegClasses.List"/>, <see cref="RegClasses.Names"/>, and <see cref="RegClasses.Acronyms"/>
        /// arrays.
        /// </summary>
        public static int GetListIndex(this RegulatoryClass src)
        {
            switch (src) {
                case RegulatoryClass.DomesticCar: return RegClasses.DomesticCarIndex;
                case RegulatoryClass.ImportedCar: return RegClasses.ImportedCarIndex;
                case RegulatoryClass.LightTruck: return RegClasses.LightTruckIndex;
                case RegulatoryClass.HDPUV: return RegClasses.HdpuvIndex;

                // unknown
                default:
                    return -1;
            }
        }

        /// <summary>
        /// Returns an integer index that represents the location of the specified <see cref="RegulatoryClass"/> within
        /// the <see cref="RegClasses.AltList"/>, <see cref="RegClasses.AltNames"/>, and
        /// <see cref="RegClasses.AltAcronyms"/> arrays.
        /// </summary>
        public static int GetAltListIndex(this RegulatoryClass src)
        {
            switch (src) {
                // Passenger Cars
                case RegulatoryClass.DomesticCar:
                case RegulatoryClass.ImportedCar:
                case RegulatoryClass.AllPassengerCar:
                    return RegClasses.AltPassengerCarIndex;

                case RegulatoryClass.LightTruck:
                    return RegClasses.AltLightTruckIndex;

                case RegulatoryClass.HDPUV:
                    return RegClasses.AltHdpuvIndex;

                // unknown
                default:
                    return -1;
            }
        }

        /// <summary>
        /// Determines whether the specified <see cref="RegulatoryClass"/> instance contains the specified
        /// <see cref="RegulatoryClass"/> value.
        /// </summary>
        /// <param name="src">The containing <see cref="RegulatoryClass"/> value to test against.</param>
        /// <param name="value">The value to test.</param>
        /// <returns>
        /// true, if the specified value is fully contained within this <see cref="RegulatoryClass"/>;
        /// false, otherwise.
        /// </returns>
        public static bool Contains(this RegulatoryClass src, RegulatoryClass value)
        {
            if (src == value)
                return true;

            switch (src)
            {
                case RegulatoryClass.All            : return value != RegulatoryClass.None;
                case RegulatoryClass.AllLightDuty   : return value.IsLD();
                case RegulatoryClass.AllPassengerCar: return value.IsPC();
            }

            return false;
        }

        /// <summary>
        /// Determines whether the specified <see cref="RegulatoryClass"/> instance is
        ///     <see cref="RegulatoryClass.DomesticCar"/>,
        ///     <see cref="RegulatoryClass.ImportedCar"/>,
        ///     <see cref="RegulatoryClass.AllPassengerCar"/>, or
        ///     <see cref="RegulatoryClass.LightTruck"/>.
        /// </summary>
        public static bool IsLD(this RegulatoryClass src)
        {
            return src.IsPC() || src.IsLT();
        }

        /// <summary>
        /// Determines whether the specified <see cref="RegulatoryClass"/> instance is
        ///     <see cref="RegulatoryClass.DomesticCar"/>,
        ///     <see cref="RegulatoryClass.ImportedCar"/>, or
        ///     <see cref="RegulatoryClass.AllPassengerCar"/>.
        /// </summary>
        public static bool IsPC(this RegulatoryClass src)
        {
            return (src == RegulatoryClass.AllPassengerCar
                 || src == RegulatoryClass.DomesticCar
                 || src == RegulatoryClass.ImportedCar);
        }
        /// <summary>
        /// Determines whether the specified <see cref="RegulatoryClass"/> instance is
        /// <see cref="RegulatoryClass.DomesticCar"/>.
        /// </summary>
        public static bool IsDC(this RegulatoryClass src) => (src == RegulatoryClass.DomesticCar);
        /// <summary>
        /// Determines whether the specified <see cref="RegulatoryClass"/> instance is
        /// <see cref="RegulatoryClass.ImportedCar"/>.
        /// </summary>
        public static bool IsIC(this RegulatoryClass src) => (src == RegulatoryClass.ImportedCar);

        /// <summary>
        /// Determines whether the specified <see cref="RegulatoryClass"/> instance is
        /// <see cref="RegulatoryClass.LightTruck"/>.
        /// </summary>
        public static bool IsLT(this RegulatoryClass src) => (src == RegulatoryClass.LightTruck);

        /// <summary>
        /// Determines whether the specified <see cref="RegulatoryClass"/> instance is
        /// <see cref="RegulatoryClass.HDPUV"/>.
        /// </summary>
        public static bool IsHDPUV(this RegulatoryClass src) => (src == RegulatoryClass.HDPUV);

        #endregion

        #region < Enum SafetyClass >

        /// <summary>
        /// Returns an integer index that represents the location of the specified <see cref="SafetyClass"/> within
        /// the <see cref="SafetyClasses.List"/> and <see cref="SafetyClasses.Names"/> arrays.
        /// </summary>
        public static int GetListIndex(this SafetyClass src)
        {
            switch (src) {
                case SafetyClass.PC: return SafetyClasses.PcIndex;
                case SafetyClass.LT: return SafetyClasses.LtIndex;
                case SafetyClass.CM: return SafetyClasses.CmIndex;

                // unknown
                default:
                    return -1;
            }
        }

        #endregion

        #region < Enum VehicleClass >

        /// <summary>
        /// Returns an integer index that represents the location of the specified <see cref="VehicleStyle"/>
        /// within the <see cref="RegClasses.AltList"/>, and <see cref="RegClasses.AltNames"/> arrays.
        /// </summary>
        public static int GetAltListIndex(this VehicleClass src)
        {
            switch (src) {
                case VehicleClass.LDV: return VehicleClasses.LdvIndex;

                case VehicleClass.LDT1:
                case VehicleClass.LDT2a:
                case VehicleClass.LDT12a: return VehicleClasses.Ldt12aIndex;

                case VehicleClass.LDT2b:
                case VehicleClass.LDT3:
                case VehicleClass.LDT2b3: return VehicleClasses.Ldt2b3Index;

                default:
                    return -1;
            }
        }

        /// <summary>
        /// Determines whether the specified <see cref="VehicleClass"/> instance contains the specified
        /// <see cref="VehicleClass"/> value.
        /// </summary>
        /// <param name="src">The containing <see cref="VehicleClass"/> value to test against.</param>
        /// <param name="value">The value to test.</param>
        /// <returns>
        /// true, if the specified value is fully contained within this <see cref="VehicleClass"/>;
        /// false, otherwise.
        /// </returns>
        public static bool Contains(this VehicleClass src, VehicleClass value)
        {
            if (src == value)
                return true;

            switch (src)
            {
                case VehicleClass.All   : return value != VehicleClass.None;
                case VehicleClass.LDT2b3: return value.IsLDT2b3();
                case VehicleClass.LDT12a: return value.IsLDT12a();
            }

            return false;
        }

        /// <summary>
        /// Determines whether the specified <see cref="VehicleClass"/> instance is <see cref="VehicleClass.LDV"/>.
        /// </summary>
        public static bool IsLDV(this VehicleClass src)
        {
            return (src == VehicleClass.LDV);
        }
        /// <summary>
        /// Determines whether the specified <see cref="VehicleClass"/> instance is <see cref="VehicleClass.LDT1"/>,
        /// <see cref="VehicleClass.LDT2a"/>, or <see cref="VehicleClass.LDT12a"/>.
        /// </summary>
        public static bool IsLDT12a(this VehicleClass src)
        {
            return (src == VehicleClass.LDT1
                 || src == VehicleClass.LDT2a
                 || src == VehicleClass.LDT12a);
        }
        /// <summary>
        /// Determines whether the specified <see cref="VehicleClass"/> instance is <see cref="VehicleClass.LDT2b"/>,
        /// <see cref="VehicleClass.LDT3"/>, or <see cref="VehicleClass.LDT2b3"/>.
        /// </summary>
        public static bool IsLDT2b3(this VehicleClass src)
        {
            return (src == VehicleClass.LDT2b
                 || src == VehicleClass.LDT3
                 || src == VehicleClass.LDT2b3);
        }

        #endregion

        #region < Enum VehicleStyle >

        /// <summary>
        /// Returns an integer index that represents the location of the specified <see cref="VehicleStyle"/>
        /// within the <see cref="VehicleStyles.AltList"/> and <see cref="VehicleStyles.AltNames"/> arrays.
        /// </summary>
        public static int GetAltListIndex(this VehicleStyle src)
        {
            switch (src) {
                // cars
                case VehicleStyle.Convertible:
                case VehicleStyle.Coupe:
                case VehicleStyle.Hatchback:
                case VehicleStyle.Sedan:
                case VehicleStyle.Wagon:
                case VehicleStyle.GenericCar: return VehicleStyles.GenericCarIndex;

                // vans/suvs
                case VehicleStyle.SportUtility:
                case VehicleStyle.Minivan:
                case VehicleStyle.Van:
                case VehicleStyle.PassengerVan:
                case VehicleStyle.CargoVan:
                case VehicleStyle.GenericVanSUV: return VehicleStyles.GenericVanSuvIndex;

                // pickups
                case VehicleStyle.Pickup:
                case VehicleStyle.GenericPickup: return VehicleStyles.GenericPickupIndex;

                // 2b/3
                case VehicleStyle.FleetSuv:
                case VehicleStyle.WorkVan:
                case VehicleStyle.WorkTruck:
                case VehicleStyle.ChassisCab:
                case VehicleStyle.Cutaway:
                case VehicleStyle.Generic2b3: return VehicleStyles.Generic2b3Index;

                // unknown
                default:
                    return -1;
            }
        }

        /// <summary>
        /// Translates the specified <see cref="VehicleStyle"/> instance to a corresponding <see cref="VehicleClass"/>,
        /// using the specified GVWR value to distinguish between different light duty truck (LDT) classes.
        /// <br/>
        /// The following mapping is applied by this method:
        /// <br/>
        ///     LDV   for "car" vehicle styles;
        ///     LDT1  if GVWR &lt;=  6000;
        ///     LDT2a if GVWR &gt;=  6001;
        ///     LDT2b if GVWR &gt;=  8501;
        ///     LDT3  if GVWR &gt;= 10001.
        /// </summary>
        /// <seealso cref="IsCar(VehicleStyle)"/>
        public static VehicleClass ToVehicleClass(this VehicleStyle src, double gvwr)
        {
            return src.IsCar()     ? VehicleClass.LDV
                 : (gvwr >= 10001) ? VehicleClass.LDT3
                 : (gvwr >=  8501) ? VehicleClass.LDT2b
                 : (gvwr >=  6001) ? VehicleClass.LDT2a
                 :                   VehicleClass.LDT1;
        }

        /// <summary>
        /// Translates the specified <see cref="VehicleStyle"/> instance to a corresponding "aggregate"
        /// <see cref="VehicleClass"/>.
        /// <br/>
        /// The following mapping is applied by this method:
        /// <br/>
        ///     LDV    for "Car" vehicle styles;
        ///     LDT12a for "Van", "SUV", and "Pickup" vehicle styles;
        ///     LDT2b3 for "2b/3" vehicle styles.
        /// </summary>
        /// <seealso cref="IsCar(VehicleStyle)"/>
        /// <seealso cref="IsVanSUV(VehicleStyle)"/>
        /// <seealso cref="IsPickup(VehicleStyle)"/>
        /// <seealso cref="Is2b3(VehicleStyle)"/>
        public static VehicleClass ToVehicleClass(this VehicleStyle src)
        {
            return src.IsCar() ? VehicleClass.LDV
                 : src.IsVSP() ? VehicleClass.LDT12a
                 : src.Is2b3() ? VehicleClass.LDT2b3
                 :               VehicleClass.None;
        }

        /// <summary>
        /// Converts the specified <see cref="VehicleStyle"/> instance to a corresponding "generic"
        /// <see cref="VehicleStyle"/> value.
        /// </summary>
        public static VehicleStyle ToGenericStyle(this VehicleStyle src)
        {
            int index = src.GetAltListIndex();
            return (index == -1) ? VehicleStyle.None : VehicleStyles.AltList[index];
        }

        /// <summary>
        /// Determines whether the specified <see cref="VehicleStyle"/> instance represents passenger cars.
        /// That is, one of:
        ///     <see cref="VehicleStyle.GenericCar"/>,
        ///     <see cref="VehicleStyle.Convertible"/>,
        ///     <see cref="VehicleStyle.Coupe"/>,
        ///     <see cref="VehicleStyle.Hatchback"/>,
        ///     <see cref="VehicleStyle.Sedan"/>, or
        ///     <see cref="VehicleStyle.Wagon"/>.
        /// </summary>
        public static bool IsCar(this VehicleStyle src)
        {
            return (src.GetAltListIndex() == VehicleStyles.GenericCarIndex);
        }
        /// <summary>
        /// Determines whether the specified <see cref="VehicleStyle"/> instance represents light duty vans and SUVs.
        /// That is, one of:
        ///     <see cref="VehicleStyle.GenericVanSUV"/>,
        ///     <see cref="VehicleStyle.SportUtility"/>,
        ///     <see cref="VehicleStyle.Minivan"/>,
        ///     <see cref="VehicleStyle.Van"/>,
        ///     <see cref="VehicleStyle.PassengerVan"/>, or
        ///     <see cref="VehicleStyle.CargoVan"/>.
        /// </summary>
        public static bool IsVanSUV(this VehicleStyle src)
        {
            return (src.GetAltListIndex() == VehicleStyles.GenericVanSuvIndex);
        }
        /// <summary>
        /// Determines whether the specified <see cref="VehicleStyle"/> instance represents light duty pickup trucks.
        /// That is, one of:
        ///     <see cref="VehicleStyle.GenericPickup"/> or
        ///     <see cref="VehicleStyle.Pickup"/>.
        /// </summary>
        public static bool IsPickup(this VehicleStyle src)
        {
            return (src.GetAltListIndex() == VehicleStyles.GenericPickupIndex);
        }
        /// <summary>
        /// Determines whether the specified <see cref="VehicleStyle"/> instance represents class 2b/3 vehicles.
        /// That is, one of:
        ///     <see cref="VehicleStyle.Generic2b3"/>,
        ///     <see cref="VehicleStyle.FleetSuv"/>,
        ///     <see cref="VehicleStyle.WorkVan"/>,
        ///     <see cref="VehicleStyle.WorkTruck"/>,
        ///     <see cref="VehicleStyle.ChassisCab"/>, or
        ///     <see cref="VehicleStyle.Cutaway"/>.
        /// </summary>
        public static bool Is2b3(this VehicleStyle src)
        {
            return (src.GetAltListIndex() == VehicleStyles.Generic2b3Index);
        }

        // helper method for Van, SUV, Pickup
        private static bool IsVSP(this VehicleStyle src)
        {
            int index = src.GetAltListIndex();
            return (index == VehicleStyles.GenericVanSuvIndex || index == VehicleStyles.GenericPickupIndex);
        }

        #endregion

        #region < Enum TechnologyClass >

        /// <summary>
        /// Returns the friendly string representation of the specified <see cref="TechnologyClass"/> instance.
        /// </summary>
        public static string ToFriendlyString(this TechnologyClass src)
        {
            return TechnologyClasses.Names[src.GetArrayIndex()];
        }

        /// <summary>
        /// Returns an integer index that represents the location of the specified <see cref="TechnologyClass"/> within
        /// the <see cref="TechnologyClasses.List"/> and <see cref="TechnologyClasses.Names"/> arrays.
        /// </summary>
        public static int GetArrayIndex(this TechnologyClass src)
        {
            return (int)src - 1;
        }

        #endregion

        #region < Enum EngineTechnologyClass >

        /// <summary>
        /// Returns the friendly string representation of the specified <see cref="EngineTechnologyClass"/> instance.
        /// </summary>
        public static string ToFriendlyString(this EngineTechnologyClass src)
        {
            return TechnologyClasses.EngineNames[src.GetArrayIndex()];
        }

        /// <summary>
        /// Returns an integer index that represents the location of the specified <see cref="EngineTechnologyClass"/>
        /// within the <see cref="TechnologyClasses.EngineList"/> and <see cref="TechnologyClasses.EngineNames"/>
        /// arrays.
        /// </summary>
        public static int GetArrayIndex(this EngineTechnologyClass src)
        {
            return (int)src - 1;
        }

        #endregion

        #region < Enum TechnologyState >

        /// <summary>
        /// Converts the specified <see cref="TechnologyState"/> value to its equivalent string representation,
        /// optionally using the associated abbreviations.
        /// </summary>
        /// <param name="src">The <see cref="TechnologyState"/> value to convert.</param>
        /// <param name="getAbbr">true, to return technology state abbreviations; false, to return full names.</param>
        /// <returns>A string equivalent of the <see cref="TechnologyState"/> value.</returns>
        public static string ToString(this TechnologyState src, bool getAbbr = false)
        {
            if (!getAbbr) { return src.ToString(); }

            if (src.IsUnavailable()) { return "X"; }
            if (src.IsAvailable()) { return "-"; }

            // technology state may be a composite value
            return
                (src.HasUsed      () ? "U" : string.Empty) +
                (src.HasInherited () ? "I" : string.Empty) +
                (src.HasSuperseded() ? "S" : string.Empty);
        }

        /// <summary>
        /// Determines whether the specified <see cref="TechnologyState"/> instance is
        /// <see cref="TechnologyState.Unavailable"/>.
        /// </summary>
        public static bool IsUnavailable(this TechnologyState src) => (src == TechnologyState.Unavailable);
        /// <summary>
        /// Determines whether the specified <see cref="TechnologyState"/> instance is
        /// <see cref="TechnologyState.Available"/>.
        /// </summary>
        public static bool IsAvailable(this TechnologyState src) => (src == TechnologyState.Available);
        /// <summary>
        /// Determines whether the specified <see cref="TechnologyState"/> instance is
        /// <see cref="TechnologyState.Used"/>.
        /// </summary>
        public static bool IsUsed(this TechnologyState src) => (src == TechnologyState.Used);
        /// <summary>
        /// Determines whether the specified <see cref="TechnologyState"/> instance is
        /// <see cref="TechnologyState.Inherited"/>.
        /// </summary>
        public static bool IsInherited(this TechnologyState src) => (src == TechnologyState.Inherited);
        /// <summary>
        /// Determines whether the specified <see cref="TechnologyState"/> instance is
        /// <see cref="TechnologyState.Superseded"/>.
        /// </summary>
        public static bool IsSuperseded(this TechnologyState src) => (src == TechnologyState.Superseded);

        /// <summary>
        /// Determines whether the specified <see cref="TechnologyState"/> instance is a composite value, containing a
        /// <see cref="TechnologyState.Used"/> state.
        /// </summary>
        public static bool HasUsed(this TechnologyState src)
        {
            return (src & TechnologyState.Used) == TechnologyState.Used;
        }
        /// <summary>
        /// Determines whether the specified <see cref="TechnologyState"/> instance is a composite value, containing a
        /// <see cref="TechnologyState.Inherited"/> state.
        /// </summary>
        public static bool HasInherited(this TechnologyState src)
        {
            return (src & TechnologyState.Inherited) == TechnologyState.Inherited;
        }
        /// <summary>
        /// Determines whether the specified <see cref="TechnologyState"/> instance is a composite value, containing a
        /// <see cref="TechnologyState.Superseded"/> state.
        /// </summary>
        public static bool HasSuperseded(this TechnologyState src)
        {
            return (src & TechnologyState.Superseded) == TechnologyState.Superseded;
        }

        #endregion

        #region < Enum ComplianceProgram >

        /// <summary>
        /// Determines whether the specified <see cref="ComplianceProgram"/> instance is
        /// <see cref="ComplianceProgram.CAFE"/>.
        /// </summary>
        public static bool IsCAFE(this ComplianceProgram src) => (src == ComplianceProgram.CAFE);
        /// <summary>
        /// Determines whether the specified <see cref="ComplianceProgram"/> instance is
        /// <see cref="ComplianceProgram.CO2"/>.
        /// </summary>
        public static bool IsCO2(this ComplianceProgram src) => (src == ComplianceProgram.CO2);
        /// <summary>
        /// Determines whether the specified <see cref="ComplianceProgram"/> instance is
        /// <see cref="ComplianceProgram.CAFEAndCO2"/>.
        /// </summary>
        public static bool IsCAFEAndCO2(this ComplianceProgram src) => (src == ComplianceProgram.CAFEAndCO2);

        /// <summary>
        /// Determines whether the specified <see cref="ComplianceProgram"/> instance enforces, at a minimum, NHTSA's
        /// CAFE program. That is, the specified <see cref="ComplianceProgram"/> is <see cref="ComplianceProgram.CAFE"/>
        /// or <see cref="ComplianceProgram.CAFEAndCO2"/>.
        /// </summary>
        public static bool HasCAFE(this ComplianceProgram src) => (src.IsCAFE() || src.IsCAFEAndCO2());
        /// <summary>
        /// Determines whether the specified <see cref="ComplianceProgram"/> instance enforces, at a minimum, EPA's
        /// CO-2 program. That is, the specified <see cref="ComplianceProgram"/> is <see cref="ComplianceProgram.CO2"/>
        /// or <see cref="ComplianceProgram.CAFEAndCO2"/>.
        /// </summary>
        public static bool HasCO2(this ComplianceProgram src) => (src.IsCO2() || src.IsCAFEAndCO2());

        #endregion
    }

    #endregion
}
