honeybee-radiance-postprocess 0.4.420__py2.py3-none-any.whl → 0.4.422__py2.py3-none-any.whl

honeybee_radiance_postprocess/cli/leed.py

@@ -5,7 +5,7 @@ import logging
 import os
 import click
 
-from ..leed import leed_option_one
+from ..leed.leed import leed_option_one
 from ..results.annual_daylight import AnnualDaylight
 
 _logger = logging.getLogger(__name__)
@@ -28,24 +28,32 @@ def leed():
 @click.option(
     '--shade-transmittance', '-st', help='A value to use as a multiplier in place of '
     'solar shading. Value for shade transmittance must be 1 > value > 0.',
-    default=0.05, show_default=True, type=click.FLOAT
+    default=0.02, show_default=True, type=click.FLOAT
 )
 @click.option(
     '--shade-transmittance-file', '-stf', help='A JSON file with a dictionary '
     'where aperture groups are keys, and the value for each key is the shade '
     'transmittance. Values for shade transmittance must be 1 > value > 0. '
     'If any aperture groups are missing in the JSON file, its shade transmittance '
-    'value will be set to the value of the shade transmittance option (0.05 by '
+    'value will be set to the value of the --shade-transmittance option (0.02 by '
     'default).', default=None, show_default=True,
     type=click.Path(exists=False, file_okay=True, dir_okay=False, resolve_path=True)
 )
+@click.option(
+    '--use-shade-transmittance/--use-states', help='A flag to select if the '
+    'post-processing should use a shade transmittance or the simulated states '
+    'of aperture groups. Using states should only be selected if the annual '
+    'daylight simulation included ray tracing of a second (blind) state for '
+    'each aperture group.',
+    is_flag=True, default=True, show_default=True
+)
 @click.option(
     '--sub-folder', '-sf', help='Relative path for subfolder to write output '
-    'files.', default='leed_summary'
+    'files.', default='leed_summary', show_default=True
 )
 def daylight_option_one(
     folder, shade_transmittance, shade_transmittance_file, grids_filter,
-    sub_folder
+    use_shade_transmittance, sub_folder
 ):
     """Calculate credits for LEED v4.1 Daylight Option 1.
 
@@ -60,7 +68,12 @@ def daylight_option_one(
         folder: Results folder. This folder is an output folder of annual daylight
             recipe. The daylight simulation must include aperture groups.
     """
-    if shade_transmittance_file and os.path.isfile(shade_transmittance_file):
+    use_states = not use_shade_transmittance
+    if (
+        shade_transmittance_file
+        and os.path.isfile(shade_transmittance_file)
+        and use_shade_transmittance
+    ):
         with open(shade_transmittance_file) as json_file:
             shd_trans = json.load(json_file)
         results = AnnualDaylight(folder)
@@ -73,7 +86,8 @@ def daylight_option_one(
     try:
         leed_option_one(
             folder, grids_filter=grids_filter,
-            shade_transmittance=shade_transmittance, sub_folder=sub_folder
+            shade_transmittance=shade_transmittance, use_states=use_states,
+            sub_folder=sub_folder
         )
     except Exception:
         _logger.exception('Failed to generate LEED summary.')

honeybee_radiance_postprocess/cli/postprocess.py

@@ -567,7 +567,7 @@ def point_in_time(
     default=1000, type=float, show_default=True
 )
 @click.option(
-    '--occ_hours', '-oh', help='The number of occupied hours that cannot '
+    '--occ-hours', '-oh', help='The number of occupied hours that cannot '
     'receive more than the direct_threshold.', default=250, type=int,
     show_default=True
 )

honeybee_radiance_postprocess/leed/__init__.py

@@ -0,0 +1 @@
+"""honeybee-radiance-postprocess library."""

honeybee_radiance_postprocess/{leed.py → leed/leed.py}

@@ -18,16 +18,18 @@ from honeybee.model import Model
 from honeybee.units import conversion_factor_to_meters
 from honeybee_radiance.writer import _filter_by_pattern
 from honeybee_radiance.postprocess.annual import filter_schedule_by_hours
-from .metrics import da_array2d, ase_array2d
-from .annual import schedule_to_hoys, occupancy_schedule_8_to_6
-from .results.annual_daylight import AnnualDaylight
-from .util import filter_array, recursive_dict_merge
+
+from ..metrics import da_array2d, ase_array2d
+from ..annual import schedule_to_hoys, occupancy_schedule_8_to_6
+from ..results.annual_daylight import AnnualDaylight
+from ..util import filter_array, recursive_dict_merge
+from ..dynamic import DynamicSchedule, ApertureGroupSchedule
+from .leed_schedule import shd_trans_schedule_descending, states_schedule_descending
 
 
 def _create_grid_summary(
     grid_info, sda_grid, sda_blinds_up_grid, sda_blinds_down_grid, ase_grid,
-    pass_sda, pass_sda_blind_up, pass_sda_blinds_down, pass_ase, total_floor,
-    area_weighted=True):
+    pass_sda, pass_ase, total_floor, area_weighted=True):
     """Create a LEED summary for a single grid.
 
     Args:
@@ -141,8 +143,7 @@ def _leed_summary(
             grid_summary = \
                 _create_grid_summary(
                     grid_info, sda_grid, sda_blinds_up_grid, sda_blinds_down_grid,
-                    ase_grid, area_pass_sda, area_pass_sda_blind_up,
-                    area_pass_sda_blinds_down, area_pass_ase, total_grid_area,
+                    ase_grid, area_pass_sda, area_pass_ase, total_grid_area,
                     area_weighted=True
                 )
 
@@ -181,8 +182,7 @@ def _leed_summary(
             grid_summary = \
                 _create_grid_summary(
                     grid_info, sda_grid, sda_blinds_up_grid, sda_blinds_down_grid,
-                    ase_grid, sensor_count_pass_sda, sensor_count_pass_sda_blinds_up,
-                    sensor_count_pass_sda_blinds_down, sensor_count_pass_ase,
+                    ase_grid, sensor_count_pass_sda, sensor_count_pass_ase,
                     grid_count, area_weighted=False
                 )
 
@@ -291,12 +291,13 @@ def shade_transmittance_per_light_path(
                 shade_transmittances[light_path].append(1)
                 shd_trans_dict[light_path] = 1
 
-    return shade_transmittances
+    return shade_transmittances, shd_trans_dict
 
 
 def leed_states_schedule(
         results: Union[str, AnnualDaylight], grids_filter: str = '*',
-        shade_transmittance: Union[float, dict] = 0.05
+        shade_transmittance: Union[float, dict] = 0.05,
+        use_states: bool = False
         ) -> Tuple[dict, dict]:
     """Calculate a schedule of each aperture group for LEED compliant sDA.
 
