honeybee-energy 1.116.106__py3-none-any.whl

honeybee_energy/ventcool/afn.py

@@ -0,0 +1,289 @@
+# coding=utf-8
+"""Functions to generate an Airflow Network for a list of rooms."""
+from __future__ import division
+
+import math
+
+from .crack import AFNCrack
+from .opening import VentilationOpening
+from ._crack_data import CRACK_TEMPLATE_DATA
+
+
+def _air_density_from_pressure(atmospheric_pressure=101325, air_temperature=20.0):
+    """Calculate density of dry air using the ideal gas law from temperature and pressure.
+
+    Args:
+        atmospheric_pressure: Atmospheric pressure in Pascals. (Default: 101325).
+        air_temperature: Air temperature in Celsius. (Default: 20.0).
+    Returns:
+        Air density at the given atmospheric pressure in kg/m3.
+    """
+    r_specific = 287.058  # specific gas constant for dry air in J/kg/K
+    air_temperature += 273.15  # absolute temperature
+    return atmospheric_pressure / (r_specific * air_temperature)
+
+
+def _interior_afn(interior_face_groups, int_cracks, air_density=1.2041):
+    """Mutate interior faces and subfaces to model airflow through cracks and openings.
+
+    This function creates an AFNCrack object with an air mass flow coefficient that
+    reflects the leakage characteristics of faces with different areas and types.
+    This requires multiplying the area-normalized air mass flow coefficients from the
+    reference crack data in int_cracks, by the wall area. This function assumes adjacent
+    faces share the same type and area properties so that the computed leakage parameters
+    are equivalent for each face.
+
+    Args:
+        interior_face_groups: A tuple with four groups of interior faces types
+
+            - int_walls: List of interior Wall type Face objects.
+
+            - int_floorceilings: List of interior RoofCeiling and Floor type Face
+                objects.
+
+            - int_apertures: List of interior Aperture Face objects.
+
+            - int_doors: List of interior Door Face objects.
+
+            - int_air: List of interior Faces with AirBoundary face type.
+
+        int_cracks: A dictionary of air mass flow coefficient and exponent data
+            corresponding to the face types in the interior_face_groups. Face
+            data flow coefficients should be normalized by surface area, and closed
+            opening flow coefficients should be normalized by edge lengths, for example:
+
+        .. code-block:: python
+
+            {
+            "wall_flow_cof": 0.003, # wall flow coefficient
+            "wall_flow_exp": 0.75, # wall flow exponent
+            "floorceiling_flow_cof": 0.0009, # floorceiling flow coefficient
+            "floorceiling_flow_exp": 0.7, # floorceiling flow exponent
+            "window_flow_cof": 0.0014, # window flow coefficient
+            "window_flow_exp": 0.65, # window flow exponent
+            "door_flow_cof": 0.02, # door flow coefficient
+            "door_flow_exp": 0.6 # door flow exponent
+            }
+
+        air_density: Air density in kg/m3. (Default: 1.2041 represents
+            air density at a temperature of 20 C and 101325 Pa).
+    """
+
+    # simplify parameters
+    int_walls, int_floorceilings, int_apertures, int_doors, int_air = interior_face_groups
+
+    # add interior crack leakage components for opaque building Faces
+    for int_wall in int_walls:
+        opening_area = sum([aper.area for aper in int_wall.apertures])
+        opening_area += sum([door.area for door in int_wall.doors])
+        face_area = int_wall.area - opening_area
+        flow_cof = int_cracks['wall_flow_cof'] * face_area
+        flow_exp = int_cracks['wall_flow_exp']
+        int_wall.properties.energy.vent_crack = AFNCrack(flow_cof, flow_exp)
+
+    for int_floorceiling in int_floorceilings:
+        opening_area = sum([aper.area for aper in int_floorceiling.apertures])
+        face_area = int_floorceiling.area - opening_area
+        flow_cof = int_cracks['floorceiling_flow_cof'] * face_area
+        flow_exp = int_cracks['floorceiling_flow_exp']
+        int_floorceiling.properties.energy.vent_crack = AFNCrack(flow_cof, flow_exp)
+
+    # add interior crack leakage for air boundary Faces
+    for int_ab in int_air:
+        # derive (large) flow coefficient from the orifice equation with 0.65 discharge
+        flow_cof = 0.65 * int_ab.area * math.sqrt(air_density * 2)
+        flow_exp = 0.5  # always use 0.5 exponent for a large hole-shaped opening
+        int_ab.properties.energy.vent_crack = AFNCrack(flow_cof, flow_exp)
+
+    # add interior opening leakage components
+    for int_aperture in int_apertures:
+        if int_aperture.properties.energy.vent_opening is None:
+            int_aperture.is_operable = True
+            int_aperture.properties.energy.vent_opening = \
+                VentilationOpening(fraction_area_operable=0)
+        vent_opening = int_aperture.properties.energy.vent_opening
+        vent_opening.flow_coefficient_closed = int_cracks['window_flow_cof']
+        vent_opening.flow_exponent_closed = int_cracks['window_flow_exp']
+
+    for int_door in int_doors:
+        if int_door.properties.energy.vent_opening is None:
+            int_door.properties.energy.vent_opening = \
+                VentilationOpening(fraction_area_operable=0)
+        vent_opening = int_door.properties.energy.vent_opening
+        vent_opening.flow_coefficient_closed = int_cracks['door_flow_cof']
+        vent_opening.flow_exponent_closed = int_cracks['door_flow_exp']
+
+
+def _exterior_afn(exterior_face_groups, ext_cracks):
+    """Mutate exterior faces and subfaces to model airflow through cracks and openings.
+
+    This function creates an AFNCrack object with an air mass flow coefficient that
+    reflects the leakage characteristics of faces with different areas and types.
+    This requires multiplying the area-normalized air mass flow coefficients from the
+    reference crack data in ext_cracks, by the wall area.
+
+    Args:
+        exterior_face_groups: A tuple with five groups of exterior envelope types
+
+            -   ext_walls - A list of exterior Wall type Face objects.
+
+            -   ext_roofs - A list of exterior RoofCeiling type Face objects.
+
+            -   ext_floors - A list of exterior Floor type Face objects, like you
+                would find in a cantilevered Room.
+
+            -   ext_apertures - A list of exterior Aperture Face objects.
+
+            -   ext_doors - A list of exterior Door Face objects.
+
+        ext_cracks: A dictionary of air mass flow coefficient and exponent data
+            corresponding to the face types in the exterior_face_groups. Face
+            data flow coefficients should be normalized by surface area, and closed
+            opening flow coefficients should be normalized by edge lengths, for example:
+
+        .. code-block:: python
+
+            {
+            "wall_flow_cof": 0.003, # wall flow coefficient
+            "wall_flow_exp": 0.75, # wall flow exponent
+            "roof_flow_cof": 0.0009, # roof flow coefficient
+            "roof_flow_exp": 0.7, # roof flow exponent
+            "floor_flow_cof": 0.0009, # floor flow coefficient
+            "floor_flow_exp": 0.7, # floor flow exponent
+            "window_flow_cof": 0.0014, # window flow coefficient
+            "window_flow_exp": 0.65, # window flow exponent
+            "door_flow_cof": 0.02, # door flow coefficient
+            "door_flow_exp": 0.6 # door flow exponent
+            }
+    """
+
+    # simplify parameters
+    ext_walls, ext_roofs, ext_floors, ext_apertures, ext_doors = exterior_face_groups
+
+    # add exterior crack leakage components
+    for ext_wall in ext_walls:
+        opening_area = sum([aper.area for aper in ext_wall.apertures])
+        opening_area += sum([door.area for door in ext_wall.doors])
+        face_area = ext_wall.area - opening_area
+        flow_cof = ext_cracks['wall_flow_cof'] * face_area
+        flow_exp = ext_cracks['wall_flow_exp']
+        ext_wall.properties.energy.vent_crack = AFNCrack(flow_cof, flow_exp)
+
+    for ext_roof in ext_roofs:
+        opening_area = sum([aper.area for aper in ext_roof.apertures])
+        face_area = ext_roof.area - opening_area
+        flow_cof = ext_cracks['roof_flow_cof'] * face_area
+        flow_exp = ext_cracks['roof_flow_exp']
+        ext_roof.properties.energy.vent_crack = AFNCrack(flow_cof, flow_exp)
+
+    for ext_floor in ext_floors:
+        face_area = ext_floor.area
+        flow_cof = ext_cracks['floor_flow_cof'] * face_area
+        flow_exp = ext_cracks['floor_flow_exp']
+        ext_floor.properties.energy.vent_crack = AFNCrack(flow_cof, flow_exp)
+
+    # add exterior opening leakage components
+    for ext_aperture in ext_apertures:
+        if ext_aperture.properties.energy.vent_opening is None:
+            ext_aperture.is_operable = True
+            ext_aperture.properties.energy.vent_opening = \
+                VentilationOpening(fraction_area_operable=0)
+        vent_opening = ext_aperture.properties.energy.vent_opening
+        vent_opening.flow_coefficient_closed = ext_cracks['window_flow_cof']
+        vent_opening.flow_exponent_closed = ext_cracks['window_flow_exp']
+
+    for ext_door in ext_doors:
+        if ext_door.properties.energy.vent_opening is None:
+            ext_door.properties.energy.vent_opening = \
+                VentilationOpening(fraction_area_operable=0)
+        vent_opening = ext_door.properties.energy.vent_opening
+        vent_opening.flow_coefficient_closed = ext_cracks['door_flow_cof']
+        vent_opening.flow_exponent_closed = ext_cracks['door_flow_exp']
+
+
+def generate(rooms, leakage_type='Medium', use_room_infiltration=True,
+             atmospheric_pressure=101325, delta_pressure=4):
+    """
+    Mutate a list of Honeybee Room objects to represent an EnergyPlus AirflowNetwork.
+
+    This function will compute leakage component parameters for the ventilation
+    cooling energy properties of Honeybee Room and Face objects to simulate an
+    EnergyPlus AirflowNetwork. The leakage flow coefficient and exponent values are
+    referenced from the DesignBuilder Cracks Template[1], which provides typical air
+    changes rates for different envelope tightness classifications for a range of
+    building types. Specifically this function references leakage values for an
+    'Excellent', 'Medium', and 'VeryPoor' classification of envelope tightness.
+
+    VentilationOpening objects will be added to Aperture and Door objects if not already
+    defined, with the fraction_area_operable set to 0. If already defined, only the
+    parameters defining leakage when the openings are closed will be overwritten.
+    AFNCrack objects will be added to all external and internal Face objects, and any
+    existing AFNCrack objects will be overwritten.
+
+    Note:
+        [1] DesignBuilder (6.1.6.008). DesignBuilder Software Ltd, 2000-2020.
+
+    Args:
+        rooms: List of Honeybee Room objects that make up the Airflow Network. The
+            adjacencies of these rooms must be solved.
+        leakage_type: Text identifying the leakiness of the internal walls. This
+            will be used to determine the air mass flow rate parameters for cracks in
+            internal floors, ceilings and walls. (Default: ''Medium'').
+            Choose from the following:
+
+            * Excellent
+            * Medium
+            * VeryPoor
+
+        use_room_infiltration: Boolean value to specify how exterior leakage parameters
+            are computed. If True the exterior airflow leakage parameters will be derived
+            from the room infiltration rate specified in RoomEnergyProperties. This will
+            compute air leakage parameters for exterior cracks and opening edges that
+            produce a total air flow rate equivalent to the room infiltration rate, at
+            an envelope pressure difference of 4 Pa. However, the individual flow air
+            leakage parameters are not meant to be representative of real values, since
+            the infiltration flow rate is an average of the actual, variable surface
+            flow dynamics. If False, the airflow leakage parameters are selected from a
+            crack data template, corresponding to the provided leakage_type. Since these
+            leakage parameters reflect empirically obtained values for different surface
+            types, they will result in a more realistic simulation of air flow through
+            orifices and cracks. In both cases, interzone airflow leakage parameters are
+            referenced from the crack data template, corresponding to the provided
+            leakage_type.
+        atmospheric_pressure: Optional number to define the atmospheric pressure
+            measurement in Pascals used to calculate dry air density. (Default: 101325).
+        delta_pressure: Optional reference air pressure difference across the building
+            envelope orifice in Pascals. delta_pressure is used to calculate
+            infiltration crack flow coefficients if the use_room_infiltration argument
+            is True. See the exterior_afn_from_infiltration method in the
+            RoomEnergyProperties class for details on how to set this value if
+            attempting to replicate the room infiltration rate per exterior area.
+            Default 4 represents typical building pressures.
+    """
+    # simplify parameters
+    if leakage_type == 'Excellent':
+        int_cracks = CRACK_TEMPLATE_DATA['internal_excellent_cracks']
+        ext_cracks = CRACK_TEMPLATE_DATA['external_excellent_cracks']
+    elif leakage_type == 'Medium':
+        int_cracks = CRACK_TEMPLATE_DATA['internal_medium_cracks']
+        ext_cracks = CRACK_TEMPLATE_DATA['external_medium_cracks']
+    elif leakage_type == 'VeryPoor':
+        int_cracks = CRACK_TEMPLATE_DATA['internal_verypoor_cracks']
+        ext_cracks = CRACK_TEMPLATE_DATA['external_verypoor_cracks']
+    else:
+        raise AssertionError('leakage_type must be "Excellent", "Medium", '
+                             'or "VeryPoor". Got: {}.'.format(leakage_type))
+
+    # generate the airflow newtwork
+    for room in rooms:
+        # get grouped faces by type that experience air flow leakage
+        ext_faces, int_faces = room.properties.energy.envelope_components_by_type()
+
+        # mutate surfaces with AFN flow parameters
+        rho = _air_density_from_pressure(atmospheric_pressure)
+        if use_room_infiltration and room.properties.energy.infiltration is not None:
+            room.properties.energy.exterior_afn_from_infiltration_load(
+                ext_faces, air_density=rho, delta_pressure=delta_pressure)
+        else:
+            _exterior_afn(ext_faces, ext_cracks)
+        _interior_afn(int_faces, int_cracks, rho)

