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

honeybee_grasshopper_radiance/src/HB Sensor Grid from Faces.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>
+
+"""
+Generate SensorGrid objects from exterior Faces (Walls, Roofs, and Floors).
+_
+These SensorGrids can be used in any grid-based recipe and are particularly useful
+for radiation studies of roofs for photovoltaic potential or solar gain studies
+of walls.
+-
+
+    Args:
+        _hb_objs: A list of honeybee Faces or Rooms for which sensor grids will be
+            generated. This can also be an entire Honeybee Model.
+        _grid_size: Number for the size of the grid cells.
+        _offset_: Number for the distance to move points from the base geometry.
+            The default is 0.1 meters.
+        _face_type_: Text or an integer to specify the type of face that will be used to
+            generate grids. Note that only Faces with Outdoors boundary conditions
+            will be used, meaning that most Floors will typically be
+            excluded unless they represent the underside of a cantilever.
+            Choose from the following. (Default: Wall).
+                * 1 - Wall
+                * 2 - Roof
+                * 3 - Floor
+                * 4 - All
+        punched_: Boolean to note whether the punched_geometry of the faces
+            should be used (True) with the areas of sub-faces removed from the grid
+            or the full geometry should be used (False). (Default:False).
+        quad_only_: Boolean to note whether meshing should be done using Rhino's
+            defaults (False), which fills the entire face geometry to the edges
+            with both quad and tringulated faces, or a mesh with only quad
+            faces should be generated. (Default: False).
+
+    Returns:
+        grid: A SensorGrid object that can be used in a grid-based recipe.
+        points: The points that are at the center of each grid cell.
+        mesh: Analysis mesh that can be passed to the 'Spatial Heatmap' component.
+"""
+
+ghenv.Component.Name = 'HB Sensor Grid from Faces'
+ghenv.Component.NickName = 'GridFaces'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '0 :: Basic Properties'
+ghenv.Component.AdditionalHelpFromDocStrings = '0'
+
+try:  # import the ladybug_geometry dependencies
+    from ladybug_geometry.geometry3d.mesh import Mesh3D
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_geometry:\n\t{}'.format(e))
+
+try:  # import the core honeybee dependencies
+    from honeybee.model import Model
+    from honeybee.room import Room
+    from honeybee.face import Face
+    from honeybee.boundarycondition import Outdoors
+    from honeybee.facetype import Floor, Wall, RoofCeiling
+    from honeybee.typing import clean_rad_string, clean_and_id_rad_string
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import the honeybee-radiance dependencies
+    from honeybee_radiance.sensorgrid import SensorGrid
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.config import conversion_to_meters
+    from ladybug_rhino.togeometry import to_joined_gridded_mesh3d
+    from ladybug_rhino.fromgeometry import from_mesh3d, from_point3d, from_face3d
+    from ladybug_rhino.grasshopper import all_required_inputs
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+FACE_TYPES = {
+    '1': Wall,
+    '2': RoofCeiling,
+    '3': Floor,
+    '4': (Wall, RoofCeiling, Floor),
+    'Wall': Wall,
+    'Roof': RoofCeiling,
+    'RoofCeiling': RoofCeiling,
+    'Floor': Floor,
+    'All': (Wall, RoofCeiling, Floor)
+}
+
+
+if all_required_inputs(ghenv.Component):
+    # set defaults for any blank inputs
+    _offset_ = 0.1 / conversion_to_meters() if _offset_ is None else _offset_
+    ft = FACE_TYPES[_face_type_.title()] if _face_type_ is not None else Wall
+
+    # collect all of the relevant faces
+    faces = []
+    for obj in _hb_objs:
+        if isinstance(obj, (Model, Room)):
+            for face in obj.faces:
+                if isinstance(face.boundary_condition, Outdoors) and isinstance(face.type, ft):
+                    faces.append(face)
+        elif isinstance(obj, Face):
+            if isinstance(obj.boundary_condition, Outdoors) and isinstance(obj.type, ft):
+                faces.append(obj)
+        else:
+            raise TypeError('Expected Honeybee Face, Room or Model. Got {}.'.format(type(obj)))
+
+    # greneate the meshes and grids from the faces
+    if len(faces) != 0:
+        # create the gridded ladybug Mesh3D
+        f_geos = [face.punched_geometry for face in faces] if punched_ else \
+            [face.geometry for face in faces]
+        if quad_only_:  # use Ladybug's built-in meshing methods
+            lb_meshes = []
+            for geo in f_geos:
+                try:
+                    lb_meshes.append(geo.mesh_grid(_grid_size, offset=_offset_))
+                except AssertionError:
+                    continue
+            if len(lb_meshes) == 0:
+                lb_mesh = None
+            else:
+                lb_mesh = lb_meshes[0] if len(lb_meshes) == 1 else \
+                    Mesh3D.join_meshes(lb_meshes)
+        else:  # use Rhino's default meshing
+            rh_faces = [from_face3d(face) for face in f_geos]
+            lb_mesh = to_joined_gridded_mesh3d(rh_faces, _grid_size, _offset_)
+
+        if lb_mesh is not None:
+            # extract positions and directions from the mesh
+            mesh = from_mesh3d(lb_mesh)
+            points = [from_point3d(pt) for pt in lb_mesh.face_centroids]
+            base_poss = [(pt.x, pt.y, pt.z) for pt in lb_mesh.face_centroids]
+            base_dirs = [(vec.x, vec.y, vec.z) for vec in lb_mesh.face_normals]
+
+            # create the sensor grid
+            f_nm = 'Faces' if isinstance(ft, tuple) else ft.__name__
+            g_name = clean_rad_string('{}_Exterior{}'.format(_hb_objs[0].display_name, f_nm)) \
+                if len(_hb_objs) == 1 else clean_and_id_rad_string('Exterior{}'.format(f_nm))
+            grid = SensorGrid.from_position_and_direction(g_name, base_poss, base_dirs)
+            grid.mesh = lb_mesh

