honeybee-radiance 1.66.190__py3-none-any.whl

honeybee_radiance/geometry/ring.py

@@ -0,0 +1,214 @@
+"""Radiance Ring.
+
+http://radsite.lbl.gov/radiance/refer/ray.html#Ring
+"""
+from .geometrybase import Geometry
+import honeybee.typing as typing
+
+
+class Ring(Geometry):
+    """Radiance Ring.
+
+    A ring is a circular disk given by its center, surface normal, and inner and outer
+    radii:
+
+    .. code-block:: shell
+
+        mod ring id
+        0
+        0
+        8
+                xcent   ycent   zcent
+                xdir    ydir    zdir
+                r0      r1
+
+    Args:
+        identifier: Text string for a unique Geometry ID. Must not contain spaces
+            or special characters. This will be used to identify the object across
+            a model and in the exported Radiance files.
+        center_pt: Ring start center point as (x, y, z) (Default: (0, 0 ,0)).
+        normal_vector: Surface normal as (x, y, z) (Default: (0, 0 ,1)).
+        radius_inner: Ring inner radius as a number (Default: 5).
+        radius_outer: Ring outer radius as a number (Default: 10).
+        modifier: Geometry modifier (Default: None).
+        dependencies: A list of primitives that this primitive depends on. This
+            argument is only useful for defining advanced primitives where the
+            primitive is defined based on other primitives. (Default: [])
+
+    Properties:
+        * identifier
+        * display_name
+        * center_pt
+        * normal_vector
+        * radius_inner
+        * radius_outer
+        * modifier
+        * dependencies
+        * values
+    """
+    __slots__ = ('_center_pt', '_normal_vector', '_radius_inner', '_radius_outer')
+
+    def __init__(self, identifier, center_pt=None, normal_vector=None, radius_inner=5,
+                 radius_outer=10, modifier=None, dependencies=None):
+        """Radiance Ring."""
+        Geometry.__init__(self, identifier, modifier=modifier)
+        self.center_pt = center_pt or (0, 0, 0)
+        self.normal_vector = normal_vector or (0, 0, 1)
+        self.radius_inner = radius_inner if radius_inner is not None else 5
+        self.radius_outer = radius_outer if radius_outer is not None else 10
+
+        self._update_values()
+
+    def _update_values(self):
+        """update value dictionaries."""
+        self._values[2] = \
+            [self.center_pt[0], self.center_pt[1], self.center_pt[2],
+             self.normal_vector[0], self.normal_vector[1], self.normal_vector[2],
+             self.radius_inner, self.radius_outer]
+
+    @property
+    def center_pt(self):
+        """Ring start center point as (x, y, z). Default is (0, 0 ,0)."""
+        return self._center_pt
+
+    @center_pt.setter
+    def center_pt(self, value):
+        self._center_pt = tuple(float(v) for v in value)
+        assert len(self._center_pt) == 3, \
+            'Radiance Ring center point must have 3 values for (x, y, z).'
+
+    @property
+    def radius_inner(self):
+        """Ring inner radius as a number (Default is 5)."""
+        return self._radius_inner
+
+    @radius_inner.setter
+    def radius_inner(self, value):
+        self._radius_inner = typing.float_positive(value)
+
+    @property
+    def normal_vector(self):
+        """Surface normal as (x, y, z) (Default is (0, 0 ,1))."""
+        return self._normal_vector
+
+    @normal_vector.setter
+    def normal_vector(self, value):
+        self._normal_vector = tuple(float(v) for v in value)
+        assert len(self._center_pt) == 3, \
+            'Radiance Ring normal venctor must have 3 values for (x, y, z).'
+
+    @property
+    def radius_outer(self):
+        """Ring outer radius as a number (Default is 10)."""
+        return self._radius_outer
+
+    @radius_outer.setter
+    def radius_outer(self, value):
+        self._radius_outer = typing.float_positive(value)
+
+    @classmethod
+    def from_primitive_dict(cls, primitive_dict):
+        """Initialize a Ring from a primitive dict.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "modifier": {},  # primitive modifier (Default: None)
+            "type": "ring",  # primitive type
+            "identifier": "",  # primitive identifier
+            "display_name": "",  # primitive display name
+            "values": []  # values,
+            "dependencies": []
+            }
+        """
+        assert 'type' in primitive_dict, 'Input dictionary is missing "type".'
+        if primitive_dict['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(), primitive_dict['type'])
+            )
+
+        modifier, dependencies = cls.filter_dict_input(primitive_dict)
+        values = primitive_dict['values'][2]
+
+        cls_ = cls(
+            identifier=primitive_dict['identifier'],
+            center_pt=values[0:3],
+            normal_vector=values[3:6],
+            radius_inner=values[6],
+            radius_outer=values[7],
+            modifier=modifier,
+            dependencies=dependencies
+        )
+        if 'display_name' in primitive_dict and primitive_dict['display_name'] is not None:
+            cls_.display_name = primitive_dict['display_name']
+
+        # this might look redundant but it is NOT. see glass for explanation.
+        cls_.values = primitive_dict['values']
+        return cls_
+
+    @classmethod
+    def from_dict(cls, data):
+        """Initialize a Ring from a dictionary.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "ring",  # Geometry type
+            "modifier": {} ,
+            "identifier": "",  # Geometry identifier
+            "display_name": "",  # Geometry display name
+            "center_pt": (0, 0, 0),
+            "normal_vector": (0, 0, 1),
+            "radius_inner": float,
+            "radius_outer": float,
+            "dependencies": []
+            }
+        """
+        assert 'type' in data, 'Input dictionary is missing "type".'
+        if data['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(),
+                                             data['type'])
+            )
+        modifier, dependencies = cls.filter_dict_input(data)
+
+        new_obj = cls(identifier=data["identifier"],
+                      center_pt=(data["center_pt"]),
+                      radius_inner=data["radius_inner"],
+                      normal_vector=(data["normal_vector"]),
+                      radius_outer=data["radius_outer"],
+                      modifier=modifier,
+                      dependencies=dependencies)
+        if 'display_name' in data and data['display_name'] is not None:
+            new_obj.display_name = data['display_name']
+        return new_obj
+
+    def to_dict(self):
+        """Translate this object to a dictionary."""
+        base = {
+            "modifier": self.modifier.to_dict(),
+            "type": self.__class__.__name__.lower(),
+            "identifier": self.identifier,
+            "center_pt": self.center_pt,
+            "normal_vector": self.normal_vector,
+            "radius_inner": self.radius_inner,
+            "radius_outer": self.radius_outer,
+            'dependencies': [dp.to_dict() for dp in self.dependencies]
+        }
+        if self._display_name is not None:
+            base['display_name'] = self.display_name
+        return base
+
+    def __copy__(self):
+        mod, depend = self._dup_mod_and_depend()
+        new_obj = self.__class__(
+            self.identifier, self.center_pt, self.normal_vector, self.radius_inner,
+            self.radius_outer, mod, depend)
+        new_obj._display_name = self._display_name
+        return new_obj