@@ -315,6 +316,9 @@ def leed_states_schedule(
             keys, and the value for each key is the shade transmittance. Values
             for shade transmittance must be 1 > value > 0.
             Defaults to 0.05.
+        use_states: A boolean to note whether to use the simulated states. Set
+            to True to use the simulated states. The default is False which will
+            use the shade transmittance instead.
 
     Returns:
         Tuple: A tuple with a dictionary of the annual schedule and a
@@ -335,172 +339,51 @@ def leed_states_schedule(
     shd_trans_dict = {}
 
     for grid_info in grids_info:
-        grid_id = grid_info['full_id']
         grid_count = grid_info['count']
         light_paths = [lp[0] for lp in grid_info['light_path']]
 
-        shade_transmittances = shade_transmittance_per_light_path(
-            light_paths, shade_transmittance, shd_trans_dict)
+        shade_transmittances, shd_trans_dict = (
+            shade_transmittance_per_light_path(
+                light_paths, shade_transmittance, shd_trans_dict
+            )
+        )
 
         if len(light_paths) > 6:
-            full_direct = []
-            full_thresh = []
-            shd_trans_array = []
-            for light_path in light_paths:
-                array = results._get_array(grid_info, light_path, res_type='direct')
-                array = np.apply_along_axis(filter_array, 1, array, occ_mask)
-                full_direct.append(array)
-                full_thresh.append((array >= 1000).sum(axis=0))
-                shd_trans_array.append(shade_transmittances[light_path][1])
-
-            # sum the array element-wise
-            full_direct_sum = sum(full_direct)
-
-            # create base list of shading combinations (all set to 1)
-            combinations = [
-                {light_path: 1 for light_path in light_paths} \
-                    for i in range(full_direct_sum.shape[1])
-            ]
-
-            # find the percentage of floor area >= 1000 lux
-            direct_pct_above = (full_direct_sum >= 1000).sum(axis=0) / grid_count
-
-            # find the indices where the percentage of floor area is > 2%
-            above_2_indices = np.where(direct_pct_above > 0.02)[0]
-
-            # get an array of only the relevant hours
-            direct_sum = np.take(full_direct_sum, above_2_indices, axis=1)
-
-            # get an array of only the relevant hours
-            direct = np.take(full_direct, above_2_indices, axis=2)
-
-            # get an array of only the relevant hours
-            thresh = np.take(full_thresh, above_2_indices, axis=1)
-
-            # sort and get indices. Negate the array to get descending order
-            sort_thresh = np.argsort(-thresh, axis=0).transpose()
-
-            _combinations = []
-            _combinations.insert(0, (np.arange(full_direct_sum.shape[1]), combinations))
-
-            if np.any(above_2_indices):
-                for idx in range(len(full_direct)):
-                    # take column
-                    sort_indices = np.take(sort_thresh, idx, axis=1)
-
-                    # map light path identifiers
-                    light_path_ids = np.take(light_paths, sort_indices)
-
-                    # get a list of shade transmittances
-                    shd_trans_array = np.take(shd_trans_array, sort_indices)
-
-                    # create combination for the subset
-                    _subset_combination = [
-                        {light_path: _shd_trans} for light_path, _shd_trans in \
-                            zip(light_path_ids, shd_trans_array)
-                    ]
-                    _combinations.insert(0, (above_2_indices, _subset_combination))
-
-                    # take the values from each array by indexing
-                    direct_array = \
-                        direct[sort_indices, :, range(len(sort_indices))].transpose()
-
-                    # subtract the illuminance values
-                    direct_sum = direct_sum - (direct_array * (1 - shd_trans_array))
-
-                    # find the percentage of floor area >= 1000 lux
-                    direct_pct_above = (direct_sum >= 1000).sum(axis=0) / grid_count
-
-                    # find the indices where the percentage of floor area is > 2%
-                    above_2_indices = np.where(direct_pct_above > 0.02)[0]
-
-                    # break if there are no hours above 2%
-                    if not np.any(above_2_indices):
-                        break
-
-                    # update variables for the next iteration
-                    direct_sum = np.take(direct_sum, above_2_indices, axis=1)
-                    direct = np.take(direct, above_2_indices, axis=2)
-                    thresh = np.take(thresh, above_2_indices, axis=1)
-                    sort_thresh = np.take(sort_thresh, above_2_indices, axis=0)
-                    shd_trans_array = np.take(shd_trans_array, above_2_indices)
-
-                if np.any(above_2_indices):
-                    # take column
-                    sort_indices = np.take(sort_thresh, idx, axis=1)
-
-                    # map light path identifiers
-                    light_path_ids = np.take(light_paths, sort_indices)
-
-                    # get a list of shade transmittances
-                    shd_trans_array = np.take(shd_trans_array, sort_indices)
-
-                    # create combination for the subset
-                    _subset_combination = [
-                        {light_path: _shd_trans} for light_path, _shd_trans in \
-                            zip(light_path_ids, shd_trans_array)
-                    ]
-                    _combinations.insert(0, (above_2_indices, _subset_combination))
-
-                    # there are hours not complying with the 2% rule
-                    previous_indices = []
-                    previous_combination = []
-                    grid_comply = []
-                    # merge the combinations from the iterations of the subsets
-                    for i, subset in enumerate(_combinations):
-                        if i == 0:
-                            previous_indices = subset[0]
-                        else:
-                            _indices = subset[0]
-                            grid_comply = []
-                            for _pr_idx in previous_indices:
-                                grid_comply.append(_indices[_pr_idx])
-                            previous_indices = grid_comply
-                    # convert indices to sun up hours indices
-                    filter_indices = np.where(occ_mask.astype(bool))[0]
-                    grid_comply = [filter_indices[_gc] for _gc in grid_comply]
-                    grid_comply = np.array(results.sun_up_hours)[grid_comply]
-                    fail_to_comply[grid_info['name']] = \
-                        [int(hoy) for hoy in grid_comply]
-
-                previous_indices = None
-                previous_combination = None
-                # merge the combinations from the iterations of the subsets
-                for i, subset in enumerate(_combinations):
-                    if i == 0:
-                        previous_indices, previous_combination = subset
-                    else:
-                        _indices, _combination = subset
-                        for _pr_idx, _pr_comb in \
-                            zip(previous_indices, previous_combination):
-                            for light_path, _shd_trans in _pr_comb.items():
-                                _combination[_pr_idx][light_path] = _shd_trans
-                        previous_indices = _indices
-                        previous_combination = _combination
-
-                combinations = _combination
-
-            # merge the combinations of dicts
-            for combination in combinations:
-                for light_path, shd_trans in combination.items():
-                    if light_path != '__static_apertures__':
-                        states_schedule[light_path].append(shd_trans)
-
+            if use_states:
+                states_schedule, fail_to_comply = states_schedule_descending(
+                    results, grid_info, light_paths, occ_mask,
+                    states_schedule, fail_to_comply)
+            else:
+                states_schedule, fail_to_comply = shd_trans_schedule_descending(
+                    results, grid_info, light_paths, shade_transmittances, occ_mask,
+                    states_schedule, fail_to_comply)
         else:
-            keys, values = zip(*shade_transmittances.items())
-            combinations = [dict(zip(keys, v)) for v in itertools.product(*values)]
+            if use_states:
+                combinations = results._get_state_combinations(grid_info)
+            else:
+                shade_transmittances, shd_trans_dict = shade_transmittance_per_light_path(
+                    light_paths, shade_transmittance, shd_trans_dict)
+                keys, values = zip(*shade_transmittances.items())
+                combinations = [dict(zip(keys, v)) for v in itertools.product(*values)]
 
             array_list_combinations = []
             for combination in combinations:
                 combination_arrays = []
-                for light_path, shd_trans in combination.items():
-                    array = results._get_array(
-                        grid_info, light_path, res_type='direct')
-                    if shd_trans == 1:
-                        combination_arrays.append(array)
+                for light_path, value in combination.items():
+                    if use_states:
+                        combination_arrays.append(
+                            results._get_array(grid_info, light_path, state=value,
+                                               res_type='direct')
+                        )
                     else:
-                        combination_arrays.append(array * shd_trans)
+                        array = results._get_array(
+                            grid_info, light_path, res_type='direct')
+                        if value == 1:
+                            combination_arrays.append(array)
+                        else:
+                            combination_arrays.append(array * value)
                 combination_array = sum(combination_arrays)
+
                 combination_percentage = \
                     (combination_array >= 1000).sum(axis=0) / grid_count
                 array_list_combinations.append(combination_percentage)
@@ -513,24 +396,36 @@ def leed_states_schedule(
                 fail_to_comply[grid_info['name']] = \
                     [int(hoy) for hoy in grid_comply]
 
-            array_combinations_filter = \
-                np.apply_along_axis(filter_array, 1, array_combinations, occ_mask)
+            array_combinations_filter = np.apply_along_axis(
+                filter_array, 1, array_combinations, occ_mask
+            )
             max_indices = array_combinations_filter.argmax(axis=0)
             # select the combination for each hour
             combinations = [combinations[idx] for idx in max_indices]
             # merge the combinations of dicts
             for combination in combinations:
-                for light_path, shd_trans in combination.items():
+                for light_path, value in combination.items():
                     if light_path != '__static_apertures__':
-                        states_schedule[light_path].append(shd_trans)
+                        states_schedule[light_path].append(value)
 
     occupancy_hoys = schedule_to_hoys(schedule, results.sun_up_hours)
 
     # map states to 8760 values
-    for light_path, shd_trans in states_schedule.items():
-        mapped_states = results.values_to_annual(
-            occupancy_hoys, shd_trans, results.timestep)
-        states_schedule[light_path] = mapped_states
+    if use_states:
+        aperture_group_schedules = []
+        for identifier, values in states_schedule.items():
+            mapped_states = results.values_to_annual(
+                occupancy_hoys, values, results.timestep, dtype=np.int32)
+            aperture_group_schedules.append(
+                ApertureGroupSchedule(identifier, mapped_states.tolist())
+            )
+        states_schedule = \
+            DynamicSchedule.from_group_schedules(aperture_group_schedules)
+    else:
+        for light_path, shd_trans in states_schedule.items():
+            mapped_states = results.values_to_annual(
+                occupancy_hoys, shd_trans, results.timestep)
+            states_schedule[light_path] = mapped_states
 
     return states_schedule, fail_to_comply, shd_trans_dict
 
@@ -538,9 +433,9 @@ def leed_states_schedule(
 def leed_option_one(
         results: Union[str, AnnualDaylight], grids_filter: str = '*',
         shade_transmittance: Union[float, dict] = 0.05,
-        states_schedule: dict = None, threshold: float = 300,
-        direct_threshold: float = 1000, occ_hours: int = 250,
-        target_time: float = 50, sub_folder: str = None):
+        use_states: bool = False, states_schedule: dict = None,
+        threshold: float = 300, direct_threshold: float = 1000,
+        occ_hours: int = 250, target_time: float = 50, sub_folder: str = None):
     """Calculate credits for LEED v4.1 Daylight Option 1.
 
     Args:
@@ -553,6 +448,9 @@ def leed_option_one(
             keys, and the value for each key is the shade transmittance. Values
             for shade transmittance must be 1 > value > 0.
             Defaults to 0.05.
+        use_states: A boolean to note whether to use the simulated states. Set
+            to True to use the simulated states. The default is False which will
+            use the shade transmittance instead.
         states_schedule: A custom dictionary of shading states. In case this is
             left empty, the function will calculate a shading schedule by using
             the shade_transmittance input. If a states schedule is provided it
@@ -598,7 +496,7 @@ def leed_option_one(
     if not states_schedule:
         states_schedule, fail_to_comply, shd_trans_dict = \
             leed_states_schedule(results, grids_filter=grids_filter,
-                shade_transmittance=shade_transmittance)
+                shade_transmittance=shade_transmittance, use_states=use_states)
     else:
         raise NotImplementedError(
             'Custom input for argument states_schedule is not yet implemented.'
@@ -663,22 +561,42 @@ def leed_option_one(
         arrays_blinds_up = []
         arrays_blinds_down = []
         # combine total array for all light paths
-        for light_path in light_paths:
-            array = results._get_array(grid_info, light_path, res_type='total')
-            array_filter = np.apply_along_axis(
-                filter_array, 1, array, occ_mask)
-            if light_path != '__static_apertures__':
-                sun_up_hours = np.array(results.sun_up_hours).astype(int)
-                shd_trans_array = states_schedule[light_path][sun_up_hours]
-                shd_trans_array = shd_trans_array[occ_mask.astype(bool)]
-                arrays.append(array_filter * shd_trans_array)
-                arrays_blinds_up.append(array_filter)
-                arrays_blinds_down.append(array_filter * shd_trans_dict[light_path])
-            else:
-                arrays.append(array_filter)
+        if use_states:
+            array = results._array_from_states(grid_info, states=states_schedule)
+            array = np.apply_along_axis(filter_array, 1, array, occ_mask)
+
+            for light_path in light_paths:
+                # do an extra pass to calculate with blinds always up or down
+                array_blinds_up = results._get_array(
+                    grid_info, light_path, state=0, res_type='total')
+                array_filter = np.apply_along_axis(
+                    filter_array, 1, array_blinds_up, occ_mask)
                 arrays_blinds_up.append(array_filter)
+                array_blinds_down = results._get_array(
+                    grid_info, light_path, state=1, res_type='total')
+                array_filter = np.apply_along_axis(
+                    filter_array, 1, array_blinds_down, occ_mask)
                 arrays_blinds_down.append(array_filter)
-        array = sum(arrays)
+        else:
+            for light_path in light_paths:
+                array = results._get_array(
+                    grid_info, light_path, res_type='total')
+                array_filter = np.apply_along_axis(
+                    filter_array, 1, array, occ_mask)
+                if light_path != '__static_apertures__':
+                    sun_up_hours = np.array(results.sun_up_hours).astype(int)
+                    shd_trans_array = states_schedule[light_path][sun_up_hours]
+                    shd_trans_array = shd_trans_array[occ_mask.astype(bool)]
+                    arrays.append(array_filter * shd_trans_array)
+                    arrays_blinds_up.append(array_filter)
+                    arrays_blinds_down.append(
+                        array_filter * shd_trans_dict[light_path])
+                else:
+                    arrays.append(array_filter)
+                    arrays_blinds_up.append(array_filter)
+                    arrays_blinds_down.append(array_filter)
+            array = sum(arrays)
+
         array_blinds_up = sum(arrays_blinds_up)
         array_blinds_down = sum(arrays_blinds_down)
         # calculate da per grid
@@ -727,15 +645,23 @@ def leed_option_one(
     # convert to datacollection
     def to_datacollection(aperture_group: str, values: np.ndarray):
         # convert values to 0 and 1 (0 = no shading, 1 = shading)
-        values[values == 1] = 0
-        values[values == shd_trans_dict[aperture_group]] = 1
-        header = Header(data_type=GenericType(aperture_group, ''), unit='',
-                        analysis_period=AnalysisPeriod(),
-                        metadata={'Shade Transmittance': shd_trans_dict[aperture_group]})
-        hourly_data = HourlyContinuousCollection(header=header, values=values.tolist())
+        if use_states:
+            header = Header(data_type=GenericType(aperture_group, ''), unit='',
+                            analysis_period=AnalysisPeriod())
+            hourly_data = HourlyContinuousCollection(header=header, values=values)
+        else:
+            values[values == 1] = 0
+            values[values == shd_trans_dict[aperture_group]] = 1
+            header = Header(data_type=GenericType(aperture_group, ''), unit='',
+                            analysis_period=AnalysisPeriod(),
+                            metadata={'Shade Transmittance': shd_trans_dict[aperture_group]})
+            hourly_data = HourlyContinuousCollection(header=header, values=values.tolist())
         return hourly_data.to_dict()
 
-    states_schedule = {k:to_datacollection(k, v) for k, v in states_schedule.items()}
+    if use_states:
+        states_schedule = {k:to_datacollection(k, v['schedule']) for k, v in states_schedule.to_dict().items()}
+    else:
+        states_schedule = {k:to_datacollection(k, v) for k, v in states_schedule.items()}
 
     if sub_folder:
         folder = Path(sub_folder)

honeybee_radiance_postprocess/leed/leed_schedule.py

@@ -0,0 +1,243 @@
+"""Module for dynamic LEED schedules."""
+from typing import Tuple
+import numpy as np
+
+from ..results.annual_daylight import AnnualDaylight
+from ..util import filter_array
+
+
+def shd_trans_schedule_descending(
+        results: AnnualDaylight, grid_info, light_paths, shade_transmittances, occ_mask,
+        states_schedule, fail_to_comply
+        ) -> Tuple[dict, dict]:
+    grid_count = grid_info['count']
+    full_direct = []
+    full_thresh = []
+    full_shd_trans_array = []
+    for light_path in light_paths:
+        array = results._get_array(grid_info, light_path, res_type="direct")
+        array = np.apply_along_axis(filter_array, 1, array, occ_mask)
+        full_direct.append(array)
+        full_thresh.append((array >= 1000).sum(axis=0))
+        full_shd_trans_array.append(shade_transmittances[light_path][1])
+
+    # Sum the array element-wise.
+    # This array is the sum of all direct illuminance without shade
+    # transmittance.
+    full_direct_sum = sum(full_direct)
+
+    # Create base list of shading combinations (all set to 1).
+    # We will replace the 1s later.
+    combinations = [
+        {light_path: 1 for light_path in light_paths}
+        for i in range(full_direct_sum.shape[1])
+    ]
+
+    # Find the percentage of floor area >= 1000 lux.
+    # This array is the percentage for each hour (axis=0).
+    direct_pct_above = (full_direct_sum >= 1000).sum(axis=0) / grid_count
+
+    # Find the indices where the percentage of floor area is > 2%.
+    # This array is the problematic hours.
+    above_2_indices = np.where(direct_pct_above > 0.02)[0]
+
+    # Use the indices to get the relevant hours.
+    direct_sum = np.take(full_direct_sum, above_2_indices, axis=1)
+
+    # Use the indices to get the relevant hours.
+    direct = np.take(full_direct, above_2_indices, axis=2)
+
+    # Use the indices to get the relevant hours.
+    thresh = np.take(full_thresh, above_2_indices, axis=1)
+
+    # Sort and get indices. Negate the array to get descending order.
+    # Descending order puts the "highest offender" light path first.
+    sort_thresh = np.argsort(-thresh, axis=0).transpose()
+
+    _combinations = []
+    _combinations.insert(
+        0, (np.arange(full_direct_sum.shape[1]), combinations)
+    )
+
+    if np.any(above_2_indices):
+        # There are hours where the percentage of floor area is > 2%.
+        for idx, lp in enumerate(light_paths):
+            # Take column. For each iteration it will take the next column
+            # in descending order, i.e., the "highest offender" is the first
+            # column.
+            sort_indices = np.take(sort_thresh, idx, axis=1)
+
+            # Map light path identifiers to indices.
+            light_path_ids = np.take(light_paths, sort_indices)
+
+            # Map shade transmittance to indices.
+            shd_trans_array = np.take(full_shd_trans_array, sort_indices)
+
+            # Create combination for the subset.
+            _subset_combination = [
+                {light_path: _shd_trans} for light_path, _shd_trans in
+                zip(light_path_ids, shd_trans_array)
+            ]
+            _combinations.insert(0, (above_2_indices, _subset_combination))
+
+            # Take the values from each array by indexing.
+            direct_array = \
+                direct[sort_indices, :, range(len(sort_indices))].transpose()
+
+            # Subtract the illuminance values.
+            direct_sum = direct_sum - (direct_array * (1 - shd_trans_array))
+
+            # Find the percentage of floor area >= 1000 lux.
+            direct_pct_above = (direct_sum >= 1000).sum(axis=0) / grid_count
+
+            # Find the indices where the percentage of floor area is > 2%.
+            above_2_indices = np.where(direct_pct_above > 0.02)[0]
+
+            # Break if there are no hours above 2%.
+            if not np.any(above_2_indices):
+                break
+
+            # Update variables for the next iteration.
+            direct_sum = np.take(direct_sum, above_2_indices, axis=1)
+            direct = np.take(direct, above_2_indices, axis=2)
+            thresh = np.take(thresh, above_2_indices, axis=1)
+            sort_thresh = np.take(sort_thresh, above_2_indices, axis=0)
+
+        if np.any(above_2_indices):
+            # There are hours not complying with the 2% rule.
+            previous_indices = []
+            previous_combination = []
+            grid_comply = []
+            # Merge the combinations from the iterations of the subsets.
+            for i, subset in enumerate(_combinations):
+                if i == 0:
+                    previous_indices = subset[0]
+                else:
+                    _indices = subset[0]
+                    grid_comply = []
+                    for _pr_idx in previous_indices:
+                        grid_comply.append(_indices[_pr_idx])
+                    previous_indices = grid_comply
+            # Convert indices to sun up hours indices.
+            filter_indices = np.where(occ_mask.astype(bool))[0]
+            grid_comply = [filter_indices[_gc] for _gc in grid_comply]
+            grid_comply = np.array(results.sun_up_hours)[grid_comply]
+            fail_to_comply[grid_info['name']] = \
+                [int(hoy) for hoy in grid_comply]
+
+        previous_indices = None
+        previous_combination = None
+        # Merge the combinations from the iterations of the subsets.
+        for i, subset in enumerate(_combinations):
+            if i == 0:
+                previous_indices, previous_combination = subset
+            else:
+                _indices, _combination = subset
+                for _pr_idx, _pr_comb in \
+                        zip(previous_indices, previous_combination):
+                    for light_path, _shd_trans in _pr_comb.items():
+                        _combination[_pr_idx][light_path] = _shd_trans
+                previous_indices = _indices
+                previous_combination = _combination
+
+        combinations = _combination
+
+    # Merge the combinations of dicts.
+    for combination in combinations:
+        for light_path, shd_trans in combination.items():
+            if light_path != "__static_apertures__":
+                states_schedule[light_path].append(shd_trans)
+
+    return states_schedule, fail_to_comply
+
+
+def states_schedule_descending(
+        results: AnnualDaylight, grid_info, light_paths, occ_mask,
+        states_schedule, fail_to_comply
+        ) -> Tuple[dict, dict]:
+    grid_count = grid_info['count']
+    full_direct = []
+    full_thresh = []
+    full_direct_blinds = []
+    for light_path in light_paths:
+        array = results._get_array(
+            grid_info, light_path, state=0, res_type="direct")
+        array = np.apply_along_axis(filter_array, 1, array, occ_mask)
+        full_direct.append(array)
+        full_thresh.append((array >= 1000).sum(axis=0))
+
+        array = results._get_array(
+            grid_info, light_path, state=1, res_type="direct")
+        array = np.apply_along_axis(filter_array, 1, array, occ_mask)
+        full_direct_blinds.append(array)
+
+    full_direct = np.array(full_direct)
+    full_direct_blinds = np.array(full_direct_blinds)
+    full_direct_sum = full_direct.sum(axis=0)
+
+    new_array = full_direct.copy()
+
+    percentage_sensors = (full_direct_sum >= 1000).sum(axis=0) / grid_count
+    if not np.any(percentage_sensors > 0.02):
+        combinations = [
+            {light_path: 0 for light_path in light_paths}
+            for i in range(full_direct_sum.shape[1])]
+    else:
+        tracking_array = np.zeros(
+            (new_array.shape[0], new_array.shape[2]), dtype=int)
+
+        percentage_sensors = (full_direct >= 1000).sum(axis=1) / grid_count
+
+        ranking_indices = np.argsort(-percentage_sensors, axis=0)
+
+        for rank in range(ranking_indices.shape[0]):
+            # Calculate the percentage of sensors with values >= 1000 for the current new_array
+            summed_array = np.sum(new_array, axis=0)
+            percentage_sensors_summed = np.sum(
+                summed_array >= 1000, axis=0) / grid_count
+            indices_above_2_percent = np.where(
+                percentage_sensors_summed > 0.02)[0]
+
+            # Exit if there are no more hours exceeding the threshold
+            if len(indices_above_2_percent) == 0:
+                break
+
+            # Array indices to use for replacement for these hours
+            replace_indices = indices_above_2_percent
+            array_indices = ranking_indices[rank, replace_indices]
+
+            # Use advanced indexing to replace values in new_array for these hours
+            for hour_idx, array_idx in zip(replace_indices, array_indices):
+                new_array[array_idx, :, hour_idx] = full_direct_blinds[
+                    array_idx, :, hour_idx
+                ]
+
+            # Update the tracking array
+            tracking_array[array_indices, replace_indices] = 1
+
+        combinations = []
+        for hour in range(new_array.shape[2]):
+            hour_dict = {
+                light_paths[i]: tracking_array[i, hour]
+                for i in range(tracking_array.shape[0])}
+            combinations.append(hour_dict)
+
+        final_summed_array = np.sum(new_array, axis=0)
+        final_percentage_sensors_summed = (
+            final_summed_array >= 1000).sum(
+            axis=0) / grid_count
+        final_indices_above_2_percent = np.where(
+            final_percentage_sensors_summed > 0.02)[0]
+        if np.any(final_indices_above_2_percent):
+            sun_up_hours_indices = np.where(occ_mask == 1)[0][
+                final_indices_above_2_percent]
+            grid_comply = np.array(results.sun_up_hours)[sun_up_hours_indices]
+            fail_to_comply[grid_info['name']] = [
+                int(hoy) for hoy in grid_comply]
+
+    for combination in combinations:
+        for light_path, value in combination.items():
+            if light_path != '__static_apertures__':
+                states_schedule[light_path].append(value)
+
+    return states_schedule, fail_to_comply

honeybee_radiance_postprocess/results/annual_daylight.py

@@ -714,11 +714,9 @@ class AnnualDaylight(Results):
                 f'grid {grid_info["name"]}. Received {len(control_sensor)} '
                 'control sensors.')
             control_sensor_index = control_sensor[0]
-            light_paths = [lp[0] for lp in grid_info['light_path']]
-            lp_states = {key: self.valid_states[key] for key in light_paths if key in self.valid_states}
 
-            keys, values = zip(*lp_states.items())
-            combinations = [dict(zip(keys, v)) for v in itertools.product(*values)]
+            combinations = self._get_state_combinations(grid_info)
+
             array_list_combinations = []
             for combination in combinations:
                 combination_arrays = []

honeybee_radiance_postprocess/results/results.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from itertools import islice, cycle
 from typing import Tuple, Union, List
 import numpy as np
+import itertools
 
 from ladybug.analysisperiod import AnalysisPeriod
 from ladybug.datacollection import HourlyContinuousCollection
@@ -931,7 +932,8 @@ class Results(_ResultsFolder):
     def values_to_annual(
             hours: Union[List[float], np.ndarray],
             values: Union[List[float], np.ndarray],
-            timestep: int, base_value: int = 0) -> np.ndarray:
+            timestep: int, base_value: int = 0,
+            dtype: np.dtype = np.float32) -> np.ndarray:
         """Map a 1D NumPy array based on a set of hours to an annual array.
 
         This method creates an array with a base value of length 8760 and
@@ -945,6 +947,7 @@ class Results(_ResultsFolder):
                 regular list or a 1D NumPy array.
             timestep: Time step of the simulation.
             base_value: A value that will be applied for all the base array.
+            dtype: A NumPy dtype for the annual array.
 
         Returns:
             A 1D NumPy array.
@@ -955,7 +958,7 @@ class Results(_ResultsFolder):
         assert hours.shape == values.shape
         full_ap = AnalysisPeriod(timestep=timestep)
         indices = np.where(np.isin(full_ap.hoys, hours))[0]
-        annual_array = np.repeat(base_value, 8760 * timestep).astype(np.float32)
+        annual_array = np.repeat(base_value, 8760 * timestep).astype(dtype)
         annual_array[indices] = values
 
         return annual_array
@@ -1218,7 +1221,6 @@ class Results(_ResultsFolder):
         Returns:
             A NumPy array based on the states settings.
         """
-        grid_count = grid_info['count']
         # get states that are relevant for the grid
         states = self._filter_grid_states(grid_info, states=states)
 
@@ -1226,29 +1228,35 @@ class Results(_ResultsFolder):
         for light_path, gr_schedule in states.dynamic_schedule.items():
             if gr_schedule.is_static:
                 state = gr_schedule.schedule[0]
+                # if state is -1 we continue since it is "turned off"
                 if state == -1:
                     continue
+                # load static array (state is static)
                 array = self._get_array(
                     grid_info, light_path, state=state, res_type=res_type)
                 arrays.append(array)
             else:
-                # create default 0 array
-                array = np.zeros((grid_count, len(self.sun_up_hours)))
+                # create default 0 array, we will add to this later
+                array = np.zeros((grid_info['count'], len(self.sun_up_hours)))
                 # slice states to match sun up hours
-                states_array = np.array(gr_schedule.schedule)[list(map(int, self.sun_up_hours))]
-                for state in set(states_array.tolist()):
+                states_array = np.array(gr_schedule.schedule)[
+                    list(map(int, self.sun_up_hours))]
+                for state in np.unique(states_array):
                     if state == -1:
+                        # if state is -1 we continue since it is "turned off"
                         continue
+                    # load static array (state is static)
                     _array = self._get_array(
                         grid_info, light_path, state=state, res_type=res_type)
-                    conds = [states_array == state, states_array != state]
-                    array = np.select(conds, [_array, array])
+                    # get indices and add values to base array
+                    states_indicies = states_array == state
+                    array[:, states_indicies] += _array[:, states_indicies]
                 arrays.append(array)
         array = sum(arrays)
 
         if not np.any(array):
             if zero_array:
-                array = np.zeros((grid_count, len(self.sun_up_hours)))
+                array = np.zeros((grid_info['count'], len(self.sun_up_hours)))
             else:
                 array = np.array([])
 
@@ -1334,3 +1342,24 @@ class Results(_ResultsFolder):
                     valid_states[light_path] = list(range(len(states)))
 
         return valid_states
+
+    def _light_paths_from_grid_info(self, grid_info: Union[dict, str]) -> list:
+        if isinstance(grid_info, str):
+            for _grid_info in self.grids_info:
+                if _grid_info['full_id'] == grid_info:
+                    grid_info = _grid_info
+                    break
+            else:
+                raise Exception(f'Grid info with full_id "{grid_info}" not found.')
+        light_paths = [elem for lp in grid_info['light_path'] for elem in lp]
+
+        return light_paths
+
+    def _get_state_combinations(self, grid_info: Union[dict, str]) -> List[dict]:
+        light_paths = self._light_paths_from_grid_info(grid_info)
+        valid_states = self._get_valid_states()
+        filtered_states = {lp: valid_states[lp] for lp in light_paths}
+        keys, values = zip(*filtered_states.items())
+        combinations = [dict(zip(keys, v)) for v in itertools.product(*values)]
+
+        return combinations

{honeybee_radiance_postprocess-0.4.420.dist-info → honeybee_radiance_postprocess-0.4.422.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: honeybee-radiance-postprocess
-Version: 0.4.420
+Version: 0.4.422
 Summary: Postprocessing of Radiance results and matrices
 Home-page: https://github.com/ladybug-tools/honeybee-radiance-postprocess
 Author: Ladybug Tools

{honeybee_radiance_postprocess-0.4.420.dist-info → honeybee_radiance_postprocess-0.4.422.dist-info}/RECORD

@@ -8,7 +8,6 @@ honeybee_radiance_postprocess/dynamic.py,sha256=RPJh2SsjASYJCsG5QRkazVCvzWjzMxm9
 honeybee_radiance_postprocess/electriclight.py,sha256=E7uhq7-YtZ02F9a1FbEdrXnxmYJNOFnfLF0Yw3JLQ-g,732
 honeybee_radiance_postprocess/en17037.py,sha256=5c5ahfzad12FqMwBL7c0sLOKHzLKSTXtlYFfaNhzA3w,10848
 honeybee_radiance_postprocess/helper.py,sha256=qz5kaJxzy1tGBfVYYXc2cEToOCoj0YLOtwjr3LVI3YU,9000
-honeybee_radiance_postprocess/leed.py,sha256=Mx1fqNumEvLbQ1lb0HiFHVperbqtqBUjve-y4ZDdCJ4,35944
 honeybee_radiance_postprocess/metrics.py,sha256=6EHCuXf5jnhh6GglI9mTd0MFpfhfPFoKMf4b5gKRTMI,14038
 honeybee_radiance_postprocess/reader.py,sha256=6myKzfGC1pO8zPixg1kKrKjPihHabTKUh2t5BlJvij0,2367
 honeybee_radiance_postprocess/type_hints.py,sha256=4R0kZgacQrqzoh8Tq7f8MVzUDzynV-C_jlh80UV6GPE,1122
@@ -17,21 +16,24 @@ honeybee_radiance_postprocess/vis_metadata.py,sha256=7ywIgdiuNKcctxifhpy7-Q2oaSX
 honeybee_radiance_postprocess/cli/__init__.py,sha256=PVfwkuPFl4TnvQt8ovVm01JK0Alon81BaY-0tshAXyg,795
 honeybee_radiance_postprocess/cli/abnt.py,sha256=GNLmVVrEQ-1oKr5ZmBllY-KODhgJPjLVidQ_dQMcpFk,15537
 honeybee_radiance_postprocess/cli/grid.py,sha256=6peLEAPVe-iw05_wdRpFruZLqO8myvC-_QT5W1q5sk8,10677
-honeybee_radiance_postprocess/cli/leed.py,sha256=QBR6AMJJWuZ0TevyMi2tXCWMLdS-ZSqtVTZDgqxwa7M,3112
+honeybee_radiance_postprocess/cli/leed.py,sha256=bxGX2UBehYNcaPJWHL2yEasSP6dATD7B0aNNQOflqqM,3712
 honeybee_radiance_postprocess/cli/mtxop.py,sha256=UZJnjNpPjDmShy1-Mxos4H2vTUqk_yP3ZyaC1_LLFeI,5015
-honeybee_radiance_postprocess/cli/postprocess.py,sha256=CnUsIE3fWUZWLBeIjSW_wte9ptKKx-oaNDBGo63YHF4,39202
+honeybee_radiance_postprocess/cli/postprocess.py,sha256=pzZ419eBt_LNNilW1y47c4lGTFxmV7cJyWnjV78GzY8,39202
 honeybee_radiance_postprocess/cli/schedule.py,sha256=6uIy98Co4zm-ZRcELo4Lfx_aN3lNiqPe-BSimXwt1F8,3877
 honeybee_radiance_postprocess/cli/translate.py,sha256=18zkcGeRZALJ5Z82NEB3XZ-iEX2cHyneobGWV-IXWE0,6789
 honeybee_radiance_postprocess/cli/two_phase.py,sha256=xA6ayPv26DM5fuMkLhBMYGklf_j5ymowmncwJGXRgo8,7034
 honeybee_radiance_postprocess/cli/util.py,sha256=Be9cGmYhcV2W37ma6SgQPCWCpWLLLlroxRYN_l58kY0,4077
 honeybee_radiance_postprocess/cli/viewfactor.py,sha256=kU36YRzLya5PReYREjTfw3zOcWKHYZjVlVclyuR7Cqk,5245
+honeybee_radiance_postprocess/leed/__init__.py,sha256=kQXElEqFnLGNnrMSpA51XDHoqBup849FHeAqWASIy6w,45
+honeybee_radiance_postprocess/leed/leed.py,sha256=rbvhq51Dfhx4aZFcKWqOXp3FfgFy5YDRkHYn9wKHQpc,32631
+honeybee_radiance_postprocess/leed/leed_schedule.py,sha256=s3by1sv1DtOlCawvaMvnIDvEo5D8ATEJvWQ_rEeJIHg,9956
 honeybee_radiance_postprocess/results/__init__.py,sha256=1agBQbfT4Tf8KqSZzlfKYX8MeZryY4jJ1KB4HWqaDDk,182
-honeybee_radiance_postprocess/results/annual_daylight.py,sha256=ohysFt4OWlWUn_IvM6pjmiQcRTq_x5b998Iv0pw8AEQ,34964
+honeybee_radiance_postprocess/results/annual_daylight.py,sha256=11d4J1iIuITKuoWyWa-2_2WdrHYBULC0YP-mWBWi4JQ,34724
 honeybee_radiance_postprocess/results/annual_irradiance.py,sha256=5zwrr4MNeHUebbSRpSBbscPOZUs2AHmYCQfIIbdYImY,8298
-honeybee_radiance_postprocess/results/results.py,sha256=GwyjIYljaCShx1b6NlYUBcU_gHhckmLcCMNrQ6HVDdE,53507
-honeybee_radiance_postprocess-0.4.420.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-honeybee_radiance_postprocess-0.4.420.dist-info/METADATA,sha256=Wk_YuV0iIsxYoLMUY9gpJYNHZoed872Ej9o86dNQNDU,2245
-honeybee_radiance_postprocess-0.4.420.dist-info/WHEEL,sha256=unfA4MOaH0icIyIA5oH6E2sn2Hq5zKtLlHsWapZGwes,110
-honeybee_radiance_postprocess-0.4.420.dist-info/entry_points.txt,sha256=gFtVPx6UItXt27GfEZZO00eOZChJJEL6JwGSAB_O3rs,96
-honeybee_radiance_postprocess-0.4.420.dist-info/top_level.txt,sha256=4-sFbzy7ewP2EDqJV3jeFlAFx7SuxtoBBELWaKAnLdA,30
-honeybee_radiance_postprocess-0.4.420.dist-info/RECORD,,
+honeybee_radiance_postprocess/results/results.py,sha256=ABb_S8kDPruhGkDsfREXMg6K0p8FRhAZ3QIRUZCQPAI,54888
+honeybee_radiance_postprocess-0.4.422.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+honeybee_radiance_postprocess-0.4.422.dist-info/METADATA,sha256=q3U1E3sHzUes8aIUvguDRv_c6wCmRusvHkIKdlqi_NA,2245
+honeybee_radiance_postprocess-0.4.422.dist-info/WHEEL,sha256=unfA4MOaH0icIyIA5oH6E2sn2Hq5zKtLlHsWapZGwes,110
+honeybee_radiance_postprocess-0.4.422.dist-info/entry_points.txt,sha256=gFtVPx6UItXt27GfEZZO00eOZChJJEL6JwGSAB_O3rs,96
+honeybee_radiance_postprocess-0.4.422.dist-info/top_level.txt,sha256=4-sFbzy7ewP2EDqJV3jeFlAFx7SuxtoBBELWaKAnLdA,30
+honeybee_radiance_postprocess-0.4.422.dist-info/RECORD,,