honeybee-energy 1.116.106__py3-none-any.whl

honeybee_energy/ventcool/opening.py

@@ -0,0 +1,365 @@
+# coding=utf-8
+"""Definition of window opening for ventilative cooling."""
+from __future__ import division
+
+from .control import VentilationControl
+from ..writer import generate_idf_string
+
+from honeybee.typing import float_in_range, float_positive
+
+
+class VentilationOpening(object):
+    """Definition of window opening for ventilative cooling.
+
+    Args:
+        fraction_area_operable: A number between 0.0 and 1.0 for the fraction of the
+            window area that is operable. (Default: 0.5, typical of sliding windows).
+        fraction_height_operable: A number between 0.0 and 1.0 for the fraction
+            of the distance from the bottom of the window to the top that is
+            operable. (Default: 1.0, typical of windows that slide horizontally).
+        discharge_coefficient: A number between 0.0 and 1.0 that will be multiplied
+            by the area of the window in the stack (buoyancy-driven) part of the
+            equation to account for additional friction from window geometry,
+            insect screens, etc. (Default: 0.45, for unobstructed windows with
+            insect screens). This value should be lowered if windows are of an
+            awning or casement type and not allowed to fully open. Some common
+            values for this coefficient include the following.
+
+            * 0.0 - Completely discount stack ventilation from the calculation.
+            * 0.45 - For unobstructed windows with an insect screen.
+            * 0.65 - For unobstructed windows with NO insect screen.
+
+        wind_cross_vent: Boolean to indicate if there is an opening of roughly
+            equal area on the opposite side of the Room such that wind-driven
+            cross ventilation will be induced. If False, the assumption is that
+            the operable area is primarily on one side of the Room and there is
+            no wind-driven ventilation. (Default: False)
+        flow_coefficient_closed: A number in kg/s-m, at 1 Pa per meter of crack
+            length, used to calculate the mass flow rate when the opening is closed;
+            only used in an AirflowNetwork simulation. Some common values for this
+            coefficient (from the DesignBuilder Cracks template) include the following:
+
+            * 0.00001 - Tight, low-leakage closed external window
+            * 0.003 - Very poor, high-leakage closed external window
+
+            (Default: 0, indicates the VentilationOpening object will not participate
+            in the AirflowNetwork simulation).
+        flow_exponent_closed: An optional dimensionless number between 0.5 and
+            1 used to calculate the mass flow rate when the opening is closed; 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. (Default: 0.65,
+            representative of many cases of wall and window leakage, used when the
+            exponent cannot be measured).
+        two_way_threshold: A number in kg/m3 indicating the minimum density difference
+            above which two-way flow may occur due to stack effect, required to run an
+            AirflowNetwork simulation. This value is required because the air density
+            difference between two zones (which drives two-way air flow) will tend
+            towards division by zero errors as the air density difference approaches
+            zero. (Default: 0.0001, typical default value used for AirflowNetwork
+            openings).
+
+    Properties:
+        * fraction_area_operable
+        * fraction_height_operable
+        * discharge_coefficient
+        * wind_cross_vent
+        * flow_coefficient_closed
+        * flow_exponent_closed
+        * two_way_threshold
+        * parent
+        * has_parent
+    """
+    __slots__ = ('_fraction_area_operable', '_fraction_height_operable',
+                 '_discharge_coefficient', '_wind_cross_vent',
+                 '_flow_coefficient_closed', '_flow_exponent_closed',
+                 '_two_way_threshold', '_parent')
+
+    def __init__(self, fraction_area_operable=0.5, fraction_height_operable=1.0,
+                 discharge_coefficient=0.45, wind_cross_vent=False,
+                 flow_coefficient_closed=0, flow_exponent_closed=0.65,
+                 two_way_threshold=0.0001):
+        """Initialize VentilationOpening."""
+        self.fraction_area_operable = fraction_area_operable
+        self.fraction_height_operable = fraction_height_operable
+        self.discharge_coefficient = discharge_coefficient
+        self.wind_cross_vent = wind_cross_vent
+        self.flow_coefficient_closed = flow_coefficient_closed
+        self.flow_exponent_closed = flow_exponent_closed
+        self.two_way_threshold = two_way_threshold
+        self._parent = None  # this will be set when assigned to an aperture
+
+    @property
+    def fraction_area_operable(self):
+        """Get or set a number for the fraction of the window area that is operable."""
+        return self._fraction_area_operable
+
+    @fraction_area_operable.setter
+    def fraction_area_operable(self, value):
+        self._fraction_area_operable = \
+            float_in_range(value, 0.0, 1.0, 'fraction area operable')
+
+    @property
+    def fraction_height_operable(self):
+        """Get or set a number for the fraction of the window height that is operable."""
+        return self._fraction_height_operable
+
+    @fraction_height_operable.setter
+    def fraction_height_operable(self, value):
+        self._fraction_height_operable = \
+            float_in_range(value, 0.0, 1.0, 'fraction height operable')
+
+    @property
+    def discharge_coefficient(self):
+        """Get or set a number for the discharge coefficient."""
+        return self._discharge_coefficient
+
+    @discharge_coefficient.setter
+    def discharge_coefficient(self, value):
+        self._discharge_coefficient = \
+            float_in_range(value, 0.0, 1.0, 'discharge coefficient')
+
+    @property
+    def wind_cross_vent(self):
+        """Get or set a boolean for whether there is cross ventilation from the window.
+
+        Note that this property only has significance for simulations using SingleZone
+        ventilation_simulation_control and has no bearing on multizone simulations
+        with the Airflow Network.
+
+        This should be True if there is an opening of roughly equal area on the
+        opposite side of the Room such that wind-driven cross ventilation will
+        be induced. If False, the assumption is that the operable area is primarily
+        on one side of the Room and there is no wind-driven ventilation.
+        """
+        return self._wind_cross_vent
+
+    @wind_cross_vent.setter
+    def wind_cross_vent(self, value):
+        self._wind_cross_vent = bool(value)
+
+    @property
+    def flow_coefficient_closed(self):
+        """Get or set a number for the mass flow coefficient when opening is closed [kg/s-m].
+
+        Note that anything assigned here has no bearing on the simulation unless
+        the Model that this object is a part of has its ventilation_simulation_control
+        set for MultiZone air flow, thereby triggering the use of the AirflowNetwork.
+        """
+        return self._flow_coefficient_closed
+
+    @flow_coefficient_closed.setter
+    def flow_coefficient_closed(self, value):
+        self._flow_coefficient_closed = float_positive(value, 'flow_coefficient_closed')
+
+    @property
+    def flow_exponent_closed(self):
+        """Get or set the exponent for deriving the mass flow rate when opening is closed.
+
+        Note that anything assigned here has no bearing on the simulation unless
+        the Model that this object is a part of has its ventilation_simulation_control
+        set for MultiZone air flow, thereby triggering the use of the AirflowNetwork.
+        """
+        return self._flow_exponent_closed
+
+    @flow_exponent_closed.setter
+    def flow_exponent_closed(self, value):
+        self._flow_exponent_closed = \
+            float_in_range(value, 0.5, 1.0, 'flow_exponent_closed')
+
+    @property
+    def two_way_threshold(self):
+        """Get or set minimum density difference above which two-way flow occurs [kg/m3].
+
+        Note that anything assigned here has no bearing on the simulation unless
+        the Model that this object is a part of has its ventilation_simulation_control
+        set for MultiZone air flow, thereby triggering the use of the AirflowNetwork.
+        """
+        return self._two_way_threshold
+
+    @two_way_threshold.setter
+    def two_way_threshold(self, value):
+        self._two_way_threshold = float_positive(value, 'two_way_threshold')
+
+    @property
+    def parent(self):
+        """Get the parent of this object if it exists."""
+        return self._parent
+
+    @property
+    def has_parent(self):
+        """Get a boolean noting whether this VentilationOpening has a parent object."""
+        return self._parent is not None
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a VentilationOpening object from a dictionary.
+
+        Args:
+            data: A VentilationOpening dictionary in following the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "VentilationOpening",
+            "fraction_area_operable": 0.5,  # Fractional number for area operable
+            "fraction_height_operable": 0.5,  # Fractional number for height operable
+            "discharge_coefficient": 0.45,  # Fractional number for discharge coefficient
+            "wind_cross_vent": True  # Wind-driven cross ventilation
+            "flow_coefficient_closed": 0.001 # Coefficient for mass flow rate
+            "flow_exponent_closed": 0.667 # Exponent for mass flow rate
+            "two_way_threshold": 1e-3 # Minimum density for two-way flow
+            }
+        """
+        assert data['type'] == 'VentilationOpening', \
+            'Expected VentilationOpening dictionary. Got {}.'.format(data['type'])
+
+        area_op = data['fraction_area_operable'] if 'fraction_area_operable' in data \
+            and data['fraction_area_operable'] is not None else 0.5
+        height_op = data['fraction_height_operable'] if 'fraction_height_operable' in \
+            data and data['fraction_height_operable'] is not None else 1.0
+        discharge = data['discharge_coefficient'] if 'discharge_coefficient' in data \
+            and data['discharge_coefficient'] is not None else 0.45
+        cross_vent = data['wind_cross_vent'] if 'wind_cross_vent' in data \
+            and data['wind_cross_vent'] is not None else False
+
+        # Add AFN parameters
+        air_flow_coeff = data['flow_coefficient_closed'] if \
+            'flow_coefficient_closed' in data and \
+            data['flow_coefficient_closed'] is not None else 0
+        air_flow_exp = data['flow_exponent_closed'] if \
+            'flow_exponent_closed' in data and \
+            data['flow_exponent_closed'] is not None else 0.65
+        min_diff = data['two_way_threshold'] if \
+            'two_way_threshold' in data and \
+            data['two_way_threshold'] is not None else 0.0001
+
+        return cls(area_op, height_op, discharge, cross_vent, air_flow_coeff,
+                   air_flow_exp, min_diff)
+
+    def to_idf(self):
+        """IDF string representation of VentilationOpening object.
+
+        Note that this ventilation opening must be assigned to a honeybee Aperture
+        or Door for this method to run. This parent Aperture or Door must also have
+        a parent Room. It is also recommended that this Room have a VentilationControl
+        object under its energy properties. Otherwise, the default control sequence
+        will be used, which will likely result in the window never opening.
+
+        Also note that the parent's geometry should be in meters whenever calling
+        this method and that this method does not return full definitions of
+        ventilation control schedules. So these schedules must also be translated
+        into the final IDF file.
+
+        .. code-block shell
+
+            ZoneVentilation:WindandStackOpenArea,
+                ZONE 3 Ventl 1,          !- Name
+                ZONE 3,                  !- Zone Name
+                0.5,                     !- Opening Area {m2}
+                Constant,                !- Opening Area Fraction Schedule Name
+                AutoCalculate,           !- Opening Effectiveness
+                0.0,                     !- Effective Angle {deg}
+                1.0,                     !- Height Difference {m}
+                AutoCalculate,           !- Discharge Coefficient for Opening
+                18.0,                    !- Minimum Indoor Temperature {C}
+                ,                        !- Minimum Indoor Temperature Schedule Name
+                ,                        !- Maximum Indoor Temperature {C}
+                ,                        !- Maximum Indoor Temperature Schedule Name
+                1.0;                     !- Delta Temperature {deltaC}
+        """
+        # check that a parent is assigned
+        assert self.parent is not None, \
+            'VentilationOpening must be assigned to an Aperture or Door to use to_idf().'
+
+        # get the VentilationControl object from the room
+        cntrl = None
+        room = None
+        if self.parent.has_parent:
+            if self.parent.parent.has_parent:
+                room = self.parent.parent.parent
+                if room.properties.energy.window_vent_control is not None:
+                    cntrl = room.properties.energy.window_vent_control
+        if cntrl is None:  # use default ventilation control
+            cntrl = VentilationControl()
+        assert room is not None, \
+            'VentilationOpening must have a parent Room to use to_idf().'
+
+        # process the properties on this object into IDF format
+        sch = '' if cntrl.schedule is None else cntrl.schedule.identifier
+        wind = 'autocalculate' if self.wind_cross_vent else 0
+        angle = self.parent.horizontal_orientation() if self.parent.normal.z != 1 else 0
+        angle = angle % 360
+        height = (self.parent.geometry.max.z - self.parent.geometry.min.z) * \
+            self.fraction_height_operable
+
+        # create the final IDF string
+        values = (
+            '{}_Opening'.format(self.parent.identifier), room.identifier,
+            self.parent.area * self.fraction_area_operable, sch, wind, angle,
+            height, self.discharge_coefficient, cntrl.min_indoor_temperature, '',
+            cntrl.max_indoor_temperature, '', cntrl.delta_temperature, '',
+            cntrl.min_outdoor_temperature, '', cntrl.max_outdoor_temperature, '', 40)
+        comments = (
+            'name', 'zone name', 'opening area', 'opening schedule',
+            'opening effectiveness {m2}', 'horizontal orientation angle',
+            'height difference {m}', 'discharge coefficient',
+            'min indoor temperature {C}', 'min in temp schedule',
+            'max indoor temperature {C}', 'max in temp schedule',
+            'delta temperature {C}', 'delta temp schedule',
+            'min outdoor temperature {C}', 'min out temp schedule',
+            'max outdoor temperature {C}', 'max out temp schedule', 'max wind speed')
+        return generate_idf_string(
+            'ZoneVentilation:WindandStackOpenArea', values, comments)
+
+    def to_dict(self):
+        """Ventilation Opening dictionary representation."""
+        base = {'type': 'VentilationOpening'}
+        base['fraction_area_operable'] = self.fraction_area_operable
+        base['fraction_height_operable'] = self.fraction_height_operable
+        base['discharge_coefficient'] = self.discharge_coefficient
+        base['wind_cross_vent'] = self.wind_cross_vent
+
+        base['flow_coefficient_closed'] = self.flow_coefficient_closed
+        base['flow_exponent_closed'] = self.flow_exponent_closed
+        base['two_way_threshold'] = self.two_way_threshold
+
+        return base
+
+    def duplicate(self):
+        """Get a copy of this object."""
+        return self.__copy__()
+
+    def __copy__(self):
+        return VentilationOpening(
+            self.fraction_area_operable, self.fraction_height_operable,
+            self.discharge_coefficient, self.wind_cross_vent,
+            self.flow_coefficient_closed, self.flow_exponent_closed,
+            self.two_way_threshold)
+
+    def __key(self):
+        """A tuple based on the object properties, useful for hashing."""
+        return (self.fraction_area_operable, self.fraction_height_operable,
+                self.discharge_coefficient, self.wind_cross_vent,
+                self.flow_coefficient_closed,
+                self.flow_exponent_closed,
+                self.two_way_threshold)
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __eq__(self, other):
+        return isinstance(other, VentilationOpening) 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 'VentilationOpening: [fraction area: {}] ' \
+            '[fraction height: {}] [discharge: {}]'.format(
+                self.fraction_area_operable, self.fraction_height_operable,
+                self.discharge_coefficient)

honeybee_energy/ventcool/simulation.py

@@ -0,0 +1,314 @@
+# coding=utf-8
+"""Definitions for global parameters used in the ventilation simulation."""
+from __future__ import division
+import math
+
+from ladybug_geometry.bounding import bounding_box_extents
+
+from honeybee._lockable import lockable
+from honeybee.typing import float_in_range, float_positive, float_in_range_excl_incl
+
+
+@lockable
+class VentilationSimulationControl(object):
+    """Global parameters used to specify the simulation of air flow.
+
+    Args:
+        vent_control_type: Text indicating type of ventilation control.
+            Choose from the following:
+
+            * SingleZone
+            * MultiZoneWithDistribution
+            * MultiZoneWithoutDistribution
+
+            The MultiZone options will model air flow with the AirflowNetwork model,
+            which is generally more accurate then the SingleZone option, but will take
+            considerably longer to simulate, and requires defining more ventilation
+            parameters to explicitly account for weather and building-induced pressure
+            differences, and the leakage geometry corresponding to specific windows,
+            doors, and surface cracks (Default: 'SingleZone').
+        reference_temperature: Reference temperature measurement in Celsius under which
+            the surface crack data were obtained. This is only used for AFN simulations,
+            when vent_control_type is NOT SingleZone. (Default: 20).
+        reference_pressure: Reference barometric pressure measurement in Pascals
+            under which the surface crack data were obtained. This is only used for AFN
+            simulations, when vent_control_type is NOT SingleZone.(Default: 101325).
+        reference_humidity_ratio: Reference humidity ratio measurement in
+            kgWater/kgDryAir under which the surface crack data were obtained.
+            This is only used for AFN simulations, when vent_control_type is
+            NOT SingleZone. (Default: 0).
+        building_type: Text indicating relationship between building footprint and
+            height. Choose from the following:
+
+            * LowRise
+            * HighRise
+
+            LowRise corresponds to a building where the height is less then three
+            times the width AND length of the footprint. HighRise corresponds to a
+            building where height is more than three times the width OR length of
+            the footprint. This parameter is used to estimate building-wide wind
+            pressure coefficients for the AFN by approximating the building geometry
+            as an extruded rectangle. This property can be auto-calculated from
+            Honeybee Room geometry with the geometry_properties_from_rooms
+            method. (Default: 'LowRise').
+        long_axis_angle: A number between 0 and 180 for the clockwise angle difference
+            in degrees that the long axis of the building is from true North. This
+            parameter is used to estimate building-wide wind pressure coefficients
+            for the AFN by approximating the building geometry as an extruded
+            rectangle. 0 indicates a North-South long axis while 90 indicates an
+            East-West long axis. (Default: 0).
+        aspect_ratio: A number between 0 and 1 for the aspect ratio of the building's
+            footprint, defined as the ratio of length of the short axis divided
+            by the length of the long axis. This parameter is used to estimate
+            building-wide wind pressure coefficients for the AFN by approximating
+            the building geometry as an extruded rectangle (Default: 1).
+
+    Properties:
+        * vent_control_type
+        * reference_temperature
+        * reference_pressure
+        * reference_humidity_ratio
+        * building_type
+        * long_axis_angle
+        * aspect_ratio
+    """
+    __slots__ = ('_vent_control_type', '_reference_temperature',
+                 '_reference_pressure', '_reference_humidity_ratio',
+                 '_building_type', '_long_axis_angle', '_aspect_ratio', '_locked')
+    VENT_CONTROL_TYPES = ('SingleZone', 'MultiZoneWithDistribution',
+                          'MultiZoneWithoutDistribution')
+    BUILDING_TYPES = ('LowRise', 'HighRise')
+
+    def __init__(self, vent_control_type='SingleZone', reference_temperature=20,
+                 reference_pressure=101325, reference_humidity_ratio=0,
+                 building_type='LowRise', long_axis_angle=0, aspect_ratio=1):
+        """Initialize VentilationSimulationControl."""
+        self.vent_control_type = vent_control_type
+        self.reference_temperature = reference_temperature
+        self.reference_pressure = reference_pressure
+        self.reference_humidity_ratio = reference_humidity_ratio
+        self.building_type = building_type
+        self.long_axis_angle = long_axis_angle
+        self.aspect_ratio = aspect_ratio
+
+    @property
+    def vent_control_type(self):
+        """Get or set text indicating type of ventilation control type."""
+        return self._vent_control_type
+
+    @vent_control_type.setter
+    def vent_control_type(self, value):
+        assert value in self.VENT_CONTROL_TYPES, 'vent_control_type {} is not '\
+            'recognized.\nChoose from the following:\n{}'.format(
+                value, self.VENT_CONTROL_TYPES)
+        self._vent_control_type = value
+
+    @property
+    def reference_temperature(self):
+        """Get or set the temperature for the reference crack."""
+        return self._reference_temperature
+
+    @reference_temperature.setter
+    def reference_temperature(self, value):
+        self._reference_temperature = \
+            float_in_range(value, mi=-273.15, input_name='reference_temperature')
+
+    @property
+    def reference_pressure(self):
+        """Get or set the barometric pressure for the reference crack."""
+        return self._reference_pressure
+
+    @reference_pressure.setter
+    def reference_pressure(self, value):
+        self._reference_pressure = \
+            float_in_range(value, 31000, 120000, 'reference_pressure')
+
+    @property
+    def reference_humidity_ratio(self):
+        """Get or set the humidity ratio for the reference crack."""
+        return self._reference_humidity_ratio
+
+    @reference_humidity_ratio.setter
+    def reference_humidity_ratio(self, value):
+        self._reference_humidity_ratio = \
+            float_positive(value, 'reference_humidity_ratio')
+
+    @property
+    def building_type(self):
+        """Get or set text indicating whether the building is high or low rise."""
+        return self._building_type
+
+    @building_type.setter
+    def building_type(self, value):
+        assert value in self.BUILDING_TYPES, 'building_type {} is not '\
+            'recognized.\nChoose from the following:\n{}'.format(
+                value, self.BUILDING_TYPES)
+        self._building_type = value
+
+    @property
+    def long_axis_angle(self):
+        """Get or set a number between 0 and 180 for the building long axis angle.
+
+        The value represents the clockwise difference between the long axis and
+        true North. 0 indicates a North-South long axis while 90 indicates an
+        East-West long axis.
+        """
+        return self._long_axis_angle
+
+    @long_axis_angle.setter
+    def long_axis_angle(self, value):
+        self._long_axis_angle = float_in_range(value, 0, 180, 'long_axis_angle')
+
+    @property
+    def aspect_ratio(self):
+        """Get or set a number between 0 and 1 for the building footprint aspect ratio.
+        """
+        return self._aspect_ratio
+
+    @aspect_ratio.setter
+    def aspect_ratio(self, value):
+        self._aspect_ratio = float_in_range_excl_incl(value, 0, 1, 'aspect_ratio')
+
+    def assign_geometry_properties_from_rooms(self, rooms):
+        """Assign the geometry properties of this object using an array of Honeybee Rooms.
+
+        The building_type (HighRise or LowRise) will be determined by analyzing
+        the bounding box around the Rooms (assessing whether the box is taller than
+        it is wide + long).
+
+        This object's long_axis_angle will be used to orient the bounding box and
+        compute the aspect ratio of the footprint. If the length of what should
+        be the short axis ends up being longer than the other axis, this object's
+        long_axis_angle will be rotated 90 degrees in order to keep the aspect
+        ratio from being greater than 1.
+
+        Args:
+            rooms: An array of Honeybee Rooms, which will have their geometry
+                collectively analyzed in order to set the geometry properties
+                of this object. Typically, this should be all of the Rooms of
+                a Honeybee Model.
+        """
+        l_axis = self.long_axis_angle
+        bldg_type, aspect_r = self.geometry_properties_from_rooms(rooms, l_axis)
+        self.building_type = bldg_type
+        if aspect_r > 1:  # rotate the long axis 90 degrees
+            aspect_r = 1 / aspect_r
+            self.long_axis_angle = l_axis + 90 if l_axis < 90 else l_axis - 90
+        self.aspect_ratio = aspect_r
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a VentilationSimulationControl object from a dictionary.
+
+        Args:
+            data: A VentilationSimulationControl dictionary following the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "VentilationSimulationControl"
+            "vent_control_type": SingleZone # type of ventilation control
+            "reference_temperature": 20 # reference crack temperature
+            "reference_pressure": 101320 # reference crack barometric pressure
+            "reference_humidity_ratio": 0.5 # reference crack humidity ratio
+            "building_type": 'LowRise' # building type text
+            "long_axis_angle": 0 # angle of building low axis
+            "aspect_ratio": 1 # aspect ratio of building footprint
+            }
+        """
+        assert data['type'] == 'VentilationSimulationControl', 'Expected ' \
+            'VentilationSimulationControl dictionary. Got {}.'.format(data['type'])
+
+        vent_control_type = data['vent_control_type'] if 'vent_control_type' in data \
+            and data['vent_control_type'] is not None else 'SingleZone'
+        ref_temp = data['reference_temperature'] if 'reference_temperature' in data \
+            and data['reference_temperature'] is not None else 20
+        ref_pres = data['reference_pressure'] if \
+            'reference_pressure' in data and \
+            data['reference_pressure'] is not None else 101320
+        ref_hum = data['reference_humidity_ratio'] if 'reference_humidity_ratio' in \
+            data and data['reference_humidity_ratio'] is not None else 0
+        bld_type = data['building_type'] if 'building_type' in data and \
+            data['building_type'] is not None else 'LowRise'
+        axis = data['long_axis_angle'] if 'long_axis_angle' in data and \
+            data['long_axis_angle'] is not None else 0
+        ratio = data['aspect_ratio'] if 'aspect_ratio' in data and data['aspect_ratio'] \
+            is not None else 1
+        return cls(vent_control_type, ref_temp, ref_pres, ref_hum, bld_type, axis, ratio)
+
+    def to_dict(self):
+        """VentilationSimulationControl dictionary representation."""
+        base = {'type': 'VentilationSimulationControl'}
+        base['vent_control_type'] = self.vent_control_type
+        base['reference_temperature'] = self.reference_temperature
+        base['reference_pressure'] = self.reference_pressure
+        base['reference_humidity_ratio'] = self.reference_humidity_ratio
+        base['building_type'] = self.building_type
+        base['long_axis_angle'] = self.long_axis_angle
+        base['aspect_ratio'] = self.aspect_ratio
+        return base
+
+    def duplicate(self):
+        """Get a copy of this object."""
+        return self.__copy__()
+
+    @staticmethod
+    def geometry_properties_from_rooms(rooms, axis_angle=0):
+        """Get AFN building geometry properties from an array of Honeybee Rooms.
+
+        Args:
+            rooms: An array of Honeybee Rooms, which will have their geometry
+                collectively analyzed.
+            axis_angle: The clockwise rotation angle in degrees in the XY plane
+                to represent the orientation of the bounding box. (Default: 0).
+
+        Returns:
+            A tuple with 2 values for geometry properties.
+
+            1) Text indicating the building_type (either Highrise or LowRise)
+            2) A number for the aspect ratio of the axis_angle-oriented bounding box.
+
+            Note that the aspect ratio may be greater than 1 if the axis_angle
+            isn't aligned to the long axis of the geometry.
+        """
+        # process the inputs to be suitable for ladybug_geometry
+        if axis_angle != 0:  # convert to counter-clockwise radians for ladybug_geometry
+            axis_angle = -math.radians(axis_angle)
+        geo = [room.geometry for room in rooms]  # get ladybug_geometry polyfaces
+
+        # get the bounding box and return the properties
+        xx, yy, zz = bounding_box_extents(geo)
+        bldg_type = 'LowRise' if zz <= 3 * max(xx, yy) else 'HighRise'
+        return bldg_type, xx / yy
+
+    def __copy__(self):
+        return VentilationSimulationControl(
+            self.vent_control_type, self.reference_temperature,
+            self.reference_pressure, self.reference_humidity_ratio,
+            self.building_type, self.long_axis_angle, self.aspect_ratio)
+
+    def __key(self):
+        """A tuple based on the object properties, useful for hashing."""
+        return (self.vent_control_type, self.reference_temperature,
+                self.reference_pressure, self.reference_humidity_ratio,
+                self.building_type, self.long_axis_angle, self.aspect_ratio)
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __eq__(self, other):
+        return isinstance(other, VentilationSimulationControl) 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 'VentilationSimulationControl: [control type: {}] ' \
+            '[building_type: {}] [long axis: {}] [aspect_ratio: {}]' .format(
+                self.vent_control_type, self.building_type,
+                round(self.long_axis_angle), round(self.aspect_ratio, 2))