honeybee-radiance-postprocess 0.4.555__py3-none-any.whl

honeybee_radiance_postprocess/ies/lm.py

@@ -0,0 +1,224 @@
+"""Functions for IES LM post-processing."""
+from typing import Tuple, Union
+from collections import defaultdict
+import itertools
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
+
+from honeybee_radiance.postprocess.annual import filter_schedule_by_hours
+
+from ..annual import schedule_to_hoys, occupancy_schedule_8_to_6
+from ..results.annual_daylight import AnnualDaylight
+from ..util import filter_array
+from ..dynamic import DynamicSchedule, ApertureGroupSchedule
+from .lm_schedule import shd_trans_schedule_descending, states_schedule_descending
+
+
+def shade_transmittance_per_light_path(
+    light_paths: list, shade_transmittance: Union[float, dict],
+    shd_trans_dict: dict) -> dict:
+    """Filter shade_transmittance by light paths and add default multiplier.
+
+    Args:
+        light_paths: A list of light paths.
+        shade_transmittance: A value to use as a multiplier in place of solar
+            shading. This input can be either a single value that will be used
+            for all aperture groups, or 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.
+        shd_trans_dict: A dictionary used to store shade transmittance value
+            for each aperture group.
+
+    Returns:
+        A dictionary with filtered light paths.
+    """
+    shade_transmittances = {}
+    if isinstance(shade_transmittance, dict):
+        for light_path in light_paths:
+            # default multiplier
+            shade_transmittances[light_path] = [1]
+            # add custom shade transmittance
+            if light_path in shade_transmittance:
+                shade_transmittances[light_path].append(
+                    shade_transmittance[light_path])
+                shd_trans_dict[light_path] = shade_transmittance[light_path]
+            # add default shade transmittance (0.02)
+            elif light_path != '__static_apertures__':
+                shade_transmittances[light_path].append(0.02)
+                shd_trans_dict[light_path] = 0.02
+            else:
+                shade_transmittances[light_path].append(1)
+                shd_trans_dict[light_path] = 1
+    else:
+        shd_trans = float(shade_transmittance)
+        for light_path in light_paths:
+            # default multiplier
+            shade_transmittances[light_path] = [1]
+            # add custom shade transmittance
+            if light_path != '__static_apertures__':
+                shade_transmittances[light_path].append(shd_trans)
+                shd_trans_dict[light_path] = shd_trans
+            else:
+                shade_transmittances[light_path].append(1)
+                shd_trans_dict[light_path] = 1
+
+    return shade_transmittances, shd_trans_dict
+
+
+def dynamic_schedule_direct_illuminance(
+        results: Union[str, AnnualDaylight], grids_filter: str = '*',
+        shade_transmittance: Union[float, dict] = 0.02,
+        use_states: bool = False
+        ) -> Tuple[dict, dict]:
+    """Calculate a schedule of each aperture group.
+
+    This function calculates an annual shading schedule of each aperture
+    group. Hour by hour it will select the least shaded aperture group
+    configuration, so that no more than 2% of the sensors points receive
+    direct illuminance of 1000 lux or more.
+
+    Args:
+        results: Path to results folder or a Results class object.
+        grids_filter: The name of a grid or a pattern to filter the grids.
+            Defaults to '*'.
+        shade_transmittance: A value to use as a multiplier in place of solar
+            shading. This input can be either a single value that will be used
+            for all aperture groups, or 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.
+            Defaults to 0.02.
+        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
+            dictionary of hours where no shading configuration comply with the
+            2% rule.
+    """
+    if not isinstance(results, AnnualDaylight):
+        results = AnnualDaylight(results)
+
+    grids_info = results._filter_grids(grids_filter=grids_filter)
+    schedule = occupancy_schedule_8_to_6(as_list=True)
+    occ_pattern = \
+        filter_schedule_by_hours(results.sun_up_hours, schedule=schedule)[0]
+    occ_mask = np.array(occ_pattern)
+
+    states_schedule = defaultdict(list)
+    fail_to_comply = {}
+    shd_trans_dict = {}
+
+    for grid_info in grids_info:
+        grid_states_schedule = defaultdict(list)
+
+        grid_count = grid_info['count']
+        light_paths = []
+        for lp in grid_info['light_path']:
+            for _lp in lp:
+                if _lp == '__static_apertures__' and len(lp) > 1:
+                    pass
+                else:
+                    light_paths.append(_lp)
+
+        shade_transmittances, shd_trans_dict = (
+            shade_transmittance_per_light_path(
+                light_paths, shade_transmittance, shd_trans_dict
+            )
+        )
+
+        if len(light_paths) > 6:
+            if use_states:
+                grid_states_schedule, fail_to_comply = states_schedule_descending(
+                    results, grid_info, light_paths, occ_mask,
+                    grid_states_schedule, fail_to_comply)
+            else:
+                grid_states_schedule, fail_to_comply = shd_trans_schedule_descending(
+                    results, grid_info, light_paths, shade_transmittances, occ_mask,
+                    grid_states_schedule, fail_to_comply)
+        else:
+            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, value in combination.items():
+                    if use_states:
+                        combination_arrays.append(
+                            results._get_array(grid_info, light_path, state=value,
+                                               res_type='direct')
+                        )
+                    else:
+                        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)
+            array_combinations = np.array(array_list_combinations)
+            array_combinations[array_combinations > 0.02] = -np.inf
+
+            grid_comply = np.where(np.all(array_combinations==-np.inf, axis=0))[0]
+            if grid_comply.size != 0:
+                grid_comply = np.array(results.sun_up_hours)[grid_comply]
+                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
+            )
+            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, value in combination.items():
+                    if light_path != '__static_apertures__':
+                        grid_states_schedule[light_path].append(value)
+
+        for key, value in grid_states_schedule.items():
+            if key not in states_schedule:
+                states_schedule[key] = value
+            else:
+                if use_states:
+                    merged_array = np.logical_or(states_schedule[key], value).astype(int)
+                else:
+                    merged_array = np.minimum(states_schedule[key], value)
+                states_schedule[key] = merged_array
+
+    occupancy_hoys = schedule_to_hoys(schedule, results.sun_up_hours)
+
+    # map states to 8760 values
+    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

honeybee_radiance_postprocess/ies/lm_schedule.py

@@ -0,0 +1,248 @@
+"""Module for dynamic LM schedules."""
+from typing import Tuple
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    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/leed/__init__.py

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