honeybee-energy 1.116.106__py3-none-any.whl

honeybee_energy/lib/materials.py

@@ -0,0 +1,67 @@
+"""Establish the default materials within the honeybee_energy library."""
+from honeybee_energy.material.dictutil import dict_to_material
+
+from ._loadconstructions import _opaque_materials, _window_materials
+from ._loadmaterials import _opaque_mat_standards_dict, _window_mat_standards_dict
+
+
+# establish variables for the default materials used across the library
+brick = _opaque_materials['Generic Brick']
+concrete_lw = _opaque_materials['Generic LW Concrete']
+concrete_hw = _opaque_materials['Generic HW Concrete']
+insulation = _opaque_materials['Generic 50mm Insulation']
+insulation_thin = _opaque_materials['Generic 25mm Insulation']
+gypsum = _opaque_materials['Generic Gypsum Board']
+acoustic_tile = _opaque_materials['Generic Acoustic Tile']
+painted_metal = _opaque_materials['Generic Painted Metal']
+roof_membrane = _opaque_materials['Generic Roof Membrane']
+wood = _opaque_materials['Generic 25mm Wood']
+wall_gap = _opaque_materials['Generic Wall Air Gap']
+ceiling_gap = _opaque_materials['Generic Ceiling Air Gap']
+clear_glass = _window_materials['Generic Clear Glass']
+lowe_glass = _window_materials['Generic Low-e Glass']
+air_gap = _window_materials['Generic Window Air Gap']
+argon_gap = _window_materials['Generic Window Argon Gap']
+
+
+# make lists of material identifiers to look up items in the library
+OPAQUE_MATERIALS = tuple(_opaque_materials.keys()) + \
+    tuple(_opaque_mat_standards_dict.keys())
+WINDOW_MATERIALS = tuple(_window_materials.keys()) + \
+    tuple(_window_mat_standards_dict.keys())
+
+
+def opaque_material_by_identifier(material_identifier):
+    """Get an opaque material from the library given the material identifier.
+
+    Args:
+        material_identifier: A text string for the identifier of the material.
+    """
+    try:  # first check the default data
+        return _opaque_materials[material_identifier]
+    except KeyError:
+        try:  # search the extension data
+            _mat_dict = _opaque_mat_standards_dict[material_identifier]
+            return dict_to_material(_mat_dict)
+        except KeyError:  # material is nowhere to be found; raise an error
+            raise ValueError(
+                '"{}" was not found in the opaque energy material library.'.format(
+                    material_identifier))
+
+
+def window_material_by_identifier(material_identifier):
+    """Get an window material from the library given the material identifier.
+
+    Args:
+        material_identifier: A text string for the identifier of the material.
+    """
+    try:  # first check the default data
+        return _window_materials[material_identifier]
+    except KeyError:
+        try:  # search the extension data
+            _mat_dict = _window_mat_standards_dict[material_identifier]
+            return dict_to_material(_mat_dict)
+        except KeyError:  # material is nowhere to be found; raise an error
+            raise ValueError(
+                '"{}" was not found in the window energy material library.'.format(
+                    material_identifier))

honeybee_energy/lib/programtypes.py

