def test_window_shade_equivalency():
"""Test the equality of a WindowConstructionShade construction to another."""
clear_glass = EnergyWindowMaterialGlazing(
'Clear Glass', 0.005715, 0.770675, 0.07, 0.8836, 0.0804,
0, 0.84, 0.84, 1.0)
gap = EnergyWindowMaterialGas('air gap', thickness=0.0127)
double_clear = WindowConstruction(
'Double Clear Window', [clear_glass, gap, clear_glass])
shade_mat = EnergyWindowMaterialShade(
'Low-e Diffusing Shade', 0.005, 0.15, 0.5, 0.25, 0.5, 0, 0.4,
0.2, 0.1, 0.75, 0.25)
sched = ScheduleRuleset.from_daily_values(
'NighSched', [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1])
double_low_e_ec = WindowConstructionShade(
'Double Low-E Inside EC', double_clear, shade_mat, 'Exterior',
'OnIfHighSolarOnWindow', 200, sched)
double_low_e_ec_2 = double_low_e_ec.duplicate()
double_low_e_ec_3 = WindowConstructionShade(
'Double Low-E Inside EC', double_clear, shade_mat, 'Exterior',
'AlwaysOn', None, sched)
collection = [double_low_e_ec, double_low_e_ec, double_low_e_ec_2, double_low_e_ec_3]
assert len(set(collection)) == 2
assert double_low_e_ec == double_low_e_ec_2
assert double_low_e_ec != double_low_e_ec_3
assert double_low_e_ec_2 != double_low_e_ec_3
double_low_e_ec_2.identifier = 'Cool Window'
assert double_low_e_ec != double_low_e_ec_2
def test_schedule_ruleset_equality():
"""Test the equality of ScheduleRuleset objects."""
weekday_office = ScheduleDay(
'Weekday Office Occupancy', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
saturday_office = ScheduleDay(
'Saturday Office Occupancy', [0, 0.25, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
weekend_rule = ScheduleRule(saturday_office)
weekend_rule.apply_weekend = True
schedule = ScheduleRuleset('Office Occupancy', weekday_office,
[weekend_rule], schedule_types.fractional)
schedule_dup = schedule.duplicate()
residential_schedule = ScheduleRuleset.from_daily_values(
'Residence Occupancy', [
1, 1, 1, 1, 1, 1, 1, 0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0.25, 0.5, 0.5,
0.5, 0.5, 1, 1, 1
])
assert schedule is schedule
assert schedule is not schedule_dup
assert schedule == schedule_dup
schedule_dup.schedule_rules[0].apply_friday = True
assert schedule != schedule_dup
assert schedule != residential_schedule
def test_window_shade_lockability():
"""Test the lockability of the WindowConstructionShade construction."""
clear_glass = EnergyWindowMaterialGlazing(
'Clear Glass', 0.005715, 0.770675, 0.07, 0.8836, 0.0804,
0, 0.84, 0.84, 1.0)
gap = EnergyWindowMaterialGas('air gap', thickness=0.0127)
double_clear = WindowConstruction(
'Double Clear Window', [clear_glass, gap, clear_glass])
shade_mat = EnergyWindowMaterialShade(
'Low-e Diffusing Shade', 0.005, 0.15, 0.5, 0.25, 0.5, 0, 0.4,
0.2, 0.1, 0.75, 0.25)
sched = ScheduleRuleset.from_daily_values(
'NighSched', [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1])
double_low_e_ec = WindowConstructionShade(
'Double Low-E Inside EC', double_clear, shade_mat, 'Exterior',
'OnIfHighSolarOnWindow', 200, sched)
with pytest.raises(AttributeError):
double_low_e_ec.window_construction.materials = \
[clear_glass, gap, clear_glass, gap, clear_glass]
with pytest.raises(AttributeError):
double_low_e_ec.window_construction.schedule.identifier = 'ScheduleName'
with pytest.raises(AttributeError):
double_low_e_ec.shade_location = 'Interior'
double_low_e_ec.control_type = 'AlwaysOn'
double_low_e_ec.lock()
with pytest.raises(AttributeError):
double_low_e_ec.control_type = 'OnIfHighSolarOnWindow'
double_low_e_ec.unlock()
double_low_e_ec.control_type = 'OnIfHighSolarOnWindow'
def test_air_construction_to_idf():
"""Test the initialization of AirBoundaryConstruction objects and basic properties."""
night_flush = ScheduleRuleset.from_daily_values(
'Night Flush', [1, 1, 1, 1, 1, 1, 1, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
0.5, 0.5, 0.5, 0.5, 0.5, 1, 1, 1])
night_flush_constr = AirBoundaryConstruction('Night Flush Boundary', 0.4, night_flush)
assert isinstance(night_flush_constr.to_idf(), str)
def schedule_ruleset_simple_repeating(directory):
test_vals = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 1, 1, 1, 1, 1, 1,
0.5, 0.5, 0.5, 0.5, 1, 1, 1, 1, 0.5, 0.5, 0.5, 0.5]
sched = ScheduleRuleset.from_daily_values('Simple Repeating', test_vals)
dest_file = os.path.join(directory, 'schedule_ruleset_simple_repeating.json')
with open(dest_file, 'w') as fp:
json.dump(sched.to_dict(True), fp, indent=4)
def test_window_construction_ec_init():
"""Test the initialization of WindowConstructionShade objects with electrochromic."""
lowe_glass = EnergyWindowMaterialGlazing(
'Low-e Glass', 0.00318, 0.4517, 0.359, 0.714, 0.207,
0, 0.84, 0.046578, 1.0)
clear_glass = EnergyWindowMaterialGlazing(
'Clear Glass', 0.005715, 0.770675, 0.07, 0.8836, 0.0804,
0, 0.84, 0.84, 1.0)
gap = EnergyWindowMaterialGas('air gap', thickness=0.03)
tint_glass = EnergyWindowMaterialGlazing(
'Tinted Low-e Glass', 0.00318, 0.09, 0.359, 0.16, 0.207,
0, 0.84, 0.046578, 1.0)
window_constr = WindowConstruction('Double Low-E', [lowe_glass, gap, clear_glass])
sched = ScheduleRuleset.from_daily_values(
'NighSched', [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1])
double_low_e_ec = WindowConstructionShade(
'Double Low-E Inside EC', window_constr, tint_glass, 'Exterior',
'OnIfHighSolarOnWindow', 200, sched)
double_low_e_between_ec = WindowConstructionShade(
'Double Low-E Between EC', window_constr, tint_glass, 'Between')
double_low_e_ext_ec = WindowConstructionShade(
'Double Low-E Outside EC', window_constr, tint_glass, 'Interior')
double_low_e_ec_dup = double_low_e_ec.duplicate()
assert double_low_e_ec.identifier == 'Double Low-E Inside EC'
assert double_low_e_ec.window_construction == \
double_low_e_ec_dup.window_construction
assert double_low_e_ec.shade_material == double_low_e_ec_dup.shade_material
assert double_low_e_ec.shade_location == \
double_low_e_ec_dup.shade_location == 'Exterior'
assert double_low_e_ec.control_type == \
double_low_e_ec_dup.control_type == 'OnIfHighSolarOnWindow'
assert double_low_e_ec.setpoint == double_low_e_ec_dup.setpoint == 200
assert double_low_e_ec.schedule == double_low_e_ec_dup.schedule == sched
assert len(double_low_e_ec.materials) == 3
assert len(double_low_e_ec.layers) == 3
assert len(double_low_e_ec.unique_materials) == 4
assert not double_low_e_ec.is_symmetric
assert double_low_e_ec.is_switchable_glazing
assert double_low_e_ec.has_shade
assert double_low_e_ec.thickness == \
double_low_e_ec.window_construction.thickness
assert double_low_e_ec.glazing_count == 2
assert double_low_e_ec.gap_count == 1
assert double_low_e_between_ec.identifier == 'Double Low-E Between EC'
assert double_low_e_between_ec.shade_location == 'Between'
assert double_low_e_between_ec.control_type == 'AlwaysOn'
assert double_low_e_between_ec.setpoint is None
assert double_low_e_between_ec.schedule is None
assert len(double_low_e_between_ec.materials) == 3
assert len(double_low_e_between_ec.unique_materials) == 4
assert not double_low_e_between_ec.is_symmetric
assert double_low_e_between_ec.gap_count == 1
assert double_low_e_ext_ec.identifier == 'Double Low-E Outside EC'
assert len(double_low_e_ext_ec.materials) == 3
def single_family_home(directory):
poly_file = './scripts/geometry/single_family_geo.json'
with open(poly_file, 'r') as fp:
geo_dict = json.load(fp)
# create the basic Room objects
program = prog_type_lib.program_type_by_identifier('2013::MidriseApartment::Apartment')
c_set = constr_set_lib.construction_set_by_identifier('2013::ClimateZone5::SteelFramed')
rooms = []
for i, room_geo_dict in enumerate(geo_dict['rooms']):
room_geo = Polyface3D.from_dict(room_geo_dict)
room_geo.merge_overlapping_edges(0.01, math.radians(1))
room = Room.from_polyface3d('House_Room_{}'.format(i), room_geo)
room.properties.energy.program_type = program
room.properties.energy.construction_set = c_set
room.properties.energy.add_default_ideal_air()
rooms.append(room)
# make some of the rooms different to make it interesting
program2 = prog_type_lib.program_type_by_identifier('2013::MidriseApartment::Corridor')
rooms[6].properties.energy.program_type = program2
cook_vals = [0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 0, 0, 0, 0, 1.0, 0, 0, 0, 0, 0, 0, 0]
cook_meals = ScheduleRuleset.from_daily_values('Cooking_Meals', cook_vals)
kitchen_equip = GasEquipment('Kitchen Stove', 20, cook_meals)
rooms[0].properties.energy.gas_equipment = kitchen_equip
# add the apertures to the rooms
apertures = []
for i, ap_geo in enumerate(geo_dict['apertures']):
ap_face = Face3D.from_dict(ap_geo)
hb_ap = Aperture('House_Aperture_{}'.format(i), ap_face)
hb_ap.extruded_border(0.3)
apertures.append(hb_ap)
# assign apertures and solve adjacency
for room in rooms:
for face in room.faces:
for sf in apertures:
if face.geometry.is_sub_face(sf.geometry, 0.5, 1.0):
face.add_aperture(sf)
Room.solve_adjacency(rooms, 0.01)
# load up the context shades
shades = []
for i, shd_geo in enumerate(geo_dict['shades']):
shd_face = Face3D.from_dict(shd_geo)
shades.append(Shade('Context_Shade_{}'.format(i), shd_face))
# put it all together in a Model and write out the JSON
model = Model('Single_Family_Home', rooms=rooms, orphaned_shades=shades,
units='Meters', tolerance=0.01, angle_tolerance=1.0)
dest_file = os.path.join(directory, 'single_family_home.hbjson')
with open(dest_file, 'w') as fp:
json.dump(model.to_dict(), fp, indent=4)
def test_air_dict_methods():
"""Test the to/from dict methods."""
night_flush = ScheduleRuleset.from_daily_values(
'Night Flush', [1, 1, 1, 1, 1, 1, 1, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
0.5, 0.5, 0.5, 0.5, 0.5, 1, 1, 1])
night_flush_constr = AirBoundaryConstruction('Night Flush Boundary', 0.4, night_flush)
constr_dict = night_flush_constr.to_dict()
new_constr = AirBoundaryConstruction.from_dict(constr_dict)
assert night_flush_constr == new_constr
assert constr_dict == new_constr.to_dict()
def test_run_idf_window_shade():
"""Test the Model.to.idf and run_idf method with a model that has a window shade."""
# Get input Model
room = Room.from_box('TinyHouseZone', 5, 10, 3)
room.properties.energy.program_type = office_program
room.properties.energy.add_default_ideal_air()
double_clear = WindowConstruction('Double Pane Clear',
[clear_glass, air_gap, clear_glass])
shade_mat = EnergyWindowMaterialShade('Low-e Diffusing Shade', 0.005, 0.15,
0.5, 0.25, 0.5, 0, 0.4, 0.2, 0.1,
0.75, 0.25)
sched = ScheduleRuleset.from_daily_values('NighSched', [
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1
])
double_ec = WindowConstructionShade('Double Low-E Inside EC', double_clear,
shade_mat, 'Interior',
'OnIfHighSolarOnWindow', 200, sched)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].properties.energy.construction = double_ec
north_face = room[1]
north_face.apertures_by_ratio(0.4, 0.01)
model = Model('TinyHouse', [room])
# Get the input SimulationParameter
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
ddy_file = './tests/ddy/chicago.ddy'
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
sim_par.run_period.end_date = Date(1, 7)
# create the IDF string for simulation paramters and model
idf_str = '\n\n'.join((sim_par.to_idf(), model.to.idf(model)))
# write the final string into an IDF
idf = os.path.join(folders.default_simulation_folder, 'test_file_shd',
'in.idf')
write_to_file(idf, idf_str, True)
# prepare the IDF for simulation
epw_file = './tests/simulation/chicago.epw'
prepare_idf_for_simulation(idf, epw_file)
# run the IDF through EnergyPlus
sql, zsz, rdd, html, err = run_idf(idf, epw_file)
assert os.path.isfile(sql)
assert os.path.isfile(err)
err_obj = Err(err)
assert 'EnergyPlus Completed Successfully' in err_obj.file_contents
def test_air_construction_init():
"""Test the initialization of AirBoundaryConstruction objects and basic properties."""
default_constr = AirBoundaryConstruction('Default Air Construction')
night_flush = ScheduleRuleset.from_daily_values(
'Night Flush', [1, 1, 1, 1, 1, 1, 1, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
0.5, 0.5, 0.5, 0.5, 0.5, 1, 1, 1])
night_flush_constr = AirBoundaryConstruction('Night Flush Boundary', 0.4, night_flush)
str(night_flush_constr) # test the string representation of the construction
constr_dup = night_flush_constr.duplicate()
assert night_flush_constr.identifier == constr_dup.identifier == 'Night Flush Boundary'
assert night_flush_constr.air_mixing_per_area == constr_dup.air_mixing_per_area == 0.4
assert night_flush_constr.air_mixing_schedule == constr_dup.air_mixing_schedule
def test_air_equivalency():
"""Test the equality of a AirBoundaryConstruction to another."""
default_constr = AirBoundaryConstruction('Default Air Construction')
night_flush = ScheduleRuleset.from_daily_values(
'Night Flush', [1, 1, 1, 1, 1, 1, 1, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
0.5, 0.5, 0.5, 0.5, 0.5, 1, 1, 1])
night_flush_constr = AirBoundaryConstruction(
'Night Flush Boundary', 0.4, night_flush)
night_flush_constr_dup = night_flush_constr.duplicate()
assert night_flush_constr is night_flush_constr
assert night_flush_constr is not night_flush_constr_dup
assert night_flush_constr == night_flush_constr_dup
assert default_constr != night_flush_constr
assert hash(night_flush_constr) == hash(night_flush_constr_dup)
assert hash(default_constr) != hash(night_flush_constr)
collection = [default_constr, night_flush_constr, night_flush_constr_dup]
assert len(set(collection)) == 2
def test_schedule_ruleset_from_daily_values():
"""Test the initialization of ScheduleRuleset from_daily_values."""
test_vals = [
0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 1, 1, 1, 1, 1, 1, 0.5, 0.5, 0.5, 0.5, 1,
1, 1, 1, 0.5, 0.5, 0.5, 0.5
]
sched = ScheduleRuleset.from_daily_values('Simple Repeating', test_vals)
day_sched = ScheduleDay(
'Simple Repeating_Day Schedule', [0.5, 1, 0.5, 1, 0.5],
[Time(0, 0),
Time(6, 0),
Time(12, 0),
Time(16, 0),
Time(20, 0)])
sched_alt = ScheduleRuleset('Simple Repeating', day_sched)
assert sched.identifier == 'Simple Repeating'
assert len(sched.schedule_rules) == 0
assert sched.summer_designday_schedule is None
assert sched.winter_designday_schedule is None
assert sched == sched_alt
def test_window_shade_dict_methods():
"""Test the to/from dict methods."""
clear_glass = EnergyWindowMaterialGlazing(
'Clear Glass', 0.005715, 0.770675, 0.07, 0.8836, 0.0804,
0, 0.84, 0.84, 1.0)
gap = EnergyWindowMaterialGas('air gap', thickness=0.0127)
double_clear = WindowConstruction(
'Double Clear Window', [clear_glass, gap, clear_glass])
shade_mat = EnergyWindowMaterialShade(
'Low-e Diffusing Shade', 0.005, 0.15, 0.5, 0.25, 0.5, 0, 0.4,
0.2, 0.1, 0.75, 0.25)
sched = ScheduleRuleset.from_daily_values(
'NighSched', [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1])
double_low_e_ec = WindowConstructionShade(
'Double Low-E Inside EC', double_clear, shade_mat, 'Exterior',
'OnIfHighSolarOnWindow', 200, sched)
constr_dict = double_low_e_ec.to_dict()
new_constr = WindowConstructionShade.from_dict(constr_dict)
assert double_low_e_ec == new_constr
assert constr_dict == new_constr.to_dict()
def test_window_construction_blind_init():
"""Test the initialization of WindowConstructionShade objects with blinds."""
lowe_glass = EnergyWindowMaterialGlazing(
'Low-e Glass', 0.00318, 0.4517, 0.359, 0.714, 0.207,
0, 0.84, 0.046578, 1.0)
clear_glass = EnergyWindowMaterialGlazing(
'Clear Glass', 0.005715, 0.770675, 0.07, 0.8836, 0.0804,
0, 0.84, 0.84, 1.0)
gap = EnergyWindowMaterialGas('air gap', thickness=0.03)
shade_mat = EnergyWindowMaterialBlind(
'Plastic Blind', 'Vertical', 0.025, 0.01875, 0.003, 90, 0.2, 0.05, 0.4,
0.05, 0.45, 0, 0.95, 0.1, 1)
window_constr = WindowConstruction('Double Low-E', [lowe_glass, gap, clear_glass])
window_clear = WindowConstruction('Double Low-E', [clear_glass, gap, clear_glass])
sched = ScheduleRuleset.from_daily_values(
'NighSched', [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1])
double_low_e_shade = WindowConstructionShade(
'Double Low-E with Blind', window_constr, shade_mat, 'Exterior',
'OnIfHighSolarOnWindow', 200, sched)
double_low_e_between_shade = WindowConstructionShade(
'Double Low-E Between Blind', window_clear, shade_mat, 'Between')
double_low_e_ext_shade = WindowConstructionShade(
'Double Low-E Outside Blind', window_constr, shade_mat, 'Interior')
double_low_e_shade_dup = double_low_e_shade.duplicate()
assert double_low_e_shade.identifier == 'Double Low-E with Blind'
assert double_low_e_shade.window_construction == \
double_low_e_shade_dup.window_construction
assert double_low_e_shade.shade_material == double_low_e_shade_dup.shade_material
assert double_low_e_shade.shade_location == \
double_low_e_shade_dup.shade_location == 'Exterior'
assert double_low_e_shade.control_type == \
double_low_e_shade_dup.control_type == 'OnIfHighSolarOnWindow'
assert double_low_e_shade.setpoint == double_low_e_shade_dup.setpoint == 200
assert double_low_e_shade.schedule == double_low_e_shade_dup.schedule == sched
assert len(double_low_e_shade.materials) == 4
assert len(double_low_e_shade.layers) == 4
assert len(double_low_e_shade.unique_materials) == 4
assert not double_low_e_shade.is_symmetric
assert not double_low_e_shade.is_switchable_glazing
assert double_low_e_shade.has_shade
assert double_low_e_shade.inside_emissivity == \
double_low_e_shade.inside_emissivity == 0.84
assert double_low_e_shade.outside_emissivity == \
double_low_e_shade.outside_emissivity == 0.95
assert double_low_e_shade.thickness == \
double_low_e_shade.window_construction.thickness
assert double_low_e_shade.glazing_count == 2
assert double_low_e_shade.gap_count == 1
assert double_low_e_between_shade.identifier == 'Double Low-E Between Blind'
assert double_low_e_between_shade.shade_location == 'Between'
assert double_low_e_between_shade.control_type == 'AlwaysOn'
assert double_low_e_between_shade.setpoint is None
assert double_low_e_between_shade.schedule is None
assert len(double_low_e_between_shade.materials) == 5
assert len(double_low_e_between_shade.unique_materials) == 3
assert double_low_e_between_shade.is_symmetric
assert double_low_e_between_shade.gap_count == 2
assert double_low_e_ext_shade.identifier == 'Double Low-E Outside Blind'
assert len(double_low_e_ext_shade.materials) == 4
def test_window_construction_shade_init():
"""Test the initialization of WindowConstructionShade objects with shades."""
lowe_glass = EnergyWindowMaterialGlazing(
'Low-e Glass', 0.00318, 0.4517, 0.359, 0.714, 0.207,
0, 0.84, 0.046578, 1.0)
clear_glass = EnergyWindowMaterialGlazing(
'Clear Glass', 0.005715, 0.770675, 0.07, 0.8836, 0.0804,
0, 0.84, 0.84, 1.0)
gap = EnergyWindowMaterialGas('air gap', thickness=0.0127)
shade_mat = EnergyWindowMaterialShade(
'Low-e Diffusing Shade', 0.005, 0.15, 0.5, 0.25, 0.5, 0, 0.4,
0.2, 0.1, 0.75, 0.25)
shade_thick = EnergyWindowMaterialShade(
'Low-e Diffusing Shade', 0.025, 0.15, 0.5, 0.25, 0.5, 0, 0.4,
0.2, 0.1, 0.75, 0.25)
window_constr = WindowConstruction('Double Low-E', [lowe_glass, gap, clear_glass])
window_clear = WindowConstruction('Double Low-E', [clear_glass, gap, clear_glass])
sched = ScheduleRuleset.from_daily_values(
'NighSched', [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1])
with pytest.raises(AssertionError):
double_low_e_between_shade = WindowConstructionShade(
'Double Low-E Between Shade', window_constr, shade_thick, 'Between')
double_low_e_shade = WindowConstructionShade(
'Double Low-E with Shade', window_constr, shade_mat, 'Exterior',
'OnIfHighSolarOnWindow', 200, sched)
double_low_e_between_shade = WindowConstructionShade(
'Double Low-E Between Shade', window_clear, shade_mat, 'Between')
double_ext_shade = WindowConstructionShade(
'Double Outside Shade', window_clear, shade_mat, 'Interior')
double_low_e_shade_dup = double_low_e_shade.duplicate()
assert double_low_e_shade.identifier == 'Double Low-E with Shade'
assert double_low_e_shade.window_construction == \
double_low_e_shade_dup.window_construction
assert double_low_e_shade.shade_material == double_low_e_shade_dup.shade_material
assert double_low_e_shade.shade_location == \
double_low_e_shade_dup.shade_location == 'Exterior'
assert double_low_e_shade.control_type == \
double_low_e_shade_dup.control_type == 'OnIfHighSolarOnWindow'
assert double_low_e_shade.setpoint == double_low_e_shade_dup.setpoint == 200
assert double_low_e_shade.schedule == double_low_e_shade_dup.schedule == sched
assert len(double_low_e_shade.materials) == 4
assert len(double_low_e_shade.layers) == 4
assert len(double_low_e_shade.unique_materials) == 4
assert double_low_e_shade.r_value == double_low_e_shade.r_value == \
pytest.approx(0.41984, rel=1e-2)
assert double_low_e_shade.u_value == double_low_e_shade.u_value == \
pytest.approx(2.3818, rel=1e-2)
assert double_low_e_shade.u_factor == double_low_e_shade.u_factor == \
pytest.approx(1.69802, rel=1e-2)
assert double_low_e_shade.r_factor == double_low_e_shade.r_factor == \
pytest.approx(0.588919, rel=1e-2)
assert not double_low_e_shade.is_symmetric
assert not double_low_e_shade.is_switchable_glazing
assert double_low_e_shade.has_shade
assert double_low_e_shade.inside_emissivity == \
double_low_e_shade.inside_emissivity == 0.84
assert double_low_e_shade.outside_emissivity == \
double_low_e_shade.outside_emissivity == 0.4
assert double_low_e_shade.thickness == \
double_low_e_shade.window_construction.thickness
assert double_low_e_shade.glazing_count == 2
assert double_low_e_shade.gap_count == 1
assert double_low_e_between_shade.identifier == 'Double Low-E Between Shade'
assert double_low_e_between_shade.shade_location == 'Between'
assert double_low_e_between_shade.control_type == 'AlwaysOn'
assert double_low_e_between_shade.setpoint is None
assert double_low_e_between_shade.schedule is None
assert len(double_low_e_between_shade.materials) == 5
assert len(double_low_e_between_shade.unique_materials) == 3
assert double_low_e_between_shade.is_symmetric
assert double_low_e_between_shade.gap_count == 2
assert double_ext_shade.identifier == 'Double Outside Shade'
assert len(double_ext_shade.materials) == 4
assert len(double_ext_shade.unique_materials) == 3
try: # import ladybug_rhino dependencies
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# get the ScheduleTypeLimit object
if _type_limit_ is None:
_type_limit_ = schedule_type_limit_by_identifier('Fractional')
elif isinstance(_type_limit_, str):
_type_limit_ = schedule_type_limit_by_identifier(_type_limit_)
# create the schedule object
name = clean_and_id_ep_string('ConstantSchedule') if _name_ is None else \
clean_ep_string(_name_)
if len(_values) == 1:
schedule = ScheduleRuleset.from_constant_value(name, _values[0],
_type_limit_)
idf_text, constant_none = schedule.to_idf()
else:
schedule = ScheduleRuleset.from_daily_values(
name, _values, timestep=1, schedule_type_limit=_type_limit_)
idf_year, idf_week = schedule.to_idf()
idf_days = [
day_sch.to_idf(_type_limit_) for day_sch in schedule.day_schedules
]
idf_text = [idf_year] + idf_week + idf_days if idf_week is not None \
else idf_year
if _name_ is not None:
schedule.display_name = _name_
from honeybee_energy.lib.scheduletypelimits import schedule_type_limit_by_identifier
except ImportError as e:
raise ImportError('\nFailed to import honeybee_energy:\n\t{}'.format(e))
try: # import ladybug_rhino dependencies
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# get the ScheduleTypeLimit object
if _type_limit_ is None:
_type_limit_ = schedule_type_limit_by_identifier('Fractional')
elif isinstance(_type_limit_, str):
_type_limit_ = schedule_type_limit_by_identifier(_type_limit_)
# create the schedule object
if len(_values) == 1:
schedule = ScheduleRuleset.from_constant_value(
clean_and_id_ep_string(_name), _values[0], _type_limit_)
idf_text, constant_none = schedule.to_idf()
else:
schedule = ScheduleRuleset.from_daily_values(
clean_and_id_ep_string(_name), _values, timestep=1,
schedule_type_limit=_type_limit_)
idf_year, idf_week = schedule.to_idf()
idf_days = [day_sch.to_idf(_type_limit_) for day_sch in schedule.day_schedules]
idf_text = [idf_year] + idf_week + idf_days
schedule.display_name = _name
