dragonfly-radiance 0.4.121__py3-none-any.whl

dragonfly_radiance/properties/building.py

@@ -0,0 +1,163 @@
+# coding=utf-8
+"""Building Radiance Properties."""
+from honeybee_radiance.modifierset import ModifierSet
+from honeybee_radiance.lib.modifiersets import generic_modifier_set_visible
+
+import dragonfly_radiance.gridpar as sg_par
+
+
+class BuildingRadianceProperties(object):
+    """Radiance Properties for Dragonfly Building.
+
+    Args:
+        host: A dragonfly_core Building object that hosts these properties.
+        modifier_set: A honeybee ModifierSet object to specify all default modifiers
+            for the Story geometry. If None, it will be the honeybee default modifier
+            set, which is only representative of typical indoor conditions in
+            the visible spectrum. (Default: None).
+
+    Properties:
+        * host
+        * modifier_set
+    """
+    __slots__ = ('_host', '_modifier_set')
+
+    def __init__(self, host, modifier_set=None):
+        """Initialize Building radiance properties."""
+        self._host = host
+        self.modifier_set = modifier_set
+
+    @property
+    def host(self):
+        """Get the Building object hosting these properties."""
+        return self._host
+
+    @property
+    def modifier_set(self):
+        """Get or set the Building ModifierSet object.
+
+        If not set, it will be the Honeybee default generic ModifierSet.
+        """
+        if self._modifier_set is not None:  # set by the user
+            return self._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
+
+    def add_grid_parameter(self, grid_par):
+        """Add a GridParameter to all of the children Room2Ds of this Building.
+
+        Args:
+            grid_par: A radiance GridParameter object to assign to all children Room2Ds.
+        """
+        for room_2d in self.host.unique_room_2ds:
+            room_2d.properties.radiance.add_grid_parameter(grid_par)
+
+    def make_plenums(self, room_ids):
+        """Turn Room2Ds on the host Building into plenums with no inside grid parameters.
+
+        Grid parameters for exterior facades will be kept. This is useful to
+        appropriately assign properties for closets, underfloor spaces, and
+        drop ceilings.
+
+        Args:
+            room_ids: A list of identifiers for Room2Ds on this Building to be
+                converted into plenums.
+        """
+        room_ids = set(room_ids)
+        for rm in self.host.unique_room_2ds:
+            if rm.identifier in room_ids:
+                rm.properties.radiance.make_plenum()
+
+    @classmethod
+    def from_dict(cls, data, host):
+        """Create BuildingRadianceProperties from a dictionary.
+
+        Note that the dictionary must be a non-abridged version for this
+        classmethod to work.
+
+        Args:
+            data: A dictionary representation of BuildingRadianceProperties.
+            host: A Building object that hosts these properties.
+        """
+        assert data['type'] == 'BuildingRadianceProperties', \
+            'Expected BuildingRadianceProperties. 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'])
+
+        return new_prop
+
+    def apply_properties_from_dict(self, abridged_data, modifier_sets):
+        """Apply properties from a BuildingRadiancePropertiesAbridged dictionary.
+
+        Args:
+            abridged_data: A BuildingRadiancePropertiesAbridged 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']]
+
+    def apply_properties_from_geojson_dict(self, data):
+        """Apply properties from a geoJSON dictionary.
+
+        Args:
+            data: A dictionary representation of a geoJSON feature properties.
+                Specifically, this should be the "properties" key describing
+                a Polygon or MultiPolygon object.
+        """
+        # assign the construction set based on climate zone
+        if 'grid_parameters' in data and data['grid_parameters'] is not None:
+            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']))
+                self.add_grid_parameter(g_class.from_dict(gp))
+
+    def to_dict(self, abridged=False):
+        """Return Building Radiance properties as a dictionary.
+
+        Args:
+            abridged: Boolean for whether the full dictionary of the Building should
+                be written (False) or just the identifier of the the individual
+                properties (True). Default: False.
+        """
+        base = {'radiance': {}}
+        base['radiance']['type'] = 'BuildingRadianceProperties' if not \
+            abridged else 'BuildingRadiancePropertiesAbridged'
+
+        # 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()
+
+        return base
+
+    def duplicate(self, new_host=None):
+        """Get a copy of this object.
+
+        new_host: A new Building object that hosts these properties.
+            If None, the properties will be duplicated with the same host.
+        """
+        _host = new_host or self._host
+        return BuildingRadianceProperties(_host, self._modifier_set)
+
+    def ToString(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'Building Radiance Properties: {}'.format(self.host.identifier)

dragonfly_radiance/properties/context.py

@@ -0,0 +1,139 @@
+# coding=utf-8
+"""Context Shade Radiance Properties."""
+from honeybee.shade import Shade
+from honeybee_radiance.modifier import Modifier
+from honeybee_radiance.properties.shade import ShadeRadianceProperties
+from honeybee_radiance.properties.shademesh import ShadeMeshRadianceProperties
+from honeybee_radiance.mutil import dict_to_modifier  # imports all modifiers classes
+from honeybee_radiance.lib.modifiers import generic_context
+
+
+class ContextShadeRadianceProperties(object):
+    """Radiance Properties for Dragonfly ContextShade.
+
+    Args:
+        host_shade: A dragonfly_core ContextShade object that hosts these properties.
+        modifier: An optional Modifier object to set the reflectance and specularity
+            of the ContextShade. The default is a completely diffuse modifier
+            with 0.2 reflectance.
+
+    Properties:
+        * host
+        * modifier
+        * is_modifier_set_by_user
+    """
+
+    __slots__ = ('_host', '_modifier')
+
+    def __init__(self, host_shade, modifier=None):
+        """Initialize ContextShade radiance properties."""
+        self._host = host_shade
+        self.modifier = modifier
+
+    @property
+    def host(self):
+        """Get the Shade object hosting these properties."""
+        return self._host
+
+    @property
+    def modifier(self):
+        """Get or set a Modifier for the context shade."""
+        if self._modifier:  # set by user
+            return self._modifier
+        else:
+            return generic_context
+
+    @modifier.setter
+    def modifier(self, value):
+        if value is not None:
+            assert isinstance(value, Modifier), \
+                'Expected Modifier. Got {}.'.format(type(value))
+            value.lock()  # lock editing in case modifier has multiple references
+        self._modifier = value
+
+    @property
+    def is_modifier_set_by_user(self):
+        """Boolean noting if modifier is user-set."""
+        return self._modifier is not None
+
+    @classmethod
+    def from_dict(cls, data, host):
+        """Create ContextShadeRadianceProperties from a dictionary.
+
+        Note that the dictionary must be a non-abridged version for this
+        classmethod to work.
+
+        Args:
+            data: A dictionary representation of ContextShadeRadianceProperties.
+            host: A ContextShade object that hosts these properties.
+        """
+        assert data['type'] == 'ContextShadeRadianceProperties', \
+            'Expected ContextShadeRadianceProperties. Got {}.'.format(data['type'])
+
+        new_prop = cls(host)
+        if 'modifier' in data and data['modifier'] is not None:
+            new_prop.modifier = dict_to_modifier(data['modifier'])
+        return new_prop
+
+    def apply_properties_from_dict(self, abridged_data, modifiers):
+        """Apply properties from a ContextShadeRadiancePropertiesAbridged dictionary.
+
+        Args:
+            abridged_data: A ContextShadeRadiancePropertiesAbridged dictionary (typically
+                coming from a Model).
+            modifiers: A dictionary of modifiers with modifiers identifiers
+                as keys, which will be used to re-assign modifiers.
+        """
+        if 'modifier' in abridged_data and abridged_data['modifier'] is not None:
+            self.modifier = modifiers[abridged_data['modifier']]
+
+    def to_dict(self, abridged=False):
+        """Return radiance properties as a dictionary.
+
+        Args:
+            abridged: Boolean to note whether the full dictionary describing the
+                object should be returned (False) or just an abridged version (True).
+                Default: False.
+        """
+        base = {'radiance': {}}
+        base['radiance']['type'] = 'ContextShadeRadianceProperties' if not \
+            abridged else 'ContextShadeRadiancePropertiesAbridged'
+        if self._modifier is not None:
+            base['radiance']['modifier'] = self._modifier.identifier if abridged \
+                else self._modifier.to_dict()
+        return base
+
+    def to_honeybee(self, new_host):
+        """Get a honeybee version of this object.
+
+        Args:
+            new_host: A honeybee-core Shade or ShadeMesh object that will host
+                these properties.
+        """
+        return ShadeRadianceProperties(new_host, self._modifier) \
+            if isinstance(new_host, Shade) else \
+            ShadeMeshRadianceProperties(new_host, self._modifier)
+
+    def from_honeybee(self, hb_properties):
+        """Transfer radiance attributes from a Honeybee Shade to Dragonfly ContextShade.
+
+        Args:
+            hb_properties: The ShadeRadianceProperties of the honeybee Shade
+                that is being translated to a Dragonfly ContextShade.
+        """
+        self._modifier = hb_properties._modifier
+
+    def duplicate(self, new_host=None):
+        """Get a copy of this object.
+
+        new_host: A new ContextShade object that hosts these properties.
+            If None, the properties will be duplicated with the same host.
+        """
+        _host = new_host or self._host
+        return ContextShadeRadianceProperties(_host, self._modifier)
+
+    def ToString(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'Context Shade Radiance Properties: {}'.format(self.host.identifier)