Remove EnergyPlus mapping functions and tests.

Author: aspeake

scout/ecm_prep.py

@@ -20,7 +20,7 @@
 from pathlib import Path
 import argparse
 from scout.ecm_prep_args import ecm_args
-from scout.ecm_prep_vars import UsefulVars, UsefulInputFiles, EPlusMapDicts
+from scout.ecm_prep_vars import UsefulVars, UsefulInputFiles
 from scout.utils import JsonIO, PrintFormat as fmt
 from scout.config import LogConfig, FilePaths as fp
 import traceback
@@ -795,73 +795,6 @@ def __init__(
                     "mseg_out_break"]["energy"]["efficient-captured"] = \
                     copy.deepcopy(self.handyvars.out_break_in)
 
-    def fill_eplus(self, msegs, eplus_dir, eplus_coltypes,
-                   eplus_files, vintage_weights, base_cols):
-        """Fill in measure performance with EnergyPlus simulation results.
-
-        Note:
-            Find the appropriate set of EnergyPlus simulation results for
-            the current measure, and use the relative savings percentages
-            in these results to determine the measure performance attribute.
-
-        Args:
-            msegs (dict): Baseline microsegment stock/energy data to use in
-                validating categorization of measure performance information.
-            eplus_dir (string): Directory of EnergyPlus performance files.
-            eplus_coltypes (list): Expected EnergyPlus variable data types.
-            eplus_files (list): EnergyPlus performance file names.
-            vintage_weights (dict): Square-footage-derived weighting factors
-                for each EnergyPlus building vintage type.
-
-        Returns:
-            Updated Measure energy_efficiency, energy_efficiency_source, and
-            energy_efficiency_source attribute values.
-
-        Raises:
-            ValueError: If EnergyPlus file is not matched to Measure
-                definition or more than one EnergyPlus file matches the
-                Measure definition.
-        """
-        # Instantiate useful EnergyPlus-Scout mapping dicts
-        handydicts = EPlusMapDicts()
-        # Determine the relevant EnergyPlus building type name(s)
-        bldg_type_names = []
-        for x in self.bldg_type:
-            bldg_type_names.extend(handydicts.bldgtype[x].keys())
-        # Find all EnergyPlus files including the relevant building type
-        # name(s)
-        eplus_perf_in = [(eplus_dir / x) for x in eplus_files if any([
-            y.lower() in x for y in bldg_type_names])]
-
-        # Import EnergyPlus input file as array and use it to fill a dict
-        # of measure performance data
-        if len(eplus_perf_in) > 0:
-            # Assemble the EnergyPlus data into a record array
-            eplus_perf_array = self.build_array(eplus_coltypes, eplus_perf_in)
-            # Create a measure performance dictionary, zeroed out, to
-            # be updated with data from EnergyPlus array
-            perf_dict_empty = self.create_perf_dict(msegs)
-
-            # Update measure performance based on EnergyPlus data
-            # (* Note: only update efficiency information for
-            # secondary microsegments if applicable)
-            if perf_dict_empty['secondary'] is not None:
-                self.energy_efficiency = self.fill_perf_dict(
-                    perf_dict_empty, eplus_perf_array,
-                    vintage_weights, base_cols, eplus_bldg_types={})
-            else:
-                self.energy_efficiency = self.fill_perf_dict(
-                    perf_dict_empty['primary'], eplus_perf_array,
-                    vintage_weights, base_cols, eplus_bldg_types={})
-            # Set the energy efficiency data source for the measure to
-            # EnergyPlus and set to highest data quality rating
-            self.energy_efficiency_source = 'EnergyPlus/OpenStudio'
-        else:
-            raise ValueError(
-                "Failure to find relevant EPlus files for " +
-                "Scout building type(s) " + str(self.bldg_type) +
-                "in ECM '" + self.name + "'")
-
     def fill_mkts(self, msegs, msegs_cpl, convert_data, tsv_data_init, opts,
                   ctrb_ms_pkg_prep, tsv_data_nonfs):
         """Fill in a measure's market microsegments using EIA baseline data.
@@ -8696,214 +8629,6 @@ def rand_list_gen(self, distrib_info, nsamples):
 
         return rand_list
 
-    def fill_perf_dict(
-            self, perf_dict, eplus_perf_array, vintage_weights,
-            base_cols, eplus_bldg_types):
-        """Fill an empty dict with updated measure performance information.
-
-        Note:
-            Use structured array data drawn from an EnergyPlus output file
-            and building type/vintage weighting data to fill a dictionary of
-            final measure performance information.
-
-        Args:
-            perf_dict (dict): Empty dictionary to fill with EnergyPlus-based
-                performance information broken down by climate zone, building
-                type/vintage, fuel type, and end use.
-            eplus_perf_array (numpy recarray): Structured array of EnergyPlus
-                energy savings information for the Measure.
-            vintage_weights (dict): Square-footage-derived weighting factors
-                for each EnergyPlus building vintage type.
-            eplus_bldg_types (dict): Scout-EnergyPlus building type mapping
-                data, including weighting factors needed to map multiple
-                EnergyPlus building types to a single Scout building type.
-                Drawn from EPlusMapDicts object's 'bldgtype' attribute.
-
-        Returns:
-            A measure performance dictionary filled with relative energy
-            savings values from an EnergyPlus simulation output file.
-
-        Raises:
-            KeyError: If an EnergyPlus category name cannot be mapped to the
-                input perf_dict keys.
-            ValueError: If weights used to map multiple EnergyPlus reference
-                building types to a single Scout building type do not sum to 1.
-        """
-        # Instantiate useful EnergyPlus-Scout mapping dicts
-        handydicts = EPlusMapDicts()
-
-        # Set the header of the EnergyPlus input array (used when reducing
-        # columns of the array to the specific performance categories being
-        # updated below)
-        eplus_header = list(eplus_perf_array.dtype.names)
-
-        # Loop through zeroed out measure performance dictionary input and
-        # update the values with data from the EnergyPlus input array
-        for key, item in perf_dict.items():
-            # If current dict item is itself a dict, reduce EnergyPlus array
-            # based on the current dict key and proceed further down the dict
-            # levels
-            if isinstance(item, dict):
-                # Microsegment type level (no update to EnergyPlus array
-                # required)
-                if key in ['primary', 'secondary']:
-                    updated_perf_array = eplus_perf_array
-                # Climate zone level
-                elif key in handydicts.czone.keys():
-                    # Reduce EnergyPlus array to only rows with climate zone
-                    # currently being updated in the performance dictionary
-                    updated_perf_array = eplus_perf_array[numpy.where(
-                        eplus_perf_array[
-                            'climate_zone'] == handydicts.czone[key])].copy()
-                    if len(updated_perf_array) == 0:
-                        raise KeyError(
-                            "EPlus climate zone name not found for ECM '" +
-                            self.name + "'")
-                # Building type level
-                elif key in handydicts.bldgtype.keys():
-                    # Determine relevant EnergyPlus building types for current
-                    # Scout building type
-                    eplus_bldg_types = handydicts.bldgtype[key]
-                    if sum(eplus_bldg_types.values()) != 1:
-                        raise ValueError(
-                            "EPlus building type weights do not sum to 1 "
-                            "for ECM '" + self.name + "'")
-                    # Reduce EnergyPlus array to only rows with building type
-                    # relevant to current Scout building type
-                    updated_perf_array = eplus_perf_array[numpy.in1d(
-                        eplus_perf_array['building_type'],
-                        list(eplus_bldg_types.keys()))].copy()
-                    if len(updated_perf_array) == 0:
-                        raise KeyError(
-                            "EPlus building type name not found for ECM '" +
-                            self.name + "'")
-                # Fuel type level
-                elif key in handydicts.fuel.keys():
-                    # Reduce EnergyPlus array to only columns with fuel type
-                    # currently being updated in the performance dictionary,
-                    # plus bldg. type/vintage, climate, and measure columns
-                    colnames = base_cols + [
-                        x for x in eplus_header if handydicts.fuel[key] in x]
-                    if len(colnames) == len(base_cols):
-                        raise KeyError(
-                            "EPlus fuel type name not found for ECM '" +
-                            self.name + "'")
-                    updated_perf_array = eplus_perf_array[colnames].copy()
-                # End use level
-                elif key in handydicts.enduse.keys():
-                    # Reduce EnergyPlus array to only columns with end use
-                    # currently being updated in the performance dictionary,
-                    # plus bldg. type/vintage, climate, and measure columns
-                    colnames = base_cols + [
-                        x for x in eplus_header if x in handydicts.enduse[
-                            key]]
-                    if len(colnames) == len(base_cols):
-                        raise KeyError(
-                            "EPlus end use name not found for ECM '" +
-                            self.name + "'")
-                    updated_perf_array = eplus_perf_array[colnames].copy()
-                else:
-                    raise KeyError(
-                        "Invalid performance dict key for ECM '" +
-                        self.name + "'")
-
-                # Given updated EnergyPlus array, proceed further down the
-                # dict level hierarchy
-                self.fill_perf_dict(
-                    item, updated_perf_array, vintage_weights,
-                    base_cols, eplus_bldg_types)
-            else:
-                # Reduce EnergyPlus array to only rows with structure type
-                # currently being updated in the performance dictionary
-                # ('new' or 'retrofit')
-                if key in handydicts.structure_type.keys():
-                    # A 'new' structure type will match only one of the
-                    # EnergyPlus building vintage names
-                    if key == "new":
-                        updated_perf_array = eplus_perf_array[numpy.where(
-                            eplus_perf_array['template'] ==
-                            handydicts.structure_type['new'])].copy()
-                    # A 'retrofit' structure type will match multiple
-                    # EnergyPlus building vintage names
-                    else:
-                        updated_perf_array = eplus_perf_array[numpy.in1d(
-                            eplus_perf_array['template'], list(
-                                handydicts.structure_type[
-                                    'retrofit'].keys()))].copy()
-                    if len(updated_perf_array) == 0 or \
-                       (key == "new" and
-                        len(numpy.unique(updated_perf_array[
-                            'template'])) != 1 or key == "retrofit" and
-                        len(numpy.unique(updated_perf_array[
-                            'template'])) != len(
-                            handydicts.structure_type["retrofit"].keys())):
-                        raise ValueError(
-                            "EPlus vintage name not found for ECM '" +
-                            self.name + "'")
-                else:
-                    raise KeyError(
-                        "Invalid performance dict key for ECM '" +
-                        self.name + "'")
-
-                # Separate filtered array into the rows representing measure
-                # consumption and those representing baseline consumption
-                updated_perf_array_m, updated_perf_array_b = [
-                    updated_perf_array[updated_perf_array[
-                        'measure'] != 'none'],
-                    updated_perf_array[updated_perf_array[
-                        'measure'] == 'none']]
-                # Ensure that a baseline consumption row exists for every
-                # measure consumption row retrieved
-                if len(updated_perf_array_m) != len(updated_perf_array_b):
-                    raise ValueError(
-                        "Lengths of ECM and baseline EPlus data arrays "
-                        "are unequal for ECM '" + self.name + "'")
-                # Initialize total measure and baseline consumption values
-                val_m, val_b = (0 for n in range(2))
-
-                # Weight and combine the measure/baseline consumption values
-                # left in the EnergyPlus arrays; subtract total measure
-                # consumption from baseline consumption and divide by baseline
-                # consumption to reach relative savings value for the current
-                # dictionary branch
-                for ind in range(0, len(updated_perf_array_m)):
-                    row_m, row_b = [
-                        updated_perf_array_m[ind], updated_perf_array_b[ind]]
-                    # Loop through remaining columns with consumption data
-                    for n in eplus_header:
-                        if row_m[n].dtype.char != 'S' and \
-                                row_m[n].dtype.char != 'U':
-                            # Find appropriate building type to weight
-                            # consumption data points by
-                            eplus_bldg_type_wt_row_m, \
-                                eplus_bldg_type_wt_row_b = [
-                                    eplus_bldg_types[row_m['building_type']],
-                                    eplus_bldg_types[row_b['building_type']]]
-                            # Weight consumption data points by factors for
-                            # appropriate building type and vintage
-                            row_m_val, row_b_val = [(
-                                row_m[n] * eplus_bldg_type_wt_row_m *
-                                vintage_weights[row_m['template'].copy()]),
-                                (row_b[n] * eplus_bldg_type_wt_row_b *
-                                 vintage_weights[row_b['template'].copy()])]
-                            # Add weighted measure consumption data point to
-                            # total measure consumption
-                            val_m += row_m_val
-                            # Add weighted baseline consumption data point to
-                            # total base consumption
-                            val_b += row_b_val
-                    # Find relative savings if total baseline use != zero
-                    if val_b != 0:
-                        end_key_val = (val_b - val_m) / val_b
-                    else:
-                        end_key_val = 0
-
-                # Update the current dictionary branch value to the final
-                # measure relative savings value derived above
-                perf_dict[key] = round(end_key_val, 3)
-
-        return perf_dict
-
     def create_perf_dict(self, msegs):
         """Create dict to fill with updated measure performance information.
 