@@ -0,0 +1,125 @@
+"""Collection of program types."""
+from honeybee_energy.programtype import ProgramType
+
+from ._loadprogramtypes import _program_types, _program_types_standards_dict, \
+    _program_types_standards_registry, _building_programs_dict
+import honeybee_energy.lib.schedules as _s
+
+
+# establish variables for the default schedules used across the library
+plenum_program = _program_types['Plenum']
+office_program = _program_types['Generic Office Program']
+
+
+# make lists of program types to look up items in the library
+PROGRAM_TYPES = tuple(_program_types.keys()) + \
+    tuple(_program_types_standards_dict.keys())
+STANDARDS_REGISTRY = _program_types_standards_registry
+BUILDING_TYPES = tuple(_building_programs_dict.keys())
+
+
+def program_type_by_identifier(program_type_identifier):
+    """Get a program_type from the library given its identifier.
+
+    Args:
+        program_type_identifier: A text string for the identifier of the ProgramType.
+    """
+    try:
+        return _program_types[program_type_identifier]
+    except KeyError:
+        try:  # search the extension data
+            p_type_dict = _program_types_standards_dict[program_type_identifier]
+            scheds = _scheds_from_ptype_dict(p_type_dict)
+            return ProgramType.from_dict_abridged(p_type_dict, scheds)
+        except KeyError:  # construction is nowhere to be found; raise an error
+            raise ValueError('"{}" was not found in the program type library.'.format(
+                program_type_identifier))
+
+
+def building_program_type_by_identifier(building_type):
+    """Get a program_type representing the program mix of a building_type.
+
+    Args:
+        building_type: A text string for the type of building. This must appear
+            under the BUILDING_TYPES constant of this module.
+    """
+    program_id = '{} Building'.format(building_type)
+    try:
+        return _program_types[program_id]
+    except KeyError:
+        try:  # search the extension data
+            bld_mix_dict = _building_programs_dict[building_type]
+            progs, ratios = [], []
+            for key, val in bld_mix_dict.items():
+                progs.append(program_type_by_identifier(key))
+                ratios.append(val)
+            bld_program = ProgramType.average(program_id, progs, ratios)
+            bld_program.lock()
+            _program_types[program_id] = bld_program  # cache the object for next time
+            return bld_program
+        except KeyError:  # construction is nowhere to be found; raise an error
+            raise ValueError(
+                '"{}" was not found in the building types.\nChoose from:\n{}'.format(
+                    building_type, '\n'.join(BUILDING_TYPES)))
+
+
+def _scheds_from_ptype_dict(p_type_dict):
+    """Get a dictionary of schedules used in a ProgramTypeAbridged dictionary."""
+    def add_schedule(scheds, p_type_dict, load_id, sch_id):
+        try:
+            sch_id = p_type_dict[load_id][sch_id]
+            scheds[sch_id] = _s.schedule_by_identifier(sch_id)
+        except KeyError:
+            pass  # key is not included
+
+    scheds = {}
+    add_schedule(scheds, p_type_dict, 'people', 'occupancy_schedule')
+    add_schedule(scheds, p_type_dict, 'people', 'activity_schedule')
+    add_schedule(scheds, p_type_dict, 'lighting', 'schedule')
+    add_schedule(scheds, p_type_dict, 'electric_equipment', 'schedule')
+    add_schedule(scheds, p_type_dict, 'gas_equipment', 'schedule')
+    add_schedule(scheds, p_type_dict, 'service_hot_water', 'schedule')
+    add_schedule(scheds, p_type_dict, 'infiltration', 'schedule')
+    add_schedule(scheds, p_type_dict, 'ventilation', 'schedule')
+    add_schedule(scheds, p_type_dict, 'setpoint', 'heating_schedule')
+    add_schedule(scheds, p_type_dict, 'setpoint', 'cooling_schedule')
+    add_schedule(scheds, p_type_dict, 'setpoint', 'humidifying_schedule')
+    add_schedule(scheds, p_type_dict, 'setpoint', 'dehumidifying_schedule')
+    return scheds
+
+
+def lib_dict_abridged_to_program_type(program_dict, schedules):
+    """Get a Python object of a ProgramType from an abridged dictionary.
+
+    When the sub-objects needed to create the program type are not available
+    in the resources provided, the current standards library will be searched.
+
+    Args:
+        program_dict: An abridged dictionary of a Honeybee ProgramType.
+        schedules: Dictionary of all schedule objects that might be used in the
+            construction set with the schedule identifiers as the keys.
+
+    Returns:
+        A Python object derived from the input program_dict.
+    """
+    def add_schedule(scheds, p_type_dict, load_id, sch_id):
+        try:
+            sch_id = p_type_dict[load_id][sch_id]
+            if sch_id not in scheds:
+                scheds[sch_id] = _s.schedule_by_identifier(sch_id)
+        except KeyError:
+            pass  # key is not included
+
+    add_schedule(schedules, program_dict, 'people', 'occupancy_schedule')
+    add_schedule(schedules, program_dict, 'people', 'activity_schedule')
+    add_schedule(schedules, program_dict, 'lighting', 'schedule')
+    add_schedule(schedules, program_dict, 'electric_equipment', 'schedule')
+    add_schedule(schedules, program_dict, 'gas_equipment', 'schedule')
+    add_schedule(schedules, program_dict, 'service_hot_water', 'schedule')
+    add_schedule(schedules, program_dict, 'infiltration', 'schedule')
+    add_schedule(schedules, program_dict, 'ventilation', 'schedule')
+    add_schedule(schedules, program_dict, 'setpoint', 'heating_schedule')
+    add_schedule(schedules, program_dict, 'setpoint', 'cooling_schedule')
+    add_schedule(schedules, program_dict, 'setpoint', 'humidifying_schedule')
+    add_schedule(schedules, program_dict, 'setpoint', 'dehumidifying_schedule')
+    return ProgramType.from_dict_abridged(program_dict, schedules)