honeybee_radiance/geometry/source.py

@@ -0,0 +1,182 @@
+"""Radiance Source.
+
+http://radsite.lbl.gov/radiance/refer/ray.html#Source
+"""
+from .geometrybase import Geometry
+import honeybee.typing as typing
+
+
+class Source(Geometry):
+    """Radiance Source.
+
+    A source is not really a surface, but a solid angle. It is used for specifying light
+    sources that are very distant. The direction to the center of the source and the
+    number of degrees subtended by its disk are given as follows:
+
+    .. code-block:: shell
+
+        mod source id
+        0
+        0
+        4 xdir ydir zdir angle
+
+    Args:
+        identifier: Text string for a unique Geometry ID. Must not contain spaces
+            or special characters. This will be used to identify the object across
+            a model and in the exported Radiance files.
+        direction: A vector to set source direction (x, y, z) (Default: (0, 0 ,-1)).
+        angle: Source solid angle (Default: 0.533).
+        modifier: Geometry modifier (Default: None).
+        dependencies: A list of primitives that this primitive depends on. This
+            argument is only useful for defining advanced primitives where the
+            primitive is defined based on other primitives. (Default: [])
+
+    Properties:
+        * identifier
+        * display_name
+        * direction
+        * angle
+        * modifier
+        * dependencies
+        * values
+
+    Usage:
+
+    .. code-block:: python
+
+        source = Source("test_source", (0, 0, 10), 10)
+        print(source)
+    """
+    __slots__ = ('_direction', '_angle')
+
+    def __init__(self, identifier, direction=None, angle=0.533, modifier=None,
+                 dependencies=None):
+        """Radiance Source."""
+        Geometry.__init__(self, identifier, modifier=modifier, dependencies=dependencies)
+        self.direction = direction or (0, 0, -1)
+        self.angle = angle if angle is not None else 0.533
+
+        self._update_values()
+
+    def _update_values(self):
+        """update values dictionary."""
+        self._values[2] = \
+            [self.direction[0], self.direction[1], self.direction[2], self.angle]
+
+    @property
+    def direction(self):
+        """A vector to set source direction (x, y, z) (Default is (0, 0 ,-1))."""
+        return self._direction
+
+    @direction.setter
+    def direction(self, value):
+        self._direction = tuple(float(v) for v in value)
+        assert len(self._direction) == 3, \
+            'Radiance Source direction must have 3 values for (x, y, z).'
+
+    @property
+    def angle(self):
+        """Source solid angle. Default is 0.533."""
+        return self._angle
+
+    @angle.setter
+    def angle(self, value):
+        self._angle = typing.float_positive(value)
+
+    @classmethod
+    def from_primitive_dict(cls, primitive_dict):
+        """Initialize a Source from a primitive dict.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "modifier": {},  # primitive modifier (Default: None)
+            "type": "source",  # primitive type
+            "identifier": "",  # primitive identifier
+            "display_name": "",  # primitive display name
+            "values": [],  # values
+            "dependencies": []
+            }
+        """
+        assert 'type' in primitive_dict, 'Input dictionary is missing "type".'
+        if primitive_dict['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(), primitive_dict['type'])
+            )
+
+        modifier, dependencies = cls.filter_dict_input(primitive_dict)
+        values = primitive_dict['values'][2]
+
+        cls_ = cls(
+            identifier=primitive_dict['identifier'],
+            direction=values[0:3],
+            angle=values[3],
+            modifier=modifier,
+            dependencies=dependencies
+        )
+        if 'display_name' in primitive_dict and primitive_dict['display_name'] is not None:
+            cls_.display_name = primitive_dict['display_name']
+
+        # this might look redundant but it is NOT. see glass for explanation.
+        cls_.values = primitive_dict['values']
+        return cls_
+
+    @classmethod
+    def from_dict(cls, data):
+        """Initialize a Ring from a dictionary.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "source",  # Geometry type
+            "modifier": {} ,
+            "identifier": "",  # Geometry identifier
+            "display_name": "",  # Geometry display name
+            "direction": {"x": float, "y": float, "z": float},
+            "angle": float,
+            "dependencies": []
+            }
+        """
+        assert 'type' in data, 'Input dictionary is missing "type".'
+        if data['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(),
+                    data['type'])
+            )
+        modifier, dependencies = cls.filter_dict_input(data)
+
+        new_obj = cls(identifier=data["identifier"],
+                      direction=(data["direction"]),
+                      angle=data["angle"],
+                      modifier=modifier,
+                      dependencies=dependencies)
+        if 'display_name' in data and data['display_name'] is not None:
+            new_obj.display_name = data['display_name']
+        return new_obj
+
+    def to_dict(self):
+        """Translate this object to a dictionary."""
+        base = {
+            "modifier": self.modifier.to_dict(),
+            "type": self.__class__.__name__.lower(),
+            "identifier": self.identifier,
+            "direction": self.direction,
+            "angle": self.angle,
+            'dependencies': [dp.to_dict() for dp in self.dependencies]
+        }
+        if self._display_name is not None:
+            base['display_name'] = self.display_name
+        return base
+
+    def __copy__(self):
+        mod, depend = self._dup_mod_and_depend()
+        new_obj = self.__class__(
+            self.identifier, self.direction, self.angle, mod, depend)
+        new_obj._display_name = self._display_name
+        return new_obj

