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

honeybee_grasshopper_radiance/src/HB ModifierSet.py

@@ -0,0 +1,127 @@
+# 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 ModifierSet object containing all radiance modifiers needed to create
+an radiance model. ModifierSets can be assigned to Honeybee Rooms to specify
+all default modifiers on the Room.
+-
+
+    Args:
+        _name_: Text to set the name for the ModifierSet and to be incorporated
+            into a unique ModifierSet identifier. If None, a random one will
+            be genrated.
+        base_mod_set_: An optional ModifierSet object that will be used
+            as the starting point for the new ModifierSet output from this
+            component. This can also be text for the name of a ModifierSet
+            within the library such as that output from the "HB Search Modifier
+            Sets" component. If None, the Honeybee "Generic Default Modifier
+            Set" will be used as the base.
+        _exterior_subset_: A modifier subset list from the "HB Exterior Modifier
+            Subset" component. Note that None values in this list correspond to
+            no change to the given modifier in the base_mod_set_.
+        _interior_subset_: A modifier subset list from the "HB Interior Modifier
+            Subset" component. Note that None values in this list correspond to
+            no change to the given modifier in the base_mod_set_.
+        _subface_subset_: A modifier subset list from the "HB Subface Subset"
+            component. Note that None values in this list correspond to no
+            change to the given modifier in the base_mod_set_.
+        _shade_subset_: A modifier subset list from the "HB Shade Modifier
+            Subset" component. Note that None values in this list correspond to
+            no change to the given modifier in the base_mod_set_.
+
+    Returns:
+        mod_set: A ModifierSet object that can be assigned to Honeybee
+            Rooms in order to specify all default modifiers on the Room.
+"""
+
+ghenv.Component.Name = 'HB ModifierSet'
+ghenv.Component.NickName = 'ModifierSet'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '1 :: Modifiers'
+ghenv.Component.AdditionalHelpFromDocStrings = '3'
+
+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.modifierset import ModifierSet
+    from honeybee_radiance.lib.modifiersets import modifier_set_by_identifier
+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 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)
+
+
+# get the base modifier set
+name = clean_and_id_rad_string('ModifierSet') if _name_ is None else \
+    clean_rad_string(_name_)
+if base_mod_set_ is None:
+    mod_set = ModifierSet(name)
+else:
+    if isinstance(base_mod_set_, str):
+        base_mod_set_ = modifier_set_by_identifier(base_mod_set_)
+    mod_set = base_mod_set_.duplicate()
+    mod_set.identifier = name
+    if _name_ is not None:
+        mod_set.display_name = _name_
+
+# go through each input modifier subset and assign it to the set
+if len(_exterior_subset_) != 0:
+    assert len(_exterior_subset_) == 3, 'Input _exterior_subset_ is not valid.'
+    if _exterior_subset_[0] is not None:
+        mod_set.wall_set.exterior_modifier = _exterior_subset_[0]
+    if _exterior_subset_[1] is not None:
+        mod_set.roof_ceiling_set.exterior_modifier = _exterior_subset_[1]
+    if _exterior_subset_[2] is not None:
+        mod_set.floor_set.exterior_modifier = _exterior_subset_[2]
+
+if len(_interior_subset_) != 0:
+    assert len(_interior_subset_) == 6, 'Input _interior_subset_ is not valid.'
+    if _interior_subset_[0] is not None:
+        mod_set.wall_set.interior_modifier = _interior_subset_[0]
+    if _interior_subset_[1] is not None:
+        mod_set.roof_ceiling_set.interior_modifier = _interior_subset_[1]
+    if _interior_subset_[2] is not None:
+        mod_set.floor_set.interior_modifier = _interior_subset_[2]
+    if _interior_subset_[3] is not None:
+        mod_set.aperture_set.interior_modifier = _interior_subset_[3]
+    if _interior_subset_[4] is not None:
+        mod_set.door_set.interior_modifier = _interior_subset_[4]
+    if _interior_subset_[5] is not None:
+        mod_set.door_set.interior_glass_modifier = _interior_subset_[5]
+
+if len(_subface_subset_) != 0:
+    assert len(_subface_subset_) == 6, 'Input _subface_subset_ is not valid.'
+    if _subface_subset_[0] is not None:
+        mod_set.aperture_set.window_modifier = _subface_subset_[0]
+    if _subface_subset_[1] is not None:
+        mod_set.aperture_set.skylight_modifier = _subface_subset_[1]
+    if _subface_subset_[2] is not None:
+        mod_set.aperture_set.operable_modifier = _subface_subset_[2]
+    if _subface_subset_[3] is not None:
+        mod_set.door_set.exterior_modifier = _subface_subset_[3]
+    if _subface_subset_[4] is not None:
+        mod_set.door_set.overhead_modifier = _subface_subset_[4]
+    if _subface_subset_[5] is not None:
+        mod_set.door_set.exterior_glass_modifier = _subface_subset_[5]
+
+if len(_shade_subset_) != 0:
+    assert len(_shade_subset_) == 2, 'Input _shade_subset_ is not valid.'
+    if _shade_subset_[0] is not None:
+        mod_set.shade_set.exterior_modifier = _shade_subset_[0]
+    if _shade_subset_[1] is not None:
+        mod_set.shade_set.interior_modifier = _shade_subset_[1]

honeybee_grasshopper_radiance/src/HB Opaque Modifier 3.py

@@ -0,0 +1,68 @@
+# 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 an opaque radiance modifier from red, green, and blue reflectances.
+-
+
+    Args:
+        _name_: Text to set the name for the modifier and to be incorporated into
+            a unique modifier identifier.
+        _r_ref: A number between 0 and 1 for the absolute diffuse red reflectance.
+        _g_ref: A number between 0 and 1 for the absolute diffuse green reflectance.
+        _b_ref: A number between 0 and 1 for the absolute diffuse blue reflectance.
+        _spec_: A number between 0 and 1 for the absolute specular reflectance of the modifier.
+            Note that the sum of this value and the diffuse should be less
+            than one. Specular reflectances greater than 0.1 are rare for
+            non-metallic materials. (Default: 0).
+        _rough_: Roughness is specified as the rms slope of surface facets. A value
+            of 0 corresponds to a perfectly smooth surface, and a value of 1 would be
+            a very rough surface. Roughness values greater than 0.2 are not very
+            realistic. (Default: 0).
+
+    Returns:
+        modifier: An opaque modifier that can be assigned to a Honeybee geometry
+            or Modifier Sets.
+"""
+
+ghenv.Component.Name = 'HB Opaque Modifier 3'
+ghenv.Component.NickName = 'OpaqueMod3'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '1 :: Modifiers'
+ghenv.Component.AdditionalHelpFromDocStrings = '0'
+
+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.modifier.material import Plastic
+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
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    # set the default modifier properties
+    _spec_ = 0.0 if _spec_ is None else _spec_
+    _rough_ = 0.0 if _rough_ is None else _rough_
+    name = clean_and_id_rad_string('OpaqueMaterial') if _name_ is None else \
+        clean_rad_string(_name_)
+
+    # create the modifier
+    modifier = Plastic.from_reflected_specularity(
+        name, _r_ref, _g_ref, _b_ref, _spec_, _rough_)
+    if _name_ is not None:
+        modifier.display_name = _name_