honeybee_grasshopper_radiance/src/HB Sensor Grid from Rooms.py

@@ -0,0 +1,210 @@
+# 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>
+
+"""
+Generate SensorGrid objects from the floors of honeybee Rooms.
+These SensorGrids can be used in a grid-based recipe.
+-
+The names of the grids will be the same as the rooms that they came from.
+-
+
+    Args:
+        _rooms: A list of honeybee Rooms for which sensor grids will be generated.
+            This can also be an entire Honeybee Model from which Rooms will
+            be extracted.
+        _grid_size: Number for the size of the grid cells.
+        _dist_floor_: Number for the distance to move points from the floors of
+            the input rooms. The default is 0.8 meters.
+        quad_only_: Boolean to note whether meshing should be done using Rhino's
+            defaults (False), which fills the entire floor geometry to the edges
+            with both quad and tringulated faces, or a mesh with only quad
+            faces should be generated.
+            _
+            FOR ADVANCED USERS: This input can also be a vector object that will
+            be used to set the orientation of the quad-only grid. Note that,
+            if a vector is input here that is not aligned with the plane of
+            the room's floors, an error will be raised.
+        remove_out_: Boolean to note whether an extra check should be run to remove
+            sensor points that lie outside the Room volume. Note that this can
+            add significantly to the component's run time and this check is
+            usually not necessary in the case that all walls are vertical
+            and all floors are horizontal (Default: False).
+        wall_offset_: A number for the distance at which sensors close to walls
+            should be removed.
+        by_zone_: Set to "True" to have the component generate one sensor grid per zone
+            across the input rooms rather than one sensor grid per room. This
+            option is useful for getting a more consolidated set of Radiance
+            results by zone. (Default: False).
+
+    Returns:
+        grid: A SensorGrid object that can be used in a grid-based recipe.
+        points: The points that are at the center of each grid cell.
+        mesh: Analysis mesh that can be passed to the 'Spatial Heatmap' component.
+"""
+
+ghenv.Component.Name = 'HB Sensor Grid from Rooms'
+ghenv.Component.NickName = 'GridRooms'
+ghenv.Component.Message = '1.9.1'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '0 :: Basic Properties'
+ghenv.Component.AdditionalHelpFromDocStrings = '4'
+
+import math
+from collections import OrderedDict
+
+try:  # import the ladybug_geometry dependencies
+    from ladybug_geometry.geometry3d.plane import Plane
+    from ladybug_geometry.geometry3d.face import Face3D
+    from ladybug_geometry.geometry3d.mesh import Mesh3D
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_geometry:\n\t{}'.format(e))
+
+try:  # import the core honeybee dependencies
+    from honeybee.model import Model
+    from honeybee.room import Room
+    from honeybee.facetype import Floor, Wall
+    from honeybee.typing import clean_rad_string
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import the honeybee-radiance dependencies
+    from honeybee_radiance.sensorgrid import SensorGrid
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.config import conversion_to_meters, tolerance
+    from ladybug_rhino.togeometry import to_joined_gridded_mesh3d, to_vector3d
+    from ladybug_rhino.fromgeometry import from_mesh3d, from_point3d, from_face3d
+    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 defaults for any blank inputs and process the quad_only_
+    _dist_floor_ = 0.8 / conversion_to_meters() if _dist_floor_ is None else _dist_floor_
+    try:
+        x_axis = to_vector3d(quad_only_)
+    except AttributeError:
+        x_axis = None
+
+    # create lists to be filled with content
+    grid = []
+    points = []
+    mesh = []
+    rooms = []
+    for obj in _rooms:
+        if isinstance(obj, Model):
+            rooms.extend(obj.rooms)
+        elif isinstance(obj, Room):
+            rooms.append(obj)
+        else:
+            raise TypeError('Expected Honeybee Room or Model. Got {}.'.format(type(obj)))
+
+    # group the rooms by zone if requested
+    if by_zone_:
+        room_groups = OrderedDict()
+        for room in rooms:
+            try:
+                room_groups[room.zone].append(room)
+            except KeyError:  # first room to be found in the zone
+                room_groups[room.zone] = [room]
+    else:
+        room_groups = OrderedDict([(room.identifier, [room]) for room in rooms])
+
+    for zone_id, room_group in room_groups.items():
+        # get all of the floor faces of the room
+        lb_floors = []
+        for room in room_group:
+            lb_floors.extend([floor.geometry.flip() for floor in room.floors])
+
+        if len(lb_floors) != 0:
+            # create the gridded ladybug Mesh3D
+            if quad_only_:  # use Ladybug's built-in meshing methods
+                if x_axis:
+                    lb_floors = [Face3D(f.boundary, Plane(f.normal, f[0], x_axis), f.holes)
+                                 for f in lb_floors]
+                lb_meshes = []
+                for geo in lb_floors:
+                    try:
+                        lb_meshes.append(geo.mesh_grid(_grid_size, offset=_dist_floor_))
+                    except AssertionError:
+                        continue
+                if len(lb_meshes) == 0:
+                    lb_mesh = None
+                else:
+                    lb_mesh = lb_meshes[0] if len(lb_meshes) == 1 else \
+                        Mesh3D.join_meshes(lb_meshes)
+            else:  # use Rhino's default meshing
+                floor_faces = [from_face3d(face) for face in lb_floors]
+                lb_mesh = to_joined_gridded_mesh3d(floor_faces, _grid_size, _dist_floor_)
+
+            # remove points outside of the room volume if requested
+            if remove_out_ and lb_mesh is not None:
+                pattern = []
+                for pt in lb_mesh.face_centroids:
+                    for room in room_group:
+                        if room.geometry.is_point_inside(pt):
+                            pattern.append(True)
+                            break
+                    else:
+                        pattern.append(False)
+                try:
+                    lb_mesh, vertex_pattern = lb_mesh.remove_faces(pattern)
+                except AssertionError:  # the grid lies completely outside of the room
+                    lb_mesh = None
+
+            # remove any sensors within a certain distance of the walls, if requested
+            if wall_offset_ is not None and lb_mesh is not None:
+                wall_geos = []
+                for room in room_group:
+                    wall_geos.extend([wall.geometry for wall in room.walls])
+                pattern = []
+                for pt in lb_mesh.face_centroids:
+                    for wg in wall_geos:
+                        close_pt = wg.plane.closest_point(pt)
+                        p_dist = pt.distance_to_point(close_pt)
+                        if p_dist <= wall_offset_:
+                            close_pt_2d = wg.plane.xyz_to_xy(close_pt)
+                            g_dist = wg.polygon2d.distance_to_point(close_pt_2d)
+                            f_dist = math.sqrt(p_dist ** 2 + g_dist ** 2)
+                            if f_dist <= wall_offset_:
+                                pattern.append(False)
+                                break
+                    else:
+                        pattern.append(True)
+                try:
+                    lb_mesh, vertex_pattern = lb_mesh.remove_faces(pattern)
+                except AssertionError:  # the grid lies completely outside of the room
+                    lb_mesh = None
+
+            if lb_mesh is not None:
+                # extract positions and directions from the mesh
+                base_points = [from_point3d(pt) for pt in lb_mesh.face_centroids]
+                base_poss = [(pt.x, pt.y, pt.z) for pt in lb_mesh.face_centroids]
+                base_dirs = [(vec.x, vec.y, vec.z) for vec in lb_mesh.face_normals]
+
+                # create the sensor grid
+                grid_name = room.display_name if not by_zone_ else zone_id
+                s_grid = SensorGrid.from_position_and_direction(
+                    clean_rad_string(grid_name), base_poss, base_dirs)
+                s_grid.display_name = grid_name
+                s_grid.room_identifier = room_group[0].identifier
+                s_grid.mesh = lb_mesh
+                s_grid.base_geometry = \
+                    tuple(f.move(f.normal * _dist_floor_) for f in lb_floors)
+
+                # append everything to the lists
+                grid.append(s_grid)
+                points.append(base_points)
+                mesh.append(from_mesh3d(lb_mesh))
+
+    # convert the lists of points to data trees
+    points = list_to_data_tree(points)