honeybee_radiance/geometry/sphere.py

@@ -0,0 +1,178 @@
+"""Radiance Sphere.
+
+http://radsite.lbl.gov/radiance/refer/ray.html#Sphere
+"""
+from .geometrybase import Geometry
+import honeybee.typing as typing
+
+
+class Sphere(Geometry):
+    """Radiance Sphere.
+
+    .. code-block:: shell
+
+        mod sphere id
+        0
+        0
+        4 xcent ycent zcent radius
+
+    Args:
+        identifier: Text string for a unique Geometry ID. Must not contain spaces
+            or special characters. This will be used to identify the object across
+            a model and in the exported Radiance files.
+        center_pt: Sphere center point as (x, y, z) (Default: (0, 0 ,0)).
+        radius: Sphere radius as a number (Default: 10).
+        modifier: Geometry modifier (Default: None).
+        dependencies: A list of primitives that this primitive depends on. This
+            argument is only useful for defining advanced primitives where the
+            primitive is defined based on other primitives. (Default: [])
+
+    Properties:
+        * identifier
+        * display_name
+        * center_pt
+        * radius
+        * modifier
+        * dependencies
+        * values
+
+    Usage:
+
+    .. code-block:: python
+
+        sphere = Sphere("test_sphere", (0, 0, 10), 10)
+        print(sphere)
+    """
+    __slots__ = ('_center_pt', '_radius')
+
+    def __init__(self, identifier, center_pt=None, radius=10, modifier=None,
+                 dependencies=None):
+        """Radiance Sphere."""
+        Geometry.__init__(self, identifier, modifier=modifier, dependencies=dependencies)
+        self.center_pt = center_pt or (0, 0, 0)
+        self.radius = radius if radius is not None else 10
+
+        self._update_values()
+
+    def _update_values(self):
+        """update value dictionaries."""
+        self._values[2] = \
+            [self.center_pt[0], self.center_pt[1], self.center_pt[2], self.radius]
+
+    @property
+    def center_pt(self):
+        """Sphere center point as (x, y, z). Default is (0, 0 ,0)."""
+        return self._center_pt
+
+    @center_pt.setter
+    def center_pt(self, value):
+        self._center_pt = tuple(float(v) for v in value)
+        assert len(self._center_pt) == 3, \
+            'Radiance Sphere center point must have 3 values for (x, y, z).'
+
+    @property
+    def radius(self):
+        """Sphere radius as a number. Default is 10."""
+        return self._radius
+
+    @radius.setter
+    def radius(self, value):
+        self._radius = typing.float_positive(value)
+
+    @classmethod
+    def from_primitive_dict(cls, primitive_dict):
+        """Initialize a Sphere from a primitive dict.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "modifier": {},  # primitive modifier (Default: None)
+            "type": "sphere",  # primitive type
+            "identifier": "",  # primitive identifier
+            "display_name": "",  # primitive display name
+            "values": [],  # values
+            "dependencies": []
+            }
+        """
+        assert 'type' in primitive_dict, 'Input dictionary is missing "type".'
+        if primitive_dict['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(), primitive_dict['type'])
+            )
+
+        modifier, dependencies = cls.filter_dict_input(primitive_dict)
+        values = primitive_dict['values'][2]
+
+        cls_ = cls(
+            identifier=primitive_dict['identifier'],
+            center_pt=values[0:3],
+            radius=values[3],
+            modifier=modifier,
+            dependencies=dependencies
+        )
+        if 'display_name' in primitive_dict and primitive_dict['display_name'] is not None:
+            cls_.display_name = primitive_dict['display_name']
+
+        # this might look redundant but it is NOT. see glass for explanation.
+        cls_.values = primitive_dict['values']
+        return cls_
+
+    @classmethod
+    def from_dict(cls, data):
+        """Initialize a Sphere from a dictionary.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "sphere",  # Geometry type
+            "modifier": {} ,
+            "identifier": "",  # Geometry identifier
+            "display_name": "",  # Geometry display name
+            "center_pt": {"x": float, "y": float, "z": float},
+            "radius": float,
+            "dependencies": []
+            }
+        """
+        assert 'type' in data, 'Input dictionary is missing "type".'
+        if data['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(),
+                    data['type'])
+            )
+        modifier, dependencies = cls.filter_dict_input(data)
+
+        new_obj = cls(identifier=data["identifier"],
+                      center_pt=(data["center_pt"]),
+                      radius=data["radius"],
+                      modifier=modifier,
+                      dependencies=dependencies)
+        if 'display_name' in data and data['display_name'] is not None:
+            new_obj.display_name = data['display_name']
+        return new_obj
+
+    def to_dict(self):
+        """Translate this object to a dictionary."""
+        base = {
+            "modifier": self.modifier.to_dict(),
+            "type": self.__class__.__name__.lower(),
+            "identifier": self.identifier,
+            "center_pt": self.center_pt,
+            "radius": self.radius,
+            'dependencies': [dp.to_dict() for dp in self.dependencies]
+        }
+        if self._display_name is not None:
+            base['display_name'] = self.display_name
+        return base
+
+    def __copy__(self):
+        mod, depend = self._dup_mod_and_depend()
+        new_obj = self.__class__(
+            self.identifier, self.center_pt, self.radius, mod, depend)
+        new_obj._display_name = self._display_name
+        return new_obj