honeybee_energy/ventcool/control.py

@@ -0,0 +1,269 @@
+# coding=utf-8
+"""Object to dictate setpoints and schedule for ventilative cooling."""
+from __future__ import division
+
+from ..schedule.dictutil import dict_to_schedule
+from ..schedule.ruleset import ScheduleRuleset
+from ..schedule.fixedinterval import ScheduleFixedInterval
+from ..lib.schedules import always_on
+
+from honeybee._lockable import lockable
+from honeybee.typing import float_in_range
+
+
+@lockable
+class VentilationControl(object):
+    """Object to dictate setpoints and schedule for ventilative cooling.
+
+    Note the all of the default setpoints of this object are set to always perform
+    ventilative cooling such that users can individually decide which setpoints
+    are relevant to a given ventilation strategy.
+
+    Args:
+        min_indoor_temperature: A number between -100 and 100 for the minimum
+            indoor temperature at which to ventilate in Celsius. Typically,
+            this variable is used to initiate ventilation. (Default: -100).
+        max_indoor_temperature: A number between -100 and 100 for the maximum
+            indoor temperature at which to ventilate in Celsius. This can be
+            used to set a maximum temperature at which point ventilation is
+            stopped and a cooling system is turned on. (Default: 100).
+        min_outdoor_temperature: A number between -100 and 100 for the minimum
+            outdoor temperature at which to ventilate in Celsius. This can be
+            used to ensure ventilative cooling doesn't happen during the winter
+            even if the Room is above the min_indoor_temperature. (Default: -100).
+        max_outdoor_temperature: A number between -100 and 100 for the maximum
+            outdoor temperature at which to ventilate in Celsius. This can be
+            used to set a limit for when it is considered too hot outside for
+            ventilative cooling. (Default: 100).
+        delta_temperature: A number between -100 and 100 for the temperature
+            differential in Celsius between indoor and outdoor below which
+            ventilation is shut off.  This should usually be a positive number
+            so that ventilation only occurs when the outdoors is cooler than the
+            indoors. Negative numbers indicate how much hotter the outdoors can
+            be than the indoors before ventilation is stopped. (Default: -100).
+        schedule: An optional ScheduleRuleset or ScheduleFixedInterval for the
+            ventilation over the course of the year. Note that this is applied
+            on top of any setpoints. The type of this schedule should be On/Off
+            and values should be either 0 (no possibility of ventilation) or 1
+            (ventilation possible). (Default: "Always On")
+
+    Properties:
+        * min_indoor_temperature
+        * max_indoor_temperature
+        * min_outdoor_temperature
+        * max_outdoor_temperature
+        * delta_temperature
+        * schedule
+    """
+    __slots__ = ('_min_indoor_temperature', '_max_indoor_temperature',
+                 '_min_outdoor_temperature', '_max_outdoor_temperature',
+                 '_delta_temperature', '_schedule', '_locked')
+
+    def __init__(self, min_indoor_temperature=-100, max_indoor_temperature=100,
+                 min_outdoor_temperature=-100, max_outdoor_temperature=100,
+                 delta_temperature=-100, schedule=always_on):
+        """Initialize VentilationControl."""
+        self.min_indoor_temperature = min_indoor_temperature
+        self.max_indoor_temperature = max_indoor_temperature
+        self.min_outdoor_temperature = min_outdoor_temperature
+        self.max_outdoor_temperature = max_outdoor_temperature
+        self.delta_temperature = delta_temperature
+        self.schedule = schedule
+
+    @property
+    def min_indoor_temperature(self):
+        """Get or set a number for the minimum indoor temperature for ventilation (C)."""
+        return self._min_indoor_temperature
+
+    @min_indoor_temperature.setter
+    def min_indoor_temperature(self, value):
+        self._min_indoor_temperature = \
+            float_in_range(value, -100.0, 100.0, 'min indoor temperature')
+
+    @property
+    def max_indoor_temperature(self):
+        """Get or set a number for the maximum indoor temperature for ventilation (C)."""
+        return self._max_indoor_temperature
+
+    @max_indoor_temperature.setter
+    def max_indoor_temperature(self, value):
+        self._max_indoor_temperature = \
+            float_in_range(value, -100.0, 100.0, 'max indoor temperature')
+
+    @property
+    def min_outdoor_temperature(self):
+        """Get or set a number for the minimum outdoor temperature for ventilation (C).
+        """
+        return self._min_outdoor_temperature
+
+    @min_outdoor_temperature.setter
+    def min_outdoor_temperature(self, value):
+        self._min_outdoor_temperature = \
+            float_in_range(value, -100.0, 100.0, 'min outdoor temperature')
+
+    @property
+    def max_outdoor_temperature(self):
+        """Get or set a number for the maximum outdoor temperature for ventilation (C).
+        """
+        return self._max_outdoor_temperature
+
+    @max_outdoor_temperature.setter
+    def max_outdoor_temperature(self, value):
+        self._max_outdoor_temperature = \
+            float_in_range(value, -100.0, 100.0, 'max outdoor temperature')
+
+    @property
+    def delta_temperature(self):
+        """Get or set the indoor/outdoor temperature difference for ventilation (C)."""
+        return self._delta_temperature
+
+    @delta_temperature.setter
+    def delta_temperature(self, value):
+        self._delta_temperature = \
+            float_in_range(value, -100.0, 100.0, 'delta temperature')
+
+    @property
+    def schedule(self):
+        """Get or set an On/Off schedule for the ventilation.
+
+        Note that this is applied on top of any setpoints.
+        """
+        return self._schedule
+
+    @schedule.setter
+    def schedule(self, value):
+        if value is not None:
+            assert isinstance(value, (ScheduleRuleset, ScheduleFixedInterval)), \
+                'Expected schedule for VentilationControl schedule. ' \
+                'Got {}.'.format(type(value))
+            if value.schedule_type_limit is not None:
+                assert value.schedule_type_limit.unit == 'fraction', \
+                    'VentilationControl schedule should be fractional ' \
+                    '[Dimensionless]. Got a schedule ' \
+                    'of unit_type [{}].'.format(value.schedule_type_limit.unit_type)
+            value.lock()  # lock editing in case schedule has multiple references
+            self._schedule = value
+        else:
+            self._schedule = always_on
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a VentilationControl from a dictionary.
+
+        Args:
+            data: A python dictionary in the following format
+
+        .. code-block:: python
+
+            {
+            "type": 'VentilationControl',
+            "min_indoor_temperature": 22,
+            "max_indoor_temperature": 26,
+            "min_outdoor_temperature": 12,
+            "max_outdoor_temperature": 32,
+            "delta_temperature": -4,
+            "schedule": {}  # dictionary of a schedule
+            }
+        """
+        assert data['type'] == 'VentilationControl', \
+            'Expected VentilationControl. Got {}.'.format(data['type'])
+        min_in, max_in, min_out, max_out, delta = cls._default_dict_values(data)
+        sch = dict_to_schedule(data['schedule']) if 'schedule' in data and \
+            data['schedule'] is not None else always_on
+        vent_control = cls(min_in, max_in, min_out, max_out, delta, sch)
+        return vent_control
+
+    @classmethod
+    def from_dict_abridged(cls, data, schedule_dict):
+        """Create a VentilationControl from an abridged dictionary.
+
+        Args:
+            data: A VentilationControlAbridged dictionary with the format below.
+            schedule_dict: A dictionary with schedule identifiers as keys and
+                honeybee schedule objects as values. These will be used to
+                assign the schedule to the VentilationControl object.
+
+        .. code-block:: python
+
+            {
+            "type": 'VentilationControlAbridged',
+            "min_indoor_temperature": 22,
+            "max_indoor_temperature": 26,
+            "min_outdoor_temperature": 12,
+            "max_outdoor_temperature": 32,
+            "delta_temperature": -4,
+            "schedule": ""  # identifier of a schedule
+            }
+        """
+        assert data['type'] == 'VentilationControlAbridged', \
+            'Expected VentilationControlAbridged. Got {}.'.format(data['type'])
+        min_in, max_in, min_out, max_out, delta = cls._default_dict_values(data)
+        sch = schedule_dict[data['schedule']] if \
+            'schedule' in data and data['schedule'] is not None else always_on
+        vent_control = cls(min_in, max_in, min_out, max_out, delta, sch)
+        return vent_control
+
+    def to_dict(self, abridged=False):
+        """Ventilation Control dictionary representation."""
+        base = {'type': 'VentilationControl'} if not \
+            abridged else {'type': 'VentilationControlAbridged'}
+        base['min_indoor_temperature'] = self.min_indoor_temperature
+        base['max_indoor_temperature'] = self.max_indoor_temperature
+        base['min_outdoor_temperature'] = self.min_outdoor_temperature
+        base['max_outdoor_temperature'] = self.max_outdoor_temperature
+        base['delta_temperature'] = self.delta_temperature
+        if self.schedule is not always_on:
+            base['schedule'] = self.schedule.identifier if abridged \
+                else self.schedule.to_dict()
+        return base
+
+    def duplicate(self):
+        """Get a copy of this object."""
+        return self.__copy__()
+
+    @staticmethod
+    def _default_dict_values(data):
+        """Process dictionary values and include defaults for missing values."""
+        min_in = data['min_indoor_temperature'] if 'min_indoor_temperature' in data \
+            and data['min_indoor_temperature'] is not None else -100
+        max_in = data['max_indoor_temperature'] if 'max_indoor_temperature' in data \
+            and data['max_indoor_temperature'] is not None else 100
+        min_out = data['min_outdoor_temperature'] if 'min_outdoor_temperature' in data \
+            and data['min_outdoor_temperature'] is not None else -100
+        max_out = data['max_outdoor_temperature'] if 'max_outdoor_temperature' in data \
+            and data['max_outdoor_temperature'] is not None else 100
+        delta = data['delta_temperature'] if 'delta_temperature' in data \
+            and data['delta_temperature'] is not None else -100
+        return min_in, max_in, min_out, max_out, delta
+
+    def __copy__(self):
+        return VentilationControl(
+            self.min_indoor_temperature, self.max_indoor_temperature,
+            self.min_outdoor_temperature, self.max_outdoor_temperature,
+            self.delta_temperature, self.schedule)
+
+    def __key(self):
+        """A tuple based on the object properties, useful for hashing."""
+        return (self.min_indoor_temperature, self.max_indoor_temperature,
+                self.min_outdoor_temperature, self.max_outdoor_temperature,
+                self.delta_temperature, hash(self._schedule))
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __eq__(self, other):
+        return isinstance(other, VentilationControl) and self.__key() == other.__key()
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'VentilationControl, [min in: {}] [max in: {}] [min out: {}] ' \
+            '[max out: {}] [delta: {}]'.format(
+                self.min_indoor_temperature, self.max_indoor_temperature,
+                self.min_outdoor_temperature, self.max_outdoor_temperature,
+                self.delta_temperature)

honeybee_energy/ventcool/crack.py

@@ -0,0 +1,126 @@
+# coding=utf-8
+"""Definition of surface crack for multizone airflow."""
+from __future__ import division
+
+from honeybee._lockable import lockable
+from honeybee.typing import float_in_range, float_positive
+
+
+@lockable
+class AFNCrack(object):
+    """Airflow leakage through surface due to cracks or porous surface material.
+
+    Note that this whole class only has bearing on the simulation when the Model
+    that the AFNCrack is a part of has its ventilation_simulation_control set for
+    MultiZone air flow, thereby triggering the use of the AirflowNetwork.
+
+    Args:
+        flow_coefficient: A number in kg/s-m at 1 Pa per meter of
+            crack length at the conditions defined in the ReferenceCrack condition;
+            required to run an AirflowNetwork simulation. Some common values for this
+            coefficient from the DesignBuilder Cracks template include the following:
+
+            * 0.00001 - Tight low-leakage external wall
+            * 0.001 - Tight, low-leakage internal wall
+            * 0.0004 - Poor, high-leakage external wall
+            * 0.019 - Poor, high-leakage internal wall
+
+        flow_exponent: An optional dimensionless number between 0.5 and 1 used
+            to calculate the crack mass flow rate; required to run an AirflowNetwork
+            simulation. This value represents the leak geometry impact on airflow, with
+            0.5 generally corresponding to turbulent orifice flow and 1 generally
+            corresponding to laminar flow. The default of 0.65 is representative of many
+            cases of wall and window leakage, used when the exponent cannot be measured.
+            (Default: 0.65).
+
+    Properties:
+        * flow_coefficient
+        * flow_exponent
+    """
+    __slots__ = ('_flow_coefficient', '_flow_exponent', '_locked')
+
+    def __init__(self, flow_coefficient, flow_exponent=0.65):
+        """Initialize AFNCrack."""
+        self.flow_coefficient = flow_coefficient
+        self.flow_exponent = flow_exponent
+
+    @property
+    def flow_coefficient(self):
+        """Get or set the air mass flow coefficient defined at the reference crack."""
+        return self._flow_coefficient
+
+    @flow_coefficient.setter
+    def flow_coefficient(self, value):
+        self._flow_coefficient = float_positive(value, 'flow_coefficient')
+
+    @property
+    def flow_exponent(self):
+        """Get or set the air mass flow exponent for the surface crack."""
+        return self._flow_exponent
+
+    @flow_exponent.setter
+    def flow_exponent(self, value):
+        self._flow_exponent = float_in_range(value, 0.5, 1.0, 'flow_exponent')
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a AFNCrack object from a dictionary.
+
+        Args:
+            data: A AFNCrack dictionary following the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "AFNCrack",
+            "flow_coefficient": 0.01 # coefficient at reference crack
+            "flow_exponent": 0.65 # exponent for the surface crack
+            }
+        """
+        assert data['type'] == 'AFNCrack', \
+            'Expected AFNCrack dictionary. Got {}.'.format(data['type'])
+
+        assert 'flow_coefficient' in data, 'The flow_coefficient must be defined to ' \
+            'create a AFNCrack object.'
+
+        air_coeff = data['flow_coefficient']
+        air_exp = data['flow_exponent'] if 'flow_exponent' in data \
+            and data['flow_exponent'] is not None else 0.65
+
+        return cls(air_coeff, air_exp)
+
+    def to_dict(self):
+        """AFNCrack dictionary representation."""
+        base = {'type': 'AFNCrack'}
+        base['flow_coefficient'] = self.flow_coefficient
+        base['flow_exponent'] = self.flow_exponent
+        return base
+
+    def duplicate(self):
+        """Get a copy of this object."""
+        return self.__copy__()
+
+    def __copy__(self):
+        return AFNCrack(
+            self.flow_coefficient, self.flow_exponent)
+
+    def __key(self):
+        """A tuple based on the object properties, useful for hashing."""
+        return (self.flow_coefficient, self.flow_exponent)
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __eq__(self, other):
+        return isinstance(other, AFNCrack) and self.__key() == other.__key()
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'AFNCrack: [coefficient: {}] [exponent: {}]'.format(
+            self.flow_coefficient, self.flow_exponent)