honeybee-energy 1.116.106__py3-none-any.whl

honeybee_energy/simulation/control.py

@@ -0,0 +1,214 @@
+# coding=utf-8
+"""Simulation controls for which types of calculations to run."""
+from __future__ import division
+
+from ..reader import parse_idf_string
+from ..writer import generate_idf_string
+
+
+class SimulationControl(object):
+    """Simulation controls for which types of calculations to run.
+
+    Args:
+        do_zone_sizing: Boolean for whether the zone sizing calculation
+            should be run. Default: True.
+        do_system_sizing: Boolean for whether the system sizing calculation
+            should be run. Default: True.
+        do_plant_sizing: Boolean for whether the plant sizing calculation
+            should be run. Default: True.
+        run_for_sizing_periods: Boolean for whether the simulation should
+            be run for the sizing periods. Default: False.
+        run_for_run_periods: Boolean for whether the simulation should
+            be run for the run periods. Default: True.
+
+    Properties:
+        * do_zone_sizing
+        * do_system_sizing
+        * do_plant_sizing
+        * run_for_sizing_periods
+        * run_for_run_periods
+    """
+    __slots__ = ('_do_zone_sizing', '_do_system_sizing', '_do_plant_sizing',
+                 '_run_for_sizing_periods', '_run_for_run_periods')
+
+    def __init__(self, do_zone_sizing=True, do_system_sizing=True,
+                 do_plant_sizing=True, run_for_sizing_periods=False,
+                 run_for_run_periods=True):
+        """Initialize SimulationControl."""
+        self.do_zone_sizing = do_zone_sizing
+        self.do_system_sizing = do_system_sizing
+        self.do_plant_sizing = do_plant_sizing
+        self.run_for_sizing_periods = run_for_sizing_periods
+        self.run_for_run_periods = run_for_run_periods
+
+    @property
+    def do_zone_sizing(self):
+        """Get or set a boolean for whether the zone sizing calculation is run."""
+        return self._do_zone_sizing
+
+    @do_zone_sizing.setter
+    def do_zone_sizing(self, value):
+        self._do_zone_sizing = bool(value)
+
+    @property
+    def do_system_sizing(self):
+        """Get or set a boolean for whether the system sizing calculation is run."""
+        return self._do_system_sizing
+
+    @do_system_sizing.setter
+    def do_system_sizing(self, value):
+        self._do_system_sizing = bool(value)
+
+    @property
+    def do_plant_sizing(self):
+        """Get or set a boolean for whether the plant sizing calculation is run."""
+        return self._do_plant_sizing
+
+    @do_plant_sizing.setter
+    def do_plant_sizing(self, value):
+        self._do_plant_sizing = bool(value)
+
+    @property
+    def run_for_sizing_periods(self):
+        """Get or set a boolean for whether the simulation is run for sizing periods."""
+        return self._run_for_sizing_periods
+
+    @run_for_sizing_periods.setter
+    def run_for_sizing_periods(self, value):
+        self._run_for_sizing_periods = bool(value)
+
+    @property
+    def run_for_run_periods(self):
+        """Get or set a boolean for whether the simulation is run for run periods."""
+        return self._run_for_run_periods
+
+    @run_for_run_periods.setter
+    def run_for_run_periods(self, value):
+        self._run_for_run_periods = bool(value)
+
+    @classmethod
+    def from_idf(cls, idf_string):
+        """Create a SimulationControl object from an EnergyPlus IDF text string.
+
+        Args:
+            idf_string: A text string fully describing an EnergyPlus
+                SimulationControl definition.
+        """
+        # check the inputs
+        ep_strs = parse_idf_string(idf_string, 'SimulationControl,')
+
+        # extract the properties from the string
+        do_zone_sizing = False
+        do_system_sizing = False
+        do_plant_sizing = False
+        run_for_sizing_periods = True
+        run_for_run_periods = True
+        try:
+            do_zone_sizing = True if ep_strs[0].lower() == 'yes' else False
+            do_system_sizing = True if ep_strs[1].lower() == 'yes' else False
+            do_plant_sizing = True if ep_strs[2].lower() == 'yes' else False
+            run_for_sizing_periods = False if ep_strs[3].lower() == 'no' else True
+            run_for_run_periods = False if ep_strs[4].lower() == 'no' else True
+        except IndexError:
+            pass  # shorter SimulationControl definition
+
+        return cls(do_zone_sizing, do_system_sizing, do_plant_sizing,
+                   run_for_sizing_periods, run_for_run_periods)
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a SimulationControl object from a dictionary.
+
+        Args:
+            data: A SimulationControl dictionary in following the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "SimulationControl",
+            "do_zone_sizing": True,
+            "do_system_sizing": True,
+            "do_plant_sizing": True,
+            "run_for_sizing_periods": False,
+            "run_for_run_periods": True
+            }
+        """
+        assert data['type'] == 'SimulationControl', \
+            'Expected SimulationControl dictionary. Got {}.'.format(data['type'])
+        do_zone_sizing = data['do_zone_sizing'] if \
+            'do_zone_sizing' in data else True
+        do_system_sizing = data['do_system_sizing'] if \
+            'do_system_sizing' in data else True
+        do_plant_sizing = data['do_plant_sizing'] if \
+            'do_plant_sizing' in data else True
+        run_for_sizing_periods = data['run_for_sizing_periods'] if \
+            'run_for_sizing_periods' in data else False
+        run_for_run_periods = data['run_for_run_periods'] if \
+            'run_for_run_periods' in data else False
+        return cls(do_zone_sizing, do_system_sizing, do_plant_sizing,
+                   run_for_sizing_periods, run_for_run_periods)
+
+    def to_idf(self):
+        """Get an EnergyPlus string representation of the SimulationControl.
+
+        .. code-block:: shell 
+
+            SimulationControl,
+                Yes,                      !- do zone sizing
+                Yes,                      !- do system sizing
+                Yes,                      !- do plant sizing
+                No,                       !- run for sizing periods
+                Yes;                      !- run for run periods
+        """
+        do_zone_sizing = 'Yes' if self.do_zone_sizing else 'No'
+        do_system_sizing = 'Yes' if self.do_system_sizing else 'No'
+        do_plant_sizing = 'Yes' if self.do_plant_sizing else 'No'
+        run_for_sizing_periods = 'Yes' if self.run_for_sizing_periods else 'No'
+        run_for_run_periods = 'Yes' if self.run_for_run_periods else 'No'
+        values = (do_zone_sizing, do_system_sizing, do_plant_sizing,
+                  run_for_sizing_periods, run_for_run_periods)
+        comments = ('do zone sizing', 'do system sizing', 'do plant sizing',
+                    'run for sizing periods', 'run for run periods')
+        return generate_idf_string('SimulationControl', values, comments)
+
+    def to_dict(self):
+        """SimulationControl dictionary representation."""
+        return {
+            'type': 'SimulationControl',
+            'do_zone_sizing': self.do_zone_sizing,
+            'do_system_sizing': self.do_system_sizing,
+            'do_plant_sizing': self.do_plant_sizing,
+            'run_for_sizing_periods': self.run_for_sizing_periods,
+            'run_for_run_periods': self.run_for_run_periods
+        }
+
+    def duplicate(self):
+        """Get a copy of this object."""
+        return self.__copy__()
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def __copy__(self):
+        return SimulationControl(
+            self.do_zone_sizing, self.do_system_sizing,
+            self.do_plant_sizing, self.run_for_sizing_periods,
+            self.run_for_run_periods)
+
+    def __key(self):
+        """A tuple based on the object properties, useful for hashing."""
+        return (self.do_zone_sizing, self.do_system_sizing, self.do_plant_sizing,
+                self.run_for_sizing_periods, self.run_for_run_periods)
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __eq__(self, other):
+        return isinstance(other, SimulationControl) and self.__key() == other.__key()
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        return self.to_idf()

honeybee_energy/simulation/daylightsaving.py

@@ -0,0 +1,185 @@
+# coding=utf-8
+"""EnergyPlus Daylight Saving Time Period."""
+from __future__ import division
+
+from ..reader import parse_idf_string
+from ..writer import generate_idf_string
+
+from ladybug.analysisperiod import AnalysisPeriod
+from ladybug.dt import Date
+
+
+class DaylightSavingTime(object):
+    """EnergyPlus Daylight Saving Time Period.
+
+    Args:
+        start_date: A ladybug Date object for the start of daylight saving time.
+            Must be before the end date and have a leap_year property matching the
+            end_date. Default: 12 Mar (daylight savings in the US in 2017)
+        end_date: A ladybug Date object for the end of daylight saving time.
+            Must be after the start date and have a leap_year property matching the
+            start_date. Default: 5 Nov (daylight savings in the US in 2017)
+
+    Properties:
+        * start_date
+        * end_date
+    """
+    __slots__ = ('_start_date', '_end_date')
+
+    def __init__(self, start_date=Date(3, 12), end_date=Date(11, 5)):
+        """Initialize DaylightSavingTime."""
+        # process the dates
+        if start_date is not None:
+            self._check_date(start_date, 'start_date')
+            self._start_date = start_date
+        else:
+            self._start_date = Date(3, 12)
+        self.end_date = end_date
+
+    @property
+    def start_date(self):
+        """Get or set a ladybug Date object for the start of the period."""
+        return self._start_date
+
+    @start_date.setter
+    def start_date(self, value):
+        if value is not None:
+            self._check_date(value, 'start_date')
+            self._start_date = value
+        else:
+            self._start_date = Date(1, 1)
+        self._check_start_before_end()
+
+    @property
+    def end_date(self):
+        """Get or set a ladybug Date object for the end of the period."""
+        return self._end_date
+
+    @end_date.setter
+    def end_date(self, value):
+        if value is not None:
+            self._check_date(value, 'end_date')
+            self._end_date = value
+        else:
+            self._end_date = Date(12, 31)
+        self._check_start_before_end()
+
+    @classmethod
+    def from_analysis_period(cls, analysis_period=AnalysisPeriod(3, 12, 0, 11, 5, 23)):
+        """Initialize a DaylightSavingTime object from a ladybug AnalysisPeriod.
+
+        Args:
+            analysis_period: A ladybug AnalysisPeriod object that has the start
+                and end dates for daylight savings time.
+                Default: 12 Mar - 5 Nov (daylight savings in the US in 2017)
+        """
+        assert isinstance(analysis_period, AnalysisPeriod), 'Expected AnalysisPeriod ' \
+            'for DaylightSavingTime.from_analysis_period. Got {}.'.format(
+                type(analysis_period))
+        st_date = Date(analysis_period.st_month, analysis_period.st_day,
+                       analysis_period.is_leap_year)
+        end_date = Date(analysis_period.end_month, analysis_period.end_day,
+                        analysis_period.is_leap_year)
+        return cls(st_date, end_date)
+
+    @classmethod
+    def from_idf(cls, idf_string):
+        """Create a DaylightSavingTime object from an EnergyPlus IDF text string.
+
+        Args:
+            idf_string: A text string fully describing an EnergyPlus
+                RunPeriodControl:DaylightSavingTime definition.
+        """
+        # check the inputs
+        ep_strs = parse_idf_string(idf_string, 'RunPeriodControl:DaylightSavingTime,')
+        start_vals = ep_strs[0].split('/')
+        end_vals = ep_strs[1].split('/')
+        start_date = Date(int(start_vals[0]), int(start_vals[1]))
+        end_date = Date(int(end_vals[0]), int(end_vals[1]))
+        return cls(start_date, end_date)
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a DaylightSavingTime object from a dictionary.
+
+        Args:
+            data: A DaylightSavingTime dictionary in following the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "DaylightSavingTime",
+            "start_date": [3, 12],
+            "end_date": [11, 5]
+            }
+        """
+        assert data['type'] == 'DaylightSavingTime', \
+            'Expected DaylightSavingTime dictionary. Got {}.'.format(data['type'])
+        start_date = Date.from_array(data['start_date']) if 'start_date' in data and \
+            data['start_date'] is not None else Date(1, 1)
+        end_date = Date.from_array(data['end_date']) if 'end_date' in data and \
+            data['end_date'] is not None else Date(12, 31)
+        return cls(start_date, end_date)
+
+    def to_idf(self):
+        """Get an EnergyPlus string representation of the DaylightSavingTime.
+
+        .. code-block:: shell
+
+            RunPeriodControl:DaylightSavingTime,
+                2nd Sunday in March,           !- Start Date
+                1st Sunday in November;        !- End Date
+        """
+        values = ('{}/{}'.format(self.start_date.month, self.start_date.day),
+                  '{}/{}'.format(self.end_date.month, self.end_date.day))
+        comments = ('start date', 'end date')
+        return generate_idf_string('RunPeriodControl:DaylightSavingTime',
+                                   values, comments)
+
+    def to_dict(self):
+        """DaylightSavingTime dictionary representation."""
+        return {
+            'type': 'DaylightSavingTime',
+            'start_date': self.start_date.to_array(),
+            'end_date': self.end_date.to_array()
+        }
+
+    def duplicate(self):
+        """Get a copy of this object."""
+        return self.__copy__()
+
+    def _check_start_before_end(self):
+        """Check that the start_date is before the end_date."""
+        assert self.start_date.leap_year is self.end_date.leap_year, \
+            'DaylightSavingTime start_date.leap_year must match the end_date.leap_year'
+        assert self._start_date <= self._end_date, \
+            'DaylightSavingTime start_date must be before end_date. ' \
+            '{} is after {}.'.format(self.start_date, self.end_date)
+
+    @staticmethod
+    def _check_date(date, date_name='date'):
+        assert isinstance(date, Date), 'Expected ladybug Date for ' \
+            'DaylightSavingTime {}. Got {}.'.format(date_name, type(date))
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def __copy__(self):
+        return DaylightSavingTime(self.start_date, self.end_date)
+
+    def __key(self):
+        """A tuple based on the object properties, useful for hashing."""
+        return (hash(self.start_date), hash(self.end_date))
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __eq__(self, other):
+        return isinstance(other, DaylightSavingTime) and self.__key() == other.__key()
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        return self.to_idf()