honeybee_radiance/geometry/tube.py

@@ -0,0 +1,46 @@
+"""Radiance Tube.
+
+http://radsite.lbl.gov/radiance/refer/ray.html#Tube
+"""
+from .cylinder import Cylinder
+
+
+class Tube(Cylinder):
+    """Radiance Tube.
+    A tube is an inverted cylinder. A cylinder is like a cone, but its starting and
+    ending radii are equal.
+
+    .. code-block:: shell
+
+        mod tube id
+        0
+        0
+        7
+                x0      y0      z0
+                x1      y1      z1
+                rad
+
+    Args:
+        identifier: Text string for a unique Geometry ID. Must not contain spaces
+            or special characters. This will be used to identify the object across
+            a model and in the exported Radiance files.
+        center_pt_start: Tube start center point as (x, y, z)
+            (Default: (0, 0 ,0)).
+        center_pt_end: Tube end center point as (x, y, z) (Default: (0, 0 ,10)).
+        radius: Tube start radius as a number (Default: 10).
+        modifier: Geometry modifier (Default: None).
+        dependencies: A list of primitives that this primitive depends on. This
+            argument is only useful for defining advanced primitives where the
+            primitive is defined based on other primitives. (Default: [])
+
+    Properties:
+        * identifier
+        * display_name
+        * center_pt_start
+        * center_pt_end
+        * radius
+        * values
+        * modifier
+        * dependencies
+    """
+    pass

