honeybee-radiance 1.66.190__py3-none-any.whl

honeybee_radiance/lib/_loadmodifiersets.py

@@ -0,0 +1,69 @@
+"""Load all modifier sets from the JSON libraries."""
+from honeybee_radiance.config import folders
+from honeybee_radiance.modifierset import ModifierSet
+
+from ._loadmodifiers import _loaded_modifiers
+
+import os
+import json
+
+
+# empty dictionary to hold loaded modifier sets
+_loaded_modifier_sets = {}
+
+
+# first load the honeybee defaults
+with open(folders.defaults_file) as json_file:
+    default_data = json.load(json_file)['modifier_sets']
+for mset_dict in default_data:
+    modifierset = ModifierSet.from_dict_abridged(mset_dict, _loaded_modifiers)
+    modifierset.lock()
+    _loaded_modifier_sets[mset_dict['identifier']] = modifierset
+_default_mod_sets = set(list(_loaded_modifier_sets.keys()))
+
+
+# then load modifier sets from the user-supplied files
+def load_modifier_set_object(mset_dict, load_mods, mod_sets, misc_mods):
+    """Load a modifier set object from a dictionary and add it to the lib dict."""
+    try:
+        if mset_dict['type'] == 'ModifierSetAbridged':
+            modifierset = ModifierSet.from_dict_abridged(mset_dict, load_mods)
+        else:
+            modifierset = ModifierSet.from_dict(mset_dict)
+            misc_mods.extend(modifierset.modified_modifiers)
+        modifierset.lock()
+        assert mset_dict['identifier'] not in _default_mod_sets, 'Cannot overwrite ' \
+            'default modifier set "{}".'.format(mset_dict['identifier'])
+        mod_sets[mset_dict['identifier']] = modifierset
+    except (TypeError, KeyError, ValueError):
+        pass  # not a Honeybee ModifierSet JSON; possibly a comment
+
+
+def load_modifiersets_from_folder(modifierset_lib_folder, loaded_modifiers):
+    """Load all of the ModifierSet objects from a modifierset standards folder.
+
+    Args:
+        modifierset_lib_folder: Path to a modifiersets sub-folder within a
+            honeybee standards folder.
+        loaded_modifiers: A dictionary of modifiers that have already
+            been loaded from the library.
+    """
+    mod_sets, misc_mods = {}, []
+    for f in os.listdir(modifierset_lib_folder):
+        f_path = os.path.join(modifierset_lib_folder, f)
+        if os.path.isfile(f_path) and f_path.endswith('.json'):
+            with open(f_path, 'r') as json_file:
+                mod_set_dict = json.load(json_file)
+            if 'type' in mod_set_dict:  # single object
+                load_modifier_set_object(
+                    mod_set_dict, loaded_modifiers, mod_sets, misc_mods)
+            else:  # a collection of several objects
+                for mod_set_id in mod_set_dict:
+                    load_modifier_set_object(
+                        mod_set_dict[mod_set_id], loaded_modifiers, mod_sets, misc_mods)
+    return mod_sets, misc_mods
+
+
+loaded_m_sets, misc_m = \
+    load_modifiersets_from_folder(folders.modifierset_lib, _loaded_modifiers)
+_loaded_modifier_sets.update(loaded_m_sets)

honeybee_radiance/lib/modifiers.py