honeybee_grasshopper_radiance/src/HB Sensor Grid.py

@@ -0,0 +1,82 @@
+# 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 Sensor Grid object that can be used in a grid-based recipe.
+-
+
+    Args:
+        _name_: A name for this sensor grid.
+        _positions: A list or a datatree of points with one point for the position
+            of each sensor. Each branch of the datatree will be considered as a
+            separate sensor grid.
+        _directions_: A list or a datatree of vectors with one vector for the
+            direction of each sensor. The input here MUST therefor align with
+            the input _positions. If no value is provided (0, 0, 1) will be
+            assigned for all the sensors.
+        mesh_: An optional mesh that aligns with the sensors. This is useful for
+            generating visualizations of the sensor grid beyond the sensor
+            positions. Note that the number of sensors in the grid must match
+            the number of faces or the number vertices within the mesh.
+        base_geo_: An optional Brep for the geometry used to make the grid. There are
+            no restrictions on how this brep relates to the sensors and it is
+            provided only to assist with the display of the grid when the number
+            of sensors or the mesh is too large to be practically visualized.
+
+    Returns:
+        grid: An SensorGrid object that can be used in a grid-based recipe.
+"""
+
+ghenv.Component.Name = 'HB Sensor Grid'
+ghenv.Component.NickName = 'SensorGrid'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '0 :: Basic Properties'
+ghenv.Component.AdditionalHelpFromDocStrings = '4'
+
+try:  # import the core honeybee dependencies
+    from honeybee.typing import clean_and_id_rad_string, clean_rad_string
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import the honeybee-radiance dependencies
+    from honeybee_radiance.sensorgrid import SensorGrid
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.grasshopper import all_required_inputs
+    from ladybug_rhino.togeometry import to_mesh3d, to_face3d
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    # set the default name and process the points to tuples
+    name = clean_and_id_rad_string('SensorGrid') if _name_ is None else _name_
+    pts = [(pt.X, pt.Y, pt.Z) for pt in _positions]
+
+    # create the sensor grid object
+    id  = clean_rad_string(name) if '/' not in name else clean_rad_string(name.split('/')[0])
+    if len(_directions_) == 0:
+        grid = SensorGrid.from_planar_positions(id, pts, (0, 0, 1))
+    else:
+        vecs = [(vec.X, vec.Y, vec.Z) for vec in _directions_]
+        grid = SensorGrid.from_position_and_direction(id, pts, vecs)
+
+    # set the display name
+    if _name_ is not None:
+        grid.display_name = _name_
+    if '/' in name:
+        grid.group_identifier = \
+            '/'.join(clean_rad_string(key) for key in name.split('/')[1:])
+    if mesh_ is not None:
+        grid.mesh = to_mesh3d(mesh_)
+    if base_geo_ is not None:
+        grid.base_geometry = to_face3d(base_geo_)

honeybee_grasshopper_radiance/src/HB Shade Modifier Subset.py

@@ -0,0 +1,62 @@
+# 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 list of modifiers that can be used to edit or create a ModifierSet object.
+-
+
+    Args:
+        _exterior_shade_: A modifier object for exterior shades (or text for
+            the identifier of the modifier within the library).
+        _interior_shade_: A modifier object for interior shades (or text for
+            the identifier of the modifier within the library).
+    
+    Returns:
+        shade_set: A list of shade modifiers that can be used to edit or create
+            a ModifierSet object.
+"""
+
+ghenv.Component.Name = 'HB Shade Modifier Subset'
+ghenv.Component.NickName = 'ShadeSubset'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '1 :: Modifiers'
+ghenv.Component.AdditionalHelpFromDocStrings = '4'
+
+try:  # import honeybee_radiance dependencies
+    from honeybee_radiance.modifier import Modifier
+    from honeybee_radiance.lib.modifiers import modifier_by_identifier
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:
+    from ladybug_rhino.grasshopper import turn_off_old_tag
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+turn_off_old_tag(ghenv.Component)
+
+
+def check_mod(mod, input_name):
+    """Get an Modifier from the library if it's a string."""
+    if isinstance(mod, str):
+        return modifier_by_identifier(mod)
+    else:
+        assert isinstance(mod, Modifier), \
+            'Expected Modifier for {}. Got {}'.format(input_name, type(mod))
+    return mod
+
+
+# go through each input modifier
+if _exterior_shade_ is not None:
+    _exterior_shade_ = check_mod(_exterior_shade_, '_exterior_shade_')
+if _interior_shade_ is not None:
+    _interior_shade_ = check_mod(_interior_shade_, '_interior_shade_')
+
+# return the final list from the component
+shade_set = [_exterior_shade_, _interior_shade_]