honeybee_energy/lib/schedules.py

@@ -0,0 +1,61 @@
+"""Establish the default schedule types within the honeybee_energy library."""
+from honeybee_energy.schedule.dictutil import dict_abridged_to_schedule
+from ._loadschedules import _schedules, _schedule_standards_dict
+
+import honeybee_energy.lib.scheduletypelimits as _stl
+
+
+# establish variables for the default schedules used across the library
+seated_activity = _schedules['Seated Adult Activity']
+always_on = _schedules['Always On']
+generic_office_occupancy = _schedules['Generic Office Occupancy']
+generic_office_lighting = _schedules['Generic Office Lighting']
+generic_office_equipment = _schedules['Generic Office Equipment']
+generic_office_infiltration = _schedules['Generic Office Infiltration']
+generic_office_heating = _schedules['Generic Office Heating']
+generic_office_cooling = _schedules['Generic Office Cooling']
+
+
+# make lists of schedules to look up items in the library
+SCHEDULES = tuple(_schedules.keys()) + tuple(_schedule_standards_dict.keys())
+
+
+def schedule_by_identifier(schedule_identifier):
+    """Get a schedule from the library given its identifier.
+
+    Args:
+        schedule_identifier: A text string for the identifier of the schedule.
+    """
+    try:  # first check the default data
+        return _schedules[schedule_identifier]
+    except KeyError:
+        try:  # search the extension data
+            _sch_dict = _schedule_standards_dict[schedule_identifier]
+            try:
+                _tl = _stl.schedule_type_limit_by_identifier(
+                    _sch_dict['schedule_type_limit'])
+            except KeyError:
+                _tl = _stl.fractional
+            return dict_abridged_to_schedule(_sch_dict, {_tl.identifier: _tl})
+        except KeyError:  # schedule is nowhere to be found; raise an error
+            raise ValueError('"{}" was not found in the schedule library.'.format(
+                schedule_identifier))
+
+
+def lib_dict_abridged_to_schedule(sch_dict, schedule_type_limits):
+    """Get a Python object of any Schedule from an abridged dictionary.
+
+    Args:
+        sch_dict: A dictionary of any Honeybee energy schedules. Note
+            that this should be a non-abridged dictionary to be valid.
+        schedule_type_limits: Dictionary of all schedule type limit objects that
+            might be used in the schedule with the type limit identifiers as the keys.
+
+    Returns:
+        A Python object derived from the input sch_dict.
+    """
+    if 'schedule_type_limit' in sch_dict and sch_dict['schedule_type_limit'] is not None:
+        if sch_dict['schedule_type_limit'] not in schedule_type_limits:
+            schedule_type_limits[sch_dict['schedule_type_limit']] = \
+                _stl.schedule_type_limit_by_identifier(sch_dict['schedule_type_limit'])
+    return dict_abridged_to_schedule(sch_dict, schedule_type_limits)

honeybee_energy/lib/scheduletypelimits.py