@@ -0,0 +1,58 @@
+"""Library of default modifiers for honeybee-radiance.
+
+Default values are generic values to set the initial visible / solar reflectance and
+transmittance values in your model. There is no guarantee that these values exactly
+match what you are trying to model.
+"""
+from ._loadmodifiers import _loaded_modifiers
+
+
+# establish variables for the default modifiers used across the library
+# generic opaque modifiers - visible and solar
+generic_floor = _loaded_modifiers['generic_floor_0.20']
+generic_wall = _loaded_modifiers['generic_wall_0.50']
+generic_ceiling = _loaded_modifiers['generic_ceiling_0.80']
+generic_door = _loaded_modifiers['generic_opaque_door_0.50']
+
+# generic shade modifiers - visible and solar
+generic_interior_shade = _loaded_modifiers['generic_interior_shade_0.50']
+generic_exterior_shade = _loaded_modifiers['generic_exterior_shade_0.35']
+generic_context = _loaded_modifiers['generic_context_0.20']
+generic_interior_window = _loaded_modifiers['generic_interior_window_vis_0.88']
+generic_exterior_window = _loaded_modifiers['generic_exterior_window_vis_0.64']
+generic_exterior_window_insect_screen = \
+    _loaded_modifiers['generic_exterior_screened_window_vis_0.32']
+
+# generic glass modifiers - solar
+generic_interior_window_solar = _loaded_modifiers['generic_interior_window_sol_0.77']
+generic_exterior_window_solar = _loaded_modifiers['generic_exterior_window_sol_0.37']
+generic_exterior_window_insect_screen_solar = \
+    _loaded_modifiers['generic_exterior_screened_window_sol_0.19']
+
+# generic exterior side opaque modifiers - visible and solar
+generic_floor_exterior = _loaded_modifiers['generic_floor_exterior_side_0.50']
+generic_wall_exterior = _loaded_modifiers['generic_wall_exterior_side_0.35']
+generic_roof_exterior = _loaded_modifiers['generic_ceiling_exterior_side_0.35']
+
+# special types of modifiers used within various simulation processes
+air_boundary = _loaded_modifiers['air_boundary']
+black = _loaded_modifiers['black']
+white_glow = _loaded_modifiers['white_glow']
+
+
+# make lists of modifier identifiers to look up items in the library
+MODIFIERS = tuple(_loaded_modifiers.keys())
+
+
+def modifier_by_identifier(modifier_identifier):
+    """Get a modifier from the library given the modifier identifier.
+
+    Args:
+        modifier_identifier: A text string for the identifier of the modifier.
+    """
+    try:
+        return _loaded_modifiers[modifier_identifier]
+    except KeyError:
+        raise ValueError(
+            '"{}" was not found in the radiance modifier library.'.format(
+                modifier_identifier))

honeybee_radiance/lib/modifiersets.py

@@ -0,0 +1,63 @@
+"""Collection of modifier sets."""
+from honeybee_radiance.modifierset import ModifierSet
+from ._loadmodifiersets import _loaded_modifier_sets
+
+import honeybee_radiance.lib.modifiers as _m
+
+
+# establish variables for the default modifier sets used across the library
+generic_modifier_set_visible = \
+    _loaded_modifier_sets['Generic_Interior_Visible_Modifier_Set']
+generic_modifier_set_solar = \
+    _loaded_modifier_sets['Generic_Interior_Solar_Modifier_Set']
+generic_modifier_set_visible_exterior = \
+    _loaded_modifier_sets['Generic_Exterior_Visible_Modifier_Set']
+generic_modifier_set_solar_exterior = \
+    _loaded_modifier_sets['Generic_Exterior_Solar_Modifier_Set']
+
+
+# make lists of modifier sets to look up items in the library
+MODIFIER_SETS = tuple(_loaded_modifier_sets.keys())
+
+
+def modifier_set_by_identifier(modifier_set_identifier):
+    """Get a modifier_set from the library given its identifier.
+
+    Args:
+        modifier_set_identifier: A text string for the identifier of the ModifierSet.
+    """
+    try:
+        return _loaded_modifier_sets[modifier_set_identifier]
+    except KeyError:
+        raise ValueError('"{}" was not found in the modifier set library.'.format(
+            modifier_set_identifier))
+
+
+def lib_dict_abridged_to_modifier_set(mod_set_dict, modifiers):
+    """Get a Python object of a ModifierSet from an abridged dictionary.
+
+    When the sub-objects needed to create the modifier set are not available
+    in the resources provided, the current standards library will be searched.
+
+    Args:
+        mod_set_dict: An abridged dictionary of a Honeybee ModifierSet.
+        modifiers: Dictionary of all modifier objects that might be used in the
+            modifier set with the modifier identifiers as the keys.
+
+    Returns:
+        A Python object derived from the input mod_set_dict.
+    """
+    for key in mod_set_dict:
+        if isinstance(mod_set_dict[key], dict):
+            sub_dict = mod_set_dict[key]
+            for sub_key in sub_dict:
+                if sub_key == 'type' or sub_key in modifiers:
+                    continue
+                if sub_dict[sub_key] not in modifiers:
+                    modifiers[sub_dict[sub_key]] = \
+                        _m.modifier_by_identifier(sub_dict[sub_key])
+        elif key == 'air_boundary_modifier' \
+                and mod_set_dict[key] not in modifiers:
+            modifiers[mod_set_dict[key]] = \
+                _m.modifier_by_identifier(mod_set_dict[key])
+    return ModifierSet.from_dict_abridged(mod_set_dict, modifiers)