honeybee_grasshopper_radiance/src/HB Sky View.py

@@ -0,0 +1,86 @@
+# 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>
+
+"""
+Run a Sky View (SV) study for a Honeybee model.
+_
+Sky View is defined as the percent of the sky dome seen by a surface. These can
+be computed either using a uniform (default) sky or a cloudy sky.
+_
+Note that computing cloudy Sky View for a vertically-oriented geometry (horizontal
+sensor direction) will yield Vertical Sky Component (VSC) as described by the UK
+Building Research Establishment (BRE). VSC is defined as the ratio of cloudy sky
+illuminance falling on a vertical wall to the simultaneous horizontal illuminance
+under an unobstructed sky [Littlefair, 1991].
+_
+Also note that this recipe still respects the transparency of objects, reducing
+the percentage of the sky visible through a certain geometry by the transmittance
+of that geometry.
+
+-
+    Args:
+        _model: A Honeybee Model for which Sky View or Wky Exposure will be simulated.
+            Note that this model should have grids assigned to it in order
+            to produce meaningful results.
+        cloudy_sky_: A boolean to note whether a uniform sky should be used  (False) or
+            a cloudy overcast sky (True). (Default: False).
+        grid_filter_: Text for a grid identifer or a pattern to filter the sensor grids of
+            the model that are simulated. For instance, `first_floor_*` will simulate
+            only the sensor grids that have an identifier that starts with
+            `first_floor_`. By default, all grids in the model will be simulated.
+        radiance_par_: Text for the radiance parameters to be used for ray
+            tracing. (Default: -ab 2 -aa 0.1 -ad 2048 -ar 64).
+        run_settings_: Settings from the "HB Recipe Settings" component that specify
+            how the recipe should be run. This can also be a text string of
+            recipe settings.
+        _run: Set to True to run the recipe and get results.
+
+    Returns:
+        report: Reports, errors, warnings, etc.
+        results: Numbers for the sky view or sky exposure at each sensor. These can be plugged
+            into the "LB Spatial Heatmap" component along with meshes of the
+            sensor grids to visualize results. Values are in percent (between 0
+            and 100).
+"""
+
+ghenv.Component.Name = 'HB Sky View'
+ghenv.Component.NickName = 'SkyView'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '3 :: Recipes'
+ghenv.Component.AdditionalHelpFromDocStrings = '3'
+
+try:
+    from lbt_recipes.recipe import Recipe
+except ImportError as e:
+    raise ImportError('\nFailed to import lbt_recipes:\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) and _run:
+    # create the recipe and set the input arguments
+    recipe = Recipe('sky-view')
+    recipe.input_value_by_name('model', _model)
+    recipe.input_value_by_name('grid-filter', grid_filter_)
+    recipe.input_value_by_name('cloudy-sky', cloudy_sky_)
+    recipe.input_value_by_name('radiance-parameters', radiance_par_)
+
+    # run the recipe
+    silent = True if _run > 1 else False
+    project_folder = recipe.run(run_settings_, radiance_check=True, silent=silent)
+
+    # load the results
+    try:
+        results = recipe_result(recipe.output_value_by_name('results', project_folder))
+    except Exception:
+        raise Exception(recipe.failure_message(project_folder))

honeybee_grasshopper_radiance/src/HB Spatial Daylight Autonomy.py

@@ -0,0 +1,86 @@
+# 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 Spatial Daylight Autonomy (sDA) from lists of daylight autonomy values.
+_
+As per IES-LM-83-12 Spatial Daylight Autonomy (sDA) is a metric describing
+annual sufficiency of ambient daylight levels in interior environments.
+It is defined as the percent of an analysis area (the area where calcuations
+are performed -typically across an entire space) that meets a minimum
+daylight illuminance level for a specified fraction of the operating hours
+per year. The sDA value is expressed as a percentage of area.
+_
+Note: This component will only output a LEED compliant sDA if you've run the
+simulation with dynamic blinds and blind schedules as per the IES-LM-83-12
+standard. If you are not using dynamic blinds, then this output is NOT LEED
+compliant.
+
+-
+    Args:
+        _DA: A data tree of daylight autonomy values output from the "HB Annual Dalyight"
+            recipe or the "HB Annual Daylight Metrics" component. Note that,
+            unless these DA values follow LM83 dynamic blinds setup, the resulting
+            sDA is not LEED compliant.
+        mesh_: An optional list of Meshes that align with the _DA data tree above, which
+            will be used to assign an area to each sensor. If no mesh is connected
+            here, it will be assumed that each sensor represents an equal area
+            to all of the others.
+        _target_time_: A minimum threshold of occupied time (eg. 50% of the time), above
+            which a given sensor passes and contributes to the spatial daylight
+            autonomy. (Default: 50%).
+
+    Returns:
+        report: Reports, errors, warnings, etc.
+        sDA: Spatial daylight autonomy as percentage of area for each analysis grid.
+        pass_fail: A data tree of zeros and ones, which indicate whether a given senor
+            passes the criteria for being daylit (1) or fails the criteria (0). 
+            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 Spatial Daylight Autonomy'
+ghenv.Component.NickName = 'sDA'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '4 :: Results'
+ghenv.Component.AdditionalHelpFromDocStrings = '1'
+
+try:
+    from ladybug_rhino.togeometry import to_mesh3d
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+try:
+    from ladybug_rhino.grasshopper import all_required_inputs, list_to_data_tree, \
+        data_tree_to_list
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    # process the input values into a rokable format
+    da_mtx = [item[-1] for item in data_tree_to_list(_DA)]
+    _target_time_ = 50 if _target_time_ is None else _target_time_
+    lb_meshes = [to_mesh3d(mesh) for mesh in mesh_]
+
+    # determine whether each point passes or fails
+    pass_fail = [[int(val > _target_time_) for val in grid] for grid in da_mtx]
+
+    # compute spatial daylight autonomy from the pass/fail results
+    if len(lb_meshes) == 0:  # all sensors represent the same area
+        sDA = [sum(pf_list) / len(pf_list) for pf_list in pass_fail]
+    else:  # weight the sensors based on the area of mesh faces
+        sDA = []
+        for i, mesh in enumerate(lb_meshes):
+            m_area = mesh.area
+            weights = [fa / m_area for fa in mesh.face_areas]
+            sDA.append(sum(v * w for v, w in zip(pass_fail[i], weights)))
+
+    pass_fail = list_to_data_tree(pass_fail)  # convert matrix to data tree