@@ -0,0 +1,31 @@
+"""Establish the default schedule types within the honeybee_energy library."""
+from ._loadtypelimits import _schedule_type_limits
+
+
+# establish variables for the default schedule types used across the library
+fractional = _schedule_type_limits['Fractional']
+on_off = _schedule_type_limits['On-Off']
+temperature = _schedule_type_limits['Temperature']
+activity_level = _schedule_type_limits['Activity Level']
+power = _schedule_type_limits['Power']
+humidity = _schedule_type_limits['Humidity']
+angle = _schedule_type_limits['Angle']
+delta_temperature = _schedule_type_limits['Delta Temperature']
+
+
+# make lists of schedule types to look up items in the library
+SCHEDULE_TYPE_LIMITS = tuple(_schedule_type_limits.keys())
+
+
+def schedule_type_limit_by_identifier(schedule_type_limit_identifier):
+    """Get a schedule type from the library given its identifier.
+
+    Args:
+        schedule_type_limit_identifier: A text string for the identifier of the
+            schedule type.
+    """
+    try:
+        return _schedule_type_limits[schedule_type_limit_identifier]
+    except KeyError:
+        raise ValueError('"{}" was not found in the schedule type limits '
+                         'library.'.format(schedule_type_limit_identifier))

honeybee_energy/load/__init__.py

@@ -0,0 +1 @@
+"""honeybee-energy load definitions."""

honeybee_energy/load/_base.py

