dragonfly-doe2 0.11.2__py2.py3-none-any.whl → 0.12.1__py2.py3-none-any.whl

dragonfly_doe2/doe/glass_types.py

@@ -1,44 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import Union
-
-from honeybee_energy.construction.window import WindowConstruction
-from honeybee_energy.material.glazing import EnergyWindowMaterialGlazing, \
-    EnergyWindowMaterialSimpleGlazSys
-
-from honeybee_energy.construction.window import WindowConstruction
-
-from .utils import short_name, unit_convertor
-
-
-@dataclass
-class GlassType:
-    """ Doe2 glass type, (window construction) """
-    name: str
-    shading_coef: float
-    glass_cond: float
-
-    @classmethod
-    def from_hb_window_constr(cls, window_constr: WindowConstruction):
-        simple_window_con = window_constr.to_simple_construction()
-        simple_window_mat = simple_window_con.materials[0]
-
-        shading_coef = simple_window_mat.shgc / 0.87
-
-        glass_cond = unit_convertor(
-            [simple_window_mat.u_factor], 'Btu/h-ft2-F', 'W/m2-K')
-
-        name = simple_window_con.identifier
-        name = short_name(name, 32)
-
-        return cls(name=name, shading_coef=shading_coef, glass_cond=glass_cond)
-
-    def to_inp(self) -> str:
-        return f'"{self.name}" = GLASS-TYPE\n' \
-               f'   TYPE               = SHADING-COEF\n' \
-               f'   SHADING-COEF       = {self.shading_coef}\n' \
-               f'   GLASS-CONDUCT      = {self.glass_cond}\n' \
-               f'   ..'
-
-    def __repr__(self):
-        return self.to_inp()

dragonfly_doe2/doe/hvac.py

@@ -1,96 +0,0 @@
-from dragonfly.story import Story as DFStory
-from dragonfly.room2d import Room2D as DFRoom
-from .utils import short_name
-from dataclasses import dataclass
-from typing import List
-
-# TODO: I don't like the disconnect between this MO and the 'floor_space'
-# TODO: Classes, on refactor; need more OOP for sure, this 'lesser oopy'
-# TODO: be getting confusing and there is obvious shared atrib/props
-# TODO: that should be linked to prevent breakage, possibly from doe objs
-# TODO: instead of df objs? as a temp means?
-
-
-@dataclass
-class Zone:
-    """A doe2 'Zone' object from dragonfly Room2D.
-    Args:
-        name: room display name
-        heating_setpoint: heating setpoint temperature (*F) eQuest default of 72*F if no 
-        setpoint found in DF room2D program
-        cooling_setpoint: cooling setpoint temperature (*F) eQuest default of 75*F if no
-        setpoint found in DF room2D program
-    Init method(s):
-        1. from_room(room: DFRoom)-> doe_zone:
-        """
-    name: str
-    heating_setpoint: float
-    cooling_setpoint: float
-
-    @classmethod
-    def from_room(cls, room: DFRoom):
-        if not isinstance(room, DFRoom):
-            raise ValueError(
-                f'Unsupported type: {type(room)}\n'
-                'Expected dragonfly.room2d.Room2D'
-            )
-
-        name = room.display_name
-        if room.properties.energy.is_conditioned:
-            heating_setpoint = room.properties.energy.program_type.setpoint.heating_setpoint
-            cooling_setpoint = room.properties.energy.program_type.setpoint.cooling_setpoint
-        else:
-            heating_setpoint = 72
-            cooling_setpoint = 75
-
-        return cls(name=name, heating_setpoint=heating_setpoint,
-                   cooling_setpoint=cooling_setpoint)
-
-    def to_inp(self):
-        inp_str = f'"{self.name} Zn"   = ZONE\n  ' \
-            'TYPE             = UNCONDITIONED\n  ' \
-            f'DESIGN-HEAT-T    = {self.heating_setpoint}\n  ' \
-            f'DESIGN-COOL-T    = {self.cooling_setpoint}\n  ' \
-            'SIZING-OPTION    = ADJUST-LOADS\n  ' \
-            f'SPACE            = "{self.name}"\n  ..\n'
-        return inp_str
-
-    def __repr__(self) -> str:
-        return self.to_inp()
-
-
-@dataclass
-class HVACSystem:
-    """Placeholder HVAC system class, returns each floor as a doe2,
-    HVAC system, with rooms as zones.
-    Args:
-        name: story display name
-        zones: list of doe2.hvac.Zone objects serviced by the system
-    Init method(s):
-        1. from_story(story: DFStory) -> doe2_system:
-    """
-    name: str
-    zones: List[Zone]
-
-    @classmethod
-    def from_story(cls, story: DFStory):
-        if not isinstance(story, DFStory):
-            raise ValueError(
-                f'Unsupported type: {type(story)}\n'
-                'Expected dragonfly.story.Story'
-            )
-        name = story.display_name
-        zones = [Zone.from_room(room) for room in story.room_2ds]
-        return cls(name=name, zones=zones)
-
-    def to_inp(self):
-        sys_str = f'"{self.name}flr_Sys (SUM)" = SYSTEM\n' \
-            '   TYPE             = SUM\n' \
-            '   HEAT-SOURCE      = NONE\n' \
-            '   SYSTEM-REPORTS   = NO\n   ..\n'
-        zones_str = '\n'.join(zone.to_inp() for zone in self.zones)
-        inp_str = '\n'.join([sys_str, zones_str])
-        return inp_str
-
-    def __repr__(self):
-        return self.to_inp()