honeybee_radiance/lib/__init__.py

@@ -0,0 +1 @@
+"""Library of modifiers and modifier sets used in honeybee-radiance."""

honeybee_radiance/lib/_loadmodifiers.py

@@ -0,0 +1,72 @@
+"""Load all modifiers from the IDF libraries."""
+from honeybee_radiance.config import folders
+from honeybee_radiance.reader import string_to_dicts
+from honeybee_radiance.mutil import dict_to_modifier, modifier_class_from_type_string
+
+import os
+import json
+
+
+# empty dictionary to hold loaded modifiers
+_loaded_modifiers = {}
+
+
+# first load the honeybee defaults
+with open(folders.defaults_file) as json_file:
+    default_data = json.load(json_file)['modifiers']
+for mod_dict in default_data:
+    m_class = modifier_class_from_type_string(mod_dict['type'])
+    mod = m_class.from_dict(mod_dict)
+    mod.lock()
+    _loaded_modifiers[mod_dict['identifier']] = mod
+_default_mods = set(list(_loaded_modifiers.keys()))
+
+
+# then load modifiers from the user-supplied files
+def load_modifier_object(mod_dict, user_modifiers):
+    """Load a modifier object from a dictionary and add it to the library dict."""
+    try:
+        m_class = modifier_class_from_type_string(mod_dict['type'])
+        mod = m_class.from_dict(mod_dict)
+        mod.lock()
+        assert mod_dict['identifier'] not in _default_mods, 'Cannot overwrite ' \
+            'default modifier "{}".'.format(mod_dict['identifier'])
+        user_modifiers[mod_dict['identifier']] = mod
+    except (TypeError, KeyError):
+        pass  # not a Honeybee Modifier JSON; possibly a comment
+
+
+def load_modifiers_from_folder(modifier_lib_folder):
+    """Load all of the material layer objects from a modifier standards folder.
+
+    Args:
+        modifier_lib_folder: Path to a modifiers sub-folder within a
+            honeybee standards folder.
+    """
+    user_modifiers = {}
+    for f in os.listdir(modifier_lib_folder):
+        f_path = os.path.join(modifier_lib_folder, f)
+        if os.path.isfile(f_path):
+            if f_path.endswith('.mat') or f_path.endswith('.rad'):
+                with open(f_path) as f:
+                    try:
+                        rad_dicts = string_to_dicts(f.read())
+                        for mod_dict in rad_dicts:
+                            mod = dict_to_modifier(mod_dict)
+                            mod.lock()
+                            user_modifiers[mod.identifier] = mod
+                    except ValueError:
+                        pass  # empty rad file with no modifiers in them
+            if f_path.endswith('.json'):
+                with open(f_path) as json_file:
+                    data = json.load(json_file)
+                if 'type' in data:  # single object
+                    load_modifier_object(data, user_modifiers)
+                else:  # a collection of several objects
+                    for mod_identifier in data:
+                        load_modifier_object(data[mod_identifier], user_modifiers)
+    return user_modifiers
+
+
+user_mods = load_modifiers_from_folder(folders.modifier_lib)
+_loaded_modifiers.update(user_mods)