honeybee_grasshopper_radiance/src/HB Opaque Modifier.py

@@ -0,0 +1,67 @@
+# 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 an opaque radiance modifier from a single reflectance.
+-
+
+    Args:
+        _name_: Text to set the name for the modifier and to be incorporated into
+            a unique modifier identifier.
+        _reflect: A number between 0 and 1 for the absolute diffuse reflectance of the modifier.
+            This reflectance will be the same for the red, green and blue channels.
+        _spec_: A number between 0 and 1 for the absolute specular reflectance of the modifier.
+            Note that the sum of this value and the diffuse _reflect should be less than one.
+            Specular reflectances greater than 0.1 are rare for non-metallic
+            materials. (Default: 0).
+        _rough_: Roughness is specified as the rms slope of surface facets. A value
+            of 0 corresponds to a perfectly smooth surface, and a value of 1 would be
+            a very rough surface. Roughness values greater than 0.2 are not very
+            realistic. (Default: 0).
+
+    Returns:
+        modifier: An opaque modifier that can be assigned to a Honeybee geometry
+            or Modifier Sets.
+"""
+
+ghenv.Component.Name = 'HB Opaque Modifier'
+ghenv.Component.NickName = 'OpaqueMod'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '1 :: Modifiers'
+ghenv.Component.AdditionalHelpFromDocStrings = '2'
+
+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.modifier.material import Plastic
+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
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    # set the default modifier properties
+    _spec_ = 0.0 if _spec_ is None else _spec_
+    _rough_ = 0.0 if _rough_ is None else _rough_
+    name = clean_and_id_rad_string('OpaqueMaterial') if _name_ is None else \
+        clean_rad_string(_name_)
+
+    # create the modifier
+    modifier = Plastic.from_reflected_specularity(
+        name, _reflect, _reflect, _reflect, _spec_, _rough_)
+    if _name_ is not None:
+        modifier.display_name = _name_

honeybee_grasshopper_radiance/src/HB Point-In-Time Grid-Based.py

@@ -0,0 +1,93 @@
+# 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 point-in-time grid-based study for a Honeybee model.
+_
+Point-in-time recipes require a sky and can output illuminance, irradiance,
+luminance or radiance.
+
+-
+    Args:
+        _model: A Honeybee Model for which a point-in-time grid-based study will be run.
+            Note that this model should have grids assigned to it in order
+            to produce meaningfule results.
+        _sky: A Radiance sky from any of the sky components under the "Light Sources" tab.
+            Skies can be either CIE, ClimateBased/Custom, or for a specific
+            Illuminance/Irradiance. This input can also just be a text definition
+            of a sky's paramters. Examples include:
+                * cie 21 Mar 9:00 -lat 41.78 -lon -87.75 -tz 5 -type 0
+                * climate-based 21 Jun 12:00 -lat 41.78 -lon -87.75 -tz 5 -dni 800 -dhi 120
+                * irradiance 0
+        _metric_: Either an integer or the full name of a point-in-time metric to be computed
+            by the recipe. (Default: illuminance). Choose from the following:
+                * 0 = illuminance
+                * 1 = irradiance
+                * 2 = luminance
+                * 3 = radiance
+        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. This input can also be
+            the integer "2" to run the recipe silently.
+
+    Returns:
+        report: Reports, errors, warnings, etc.
+        results: Numbers for the point-in-time value at each sensor. Values are in the
+            standard SI units of the requested input metric. These can be plugged
+            into the "LB Spatial Heatmap" component along with meshes of the
+            sensor grids to visualize results.
+                * illuminance = lux (aka. lm/m2)
+                * irradiance = W/m2
+                * luminance = cd/m2 (aka. lm/m2-sr)
+                * radiance = W/m2-sr
+"""
+
+ghenv.Component.Name = 'HB Point-In-Time Grid-Based'
+ghenv.Component.NickName = 'PITGrid'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '3 :: Recipes'
+ghenv.Component.AdditionalHelpFromDocStrings = '2'
+
+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('point-in-time-grid')
+    recipe.input_value_by_name('model', _model)
+    recipe.input_value_by_name('sky', _sky)
+    recipe.input_value_by_name('metric', _metric_)
+    recipe.input_value_by_name('grid-filter', grid_filter_)
+    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 Point-In-Time View-Based.py