dragonfly_doe2/doe/material.py

@@ -1,84 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import Union
-
-from honeybee_energy.material.opaque import EnergyMaterial, EnergyMaterialNoMass
-from .utils import short_name, unit_convertor
-
-
-class MaterialType(Enum):
-    """Doe2 material types."""
-    mass = 'PROPERTIES'
-    no_mass = 'RESISTANCE'
-
-
-@dataclass
-class NoMassMaterial:
-    name: str
-    resistance: float
-
-    @classmethod
-    def from_hb_material(cls, material: EnergyMaterialNoMass):
-        resistance = unit_convertor([material.r_value], 'h-ft2-F/Btu', 'm2-K/W')
-        return cls(short_name(material.display_name, 32), resistance)
-
-    def to_inp(self):
-        return f'"{self.name}" = MATERIAL\n' \
-            f'   TYPE            = {MaterialType.no_mass.value}\n' \
-            f'   RESISTANCE      = {self.resistance}\n' \
-            '   ..'
-
-
-@dataclass
-class MassMaterial:
-
-    name: str
-    thickness: float
-    conductivity: str
-    density: float
-    specific_heat: float
-
-    @classmethod
-    def from_hb_material(cls, material: EnergyMaterial):
-        name = short_name(material.display_name, 32)
-        thickness = unit_convertor([material.thickness], 'ft', 'm')
-        conductivity = unit_convertor([material.conductivity], 'Btu/h-ft2', 'W/m2')
-        density = round(material.density / 16.018, 3)
-        specific_heat = unit_convertor([material.specific_heat], 'Btu/lb', 'J/kg')
-        return cls(
-            name, thickness, conductivity, density, specific_heat
-        )
-
-    def to_inp(self):
-        return f'"{self.name}" = MATERIAL\n' \
-               f'   TYPE            = {MaterialType.mass.value}\n' \
-               f'   THICKNESS       = {self.thickness}\n' \
-               f'   CONDUCTIVITY    = {self.conductivity}\n' \
-               f'   DENSITY         = {self.density}\n' \
-               f'   SPECIFIC-HEAT   = {self.specific_heat}\n' \
-            '   ..'
-
-
-@dataclass
-class Material:
-    """Do2 Material object.
-
-    refer to:
-        assets/DOE22Vol2-Dictionary_48r.pdf pg: 97
-    """
-    material: Union[NoMassMaterial, MassMaterial]
-
-    @classmethod
-    def from_hb_material(cls, material: Union[EnergyMaterial, EnergyMaterialNoMass]):
-        if isinstance(material, EnergyMaterial):
-            return MassMaterial.from_hb_material(material)
-        elif isinstance(material, EnergyMaterialNoMass):
-            return NoMassMaterial.from_hb_material(material)
-        else:
-            raise ValueError(f'{type(material)} type is not supported for materials.')
-
-    def to_inp(self) -> str:
-        return self.material.to_inp()
-
-    def __repr__(self):
-        return self.to_inp()

dragonfly_doe2/doe/model.py

