honeybee-grasshopper-radiance 1.35.1__py3-none-any.whl

honeybee_grasshopper_radiance/src/HB Annual Peak Values.py

@@ -0,0 +1,224 @@
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Get peak irradiance or sum of illuminance values over an annual irradiance or
+daylight simulation.
+_
+The _hoys_ input can also be used to filter the data for a particular time period or
+hour/timestep of the simulation.
+
+-
+    Args:
+        _results: An list of annual Radiance result files from either the "HB Annual Daylight"
+            or the "HB Annual Irradiance" component (containing the .ill files and
+            the sun-up-hours.txt). This can also be just the path to the folder
+            containing these result files.
+        dyn_sch_: Optional dynamic Aperture Group Schedules from the "HB Aperture Group
+            Schedule" component, which will be used to customize the behavior
+            of any dyanmic aperture geometry in the output metrics. If unsupplied,
+            all dynamic aperture groups will be in their default state in for
+            the output metrics.
+        _hoys_: An optional numbers or list of numbers to select the hours of the year (HOYs)
+            for which results will be computed. These HOYs can be obtained from the
+            "LB Calculate HOY" or the "LB Analysis Period" components. If None, all
+            hours of the results will be used.
+        grid_filter_: The name of a grid or a pattern to filter the grids. For instance,
+            first_floor_* will simulate only the sensor grids that have an
+            identifier that starts with first_floor_. By default all the grids
+            will be processed.
+        coincident_: Boolean to indicate whether output values represent the the peak
+            value for each sensor throughout the entire analysis (False) or
+            they represent the highest overall value across each sensor grid
+            at a particular timestep (True). (Default: False).
+
+    Returns:
+        report: Reports, errors, warnings, etc.
+        hoys: An integer for each sesnor grid that represents the hour of the year at
+            which the peak occurs. This will be None unless coincident_ is
+            set to True.
+        values: Peak illuminance or irradiance valules for each sensor in lux or W/m2.
+            Each value is for a different sensor of the grid. These can be plugged
+            into the "LB Spatial Heatmap" component along with meshes of the sensor
+            grids to visualize results.
+"""
+
+ghenv.Component.Name = 'HB Annual Peak Values'
+ghenv.Component.NickName = 'PeakValues'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '4 :: Results'
+ghenv.Component.AdditionalHelpFromDocStrings = '2'
+
+import os
+import subprocess
+
+try:
+    from ladybug.futil import write_to_file
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e))
+
+try:
+    from honeybee.config import folders
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:
+    from honeybee_radiance.postprocess.annualdaylight import _process_input_folder
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:
+    from honeybee_radiance_postprocess.dynamic import DynamicSchedule
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:
+    from pollination_handlers.outputs.helper import read_sensor_grid_result
+except ImportError as e:
+    raise ImportError('\nFailed to import pollination_handlers:\n\t{}'.format(e))
+
+try:
+    from ladybug_rhino.grasshopper import all_required_inputs, list_to_data_tree, \
+        give_warning
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+def parse_sun_up_hours(sun_up_hours, hoys, timestep):
+    """Parse the sun-up hours from the result file .txt file.
+
+    Args:
+        sun_up_hours: A list of integers for the sun-up hours.
+        hoys: A list of 8760 * timestep values for the hoys to select. If an empty
+            list is passed, None will be returned.
+        timestep: Integer for the timestep of the analysis.
+    """
+    if len(hoys) != 0:
+        schedule = [False] * (8760 * timestep)
+        for hr in hoys:
+            schedule[int(hr * timestep)] = True
+        su_pattern = [schedule[int(h * timestep)] for h in sun_up_hours]
+        return su_pattern
+
+
+def peak_values(ill_file, su_pattern, coincident):
+    """Compute average values for a given result file."""
+    max_vals, max_i = [], None
+    with open(ill_file) as results:
+        if coincident:
+            all_values = [[float(r) for r in pt_res.split()] for pt_res in results] \
+                if su_pattern is None else \
+                [[float(r) for r, is_hoy in zip(pt_res.split(), su_pattern) if is_hoy]
+                 for pt_res in results]
+            max_val, max_i = 0, 0
+            for i, t_step in enumerate(zip(*all_values)):
+                tot_val = sum(t_step)
+                if tot_val > max_val:
+                    max_val = tot_val
+                    max_i = i
+            for sensor in all_values:
+                max_vals.append(sensor[max_i])
+        else:
+            if su_pattern is None:  # no HOY filter on results
+                for pt_res in results:
+                    values = [float(r) for r in pt_res.split()]
+                    max_vals.append(max(values))
+            else:
+                for pt_res in results:
+                    values = [float(r) for r, is_hoy in zip(pt_res.split(), su_pattern) if is_hoy]
+                    max_vals.append(max(values))
+    return max_vals, max_i
+
+
+if all_required_inputs(ghenv.Component):
+    # set up the default values
+    grid_filter_ = '*' if grid_filter_ is None else grid_filter_
+    res_folder = os.path.dirname(_results[0]) if os.path.isfile(_results[0]) \
+        else _results[0]
+
+    # check to see if results use the newer numpy arrays
+    if os.path.isdir(os.path.join(res_folder, '__static_apertures__')) or \
+            os.path.isfile(os.path.join(res_folder, 'grid_states.json')):
+        cmds = [folders.python_exe_path, '-m', 'honeybee_radiance_postprocess',
+                'post-process', 'peak-values', res_folder, '-sf', 'metrics']
+        if len(_hoys_) != 0:
+            hoys_str = '\n'.join(str(h) for h in _hoys_)
+            hoys_file = os.path.join(res_folder, 'hoys.txt')
+            write_to_file(hoys_file, hoys_str)
+            cmds.extend(['--hoys-file', hoys_file])
+        if grid_filter_ != '*':
+            cmds.extend(['--grids-filter', grid_filter_])
+        if coincident_:
+            cmds.append('--coincident')
+        if len(dyn_sch_) != 0:
+            if os.path.isfile(os.path.join(res_folder, 'grid_states.json')):
+                dyn_sch = dyn_sch_[0] if isinstance(dyn_sch_[0], DynamicSchedule) else \
+                    DynamicSchedule.from_group_schedules(dyn_sch_)
+                dyn_sch_file = dyn_sch.to_json(folder=res_folder)
+                cmds.extend(['--states', dyn_sch_file])
+            else:
+                msg = 'No dynamic aperture groups were found in the Model.\n' \
+                    'The input dynamic schedules will be ignored.'
+                print(msg)
+                give_warning(ghenv.Component, msg)
+        use_shell = True if os.name == 'nt' else False
+        custom_env = os.environ.copy()
+        custom_env['PYTHONHOME'] = ''
+        process = subprocess.Popen(
+            cmds, cwd=res_folder, shell=use_shell, env=custom_env,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout = process.communicate()  # wait for the process to finish
+        if stdout[-1] != '':
+            print(stdout[-1])
+            raise ValueError('Failed to compute peak values.')
+        avg_dir = os.path.join(res_folder, 'metrics', 'peak_values')
+        if os.path.isdir(avg_dir):
+            values = read_sensor_grid_result(avg_dir, 'peak','full_id', False)
+            values = list_to_data_tree(values)
+            with open(os.path.join(avg_dir, 'max_hoys.txt'), 'r') as max_hoys:
+                hoys = [line.rstrip() for line in max_hoys.readlines()]
+            if coincident_:
+                hoys = map(int, hoys)
+            else:
+                hoys = [None] * len(hoys)
+
+    else:
+        if len(dyn_sch_) != 0:
+            msg = 'Dynamic Schedules are currently only supported for Annual Daylight ' \
+                'simulations.\nThe input schedules will be ignored.'
+            print(msg)
+            give_warning(ghenv.Component, msg)
+
+        # extract the timestep if it exists
+        timestep = 1
+        tstep_file = os.path.join(res_folder, 'timestep.txt')
+        if os.path.isfile(tstep_file):
+            with open(tstep_file) as tf:
+                timestep = int(tf.readline())
+
+        # parse the sun-up-hours
+        grids, sun_up_hours = _process_input_folder(res_folder, grid_filter_)
+        su_pattern = parse_sun_up_hours(sun_up_hours, _hoys_, timestep)
+        filt_suh = [suh for suh in sun_up_hours if int(suh) in _hoys_] \
+            if len(_hoys_) != 0 else sun_up_hours
+        # compute the average values
+        values, hoys = [], []
+        for grid_info in grids:
+            ill_file = os.path.join(res_folder, '%s.ill' % grid_info['full_id'])
+            dgp_file = os.path.join(res_folder, '%s.dgp' % grid_info['full_id'])
+            if os.path.isfile(dgp_file):
+                max_list, max_i = peak_values(dgp_file, su_pattern, coincident_)
+            else:
+                max_list, max_i = peak_values(ill_file, su_pattern, coincident_)
+            values.append(max_list)
+            if max_i is not None:
+                hoys.append(filt_suh[max_i])
+            else:
+                hoys.append(max_i)
+        values = list_to_data_tree(values)

honeybee_grasshopper_radiance/src/HB Annual Results to Data.py

@@ -0,0 +1,246 @@
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Import the hourly illuminance or irradiance results of an annual daylight or irradiance
+study to a list of data collections.
+_
+The resulting data collections can be visulized using the ladybug components or
+deconstructed for detailed analysis with native Grasshopper math components.
+
+-
+    Args:
+        _results: An list of annual Radiance result files from the "HB Annual Daylight"
+            component (containing the .ill files and the sun-up-hours.txt).
+            This can also be just the path to the folder containing these
+            result files.
+        dyn_sch_: Optional dynamic Aperture Group Schedules from the "HB Aperture Group
+            Schedule" component, which will be used to customize the behavior
+            of any dyanmic aperture geometry in the output metrics. If unsupplied,
+            all dynamic aperture groups will be in their default state in for
+            the output metrics.
+        _sel_pts: A point or list of points, which will be used to filter the sensors
+            for which data collections will be imported.
+        _all_pts: The data tree of all sensor points that were used in the simulation.
+            This is required in order to look up the index of the _sel_pts in
+            the results matrices.
+        sel_vecs_: An optional vector or list of vectors, which will be used to filter
+            the sensors for which data collections will be imported. If there
+            is an input here, the all_vecs_ must be connected.
+        all_vecs_: The data tree of all sensor directions that were used in the simulation.
+            This is required in order to look up the index of the sel_vecs_ in
+            the results matrices. 
+
+ Returns:
+        report: Reports, errors, warnings, etc.
+        data: A list of hourly data collections containing illuminance or irradiance results.
+            These can be visulized using the ladybug components or deconstructed
+            for detailed analysis with native Grasshopper math components.
+"""
+
+ghenv.Component.Name = 'HB Annual Results to Data'
+ghenv.Component.NickName = 'AnnualToData'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '4 :: Results'
+ghenv.Component.AdditionalHelpFromDocStrings = '2'
+
+import os
+import json
+import subprocess
+
+try:
+    from ladybug.datatype.illuminance import Illuminance
+    from ladybug.datatype.energyflux import Irradiance
+    from ladybug.datatype.time import Time
+    from ladybug.datatype.fraction import Fraction
+    from ladybug.analysisperiod import AnalysisPeriod
+    from ladybug.header import Header
+    from ladybug.datacollection import HourlyContinuousCollection
+    from ladybug.futil import write_to_file
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e))
+
+try:
+    from honeybee.config import folders
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:
+    from honeybee_radiance.postprocess.annualdaylight import _process_input_folder
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:
+    from honeybee_radiance_postprocess.dynamic import DynamicSchedule
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:
+    from ladybug_rhino.config import tolerance
+    from ladybug_rhino.togeometry import to_point3d, to_vector3d
+    from ladybug_rhino.grasshopper import all_required_inputs, list_to_data_tree, \
+        data_tree_to_list, give_warning
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+def file_to_data(ill_file, point_filter, su_pattern, header, timestep, grid_id):
+    """Get a list of data collections for a given result file."""
+    data_colls = []
+    new_header = header.duplicate()
+    new_header.metadata['sensor grid'] = grid_id
+    with open(ill_file) as results:
+        if point_filter is None:
+            for pt_res in results:
+                base_values = [0] * 8760 * timestep
+                for val, hr in zip(pt_res.split(), su_pattern):
+                    base_values[hr] = float(val)
+                data_colls.append(HourlyContinuousCollection(new_header, base_values))
+        else:
+            for i, pt_res in enumerate(results):
+                if i in point_filter:
+                    new_header = new_header.duplicate()
+                    new_header.metadata['sensor index'] = i
+                    base_values = [0] * 8760 * timestep
+                    for val, hr in zip(pt_res.split(), su_pattern):
+                        base_values[hr] = float(val)
+                    data_colls.append(HourlyContinuousCollection(new_header, base_values))
+    return data_colls
+
+
+def find_point_in_grid(s_pt, all_pts):
+    """Find the index of a point in a list of list of grids."""
+    m_pts = []
+    for i, grid_pts in enumerate(all_pts):
+        for j, g_pt in enumerate(grid_pts):
+            if g_pt.is_equivalent(s_pt, tolerance):
+                m_pts.append((i, j))
+    return m_pts
+
+
+def find_vec_in_grid(s_v, all_vecs, pt_filter):
+    """Find the index of a vector in a list of list of grids."""
+    m_vecs = []
+    for i, grid in enumerate(pt_filter):
+        for j in grid:
+            if all_vecs[i][j].is_equivalent(s_v, tolerance):
+                m_vecs.append((i, j))
+    return m_vecs
+
+
+if all_required_inputs(ghenv.Component):
+    # get the relevant .ill files
+    res_folder = os.path.dirname(_results[0]) if os.path.isfile(_results[0]) \
+        else _results[0]
+    grids, sun_up_hours = _process_input_folder(res_folder, '*')
+
+    # set up the sensor filter
+    pt_filter = [None for i in grids]
+    if len(_sel_pts) != 0 or len(sel_vecs_) != 0:
+        pt_filter = [[] for i in grids]
+
+    # check the sel_pts and all_pts input
+    if len(_sel_pts) != 0:
+        all_pts = [[to_point3d(pt) for pt in dat[-1]] for dat in data_tree_to_list(_all_pts)]
+        assert len(all_pts) != 0, '_all_pts must be connected in order to use _sel_pts.'
+        sel_pts = [to_point3d(pt) for pt in _sel_pts]
+        for s_pt in sel_pts:
+            m_pts = find_point_in_grid(s_pt, all_pts)
+            for i, j in m_pts:
+                pt_filter[i].append(j)
+
+    # check the sel_vecs and all_vecs input
+    if len(sel_vecs_) != 0:
+        new_pt_filter = [[] for i in grids]
+        all_vecs = [[to_vector3d(v) for v in dat[-1]] for dat in data_tree_to_list(all_vecs_)]
+        assert len(all_vecs) != 0, 'all_vecs_ must be connected in order to use sel_vecs_.'
+        sel_vecs = [to_vector3d(v) for v in sel_vecs_]
+        for s_v in sel_vecs:
+            m_vs = find_point_in_grid(s_v, all_vecs) if len(_sel_pts) == 0 else \
+                find_vec_in_grid(s_v, all_vecs, pt_filter)
+            for i, j in m_vs:
+                new_pt_filter[i].append(j)
+        pt_filter = new_pt_filter
+
+    # check to see if results use the newer numpy arrays
+    if os.path.isdir(os.path.join(res_folder, '__static_apertures__'))  or \
+            os.path.isfile(os.path.join(res_folder, 'grid_states.json')):
+        cmds = [folders.python_exe_path, '-m', 'honeybee_radiance_postprocess',
+                'post-process', 'annual-to-data', res_folder]
+        if pt_filter[0] is not None:
+            sen_dict = {g['full_id']: s_ind for g, s_ind in zip(grids, pt_filter)}
+            si_file = os.path.join(res_folder, 'sensor_indices.json')
+            write_to_file(si_file, json.dumps(sen_dict))
+            cmds.extend(['--sensor-index', si_file])
+        if len(dyn_sch_) != 0:
+            if os.path.isfile(os.path.join(res_folder, 'grid_states.json')):
+                dyn_sch = dyn_sch_[0] if isinstance(dyn_sch_[0], DynamicSchedule) else \
+                    DynamicSchedule.from_group_schedules(dyn_sch_)
+                dyn_sch_file = dyn_sch.to_json(folder=res_folder)
+                cmds.extend(['--states', dyn_sch_file])
+            else:
+                msg = 'No dynamic aperture groups were found in the Model.\n' \
+                    'The input dynamic schedules will be ignored.'
+                print(msg)
+                give_warning(ghenv.Component, msg)
+        use_shell = True if os.name == 'nt' else False
+        custom_env = os.environ.copy()
+        custom_env['PYTHONHOME'] = ''
+        process = subprocess.Popen(
+            cmds, cwd=res_folder, shell=use_shell, env=custom_env,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout, stderr = process.communicate()  # wait for the process to finish
+        if stderr != '':
+            print(stderr)
+            raise ValueError('Failed to compute data collections.')
+        data_dicts = json.loads(stdout)
+        data = [[HourlyContinuousCollection.from_dict(d) for d in data]
+                for data in data_dicts]
+        data = list_to_data_tree(data)
+
+    else:
+        if len(dyn_sch_) != 0:
+            msg = 'Dynamic Schedules are currently only supported for Annual Daylight ' \
+                'simulations.\nThe input schedules will be ignored.'
+            print(msg)
+            give_warning(ghenv.Component, msg)
+
+        # extract the timestep if it exists
+        timestep, has_t_step = 1, False
+        tstep_file = os.path.join(res_folder, 'timestep.txt')
+        if os.path.isfile(tstep_file):  # it's an annual irradiance simulation
+            with open(tstep_file) as tf:
+                timestep = int(tf.readline())
+            has_t_step = True
+
+        # parse the sun-up-hours
+        sun_up_hours = [int(h * timestep) for h in sun_up_hours]
+
+        # create the header that will be used for all of the data collections
+        aper = AnalysisPeriod(timestep=timestep)
+        if 'direct_sun_hours' in res_folder:
+            head = Header(Time(), 'hr', aper)
+        elif has_t_step:
+            head = Header(Irradiance(), 'W/m2', aper)
+        else:
+            head = Header(Illuminance(), 'lux', aper)
+        dgp_head = Header(Fraction(), 'fraction', aper, metadata={'type': 'Daylight Glare Probability (DGP)'})
+
+        # create the data collections from the .ill files
+        data = []
+        for grid_info, p_filt in zip(grids, pt_filter):
+            grid_id = grid_info['full_id']
+            ill_file = os.path.join(res_folder, '%s.ill' % grid_id)
+            dgp_file = os.path.join(res_folder, '%s.dgp' % grid_id)
+            if os.path.isfile(dgp_file):
+                data_list = file_to_data(dgp_file, p_filt, sun_up_hours, dgp_head, timestep, grid_id)
+            else:
+                data_list = file_to_data(ill_file, p_filt, sun_up_hours, head, timestep, grid_id)
+            data.append(data_list)
+        data = list_to_data_tree(data)

honeybee_grasshopper_radiance/src/HB Annual Sunlight Exposure.py

@@ -0,0 +1,147 @@
+# Honeybee: A Plugin for Environmental Analysis (GPL)
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Calculate Annual Sunlight Exposure from a results folder.
+_
+Note: This component will only output a LEED compliant ASE if you've run the
+simulation with all operable shading devices retracted. If you are using
+results with operable shading devices, then this output is NOT LEED compliant.
+
+-
+    Args:
+        _results: An annual results folder containing direct illuminance results.
+            This can be the output of the "HB Annual Daylight" component. This can
+            also be just the path to the results folder.
+        _occ_sch_: An annual occupancy schedule as a Ladybug Data Collection or a HB-Energy
+            schedule object. This can also be the identifier of a schedule in
+            your HB-Energy schedule library. Any value in this schedule that is
+            0.1 or above will be considered occupied. If None, a schedule from
+            8AM to 6PM on all days will be used.
+        _threshold_: The threshold (lux) that determines if a sensor is
+            overlit (default: 1000).
+        _target_hrs_: The number of occupied hours that cannot receive higher
+            illuminance than the direct threshold (default: 250).
+        grid_filter_: The name of a grid or a pattern to filter the grids. For instance,
+            first_floor_* will simulate only the sensor grids that have an
+            identifier that starts with first_floor_. By default all the grids
+            will be processed.
+
+    Returns:
+        report: Reports, errors, warnings, etc.
+        ASE: Annual sunlight exposure as a percentage for each sensor grid.
+        hrs_above: The number of hours above the threshold for each sensor point.
+            These can be plugged into the "LB Spatial Heatmap" component along with
+            meshes of the sensor grids to visualize results.
+"""
+
+ghenv.Component.Name = "HB Annual Sunlight Exposure"
+ghenv.Component.NickName = 'ASE'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '4 :: Results'
+ghenv.Component.AdditionalHelpFromDocStrings = '1'
+
+import os
+import subprocess
+
+try:
+    from ladybug.datacollection import BaseCollection
+    from ladybug.futil import write_to_file
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e))
+
+try:
+    from honeybee.config import folders
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:
+    from honeybee_energy.lib.schedules import schedule_by_identifier
+except ImportError as e:  # honeybee schedule library is not available
+    schedule_by_identifier = None
+
+try:
+    from pollination_handlers.outputs.daylight import read_ase_from_folder, \
+        read_hours_from_folder
+except ImportError as e:
+    raise ImportError('\nFailed to import pollination_handlers:\n\t{}'.format(e))
+
+try:
+    from ladybug_rhino.grasshopper import all_required_inputs, list_to_data_tree
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    # set default values for the thresholds and the grid filter
+    grid_filter_ = '*' if grid_filter_ is None else grid_filter_
+    _direct_threshold_ = _threshold_ if _threshold_ else 1000
+    _occ_hours_ = _target_hrs_ if _target_hrs_ else 250
+
+    # process the schedule
+    if _occ_sch_ is None:
+        schedule = None
+    elif isinstance(_occ_sch_, BaseCollection):
+        schedule = _occ_sch_.values
+    elif isinstance(_occ_sch_, str):
+        if schedule_by_identifier is not None:
+            try:
+                schedule = schedule_by_identifier(_occ_sch_).values()
+            except TypeError:  # it's probably a ScheduleFixedInterval
+                schedule = schedule_by_identifier(_occ_sch_).values
+        else:
+            raise ValueError('honeybee-energy must be installed to reference '
+                             'occupancy schedules by identifier.')
+    else:  # assume that it is a honeybee schedule object
+        try:
+            schedule = _occ_sch_.values()
+        except TypeError:  # it's probably a ScheduleFixedInterval
+            schedule = _occ_sch_.values
+    if schedule is not None:
+        bin_schedule = []
+        for val in schedule:
+            bin_val = 1 if val >= 0.1 else 0
+            bin_schedule.append(bin_val)
+        schedule = bin_schedule
+
+    # compute the annual metrics
+    res_folder = os.path.dirname(_results[0]) if os.path.isfile(_results[0]) \
+        else _results[0]
+    if os.path.isfile(os.path.join(res_folder, 'grid_states.json')):
+        cmds = [
+            folders.python_exe_path, '-m', 'honeybee_radiance_postprocess',
+            'post-process', 'annual-sunlight-exposure', res_folder, '-sf', 'metrics',
+            '-dt', str(_direct_threshold_), '-oh', str(_occ_hours_)
+        ]
+        if grid_filter_ != '*':
+            cmds.extend(['--grids-filter', grid_filter_])
+        if schedule is not None:
+            sch_str = '\n'.join(str(h) for h in schedule)
+            sch_file = os.path.join(res_folder, 'schedule.txt')
+            write_to_file(sch_file, sch_str)
+            cmds.extend(['--schedule', sch_file])
+        use_shell = True if os.name == 'nt' else False
+        custom_env = os.environ.copy()
+        custom_env['PYTHONHOME'] = ''
+        process = subprocess.Popen(
+            cmds, cwd=res_folder, shell=use_shell, env=custom_env,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout = process.communicate()  # wait for the process to finish
+        if stdout[-1] != '':
+            print(stdout[-1])
+            raise ValueError('Failed to compute annual sunlight exposure.')
+        metric_dir = os.path.join(res_folder, 'metrics')
+        ASE = read_ase_from_folder(os.path.join(metric_dir, 'ase'))
+        hrs_above = list_to_data_tree(read_hours_from_folder(os.path.join(metric_dir, 'hours_above')))
+    else:
+        raise ValueError(
+            'Invalid results folder!\n'
+            'Make sure an enhanced daylight simulation was run'
+        )

honeybee_grasshopper_radiance/src/HB Aperture Group Schedule.py

@@ -0,0 +1,69 @@
+# Honeybee: A Plugin for Environmental Analysis (GPL)
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Create a Dynamic Aperture Group Schedule, which can be used to process any dynamic
+aperture geometry that was run in an annual simulation.
+
+-
+    Args:
+        _group_aps: Honeybee Apertures that are a part of the same dynamic group and will
+            be assigned the same schedule for postprocessing. Typically, this is
+            the output of the "HB Dynamic Aperture Group" component but it can
+            also be the output of the "HB Get Dynamic Groups" component, which
+            returns all of the dynamic groups on a particular Model.
+        _schedule: A list of 8760 integers refering to the index of the aperture group state
+            to be used at each hour of the simulation. This can also be a single integer
+            for a static state to be used for the entire period of the simulation
+            or a pattern of integers that is less than 8760 in length and will be
+            repeated until the 8760 is reached. Note that 0 refers to the first
+            state, 1 refers to the second state, and so on. -1 can be used to
+            completely discout the aperture from the simulation for a given hour.
+
+    Returns:
+        dyn_sch: A dynamic schedule object for the input aperture group, which can be plugged
+            into any of the Results components with a syn_sch input.
+"""
+
+ghenv.Component.Name = 'HB Aperture Group Schedule'
+ghenv.Component.NickName = 'GroupSch'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '4 :: Results'
+ghenv.Component.AdditionalHelpFromDocStrings = '1'
+
+try:
+    from honeybee.aperture import Aperture
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:
+    from honeybee_radiance_postprocess.dynamic import ApertureGroupSchedule
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:
+    from ladybug_rhino.grasshopper import all_required_inputs, recipe_result
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    dyn_sch = []
+    dyn_ids = set()
+    for ap in _group_aps:
+        assert isinstance(ap, Aperture), 'Expected Aperture. Got {}.'.format(type(ap))
+        dyn_grp_id = ap.properties.radiance.dynamic_group_identifier
+        if dyn_grp_id is None:
+            raise ValueError(
+                'Input Aperture "{}" is not a part of a dynamic group.'.format(ap.display_name))
+        if dyn_grp_id not in dyn_ids:
+            dyn_ids.add(dyn_grp_id)
+            _ap_group_sch = ApertureGroupSchedule(dyn_grp_id, _schedule)
+            dyn_sch.append(_ap_group_sch)