def test_set_program_type():
"""Test the setting of a ProgramType on a Room."""
lab_equip_day = ScheduleDay(
'Daily Lab Equipment', [0.25, 0.5, 0.25],
[Time(0, 0), Time(9, 0), Time(20, 0)])
lab_equipment = ScheduleRuleset('Lab Equipment', lab_equip_day, None,
schedule_types.fractional)
lab_vent_day = ScheduleDay(
'Daily Lab Ventilation', [0.5, 1, 0.5],
[Time(0, 0), Time(9, 0), Time(20, 0)])
lab_ventilation = ScheduleRuleset('Lab Ventilation', lab_vent_day, None,
schedule_types.fractional)
lab_program = office_program.duplicate()
lab_program.identifier = 'Bio Laboratory'
lab_program.electric_equipment.watts_per_area = 50
lab_program.electric_equipment.schedule = lab_equipment
lab_program.ventilation.flow_per_person = 0
lab_program.ventilation.flow_per_area = 0
lab_program.ventilation.air_changes_per_hour = 6
lab_program.ventilation.schedule = lab_ventilation
room = Room.from_box('ShoeBox', 5, 10, 3)
room.properties.energy.program_type = lab_program
assert room.properties.energy.program_type.identifier == 'Bio Laboratory'
assert room.properties.energy.program_type == lab_program
assert room.properties.energy.electric_equipment.watts_per_area == 50
assert room.properties.energy.electric_equipment.schedule == lab_equipment
assert room.properties.energy.ventilation.flow_per_person == 0
assert room.properties.energy.ventilation.flow_per_area == 0
assert room.properties.energy.ventilation.air_changes_per_hour == 6
assert room.properties.energy.ventilation.schedule == lab_ventilation
def test_ventilation_average():
"""Test the Ventilation.average method."""
weekday_office = ScheduleDay(
'Weekday Office Ventilation', [0, 1, 0.5, 0],
[Time(0, 0), Time(9, 0),
Time(17, 0), Time(19, 0)])
weekday_lobby = ScheduleDay(
'Weekday Lobby Ventilation', [0.1, 1, 0.1],
[Time(0, 0), Time(8, 0), Time(20, 0)])
weekend_office = ScheduleDay('Weekend Office Ventilation', [0])
weekend_lobby = ScheduleDay('Weekend Office Ventilation', [0.1])
wknd_office_rule = ScheduleRule(weekend_office,
apply_saturday=True,
apply_sunday=True)
wknd_lobby_rule = ScheduleRule(weekend_lobby,
apply_saturday=True,
apply_sunday=True)
office_schedule = ScheduleRuleset('Office Ventilation', weekday_office,
[wknd_office_rule],
schedule_types.fractional)
lobby_schedule = ScheduleRuleset('Lobby Ventilation', weekday_lobby,
[wknd_lobby_rule],
schedule_types.fractional)
office_vent = Ventilation('Office Ventilation', 0.01, 0.0006, 0, 0,
office_schedule)
lobby_vent = Ventilation('Lobby Ventilation', 0, 0, 0, 1, lobby_schedule)
office_avg = Ventilation.average('Average Ventilation',
[office_vent, lobby_vent])
assert office_avg.flow_per_person == pytest.approx(0.005, rel=1e-3)
assert office_avg.flow_per_area == pytest.approx(0.0003, rel=1e-3)
assert office_avg.flow_per_zone == pytest.approx(0, rel=1e-3)
assert office_avg.air_changes_per_hour == pytest.approx(0.5, rel=1e-3)
week_vals = office_avg.schedule.values(end_date=Date(1, 7))
avg_vals = [
0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.5, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 0.75, 0.75, 0.5, 0.05, 0.05, 0.05, 0.05
]
assert week_vals[:24] == [0.05] * 24
assert week_vals[24:48] == avg_vals
office_vent.schedule = None
lobby_vent.schedule = None
office_avg = Ventilation.average('Average Ventilation',
[office_vent, lobby_vent])
assert office_avg.schedule is None
def test_equipment_equality():
"""Test the equality of ElectricEquipment objects."""
weekday_office = ScheduleDay(
'Weekday Office Equip', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
saturday_office = ScheduleDay(
'Saturday Office Equip', [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 Equip', weekday_office, [weekend_rule],
schedule_types.fractional)
equipment = ElectricEquipment('Open Office Zone Equip', 10, schedule)
equipment_dup = equipment.duplicate()
equipment_alt = ElectricEquipment(
'Open Office Zone Equip', 10,
ScheduleRuleset.from_constant_value('Constant', 1,
schedule_types.fractional))
assert equipment is equipment
assert equipment is not equipment_dup
assert equipment == equipment_dup
equipment_dup.watts_per_area = 6
assert equipment != equipment_dup
assert equipment != equipment_alt
def test_equipment_lockability():
"""Test the lockability of ElectricEquipment objects."""
weekday_office = ScheduleDay(
'Weekday Office Equip', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
saturday_office = ScheduleDay(
'Saturday Office Equip', [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 Equip', weekday_office, [weekend_rule],
schedule_types.fractional)
equipment = ElectricEquipment('Open Office Zone Equip', 10, schedule)
equipment.watts_per_area = 6
equipment.lock()
with pytest.raises(AttributeError):
equipment.watts_per_area = 8
with pytest.raises(AttributeError):
equipment.schedule.default_day_schedule.remove_value_by_time(
Time(17, 0))
equipment.unlock()
equipment.watts_per_area = 8
with pytest.raises(AttributeError):
equipment.schedule.default_day_schedule.remove_value_by_time(
Time(17, 0))
def test_lighting_setability():
"""Test the setting of properties of Lighting."""
simple_office = ScheduleDay(
'Simple Weekday Light', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
schedule = ScheduleRuleset('Office Lighting', simple_office, None,
schedule_types.fractional)
constant = ScheduleRuleset.from_constant_value('Constant Light', 1,
schedule_types.fractional)
lighting = Lighting('Open Office Zone Lighting', 10, schedule)
lighting.identifier = 'Office Zone Lighting'
assert lighting.identifier == 'Office Zone Lighting'
lighting.watts_per_area = 6
assert lighting.watts_per_area == 6
lighting.schedule = constant
assert lighting.schedule == constant
assert lighting.schedule.values() == [1] * 8760
lighting.return_air_fraction = 0.1
assert lighting.return_air_fraction == 0.1
lighting.radiant_fraction = 0.4
assert lighting.radiant_fraction == 0.4
lighting.visible_fraction = 0.2
assert lighting.visible_fraction == 0.2
lighting.baseline_watts_per_area = 5.0
assert lighting.baseline_watts_per_area == 5.0
def test_people_lockability():
"""Test the lockability of People 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
occ_schedule = ScheduleRuleset('Office Occupancy', weekday_office,
[weekend_rule], schedule_types.fractional)
people = People('Open Office Zone People', 0.05, occ_schedule)
people.people_per_area = 0.1
people.lock()
with pytest.raises(AttributeError):
people.people_per_area = 0.1
with pytest.raises(AttributeError):
people.occupancy_schedule.default_day_schedule.remove_value_by_time(
Time(17, 0))
people.unlock()
people.people_per_area = 0.05
with pytest.raises(AttributeError):
people.occupancy_schedule.default_day_schedule.remove_value_by_time(
Time(17, 0))
def test_people_equality():
"""Test the equality of People 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
occ_schedule = ScheduleRuleset('Office Occupancy', weekday_office,
[weekend_rule], schedule_types.fractional)
people = People('Open Office Zone People', 0.05, occ_schedule)
people_dup = people.duplicate()
people_alt = People(
'Open Office Zone People', 0.05,
ScheduleRuleset.from_constant_value('Constant', 1,
schedule_types.fractional))
assert people is people
assert people is not people_dup
assert people == people_dup
people_dup.people_per_area = 0.06
assert people != people_dup
assert people != people_alt
def test_people_setability():
"""Test the setting of properties of People."""
simple_office = ScheduleDay(
'Simple Weekday Occupancy', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
occ_schedule = ScheduleRuleset('Office Occupancy', simple_office, None,
schedule_types.fractional)
constant_ppl = ScheduleRuleset.from_constant_value(
'Constant Occ', 1, schedule_types.fractional)
sleeping_act = ScheduleRuleset.from_constant_value(
'Sleeping Activity', 95, schedule_types.activity_level)
people = People('Open Office Zone People', 0.05, occ_schedule)
people.identifier = 'Office Zone People'
assert people.identifier == 'Office Zone People'
people.people_per_area = 0.1
assert people.people_per_area == 0.1
assert people.area_per_person == 10
people.area_per_person = 20
assert people.area_per_person == 20
assert people.people_per_area == 0.05
people.occupancy_schedule = constant_ppl
assert people.occupancy_schedule == constant_ppl
people.activity_schedule = sleeping_act
assert people.activity_schedule.schedule_type_limit == schedule_types.activity_level
assert people.activity_schedule.values() == [95] * 8760
people.radiant_fraction = 0.4
assert people.radiant_fraction == 0.4
people.latent_fraction = 0.2
assert people.latent_fraction == 0.2
def schedule_primary_school_occupancy(directory):
weekday_school = ScheduleDay('Weekday School Year', [0, 1, 0.5, 0],
[Time(0, 0), Time(8, 0), Time(15, 0), Time(18, 0)])
weekend_school = ScheduleDay('Weekend School Year', [0])
weekday_summer = ScheduleDay('Weekday Summer', [0, 0.5, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
weekend_summer = ScheduleDay('Weekend Summer', [0])
summer_weekday_rule = ScheduleRule(
weekday_summer, start_date=Date(7, 1), end_date=Date(9, 1))
summer_weekday_rule.apply_weekday = True
summer_weekend_rule = ScheduleRule(
weekend_summer, start_date=Date(7, 1), end_date=Date(9, 1))
summer_weekend_rule.apply_weekend = True
school_weekend_rule = ScheduleRule(weekend_school)
school_weekend_rule.apply_weekend = True
summer_design = ScheduleDay('School Summer Design', [0, 1, 0.25],
[Time(0, 0), Time(6, 0), Time(18, 0)])
winter_design = ScheduleDay('School Winter Design', [0])
schedule = ScheduleRuleset('School Occupancy', weekday_school,
[summer_weekday_rule, summer_weekend_rule,
school_weekend_rule], schedule_types.fractional,
weekend_summer, summer_design, winter_design)
dest_file = os.path.join(directory, 'schedule_primary_school_occupancy.json')
with open(dest_file, 'w') as fp:
json.dump(schedule.to_dict(True), fp, indent=4)
def test_program_type_dict_methods():
"""Test the to/from dict methods."""
simple_office = ScheduleDay(
'Simple Weekday Occupancy', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
occ_schedule = ScheduleRuleset('Office Occupancy Schedule', simple_office,
None, schedule_types.fractional)
light_schedule = occ_schedule.duplicate()
light_schedule.identifier = 'Office Lighting-Equip Schedule'
light_schedule.default_day_schedule.values = [0.25, 1, 0.25]
equip_schedule = light_schedule.duplicate()
inf_schedule = ScheduleRuleset.from_constant_value(
'Infiltration Schedule', 1, schedule_types.fractional)
heat_setpt = ScheduleRuleset.from_constant_value(
'Office Heating Schedule', 21, schedule_types.temperature)
cool_setpt = ScheduleRuleset.from_constant_value(
'Office Cooling Schedule', 24, schedule_types.temperature)
people = People('Open Office People', 0.05, occ_schedule)
lighting = Lighting('Open Office Lighting', 10, light_schedule)
equipment = ElectricEquipment('Open Office Equipment', 10, equip_schedule)
infiltration = Infiltration('Office Infiltration', 0.00015, inf_schedule)
ventilation = Ventilation('Office Ventilation', 0.0025, 0.0003)
setpoint = Setpoint('Office Setpoints', heat_setpt, cool_setpt)
office_program = ProgramType('Open Office Program', people, lighting,
equipment, None, None, infiltration,
ventilation, setpoint)
prog_dict = office_program.to_dict()
new_office_program = ProgramType.from_dict(prog_dict)
assert new_office_program == office_program
assert prog_dict == new_office_program.to_dict()
def test_lighting_equality():
"""Test the equality of Lighting objects."""
weekday_office = ScheduleDay(
'Weekday Office Lighting', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
saturday_office = ScheduleDay(
'Saturday Office Lighting', [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 Lighting', weekday_office,
[weekend_rule], schedule_types.fractional)
lighting = Lighting('Open Office Zone Lighting', 10, schedule)
lighting_dup = lighting.duplicate()
lighting_alt = Lighting(
'Open Office Zone Lighting', 10,
ScheduleRuleset.from_constant_value('Constant', 1,
schedule_types.fractional))
assert lighting is lighting
assert lighting is not lighting_dup
assert lighting == lighting_dup
lighting_dup.watts_per_area = 6
assert lighting != lighting_dup
assert lighting != lighting_alt
def test_lighting_lockability():
"""Test the lockability of Lighting objects."""
weekday_office = ScheduleDay(
'Weekday Office Lighting', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
saturday_office = ScheduleDay(
'Saturday Office Lighting', [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 Lighting', weekday_office,
[weekend_rule], schedule_types.fractional)
lighting = Lighting('Open Office Zone Lighting', 10, schedule)
lighting.watts_per_area = 6
lighting.lock()
with pytest.raises(AttributeError):
lighting.watts_per_area = 8
with pytest.raises(AttributeError):
lighting.schedule.default_day_schedule.remove_value_by_time(Time(
17, 0))
lighting.unlock()
lighting.watts_per_area = 8
with pytest.raises(AttributeError):
lighting.schedule.default_day_schedule.remove_value_by_time(Time(
17, 0))
def test_schedule_ruleset_values():
"""Test the ScheduleRuleset values method."""
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)])
sunday_office = ScheduleDay('Sunday Office Occupancy', [0])
sat_rule = ScheduleRule(saturday_office, apply_saturday=True)
sun_rule = ScheduleRule(sunday_office, apply_sunday=True)
schedule = ScheduleRuleset('Office Occupancy', weekday_office,
[sat_rule, sun_rule], schedule_types.fractional)
assert len(schedule.values()) == 8760
assert len(schedule.values(leap_year=True)) == 8784
sch_week_vals = schedule.values(end_date=Date(1, 7))
assert len(sch_week_vals) == 24 * 7
assert sch_week_vals[:24] == sunday_office.values_at_timestep()
assert sch_week_vals[24:48] == weekday_office.values_at_timestep()
assert sch_week_vals[144:] == saturday_office.values_at_timestep()
sch_week_vals_10_min = schedule.values(6, end_date=Date(1, 7))
assert len(sch_week_vals_10_min) == 24 * 7 * 6
def test_ideal_air_to_dict():
"""Test the to_dict method."""
ideal_air = IdealAirSystem('Passive House HVAC System')
ideal_air.economizer_type = 'DifferentialEnthalpy'
ideal_air.demand_controlled_ventilation = True
ideal_air.sensible_heat_recovery = 0.75
ideal_air.latent_heat_recovery = 0.6
ideal_air.heating_air_temperature = 40
ideal_air.cooling_air_temperature = 15
ideal_air.heating_limit = 2000
ideal_air.cooling_limit = 3500
sch_day = ScheduleDay(
'Day Control', [0, 1, 0],
[Time(0, 0), Time(8, 0), Time(22, 0)])
schedule = ScheduleRuleset('HVAC Control', sch_day, None,
schedule_types.on_off)
ideal_air.heating_availability = schedule
ideal_air.cooling_availability = schedule
ideal_air_dict = ideal_air.to_dict(abridged=True)
assert ideal_air_dict['economizer_type'] == 'DifferentialEnthalpy'
assert ideal_air_dict['demand_controlled_ventilation'] == True
assert ideal_air_dict['sensible_heat_recovery'] == 0.75
assert ideal_air_dict['latent_heat_recovery'] == 0.6
assert ideal_air_dict['heating_air_temperature'] == 40
assert ideal_air_dict['cooling_air_temperature'] == 15
assert ideal_air_dict['heating_limit'] == 2000
assert ideal_air_dict['cooling_limit'] == 3500
assert ideal_air_dict['heating_availability'] == 'HVAC Control'
assert ideal_air_dict['cooling_availability'] == 'HVAC Control'
def test_schedule_ruleset_to_from_idf():
"""Test the ScheduleRuleset to_idf and from_idf methods."""
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)])
sunday_office = ScheduleDay('Sunday Office Occupancy', [0])
week_rule = ScheduleRule(weekday_office)
week_rule.apply_weekday = True
sat_rule = ScheduleRule(saturday_office, apply_saturday=True)
summer_office = ScheduleDay(
'Summer Office Occupancy', [0, 1, 0.25],
[Time(0, 0), Time(6, 0), Time(22, 0)])
winter_office = ScheduleDay('Winter Office Occupancy', [0])
schedule = ScheduleRuleset('Office Occupancy', sunday_office,
[week_rule, sat_rule],
schedule_types.fractional, summer_office,
winter_office)
year_sched, week_scheds = schedule.to_idf()
assert len(week_scheds) == 1
day_scheds = (weekday_office.to_idf(), saturday_office.to_idf(),
sunday_office.to_idf(), summer_office.to_idf(),
winter_office.to_idf())
sch_type = schedule_types.fractional.to_idf()
rebuilt_schedule = ScheduleRuleset.from_idf(year_sched, week_scheds,
day_scheds, sch_type)
rebuilt_year_sched, rebuilt_week_scheds = rebuilt_schedule.to_idf()
assert rebuilt_year_sched == year_sched
assert rebuilt_week_scheds[0] == week_scheds[0]
def test_program_type_setability():
"""Test the setting of properties of ProgramType."""
simple_office = ScheduleDay(
'Simple Weekday Occupancy', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
occ_schedule = ScheduleRuleset('Office Occupancy Schedule', simple_office,
None, schedule_types.fractional)
light_schedule = occ_schedule.duplicate()
light_schedule.identifier = 'Office Lighting-Equip Schedule'
light_schedule.default_day_schedule.values = [0.25, 1, 0.25]
equip_schedule = light_schedule.duplicate()
inf_schedule = ScheduleRuleset.from_constant_value(
'Infiltration Schedule', 1, schedule_types.fractional)
heat_setpt = ScheduleRuleset.from_constant_value(
'Office Heating Schedule', 21, schedule_types.temperature)
cool_setpt = ScheduleRuleset.from_constant_value(
'Office Cooling Schedule', 24, schedule_types.temperature)
people = People('Open Office People', 0.05, occ_schedule)
lighting = Lighting('Open Office Lighting', 10, light_schedule)
equipment = ElectricEquipment('Open Office Equipment', 10, equip_schedule)
infiltration = Infiltration('Office Infiltration', 0.00015, inf_schedule)
ventilation = Ventilation('Office Ventilation', 0.0025, 0.0003)
setpoint = Setpoint('Office Setpoints', heat_setpt, cool_setpt)
office_program = ProgramType('Open Office Program')
assert office_program.identifier == 'Open Office Program'
office_program.identifier = 'Office Program'
assert office_program.identifier == 'Office Program'
assert office_program.people is None
office_program.people = people
assert office_program.people == people
assert office_program.lighting is None
office_program.lighting = lighting
assert office_program.lighting == lighting
assert office_program.electric_equipment is None
office_program.electric_equipment = equipment
assert office_program.electric_equipment == equipment
assert office_program.infiltration is None
office_program.infiltration = infiltration
assert office_program.infiltration == infiltration
assert office_program.ventilation is None
office_program.ventilation = ventilation
assert office_program.ventilation == ventilation
assert office_program.setpoint is None
office_program.setpoint = setpoint
assert office_program.setpoint == setpoint
with pytest.raises(AssertionError):
office_program.people = lighting
with pytest.raises(AssertionError):
office_program.lighting = equipment
with pytest.raises(AssertionError):
office_program.electric_equipment = people
with pytest.raises(AssertionError):
office_program.infiltration = people
with pytest.raises(AssertionError):
office_program.ventilation = setpoint
with pytest.raises(AssertionError):
office_program.setpoint = ventilation
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_ideal_air_system_setability():
"""Test the setting of properties of IdealAirSystem."""
ideal_air = IdealAirSystem('Test System')
ideal_air.identifier = 'Test System2'
assert ideal_air.identifier == 'Test System2'
ideal_air.economizer_type = 'DifferentialEnthalpy'
assert ideal_air.economizer_type == 'DifferentialEnthalpy'
ideal_air.sensible_heat_recovery = 0.75
assert ideal_air.sensible_heat_recovery == 0.75
ideal_air.latent_heat_recovery = 0.65
assert ideal_air.latent_heat_recovery == 0.65
ideal_air.heating_air_temperature = 40
assert ideal_air.heating_air_temperature == 40
ideal_air.cooling_air_temperature = 15
assert ideal_air.cooling_air_temperature == 15
ideal_air.heating_limit = 1000
assert ideal_air.heating_limit == 1000
ideal_air.cooling_limit = 2000
assert ideal_air.cooling_limit == 2000
sch_day = ScheduleDay(
'Day Control', [0, 1, 0],
[Time(0, 0), Time(8, 0), Time(22, 0)])
schedule = ScheduleRuleset('HVAC Control', sch_day, None,
schedule_types.on_off)
ideal_air.heating_availability = schedule
assert ideal_air.heating_availability == schedule
ideal_air.cooling_availability = schedule
assert ideal_air.cooling_availability == schedule
def test_service_hot_water_init_from_idf():
"""Test the initialization of Lighting from_idf."""
weekday_office = ScheduleDay('Weekday Office Water Use', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
saturday_office = ScheduleDay('Saturday Office Water Use', [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 Water Use', weekday_office,
[weekend_rule], schedule_types.fractional)
shw = ServiceHotWater('Open Office Zone Hot Water', 0.1, schedule)
sched_dict = {schedule.identifier: schedule}
room = Room.from_box('Test_Zone', 10, 10, 3)
idf_str, sch_strs = shw.to_idf(room)
for sch in sch_strs:
sch_obj = ScheduleRuleset.from_idf_constant(sch)
sched_dict[sch_obj.identifier] = sch_obj
rebuilt_shw, room_id, flow = ServiceHotWater.from_idf(
idf_str, room.floor_area, sched_dict)
if (sys.version_info >= (3, 0)):
assert shw == rebuilt_shw
assert room_id == room.identifier
assert flow == shw.flow_per_area * room.floor_area
def test_people_average():
"""Test the People.average method."""
weekday_office = ScheduleDay(
'Weekday Office Occupancy', [0, 1, 0.5, 0],
[Time(0, 0), Time(9, 0),
Time(17, 0), Time(19, 0)])
weekday_lobby = ScheduleDay(
'Weekday Lobby Occupancy', [0.1, 1, 0.1],
[Time(0, 0), Time(8, 0), Time(20, 0)])
weekend_office = ScheduleDay('Weekend Office Occupancy', [0])
weekend_lobby = ScheduleDay('Weekend Office Occupancy', [0.1])
wknd_office_rule = ScheduleRule(weekend_office,
apply_saturday=True,
apply_sunday=True)
wknd_lobby_rule = ScheduleRule(weekend_lobby,
apply_saturday=True,
apply_sunday=True)
office_schedule = ScheduleRuleset('Office Occupancy', weekday_office,
[wknd_office_rule],
schedule_types.fractional)
lobby_schedule = ScheduleRuleset('Lobby Occupancy', weekday_lobby,
[wknd_lobby_rule],
schedule_types.fractional)
lobby_activity = ScheduleRuleset.from_constant_value(
'Lobby Activity Sched', 160, schedule_types.activity_level)
office_people = People('Office People', 0.05, office_schedule)
lobby_people = People('Lobby People', 0.1, lobby_schedule, lobby_activity,
0.4, 0.2)
office_avg = People.average('Office Average People',
[office_people, lobby_people])
assert office_avg.people_per_area == pytest.approx(0.075, rel=1e-3)
assert office_avg.radiant_fraction == pytest.approx(0.35, rel=1e-3)
assert office_avg.latent_fraction == autocalculate
week_vals = office_avg.occupancy_schedule.values(end_date=Date(1, 7))
avg_vals = [
0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.5, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 0.75, 0.75, 0.5, 0.05, 0.05, 0.05, 0.05
]
assert week_vals[:24] == [0.05] * 24
assert week_vals[24:48] == avg_vals
act_vals = office_avg.activity_schedule.values(end_date=Date(1, 1))
assert act_vals == [140] * 24
def test_infiltration_average():
"""Test the Infiltration.average method."""
weekday_office = ScheduleDay(
'Weekday Office Infiltration', [0, 1, 0.5, 0],
[Time(0, 0), Time(9, 0),
Time(17, 0), Time(19, 0)])
weekday_lobby = ScheduleDay(
'Weekday Lobby Infiltration', [0.1, 1, 0.1],
[Time(0, 0), Time(8, 0), Time(20, 0)])
weekend_office = ScheduleDay('Weekend Office Infiltration', [0])
weekend_lobby = ScheduleDay('Weekend Office Infiltration', [0.1])
wknd_office_rule = ScheduleRule(weekend_office,
apply_saturday=True,
apply_sunday=True)
wknd_lobby_rule = ScheduleRule(weekend_lobby,
apply_saturday=True,
apply_sunday=True)
office_schedule = ScheduleRuleset('Office Infiltration', weekday_office,
[wknd_office_rule],
schedule_types.fractional)
lobby_schedule = ScheduleRuleset('Lobby Infiltration', weekday_lobby,
[wknd_lobby_rule],
schedule_types.fractional)
office_inf = Infiltration('Office Infiltration', 0.0003, office_schedule,
1, 0, 0)
lobby_inf = Infiltration('Lobby Infiltration', 0.0006, lobby_schedule, 0.6,
0.03, 0.1)
office_avg = Infiltration.average('Average Infiltration',
[office_inf, lobby_inf])
assert office_avg.flow_per_exterior_area == pytest.approx(0.00045,
rel=1e-3)
assert office_avg.constant_coefficient == pytest.approx(0.8, rel=1e-3)
assert office_avg.temperature_coefficient == pytest.approx(0.015, rel=1e-3)
assert office_avg.velocity_coefficient == pytest.approx(0.05, rel=1e-3)
week_vals = office_avg.schedule.values(end_date=Date(1, 7))
avg_vals = [
0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.5, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 0.75, 0.75, 0.5, 0.05, 0.05, 0.05, 0.05
]
assert week_vals[:24] == [0.05] * 24
assert week_vals[24:48] == avg_vals
def test_setpoint_init_from_idf():
"""Test the initialization of Setpoint from_idf."""
simple_heat = ScheduleDay(
'Simple Weekday HtgSetp', [18, 21, 18],
[Time(0, 0), Time(9, 0), Time(17, 0)])
simple_cool = ScheduleDay(
'Simple Weekday ClgSetp', [28, 24, 28],
[Time(0, 0), Time(9, 0), Time(17, 0)])
heat_setpt = ScheduleRuleset('Office Heating', simple_heat, None,
schedule_types.temperature)
cool_setpt = ScheduleRuleset('Office Cooling', simple_cool, None,
schedule_types.temperature)
setpoint = Setpoint('Office Setpoint', heat_setpt, cool_setpt)
sched_dict = {heat_setpt.name: heat_setpt, cool_setpt.name: cool_setpt}
idf_str = setpoint.to_idf()
rebuilt_setpoint = Setpoint.from_idf(idf_str, sched_dict)
assert setpoint == rebuilt_setpoint
def test_equipment_average():
"""Test the ElectricEquipment.average method."""
weekday_office = ScheduleDay(
'Weekday Office Equip', [0, 1, 0.5, 0],
[Time(0, 0), Time(9, 0),
Time(17, 0), Time(19, 0)])
weekday_lobby = ScheduleDay(
'Weekday Lobby Equip', [0.1, 1, 0.1],
[Time(0, 0), Time(8, 0), Time(20, 0)])
weekend_office = ScheduleDay('Weekend Office Equip', [0])
weekend_lobby = ScheduleDay('Weekend Office Equip', [0.1])
wknd_office_rule = ScheduleRule(weekend_office,
apply_saturday=True,
apply_sunday=True)
wknd_lobby_rule = ScheduleRule(weekend_lobby,
apply_saturday=True,
apply_sunday=True)
office_schedule = ScheduleRuleset('Office Equip', weekday_office,
[wknd_office_rule],
schedule_types.fractional)
lobby_schedule = ScheduleRuleset('Lobby Equip', weekday_lobby,
[wknd_lobby_rule],
schedule_types.fractional)
office_equip = ElectricEquipment('Office Equip', 10, office_schedule, 0.3,
0.3)
lobby_equip = ElectricEquipment('Lobby Equip', 6, lobby_schedule, 0.4, 0.2,
0.1)
office_avg = ElectricEquipment.average('Office Average Equip',
[office_equip, lobby_equip])
assert office_avg.watts_per_area == pytest.approx(8, rel=1e-3)
assert office_avg.radiant_fraction == pytest.approx(0.35, rel=1e-3)
assert office_avg.latent_fraction == pytest.approx(0.25, rel=1e-3)
assert office_avg.lost_fraction == pytest.approx(0.05, rel=1e-3)
week_vals = office_avg.schedule.values(end_date=Date(1, 7))
avg_vals = [
0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.5, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 0.75, 0.75, 0.5, 0.05, 0.05, 0.05, 0.05
]
assert week_vals[:24] == [0.05] * 24
assert week_vals[24:48] == avg_vals
def test_lighting_average():
"""Test the Lighting.average method."""
weekday_office = ScheduleDay(
'Weekday Office Lighting', [0, 1, 0.5, 0],
[Time(0, 0), Time(9, 0),
Time(17, 0), Time(19, 0)])
weekday_lobby = ScheduleDay(
'Weekday Lobby Lighting', [0.1, 1, 0.1],
[Time(0, 0), Time(8, 0), Time(20, 0)])
weekend_office = ScheduleDay('Weekend Office Lighting', [0])
weekend_lobby = ScheduleDay('Weekend Office Lighting', [0.1])
wknd_office_rule = ScheduleRule(weekend_office,
apply_saturday=True,
apply_sunday=True)
wknd_lobby_rule = ScheduleRule(weekend_lobby,
apply_saturday=True,
apply_sunday=True)
office_schedule = ScheduleRuleset('Office Lighting', weekday_office,
[wknd_office_rule],
schedule_types.fractional)
lobby_schedule = ScheduleRuleset('Lobby Lighting', weekday_lobby,
[wknd_lobby_rule],
schedule_types.fractional)
office_lights = Lighting('Office Lighting', 10, office_schedule, 0, 0.3,
0.3)
lobby_lights = Lighting('Lobby Lighting', 6, lobby_schedule, 0.1, 0.4, 0.2)
office_avg = Lighting.average('Office Average Lighting',
[office_lights, lobby_lights])
assert office_avg.watts_per_area == pytest.approx(8, rel=1e-3)
assert office_avg.return_air_fraction == pytest.approx(0.05, rel=1e-3)
assert office_avg.radiant_fraction == pytest.approx(0.35, rel=1e-3)
assert office_avg.visible_fraction == pytest.approx(0.25, rel=1e-3)
week_vals = office_avg.schedule.values(end_date=Date(1, 7))
avg_vals = [
0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.5, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 0.75, 0.75, 0.5, 0.05, 0.05, 0.05, 0.05
]
assert week_vals[:24] == [0.05] * 24
assert week_vals[24:48] == avg_vals
def ventilation_control_detailed(directory):
simple_flush = ScheduleDay('Simple Flush', [1, 0, 1],
[Time(0, 0), Time(9, 0), Time(22, 0)])
schedule = ScheduleRuleset('Night Flush Schedule', simple_flush,
None, schedule_types.fractional)
ventilation = VentilationControl(22, 28, 12, 32, 0)
ventilation.schedule = schedule
dest_file = os.path.join(directory, 'ventilation_control_detailed.json')
with open(dest_file, 'w') as fp:
json.dump(ventilation.to_dict(abridged=True), fp, indent=4)
def test_schedule_ruleset_average_schedules_date_range():
"""Test the ScheduleRuleset average_schedules method with schedules over a date range."""
weekday_school = ScheduleDay(
'Weekday School Year', [0.1, 1, 0.1],
[Time(0, 0), Time(8, 0), Time(17, 0)])
weekend_school = ScheduleDay('Weekend School Year', [0.1])
weekday_summer = ScheduleDay(
'Weekday Summer', [0, 0.5, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
weekend_summer = ScheduleDay('Weekend Summer', [0])
summer_weekday_rule = ScheduleRule(weekday_summer,
start_date=Date(7, 1),
end_date=Date(9, 1))
summer_weekday_rule.apply_weekday = True
summer_weekend_rule = ScheduleRule(weekend_summer,
start_date=Date(7, 1),
end_date=Date(9, 1))
summer_weekend_rule.apply_weekend = True
summer_weekend_rule.apply_holiday = True
school_weekend_rule = ScheduleRule(weekend_school)
school_weekend_rule.apply_weekend = True
school_weekend_rule.apply_holiday = True
summer_design = ScheduleDay(
'School Summer Design', [0, 1, 0.25],
[Time(0, 0), Time(6, 0), Time(18, 0)])
winter_design = ScheduleDay('School Winter Design', [0])
all_rules = [summer_weekday_rule, summer_weekend_rule, school_weekend_rule]
school_schedule = ScheduleRuleset('School Occupancy', weekday_school,
all_rules, schedule_types.fractional,
summer_design, winter_design)
lobby_schedule = ScheduleRuleset.from_constant_value(
'Lobby Occupancy', 0.1, schedule_types.fractional)
school_avg = ScheduleRuleset.average_schedules(
'Office Average', [school_schedule, lobby_schedule])
week_vals = school_avg.values(end_date=Date(1, 7))
avg_vals = [
0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.55, 0.55, 0.55, 0.55, 0.55,
0.55, 0.55, 0.55, 0.55, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1
]
assert week_vals[:24] == [0.1] * 24
assert week_vals[24:48] == avg_vals
week_vals = school_avg.values(start_date=Date(7, 1), end_date=Date(7, 7))
avg_vals = [
0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.3, 0.3, 0.3,
0.3, 0.3, 0.3, 0.3, 0.3, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05
]
assert week_vals[:24] == [0.05] * 24
assert week_vals[24:48] == avg_vals
def test_setpoint_init_with_setback():
"""Test the initialization of Setpoint with a setback schedule."""
simple_heat = ScheduleDay(
'Simple Weekday HtgSetp', [18, 21, 18],
[Time(0, 0), Time(9, 0), Time(17, 0)])
simple_cool = ScheduleDay(
'Simple Weekday ClgSetp', [28, 24, 28],
[Time(0, 0), Time(9, 0), Time(17, 0)])
heat_setpt = ScheduleRuleset('Office Heating', simple_heat, None,
schedule_types.temperature)
cool_setpt = ScheduleRuleset('Office Cooling', simple_cool, None,
schedule_types.temperature)
setpoint = Setpoint('Office Setpoint', heat_setpt, cool_setpt)
assert setpoint.identifier == 'Office Setpoint'
assert setpoint.heating_schedule == heat_setpt
assert setpoint.heating_setpoint == 21
assert setpoint.heating_setback == 18
assert setpoint.cooling_schedule == cool_setpt
assert setpoint.cooling_setpoint == 24
assert setpoint.cooling_setback == 28
def program_type_office(directory):
dest_file = os.path.join(directory, 'program_type_office.json')
program_obj = office_program.duplicate()
simple_office = ScheduleDay(
'Simple Weekday', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
schedule = ScheduleRuleset('Office Water Use', simple_office, None,
schedule_types.fractional)
shw = ServiceHotWater('Office Hot Water', 0.1, schedule)
program_obj.service_hot_water = shw
with open(dest_file, 'w') as fp:
json.dump(program_obj.to_dict(abridged=False), fp, indent=4)
def test_ventilation_control_init_schedule():
"""Test the initialization of VentilationControl with a schedule."""
simple_office = ScheduleDay('Simple Flush', [1, 0, 1],
[Time(0, 0), Time(9, 0), Time(22, 0)])
schedule = ScheduleRuleset('Night Flush Schedule', simple_office,
None, schedule_types.fractional)
ventilation = VentilationControl(100, schedule=schedule)
str(ventilation) # test the string representation
assert ventilation.min_indoor_temperature == 100
assert ventilation.schedule.identifier == 'Night Flush Schedule'
assert ventilation.schedule.schedule_type_limit == schedule_types.fractional
assert ventilation.schedule == schedule
def test_infiltration_dict_methods():
"""Test the to/from dict methods."""
simple_lobby = ScheduleDay(
'Simple Weekday', [0, 1, 0],
[Time(0, 0), Time(9, 0), Time(17, 0)])
schedule = ScheduleRuleset('Lobby Infiltration Schedule', simple_lobby,
None, schedule_types.fractional)
infiltration = Infiltration('Lobby Infiltration', 0.0003, schedule)
inf_dict = infiltration.to_dict()
new_infiltration = Infiltration.from_dict(inf_dict)
assert new_infiltration == infiltration
assert inf_dict == new_infiltration.to_dict()
