dragonfly-radiance 0.4.121__py3-none-any.whl

dragonfly_radiance/properties/model.py

@@ -0,0 +1,443 @@
+# coding=utf-8
+"""Model Radiance Properties."""
+try:
+    from itertools import izip as zip  # python 2
+except ImportError:
+    pass   # python 3
+
+from honeybee.checkdup import check_duplicate_identifiers
+from honeybee.extensionutil import room_extension_dicts
+import honeybee_radiance.properties.model as hb_model_properties
+from honeybee_radiance.lib.modifiersets import generic_modifier_set_visible
+from honeybee_radiance.lib.modifiers import generic_context
+
+from dragonfly.extensionutil import model_extension_dicts
+
+
+class ModelRadianceProperties(object):
+    """Radiance Properties for Dragonfly Model.
+
+    Args:
+        host: A dragonfly_core Model object that hosts these properties.
+
+    Properties:
+        * host
+        * modifiers
+        * shade_modifiers
+        * modifier_sets
+        * global_modifier_set
+    """
+    # dictionary mapping validation error codes to a corresponding check function
+    ERROR_MAP = {
+        '010001': 'check_duplicate_modifier_identifiers',
+        '010002': 'check_duplicate_modifier_set_identifiers'
+    }
+
+    def __init__(self, host):
+        """Initialize Model Radiance properties."""
+        self._host = host
+
+    @property
+    def host(self):
+        """Get the Model object hosting these properties."""
+        return self._host
+
+    @property
+    def modifiers(self):
+        """List of all unique modifiers contained within the model.
+
+        This includes modifiers across all Room2Ds, Stories, and Building
+        ModifierSets but it does NOT include the Honeybee generic default
+        modifier set.
+        """
+        bldg_mods = []
+        for mod_set in self.modifier_sets:
+            bldg_mods.extend(mod_set.modified_modifiers_unique)
+        all_mods = bldg_mods + self.face_modifiers + self.shade_modifiers
+        return list(set(all_mods))
+
+    @property
+    def face_modifiers(self):
+        """Get a list of all unique modifiers assigned to Faces, Apertures and Doors.
+
+        These objects only exist under the Building.room_3ds property.
+        """
+        modifiers = []
+        for bldg in self.host.buildings:
+            for face in bldg.room_3d_faces:
+                self._check_and_add_obj_modifier(face, modifiers)
+                for ap in face.apertures:
+                    self._check_and_add_obj_modifier(ap, modifiers)
+                for dr in face.doors:
+                    self._check_and_add_obj_modifier(dr, modifiers)
+        return list(set(modifiers))
+
+    @property
+    def shade_modifiers(self):
+        """A list of all unique modifiers assigned to ContextShades in the model."""
+        modifiers = []
+        for shade in self.host.context_shades:
+            self._check_and_add_obj_modifier(shade, modifiers)
+        for bldg in self.host.buildings:
+            for shd in bldg.room_3d_shades:
+                self._check_and_add_obj_modifier(shd, modifiers)
+        return list(set(modifiers))
+
+    @property
+    def modifier_sets(self):
+        """A list of all unique Building-Assigned ModifierSets in the Model.
+
+        Note that this includes ModifierSets assigned to individual Stories and
+        Room2Ds in the Building.
+        """
+        modifier_sets = []
+        for bldg in self.host.buildings:
+            self._check_and_add_obj_mod_set(bldg, modifier_sets)
+            for story in bldg.unique_stories:
+                self._check_and_add_obj_mod_set(story, modifier_sets)
+                for room in story.room_2ds:
+                    self._check_and_add_obj_mod_set(room, modifier_sets)
+            for room in bldg.room_3ds:
+                self._check_and_add_obj_mod_set(room, modifier_sets)
+        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 there is no modifier_set assigned to a
+        Room2D, a parent Story, or a parent Building.
+        """
+        return generic_modifier_set_visible
+
+    def check_for_extension(self, raise_exception=True, detailed=False):
+        """Check that the Model is valid for Radiance simulation.
+
+        This process includes all relevant dragonfly-core checks as well as checks
+        that apply only for Radiance.
+
+        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 = []
+        tol = self.host.tolerance
+        ang_tol = self.host.angle_tolerance
+
+        # perform checks for duplicate identifiers, which might mess with other checks
+        msgs.append(self.host.check_all_duplicate_identifiers(False, detailed))
+
+        # perform checks for key dragonfly model schema rules
+        msgs.append(self.host.check_degenerate_room_2ds(tol, False, detailed))
+        msgs.append(self.host.check_self_intersecting_room_2ds(tol, False, detailed))
+        msgs.append(self.host.check_plenum_depths(tol, False, detailed))
+        msgs.append(self.host.check_window_parameters_valid(tol, False, detailed))
+        msgs.append(self.host.check_no_room2d_overlaps(tol, False, detailed))
+        msgs.append(self.host.check_collisions_between_stories(tol, False, detailed))
+        msgs.append(self.host.check_roofs_above_rooms(tol, False, detailed))
+        msgs.append(self.host.check_room2d_floor_heights_valid(False, detailed))
+        msgs.append(self.host.check_all_room3d(tol, ang_tol, 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
+
+    def check_generic(self, raise_exception=True, detailed=False):
+        """Check generic of the aspects of the Model radiance properties.
+
+        This includes checks for everything except duplicate identifiers for
+        modifiers and modifier sets. Typically, these checks just add to the
+        validation time without providing useful information since extension
+        objects with duplicate IDs are lost during HBJSON serialization.
+
+        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.
+            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 specific radiance simulation rules
+        # 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
+
+    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.
+            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 duplicate identifiers
+        msgs.append(self.check_all_duplicate_identifiers(False, detailed))
+        # perform checks for specific radiance simulation rules
+        # 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
+
+    def check_all_duplicate_identifiers(self, raise_exception=True, detailed=False):
+        """Check that there are no duplicate identifiers for any geometry objects.
+
+        This includes Rooms, Faces, Apertures, Doors, Shades, and ShadeMeshes.
+
+        Args:
+            raise_exception: Boolean to note whether a ValueError should be raised
+                if any Model 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 duplicate identifiers
+        msgs.append(self.check_duplicate_modifier_identifiers(False, detailed))
+        msgs.append(self.check_duplicate_modifier_set_identifiers(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
+
+    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')
+
+    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')
+
+    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 dragonfly-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 = \
+            hb_model_properties.ModelRadianceProperties.load_properties_from_dict(data)
+
+        # collect lists of radiance property dictionaries
+        building_e_dicts, story_e_dicts, room2d_e_dicts, context_e_dicts = \
+            model_extension_dicts(data, 'radiance', [], [], [], [])
+
+        # apply radiance properties to objects using the radiance property dictionaries
+        for bldg, b_dict in zip(self.host.buildings, building_e_dicts):
+            if b_dict is not None:
+                bldg.properties.radiance.apply_properties_from_dict(
+                    b_dict, modifier_sets)
+            if bldg.has_room_3ds and b_dict is not None and 'room_3ds' in b_dict and \
+                    b_dict['room_3ds'] is not None:
+                room_e_dicts, face_e_dicts, shd_e_dicts, ap_e_dicts, dr_e_dicts = \
+                    room_extension_dicts(b_dict['room_3ds'], 'radiance', [], [], [], [], [])
+                for room, r_dict in zip(bldg.room_3ds, 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(bldg.room_3d_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(bldg.room_3d_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(bldg.room_3d_doors, dr_e_dicts):
+                    if d_dict is not None:
+                        door.properties.radiance.apply_properties_from_dict(
+                            d_dict, modifiers)
+                for shade, s_dict in zip(bldg.room_3d_shades, shd_e_dicts):
+                    if s_dict is not None:
+                        shade.properties.radiance.apply_properties_from_dict(
+                            s_dict, modifiers)
+        for story, s_dict in zip(self.host.stories, story_e_dicts):
+            if s_dict is not None:
+                story.properties.radiance.apply_properties_from_dict(
+                    s_dict, modifier_sets)
+        for room, r_dict in zip(self.host.room_2ds, room2d_e_dicts):
+            if r_dict is not None:
+                room.properties.radiance.apply_properties_from_dict(
+                    r_dict, modifier_sets)
+        for shade, s_dict in zip(self.host.context_shades, context_e_dicts):
+            if s_dict is not None:
+                shade.properties.radiance.apply_properties_from_dict(s_dict, modifiers)
+
+    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 = tuple(set(all_mods))
+        base['radiance']['modifiers'] = []
+        for mod in modifiers:
+            base['radiance']['modifiers'].append(mod.to_dict())
+
+        return base
+
+    def to_honeybee(self, new_host):
+        """Get a honeybee version of this object.
+
+        Args:
+            new_host: A honeybee-core Model object that will host these properties.
+        """
+        hb_rad_props = hb_model_properties.ModelRadianceProperties(new_host)
+        # gather all of the sensor grid parameters across the model
+        sg_dict = {}
+        for rm_2d in self.host.room_2ds:
+            if len(rm_2d.properties.radiance._grid_parameters) != 0:
+                sg_dict[rm_2d.identifier] = rm_2d.properties.radiance._grid_parameters
+        # generate and assign sensor grids to the rooms of the new_host
+        if len(sg_dict) != 0:
+            sensor_grids = []
+            for rm_id, g_par in sg_dict.items():
+                for room in new_host.rooms:
+                    if room.identifier == rm_id:
+                        for gp in g_par:
+                            sg = gp.generate_grid_from_room(room)
+                            if sg is not None:
+                                sensor_grids.append(sg)
+                        break
+            hb_rad_props.sensor_grids = sensor_grids
+        return hb_rad_props
+
+    def duplicate(self, new_host=None):
+        """Get a copy of this Model.
+
+        Args:
+            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
+        return ModelRadianceProperties(_host)
+
+    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_obj_mod_set(self, obj, modifier_sets):
+        """Check if a modifier set is assigned to an object and add it to a list."""
+        m_set = obj.properties.radiance._modifier_set
+        if m_set is not None:
+            if not self._instance_in_array(m_set, modifier_sets):
+                modifier_sets.append(m_set)
+
+    @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
+
+    def ToString(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'Model Radiance Properties: {}'.format(self.host.identifier)

dragonfly_radiance/properties/room2d.py

@@ -0,0 +1,230 @@
+# coding=utf-8
+"""Room2D Radiance Properties."""
+from honeybee_radiance.properties.room import RoomRadianceProperties
+from honeybee_radiance.modifierset import ModifierSet
+from honeybee_radiance.lib.modifiersets import generic_modifier_set_visible
+
+import dragonfly_radiance.gridpar as sg_par
+from ..gridpar import _GridParameterBase, RoomGridParameter, RoomRadialGridParameter
+
+
+class Room2DRadianceProperties(object):
+    """Radiance Properties for Dragonfly Room2D.
+
+    Args:
+        host: A dragonfly_core Room2D object that hosts these properties.
+        modifier_set: A honeybee ModifierSet object to specify all default
+            modifiers for the Faces of the Room2D. If None, the Room2D will use
+            the honeybee default modifier set, which is only representative
+            of typical indoor conditions in the visible spectrum. (Default: None).
+        grid_parameters: An optional list of GridParameter objects to describe
+            how sensor grids should be generated for the Room2D. (Default: None).
+
+    Properties:
+        * host
+        * modifier_set
+        * grid_parameters
+    """
+    __slots__ = ('_host', '_modifier_set', '_grid_parameters')
+
+    def __init__(self, host, modifier_set=None, grid_parameters=None):
+        """Initialize Room2D Radiance properties."""
+        self._host = host
+        self.modifier_set = modifier_set
+        self.grid_parameters = grid_parameters
+
+    @property
+    def host(self):
+        """Get the Room2D object hosting these properties."""
+        return self._host
+
+    @property
+    def modifier_set(self):
+        """Get or set the Room2D ModifierSet object.
+
+        If not set, it will be set by the parent Story or will be the Honeybee
+        default generic ModifierSet.
+        """
+        if self._modifier_set is not None:  # set by the user
+            return self._modifier_set
+        elif self._host.has_parent:  # set by parent story
+            return self._host.parent.properties.radiance.modifier_set
+        else:
+            return generic_modifier_set_visible
+
+    @modifier_set.setter
+    def modifier_set(self, value):
+        if value is not None:
+            assert isinstance(value, ModifierSet), \
+                'Expected ModifierSet. Got {}'.format(type(value))
+            value.lock()   # lock in case modifier set has multiple references
+        self._modifier_set = value
+
+    @property
+    def grid_parameters(self):
+        """Get or set a list of GridParameters to generate sensor grids for the room.
+        """
+        return tuple(self._grid_parameters)
+
+    @grid_parameters.setter
+    def grid_parameters(self, value):
+        if value is not None:
+            if not isinstance(value, list):
+                value = list(value)
+            for sg in value:
+                assert isinstance(sg, _GridParameterBase), \
+                    'Expected GridParameter. Got {}'.format(type(sg))
+        else:
+            value = []
+        self._grid_parameters = value
+
+    def remove_grid_parameters(self):
+        """Remove all grid_parameters from the Room2D."""
+        self._grid_parameters = []
+
+    def add_grid_parameter(self, grid_parameter):
+        """Add a GridParameter to this Room2D.
+
+        Args:
+            grid_parameter: An GridParameter objects to describe how sensor grids
+                should be generated for the Room2D.
+        """
+        assert isinstance(grid_parameter, _GridParameterBase), \
+            'Expected GridParameter. Got {}.'.format(type(grid_parameter))
+        self._grid_parameters.append(grid_parameter)
+
+    def make_plenum(self):
+        """Turn the host Room2D into a plenum with no grid parameters inside the room.
+
+        Grid parameters for exterior facades will be kept. This is useful to
+        appropriately assign properties for closets, underfloor spaces, and
+        drop ceilings.
+        """
+        plenum_g_par = []
+        for g_par in self._grid_parameters:
+            if not isinstance(g_par, (RoomGridParameter, RoomRadialGridParameter)):
+                plenum_g_par.append(g_par)
+        self._grid_parameters = plenum_g_par
+
+    @classmethod
+    def from_dict(cls, data, host):
+        """Create Room2DRadianceProperties from a dictionary.
+
+        Note that the dictionary must be a non-abridged version for this
+        classmethod to work.
+
+        Args:
+            data: A dictionary representation of Room2DRadianceProperties in the
+                format below.
+            host: A Room2D object that hosts these properties.
+
+        .. code-block:: python
+
+            {
+            "type": 'Room2DRadianceProperties',
+            "modifier_set": {},  # A ModifierSet dictionary
+            "grid_parameters": []  # A list of GridParameter dictionaries
+            }
+        """
+        assert data['type'] == 'Room2DRadianceProperties', \
+            'Expected Room2DRadianceProperties. Got {}.'.format(data['type'])
+
+        new_prop = cls(host)
+        if 'modifier_set' in data and data['modifier_set'] is not None:
+            new_prop.modifier_set = ModifierSet.from_dict(data['modifier_set'])
+        if 'grid_parameters' in data and data['grid_parameters'] is not None:
+            grd_par = []
+            for gp in data['grid_parameters']:
+                try:
+                    g_class = getattr(sg_par, gp['type'])
+                except AttributeError:
+                    raise ValueError(
+                        'GridParameter "{}" is not recognized.'.format(gp['type']))
+                grd_par.append(g_class.from_dict(gp))
+            new_prop.grid_parameters = grd_par
+
+        return new_prop
+
+    def apply_properties_from_dict(self, abridged_data, modifier_sets):
+        """Apply properties from a Room2DRadiancePropertiesAbridged dictionary.
+
+        Args:
+            abridged_data: A Room2DRadiancePropertiesAbridged dictionary (typically
+                coming from a Model).
+            modifier_sets: A dictionary of ModifierSets with identifiers
+                of the sets as keys, which will be used to re-assign modifier_sets.
+        """
+        if 'modifier_set' in abridged_data and abridged_data['modifier_set'] is not None:
+            self.modifier_set = modifier_sets[abridged_data['modifier_set']]
+        if 'grid_parameters' in abridged_data and \
+                abridged_data['grid_parameters'] is not None:
+            grd_par = []
+            for gp in abridged_data['grid_parameters']:
+                try:
+                    g_class = getattr(sg_par, gp['type'])
+                except AttributeError:
+                    raise ValueError(
+                        'GridParameter "{}" is not recognized.'.format(gp['type']))
+                grd_par.append(g_class.from_dict(gp))
+            self.grid_parameters = grd_par
+
+    def to_dict(self, abridged=False):
+        """Return Room2D radiance properties as a dictionary.
+
+        Args:
+            abridged: Boolean for whether the full dictionary of the Room2D should
+                be written (False) or just the identifier of the the individual
+                properties (True). Default: False.
+        """
+        base = {'radiance': {}}
+        base['radiance']['type'] = 'Room2DRadianceProperties' if not \
+            abridged else 'Room2DRadiancePropertiesAbridged'
+
+        # write the ModifierSet into the dictionary
+        if self._modifier_set is not None:
+            base['radiance']['modifier_set'] = \
+                self._modifier_set.identifier if abridged else \
+                self._modifier_set.to_dict()
+
+        # write the GridParameters into the dictionary
+        if len(self._grid_parameters) != 0:
+            base['radiance']['grid_parameters'] = \
+                [gdp.to_dict() for gdp in self._grid_parameters]
+        return base
+
+    def to_honeybee(self, new_host):
+        """Get a honeybee version of this object.
+
+        Args:
+            new_host: A honeybee-core Room object that will host these properties.
+        """
+        mod_set = self.modifier_set  # includes story and building-assigned sets
+        hb_mods = mod_set if mod_set is not generic_modifier_set_visible else None
+        hb_prop = RoomRadianceProperties(new_host, hb_mods)
+        return hb_prop
+
+    def from_honeybee(self, hb_properties):
+        """Transfer radiance attributes from a Honeybee Room to Dragonfly Room2D.
+
+        Args:
+            hb_properties: The RoomRadianceProperties of the honeybee Room that is being
+                translated to a Dragonfly Room2D.
+        """
+        self._modifier_set = hb_properties._modifier_set
+
+    def duplicate(self, new_host=None):
+        """Get a copy of this object.
+
+        Args:
+            new_host: A new Room2D object that hosts these properties.
+                If None, the properties will be duplicated with the same host.
+        """
+        _host = new_host or self._host
+        return Room2DRadianceProperties(
+            _host, self._modifier_set, self._grid_parameters[:])
+
+    def ToString(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'Room2D Radiance Properties: {}'.format(self.host.identifier)