Source code for honeybee_radiance.properties.model

# coding=utf-8
"""Model Radiance Properties."""
from honeybee.extensionutil import model_extension_dicts
from honeybee.checkdup import check_duplicate_identifiers
from honeybee.boundarycondition import Surface
from honeybee.typing import invalid_dict_error, clean_rad_string, clean_and_id_rad_string
from honeybee.model import Model

from ..sensorgrid import SensorGrid
from ..view import View
from ..dynamic.group import DynamicShadeGroup, DynamicSubFaceGroup
from ..modifierset import ModifierSet
from ..mutil import dict_to_modifier  # imports all modifiers classes
from ..modifier.material import aBSDF, BSDF
from ..lib.modifiers import black, generic_context
from ..lib.modifiersets import generic_modifier_set_visible

try:
    from itertools import izip as zip  # python 2
except ImportError:
    pass   # python 3


[docs]class ModelRadianceProperties(object): """Radiance Properties for Honeybee Model. Args: host: A honeybee_core Model object that hosts these properties. Properties: * host * sensor_grids * views * modifiers * blk_modifiers * room_modifiers * face_modifiers * shade_modifiers * bsdf_modifiers * modifier_sets * global_modifier_set * dynamic_shade_groups * dynamic_subface_groups * shade_group_identifiers * subface_group_identifiers * has_sensor_grids * has_views """ def __init__(self, host, sensor_grids=None, views=None): """Initialize Model radiance properties.""" self._host = host self.sensor_grids = sensor_grids self.views = views @property def host(self): """Get the Model object hosting these properties.""" return self._host @property def sensor_grids(self): """Get or set an array of SensorGrids that are associated with the model.""" return tuple(self._sensor_grids) @sensor_grids.setter def sensor_grids(self, value): if value: try: self._sensor_grids = list(value) for obj in self._sensor_grids: assert isinstance(obj, SensorGrid), 'Expected SensorGrid for Model' \ ' sensor_grids. Got {}.'.format(type(value)) except (ValueError, TypeError): raise TypeError( 'Model sensor_grids must be an array. Got {}.'.format(type(value))) else: self._sensor_grids = [] @property def views(self): """Get or set an array of Views that are associated with the model.""" return tuple(self._views) @views.setter def views(self, value): if value: try: self._views = list(value) for obj in self._views: assert isinstance(obj, View), 'Expected View for Model' \ ' views. Got {}.'.format(type(value)) except (ValueError, TypeError): raise TypeError( 'Model views must be an array. Got {}.'.format(type(value))) else: self._views = [] @property def modifiers(self): """A list of all unique modifiers in the model. This includes modifiers across all Faces, Apertures, Doors, Shades, Room ModifierSets, and modifiers for any dynamic states assigned to these objects. However, it excludes modifiers in the default modifier set. It also excludes blk_modifiers and the modifier_direct of any states, which can be obtained separately from the blk_modifiers property. """ all_mods = self.room_modifiers + self.face_modifiers + self.shade_modifiers return list(set(all_mods)) @property def blk_modifiers(self): """A list of all unique modifier_blk in the model. This includes modifier_blk across all Faces, Apertures, Doors, and Shades. It also includes modifier_direct for any dynamic states assigned to these objects. """ modifiers = [black] for face in self.host.faces: # check all orphaned Face modifiers self._check_and_add_face_modifier_blk(face, modifiers) for ap in self.host.orphaned_apertures: # check all Aperture modifiers self._check_and_add_dynamic_obj_modifier_blk(ap, modifiers) for dr in self.host.orphaned_doors: # check all Door modifiers self._check_and_add_dynamic_obj_modifier_blk(dr, modifiers) for shade in self.host.shades: self._check_and_add_dynamic_obj_modifier_blk(shade, modifiers) for sm in self.host.shade_meshes: # check all ShadeMesh modifiers self._check_and_add_obj_modifier_blk(sm, modifiers) return list(set(modifiers)) @property def room_modifiers(self): """A list of all unique modifiers assigned to Room ModifierSets.""" room_mods = [] for cnstr_set in self.modifier_sets: room_mods.extend(cnstr_set.modified_modifiers_unique) return list(set(room_mods)) @property def face_modifiers(self): """A list of all unique modifiers assigned to Faces, Apertures and Doors. This includes both objects that are a part of Rooms as well as orphaned objects. It does not include the modifiers of any shades assigned to these objects. Nor does it include any blk modifiers. """ modifiers = [] for face in self.host.faces: # check all orphaned Face modifiers self._check_and_add_face_modifier(face, modifiers) for ap in self.host.orphaned_apertures: # check all Aperture modifiers self._check_and_add_dynamic_obj_modifier(ap, modifiers) for dr in self.host.orphaned_doors: # check all Door modifiers self._check_and_add_dynamic_obj_modifier(dr, modifiers) return list(set(modifiers)) @property def shade_modifiers(self): """A list of all unique modifiers assigned to Shade and ShadeMeshes in the model. """ modifiers = [] for room in self.host.rooms: self._check_and_add_room_modifier_shade(room, modifiers) for face in self.host.orphaned_faces: self._check_and_add_face_modifier_shade(face, modifiers) for ap in self.host.orphaned_apertures: self._check_and_add_obj_modifier_shade(ap, modifiers) for dr in self.host.orphaned_doors: self._check_and_add_obj_modifier_shade(dr, modifiers) for shade in self.host.orphaned_shades: self._check_and_add_orphaned_shade_modifier(shade, modifiers) for shade_mesh in self.host.shade_meshes: self._check_and_add_shade_mesh_modifier(shade_mesh, modifiers) return list(set(modifiers)) @property def bsdf_modifiers(self): """A list of all unique BSDF modifiers in the model. This includes any BSDF modifiers in both the Model.modifiers and the Model.blk_modifiers. """ all_mods = self.modifiers + self.blk_modifiers return list(set(mod for mod in all_mods if isinstance(mod, (aBSDF, BSDF)))) @property def modifier_sets(self): """A list of all unique Room-Assigned ModifierSets in the Model.""" modifier_sets = [] for room in self.host.rooms: if room.properties.radiance._modifier_set is not None: if not self._instance_in_array(room.properties.radiance._modifier_set, modifier_sets): modifier_sets.append(room.properties.radiance._modifier_set) return list(set(modifier_sets)) # catch equivalent modifier sets @property def global_modifier_set(self): """The global radiance modifier set. This is what is used whenever no modifier has been assigned to a given Face/Aperture/Door/Shade and there is no modifier_set assigned to the parent Room. """ return generic_modifier_set_visible @property def dynamic_shade_groups(self): """Get a list of DynamicShadeGroups in the model. These can be used to write dynamic shades into radiance files. """ # gather all of the shades with a common identifier into groups group_dict = {} for shade in self.host.shades: if shade.properties.radiance._dynamic_group_identifier: group_id = shade.properties.radiance._dynamic_group_identifier try: group_dict[group_id].append(shade) except KeyError: group_dict[group_id] = [shade] # return DynamicShadeGroup objects return [DynamicShadeGroup(ident, shades)for ident, shades in group_dict.items()] @property def dynamic_subface_groups(self): """Get a list of DynamicSubFaceGroups in the model. These can be used to write dynamic Apertures and Doors into radiance files. """ # gather all of the subfaces with a common identifier into groups group_dict = {} for subface in self.host.apertures + self.host.doors: if subface.properties.radiance._dynamic_group_identifier: group_id = subface.properties.radiance._dynamic_group_identifier try: group_dict[group_id].append(subface) except KeyError: group_dict[group_id] = [subface] # return DynamicSubFaceGroup objects return [DynamicSubFaceGroup(ident, subf)for ident, subf in group_dict.items()] @property def shade_group_identifiers(self): """Get a list of identifiers for all the DynamicShadeGroups in the model.""" group_ids = set() for shade in self.host.shades: if shade.properties.radiance._dynamic_group_identifier: group_ids.add(shade.properties.radiance._dynamic_group_identifier) return list(group_ids) @property def subface_group_identifiers(self): """Get a list of identifiers for all the DynamicSubFaceGroups in the model.""" group_ids = set() for subface in self.host.apertures + self.host.doors: if subface.properties.radiance._dynamic_group_identifier: group_ids.add(subface.properties.radiance._dynamic_group_identifier) return list(group_ids) @property def has_sensor_grids(self): """Get a boolean for whether there are sensor grids assigned to the model.""" return len(self._sensor_grids) != 0 @property def has_views(self): """Get a boolean for whether there are views assigned to the model.""" return len(self._views) != 0
[docs] def remove_sensor_grids(self): """Remove all sensor grids from the model.""" self._sensor_grids = []
[docs] def remove_views(self): """Remove all views from the model.""" self._views = []
[docs] def add_sensor_grid(self, sensor_grid): """Add a SensorGrid to this model. Args: sensor_grid: A SensorGrid to add to this model. """ assert isinstance(sensor_grid, SensorGrid), \ 'Expected SensorGrid. Got {}.'.format(type(sensor_grid)) self._sensor_grids.append(sensor_grid)
[docs] def add_view(self, view): """Add a View to this model. Args: view: A View to add to this model. """ assert isinstance(view, View), 'Expected View. Got {}.'.format(type(view)) self._views.append(view)
[docs] def add_sensor_grids(self, sensor_grids): """Add a list of SensorGrids to this model.""" for grid in sensor_grids: self.add_sensor_grid(grid)
[docs] def add_views(self, views): """Add a list of Views to this model.""" for view in views: self.add_view(view)
[docs] def faces_by_blk(self): """Get all Faces in the model separated by their blk property. This method will also ensure that any faces with Surface boundary condition are not duplicated in the result but are rather offset from the base face to ensure modifiers on opposite sides of interior Faces are accounted for. Furthermore, this method also ensures that any static interior sub-faces (with Surface boundary condition) only have one of such objects in the output lists. Returns: A tuple with 2 lists: - faces: A list of all faces without a unique modifier_blk. - faces_blk: A list of all opaque faces that have a unique modifier_blk. """ faces, faces_blk = [], [] interior_faces, offset = set(), self.host.tolerance * -2 for face in self.host.faces: if isinstance(face.boundary_condition, Surface): if face.identifier in interior_faces: face = face.duplicate() face.move(face.normal * offset) else: interior_faces.add(face.boundary_condition.boundary_condition_object) for subf in face.apertures + face.doors: if subf.properties.radiance.dynamic_group_identifier is None: if subf.properties.radiance._modifier_blk: faces_blk.append(subf) else: faces.append(subf) if face.properties.radiance._modifier_blk: faces_blk.append(face) else: faces.append(face) return faces, faces_blk
[docs] def subfaces_by_blk(self): """Get model exterior sub-faces (Apertures, Doors) grouped by their blk property. Dynamic sub-faces will be excluded from the output lists. Returns: A tuple with 2 lists: - subfaces: A list of all sub-faces without a unique modifier_blk (just using the default black). - subfaces_blk: A list of all sub-faces that have a unique modifier_blk. """ subfaces, subfaces_blk = [], [] for subf in self.host.apertures + self.host.doors: if subf.properties.radiance.dynamic_group_identifier: continue # sub-face will be accounted for in the dynamic objects if isinstance(subf.boundary_condition, Surface): continue # static interior apertures are part of the scene if subf.properties.radiance._modifier_blk: subfaces_blk.append(subf) else: subfaces.append(subf) return subfaces, subfaces_blk
[docs] def shades_by_blk(self): """Get all Shades in the model separated by their blk property. Dynamic shades will be excluded from the output lists. Returns: A tuple with 2 lists: - shades: A list of all opaque shades without a unique modifier_blk (just using the default black or transparent modifier). - shades_blk: A list of all opaque shades that have a unique modifier_blk. """ shades, shades_blk = [], [] for shade in self.host.shades: if shade.properties.radiance.dynamic_group_identifier: continue # shade will be accounted for in the dynamic objects if shade.properties.radiance._modifier_blk: shades_blk.append(shade) else: shades.append(shade) return shades, shades_blk
[docs] def shade_meshes_by_blk(self): """Get all ShadeMeshes in the model separated by their blk property. Returns: A tuple with 2 lists: - shade_meshes: A list of all shade meshes without a unique modifier_blk (just using the default black or transparent modifier). - shade_meshes_blk: A list of all shade meshes that have a unique modifier_blk. """ shade_meshes, shade_meshes_blk = [], [] for shade in self.host.shade_meshes: if shade.properties.radiance._modifier_blk: shade_meshes_blk.append(shade) else: shade_meshes.append(shade) return shade_meshes, shade_meshes_blk
[docs] def move(self, moving_vec): """Move all sensor_grid and view geometry along a vector. Args: moving_vec: A ladybug_geometry Vector3D with the direction and distance to move the objects. """ for grid in self._sensor_grids: grid.move(moving_vec) for view in self._views: view.move(moving_vec)
[docs] def rotate(self, axis, angle, origin): """Rotate all sensor_grid and view geometry. Args: axis: A ladybug_geometry Vector3D axis representing the axis of rotation. angle: An angle for rotation in degrees. origin: A ladybug_geometry Point3D for the origin around which the object will be rotated. """ for grid in self._sensor_grids: grid.rotate(axis, angle, origin) for view in self._views: view.rotate(axis, angle, origin)
[docs] def rotate_xy(self, angle, origin): """Rotate all sensor_grids and views counterclockwise in the world XY plane. Args: angle: An angle in degrees. origin: A ladybug_geometry Point3D for the origin around which the object will be rotated. """ for grid in self._sensor_grids: grid.rotate_xy(angle, origin) for view in self._views: view.rotate_xy(angle, origin)
[docs] def reflect(self, plane): """Reflect all sensor_grid and view geometry across a plane. Args: plane: A ladybug_geometry Plane across which the object will be reflected. """ for grid in self._sensor_grids: grid.reflect(plane) for view in self._views: view.reflect(plane)
[docs] def scale(self, factor, origin=None): """Scale all sensor_grid and view geometry by a factor. Args: factor: A number representing how much the object should be scaled. origin: A ladybug_geometry Point3D representing the origin from which to scale. If None, it will be scaled from the World origin (0, 0, 0). """ for grid in self._sensor_grids: grid.scale(factor, origin) for view in self._views: view.scale(factor, origin)
[docs] def generate_exterior_face_sensor_grid( self, dimension, offset=0.1, face_type='Wall', punched_geometry=False): """Get a radiance SensorGrid generated from all exterior Faces of this Model. The Face geometry without windows punched into it will be used. This will be None if the Model has no exterior Faces. Args: dimension: The dimension of the grid cells as a number. offset: A number for how far to offset the grid from the base face. Positive numbers indicate an offset towards the exterior. (Default is 0.1, which will offset the grid to be 0.1 unit from the faces). face_type: Text 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). * Wall * Roof * Floor * All punched_geometry: 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). Returns: A honeybee_radiance SensorGrid generated from the exterior Faces of the model. Will be None if the Model has no exterior Faces. """ # generate the mesh grid from the exterior Faces face_grid = self.host.generate_exterior_face_grid( dimension, offset, face_type, punched_geometry) if face_grid is None: # no valid mesh could be generated return None # create the sensor grid from the mesh f_nm = 'Faces' if face_type.title() == 'All' else face_type.title() grid_name = '{}_Exterior{}'.format(self.host.display_name, f_nm) sensor_grid = SensorGrid.from_mesh3d(clean_rad_string(grid_name), face_grid) sensor_grid.display_name = grid_name return sensor_grid
[docs] def generate_exterior_aperture_sensor_grid( self, dimension, offset=0.1, aperture_type='All'): """Get a radiance SensorGrid generated from all exterior Apertures of this Model. This will be None if the Model has no exterior Apertures. Args: dimension: The dimension of the grid cells as a number. offset: A number for how far to offset the grid from the base aperture. Positive numbers indicate an offset towards the exterior while negative numbers indicate an offset towards the interior, essentially modeling the value of sun on the building interior. (Default is 0.1, which will offset the grid to be 0.1 unit from the aperture). aperture_type: Text to specify the type of Aperture that will be used to generate grids. Window indicates Apertures in Walls. Choose from the following. (Default: All). * Window * Skylight * All Returns: A honeybee_radiance SensorGrid generated from the exterior Apertures of the model. Will be None if the Model has no exterior Apertures. """ # generate the mesh grid from the exterior Apertures ap_grid = self.host.generate_exterior_aperture_grid( dimension, offset, aperture_type) if ap_grid is None: # no valid mesh could be generated return None # create the sensor grid from the mesh f_nm = 'Apertures' if aperture_type.title() == 'All' else aperture_type.title() grid_name = '{}_Exterior{}'.format(self.host.display_name, f_nm) sensor_grid = SensorGrid.from_mesh3d(clean_rad_string(grid_name), ap_grid) sensor_grid.display_name = grid_name return sensor_grid
[docs] def check_all(self, raise_exception=True, detailed=False): """Check all of the aspects of the Model radiance properties. Args: raise_exception: Boolean to note whether a ValueError should be raised if any errors are found. If False, this method will simply return a text string with all errors that were found. (Default: True). detailed: Boolean for whether the returned object is a detailed list of dicts with error info or a string with a message. (Default: False). Returns: A text string with all errors that were found or a list if detailed is True. This string (or list) will be empty if no errors were found. """ # set up defaults to ensure the method runs correctly detailed = False if raise_exception else detailed msgs = [] # perform checks for key honeybee model schema rules msgs.append(self.check_duplicate_modifier_identifiers(False, detailed)) msgs.append(self.check_duplicate_modifier_set_identifiers(False, detailed)) msgs.append(self.check_duplicate_sensor_grid_identifiers(False, detailed)) msgs.append(self.check_duplicate_view_identifiers(False, detailed)) msgs.append(self.check_sensor_grid_rooms_in_model(False, detailed)) msgs.append(self.check_view_rooms_in_model(False, detailed)) # output a final report of errors or raise an exception full_msgs = [msg for msg in msgs if msg] if detailed: return [m for msg in full_msgs for m in msg] full_msg = '\n'.join(full_msgs) if raise_exception and len(full_msgs) != 0: raise ValueError(full_msg) return full_msg
[docs] def check_duplicate_modifier_identifiers(self, raise_exception=True, detailed=False): """Check that there are no duplicate Modifier identifiers in the model. Args: raise_exception: Boolean to note whether a ValueError should be raised if duplicate identifiers are found. (Default: True). detailed: Boolean for whether the returned object is a detailed list of dicts with error info or a string with a message. (Default: False). Returns: A string with the message or a list with a dictionary if detailed is True. """ return check_duplicate_identifiers( self.modifiers, raise_exception, 'Radiance Modifier', detailed, '010001', 'Radiance', error_type='Duplicate Modifier Identifier')
[docs] def check_duplicate_modifier_set_identifiers( self, raise_exception=True, detailed=False): """Check that there are no duplicate ModifierSet identifiers in the model. Args: raise_exception: Boolean to note whether a ValueError should be raised if duplicate identifiers are found. (Default: True). detailed: Boolean for whether the returned object is a detailed list of dicts with error info or a string with a message. (Default: False). Returns: A string with the message or a list with a dictionary if detailed is True. """ return check_duplicate_identifiers( self.modifier_sets, raise_exception, 'ModifierSet', detailed, '010002', 'Radiance', error_type='Duplicate ModifierSet Identifier')
[docs] def check_duplicate_sensor_grid_identifiers( self, raise_exception=True, detailed=False): """Check that there are no duplicate SensorGrid identifiers in the model. Args: raise_exception: Boolean to note whether a ValueError should be raised if duplicate identifiers are found. (Default: True). detailed: Boolean for whether the returned object is a detailed list of dicts with error info or a string with a message. (Default: False). Returns: A string with the message or a list with a dictionary if detailed is True. """ return check_duplicate_identifiers( self.sensor_grids, raise_exception, 'SensorGrid', detailed, '010003', 'Radiance', error_type='Duplicate SensorGrid Identifier')
[docs] def check_duplicate_view_identifiers(self, raise_exception=True, detailed=False): """Check that there are no duplicate View identifiers in the model. Args: raise_exception: Boolean to note whether a ValueError should be raised if duplicate identifiers are found. (Default: True). detailed: Boolean for whether the returned object is a detailed list of dicts with error info or a string with a message. (Default: False). Returns: A string with the message or a list with a dictionary if detailed is True. """ return check_duplicate_identifiers( self.views, raise_exception, 'View', detailed, '010004', 'Radiance', error_type='Duplicate View Identifier')
[docs] def check_sensor_grid_rooms_in_model(self, raise_exception=True, detailed=False): """Check that the room_identifiers of SenorGrids are in the model. Args: raise_exception: Boolean to note whether a ValueError should be raised if SensorGrids reference Rooms that are not in the Model. (Default: True). detailed: Boolean for whether the returned object is a detailed list of dicts with error info or a string with a message. (Default: False). Returns: A string with the message or a list with a dictionary if detailed is True. """ detailed = False if raise_exception else detailed # gather a list of all the missing rooms grid_ids = [(grid, grid.room_identifier) for grid in self.sensor_grids if grid.room_identifier is not None] room_ids = set(room.identifier for room in self.host.rooms) missing_rooms = [] if detailed else set() for grid in grid_ids: if grid[1] not in room_ids: if detailed: missing_rooms.append(grid[0]) else: missing_rooms.add(grid[1]) # if missing rooms were found, then report the issue if len(missing_rooms) != 0: if detailed: all_err = [] for grid in missing_rooms: msg = 'SensorGrid "{}" has a room_identifier that is not in the ' \ 'Model: "{}"'.format(grid.identifier, grid.room_identifier) error_dict = { 'type': 'ValidationError', 'code': '010005', 'error_type': 'SensorGrid Room Not In Model', 'extension_type': 'Radiance', 'element_type': 'SensorGrid', 'element_id': [grid.identifier], 'element_name': [grid.display_name], 'message': msg } all_err.append(error_dict) return all_err else: msg = 'The model has the following missing rooms referenced by sensor ' \ 'grids:\n{}'.format('\n'.join(missing_rooms)) if raise_exception: raise ValueError(msg) return msg return [] if detailed else ''
[docs] def check_view_rooms_in_model(self, raise_exception=True, detailed=False): """Check that the room_identifiers of Views are in the model. Args: raise_exception: Boolean to note whether a ValueError should be raised if Views reference Rooms that are not in the Model. (Default: True). detailed: Boolean for whether the returned object is a detailed list of dicts with error info or a string with a message. (Default: False). Returns: A string with the message or a list with a dictionary if detailed is True. """ detailed = False if raise_exception else detailed # gather a list of all the missing rooms view_ids = [(view, view.room_identifier) for view in self.views if view.room_identifier is not None] room_ids = set(room.identifier for room in self.host.rooms) missing_rooms = [] if detailed else set() for view in view_ids: if view[1] not in room_ids: if detailed: missing_rooms.append(view[0]) else: missing_rooms.add(view[1]) if len(missing_rooms) != 0: if detailed: all_err = [] for view in missing_rooms: msg = 'View "{}" has a room_identifier that is not in the ' \ 'Model: "{}"'.format(view.identifier, view.room_identifier) error_dict = { 'type': 'ValidationError', 'code': '010006', 'error_type': 'View Room Not In Model', 'extension_type': 'Radiance', 'element_type': 'View', 'element_id': [view.identifier], 'element_name': [view.display_name], 'message': msg } all_err.append(error_dict) return all_err else: msg = 'The model has the following missing rooms referenced by ' \ 'views:\n{}'.format('\n'.join(missing_rooms)) if raise_exception: raise ValueError(msg) return msg return [] if detailed else ''
[docs] def apply_properties_from_dict(self, data): """Apply the radiance properties of a dictionary to the host Model of this object. Args: data: A dictionary representation of an entire honeybee-core Model. Note that this dictionary must have ModelRadianceProperties in order for this method to successfully apply the radiance properties. """ assert 'radiance' in data['properties'], \ 'Dictionary possesses no ModelRadianceProperties.' modifiers, modifier_sets = self.load_properties_from_dict(data) # collect lists of radiance property dictionaries room_e_dicts, face_e_dicts, shd_e_dicts, ap_e_dicts, dr_e_dicts = \ model_extension_dicts(data, 'radiance', [], [], [], [], []) # apply radiance properties to objects using the radiance property dictionaries for room, r_dict in zip(self.host.rooms, room_e_dicts): if r_dict is not None: room.properties.radiance.apply_properties_from_dict( r_dict, modifier_sets) for face, f_dict in zip(self.host.faces, face_e_dicts): if f_dict is not None: face.properties.radiance.apply_properties_from_dict( f_dict, modifiers) for aperture, a_dict in zip(self.host.apertures, ap_e_dicts): if a_dict is not None: aperture.properties.radiance.apply_properties_from_dict( a_dict, modifiers) for door, d_dict in zip(self.host.doors, dr_e_dicts): if d_dict is not None: door.properties.radiance.apply_properties_from_dict( d_dict, modifiers) # apply properties to the Shades with separation of Shades from ShadeMesh all_shades = self.host.shades + self.host._shade_meshes for shade, s_dict in zip(all_shades, shd_e_dicts): if s_dict is not None: shade.properties.radiance.apply_properties_from_dict( s_dict, modifiers) # apply the sensor grids and views if they are in the data. rad_data = data['properties']['radiance'] if 'sensor_grids' in rad_data and rad_data['sensor_grids'] is not None: self.sensor_grids = \ [SensorGrid.from_dict(grid) for grid in rad_data['sensor_grids']] if 'views' in rad_data and rad_data['views'] is not None: self.views = [View.from_dict(view) for view in rad_data['views']]
[docs] def to_dict(self): """Return Model radiance properties as a dictionary.""" base = {'radiance': {'type': 'ModelRadianceProperties'}} # add the global modifier set to the dictionary gs = self.global_modifier_set.to_dict(abridged=True, none_for_defaults=False) gs['type'] = 'GlobalModifierSet' del gs['identifier'] g_mods = self.global_modifier_set.modifiers_unique gs['modifiers'] = [mod.to_dict() for mod in g_mods] gs['context_modifier'] = generic_context.identifier gs['modifiers'].append(generic_context.to_dict()) base['radiance']['global_modifier_set'] = gs # add all ModifierSets to the dictionary base['radiance']['modifier_sets'] = [] modifier_sets = self.modifier_sets for mod_set in modifier_sets: base['radiance']['modifier_sets'].append(mod_set.to_dict(abridged=True)) # add all unique Modifiers to the dictionary room_mods = [] for mod_set in modifier_sets: room_mods.extend(mod_set.modified_modifiers_unique) all_mods = room_mods + self.face_modifiers + self.shade_modifiers modifiers = list(set(all_mods)) base['radiance']['modifiers'] = [] for mod in modifiers: base['radiance']['modifiers'].append(mod.to_dict()) # add the sensor grids and views to the dictionary if len(self._sensor_grids) != 0: base['radiance']['sensor_grids'] = \ [grid.to_dict() for grid in self._sensor_grids] if len(self._views) != 0: base['radiance']['views'] = [view.to_dict() for view in self._views] return base
[docs] def duplicate(self, new_host=None): """Get a copy of this object. new_host: A new Model object that hosts these properties. If None, the properties will be duplicated with the same host. """ _host = new_host or self._host new_grids = [sg.duplicate() for sg in self._sensor_grids] new_views = [vw.duplicate() for vw in self._views] return ModelRadianceProperties(_host, new_grids, new_views)
[docs] @staticmethod def load_properties_from_dict(data): """Load model radiance properties of a dictionary to Python objects. Loaded objects include Modifiers and ModifierSets. The function is called when re-serializing a Model object from a dictionary to load honeybee_radiance objects into their Python object form before applying them to the Model geometry. Args: data: A dictionary representation of an entire honeybee-core Model. Note that this dictionary must have ModelRadianceProperties in order for this method to successfully load the radiance properties. Returns: A tuple with two elements - modifiers: A dictionary with identifiers of modifiers as keys and Python modifier objects as values. - modifier_sets: A dictionary with identifiers of modifier sets as keys and Python modifier set objects as values. """ assert 'radiance' in data['properties'], \ 'Dictionary possesses no ModelRadianceProperties.' # process all modifiers in the ModelRadianceProperties dictionary modifiers = {} if 'modifiers' in data['properties']['radiance'] and \ data['properties']['radiance']['modifiers'] is not None: for mod in data['properties']['radiance']['modifiers']: try: modifiers[mod['identifier']] = dict_to_modifier(mod) except Exception as e: invalid_dict_error(mod, e) # process all modifier sets in the ModelRadianceProperties dictionary modifier_sets = {} if 'modifier_sets' in data['properties']['radiance'] and \ data['properties']['radiance']['modifier_sets'] is not None: if 'modifier_sets' in data['properties']['radiance'] and \ data['properties']['radiance']['modifier_sets'] is not None: for m_set in data['properties']['radiance']['modifier_sets']: try: if m_set['type'] == 'ModifierSet': modifier_sets[m_set['identifier']] = \ ModifierSet.from_dict(m_set) else: modifier_sets[m_set['identifier']] = \ ModifierSet.from_dict_abridged(m_set, modifiers) except Exception as e: invalid_dict_error(m_set, e) return modifiers, modifier_sets
[docs] @staticmethod def dump_properties_to_dict(modifiers=None, modifier_sets=None): """Get a ModelRadianceProperties dictionary from arrays of Python objects. Args: modifiers: A list or tuple of radiance modifier objects. modifier_sets: A list or tuple of modifier set objects. Returns: data: A dictionary representation of ModelRadianceProperties. Note that all objects in this dictionary will follow the abridged schema. """ # process the modifiers and modifier sets all_m = [] if modifiers is None else list(modifiers) all_mod_sets = [] if modifier_sets is None else list(modifier_sets) for mod_set in all_mod_sets: all_m.extend(mod_set.modified_modifiers) # get sets of unique objects all_mods = set(all_m) # add all object dictionaries into one object data = {'type': 'ModelRadianceProperties'} data['modifiers'] = [m.to_dict() for m in all_mods] data['modifier_sets'] = [ms.to_dict(abridged=True) for ms in all_mod_sets] return data
[docs] @staticmethod def reset_resource_ids_in_dict( data, add_uuid=False, reset_modifiers=True, reset_modifier_sets=True): """Reset the identifiers of radiance resource objects in a Model dictionary. This is useful when human-readable names are needed when the model is exported to other formats like Rad and the uniqueness of the identifiers is less of a concern. Args: data: A dictionary representation of an entire honeybee-core Model. Note that this dictionary must have ModelRadianceProperties in order for this method to successfully edit the radiance properties. add_uuid: Boolean to note whether newly-generated resource object IDs should be derived only from a cleaned display_name (False) or whether this new ID should also have a unique set of 8 characters appended to it to guarantee uniqueness. (Default: False). reset_modifiers: Boolean to note whether the IDs of all modifiers in the model should be reset or kept. (Default: True). reset_modifier_sets: Boolean to note whether the IDs of all modifier sets in the model should be reset or kept. (Default: True). Returns: A new Model dictionary with the resource identifiers reset. All references to the reset resources will be correct and valid in the resulting dictionary, assuming that the input is valid. """ model = Model.from_dict(data) modifiers, modifier_sets = \ model.properties.radiance.load_properties_from_dict(data) res_func = clean_and_id_rad_string if add_uuid else clean_rad_string # change the identifiers of the modifiers if reset_modifiers: model_mods = set() for mod in model.properties.radiance.modifiers: mod.unlock() old_id, new_id = mod.identifier, res_func(mod.display_name) mod.identifier = new_id modifiers[old_id].unlock() modifiers[old_id].identifier = new_id model_mods.add(old_id) for old_id, mod in modifiers.items(): if old_id not in model_mods: mod.unlock() mod.identifier = res_func(mod.display_name) # change the identifiers of the modifier_sets if reset_modifier_sets: model_ms = set() for ms in model.properties.radiance.modifier_sets: ms.unlock() old_id, new_id = ms.identifier, res_func(ms.display_name) ms.identifier = new_id modifier_sets[old_id].unlock() modifier_sets[old_id].identifier = new_id model_ms.add(old_id) for old_id, ms in modifier_sets.items(): if old_id not in model_ms: ms.unlock() ms.identifier = res_func(ms.display_name) # create the model dictionary and update any unreferenced resources model_dict = model.to_dict() mr_props = model_dict['properties']['radiance'] mr_props['modifiers'] = [mod.to_dict() for mod in modifiers.values()] mr_props['modifier_sets'] = \ [ms.to_dict(abridged=True) for ms in modifier_sets.values()] return model_dict
def _check_and_add_room_modifier_shade(self, room, modifiers): """Check if a modifier is assigned to a Room's shades and add it to a list.""" self._check_and_add_obj_modifier_shade(room, modifiers) for face in room.faces: # check all Face modifiers self._check_and_add_face_modifier_shade(face, modifiers) def _check_and_add_face_modifier_shade(self, face, modifiers): """Check if a modifier is assigned to a Face's shades and add it to a list.""" self._check_and_add_obj_modifier_shade(face, modifiers) for ap in face.apertures: # check all Aperture modifiers self._check_and_add_obj_modifier_shade(ap, modifiers) for dr in face.doors: # check all Door Shade modifiers self._check_and_add_obj_modifier_shade(dr, modifiers) def _check_and_add_obj_modifier_shade(self, subf, modifiers): """Check if a modifier is assigned to an object's shades and add it to a list.""" for shade in subf.shades: self._check_and_add_dynamic_obj_modifier(shade, modifiers) def _check_and_add_face_modifier(self, face, modifiers): """Check if a modifier is assigned to a face and add it to a list.""" self._check_and_add_obj_modifier(face, modifiers) for ap in face.apertures: # check all Aperture modifiers self._check_and_add_dynamic_obj_modifier(ap, modifiers) for dr in face.doors: # check all Door modifiers self._check_and_add_dynamic_obj_modifier(dr, modifiers) def _check_and_add_face_modifier_blk(self, face, modifiers): """Check if a modifier_blk is assigned to a face and add it to a list.""" self._check_and_add_obj_modifier_blk(face, modifiers) for ap in face.apertures: # check all Aperture modifiers self._check_and_add_dynamic_obj_modifier_blk(ap, modifiers) for dr in face.doors: # check all Door modifiers self._check_and_add_dynamic_obj_modifier_blk(dr, modifiers) def _check_and_add_obj_modifier(self, obj, modifiers): """Check if a modifier is assigned to an object and add it to a list.""" mod = obj.properties.radiance._modifier if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) def _check_and_add_dynamic_obj_modifier(self, obj, modifiers): """Check if a modifier is assigned to a dynamic object and add it to a list.""" mod = obj.properties.radiance._modifier if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) for st in obj.properties.radiance._states: stm = (st._modifier, st._modifier_direct) + \ tuple(s.modifier for s in st._shades) for mod in stm: if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) def _check_and_add_obj_modifier_blk(self, obj, modifiers): """Check if a modifier_blk is assigned to an object and add it to a list.""" mod = obj.properties.radiance._modifier_blk if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) def _check_and_add_dynamic_obj_modifier_blk(self, obj, modifiers): """Check if a modifier_blk is assigned to a dynamic object and add it to a list. """ mod = obj.properties.radiance._modifier_blk if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) for st in obj.properties.radiance._states: for s in st._shades: mod = s.modifier if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) def _check_and_add_orphaned_shade_modifier(self, obj, modifiers): """Check if a modifier is assigned to an object and add it to a list.""" mod = obj.properties.radiance._modifier if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) else: def_mod = generic_context if obj.is_detached else \ generic_modifier_set_visible.shade_set.exterior_modifier if not self._instance_in_array(def_mod, modifiers): modifiers.append(def_mod) for st in obj.properties.radiance._states: stm = (st._modifier, st._modifier_direct) + \ tuple(s.modifier for s in st._shades) for mod in stm: if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) def _check_and_add_shade_mesh_modifier(self, obj, modifiers): """Check if a modifier is assigned to an object and add it to a list.""" mod = obj.properties.radiance._modifier if mod is not None: if not self._instance_in_array(mod, modifiers): modifiers.append(mod) else: def_mod = generic_context if obj.is_detached else \ generic_modifier_set_visible.shade_set.exterior_modifier if not self._instance_in_array(def_mod, modifiers): modifiers.append(def_mod) @staticmethod def _instance_in_array(object_instance, object_array): """Check if a specific object instance is already in an array. This can be much faster than `if object_instance in object_array` when you expect to be testing a lot of the same instance of an object for inclusion in an array since the builtin method uses an == operator to test inclusion. """ for val in object_array: if val is object_instance: return True return False
[docs] def ToString(self): return self.__repr__()
def __repr__(self): return 'Model Radiance Properties: [host: {}]'.format(self.host.display_name)