scout/ecm_prep_vars.py

@@ -1699,90 +1699,3 @@ def get_suffix(arg):
                                     f"tsv_carbon-{opts.alt_regions.lower()}-MidCase.json")
             self.ss_data_nonfs, self.tsv_cost_data_nonfs, \
                 self.tsv_carbon_data_nonfs = (None for n in range(3))
-
-
-class EPlusMapDicts(object):
-    """Class of dicts used to map Scout measure definitions to EnergyPlus.
-
-    Attributes:
-        czone (dict): Scout-EnergyPlus climate zone mapping.
-        bldgtype (dict): Scout-EnergyPlus building type mapping. Shown are
-            the EnergyPlus commercial reference building names that correspond
-            to each AEO commercial building type, and the weights needed in
-            some cases to map multiple EnergyPlus reference building types to
-            a single AEO type. See 'convert_data' JSON for more details.
-        fuel (dict): Scout-EnergyPlus fuel type mapping.
-        enduse (dict): Scout-EnergyPlus end use mapping.
-        structure_type (dict): Scout-EnergyPlus structure type mapping.
-    """
-
-    def __init__(self):
-        self.czone = {
-            "sub arctic": "BA-SubArctic",
-            "very cold": "BA-VeryCold",
-            "cold": "BA-Cold",
-            "marine": "BA-Marine",
-            "mixed humid": "BA-MixedHumid",
-            "mixed dry": "BA-MixedDry",
-            "hot dry": "BA-HotDry",
-            "hot humid": "BA-HotHumid"}
-        self.bldgtype = {
-            "assembly": {
-                "Hospital": 1},
-            "education": {
-                "PrimarySchool": 0.26,
-                "SecondarySchool": 0.74},
-            "food sales": {
-                "Supermarket": 1},
-            "food service": {
-                "QuickServiceRestaurant": 0.31,
-                "FullServiceRestaurant": 0.69},
-            "health care": None,
-            "lodging": {
-                "SmallHotel": 0.26,
-                "LargeHotel": 0.74},
-            "large office": {
-                "LargeOfficeDetailed": 0.9,
-                "MediumOfficeDetailed": 0.1},
-            "small office": {
-                "SmallOffice": 0.12,
-                "OutpatientHealthcare": 0.88},
-            "mercantile/service": {
-                "RetailStandalone": 0.53,
-                "RetailStripmall": 0.47},
-            "warehouse": {
-                "Warehouse": 1},
-            "other": None,
-            "unspecified": None}
-        self.fuel = {
-            'electricity': 'electricity',
-            'natural gas': 'gas',
-            'distillate': 'other_fuel'}
-        self.enduse = {
-            'heating': [
-                'heating_electricity', 'heat_recovery_electricity',
-                'humidification_electricity', 'pump_electricity',
-                'heating_gas', 'heating_other_fuel'],
-            'cooling': [
-                'cooling_electricity', 'pump_electricity',
-                'heat_rejection_electricity'],
-            'water heating': [
-                'service_water_heating_electricity',
-                'service_water_heating_gas',
-                'service_water_heating_other_fuel'],
-            'ventilation': ['fan_electricity'],
-            'cooking': [
-                'interior_equipment_gas', 'interior_equipment_other_fuel'],
-            'lighting': ['interior_lighting_electricity'],
-            'refrigeration': ['refrigeration_electricity'],
-            'PCs': ['interior_equipment_electricity'],
-            'non-PC office equipment': ['interior_equipment_electricity'],
-            'MELs': ['interior_equipment_electricity']}
-        # Note: assumed year range for each structure vintage shown in lists
-        self.structure_type = {
-            "new": '90.1-2013',
-            "retrofit": {
-                '90.1-2004': [2004, 2009],
-                '90.1-2010': [2010, 2012],
-                'DOE Ref 1980-2004': [1980, 2003],
-                'DOE Ref Pre-1980': [0, 1979]}}