def from_rooms_radial(model_file, grid_size, offset, include_mesh, keep_out,
wall_offset, dir_count, start_vector, mesh_radius, room,
write_json, folder, output_file):
"""Generate SensorGrids of radial directions around positions from room floors.
\b
Args:
model_file: Full path to a HBJSON or HBPkl Model file.
"""
try:
# re-serialize the Model and extract rooms and units
model = Model.from_file(model_file)
rooms = model.rooms if room is None or len(room) == 0 else \
[r for r in model.rooms if r.identifier in room]
grid_size = parse_distance_string(grid_size, model.units)
offset = parse_distance_string(offset, model.units)
wall_offset = parse_distance_string(wall_offset, model.units)
vec = [float(v) for v in start_vector.split()]
st_vec = Vector3D(*vec)
# loop through the rooms and generate sensor grids
sensor_grids = []
remove_out = not keep_out
for room in rooms:
sg = room.properties.radiance.generate_sensor_grid_radial(
grid_size,
offset=offset,
remove_out=remove_out,
wall_offset=wall_offset,
dir_count=dir_count,
start_vector=st_vec,
mesh_radius=mesh_radius)
if sg is not None:
sensor_grids.append(sg)
if not include_mesh:
for sg in sensor_grids:
sg.mesh = None
# write the sensor grids to the output file or folder
if folder is None:
if write_json:
output_file.write(
json.dumps([sg.to_dict() for sg in sensor_grids]))
else:
output_file.write('\n'.join(
[sg.to_radiance() for sg in sensor_grids]))
else:
if write_json:
for sg in sensor_grids:
sg.to_json(folder)
else:
for sg in sensor_grids:
sg.to_file(folder)
except Exception as e:
_logger.exception('Grid generation failed.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_check_duplicate_face_identifiers():
"""Test the check_duplicate_face_identifiers 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)
]
face_1 = Face('Face1', Face3D(pts_1))
face_2 = Face('Face2', Face3D(pts_2))
face_3 = Face('Face3', Face3D(pts_3))
face_4 = Face('Face4', Face3D(pts_4))
face_5 = Face('Face5', Face3D(pts_5))
face_6 = Face('Face6', Face3D(pts_6))
face_7 = Face('Face1', Face3D(pts_6))
room_1 = Room('TestRoom', [face_1, face_2, face_3, face_4, face_5, face_6])
room_2 = Room('TestRoom', [face_1, face_2, face_3, face_4, face_5, face_7])
model_1 = Model('TestHouse', [room_1])
model_2 = Model('TestHouse', [room_2])
assert model_1.check_duplicate_face_identifiers(False)
assert not model_2.check_duplicate_face_identifiers(False)
with pytest.raises(ValueError):
model_2.check_duplicate_face_identifiers(True)
def test_to_dict():
"""Test the Model to_dict 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)
model = Model('TinyHouse', [room])
model_dict = model.to_dict()
assert model_dict['type'] == 'Model'
assert model_dict['identifier'] == 'TinyHouse'
assert model_dict['display_name'] == 'TinyHouse'
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 'properties' in model_dict
assert model_dict['properties']['type'] == 'ModelProperties'
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_to_dict_multizone_house():
"""Test the Model to_dict method with a multi-zone house."""
first_floor = Room.from_box('First_Floor', 10, 10, 3, origin=Point3D(0, 0, 0))
second_floor = Room.from_box('Second_Floor', 10, 10, 3, origin=Point3D(0, 0, 3))
for face in first_floor[1:5]:
face.apertures_by_ratio(0.2, 0.01)
for face in second_floor[1:5]:
face.apertures_by_ratio(0.2, 0.01)
pts_1 = [Point3D(0, 0, 6), Point3D(0, 10, 6), Point3D(10, 10, 6), Point3D(10, 0, 6)]
pts_2 = [Point3D(0, 0, 6), Point3D(5, 0, 9), Point3D(5, 10, 9), Point3D(0, 10, 6)]
pts_3 = [Point3D(10, 0, 6), Point3D(10, 10, 6), Point3D(5, 10, 9), Point3D(5, 0, 9)]
pts_4 = [Point3D(0, 0, 6), Point3D(10, 0, 6), Point3D(5, 0, 9)]
pts_5 = [Point3D(10, 10, 6), Point3D(0, 10, 6), Point3D(5, 10, 9)]
face_1 = Face('AtticFace1', Face3D(pts_1))
face_2 = Face('AtticFace2', Face3D(pts_2))
face_3 = Face('AtticFace3', Face3D(pts_3))
face_4 = Face('AtticFace4', Face3D(pts_4))
face_5 = Face('AtticFace5', Face3D(pts_5))
attic = Room('Attic', [face_1, face_2, face_3, face_4, face_5], 0.01, 1)
mod_set = ModifierSet('Attic_Construction_Set')
mod_set.floor_set.interior_modifier = Plastic('AtticFloor', 0.4)
mod_set.roof_ceiling_set.exterior_modifier = Plastic('AtticRoof', 0.6)
attic.properties.radiance.modifier_set = mod_set
Room.solve_adjacency([first_floor, second_floor, attic], 0.01)
model = Model('Multi_Zone_Single_Family_House', [first_floor, second_floor, attic])
model_dict = model.to_dict()
assert 'radiance' in model_dict['properties']
assert 'modifiers' in model_dict['properties']['radiance']
assert 'modifier_sets' in model_dict['properties']['radiance']
assert len(model_dict['properties']['radiance']['modifiers']) == 2
assert len(model_dict['properties']['radiance']['modifier_sets']) == 1
assert model_dict['rooms'][0]['faces'][5]['boundary_condition']['type'] == 'Surface'
assert model_dict['rooms'][1]['faces'][0]['boundary_condition']['type'] == 'Surface'
assert model_dict['rooms'][1]['faces'][5]['boundary_condition']['type'] == 'Surface'
assert model_dict['rooms'][2]['faces'][0]['boundary_condition']['type'] == 'Surface'
assert model_dict['rooms'][2]['properties']['radiance']['modifier_set'] == \
mod_set.identifier
def test_afn_plenum_zone():
"""Test case where no infiltration load exists."""
zone_pts = Face3D(
[Point3D(0, 0),
Point3D(20, 0),
Point3D(20, 10),
Point3D(0, 10)])
room = Room.from_polyface3d('PlenumRoom',
Polyface3D.from_offset_face(zone_pts, 1))
room.properties.energy.program_type = prog_type_lib.plenum_program
# Make model
model = Model('PlenumSimple', [room])
# generate afn, w/ average leakage
afn.generate(model.rooms,
leakage_type='Medium',
use_room_infiltration=True)
faces = model.faces
# check ext wall
crack = faces[1].properties.energy.vent_crack
chk_cof = CRACK_TEMPLATE_DATA['external_medium_cracks']['wall_flow_cof']
chk_exp = CRACK_TEMPLATE_DATA['external_medium_cracks']['wall_flow_exp']
assert crack.flow_coefficient == pytest.approx(chk_cof * faces[1].area,
abs=1e-10)
assert crack.flow_exponent == pytest.approx(chk_exp, abs=1e-10)
# check roof
crack = faces[5].properties.energy.vent_crack
chk_cof = CRACK_TEMPLATE_DATA['external_medium_cracks']['roof_flow_cof']
chk_exp = CRACK_TEMPLATE_DATA['external_medium_cracks']['roof_flow_exp']
assert crack.flow_coefficient == pytest.approx(chk_cof * faces[5].area,
abs=1e-10)
assert crack.flow_exponent == pytest.approx(chk_exp, abs=1e-10)
# generate afn, w/ tight leakage
afn.generate(model.rooms,
leakage_type='Excellent',
use_room_infiltration=False)
faces = model.faces
# check ext wall
crack = faces[1].properties.energy.vent_crack
chk_cof = CRACK_TEMPLATE_DATA['external_excellent_cracks']['wall_flow_cof']
chk_exp = CRACK_TEMPLATE_DATA['external_excellent_cracks']['wall_flow_exp']
assert crack.flow_coefficient == pytest.approx(chk_cof * faces[1].area,
abs=1e-10)
assert crack.flow_exponent == pytest.approx(chk_exp, abs=1e-10)
# check roof
crack = faces[5].properties.energy.vent_crack
chk_cof = CRACK_TEMPLATE_DATA['external_excellent_cracks']['roof_flow_cof']
chk_exp = CRACK_TEMPLATE_DATA['external_excellent_cracks']['roof_flow_exp']
assert crack.flow_coefficient == pytest.approx(chk_cof * faces[5].area,
abs=1e-10)
assert crack.flow_exponent == pytest.approx(chk_exp, abs=1e-10)
def test_add_room_sensors():
runner = CliRunner()
input_hb_model = './tests/assets/model/model_radiance_dynamic_states.hbjson'
result = runner.invoke(add_room_sensors, [input_hb_model])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert len(new_model.properties.radiance.sensor_grids) == 2
def test_model_add_prefix():
"""Test the model add_prefix method."""
room = Room.from_box('ShoeBoxZone', 5, 10, 3)
south_face = room[3]
south_face.apertures_by_ratio(0.5, 0.01)
table_geo = Face3D.from_rectangle(2, 2, Plane(o=Point3D(1.5, 4, 1)))
room.add_indoor_shade(Shade('Table', table_geo))
prefix = 'New'
model = Model('ShoeBox', [room])
model.add_prefix(prefix)
assert room.identifier.startswith(prefix)
for face in room.faces:
assert face.identifier.startswith(prefix)
for ap in face.apertures:
assert ap.identifier.startswith(prefix)
for shd in room.shades:
assert shd.identifier.startswith(prefix)
def test_shoe_box_simple():
runner = CliRunner()
result = runner.invoke(shoe_box, ['5', '10', '3.5'])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert len(new_model.rooms) == 1
assert len(new_model.apertures) == 0
def test_model_from_idf():
runner = CliRunner()
input_idf_model = os.path.abspath('./tests/idf/test_shoe_box.idf')
result = runner.invoke(model_from_idf, [input_idf_model])
assert result.exit_code == 0
result_dict = json.loads(result.output)
model = Model.from_dict(result_dict)
assert isinstance(model, Model)
def test_convert_units():
input_model = './tests/json/single_family_home.hbjson'
runner = CliRunner()
result = runner.invoke(convert_units, [input_model, 'Feet'])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert new_model.units == 'Feet'
def model_occ_schedules(model_json, threshold, period, output_file):
"""Translate a Model's occupancy schedules into a JSON of 0/1 values.
\b
Args:
model_json: Full path to a Model JSON file.
"""
try:
# re-serialize the Model
with open(model_json) as json_file:
data = json.load(json_file)
model = Model.from_dict(data)
# loop through the rooms and collect all unique occupancy schedules
scheds, room_occupancy = [], {}
for room in model.rooms:
people = room.properties.energy.people
if people is not None:
model.properties.energy._check_and_add_schedule(
people.occupancy_schedule, scheds)
room_occupancy[room.identifier] = people.occupancy_schedule.identifier
else:
room_occupancy[room.identifier] = None
# process the run period if it is supplied
if period is not None and period != '' and period != 'None':
a_per = AnalysisPeriod.from_string(period)
start = Date(a_per.st_month, a_per.st_day)
end = Date(a_per.end_month, a_per.end_day)
a_period = AnalysisPeriod(start.month, start.day, 0, end.month, end.day, 23)
timestep = a_per.timestep
else:
a_per = a_period = AnalysisPeriod()
start, end, timestep = Date(1, 1), Date(12, 31), 1
# convert occupancy schedules to lists of 0/1 values
schedules = {}
for sch in scheds:
values = []
for val in sch.values(timestep, start, end):
is_occ = 0 if val < threshold else 1
values.append(is_occ)
header = Header(Fraction(), 'fraction', a_period)
schedules[sch.identifier] = HourlyContinuousCollection(header, values)
if a_per.st_hour != 0 or a_per.end_hour != 23:
schedules = {key: data.filter_by_analysis_period(a_per)
for key, data in schedules.items()}
schedules = {key: data.values for key, data in schedules.items()}
# write out the JSON file
occ_dict = {'schedules': schedules, 'room_occupancy': room_occupancy}
output_file.write(json.dumps(occ_dict))
except Exception as e:
_logger.exception('Model translation failed.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_remove_ecms():
runner = CliRunner()
input_hb_model = './tests/json/ShoeBox.json'
result = runner.invoke(remove_ecms, [input_hb_model])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert new_model.rooms[0].properties.energy.window_vent_control is None
def test_model_to_dict_with_program_type():
"""Test Model.to_dict() with standards ProgramTypes."""
pat_room_program = prog_type_lib.program_type_by_identifier(
'2013::Hospital::ICU_PatRm')
room = Room.from_box('Hospital_Patient_Room', 5, 10, 3)
room.properties.energy.program_type = pat_room_program
room.properties.energy.add_default_ideal_air()
ideal_air = room.properties.energy.hvac.duplicate()
ideal_air.economizer_type = 'DifferentialEnthalpy'
ideal_air.sensible_heat_recovery = 0.81
ideal_air.latent_heat_recovery = 0.68
room.properties.energy.hvac = ideal_air
pat_rm_setpoint = room.properties.energy.setpoint.duplicate()
pat_rm_setpoint.identifier = 'Humidity Controlled PatRm Setpt'
pat_rm_setpoint.heating_setpoint = 21
pat_rm_setpoint.cooling_setpoint = 24
pat_rm_setpoint.humidifying_setpoint = 30
pat_rm_setpoint.dehumidifying_setpoint = 55
room.properties.energy.setpoint = pat_rm_setpoint
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].overhang(0.5, indoor=False)
south_face.move_shades(Vector3D(0, 0, -0.5))
room[0].boundary_condition = boundary_conditions.adiabatic
room[1].boundary_condition = boundary_conditions.adiabatic
room[2].boundary_condition = boundary_conditions.adiabatic
room[4].boundary_condition = boundary_conditions.adiabatic
room[5].boundary_condition = boundary_conditions.adiabatic
model = Model('Patient_Room_Test_Box', [room])
model_dict = model.to_dict()
assert model_dict['properties']['energy']['program_types'][0]['identifier'] == \
'2013::Hospital::ICU_PatRm'
assert model_dict['rooms'][0]['properties']['energy']['program_type'] == \
'2013::Hospital::ICU_PatRm'
assert 'setpoint' in model_dict['rooms'][0]['properties']['energy']
assert model_dict['rooms'][0]['properties']['energy']['setpoint']['identifier'] == \
'Humidity Controlled PatRm Setpt'
assert 'hvac' in model_dict['rooms'][0]['properties']['energy']
def test_check_duplicate_room_names():
"""Test the check_duplicate_room_names method."""
room_south = Room.from_box('Zone1', 5, 5, 3, origin=Point3D(0, 0, 0))
room_north = Room.from_box('Zone1', 5, 5, 3, origin=Point3D(0, 5, 0))
room_south[3].apertures_by_ratio(0.4, 0.01)
Room.solve_adjacency([room_south, room_north], 0.01)
model_1 = Model('South House', [room_south])
model_2 = Model('North House', [room_north])
assert model_1.check_duplicate_room_names(False)
model_1.add_model(model_2)
assert not model_1.check_duplicate_room_names(False)
with pytest.raises(ValueError):
model_1.check_duplicate_room_names(True)
def test_lighting_2004():
runner = CliRunner()
input_hb_model = './tests/json/ShoeBox.json'
result = runner.invoke(lighting_2004, [input_hb_model])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert new_model.rooms[0].properties.energy.lighting.watts_per_area == \
pytest.approx(11.84029, rel=1e-1)
def test_move():
"""Test the Model move 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)
new_room = room.duplicate()
model = Model('Tiny House', [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_extruded_border():
input_model = './tests/json/single_family_home.hbjson'
runner = CliRunner()
in_args = [input_model, '0.2', '-i']
result = runner.invoke(extruded_border, in_args)
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert all(len(ap.indoor_shades) > 1 for ap in new_model.apertures)
def test_windows_by_ratio():
input_model = './tests/json/single_family_home.hbjson'
runner = CliRunner()
result = runner.invoke(windows_by_ratio, [input_model, '0.6'])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert new_model.exterior_aperture_area / new_model.exterior_wall_area == \
pytest.approx(0.6, rel=1e-3)
def test_model_from_gbxml():
runner = CliRunner()
input_gbxml_model = os.path.abspath(
'./tests/gbxml/SampleGBXMLfromRevit.xml')
result = runner.invoke(model_from_gbxml, [input_gbxml_model])
assert result.exit_code == 0
result_dict = json.loads(result.output)
model = Model.from_dict(result_dict)
assert isinstance(model, Model)
def test_overhang():
input_model = './tests/json/single_family_home.hbjson'
runner = CliRunner()
in_args = [input_model, '0.4', '-a', '10', '-vo', '0.5', '-i']
result = runner.invoke(overhang, in_args)
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert all(len(ap.indoor_shades) == 1 for ap in new_model.apertures)
def test_rectangle_plan_custom():
runner = CliRunner()
in_arg = ['30', '20', '3.5', '-p', '5', '-a', '135', '-ar', '-af']
result = runner.invoke(rectangle_plan, in_arg)
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert new_model.units == 'Meters'
assert len(new_model.rooms) == 5
assert len(new_model.apertures) == 0
def test_l_shaped_plan_detailed():
runner = CliRunner()
in_arg = ['20', '40', '15', '30', '3.5', '-p', '5', '-s', '3', '-a', '45']
result = runner.invoke(l_shaped_plan, in_arg)
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert new_model.units == 'Meters'
assert len(new_model.rooms) == 21
assert len(new_model.apertures) == 0
def test_louvers_by_count():
input_model = './tests/json/single_family_home.hbjson'
runner = CliRunner()
in_args = [input_model, '2', '0.2', '-a', '-10', '-o', '0.05', '-i']
result = runner.invoke(louvers_by_count, in_args)
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert all(len(ap.indoor_shades) == 2 for ap in new_model.apertures)
def model_complete_single_zone_office_user_data(directory):
room = Room.from_box('Tiny_House_Office', 5, 10, 3)
room.properties.energy.program_type = prog_type_lib.office_program
room.properties.energy.add_default_ideal_air()
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))
north_face.add_aperture(aperture)
model = Model('Tiny_House', [room])
model_dict = model.to_dict()
model_dict['user_data'] = {'site': 'The backyard'}
model_dict['rooms'][0]['user_data'] = {'alt_name': 'Little old tiny house'}
model_dict['rooms'][0]['faces'][0]['user_data'] = {'alt_name': 'The floor'}
model_dict['rooms'][0]['faces'][3]['apertures'][0]['user_data'] = \
{'alt_name': 'Picture window'}
model_dict['rooms'][0]['faces'][1]['doors'][0]['user_data'] = \
{'alt_name': 'Front door'}
model_dict['rooms'][0]['faces'][3]['apertures'][0]['outdoor_shades'][0]['user_data'] = \
{'alt_name': 'Awning'}
dest_file = os.path.join(directory, 'model_complete_user_data.json')
with open(dest_file, 'w') as fp:
json.dump(model.to_dict(), fp, indent=4)
def test_to_dict_single_zone_detailed_loads():
"""Test the Model to_dict method with detailed, room-level loads."""
room = Room.from_box('OfficeTestBox', 5, 10, 3)
room.properties.energy.program_type = plenum_program
room.properties.energy.add_default_ideal_air()
room.properties.energy.people = office_program.people
room.properties.energy.lighting = office_program.lighting
room.properties.energy.electric_equipment = office_program.electric_equipment
room.properties.energy.infiltration = office_program.infiltration
room.properties.energy.ventilation = office_program.ventilation
room.properties.energy.setpoint = office_program.setpoint
room[0].boundary_condition = boundary_conditions.adiabatic
room[1].boundary_condition = boundary_conditions.adiabatic
room[2].boundary_condition = boundary_conditions.adiabatic
room[4].boundary_condition = boundary_conditions.adiabatic
room[5].boundary_condition = boundary_conditions.adiabatic
model = Model('OfficeModel', [room])
model_dict = model.to_dict()
assert 'people' in model_dict['rooms'][0]['properties']['energy']
assert model_dict['rooms'][0]['properties']['energy']['people']['identifier'] == \
office_program.people.identifier
assert 'lighting' in model_dict['rooms'][0]['properties']['energy']
assert model_dict['rooms'][0]['properties']['energy']['lighting']['identifier'] == \
office_program.lighting.identifier
assert 'electric_equipment' in model_dict['rooms'][0]['properties'][
'energy']
assert model_dict['rooms'][0]['properties']['energy']['electric_equipment']['identifier'] == \
office_program.electric_equipment.identifier
assert 'infiltration' in model_dict['rooms'][0]['properties']['energy']
assert model_dict['rooms'][0]['properties']['energy']['infiltration']['identifier'] == \
office_program.infiltration.identifier
assert 'ventilation' in model_dict['rooms'][0]['properties']['energy']
assert model_dict['rooms'][0]['properties']['energy']['ventilation']['identifier'] == \
office_program.ventilation.identifier
assert 'setpoint' in model_dict['rooms'][0]['properties']['energy']
assert model_dict['rooms'][0]['properties']['energy']['setpoint']['identifier'] == \
office_program.setpoint.identifier
def lighting_2004(model_json, output_file):
"""Convert a Model's lighting to be conformant with ASHRAE 90.1-2004 appendix G.
This includes determining whether an ASHRAE 2004 equivalent exists for each
program type in the model. If none is found, the baseline_watts_per_area on
the room's program's lighting will be used, which will default to a typical
office if none has been specified.
\b
Args:
model_json: Full path to a Model JSON file.
"""
try:
# re-serialize the Model to Python and get the glazing ratios
with open(model_json) as json_file:
data = json.load(json_file)
model = Model.from_dict(data)
# loop through the rooms and try to find equivalent programs in 2004
for room in model.rooms:
if room.properties.energy.lighting is None:
continue
prog_name = room.properties.energy.program_type.identifier.split(
'::')
prog_2004 = None
if len(prog_name) == 3:
new_prog_name = '2004::{}::{}'.format(prog_name[1],
prog_name[2])
try:
prog_2004 = program_type_by_identifier(new_prog_name)
except ValueError: # no equivalent program in ASHRAE 2004
pass
if prog_2004 is not None: # if program was found, use it to assign the LPD
if prog_2004.lighting is not None:
dup_light = room.properties.energy.lighting.duplicate()
dup_light.watts_per_area = prog_2004.lighting.watts_per_area
elif room.properties.energy.program_type.lighting is not None:
dup_light = room.properties.energy.program_type.lighting.duplicate(
)
dup_light.watts_per_area = dup_light.baseline_watts_per_area
else:
dup_light = room.properties.energy.lighting.duplicate()
dup_light.watts_per_area = dup_light.baseline_watts_per_area
dup_light.identifier = '{}_Lighting'.format(room.identifier)
room.properties.energy.lighting = dup_light
# write the Model JSON string
output_file.write(json.dumps(model.to_dict()))
except Exception as e:
_logger.exception(
'Model baseline geometry creation failed.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_rectangle_plan_simple():
runner = CliRunner()
result = runner.invoke(rectangle_plan, ['30', '20', '3.5'])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert len(new_model.rooms) == 1
assert len(new_model.apertures) == 0
result = runner.invoke(rectangle_plan, ['30', '20', '3.5', '-p', '5'])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert len(new_model.rooms) == 5
result = runner.invoke(rectangle_plan, ['30', '20', '3.5', '-p', '10'])
assert result.exit_code == 0
model_dict = json.loads(result.output)
new_model = Model.from_dict(model_dict)
assert len(new_model.rooms) == 4
def model_complete_multi_zone_office(directory):
first_floor = Room.from_box('First_Floor', 10, 10, 3, origin=Point3D(0, 0, 0))
second_floor = Room.from_box('Second_Floor', 10, 10, 3, origin=Point3D(0, 0, 3))
first_floor.properties.energy.program_type = prog_type_lib.office_program
second_floor.properties.energy.program_type = prog_type_lib.office_program
first_floor.properties.energy.add_default_ideal_air()
second_floor.properties.energy.add_default_ideal_air()
for face in first_floor[1:5]:
face.apertures_by_ratio(0.2, 0.01)
for face in second_floor[1:5]:
face.apertures_by_ratio(0.2, 0.01)
pts_1 = [Point3D(0, 0, 6), Point3D(0, 10, 6), Point3D(10, 10, 6), Point3D(10, 0, 6)]
pts_2 = [Point3D(0, 0, 6), Point3D(5, 0, 9), Point3D(5, 10, 9), Point3D(0, 10, 6)]
pts_3 = [Point3D(10, 0, 6), Point3D(10, 10, 6), Point3D(5, 10, 9), Point3D(5, 0, 9)]
pts_4 = [Point3D(0, 0, 6), Point3D(10, 0, 6), Point3D(5, 0, 9)]
pts_5 = [Point3D(10, 10, 6), Point3D(0, 10, 6), Point3D(5, 10, 9)]
face_1 = Face('AtticFace1', Face3D(pts_1))
face_2 = Face('AtticFace2', Face3D(pts_2))
face_3 = Face('AtticFace3', Face3D(pts_3))
face_4 = Face('AtticFace4', Face3D(pts_4))
face_5 = Face('AtticFace5', Face3D(pts_5))
attic = Room('Attic', [face_1, face_2, face_3, face_4, face_5], 0.01, 1)
constr_set = ConstructionSet('Attic Construction Set')
polyiso = EnergyMaterial('PolyIso', 0.2, 0.03, 43, 1210, 'MediumRough')
roof_constr = OpaqueConstruction('Attic Roof Construction',
[roof_membrane, polyiso, wood])
floor_constr = OpaqueConstruction('Attic Floor Construction',
[wood, insulation, wood])
constr_set.floor_set.interior_construction = floor_constr
constr_set.roof_ceiling_set.exterior_construction = roof_constr
attic.properties.energy.construction_set = constr_set
Room.solve_adjacency([first_floor, second_floor, attic], 0.01)
model = Model('Multi_Zone_Single_Family_House', [first_floor, second_floor, attic])
dest_file = os.path.join(directory, 'model_complete_multi_zone_office.json')
with open(dest_file, 'w') as fp:
json.dump(model.to_dict(), fp, indent=4)
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