@@ -1,276 +0,0 @@
-from typing import List
-
-from dragonfly.model import Model as DFModel
-from dragonfly.story import Story as DFStory
-from dragonfly.room2d import Room2D as DFRoom
-
-from ladybug.analysisperiod import AnalysisPeriod
-
-from honeybee_energy.construction.window import WindowConstruction
-from honeybee_energy.lib.constructionsets import generic_construction_set
-
-from .polygon import Polygon
-from .compliance import ComplianceData
-from .sitebldg import SiteBldgData
-from .title import Title
-from .run_period import RunPeriod
-from .construction import Construction, ConstructionCollection
-from .floor_space import Floor
-from .glass_types import GlassType
-from .shades import Doe2ShadeCollection
-from .hvac import HVACSystem
-
-from . import blocks as fb
-
-
-class Model:
-    """A DOE *.inp Model File Object."""
-
-    def __init__(self, title, run_period=None, compliance_data=None,
-                 site_building_data=None, polygons=None, constructions=None, floors=None,
-                 glass_types=None, context_shades=None, hvac_system_zone=None) -> None:
-        self.title = title
-        self.run_period = run_period
-        self.compliance_data = compliance_data
-        self.site_bldg_data = site_building_data
-        self.polygons = polygons
-        self.constructions = constructions
-        self.floors = floors
-        self.glass_types = glass_types
-        self.context_shades = context_shades
-        self.hvac_system_zone = hvac_system_zone
-
-    @classmethod
-    def from_df_model(cls, df_model: DFModel, run_period=None):
-        # Make model windows rectangular to be INP friendly
-        df_model.to_rectangular_windows()
-
-        # Check model units, ensure units in feet
-        df_model.convert_to_units(units='Feet')
-        df_model.properties.energy.construction_sets.append(generic_construction_set)
-
-        polygons = []
-        flr_spc = []
-        window_constructions = []
-        context_shades = []
-        hvac_system_zone = []
-
-        window_constructions.append(
-            generic_construction_set.aperture_set.window_construction)
-
-        for con_set in df_model.properties.energy.construction_sets:
-            window_constructions.append(con_set.aperture_set.window_construction)
-
-        # purge duplicate window constructions
-        window_constructions = list(set(window_constructions))
-
-        for building in df_model.buildings:
-            for story in building.all_stories():
-                # enforce a recompute of floor to floor height
-                if story.floor_to_floor_height == 0:
-                    story.floor_to_floor_height = None
-
-                story.solve_room_2d_adjacency(df_model.tolerance, intersect=True)
-
-                hvac_system_zone.append(HVACSystem.from_story(story))
-
-                flr_spc.append(Floor.from_story(story))
-                polygons.append(Polygon.from_story(story))
-                for room in story:
-                    polygons.append(Polygon.from_room(room))
-
-        df_envelope_constrs = []
-        for con in generic_construction_set.wall_set.constructions:
-            df_envelope_constrs.append(con)
-        for con in generic_construction_set.floor_set.constructions:
-            df_envelope_constrs.append(con)
-        for con in generic_construction_set.roof_ceiling_set:
-            df_envelope_constrs.append(con)
-        # TODO: This messy MO takes the un-needed door constructions out of the equation
-        # TODO: Make more elegant when implements "to thin, make u-val"
-        for construction_set in df_model.properties.energy.construction_sets:
-            for con in construction_set.wall_set.constructions:
-                df_envelope_constrs.append(con)
-            for con in generic_construction_set.wall_set.constructions:
-                df_envelope_constrs.append(con)
-            for con in construction_set.floor_set.constructions:
-                df_envelope_constrs.append(con)
-            for con in construction_set.roof_ceiling_set:
-                df_envelope_constrs.append(con)
-
-        constructions = ConstructionCollection.from_hb_constructions(
-            df_envelope_constrs)
-
-        glass_types = [GlassType.from_hb_window_constr(
-            w_con) for w_con in window_constructions]
-
-        shade_objs = df_model.context_shades
-        context_shades.append(Doe2ShadeCollection.from_df_context_shades(shade_objs))
-
-        return cls(
-            df_model.display_name, run_period, polygons=polygons,
-            constructions=constructions, floors=flr_spc, glass_types=glass_types,
-            context_shades=context_shades, hvac_system_zone=hvac_system_zone)
-
-    @classmethod
-    def from_dfjson(cls, dfjson_file, run_period=None):
-        model = DFModel.from_dfjson(dfjson_file)
-        return cls.from_df_model(model, run_period)
-
-    @property
-    def _header(self):
-        """File header.
-
-        NOTE: The header is currently read-only
-        """
-        return '\n'.join([fb.top_level, fb.abort_diag])
-
-    @property
-    def title(self):
-        return self._title
-
-    @title.setter
-    def title(self, value):
-        self._title = Title(value)
-        # update the title in complinace data
-        try:
-            self.compliance_data.proj_name = value
-        except AttributeError:
-            # this happens on initiation since compliance data is not set yet
-            # we can ignore it
-            pass
-
-    @property
-    def run_period(self):
-        """Model run period."""
-        return self._run_period
-
-    @run_period.setter
-    def run_period(self, value: AnalysisPeriod):
-        self._run_period = RunPeriod.from_analysis_period(value)
-
-    @property
-    def compliance_data(self):
-        """Model DOE2 Compliance Data"""
-        return self._compliance_data
-
-    @compliance_data.setter
-    def compliance_data(self, value):
-        if not value:
-            value = ComplianceData()
-        # make sure the project name is set to model title
-        value.proj_name = self.title.title
-        self._compliance_data = value
-
-    @property
-    def site_bldg_data(self):
-        return self._site_bldg_data
-
-    @site_bldg_data.setter
-    def site_bldg_data(self, value):
-        if not value:
-            value = SiteBldgData()
-        self._site_bldg_data = value
-
-    @property
-    def polygons(self) -> List[Polygon]:
-        return self._polygons
-
-    @polygons.setter
-    def polygons(self, value):
-        self._polygons = value
-
-    @property
-    def constructions(self) -> ConstructionCollection:
-        return self._constructions
-
-    @constructions.setter
-    def constructions(self, value):
-        self._constructions = value
-
-    @property
-    def glass_types(self):
-        return self._glass_types
-
-    @glass_types.setter
-    def glass_types(self, value):
-        self._glass_types = value
-
-    @property
-    def context_shades(self):
-        return self._context_shades
-
-    @context_shades.setter
-    def context_shades(self, value):
-        self._context_shades = value
-
-    @property
-    def hvac_system_zone(self):
-        return self._hvac_system_zone
-
-    @hvac_system_zone.setter
-    def hvac_system_zone(self, value):
-        self._hvac_system_zone = value
-
-    def to_inp(self):
-
-        data = [
-            self._header,
-            fb.global_params,
-            fb.ttrpddh, self.title.to_inp(), self.run_period.to_inp(),
-            fb.comply,
-            self.compliance_data.to_inp(),
-            self.site_bldg_data.to_inp(),
-            self.constructions.to_inp(),
-            fb.glzCode,
-            '\n'.join(gt.to_inp() for gt in self.glass_types),
-            fb.polygons,
-            '\n'.join(pl.to_inp() for pl in self.polygons),
-            fb.wallParams,
-            '\n'.join(shd.to_inp() for shd in self.context_shades),
-            fb.miscCost,
-            fb.perfCurve,
-            fb.floorNspace,
-            '\n'.join(flr.to_inp() for flr in self.floors),
-            fb.elecFuelMeter,
-            fb.elec_meter,
-            fb.fuel_meter,
-            fb.master_meter,
-            fb.hvac_circ_loop,
-            fb.pumps,
-            fb.heat_exch,
-            fb.circ_loop,
-            fb.chiller_objs,
-            fb.boiler_objs,
-            fb.dwh,
-            fb.heat_reject,
-            fb.tower_free,
-            fb.pvmod,
-            fb.elecgen,
-            fb.thermal_store,
-            fb.ground_loop_hx,
-            fb.comp_dhw_res,
-            fb.steam_cld_mtr,
-            fb.steam_mtr,
-            fb.chill_meter,
-            fb.hvac_sys_zone,
-            '\n'.join(hv_sys.to_inp() for hv_sys in self.hvac_system_zone),
-            fb.misc_meter_hvac,
-            fb.equip_controls,
-            fb.load_manage,
-            fb.big_util_rate,
-            fb.ratchets,
-            fb.block_charge,
-            fb.small_util_rate,
-            fb.output_reporting,
-            fb.loads_non_hrly,
-            fb.sys_non_hrly,
-            fb.plant_non_hrly,
-            fb.econ_non_hrly,
-            fb.hourly_rep,
-            fb.the_end
-        ]
-        return '\n\n'.join(data)
-
-    def __repr__(self) -> str:
-        return 'Doe2 Model:\n%s' % self.title.to_inp()