@@ -0,0 +1,190 @@
+# coding=utf-8
+"""Base object for all load definitions."""
+from __future__ import division
+import random
+
+from honeybee._lockable import lockable
+from honeybee.typing import valid_ep_string, tuple_with_length
+
+from ..schedule.ruleset import ScheduleRuleset
+from ..schedule.fixedinterval import ScheduleFixedInterval
+
+
+@lockable
+class _LoadBase(object):
+    """A base object for all load definitions.
+
+    Args:
+        identifier: Text string for a unique Load ID. Must be < 100 characters
+            and not contain any EnergyPlus special characters. This will be used to
+            identify the object across a model and in the exported IDF.
+
+    Properties:
+        * identifier
+        * display_name
+        * user_data
+    """
+    __slots__ = ('_identifier', '_display_name', '_locked',
+                 '_properties', '_user_data')
+
+    def __init__(self, identifier):
+        """Initialize LoadBase."""
+        self._locked = False  # unlocked by default
+        self.identifier = identifier
+        self._display_name = None
+        self._user_data = None
+        self._properties = None
+
+    @property
+    def identifier(self):
+        """Get or set the text string for object identifier."""
+        return self._identifier
+
+    @identifier.setter
+    def identifier(self, identifier):
+        self._identifier = valid_ep_string(identifier)
+
+    @property
+    def display_name(self):
+        """Get or set a string for the object name without any character restrictions.
+
+        If not set, this will be equal to the identifier.
+        """
+        if self._display_name is None:
+            return self._identifier
+        return self._display_name
+
+    @display_name.setter
+    def display_name(self, value):
+        if value is not None:
+            try:
+                value = str(value)
+            except UnicodeEncodeError:  # Python 2 machine lacking the character set
+                pass  # keep it as unicode
+        self._display_name = value
+
+    @property
+    def user_data(self):
+        """Get or set an optional dictionary for additional meta data for this object.
+
+        This will be None until it has been set. All keys and values of this
+        dictionary should be of a standard Python type to ensure correct
+        serialization of the object to/from JSON (eg. str, float, int, list, dict)
+        """
+        return self._user_data
+
+    @user_data.setter
+    def user_data(self, value):
+        if value is not None:
+            assert isinstance(value, dict), 'Expected dictionary for honeybee_energy' \
+                'object user_data. Got {}.'.format(type(value))
+        self._user_data = value
+
+    @property
+    def properties(self):
+        """Get properties for extensions."""
+        return self._properties
+
+    def duplicate(self):
+        """Get a copy of this object."""
+        return self.__copy__()
+
+    def _check_fractional_schedule_type(self, schedule, obj_name=''):
+        """Check that the type limit of an input schedule is fractional."""
+        if schedule.schedule_type_limit is not None:
+            t_lim = schedule.schedule_type_limit
+            assert t_lim.unit == 'fraction', '{} schedule should be fractional ' \
+                '[Dimensionless]. Got a schedule of unit_type ' \
+                '[{}].'.format(obj_name, t_lim.unit_type)
+            assert t_lim.lower_limit == 0, '{} schedule should have either no type ' \
+                'limit or a lower limit of 0. Got a schedule type with lower limit ' \
+                '[{}].'.format(obj_name, t_lim.lower_limit)
+            assert t_lim.upper_limit == 1, '{} schedule should have either no type ' \
+                'limit or an upper limit of 1. Got a schedule type with upper limit ' \
+                '[{}].'.format(obj_name, t_lim.upper_limit)
+
+    @staticmethod
+    def _check_avg_weights(load_objects, weights, obj_name):
+        """Check input weights of an average calculation and generate them if None."""
+        if weights is None:
+            weights = unity_weights = [1 / len(load_objects)] * len(load_objects) if \
+                len(load_objects) > 0 else []
+        else:
+            weights = tuple_with_length(weights, len(load_objects), float,
+                                        'average {} weights'.format(obj_name))
+            total_weight = sum(weights)
+            assert total_weight <= 1 + 1e-3, 'Average {} weights must be less than ' \
+                'or equal to 1. Got {}.'.format(obj_name, sum(weights))
+            unity_weights = [w / total_weight for w in weights]
+
+        return weights, unity_weights
+
+    @staticmethod
+    def _average_schedule(identifier, scheds, weights, timestep):
+        """Average a set of schedules together (no matter their type)."""
+        try:
+            return ScheduleRuleset.average_schedules(
+                identifier, scheds, weights, timestep)
+        except AttributeError:
+            return ScheduleFixedInterval.average_schedules(identifier, scheds, weights)
+
+    @staticmethod
+    def _max_schedule(identifier, scheds, timestep=1):
+        """Create a schedule that uses the maximum value between schedules."""
+        try:
+            return ScheduleRuleset.max_schedules(identifier, scheds, timestep)
+        except AttributeError:
+            return ScheduleFixedInterval.max_schedules(identifier, scheds)
+
+    @staticmethod
+    def _min_schedule(identifier, scheds, timestep=1):
+        """Create a schedule that uses the minimum value between schedules."""
+        try:
+            return ScheduleRuleset.min_schedules(identifier, scheds, timestep)
+        except AttributeError:
+            return ScheduleFixedInterval.min_schedules(identifier, scheds)
+
+    @staticmethod
+    def _get_schedule_from_dict(sch_dict):
+        """Get a schedule object from a schedule dictionary."""
+        if sch_dict['type'] == 'ScheduleRuleset':
+            return ScheduleRuleset.from_dict(sch_dict)
+        elif sch_dict['type'] == 'ScheduleFixedInterval':
+            return ScheduleFixedInterval.from_dict(sch_dict)
+        else:
+            raise NotImplementedError(
+                'Schedule {} is not supported.'.format(sch_dict['type']))
+
+    @staticmethod
+    def _shift_schedule(schedule, schedule_offset, timestep):
+        """Take a schedule and shift it behind and then ahead."""
+        if schedule_offset == 0:
+            return [schedule] * 3
+        else:
+            behind = schedule.shift_by_step(-schedule_offset, timestep)
+            ahead = schedule.shift_by_step(schedule_offset, timestep)
+            return [behind, schedule, ahead]
+
+    @staticmethod
+    def _gaussian_values(count, load_value, load_stdev):
+        """Generate Gaussian values for a load and a corresponding schedule integers."""
+        new_loads, sch_int = [], []
+        for _ in range(count):
+            val = random.gauss(load_value, load_stdev)
+            final_val = 1e-6 if val <= 0 else val  # avoid negative values
+            new_loads.append(final_val)
+            sch_int.append(random.randint(0, 2))
+        return new_loads, sch_int
+
+    def __copy__(self):
+        new_obj = _LoadBase(self.identifier)
+        new_obj._display_name = self._display_name
+        new_obj._user_data = None if self._user_data is None else self._user_data.copy()
+        return new_obj
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'Load Base: {}'.format(self.display_name)