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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: honeybee-radiance-postprocess
-Version: 0.4.543
+Version: 0.4.545
 Summary: Postprocessing of Radiance results and matrices
 Home-page: https://github.com/ladybug-tools/honeybee-radiance-postprocess
 Author: Ladybug Tools
@@ -13,7 +13,7 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: honeybee-radiance==1.66.182
+Requires-Dist: honeybee-radiance==1.66.183
 Requires-Dist: numpy<2.0.0
 
 [![Build Status](https://github.com/ladybug-tools/honeybee-radiance-postprocess/actions/workflows/ci.yaml/badge.svg)](https://github.com/ladybug-tools/honeybee-radiance-postprocess/actions)

{honeybee_radiance_postprocess-0.4.543 → honeybee_radiance_postprocess-0.4.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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.545}/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__':