dragonfly_doe2/doe/polygon.py

@@ -1,59 +0,0 @@
-""" Templates for 'Block Inputs' that are of relative
-    Redundance between rooms and story objects
-"""
-from dragonfly.room2d import Room2D
-from dragonfly.story import Story
-from .utils import short_name, lower_left_properties
-
-
-class Polygon(object):
-    "A Doe2 Polygon."
-
-    def __init__(self, name, vertices):
-        self.name = name
-        self.vertice = vertices
-
-    @classmethod
-    def from_room(cls, room: Room2D, tolerace=0.01):
-        """
-        Note: Shouldn't we ensure the points are in 2D. I'm not sure how it works.
-        #TF: ooohhhhhhhhhh good catch!! Though is there not already built into DF something
-            of the sort for room.floor_geom? was operating off the *assumption* that obj.prop
-            would be good to go as is? or am I misunderstanding the specifics in which should
-            do check: raise exception if issue?
-        """
-        room.remove_duplicate_vertices()
-        # TODO: on refactor, need to minimize the disconnect between the poly and 'space' room
-        vertices = lower_left_properties(room)[0]
-        return cls(room.display_name, vertices)
-
-    @classmethod
-    def from_story(cls, story: Story, tolerance=0.01):
-        """
-        Note: I'm not sure if this is correct - shouldn't we create a polygon per face?
-        This is based on the initial code by Trevor so I didn't change it.
-        """
-        geo = story.footprint(tolerance=tolerance)[0]
-        # 
-        b_pts = geo.boundary
-        # remove duplicate vertices if any
-        new_bound = []
-        b_pts = b_pts[1:] + (b_pts[0],)
-        for i, vert in enumerate(b_pts):
-            if not vert.is_equivalent(b_pts[i - 1], tolerance):
-                new_bound.append(b_pts[i - 1])
-        return cls(story.display_name, new_bound)
-
-    def to_inp(self) -> str:
-        """Return Room Polygons block input"""
-        vertices_template = '   V%d\t\t= ( %f, %f )'.replace('\t', '    ')
-        vertices = '\n'.join([
-            vertices_template % (i + 1, ver.x, ver.y)
-            for i, ver in enumerate(self.vertice)
-        ])
-        return f'"{self.name} Plg" = POLYGON\n' \
-               f'{vertices}\n' + \
-               '   ..'
-
-    def __repr__(self):
-        return self.to_inp()