honeybee_radiance/lightpath.py

@@ -0,0 +1,204 @@
+"""Utilities to determine the path of light taken through interior spaces of a model."""
+from honeybee.boundarycondition import Surface, Outdoors
+from honeybee.facetype import AirBoundary
+from honeybee.aperture import Aperture
+from honeybee.door import Door
+
+
+def light_path_from_room(model, room_identifier, static_name='__static_apertures__'):
+    """Get the dynamic aperture groups that need to be simulated for a room in a model.
+    
+    Args:
+        model: A honeybee Model object which will be used to identify the aperture
+            groups that are needed to simulate a single room.
+        room_identifier: Text string for the identifier of the Room in the model
+            for which the light path will be computed.
+        static_name: An optional name to be used to refer to static apertures
+            found within the model. (Default: '__static_apertures__').
+
+    Returns:
+        A list of lists where each sub-list contains the identifiers of the aperture
+        groups through which light is passing
+
+    Usage:
+
+    .. code-block:: python
+
+        from honeybee_radiance.lightpath import light_path_from_room
+        from honeybee.room import Room
+        from honeybee.model import Model
+        from ladybug_geometry.geometry3d.pointvector import Point3D
+
+        room1 = Room.from_box('Tiny_House_Room1', 5, 10, 3)
+        room1[2].apertures_by_ratio(0.4, 0.01)  # east interior window
+        room1[3].apertures_by_ratio(0.4, 0.01)  # outdoor south window
+        south_ap1 = room1[3].apertures[0]
+        south_ap1.properties.radiance.dynamic_group_identifier = 'SouthWindow1'
+
+        room2 = Room.from_box('Tiny_House_Room2', 5, 10, 3, origin=Point3D(5, 0, 0))
+        room2[4].apertures_by_ratio(0.4, 0.01)  # west interior window
+        room2[1].apertures_by_ratio(0.4, 0.01)  # outdoor north window
+        north_ap2 = room2[1].apertures[0]
+        north_ap2.properties.radiance.dynamic_group_identifier = 'NorthWindow2'
+
+        Room.solve_adjacency([room1, room2], 0.01)
+        model = Model('TinyHouse', [room1, room2])
+
+        print(light_path_from_room(model, room1.identifier))
+
+        >> [['SouthWindow1'], ['__static_apertures__', 'NorthWindow2']]
+    """
+    #TODO: Consider to modify light path if there are two consecutive
+    #      items, such as ['__static_apertures__', '__static_apertures__'].
+    def get_adjacent_room(face):
+        """Get the adjacent Room of a Face.
+
+        Args:
+            face: A Face object for which to find the adjacent room.
+
+        Returns:
+            A Room object.
+        """
+        adj_room_identifier = \
+            face.boundary_condition.boundary_condition_objects[-1]
+        adj_room = model.rooms_by_identifier([adj_room_identifier])[0]
+
+        return adj_room
+
+    def trace_light_path(
+            s_face, s_light_path, parent_room, passed_rooms = set(),
+            static_name='__static_apertures__'):
+        """Trace light path recursively.
+        
+        This function will return the light path for a single face (Aperture,
+        Door, or AirBoundary). The function will trace the light path
+        recursively meaning that it will enter rooms adjacent to interior
+        Apertures and Doors as well as AirBoundaries.
+
+        Args:
+            s_face: The Aperture, Door, or AirBoundary for which to trace the
+                light path.
+            s_light_path: The base light path of the s_face. This is a single
+                item list which contains the dynamic group identifier or the
+                static name, however, if s_face is an AirBoundary the list will
+                be empty.
+            parent_room: A Room object. This Room is the parent Room of the
+                s_face. In this function the parent room is used to check that
+                we do not go back into the parent room, and enter a infinite
+                recursive loop.
+            passed_rooms: A set of Room objects. This set contains the rooms
+                that have already been processed. This is used to not enter an
+                infinite recursive loop, e.g., if multiple are connected by
+                interior apertures.
+            static_name: An optional name to be used to refer to static apertures
+                found within the model. (Default: '__static_apertures__').
+        
+        Returns:
+            A list of lists where each sub-list contains the identifiers of the
+            ApertureGroups through which light is passing.
+        """
+        passed_rooms.add(parent_room)
+        s_face_light_path = []
+        room = get_adjacent_room(s_face)
+        for face in room.faces:
+            adj_s_faces = face.apertures + face.doors
+            if isinstance(face.type, AirBoundary):
+                adj_s_faces = adj_s_faces + (face,)
+            for adj_s_face in adj_s_faces:
+                s_light_path_duplicate = list(s_light_path)
+                if isinstance(adj_s_face, Aperture):
+                    if adj_s_face.properties.radiance._dynamic_group_identifier:
+                        light_path_id = \
+                            adj_s_face.properties.radiance._dynamic_group_identifier
+                    else:
+                        light_path_id = static_name
+                elif isinstance(adj_s_face, Door):
+                    if adj_s_face.is_glass:
+                        if adj_s_face.properties.radiance._dynamic_group_identifier:
+                            light_path_id = \
+                                [adj_s_face.properties.radiance._dynamic_group_identifier]
+                        else:
+                            light_path_id = static_name
+                    else:
+                        break
+                if isinstance(adj_s_face.boundary_condition, Surface):
+                    adj_room = get_adjacent_room(adj_s_face)
+                    # check that adjacent room is not in passed_rooms
+                    if not adj_room in passed_rooms:
+                        if isinstance(adj_s_face, (Aperture, Door)):
+                            # do not append if face is an AirBoundary
+                            if not s_light_path_duplicate:
+                                s_light_path_duplicate.append(light_path_id)
+                            elif not light_path_id == s_light_path_duplicate[-1]:
+                                s_light_path_duplicate.append(light_path_id)
+                        _s_face_light_path = trace_light_path(
+                            adj_s_face, s_light_path_duplicate, room,
+                            passed_rooms=passed_rooms
+                        )
+                        s_face_light_path.extend(_s_face_light_path)
+                elif not isinstance(adj_s_face, (Aperture, Door)) and \
+                    isinstance(adj_s_face.boundary_condition, Outdoors):
+                    # if not Aperture or Door (i.e. AirBoundary), we just pass
+                    # if the boundary condition is Outdoors
+                    pass
+                else:
+                    if not s_light_path_duplicate:
+                        s_light_path_duplicate.append(light_path_id)
+                    elif not light_path_id == s_light_path_duplicate[-1]:
+                        s_light_path_duplicate.append(light_path_id)
+                    if s_light_path_duplicate not in s_face_light_path:
+                        s_face_light_path.append(s_light_path_duplicate)
+
+        return s_face_light_path
+
+    _light_path = []
+    room = model.rooms_by_identifier([room_identifier])[0]
+    for face in room.faces:
+        s_faces = face.apertures + face.doors
+        if isinstance(face.type, AirBoundary):
+            s_faces = s_faces + (face,)
+        for s_face in s_faces:
+            if isinstance(s_face, Aperture):
+                # create base light path if Aperture or Door
+                if s_face.properties.radiance._dynamic_group_identifier:
+                    s_light_path = \
+                        [s_face.properties.radiance._dynamic_group_identifier]
+                else:
+                    s_light_path = [static_name]
+            elif isinstance(s_face, Door):
+                if s_face.is_glass:
+                    if s_face.properties.radiance._dynamic_group_identifier:
+                        s_light_path = \
+                            [s_face.properties.radiance._dynamic_group_identifier]
+                    else:
+                        s_light_path = [static_name]
+                else:
+                    s_light_path = []
+            else:
+                # else AirBoundary, no light path id
+                s_light_path = []
+            if isinstance(s_face.boundary_condition, Surface):
+                if isinstance(s_face, Door):
+                    if not s_face.is_glass:
+                        break
+                # boundary condition, trace light path recursively for s_face
+                s_face_light_path = \
+                    trace_light_path(s_face, s_light_path, room)
+                _light_path.extend(s_face_light_path)
+            elif not isinstance(s_face, (Aperture, Door)):
+                # if it is AirBoundary but without Surface boundary condition
+                pass
+            else:
+                if isinstance(s_face, Door):
+                    break
+                # no boundary condition, tracing ends here
+                if not s_light_path in _light_path:
+                    _light_path.append(s_light_path)
+
+    # remove any duplicates
+    light_path = []
+    for lp in _light_path:
+        if not lp in light_path:
+            light_path.append(lp)
+
+    return light_path

honeybee_radiance/lightsource/__init__.py

@@ -0,0 +1 @@
+"""honeybee-radiance light sources."""