def test_move():
"""Test the Model move method."""
room = Room.from_box('TinyHouseZone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].overhang(0.5, indoor=False)
south_face.apertures[0].overhang(0.5, indoor=True)
south_face.apertures[0].move_shades(Vector3D(0, 0, -0.5))
north_face = room[1]
door_verts = [
Point3D(2, 10, 0.1),
Point3D(1, 10, 0.1),
Point3D(1, 10, 2.5),
Point3D(2, 10, 2.5)
]
aperture_verts = [
Point3D(4.5, 10, 1),
Point3D(2.5, 10, 1),
Point3D(2.5, 10, 2.5),
Point3D(4.5, 10, 2.5)
]
door = Door('FrontDoor', Face3D(door_verts))
north_face.add_door(door)
aperture = Aperture('FrontAperture', Face3D(aperture_verts))
north_face.add_aperture(aperture)
new_room = room.duplicate()
model = Model('TinyHouse', [new_room])
vec_1 = Vector3D(2, 2, 0)
model.move(vec_1)
assert room.center == \
model.rooms[0].center.move(Vector3D(-2, -2, 0))
assert south_face.apertures[0].indoor_shades[0].center == \
model.rooms[0][3].apertures[0].indoor_shades[0].center.move(Vector3D(-2, -2, 0))
assert south_face.apertures[0].outdoor_shades[0].center == \
model.rooms[0][3].apertures[0].outdoor_shades[0].center.move(Vector3D(-2, -2, 0))
assert room[3].apertures[0].center == \
model.rooms[0][3].apertures[0].center.move(Vector3D(-2, -2, 0))
assert room[1].doors[0].center == \
model.rooms[0][1].doors[0].center.move(Vector3D(-2, -2, 0))
assert room.floor_area == model.rooms[0].floor_area
assert room.volume == model.rooms[0].volume
assert south_face.apertures[0].indoor_shades[0].area == \
model.rooms[0][3].apertures[0].indoor_shades[0].area
assert south_face.apertures[0].outdoor_shades[0].area == \
model.rooms[0][3].apertures[0].outdoor_shades[0].area
assert room[3].apertures[0].area == model.rooms[0][3].apertures[0].area
assert room[1].doors[0].area == model.rooms[0][1].doors[0].area
def test_check_non_zero():
"""Test the check_non_zero method."""
pts_1 = [
Point3D(0, 0, 0),
Point3D(0, 10, 0),
Point3D(10, 10, 0),
Point3D(10, 0, 0)
]
pts_2 = [
Point3D(0, 0, 0),
Point3D(0, 0, 3),
Point3D(0, 10, 3),
Point3D(0, 10, 0)
]
pts_3 = [
Point3D(0, 0, 0),
Point3D(10, 0, 0),
Point3D(10, 0, 3),
Point3D(0, 0, 3)
]
pts_4 = [
Point3D(10, 10, 0),
Point3D(0, 10, 0),
Point3D(0, 10, 3),
Point3D(10, 10, 3)
]
pts_5 = [
Point3D(10, 10, 0),
Point3D(10, 0, 0),
Point3D(10, 0, 3),
Point3D(10, 10, 3)
]
pts_6 = [
Point3D(10, 0, 3),
Point3D(10, 10, 3),
Point3D(0, 10, 3),
Point3D(0, 0, 3)
]
pts_7 = [
Point3D(10, 0, 3),
Point3D(10, 0.0001, 3),
Point3D(0, 0.0001, 3),
Point3D(0, 0, 3)
]
face_1 = Face('Face 1', Face3D(pts_1))
face_2 = Face('Face 2', Face3D(pts_2))
face_3 = Face('Face 3', Face3D(pts_3))
face_4 = Face('Face 4', Face3D(pts_4))
face_5 = Face('Face 5', Face3D(pts_5))
face_6 = Face('Face 6', Face3D(pts_6))
face_7 = Face('Face 7', Face3D(pts_7))
room_1 = Room('Zone: SHOE_BOX [920980]',
[face_1, face_2, face_3, face_4, face_5, face_6], 0.01, 1)
room_2 = Room('Zone: SHOE_BOX [920980]',
[face_1, face_2, face_3, face_4, face_5, face_6, face_7])
assert room_1.check_non_zero(0.01, False)
assert not room_2.check_non_zero(0.01, False)
def model_5vertex_sub_faces_interior(directory):
room1 = Room.from_box('TinyHouseZone1', 5, 10, 3)
north_face = room1[1]
aperture_verts = [
Point3D(4.5, 10, 1),
Point3D(2.5, 10, 1),
Point3D(2.5, 10, 2.5),
Point3D(3.5, 10, 2.9),
Point3D(4.5, 10, 2.5)
]
aperture = Aperture('FrontAperture', Face3D(aperture_verts))
north_face.add_aperture(aperture)
door_verts = [
Point3D(2, 10, 0.1),
Point3D(1, 10, 0.1),
Point3D(1, 10, 2.5),
Point3D(1.5, 10, 2.8),
Point3D(2, 10, 2.5)
]
door = Door('FrontDoor', Face3D(door_verts))
north_face.add_door(door)
room2 = Room.from_box('TinyHouseZone2', 5, 10, 3, origin=Point3D(0, 10, 0))
south_face = room2[3]
s_aperture = Aperture('BackAperture', Face3D(aperture_verts))
south_face.add_aperture(s_aperture)
s_door = Door('BackDoor', Face3D(door_verts))
south_face.add_door(s_door)
Room.solve_adjacency([room1, room2], 0.01)
model = Model('TinyHouse', [room1, room2])
model_dict = model.to_dict()
dest_file = os.path.join(directory,
'model_5vertex_sub_faces_interior.json')
with open(dest_file, 'w') as fp:
json.dump(model_dict, fp, indent=4)
def test_adjacent_zone_model():
"""Test the solve adjacency method with an interior aperture."""
room_south = Room.from_box('South Zone', 5, 5, 3, origin=Point3D(0, 0, 0))
room_north = Room.from_box('North Zone', 5, 5, 3, origin=Point3D(0, 5, 0))
room_south[1].apertures_by_ratio(0.4, 0.01)
room_north[3].apertures_by_ratio(0.4, 0.01)
room_south[3].apertures_by_ratio(0.4, 0.01)
room_south[3].apertures[0].overhang(0.5, indoor=False)
room_south[3].apertures[0].overhang(0.5, indoor=True)
room_south[3].apertures[0].move_shades(Vector3D(0, 0, -0.5))
door_verts = [Point3D(2, 10, 0.1), Point3D(1, 10, 0.1),
Point3D(1, 10, 2.5), Point3D(2, 10, 2.5)]
aperture_verts = [Point3D(4.5, 10, 1), Point3D(2.5, 10, 1),
Point3D(2.5, 10, 2.5), Point3D(4.5, 10, 2.5)]
door = Door('Front Door', Face3D(door_verts))
room_north[1].add_door(door)
aperture = Aperture('Front Aperture', Face3D(aperture_verts))
room_north[1].add_aperture(aperture)
Room.solve_adjcency([room_south, room_north], 0.01)
model = Model('Two Room House', [room_south, room_north])
assert len(model.rooms) == 2
assert len(model.faces) == 12
assert len(model.shades) == 2
assert len(model.apertures) == 4
assert len(model.doors) == 1
model_dict = model.to_dict()
new_model = Model.from_dict(model_dict)
assert isinstance(new_model.rooms[0][1].apertures[0].boundary_condition, Surface)
assert isinstance(new_model.rooms[1][3].apertures[0].boundary_condition, Surface)
assert new_model.rooms[0][1].apertures[0].boundary_condition.boundary_condition_object == \
new_model.rooms[1][3].apertures[0].name
assert new_model.rooms[1][3].apertures[0].boundary_condition.boundary_condition_object == \
new_model.rooms[0][1].apertures[0].name
def test_convert_to_units():
"""Test the Model convert_to_units method."""
room = Room.from_box('TinyHouseZone', 120, 240, 96)
inches_conversion = Model.conversion_factor_to_meters('Inches')
model = Model('TinyHouse', [room], units='Inches')
model.convert_to_units('Meters')
assert room.floor_area == pytest.approx(120 * 240 * (inches_conversion**2),
rel=1e-3)
assert room.volume == pytest.approx(120 * 240 * 96 *
(inches_conversion**3),
rel=1e-3)
assert model.units == 'Meters'
def test_make_plenum():
"""Test the make_plenum method."""
room = Room.from_box('ShoeBox', 5, 10, 3)
room.properties.energy.program_type = office_program
room.properties.energy.add_default_ideal_air()
assert room.properties.energy.people is not None
assert room.properties.energy.infiltration is not None
assert room.properties.energy.is_conditioned
room.properties.energy.make_plenum()
assert room.properties.energy.people is None
assert room.properties.energy.infiltration is not None
assert not room.properties.energy.is_conditioned
def test_model_init():
"""Test the initialization of the Model and basic properties."""
room = Room.from_box('TinyHouseZone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].overhang(0.5, indoor=False)
south_face.apertures[0].overhang(0.5, indoor=True)
south_face.apertures[0].move_shades(Vector3D(0, 0, -0.5))
north_face = room[1]
door_verts = [
Point3D(2, 10, 0.1),
Point3D(1, 10, 0.1),
Point3D(1, 10, 2.5),
Point3D(2, 10, 2.5)
]
aperture_verts = [
Point3D(4.5, 10, 1),
Point3D(2.5, 10, 1),
Point3D(2.5, 10, 2.5),
Point3D(4.5, 10, 2.5)
]
door = Door('FrontDoor', Face3D(door_verts))
north_face.add_door(door)
aperture = Aperture('FrontAperture', Face3D(aperture_verts))
north_face.add_aperture(aperture)
model = Model('TinyHouse', [room])
str(model) # test the string representation of the object
assert model.identifier == 'TinyHouse'
assert model.display_name == 'TinyHouse'
assert model.units == 'Meters'
assert model.tolerance == 0
assert model.angle_tolerance == 0
assert len(model.rooms) == 1
assert isinstance(model.rooms[0], Room)
assert len(model.faces) == 6
assert isinstance(model.faces[0], Face)
assert len(model.apertures) == 2
assert isinstance(model.apertures[0], Aperture)
assert len(model.doors) == 1
assert isinstance(model.doors[0], Door)
assert len(model.indoor_shades) == 1
assert isinstance(model.indoor_shades[0], Shade)
assert len(model.outdoor_shades) == 1
assert isinstance(model.outdoor_shades[0], Shade)
assert len(model.orphaned_faces) == 0
assert len(model.orphaned_shades) == 0
assert len(model.orphaned_apertures) == 0
assert len(model.orphaned_doors) == 0
def test_to_dict():
"""Test the Room to_dict method."""
room = Room.from_box('Shoe Box Zone', 5, 10, 3)
rd = room.to_dict()
assert rd['type'] == 'Room'
assert rd['name'] == 'ShoeBoxZone'
assert rd['display_name'] == 'Shoe Box Zone'
assert 'faces' in rd
assert len(rd['faces']) == 6
assert 'indoor_shades' not in rd
assert 'outdoor_shades' not in rd
assert 'properties' in rd
assert rd['properties']['type'] == 'RoomProperties'
def test_get_shades_by_name():
"""Test the get_shades_by_name method."""
room = Room.from_box('Tiny House Zone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].overhang(0.5, indoor=False)
south_face.apertures[0].move_shades(Vector3D(0, 0, -0.5))
model = Model('Tiny House', [room])
assert len(
model.get_shades_by_name(['TinyHouseZone_Back_Glz0_OutOverhang0'
])) == 1
with pytest.raises(ValueError):
model.get_shades_by_name(['NotAShade'])
def test_init_open():
"""Test the initialization of a room with open geometry."""
pts_1 = [Point3D(0, 0, 0), Point3D(0, 10, 0), Point3D(10, 10, 0), Point3D(10, 0, 0)]
pts_2 = [Point3D(0, 0, 0), Point3D(0, 0, 3), Point3D(0, 10, 3), Point3D(0, 10, 0)]
pts_3 = [Point3D(0, 0, 0), Point3D(10, 0, 0), Point3D(10, 0, 3), Point3D(0, 0, 3)]
pts_4 = [Point3D(10, 10, 0), Point3D(0, 10, 0), Point3D(0, 10, 3), Point3D(10, 10, 3)]
pts_5 = [Point3D(10, 10, 0), Point3D(10, 0, 0), Point3D(10, 0, 3), Point3D(10, 10, 3)]
pts_6 = [Point3D(10, 0, 3), Point3D(10, 2.5, 3), Point3D(0, 2.5, 3), Point3D(0, 0, 3)]
pts_7 = [Point3D(10, 2.5, 3), Point3D(10, 5, 3), Point3D(0, 5, 3), Point3D(0, 2.5, 3)]
face_1 = Face('Face 1', Face3D(pts_1))
face_2 = Face('Face 2', Face3D(pts_2))
face_3 = Face('Face 3', Face3D(pts_3))
face_4 = Face('Face 4', Face3D(pts_4))
face_5 = Face('Face 5', Face3D(pts_5))
face_6 = Face('Face 6', Face3D(pts_6))
face_7 = Face('Face 7', Face3D(pts_7))
room = Room('Zone: SHOE_BOX [920980]',
[face_1, face_2, face_3, face_4, face_5, face_6, face_7],
0.01, 1)
assert not room.check_solid(0.01, 1, False)
with pytest.raises(ValueError):
room.check_solid(0.01, 1, True)
def test_move():
"""Test the Room move method."""
room = Room.from_box('ShoeBoxZone', 2, 2, 2)
vec_1 = Vector3D(2, 2, 2)
new_room = room.duplicate()
new_room.move(vec_1)
assert new_room.geometry.vertices[0] == Point3D(2, 2, 2)
assert new_room.geometry.vertices[1] == Point3D(2, 4, 2)
assert new_room.geometry.vertices[2] == Point3D(4, 4, 2)
assert new_room.geometry.vertices[3] == Point3D(4, 2, 2)
assert room.floor_area == new_room.floor_area
assert room.volume == new_room.volume
def test_solve_adjacency_aperture():
"""Test the solve adjacency method with an interior aperture."""
room_south = Room.from_box('South Zone', 5, 5, 3, origin=Point3D(0, 0, 0))
room_north = Room.from_box('North Zone', 5, 5, 3, origin=Point3D(0, 5, 0))
room_south[1].apertures_by_ratio(0.4, 0.01)
room_north[3].apertures_by_ratio(0.4, 0.01)
assert room_south[1].apertures[
0].boundary_condition == boundary_conditions.outdoors
assert room_north[3].apertures[
0].boundary_condition == boundary_conditions.outdoors
adj_info = Room.solve_adjacency([room_south, room_north], 0.01)
assert isinstance(room_south[1].apertures[0].boundary_condition, Surface)
assert isinstance(room_north[3].apertures[0].boundary_condition, Surface)
assert room_south[1].apertures[0].boundary_condition.boundary_condition_object == \
room_north[3].apertures[0].name
assert room_north[3].apertures[0].boundary_condition.boundary_condition_object == \
room_south[1].apertures[0].name
assert len(adj_info['adjacent_faces']) == 1
assert len(adj_info['adjacent_apertures']) == 1
assert len(adj_info['adjacent_doors']) == 0
def test_check_missing_adjacencies():
"""Test the check_missing_adjacencies method."""
room_south = Room.from_box('SouthZone', 5, 5, 3, origin=Point3D(0, 0, 0))
room_north = Room.from_box('NorthZone', 5, 5, 3, origin=Point3D(0, 5, 0))
room_south[1].apertures_by_ratio(0.4, 0.01)
room_south[3].apertures_by_ratio(0.4, 0.01)
room_north[3].apertures_by_ratio(0.4, 0.01)
Room.solve_adjacency([room_south, room_north], 0.01)
model_1 = Model('SouthHouse', [room_south])
model_2 = Model('NorthHouse', [room_north])
assert len(model_1.rooms) == 1
assert len(model_1.faces) == 6
assert len(model_1.apertures) == 2
with pytest.raises(ValueError):
model_1.check_missing_adjacencies()
model_1.add_model(model_2)
assert len(model_1.rooms) == 2
assert len(model_1.faces) == 12
assert len(model_1.apertures) == 3
assert model_1.check_missing_adjacencies() == ''
def test_apertures_by_identifier():
"""Test the apertures_by_identifier method."""
room = Room.from_box('TinyHouseZone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
model = Model('TinyHouse', [room])
assert len(model.apertures_by_identifier(['TinyHouseZone_Back_Glz0'])) == 1
with pytest.raises(ValueError):
model.apertures_by_identifier(['NotAnAperture'])
model.remove_assigned_apertures()
with pytest.raises(ValueError):
model.shades_by_identifier(['TinyHouseZone_Back_Glz0'])
def test_init_coplanar():
"""Test the initialization of a room with coplanar faces."""
pts_1 = [Point3D(0, 0, 0), Point3D(0, 10, 0), Point3D(10, 10, 0), Point3D(10, 0, 0)]
pts_2 = [Point3D(0, 0, 0), Point3D(0, 0, 3), Point3D(0, 10, 3), Point3D(0, 10, 0)]
pts_3 = [Point3D(0, 0, 0), Point3D(10, 0, 0), Point3D(10, 0, 3), Point3D(0, 0, 3)]
pts_4 = [Point3D(10, 10, 0), Point3D(0, 10, 0), Point3D(0, 10, 3), Point3D(10, 10, 3)]
pts_5 = [Point3D(10, 10, 0), Point3D(10, 0, 0), Point3D(10, 0, 3), Point3D(10, 10, 3)]
pts_6 = [Point3D(10, 0, 3), Point3D(10, 2.5, 3), Point3D(0, 2.5, 3), Point3D(0, 0, 3)]
pts_7 = [Point3D(10, 2.5, 3), Point3D(10, 5, 3), Point3D(0, 5, 3), Point3D(0, 2.5, 3)]
pts_8 = [Point3D(10, 5, 3), Point3D(10, 10, 3), Point3D(0, 10, 3), Point3D(0, 5, 3)]
face_1 = Face('Face 1', Face3D(pts_1))
face_2 = Face('Face 2', Face3D(pts_2))
face_3 = Face('Face 3', Face3D(pts_3))
face_4 = Face('Face 4', Face3D(pts_4))
face_5 = Face('Face 5', Face3D(pts_5))
face_6 = Face('Face 6', Face3D(pts_6))
face_7 = Face('Face 7', Face3D(pts_7))
face_8 = Face('Face 8', Face3D(pts_8))
room = Room('Zone: SHOE_BOX [920980]',
[face_1, face_2, face_3, face_4, face_5, face_6, face_7, face_8],
0.01, 1)
str(room) # test the string representation of the room
assert room.name == 'ZoneSHOE_BOX920980'
assert room.display_name == 'Zone: SHOE_BOX [920980]'
assert isinstance(room.geometry, Polyface3D)
assert len(room.geometry.vertices) == 12
assert len(room) == 8
assert room.center == Point3D(5, 5, 1.5)
assert room.volume == 300
assert room.floor_area == 100
assert room.exposed_area == 220
assert room.exterior_wall_area == 120
assert room.exterior_aperture_area == 0
assert room.average_floor_height == 0
assert not room.has_parent
assert room.check_solid(0.01, 1)
def test_colorfaces_init():
"""Test the initialization of ColorFace and basic properties."""
data = []
identifiers = ['Bottom', 'Front', 'Right', 'Back', 'Left', 'Top']
for identifier in identifiers:
metadata = {
'type': 'Surface Inside Face Temperature',
'Surface': 'RESIDENCE_{}'.format(identifier.upper())
}
head = Header(Temperature(), 'C', AnalysisPeriod(1, 1, 0, 1, 1, 23),
metadata)
data.append(HourlyContinuousCollection(head, [22] * 24))
room = Room.from_box('Residence', 3, 6, 3.2)
color_obj = ColorFace(data, room.faces)
str(color_obj)
assert len(color_obj.data_collections) == 6
for coll in color_obj.data_collections:
assert isinstance(coll, HourlyContinuousCollection)
assert coll.header.unit == 'C'
assert isinstance(color_obj.legend_parameters, LegendParameters)
assert color_obj.simulation_step is None
assert color_obj.normalize
assert color_obj.geo_unit == 'm'
assert len(color_obj.matched_flat_faces) == 6
assert len(color_obj.matched_values) == 6
for val in color_obj.matched_values:
assert isinstance(val, (float, int))
assert len(color_obj.matched_flat_geometry) == 6
for face3d in color_obj.matched_flat_geometry:
assert isinstance(face3d, Face3D)
assert len(color_obj.matched_flat_areas) == 6
for val in color_obj.matched_flat_areas:
assert isinstance(val, (float, int))
assert isinstance(color_obj.graphic_container, GraphicContainer)
assert len(color_obj.graphic_container.value_colors) == 6
assert color_obj.unit == 'C'
assert isinstance(color_obj.data_type, Temperature)
assert color_obj.data_type_text == 'Surface Inside Face Temperature'
assert color_obj.title_text == 'Average Surface Inside Face Temperature ' \
'(C)\n1/1 to 1/1 between 0 and 23 '
color_obj.simulation_step = 0
assert color_obj.title_text == 'Surface Inside Face Temperature ' \
'(C)\n01 Jan 00:00'
with pytest.raises(AssertionError):
color_obj.simulation_step = 8760
def test_to_from_dict_methods():
"""Test the to/from dict methods."""
room = Room.from_box('Tiny House Zone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].overhang(0.5, indoor=False)
south_face.apertures[0].overhang(0.5, indoor=True)
south_face.apertures[0].move_shades(Vector3D(0, 0, -0.5))
north_face = room[1]
door_verts = [
Point3D(2, 10, 0.1),
Point3D(1, 10, 0.1),
Point3D(1, 10, 2.5),
Point3D(2, 10, 2.5)
]
aperture_verts = [
Point3D(4.5, 10, 1),
Point3D(2.5, 10, 1),
Point3D(2.5, 10, 2.5),
Point3D(4.5, 10, 2.5)
]
door = Door('Front Door', Face3D(door_verts))
north_face.add_door(door)
aperture = Aperture('Front Aperture', Face3D(aperture_verts))
north_face.add_aperture(aperture)
model = Model('Tiny House', [room])
model.north_angle = 15
model_dict = model.to_dict()
new_model = Model.from_dict(model_dict)
assert model_dict == new_model.to_dict()
assert new_model.name == 'TinyHouse'
assert new_model.display_name == 'Tiny House'
assert new_model.north_angle == 15
assert len(new_model.rooms) == 1
assert isinstance(new_model.rooms[0], Room)
assert len(new_model.faces) == 6
assert isinstance(new_model.faces[0], Face)
assert len(new_model.shades) == 2
assert isinstance(new_model.shades[0], Shade)
assert len(new_model.apertures) == 2
assert isinstance(new_model.apertures[0], Aperture)
assert len(new_model.doors) == 1
assert isinstance(new_model.doors[0], Door)
assert len(new_model.orphaned_faces) == 0
assert len(new_model.orphaned_shades) == 0
assert len(new_model.orphaned_apertures) == 0
assert len(new_model.orphaned_doors) == 0
def test_check_duplicate_shade_names():
"""Test the check_duplicate_shade_names method."""
room = Room.from_box('Tiny House Zone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
table_geo = Face3D.from_rectangle(2, 2, Plane(o=Point3D(1.5, 4, 1)))
room.add_indoor_shade(Shade('Table', table_geo))
model = Model('Test House', [room])
assert model.check_duplicate_shade_names(False)
tree_canopy_geo = Face3D.from_regular_polygon(6, 2, Plane(o=Point3D(5, -3, 4)))
model.add_shade(Shade('Table', tree_canopy_geo))
assert not model.check_duplicate_shade_names(False)
with pytest.raises(ValueError):
model.check_duplicate_shade_names(True)
def test_ground_by_custom_surface():
"""Test the ground_by_custom_surface method."""
room = Room.from_box('ShoeBoxZone', 5, 10, 3, origin=Point3D(0, 0, 3))
grd_face1 = Face3D([Point3D(-10, -10, 3), Point3D(-10, 10, 3),
Point3D(10, 10, 3), Point3D(10, -10, 3)])
grd_face2 = Face3D([Point3D(-10, 10, 3), Point3D(10, 10, 3),
Point3D(10, 10, 6), Point3D(-10, 10, 6)])
assert isinstance(room[0].boundary_condition, Outdoors)
assert isinstance(room[1].boundary_condition, Outdoors)
room.ground_by_custom_surface([grd_face1, grd_face2])
assert isinstance(room[0].boundary_condition, Ground)
assert isinstance(room[1].boundary_condition, Ground)
for face in room[2:]:
assert isinstance(face.boundary_condition, Outdoors)
def test_recipe_run():
# create a model for simulation
room = Room.from_box('TinyHouseZone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
model = Model('TinyHouse', [room])
# pass the model to the recipe
recipe = Recipe('daylight_factor')
recipe.input_value_by_name('model', model)
recipe.input_value_by_name('sensor-count', 30)
recipe.input_value_by_name('radiance-parameters', None)
# run the recipe
recipe.run()
def test_make_ground():
"""Test the make_ground method."""
room = Room.from_box('ShoeBox', 5, 10, 3)
room.properties.energy.program_type = office_program
room.properties.energy.add_default_ideal_air()
assert room.properties.energy.people is not None
assert room.properties.energy.infiltration is not None
assert room.properties.energy.is_conditioned
soil_constr = OpaqueConstruction('Conc_Pavement', [concrete_hw])
room.properties.energy.make_ground(soil_constr)
assert room.properties.energy.people is None
assert room.properties.energy.infiltration is None
assert not room.properties.energy.is_conditioned
def test_to_dict():
"""Test the Model to_dict method."""
room = Room.from_box('Tiny House Zone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].overhang(0.5, indoor=False)
south_face.apertures[0].overhang(0.5, indoor=True)
south_face.apertures[0].move_shades(Vector3D(0, 0, -0.5))
north_face = room[1]
door_verts = [
Point3D(2, 10, 0.1),
Point3D(1, 10, 0.1),
Point3D(1, 10, 2.5),
Point3D(2, 10, 2.5)
]
aperture_verts = [
Point3D(4.5, 10, 1),
Point3D(2.5, 10, 1),
Point3D(2.5, 10, 2.5),
Point3D(4.5, 10, 2.5)
]
door = Door('Front Door', Face3D(door_verts))
north_face.add_door(door)
aperture = Aperture('Front Aperture', Face3D(aperture_verts))
north_face.add_aperture(aperture)
model = Model('Tiny House', [room])
model.north_angle = 15
model_dict = model.to_dict()
assert model_dict['type'] == 'Model'
assert model_dict['name'] == 'TinyHouse'
assert model_dict['display_name'] == 'Tiny House'
assert 'rooms' in model_dict
assert len(model_dict['rooms']) == 1
assert 'faces' in model_dict['rooms'][0]
assert len(model_dict['rooms'][0]['faces']) == 6
assert 'apertures' in model_dict['rooms'][0]['faces'][3]
assert len(model_dict['rooms'][0]['faces'][3]['apertures']) == 1
assert 'doors' in model_dict['rooms'][0]['faces'][1]
assert len(model_dict['rooms'][0]['faces'][1]['doors']) == 1
assert 'outdoor_shades' in model_dict['rooms'][0]['faces'][3]['apertures'][
0]
assert len(model_dict['rooms'][0]['faces'][3]['apertures'][0]
['outdoor_shades']) == 1
assert 'north_angle' in model_dict
assert model_dict['north_angle'] == 15
assert 'properties' in model_dict
assert model_dict['properties']['type'] == 'ModelProperties'
def test_writer_to_idf():
"""Test the Model to.idf method."""
room = Room.from_box('TinyHouseZone', 5, 10, 3)
room.properties.energy.program_type = office_program
room.properties.energy.add_default_ideal_air()
stone = EnergyMaterial('Thick Stone', 0.3, 2.31, 2322, 832, 'Rough',
0.95, 0.75, 0.8)
thermal_mass_constr = OpaqueConstruction('Thermal Mass Floor', [stone])
room[0].properties.energy.construction = thermal_mass_constr
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].overhang(0.5, indoor=False)
south_face.apertures[0].overhang(0.5, indoor=True)
south_face.move_shades(Vector3D(0, 0, -0.5))
light_shelf_out = ShadeConstruction('OutdoorLightShelf', 0.5, 0.5)
light_shelf_in = ShadeConstruction('IndoorLightShelf', 0.7, 0.7)
south_face.apertures[0].outdoor_shades[0].properties.energy.construction = light_shelf_out
south_face.apertures[0].indoor_shades[0].properties.energy.construction = light_shelf_in
north_face = room[1]
north_face.overhang(0.25, indoor=False)
door_verts = [Point3D(2, 10, 0.1), Point3D(1, 10, 0.1),
Point3D(1, 10, 2.5), Point3D(2, 10, 2.5)]
door = Door('FrontDoor', Face3D(door_verts))
north_face.add_door(door)
aperture_verts = [Point3D(4.5, 10, 1), Point3D(2.5, 10, 1),
Point3D(2.5, 10, 2.5), Point3D(4.5, 10, 2.5)]
aperture = Aperture('FrontAperture', Face3D(aperture_verts))
triple_pane = WindowConstruction(
'Triple Pane Window', [clear_glass, air_gap, clear_glass, air_gap, clear_glass])
aperture.properties.energy.construction = triple_pane
north_face.add_aperture(aperture)
tree_canopy_geo = Face3D.from_regular_polygon(
6, 2, Plane(Vector3D(0, 0, 1), Point3D(5, -3, 4)))
tree_canopy = Shade('TreeCanopy', tree_canopy_geo)
table_geo = Face3D.from_rectangle(2, 2, Plane(o=Point3D(1.5, 4, 1)))
table = Shade('Table', table_geo)
room.add_indoor_shade(table)
model = Model('TinyHouse', [room], orphaned_shades=[tree_canopy])
assert hasattr(model.to, 'idf')
idf_string = model.to.idf(model, schedule_directory='./tests/idf/')
def test_to_dict():
"""Test the Room to_dict method with radiance properties."""
custom_set = ModifierSet('Custom_Modifier_Set')
room = Room.from_box('Shoe_Box', 5, 10, 3)
rd = room.to_dict()
assert 'properties' in rd
assert rd['properties']['type'] == 'RoomProperties'
assert 'radiance' in rd['properties']
assert rd['properties']['radiance']['type'] == 'RoomRadianceProperties'
assert 'modifier_set' not in rd['properties']['radiance'] or \
rd['properties']['radiance']['modifier_set'] is None
room.properties.radiance.modifier_set = custom_set
rd = room.to_dict()
assert rd['properties']['radiance']['modifier_set'] is not None
def test_remove_colinear_vertices_envelope():
"""Test the remove_colinear_vertices_envelope method."""
pts_1 = (Point3D(0, 0), Point3D(1, 0), Point3D(2, 0), Point3D(2, 2),
Point3D(0, 2))
pf_1 = Polyface3D.from_offset_face(Face3D(pts_1), 3)
room_1 = Room.from_polyface3d('Zone1', pf_1)
pts_2 = (Point3D(0.5, 2, 0.5), Point3D(1, 2, 0.5), Point3D(1.5, 2, 0.5),
Point3D(1.5, 2, 2), Point3D(0.5, 2, 2))
ap_2 = Aperture('TestAperture1', Face3D(pts_2))
room_1[-3].add_aperture(ap_2)
assert len(room_1[0].geometry.vertices) == 5
assert len(ap_2.geometry.vertices) == 5
room_1.remove_colinear_vertices_envelope(0.0001)
assert len(room_1[0].geometry.vertices) == 4
assert len(ap_2.geometry.vertices) == 4
def test_model_properties_setability():
"""Test the setting of properties on the Model."""
room = Room.from_box('TinyHouseZone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
model = Model('TinyHouse', [room])
model.display_name = 'TestBox'
assert model.display_name == 'TestBox'
model.units = 'Feet'
assert model.units == 'Feet'
model.tolerance = 0.01
assert model.tolerance == 0.01
model.angle_tolerance = 0.01
assert model.angle_tolerance == 0.01
def test_recipe_run():
# create a model for simulation
room = Room.from_box('TinyHouseZone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
model = Model('TinyHouse', [room])
model.properties.radiance.sensor_grids = \
[room.properties.radiance.generate_sensor_grid(1, offset=0.8)]
# pass the model to the recipe
recipe = Recipe('daylight_factor')
recipe.input_value_by_name('model', model)
recipe.input_value_by_name('radiance-parameters', None)
# run the recipe
recipe.run()
def model_energy_no_program(directory):
room = Room.from_box('Abandoned_Tiny_House', 5, 10, 3)
stone = EnergyMaterial('Thick Stone', 0.3, 2.31, 2322, 832, 'Rough',
0.95, 0.75, 0.8)
thermal_mass_constr = OpaqueConstruction('Thermal Mass Floor', [stone])
room[0].properties.energy.construction = thermal_mass_constr
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].overhang(0.5, indoor=False)
south_face.apertures[0].overhang(0.5, indoor=True)
south_face.move_shades(Vector3D(0, 0, -0.5))
light_shelf_out = ShadeConstruction('Outdoor_Light_Shelf', 0.5, 0.5)
light_shelf_in = ShadeConstruction('Indoor_Light_Shelf', 0.7, 0.7)
south_face.apertures[0].outdoor_shades[0].properties.energy.construction = light_shelf_out
south_face.apertures[0].indoor_shades[0].properties.energy.construction = light_shelf_in
north_face = room[1]
north_face.overhang(0.25, indoor=False)
door_verts = [Point3D(2, 10, 0.1), Point3D(1, 10, 0.1),
Point3D(1, 10, 2.5), Point3D(2, 10, 2.5)]
door = Door('Front_Door', Face3D(door_verts))
north_face.add_door(door)
aperture_verts = [Point3D(4.5, 10, 1), Point3D(2.5, 10, 1),
Point3D(2.5, 10, 2.5), Point3D(4.5, 10, 2.5)]
aperture = Aperture('Front_Aperture', Face3D(aperture_verts))
triple_pane = WindowConstruction(
'Triple Pane Window', [clear_glass, air_gap, clear_glass, air_gap, clear_glass])
aperture.properties.energy.construction = triple_pane
north_face.add_aperture(aperture)
tree_canopy_geo = Face3D.from_regular_polygon(
6, 2, Plane(Vector3D(0, 0, 1), Point3D(5, -3, 4)))
tree_canopy = Shade('Tree_Canopy', tree_canopy_geo)
table_geo = Face3D.from_rectangle(2, 2, Plane(o=Point3D(1.5, 4, 1)))
table = Shade('Table', table_geo)
room.add_indoor_shade(table)
model = Model('Tiny_House', [room], orphaned_shades=[tree_canopy])
model.north_angle = 15
dest_file = os.path.join(directory, 'model_energy_no_program.json')
with open(dest_file, 'w') as fp:
json.dump(model.to_dict(included_prop=['energy']), fp, indent=4)