dragonfly_doe2/doe/run_period.py

@@ -1,41 +0,0 @@
-from dataclasses import dataclass
-from ladybug.analysisperiod import AnalysisPeriod
-
-
-@dataclass
-class RunPeriod:
-
-    begin_month: int = 1
-    begin_day: int = 1
-    begin_year: int = 2021
-    end_month: int = 12
-    end_day: int = 31
-    end_year: int = 2021
-
-    @classmethod
-    def from_analysis_period(cls, analysis_period: AnalysisPeriod = None):
-        analysis_period = analysis_period or AnalysisPeriod()
-        cls_ = cls()
-        cls_.begin_month = analysis_period.st_month
-        cls_.begin_day = analysis_period.st_day
-        cls_.end_month = analysis_period.end_month
-        cls_.end_day = analysis_period.end_month
-
-        return cls_
-
-    def to_inp(self) -> str:
-        """Return run period as an inp string."""
-        # standard holidays should be exposed.
-        return '"Entire Year" = RUN-PERIOD-PD\n   ' \
-            'BEGIN-MONTH     = 1\n' \
-            '   BEGIN-DAY      = 1\n' \
-            '   BEGIN-YEAR     = 2021\n' \
-            '   END-MONTH      = 12\n' \
-            '   END-DAY        = 31\n' \
-            '   END-YEAR       = 2021\n' \
-            '   ..\n\n' \
-            '"Standard US Holidays" = HOLIDAYS\n   ' \
-            'LIBRARY-ENTRY "US"\n   ..'
-
-    def __repr__(self) -> str:
-        return self.to_inp()