honeybee-radiance-postprocess 0.4.543__tar.gz → 0.4.544__tar.gz

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: honeybee-radiance-postprocess
-Version: 0.4.543
+Version: 0.4.544
 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.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/annual.py

@@ -1,10 +1,17 @@
 """Shared functions for post-processing annual results."""
 from typing import Union
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ladybug.analysisperiod import AnalysisPeriod
 from .util import filter_array
 
+is_cpu = not is_gpu
+
 
 def occupancy_schedule_8_to_6(
         timestep: int = 1, as_list: bool = False) -> Union[np.ndarray, list]:
@@ -19,10 +26,10 @@ def occupancy_schedule_8_to_6(
     Returns:
         A schedule as an array or list.
     """
-    full_analysis_period = AnalysisPeriod(timestep=timestep)
-    analysis_period = AnalysisPeriod(st_hour=8, end_hour=17, timestep=timestep)
+    full_analysis_period = np.array(AnalysisPeriod(timestep=timestep).hoys)
+    analysis_period = np.array(AnalysisPeriod(st_hour=8, end_hour=17, timestep=timestep).hoys)
     schedule = np.zeros(8760 * timestep).astype(int)
-    hours = np.where(np.isin(full_analysis_period.hoys, analysis_period.hoys))[0]
+    hours = np.where(np.isin(full_analysis_period, analysis_period))[0]
     schedule[hours] = 1
     if as_list:
         schedule = schedule.tolist()

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/annualdaylight.py

@@ -4,7 +4,12 @@ Note: These functions will most likely be moved to a separate package in the nea
 """
 import json
 import os
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ladybug.color import Colorset
 from ladybug.datatype.fraction import Fraction

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/breeam/breeam.py

@@ -2,7 +2,12 @@
 from typing import Union
 from pathlib import Path
 import json
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from honeybee.model import Model
 from honeybee_radiance.writer import _filter_by_pattern
@@ -339,7 +344,7 @@ def breeam_daylight_assessment_4b(
         hb_model.properties.radiance.sensor_grids, filter=grids_filter)
     for s_grid in filt_grids:
         if s_grid.mesh is not None:
-            grid_areas[s_grid.identifier] = np.array(s_grid.mesh.face_areas).sum()
+            grid_areas[s_grid.identifier] = int(np.array(s_grid.mesh.face_areas).sum())
         else:
             grid_areas[s_grid.identifier] = None
         hb_room = hb_model.rooms_by_identifier([s_grid.room_identifier])[0]
@@ -397,7 +402,7 @@ def breeam_daylight_assessment_4b(
                 target_hrs = metrics['minimum_daylight_illuminance']['hours']
                 min_comply = hrs_abv_min >= target_hrs
 
-                minimum_illuminance_index = np.argsort(hrs_abv_target)[0]
+                minimum_illuminance_index = int(np.argsort(hrs_abv_target)[0])
                 minimum_illuminance_sensor = \
                     sensor_grid_mapper[grid_info['full_id']].sensors[minimum_illuminance_index]
                 minimum_illuminance_sensors[grid_info['full_id']] = \
@@ -482,11 +487,11 @@ def breeam_daylight_assessment_4b(
         area_proportions = np.array(areas) / program_type_summary['total_area']
 
         weighted_hours_avg = area_proportions * np.array(avg_hrs)
-        total_weighted_hours_avg = np.sum(weighted_hours_avg)
+        total_weighted_hours_avg = int(np.sum(weighted_hours_avg))
         program_type_summary['average-illuminance-hours'] = total_weighted_hours_avg
 
         weighted_hours_min = area_proportions * np.array(min_hrs)
-        total_weighted_hours_min = np.sum(weighted_hours_min)
+        total_weighted_hours_min = int(np.sum(weighted_hours_min))
         program_type_summary['minimum-illuminance-hours'] = total_weighted_hours_min
 
         program_summary.append(program_type_summary)

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/abnt.py

@@ -4,7 +4,12 @@ import sys
 import logging
 from pathlib import Path
 import click
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from honeybee.model import Model
 from honeybee.room import Room

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/datacollection.py

@@ -1,10 +1,15 @@
 """Commands to work with data collections."""
 import sys
 import logging
-import numpy as np
 from pathlib import Path
 import click
 import json
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ladybug.datacollection import HourlyContinuousCollection, \
     HourlyDiscontinuousCollection

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/grid.py

@@ -3,8 +3,13 @@ import click
 import sys
 import logging
 import json
-import numpy as np
 from pathlib import Path
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from honeybee_radiance_postprocess.reader import binary_to_array
 from ..annualdaylight import _annual_daylight_vis_metadata

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/merge.py

@@ -3,8 +3,13 @@ import click
 import sys
 import logging
 import json
-import numpy as np
 from pathlib import Path
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from honeybee_radiance_postprocess.reader import binary_to_array
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/mtxop.py

@@ -2,8 +2,13 @@
 import sys
 import logging
 from pathlib import Path
-import numpy as np
 import click
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ..reader import binary_to_array, ascii_to_array
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/postprocess.py

@@ -5,7 +5,12 @@ import os
 import logging
 import json
 import click
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ladybug.location import Location
 from ladybug.wea import Wea
@@ -721,8 +726,8 @@ def annual_metrics_file(
     if grid_name is None:
         grid_name = file.stem
 
-    sun_up_hours_mask =  np.where(np.isin(study_hours, sun_up_hours))[0]
-    sun_down_hours_mask =  np.where(~np.isin(study_hours, sun_up_hours))[0]
+    sun_up_hours_mask =  np.where(np.isin(np.array(study_hours), np.array(sun_up_hours)))[0]
+    sun_down_hours_mask =  np.where(~np.isin(np.array(study_hours), np.array(sun_up_hours)))[0]
     occ_mask = np.array(schedule, dtype=int)[sun_up_hours_mask]
     sun_down_occ_hours =  np.array(schedule, dtype=int)[sun_down_hours_mask].sum()
     total_hours = sum(schedule)

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/translate.py

@@ -3,9 +3,14 @@ import sys
 import logging
 from pathlib import Path
 import shutil
-import numpy as np
 import click
 import json
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ..reader import binary_to_array
 from ..util import get_delimiter

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/two_phase.py

@@ -2,8 +2,13 @@
 import sys
 import logging
 from pathlib import Path
-import numpy as np
 import click
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ..reader import binary_to_array, ascii_to_array
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/cli/viewfactor.py

@@ -4,7 +4,12 @@ import os
 import sys
 import logging
 import math
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from honeybee_radiance.config import folders
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/data_type.py

@@ -1,6 +1,11 @@
 """Functions for NumPy data type (dtype)."""
 from typing import Tuple
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 
 def smallest_integer_dtype(array: np.ndarray) -> np.signedinteger:

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/electriclight.py

@@ -1,6 +1,12 @@
 """Functions for post-processing daylight outputs into electric lighting schedules."""
 from typing import List
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
+
 
 def array_to_dimming_fraction(
         array: np.ndarray, su_pattern: List[int], setpt: float, m_pow: float,

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/en17037.py

@@ -2,7 +2,12 @@
 from typing import Union
 from pathlib import Path
 import json
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ladybug.color import Colorset
 from ladybug.datatype.fraction import Fraction

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/helper.py

@@ -1,7 +1,12 @@
 """Helper functions."""
 import json
-import numpy as np
 from pathlib import Path
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from honeybee.model import Model
 
@@ -144,7 +149,10 @@ def grid_summary(
         arrays.append(tuple(data))
 
     # create structured array
-    struct_array = np.array(arrays, dtype=dtype)
+    if is_gpu:
+        struct_array = None
+    else:
+        struct_array = np.array(arrays, dtype=dtype)
 
     header = [dt[0] for dt in dtype]
     # write header to file
@@ -153,7 +161,13 @@ def grid_summary(
     # write structured array to grid_summary_file
     with open(folder.joinpath(f'{name}.csv'), 'a') as grid_summary_file:
         grid_summary_file.write('\n')
-        np.savetxt(grid_summary_file, struct_array, delimiter=',', fmt=fmt)
+        if is_gpu:
+            # CuPy doesn't support structured arrays; manually format rows
+            for row in arrays:
+                row_str = ','.join(fmt_val % val for fmt_val, val in zip(fmt, row))
+                grid_summary_file.write(row_str + '\n')
+        else:
+            np.savetxt(grid_summary_file, struct_array, delimiter=',', fmt=fmt)
 
     return grid_summary_file
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/ies/lm.py

@@ -2,7 +2,12 @@
 from typing import Tuple, Union
 from collections import defaultdict
 import itertools
-import numpy as np
+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
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/ies/lm_schedule.py

@@ -1,6 +1,11 @@
 """Module for dynamic LM schedules."""
 from typing import Tuple
-import numpy as np
+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

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/leed/leed.py

@@ -4,7 +4,12 @@ from pathlib import Path
 from collections import defaultdict
 import json
 import itertools
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ladybug.analysisperiod import AnalysisPeriod
 from ladybug.datatype.generic import GenericType
@@ -22,10 +27,12 @@ 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 ..util import recursive_dict_merge, filter_array2d
 from ..dynamic import DynamicSchedule, ApertureGroupSchedule
 from .leed_schedule import shd_trans_schedule_descending, states_schedule_descending
 
+is_cpu = not is_gpu
+
 
 def _create_grid_summary(
     grid_info, sda_grid, sda_blinds_up_grid, sda_blinds_down_grid, ase_grid,
@@ -117,7 +124,6 @@ def _leed_summary(
     """
     summary = {}
     summary_grid = {}
-
     if all(grid_area is not None for grid_area in grid_areas):
         # weighted by mesh face area
         total_area = 0
@@ -127,17 +133,17 @@ def _leed_summary(
              pass_sda_blinds_down) in \
             zip(pass_ase_grids, pass_sda_grids, grid_areas, grids_info,
                 pass_sda_blinds_up_grids, pass_sda_blinds_down_grids):
-            total_grid_area = grid_area.sum()
+            total_grid_area = float(grid_area.sum())
 
-            area_pass_ase = grid_area[pass_ase].sum()
-            ase_grid = (total_grid_area - area_pass_ase) / total_grid_area * 100
+            area_pass_ase = float(grid_area[pass_ase].sum())
+            ase_grid = float((total_grid_area - area_pass_ase) / total_grid_area * 100)
 
-            area_pass_sda = grid_area[pass_sda].sum()
+            area_pass_sda = float(grid_area[pass_sda].sum())
             area_pass_sda_blind_up = grid_area[pass_sda_blinds_up].sum()
             area_pass_sda_blinds_down = grid_area[pass_sda_blinds_down].sum()
-            sda_grid = area_pass_sda / total_grid_area * 100
-            sda_blinds_up_grid = area_pass_sda_blind_up / total_grid_area * 100
-            sda_blinds_down_grid = area_pass_sda_blinds_down / total_grid_area * 100
+            sda_grid = float(area_pass_sda / total_grid_area * 100)
+            sda_blinds_up_grid = float(area_pass_sda_blind_up / total_grid_area * 100)
+            sda_blinds_down_grid = float(area_pass_sda_blinds_down / total_grid_area * 100)
 
             # grid summary
             grid_summary = \
@@ -298,8 +304,7 @@ def shade_transmittance_per_light_path(
 def leed_states_schedule(
         results: Union[str, AnnualDaylight], grids_filter: str = '*',
         shade_transmittance: Union[float, dict] = 0.05,
-        use_states: bool = False
-        ) -> Tuple[dict, dict]:
+        use_states: bool = False) -> Tuple[dict, dict, dict]:
     """Calculate a schedule of each aperture group for LEED compliant sDA.
 
     This function calculates an annual shading schedule of each aperture
@@ -404,11 +409,9 @@ 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
-            )
-            max_indices = array_combinations_filter.argmax(axis=0)
-            # select the combination for each hour
+            array_combinations_filter = filter_array2d(array_combinations, occ_mask)
+
+            max_indices = [int(i) for i in array_combinations_filter.argmax(axis=0)]
             combinations = [combinations[idx] for idx in max_indices]
             # merge the combinations of dicts
             for combination in combinations:
@@ -416,6 +419,8 @@ def leed_states_schedule(
                     if light_path != '__static_apertures__':
                         grid_states_schedule[light_path].append(value)
 
+            del array_list_combinations, array_combinations, array_combinations_filter, combination_arrays
+
         for key, value in grid_states_schedule.items():
             if key not in states_schedule:
                 states_schedule[key] = value
@@ -502,7 +507,7 @@ def leed_option_one(
     schedule = occupancy_schedule_8_to_6(as_list=True)
 
     if not isinstance(results, AnnualDaylight):
-        results = AnnualDaylight(results, schedule=schedule, cache_arrays=False)
+        results = AnnualDaylight(results, schedule=schedule, cache_arrays=True)
     else:
         # set schedule to default leed schedule
         results.schedule = schedule
@@ -555,8 +560,7 @@ def leed_option_one(
         for light_path in light_paths:
             array = results._get_array(
                 grid_info, light_path, res_type='direct')
-            array_filter = np.apply_along_axis(
-                filter_array, 1, array, occ_mask)
+            array_filter = filter_array2d(array, occ_mask)
             arrays.append(array_filter)
         array = sum(arrays)
         # calculate ase per grid
@@ -575,6 +579,7 @@ def leed_option_one(
         hours_above.append(h_above)
         pass_ase = h_above < occ_hours
         pass_ase_grids.append(pass_ase)
+    results.clear_cached_arrays(res_type='direct')  # don't need direct arrays
 
     # spatial daylight autonomy
     da_grids = []
@@ -589,42 +594,40 @@ def leed_option_one(
                     pass
                 else:
                     light_paths.append(_lp)
-        base_zero_array = np.apply_along_axis(filter_array, 1, np.zeros(
-            (grid_info['count'], len(results.sun_up_hours))), occ_mask)
+        base_zero_array = filter_array2d(
+            np.zeros((grid_info['count'], len(results.sun_up_hours))), occ_mask)
         arrays = [base_zero_array.copy()]
         arrays_blinds_up = [base_zero_array.copy()]
         arrays_blinds_down = [base_zero_array.copy()]
         # combine total array for all light paths
         if use_states:
             array = results._array_from_states(grid_info, states=states_schedule, zero_array=True)
-            array = np.apply_along_axis(filter_array, 1, array, occ_mask)
+            array = filter_array2d(array, occ_mask)
 
             for light_path in light_paths:
                 # do an extra pass to calculate with blinds always up or down
                 if light_path != '__static_apertures__':
                     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)
+                    array_filter = filter_array2d(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)
+                    array_filter = filter_array2d(array_blinds_down, occ_mask)
+                    arrays_blinds_down.append(array_filter)
                     arrays_blinds_down.append(array_filter)
                 else:
                     static_array = results._get_array(
                         grid_info, light_path, state=0, res_type='total')
-                    array_filter = np.apply_along_axis(
-                        filter_array, 1, static_array, occ_mask)
+                    array_filter = filter_array2d(static_array, occ_mask)
+                    arrays.append(array_filter)
                     arrays_blinds_up.append(array_filter)
                     arrays_blinds_down.append(array_filter)
         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)
+                array_filter = filter_array2d(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]
@@ -652,6 +655,7 @@ def leed_option_one(
         pass_sda_grids.append(da_grid >= target_time)
         pass_sda_blinds_up_grids.append(da_blinds_up_grid >= target_time)
         pass_sda_blinds_down_grids.append(da_blinds_down_grid >= target_time)
+    results.clear_cached_arrays(res_type='total')
 
     # create summaries for all grids and each grid individually
     summary, summary_grid = _leed_summary(
@@ -701,7 +705,9 @@ def leed_option_one(
         return hourly_data.to_dict()
 
     if use_states:
-        states_schedule = {k:to_datacollection(k, v['schedule']) for k, v in states_schedule.to_dict().items()}
+        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()}
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/leed/leed_schedule.py

@@ -1,9 +1,14 @@
 """Module for dynamic LEED schedules."""
 from typing import Tuple
-import numpy as np
+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
+from ..util import filter_array2d
 
 
 def shd_trans_schedule_descending(
@@ -16,7 +21,7 @@ def shd_trans_schedule_descending(
     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)
+        array = filter_array2d(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])
@@ -50,6 +55,7 @@ def shd_trans_schedule_descending(
     # Use the indices to get the relevant hours.
     thresh = np.take(full_thresh, above_2_indices, axis=1)
 
+    del full_direct, full_thresh
     # 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()
@@ -59,6 +65,8 @@ def shd_trans_schedule_descending(
         0, (np.arange(full_direct_sum.shape[1]), combinations)
     )
 
+    del full_direct_sum
+
     if np.any(above_2_indices):
         # There are hours where the percentage of floor area is > 2%.
         for idx, lp in enumerate(light_paths):
@@ -142,6 +150,8 @@ def shd_trans_schedule_descending(
 
         combinations = _combination
 
+    del full_shd_trans_array, direct_sum, direct, thresh, sort_thresh
+
     # Merge the combinations of dicts.
     for combination in combinations:
         for light_path, shd_trans in combination.items():
@@ -162,27 +172,26 @@ def states_schedule_descending(
     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)
+        array = filter_array2d(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)
+        array = filter_array2d(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:
+        new_array = full_direct.copy()
         tracking_array = np.zeros(
             (new_array.shape[0], new_array.shape[2]), dtype=int)
 
@@ -235,6 +244,10 @@ def states_schedule_descending(
             fail_to_comply[grid_info['name']] = [
                 int(hoy) for hoy in grid_comply]
 
+        del new_array, tracking_array, percentage_sensors, ranking_indices, final_summed_array
+
+    del full_direct, full_thresh, full_direct_blinds, full_direct_sum
+
     for combination in combinations:
         for light_path, value in combination.items():
             if light_path != '__static_apertures__':

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/metrics.py

@@ -1,13 +1,19 @@
 """Functions to calculate various metrics for 1D and 2D NumPy arrays."""
 from typing import Tuple, Union
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from .util import check_array_dim
 
+is_cpu = not is_gpu
+
 
 def da_array2d(
-        array: np.ndarray, total_occ: int = None,
-        threshold: float = 300) -> np.ndarray:
+        array: np.ndarray, total_occ: int = None, threshold: float = 300) -> np.ndarray:
     """Calculate daylight autonomy for a 2D NumPy array.
 
     Args:
@@ -74,8 +80,11 @@ def cda_array2d(
         # set total_occ to number of columns in array
         total_occ = array.shape[1]
 
-    cda = np.apply_along_axis(
-            cda_array1d, 1, array, total_occ=total_occ, threshold=threshold)
+    if is_cpu:
+        cda = np.apply_along_axis(
+                cda_array1d, 1, array, total_occ=total_occ, threshold=threshold)
+    else:
+        cda = np.where(array >= threshold, 1, array / threshold).sum(axis=1) / total_occ * 100
 
     return cda
 
@@ -124,8 +133,11 @@ def udi_array2d(
         # set total_occ to number of columns in array
         total_occ = array.shape[1]
 
-    udi = np.apply_along_axis(
-            udi_array1d, 1, array, total_occ=total_occ, min_t=min_t, max_t=max_t)
+    if is_cpu:
+        udi = np.apply_along_axis(
+                udi_array1d, 1, array, total_occ=total_occ, min_t=min_t, max_t=max_t)
+    else:
+        udi = ((array >= min_t) & (array <= max_t)).sum(axis=1) / total_occ * 100
 
     return udi
 
@@ -174,9 +186,15 @@ def udi_lower_array2d(
         # set total_occ to number of columns in array
         total_occ = array.shape[1]
 
-    udi = np.apply_along_axis(
-            udi_lower_array1d, 1, array, total_occ=total_occ, min_t=min_t,
-            sun_down_occ_hours=sun_down_occ_hours)
+    if is_cpu:
+        udi = np.apply_along_axis(
+                udi_lower_array1d, 1, array, total_occ=total_occ, min_t=min_t,
+                sun_down_occ_hours=sun_down_occ_hours)
+    else:
+        if min_t == 0:
+            return np.zeros(array.shape[0], dtype=np.float32)
+
+        udi = ((array < min_t).sum(axis=1) + sun_down_occ_hours) / total_occ * 100
 
     return udi
 
@@ -227,8 +245,11 @@ def udi_upper_array2d(
         # set total_occ to number of columns in array
         total_occ = array.shape[1]
 
-    udi = np.apply_along_axis(
-            udi_upper_array1d, 1, array, total_occ=total_occ, max_t=max_t)
+    if is_cpu:
+        udi = np.apply_along_axis(
+                udi_upper_array1d, 1, array, total_occ=total_occ, max_t=max_t)
+    else:
+        udi = (array > max_t).sum(axis=1) / total_occ * 100
 
     return udi
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/reader.py

@@ -1,5 +1,10 @@
 """Post-processing reader functions."""
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from .util import binary_mtx_dimension
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/results/annual_daylight.py

@@ -1,8 +1,13 @@
 import json
 from pathlib import Path
 from typing import Tuple, List
-import numpy as np
-import itertools
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
+
 from collections import defaultdict
 
 from ladybug.analysisperiod import AnalysisPeriod
@@ -14,13 +19,15 @@ from ladybug.header import Header
 from ..annual import occupancy_schedule_8_to_6
 from ..metrics import da_array2d, cda_array2d, udi_array2d, udi_lower_array2d, \
     udi_upper_array2d, ase_array2d
-from ..util import filter_array
+from ..util import filter_array, filter_array2d
 from ..annualdaylight import _annual_daylight_vis_metadata
 from ..electriclight import array_to_dimming_fraction
 from .. import type_hints
 from ..dynamic import DynamicSchedule, ApertureGroupSchedule
 from .results import Results
 
+is_cpu = not is_gpu
+
 
 class AnnualDaylight(Results):
     """Annual Daylight Results class.
@@ -71,8 +78,7 @@ class AnnualDaylight(Results):
         for grid_info in grids_info:
             array = self._array_from_states(grid_info, states=states, res_type='total')
             if np.any(array):
-                array_filter = np.apply_along_axis(
-                    filter_array, 1, array, mask=self.occ_mask)
+                array_filter = filter_array2d(array, mask=self.occ_mask)
                 results = da_array2d(
                     array_filter, total_occ=self.total_occ, threshold=threshold)
             else:
@@ -102,8 +108,7 @@ class AnnualDaylight(Results):
         for grid_info in grids_info:
             array = self._array_from_states(grid_info, states=states, res_type='total')
             if np.any(array):
-                array_filter = np.apply_along_axis(
-                    filter_array, 1, array, mask=self.occ_mask)
+                array_filter = filter_array2d(array, mask=self.occ_mask)
                 results = cda_array2d(
                     array_filter, total_occ=self.total_occ, threshold=threshold)
             else:
@@ -133,8 +138,7 @@ class AnnualDaylight(Results):
         for grid_info in grids_info:
             array = self._array_from_states(grid_info, states=states, res_type='total')
             if np.any(array):
-                array_filter = np.apply_along_axis(
-                    filter_array, 1, array, mask=self.occ_mask)
+                array_filter = filter_array2d(array, mask=self.occ_mask)
                 results = udi_array2d(
                     array_filter, total_occ=self.total_occ, min_t=min_t, max_t=max_t)
             else:
@@ -165,8 +169,7 @@ class AnnualDaylight(Results):
         for grid_info in grids_info:
             array = self._array_from_states(grid_info, states=states, res_type='total')
             if np.any(array):
-                array_filter = np.apply_along_axis(
-                    filter_array, 1, array, mask=self.occ_mask)
+                array_filter = filter_array2d(array, mask=self.occ_mask)
                 results = udi_lower_array2d(
                     array_filter, total_occ=self.total_occ,
                     min_t=min_t, sun_down_occ_hours=sun_down_occ_hours)
@@ -197,8 +200,7 @@ class AnnualDaylight(Results):
         for grid_info in grids_info:
             array = self._array_from_states(grid_info, states=states, res_type='total')
             if np.any(array):
-                array_filter = np.apply_along_axis(
-                    filter_array, 1, array, mask=self.occ_mask)
+                array_filter = filter_array2d(array, mask=self.occ_mask)
                 results = udi_upper_array2d(
                     array_filter, total_occ=self.total_occ, max_t=max_t)
             else:
@@ -242,8 +244,7 @@ class AnnualDaylight(Results):
         for grid_info in grids_info:
             array = self._array_from_states(grid_info, states=states, res_type='total')
             if np.any(array):
-                array_filter = np.apply_along_axis(
-                    filter_array, 1, array, mask=self.occ_mask)
+                array_filter = filter_array2d(array, mask=self.occ_mask)
                 da_results = da_array2d(
                     array_filter, total_occ=self.total_occ, threshold=threshold)
                 cda_results = cda_array2d(
@@ -379,8 +380,7 @@ class AnnualDaylight(Results):
             array = self._array_from_states(
                 grid_info, states=states, res_type='direct')
             if np.any(array):
-                array_filter = np.apply_along_axis(
-                    filter_array, 1, array, mask=self.occ_mask)
+                array_filter = filter_array2d(array, mask=self.occ_mask)
                 results, h_above = ase_array2d(
                     array_filter, occ_hours=occ_hours,
                     direct_threshold=direct_threshold)

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/results/annual_irradiance.py

@@ -1,6 +1,11 @@
 import json
 from pathlib import Path
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ladybug.datatype.energyflux import EnergyFlux
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/results/results.py

@@ -3,8 +3,13 @@ import json
 from pathlib import Path
 from itertools import islice, cycle
 from typing import Tuple, Union, List
-import numpy as np
 import itertools
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from ladybug.analysisperiod import AnalysisPeriod
 from ladybug.datacollection import HourlyContinuousCollection
@@ -21,6 +26,8 @@ from ..util import filter_array, hoys_mask, check_array_dim, \
 from .. import type_hints
 from ..dynamic import DynamicSchedule, ApertureGroupSchedule
 
+is_cpu = not is_gpu
+
 
 class _ResultsFolder(object):
     """Base class for ResultsFolder.
@@ -239,14 +246,14 @@ class _ResultsFolder(object):
     def _get_sun_up_hours_mask(self) -> List[int]:
         """Get a sun up hours masking array of the study hours."""
         sun_up_hours_mask = \
-            np.where(np.isin(self.study_hours, self.sun_up_hours))[0]
+            np.where(np.isin(np.array(self.study_hours), np.array(self.sun_up_hours)))[0]
 
         return sun_up_hours_mask
 
     def _get_sun_down_hours_mask(self) -> List[int]:
         """Get a sun down hours masking array of the study hours."""
         sun_down_hours_mask = \
-            np.where(~np.isin(self.study_hours, self.sun_up_hours))[0]
+            np.where(~np.isin(np.array(self.study_hours), np.array(self.sun_up_hours)))[0]
 
         return sun_down_hours_mask
 
@@ -277,10 +284,11 @@ class Results(_ResultsFolder):
         * datatype
         * unit
         * cache_arrays
+        * use_gpu
     """
     __slots__ = ('_schedule', '_occ_pattern', '_total_occ', '_sun_down_occ_hours',
                  '_occ_mask', '_arrays', '_valid_states', '_datatype', '_unit',
-                 '_cache_arrays')
+                 '_cache_arrays', '_use_gpu')
 
     def __init__(self, folder, datatype: DataTypeBase = None,
                  schedule: list = None, unit: str = None,
@@ -958,19 +966,23 @@ class Results(_ResultsFolder):
             values: A list of values to map to an annual array. This can be a
                 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.
+            base_value: A value that will be applied for the base array.
             dtype: A NumPy dtype for the annual array.
 
         Returns:
             A 1D NumPy array.
         """
-        values = np.array(values)
+        if not isinstance(values, np.ndarray):
+            values = np.array(values)
+        if not isinstance(hours, np.ndarray):
+            hours = np.array(hours)
         check_array_dim(values, 1)
-        hours = np.array(hours)
         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(dtype)
+
+        full_ap = np.array(AnalysisPeriod(timestep=timestep).hoys)
+        indices = np.where(np.isin(full_ap, hours))[0]
+        annual_array = np.repeat(np.array(base_value), 8760 * timestep).astype(dtype)
+
         annual_array[indices] = values
 
         return annual_array
@@ -1019,7 +1031,6 @@ class Results(_ResultsFolder):
         grid_id = grid_info['full_id']
 
         state_identifier = self._state_identifier(grid_id, light_path, state=state)
-
         try:
             array = self.arrays[grid_id][light_path][state_identifier][res_type]
         except Exception:
@@ -1064,6 +1075,7 @@ class Results(_ResultsFolder):
         state_identifier = self._state_identifier(grid_id, light_path, state=state)
         file = self._get_file(grid_id, light_path, state_identifier, res_type,
                               extension=extension)
+
         array = np.load(file)
 
         if self.cache_arrays:
@@ -1073,12 +1085,12 @@ class Results(_ResultsFolder):
 
         return array
 
-    def _clear_cached_arrays(self, res_type: str = None):
+    def clear_cached_arrays(self, res_type: str = None):
         """Clear the cached arrays.
         
-        This method will simply set the arrays property to an empty dictionary,
-        unless the res_type is selected in which case only 'total' or 'direct'
-        arrays will be deleted.
+        This method will simply clear the arrays property to remove arrays from
+        memory, unless the res_type is selected in which case only 'total' or
+        'direct' arrays will be deleted.
         
         Args:
             res_type: Which type of results to clear. This can be either
@@ -1276,29 +1288,37 @@ class Results(_ResultsFolder):
                     grid_info, light_path, state=state, res_type=res_type)
                 arrays.append(array)
             else:
-                # 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 np.unique(states_array):
-                    if state == -1:
-                        # if state is -1 we continue since it is "turned off"
-                        continue
+                    np.array(self.sun_up_hours, int)]
+
+                unique_states = np.unique(states_array)
+                unique_states = unique_states[unique_states != -1]  # skip -1
+                temp_arrays = []
+                for state in unique_states:
+                    state = int(state)
                     # load static array (state is static)
                     _array = self._get_array(
                         grid_info, light_path, state=state, res_type=res_type)
                     # get indices and add values to base array
-                    states_indicies = states_array == state
-                    array[:, states_indicies] += _array[:, states_indicies]
+                    state_indices = (states_array == state)
+                    masked_array = np.zeros_like(_array)
+                    masked_array[:, state_indices] = _array[:, state_indices]
+                    temp_arrays.append(masked_array)
+                if temp_arrays:
+                    array = np.sum(np.stack(temp_arrays), axis=0)
+                else:
+                    array = np.zeros((grid_info['count'], len(self.sun_up_hours)))
                 arrays.append(array)
-        array = sum(arrays)
+
+        if len(arrays) == 0:
+            array = np.zeros((grid_info['count'], len(self.sun_up_hours)))
+        else:
+            array = np.sum(np.stack(arrays, axis=0), axis=0)
 
         if not np.any(array):
-            if zero_array:
-                array = np.zeros((grid_info['count'], len(self.sun_up_hours)))
-            else:
-                array = np.array([])
+            if not zero_array:
+                array = np.asarray([])
 
         return array
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/type_hints.py

@@ -1,8 +1,15 @@
 """Type hints for honeybee-radiance-postprocess."""
 from typing import Tuple, List
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
+
 from ladybug.datacollection import HourlyContinuousCollection
 
+
 annual_metric = Tuple[List[np.ndarray], List[dict]]
 annual_daylight_metrics = Tuple[
     List[np.ndarray],

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess/util.py

@@ -1,9 +1,16 @@
 """Post-processing utility functions."""
 from typing import Tuple
-import numpy as np
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
 
 from honeybee_radiance.writer import _filter_by_pattern
 
+is_cpu = not is_gpu
+
 
 def binary_mtx_dimension(filepath: str) -> Tuple[int, int, int, int, str]:
     """Return binary Radiance matrix dimensions if exist.
@@ -68,6 +75,27 @@ def check_array_dim(array: np.ndarray, dim: int):
         f'Expected {dim}-dimensional array. Dimension of array is {array.ndim}'
 
 
+def filter_array2d(array: np.ndarray, mask: np.ndarray) -> np.ndarray:
+    """Filter a NumPy array by a masking array. The array will be passed as is
+    if the mask is None.
+
+    Args:
+        array: A NumPy array to filter.
+        mask: A NumPy array of ones/zeros or True/False.
+
+    Returns:
+        A filtered NumPy array.
+    """
+    if is_cpu:
+        array_filter = np.apply_along_axis(
+            filter_array, 1, array, mask=mask)
+    else:
+        mask = np.asarray(mask).astype(bool)
+        array_filter = array[:, mask]
+
+    return array_filter
+
+
 def filter_array(array: np.ndarray, mask: np.ndarray) -> np.ndarray:
     """Filter a NumPy array by a masking array. The array will be passed as is
     if the mask is None.
@@ -95,7 +123,7 @@ def hoys_mask(sun_up_hours: list, hoys: list) -> np.ndarray:
         A NumPy array of booleans.
     """
     if len(hoys) != 0:
-        hoys_mask = np.where(np.isin(sun_up_hours, hoys), True, False)
+        hoys_mask = np.where(np.isin(np.array(sun_up_hours), np.array(hoys)), True, False)
         return hoys_mask
 
 

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.544}/honeybee_radiance_postprocess.egg-info/PKG-INFO

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