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

honeybee_grasshopper_radiance/src/HB Radial Sensor Grid.py

@@ -0,0 +1,99 @@
+# 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 from radial directions around sensor positions.
+_
+This type of sensor grid is particularly helpful for studies of multiple view
+directions, such as imageless glare studies.
+-
+
+    Args:
+        _name_: A name for this sensor grid.
+        _positions: A list or a datatree of points with one point for the position
+            of each radial sensor. Each branch of the datatree will be
+            considered as a separate sensor grid.
+        _dir_count_: A positive integer for the number of radial directions to be
+            generated around each position. (Default: 8).
+        _start_vec_: A Vector3D to set the start direction of the generated directions.
+            This can be used to orient the resulting sensors to specific parts
+            of the scene. It can also change the elevation of the resulting
+            directions since this start vector will always be rotated in the
+            XY plane to generate the resulting directions. (Default: (0, -1, 0)).
+        mesh_radius_: An optional number that can be used to generate a mesh that is
+            aligned with the resulting sensors and will automatically be
+            assigned to the grid. Such meshes will resemble a circle around
+            each sensor with the specified radius and will contain triangular
+            faces that can be colored with simulation results. If zero, no mesh
+            will be generated for the sensor grid. (Default: 0.2 meters).
+
+    Returns:
+        grid: An SensorGrid object that can be used in a grid-based recipe.
+        mesh: Analysis mesh that can be passed to the 'Spatial Heatmap' component.
+"""
+
+ghenv.Component.Name = 'HB Radial 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 = '0'
+
+try:  # import the ladybug_geometry dependencies
+    from ladybug_geometry.geometry3d.pointvector import Vector3D, Point3D
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_geometry:\n\t{}'.format(e))
+
+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.config import conversion_to_meters
+    from ladybug_rhino.togeometry import to_vector3d
+    from ladybug_rhino.fromgeometry import from_mesh3d, from_point3d, from_vector3d
+    from ladybug_rhino.grasshopper import all_required_inputs
+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]
+    dir_count = 8 if _dir_count_ is None else _dir_count_
+    mesh_radius = 0.2 / conversion_to_meters() if mesh_radius_ is None else mesh_radius_
+    try:
+        st_vec = to_vector3d(_start_vec_)
+    except AttributeError:
+        st_vec = Vector3D(0, -1, 0)
+
+    # create the sensor grid object
+    id  = clean_rad_string(name) if '/' not in name else clean_rad_string(name.split('/')[0])
+    grid = SensorGrid.from_positions_radial(
+        id, pts, dir_count, start_vector=st_vec, mesh_radius=mesh_radius)
+
+    # set the display name and get outputs
+    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:])
+    sensors = grid.sensors
+    points = [from_point3d(Point3D(*sen.pos)) for sen in sensors]
+    vecs = [from_vector3d(Vector3D(*sen.dir)) for sen in sensors]
+    lb_mesh = grid.mesh
+    if lb_mesh is not None:
+        mesh = from_mesh3d(lb_mesh)

honeybee_grasshopper_radiance/src/HB Radiance Parameter.py

@@ -0,0 +1,163 @@
+# 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>
+
+"""
+Get recommended Radiance parameters given a recipe type and a level of detail.
+_
+The original recommendation for the various Radiance paramters comes from this document.
+http://radsite.lbl.gov/radiance/refer/Notes/rpict_options.html
+_
+This presentation by John Mardaljevic gives a good overview of the meaning of each
+radiance paramter.
+http://radiance-online.org/community/workshops/2011-berkeley-ca/presentations/day1/JM_AmbientCalculation.pdf
+
+-
+    Args:
+        _recipe_type: An integer or text for the type of recipe. Acceptable text inputs are
+            either the full text of the recipe type (eg. point-in-time-grid) or
+            the name of the Radiance command for which the parameters are being
+            used (eg. rtrace). Choose from the following options.
+                * 0 | rtrace     | point-in-time-grid | daylight-factor
+                * 1 | rpict      | point-in-time-view
+                * 2 | rfluxmtx   | annual
+        _detail_level_: An integer or text for the level of detail/quality for which
+            radiance parameters will be output. (Default: 0 for low).
+            Choose from the following options.
+                * 0 | low
+                * 1 | medium
+                * 2 | high
+        additional_par_: Text to override the Radiance parameters as needed. Radiance's
+            standard syntax must be followed (e.g. -ps 1 -lw 0.01).
+
+    Returns:
+        rad_par: Radiance parameters as a text string. These can be plugged into the
+            radiance_par_ input of the various recipes.
+"""
+
+ghenv.Component.Name = 'HB Radiance Parameter'
+ghenv.Component.NickName = 'RadPar'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '3 :: Recipes'
+ghenv.Component.AdditionalHelpFromDocStrings = '6'
+
+try:  # import honeybee_radiance_command dependencies
+    from honeybee_radiance_command.options.rtrace import RtraceOptions
+    from honeybee_radiance_command.options.rpict import RpictOptions
+    from honeybee_radiance_command.options.rfluxmtx import RfluxmtxOptions
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance_command:\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))
+
+# dictionaries of the various recommendations for radiance parameters
+RTRACE = {
+    'ab': [2, 3, 6],
+    'ad': [512, 2048, 4096],
+    'as_': [128, 2048, 4096],
+    'ar': [16, 64, 128],
+    'aa': [.25, .2, .1],
+    'dj': [0, .5, 1],
+    'ds': [.5, .25, .05],
+    'dt': [.5, .25, .15],
+    'dc': [.25, .5, .75],
+    'dr': [0, 1, 3],
+    'dp': [64, 256, 512],
+    'st': [.85, .5, .15],
+    'lr': [4, 6, 8],
+    'lw': [.05, .01, .005],
+    'ss': [0, .7, 1]
+}
+
+RPICT = {
+    'ab': [2, 3, 6],
+    'ad': [512, 2048, 4096],
+    'as_': [128, 2048, 4096],
+    'ar': [16, 64, 128],
+    'aa': [.25, .2, .1],
+    'ps': [8, 4, 2],
+    'pt': [.15, .10, .05],
+    'pj': [.6, .9, .9],
+    'dj': [0, .5, 1],
+    'ds': [.5, .25, .05],
+    'dt': [.5, .25, .15],
+    'dc': [.25, .5, .75],
+    'dr': [0, 1, 3],
+    'dp': [64, 256, 512],
+    'st': [.85, .5, .15],
+    'lr': [4, 6, 8],
+    'lw': [.05, .01, .005],
+    'ss': [0, .7, 1]
+}
+
+RFLUXMTX = {
+    'ab': [3, 5, 6],
+    'ad': [5000, 15000, 25000],
+    'as_': [128, 2048, 4096],
+    'ds': [.5, .25, .05],
+    'dt': [.5, .25, .15],
+    'dc': [.25, .5, .75],
+    'dr': [0, 1, 3],
+    'dp': [64, 256, 512],
+    'st': [.85, .5, .15],
+    'lr': [4, 6, 8],
+    'lw': [0.000002, 6.67E-07, 4E-07],
+    'ss': [0, .7, 1],
+    'c': [1, 1, 1]
+}
+
+
+# dictionaries to convert between input formats
+RECIPE_TYPES = {
+    '0': 'rtrace',
+    'point-in-time-grid': 'rtrace',
+    'daylight-factor': 'rtrace',
+    'rtrace': 'rtrace',
+    '1': 'rpict',
+    'point-in-time-image': 'rpict',
+    'rpict': 'rpict',
+    '2': 'rfluxmtx',
+    'annual': 'rfluxmtx',
+    'rfluxmtx': 'rfluxmtx',
+}
+
+DETAIL_LEVELS = {
+    '0': 0,
+    'low': 0,
+    '1': 1,
+    'medium': 1,
+    '2': 2,
+    'high': 2
+}
+
+
+if all_required_inputs(ghenv.Component):
+    # process the recipe type and level of detail
+    _detail_level_ = DETAIL_LEVELS[_detail_level_.lower()] \
+        if _detail_level_ is not None else 0
+    command_name = RECIPE_TYPES[_recipe_type.lower()]
+    if command_name == 'rtrace':
+        option_dict = RTRACE
+        option_obj = RtraceOptions()
+    elif command_name == 'rpict':
+        option_dict = RPICT
+        option_obj = RpictOptions()
+    elif command_name == 'rfluxmtx':
+        option_dict = RFLUXMTX
+        option_obj = RfluxmtxOptions()
+
+    # assign the defualts to the object and output the string
+    for opt_name, opt_val in option_dict.items():
+        setattr(option_obj, opt_name, opt_val[_detail_level_])
+    if additional_par_:
+        option_obj.update_from_string(additional_par_)
+    rad_par = option_obj.to_radiance()

honeybee_grasshopper_radiance/src/HB Search Modifier Sets.py

@@ -0,0 +1,58 @@
+# 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>
+
+"""
+Search for available Mofidier Sets within the honeybee standards library.
+-
+
+    Args:
+        keywords_: Optional keywords to be used to narrow down the output list of
+            modifier sets. If nothing is input here, all available modifier sets
+            will be output.
+        join_words_: If False or None, this component will automatically split
+            any strings of multiple keywords (spearated by spaces) into separate
+            keywords for searching. This results in a greater liklihood of
+            finding an item in the search but it may not be appropropriate for
+            all cases. You may want to set it to True when you are searching for
+            a specific phrase that includes spaces. Default: False.
+
+    Returns:
+        mod_sets: A list of modifier sets within the honeybee radiance
+            standards library (filtered by keywords_ if they are input).
+"""
+
+ghenv.Component.Name = 'HB Search Modifier Sets'
+ghenv.Component.NickName = 'SearchModSets'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '1 :: Modifiers'
+ghenv.Component.AdditionalHelpFromDocStrings = '1'
+
+try:  # import the honeybee-core dependencies
+    from honeybee.search import filter_array_by_keywords
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import the honeybee-radiance dependencies
+    from honeybee_radiance.lib.modifiersets import MODIFIER_SETS
+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)
+
+
+if len(keywords_) == 0:
+    mod_sets = sorted(MODIFIER_SETS)
+else:
+    split_words = True if join_words_ is None else not join_words_
+    mod_sets = sorted(filter_array_by_keywords(MODIFIER_SETS, keywords_, split_words))

honeybee_grasshopper_radiance/src/HB Search Modifiers.py

@@ -0,0 +1,58 @@
+# 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>
+
+"""
+Search for available Mofidiers within the honeybee standards library.
+-
+
+    Args:
+        keywords_: Optional keywords to be used to narrow down the output list of
+            modifiers. If nothing is input here, all available modifiers
+            will be output.
+        join_words_: If False or None, this component will automatically split
+            any strings of multiple keywords (spearated by spaces) into separate
+            keywords for searching. This results in a greater liklihood of
+            finding an item in the search but it may not be appropropriate for
+            all cases. You may want to set it to True when you are searching for
+            a specific phrase that includes spaces. Default: False.
+    
+    Returns:
+        modifiers: A list of modifiers within the honeybee radiance
+            standards library (filtered by keywords_ if they are input).
+"""
+
+ghenv.Component.Name = 'HB Search Modifiers'
+ghenv.Component.NickName = 'SearchMods'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '1 :: Modifiers'
+ghenv.Component.AdditionalHelpFromDocStrings = '1'
+
+try:  # import the honeybee-core dependencies
+    from honeybee.search import filter_array_by_keywords
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import the honeybee-radiance dependencies
+    from honeybee_radiance.lib.modifiers import MODIFIERS
+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)
+
+
+if len(keywords_) == 0:
+    modifiers = sorted(MODIFIERS)
+else:
+    split_words = True if join_words_ is None else not join_words_
+    modifiers = sorted(filter_array_by_keywords(MODIFIERS, keywords_, split_words))

honeybee_grasshopper_radiance/src/HB Section Plane View.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>
+
+"""
+Apply a section plane to a Honeybee Radiance View.
+_
+The plane will always be perpendicular to the view direction for perspective
+and parallel view types. For fisheye view types, the clipping plane is actually
+a clipping sphere, centered on the view point.
+_
+Objects in front of this imaginary plane will not be visible. This may be useful
+for seeing through walls (to get a longer perspective from an exterior view point)
+or for incremental rendering.
+-
+
+    Args:
+        _view: A Honeybee Radiance View object to which a section plane should be applied.
+        _origin: An point to set the origin of the section plane in 3D space. Note
+            that the section plane is always perpenicular to the view direction
+            for perspective and parallel views.
+
+    Returns:
+        view: A Honeybee View object that can be used in a view-based recipe.
+"""
+
+ghenv.Component.Name = 'HB Section Plane View'
+ghenv.Component.NickName = 'SectionView'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '0 :: Basic Properties'
+ghenv.Component.AdditionalHelpFromDocStrings = '0'
+
+try:
+    from ladybug_geometry.geometry3d.pointvector import Point3D
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:
+    from honeybee_radiance.view import View
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.togeometry import to_point3d
+    from ladybug_rhino.grasshopper import all_required_inputs
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    # process the input view and origin
+    if isinstance(_view, str):
+        view = View.from_string(_view)
+    else:
+        assert isinstance(_view, View), \
+            'Expected Honeybee View. Got {}.'.format(type(_view))
+        view = _view.duplicate()
+    view_pt = Point3D(*_view.position)
+    origin = to_point3d(_origin)
+
+    # set the fore clip according to the distance
+    view.fore_clip = origin.distance_to_point(view_pt)
+    #view.position = (origin.x, origin.y, origin.z)

honeybee_grasshopper_radiance/src/HB Sensor Grid from Apertures.py

@@ -0,0 +1,153 @@
+# 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 Apertures.
+_
+These SensorGrids can be used in any grid-based recipe and are particularly useful
+for irradiance studies that evaluate solar gain of buildings, such as peak solar
+irradiance studies.
+-
+
+    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.
+            Positive numbers indicate an offset towards the exterior while
+            negative numbers indicate an offset towards the interior, essentially
+            modeling the value of trasnmitted sun through the glass. The default
+            is 0.1 meters.
+        _ap_type_: Text or an integer to specify the type of aperture that will be used to
+            generate grids. Choose from the following. (Default: All).
+                * 1 - Window
+                * 2 - Skylight
+                * 3 - All
+        quad_only_: Boolean to note whether meshing should be done using Rhino's
+            defaults (False), which fills the entire aperture 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 Apertures'
+ghenv.Component.NickName = 'GridApertures'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '0 :: Basic Properties'
+ghenv.Component.AdditionalHelpFromDocStrings = '4'
+
+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.aperture import Aperture
+    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))
+
+
+APERTURE_TYPES = {
+    '1': Wall,
+    '2': RoofCeiling,
+    '3': (Wall, RoofCeiling, Floor),
+    'Window': Wall,
+    'Skylight': RoofCeiling,
+    '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 = APERTURE_TYPES[_ap_type_.title()] if _ap_type_ is not None \
+        else (Wall, RoofCeiling, Floor)
+
+    # collect all of the relevant apertures
+    apertures = []
+    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):
+                    apertures.extend(face.apertures)
+        elif isinstance(obj, Face):
+            if isinstance(obj.boundary_condition, Outdoors) and isinstance(obj.type, ft):
+                apertures.extend(obj.apertures)
+        elif isinstance(obj, Aperture):
+            if obj.has_parent:
+                face = obj.parent
+                if isinstance(face.boundary_condition, Outdoors) and isinstance(face.type, ft):
+                    apertures.append(obj)
+            else:
+                apertures.append(obj)
+        else:
+            raise TypeError(
+                'Expected Honeybee Aperture, Face, Room or Model. Got {}.'.format(type(obj)))
+
+    # greneate the meshes and grids from the faces
+    if len(apertures) != 0:
+        # create the gridded ladybug Mesh3D
+        f_geos = [ap.geometry for ap in apertures]
+        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 = 'Windows'
+            if isinstance(ft, tuple):
+                f_nm = 'Apertures' 
+            elif ft is RoofCeiling:
+                f_nm = 'Skylights'
+            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