honeybee_energy/simulation/dictutil.py

@@ -0,0 +1,51 @@
+# coding=utf-8
+"""Utilities to convert simulation dictionaries to Python objects."""
+from honeybee_energy.simulation.control import SimulationControl
+from honeybee_energy.simulation.runperiod import RunPeriod
+from honeybee_energy.simulation.daylightsaving import DaylightSavingTime
+from honeybee_energy.simulation.shadowcalculation import ShadowCalculation
+from honeybee_energy.simulation.sizing import SizingParameter
+from honeybee_energy.simulation.output import SimulationOutput
+from honeybee_energy.simulation.parameter import SimulationParameter
+
+
+SIMULATION_TYPES = ('SimulationControl', 'RunPeriod', 'DaylightSavingTime',
+                    'ShadowCalculation', 'SizingParameter', 'SimulationOutput',
+                    'SimulationParameter')
+
+
+def dict_to_simulation(sim_dict, raise_exception=True):
+    """Get a Python object of any Simulation object from a dictionary.
+
+    Args:
+        sim_dict: A dictionary of any Honeybee energy simulation object. Note
+            that this should be a non-abridged dictionary to be valid.
+        raise_exception: Boolean to note whether an excpetion should be raised
+            if the object is not identified as a simulation object. Default: True.
+
+    Returns:
+        A Python object derived from the input sim_dict.
+    """
+    try:  # get the type key from the dictionary
+        sim_type = sim_dict['type']
+    except KeyError:
+        raise ValueError('Simulation dictionary lacks required "type" key.')
+
+    if sim_type == 'SimulationControl':
+        return SimulationControl.from_dict(sim_dict)
+    elif sim_type == 'RunPeriod':
+        return RunPeriod.from_dict(sim_dict)
+    elif sim_type == 'DaylightSavingTime':
+        return DaylightSavingTime.from_dict(sim_dict)
+    elif sim_type == 'ShadowCalculation':
+        return ShadowCalculation.from_dict(sim_dict)
+    elif sim_type == 'SizingParameter':
+        return SizingParameter.from_dict(sim_dict)
+    elif sim_type == 'SimulationOutput':
+        return SimulationOutput.from_dict(sim_dict)
+    elif sim_type == 'SimulationParameter':
+        return SimulationParameter.from_dict(sim_dict)
+    elif raise_exception:
+        raise ValueError(
+            '{} is not a recognized energy Simulation type'.format(sim_type)
+        )