@@ -0,0 +1,127 @@
+# 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 point-in-time view-based study for a Honeybee model.
+_
+Point-in-time view-based recipes require a sky and can output High Dynamic Range
+(HDR) images of illuminance, irradiance, luminance or radiance.
+_
+The `view_count_` input can be used to split each view for parallel processing,
+producing multiple images that are recombined into a single .HDR for the view at
+the end of the recipe. The recombination process automatically includes an
+anti-aliasing pass that smooths and improves the quality of the image. The recipe
+also performs an overture calculation prior to splitting each view, which results
+in an image with better interpolation between neighboring pixels.
+
+-
+    Args:
+        _model: A Honeybee Model for which a point-in-time view-based study will be run.
+            Note that this model should have views assigned to it in order
+            to produce meaningfule results.
+        _sky: A Radiance sky from any of the sky components under the "Light Sources" tab.
+            Skies can be either CIE, ClimateBased/Custom, or for a specific
+            Illuminance/Irradiance. This input can also just be a text definition
+            of a sky's paramters. Examples include:
+                * cie 21 Mar 9:00 -lat 41.78 -lon -87.75 -tz 5 -type 0
+                * climate-based 21 Jun 12:00 -lat 41.78 -lon -87.75 -tz 5 -dni 800 -dhi 120
+                * irradiance 0
+        _metric_: Either an integer or the full name of a point-in-time metric to be
+            computed by the recipe. (Default: luminance). Choose from the following:
+                * 0 = illuminance
+                * 1 = irradiance
+                * 2 = luminance
+                * 3 = radiance
+        _resolution_: An integer for the maximum dimension of each image in pixels
+            (either width or height depending on the input view angle and
+            type). (Default: 800).
+        view_filter_: Text for a view identifer or a pattern to filter the views of the
+            model that are simulated. For instance, `first_floor_*` will simulate
+            only the views that have an identifier that starts with `first_floor_`.
+            By default, all views in the model will be simulated.
+        skip_overture_: A boolean to note whether an ambient file (.amb) should be
+            generated for an overture calculation before the view is split
+            into smaller views. With an overture calculation, the ambient file
+            (aka ambient cache) is first populated with values. Thereby ensuring
+            that - when reused to create an image - Radiance uses interpolation
+            between already calculated values rather than less reliable
+            extrapolation. The overture calculation has comparatively small
+            computation time to full rendering but is single-core can become
+            time consuming in situations with a high view_count_ and workers.
+        radiance_par_: Text for the radiance parameters to be used for ray
+            tracing. (Default: -ab 2 -aa 0.25 -ad 512 -ar 16).
+        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. This input can also be
+            the integer "2" to run the recipe silently.
+
+    Returns:
+        report: Reports, errors, warnings, etc.
+        results: High Dynamic Range (HDR) images for each View in the model. These can be
+            plugged into the Ladybug "Image Viewer" component to preview the image. 
+            They can also be plugged into the "HB False Color" component to convert 
+            the image into a false color version. Lastly, it can be connected to 
+            the "HB HDR to GIF" component to get a GIF image that is more portable 
+            and easily previewed by different software. Pixel values are in the
+            standard SI units of the requested input metric.
+                * illuminance = lux (aka. lm/m2)
+                * irradiance = W/m2
+                * luminance = cd/m2 (aka. lm/m2-sr)
+                * radiance = W/m2-sr
+"""
+
+ghenv.Component.Name = 'HB Point-In-Time View-Based'
+ghenv.Component.NickName = 'PITView'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '3 :: Recipes'
+ghenv.Component.AdditionalHelpFromDocStrings = '2'
+
+import os
+
+try:
+    from honeybee.model import Model
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+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, \
+        recommended_processor_count
+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('point-in-time-view')
+    recipe.input_value_by_name('model', _model)
+    recipe.input_value_by_name('sky', _sky)
+    recipe.input_value_by_name('metric', _metric_)
+    recipe.input_value_by_name('resolution', _resolution_)
+    recipe.input_value_by_name('view-filter', view_filter_)
+    recipe.input_value_by_name('skip-overture', skip_overture_)
+    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))
+        if hasattr(results, 'BranchCount') and results.BranchCount == 0:
+            raise ValueError()
+    except Exception:
+        raise Exception(recipe.failure_message(project_folder))

honeybee_grasshopper_radiance/src/HB Radial Grid from Rooms.py

@@ -0,0 +1,160 @@
+# 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 SensorGrids of radial directions around positions from the floors of rooms.
+_
+This type of sensor grid is particularly helpful for studies of multiple view
+directions, such as imageless glare studies.
+_
+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. (Default: 1.2 meters).
+        _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)).
+        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 circle. These align with
+            the vecs output below and can be visualized with the native
+            Grasshopper vector display component.
+        vecs: The vectors for the directions of each sensor. These align with
+            the points output above and can be visualized with the native
+            Grasshopper vector display component.
+        mesh: Analysis mesh that can be passed to the 'Spatial Heatmap' component.
+"""
+
+ghenv.Component.Name = 'HB Radial Grid from Rooms'
+ghenv.Component.NickName = 'RadialGridRooms'
+ghenv.Component.Message = '1.9.1'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '0 :: Basic Properties'
+ghenv.Component.AdditionalHelpFromDocStrings = '4'
+
+from collections import OrderedDict
+
+try:  # import the ladybug_geometry dependencies
+    from ladybug_geometry.geometry3d import Vector3D, Point3D, 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.typing import clean_rad_string
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:
+    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, 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_ = 1.2 / conversion_to_meters() if _dist_floor_ is None else _dist_floor_
+    wall_offset = 0 if wall_offset_ is None else wall_offset_
+    dir_count = 8 if _dir_count_ is None else _dir_count_
+    try:
+        st_vec = to_vector3d(_start_vec_)
+    except AttributeError:
+        st_vec = Vector3D(0, -1, 0)
+
+    # gather all of the rooms
+    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])
+
+    # create lists to be filled with content
+    grid, points, vecs, mesh = [], [], [], []
+
+    # loop through the rooms and create the grids
+    for zone_id, room_group in room_groups.items():
+        # get the base meshs
+        floor_meshes = []
+        for room in room_group:
+            floor_mesh = room.properties.radiance._base_sensor_mesh(
+                _grid_size, _grid_size, offset=_dist_floor_, remove_out=True,
+                wall_offset=wall_offset)
+            if floor_mesh is not None:
+                floor_meshes.append(floor_mesh)
+        if len(floor_meshes) == 0:
+            continue
+        floor_grid = Mesh3D.join_meshes(floor_meshes) \
+            if len(floor_meshes) != 1 else floor_meshes[0]
+
+        # create the sensor grid from the mesh
+        mesh_radius = _grid_size * 0.45
+        sg_name = room.display_name if not by_zone_ else zone_id
+        grid_name = '{}_Radial'.format(clean_rad_string(sg_name))
+        s_grid = SensorGrid.from_mesh3d_radial(
+            grid_name, floor_grid, dir_count=dir_count, start_vector=st_vec,
+            mesh_radius=mesh_radius)
+        s_grid.room_identifier = room_group[0].identifier
+        s_grid.display_name = sg_name
+
+        # add the relevant items to the outputs
+        grid.append(s_grid)
+        sensors = s_grid.sensors
+        base_points = [from_point3d(Point3D(*sen.pos)) for sen in sensors]
+        base_vecs = [from_vector3d(Vector3D(*sen.dir)) for sen in sensors]
+        points.append(base_points)
+        vecs.append(base_vecs)
+        lb_mesh = s_grid.mesh
+        if lb_mesh is not None:
+            mesh.append(from_mesh3d(lb_mesh))
+        else:
+            mesh.append(None)
+
+    # convert the lists of points to data trees
+    points = list_to_data_tree(points)
+    vecs = list_to_data_tree(vecs)