def test_weather_series(self):
for _ in iter_eplus_versions(self):
weather_dir = os.path.join(CONF.eplus_base_dir_path, "WeatherData")
# check Chicago
file_path = os.path.join(
weather_dir, "USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw")
# get weather series csv
with open(file_path) as f:
# skip header
for i in range(8):
next(f)
expected_df = pd.read_csv(f, header=None)
# create weather data
weather_data = WeatherData.from_epw(file_path)
generated_df = weather_data.get_weather_series()
generated_df.columns = range(len(
generated_df.columns)) # remove columns (for comparison)
# check
# correct year convention
expected_df[3] -= 1
assert_frame_equal(expected_df, generated_df)
def test_extensible(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
sch = idf.Schedule_Compact.one(lambda x: x.name == "system availability schedule")
for i in range(1500):
sch.add_field("12:00")
self.assertEqual(sch[1300], "12:00")
def test_pointing(self):
for eplus_version in iter_eplus_versions(self):
epm = self.epms_d[eplus_version]
z = epm.zone.one()
# check pointing surfaces
self.assertEqual(
{
"zn001:wall001",
"zn001:wall002",
"zn001:wall003",
"zn001:wall004",
"zn001:flr001",
"zn001:roof001",
}, {
s.name
for s in z.get_pointing_records().BuildingSurface_Detailed
})
# check number of pointing tables
self.assertEqual(4, len(z.get_pointing_records()))
# check number of pointing objects
count = 0
for qs in z.get_pointing_records().values():
count += len(qs)
self.assertEqual(9, count)
def test_pop_end(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
sch = idf.Schedule_Compact.one(lambda x: x.name == "system availability schedule")
ini_len = len(sch)
self.assertEqual("1", sch.pop())
self.assertEqual(ini_len-1, len(sch))
def test_cache_on_filter(self):
for _ in iter_eplus_versions(self):
# load idf
idf = self.get_epm()
# check that cache is empty
nb = len(idf._dev_cache)
self.assertEqual(0, nb)
# perform request
idf.Schedule_Compact.one(lambda x: x.name == "system availability schedule")
nb = len(idf._dev_cache)
# check cache went up, and hits are 0
self.assertTrue(nb > 0)
self.assertEqual([0]*nb, [v["hits"] for v in idf._dev_cache.values()])
# retry
idf.Schedule_Compact.one(lambda x: x.name == "system availability schedule")
# check cache didn't go up, and hits are 1
self.assertEqual(nb, len(idf._dev_cache))
self.assertEqual([1] * nb, [v["hits"] for v in idf._dev_cache.values()])
# clear
idf._dev_clear_cache()
# check cache was cleared
self.assertEqual(0, len(idf._dev_cache))
def test_pop_middle(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
sch = idf.Schedule_Compact.one(lambda x: x.name == "system availability schedule")
# before pop
self.assertEqual(
"""Schedule:Compact,
system availability schedule, ! - Name
any number, ! - Schedule Type Limits Name
through: 12/31, ! - Field 1
for: alldays, ! - Field 2
until: 24:00, ! - Field 3
1; ! - Field 3
""",
sch.to_idf())
# pop
self.assertEqual("through: 12/31", sch.pop(2))
# after pop
self.assertEqual(
"""Schedule:Compact,
system availability schedule, ! - Name
any number, ! - Schedule Type Limits Name
for: alldays, ! - Field 2
until: 24:00, ! - Field 3
1; ! - Field 3
""",
sch.to_idf())
def test_qs_one(self):
for eplus_version in iter_eplus_versions(self):
self.assertEqual(
self.epms_d[eplus_version].BuildingSurface_Detailed.one(
lambda x: x.name == "zn001:roof001").name,
"zn001:roof001"
)
def test_idf_unlink_and_remove(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
zone = idf.Zone.one()
zone.unlink_pointing_records()
idf.remove(zone)
self.assertEqual(len(idf.Zone.select()), 0)
def test_record_getitem_getattr_and_pk(self):
bsd_name = "zn001:roof001"
for eplus_version in iter_eplus_versions(self):
bsd = self.epms_d[eplus_version].BuildingSurface_Detailed[bsd_name]
self.assertEqual(bsd.name, bsd_name)
self.assertEqual(bsd[0], bsd_name)
self.assertEqual(bsd.get_pk(), bsd_name)
def test_get_table(self):
for eplus_version in iter_eplus_versions(self):
table = self.epms_d[eplus_version].Construction
self.assertEqual(
{"r13wall", "floor", "roof31"},
set([c.name for c in table.select()])
)
def test_add_records(self):
for eplus_version in iter_eplus_versions(self):
epm = self.epms_d[eplus_version]
schedule_compact = epm.Schedule_Compact
# add schedule with simple field
sch1 = schedule_compact.add(name="sch1")
self.assertEqual(sch1.name, "sch1")
# add schedule with extensible fields
sch2 = schedule_compact.add( # kwargs like
name="sch2",
field_1="Through: 12/31",
field_2="For: AllDays",
field_3="Until: 24:00,4"
)
self.assertEqual(5, len(sch2))
# add schedule from dict
sch3 = schedule_compact.add({ # dict like
0: "sch3",
2: "Through: 12/31",
"field_2": "For: AllDays",
"field_3": "Until: 24:00,4"
})
self.assertEqual(5, len(sch3))
# batch add schedules
schedules = schedule_compact.batch_add([
dict(name="batch0"),
dict(name="batch1"),
dict(name="batch2")
])
self.assertEqual(3, len(schedules))
self.assertEqual(set(schedules), set(schedule_compact.select(lambda x: "batch" in x.name)))
def test_values(self):
for eplus_version in iter_eplus_versions(self):
version_str = "-".join([str(v) for v in eplus_version])
s = Simulation(
os.path.join(
Resources.SimulationsOutputs.one_zone_uncontrolled,
version_str))
eio = s.get_out_eio()
self.assertEqual(
float(
eio.get_df("Site:GroundReflectance:SnowModifier").loc[
0, "Normal"]), 1)
df = eio.get_df("Material CTF Summary")
self.assertEqual(
float(df[df[df.columns[0]] == "R13LAYER"].iloc[0, 5]), 2.291)
self.assertEqual(
float(eio.get_value("Material CTF Summary", 5, 0, "R13LAYER")),
2.291)
self.assertEqual(
float(
eio.get_value("Material CTF Summary",
"ThermalResistance {m2-K/w}",
"Material Name", "R13LAYER")), 2.291)
def test_all_time_steps(self):
for eplus_version in iter_eplus_versions(self):
eplus_version_str = "-".join([str(v) for v in eplus_version])
simulation_path = os.path.join(
RESOURCES_DIR_PATH,
"simulations-outputs",
"one_zone_uncontrolled",
eplus_version_str
)
s = Simulation(simulation_path)
for frequency in ["timestep", "hourly", "daily", "monthly", "annual", "run_period"]:
df = s.eso.get_data(frequency=frequency)
if frequency == "annual":
self.assertIsNone(df)
continue
# check one day of data (15 min time step)
self.assertEqual(
{
"timestep": 96,
"hourly": 24,
"daily": 1,
"monthly": 1,
"run_period": 1
}[frequency],
len(df)
)
def test_set_record_wrong_type(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
def set_field():
idf.building.one().north_axis = "I'm a text, not a real"
self.assertRaises(ValueError, set_field)
def test_err(self):
for eplus_version in iter_eplus_versions(self):
version_str = "-".join([str(v) for v in eplus_version])
s = Simulation(
os.path.join(
Resources.SimulationsOutputs.one_zone_uncontrolled,
version_str))
self.assertIsNotNone(s.get_out_err())
def test_set_record_broken_constructing_mode(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
supply_fan = idf.Fan_ConstantVolume.one(lambda x: x.name == "supply fan")
name = supply_fan.availability_schedule_name.name
with self.assertRaises(BrokenEpmError):
with idf.is_under_construction():
supply_fan.availability_schedule_name = schedule_test_record_str % name
def test_set_record_broken(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
supply_fan = idf.Fan_ConstantVolume.one(lambda x: x.name == "supply fan")
name = supply_fan.availability_schedule_name.name
def raise_if_you_care():
supply_fan.availability_schedule_name = schedule_test_record_str % name
self.assertRaises(BrokenEpmError, raise_if_you_care)
def test_copy_record(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
old_name = "system availability schedule"
old = idf.Schedule_Compact.one(lambda x: x.name == old_name)
new = old.copy()
new_name = old_name + "- new"
new.name = new_name
self.assertNotEqual(old, new)
def test_err(self):
for eplus_version in iter_eplus_versions(self):
version_str = "-".join([str(v) for v in eplus_version])
s = Simulation(os.path.join(
RESOURCES_DIR_PATH,
"simulations-outputs",
"one_zone_uncontrolled",
version_str
))
self.assertIsNotNone(s.err)
def test_multiple_branch_links(self):
for _ in iter_eplus_versions(self):
idf = Epm(
os.path.join(CONF.eplus_base_dir_path, "ExampleFiles",
"5ZoneAirCooled.idf"))
bl = idf.BranchList.one(
lambda x: x.name == "heating supply side branches")
b3 = idf.Branch.one(
lambda x: x.name == "heating supply bypass branch")
self.assertEqual(bl[3], b3)
def test_copy_record(self):
for _ in iter_eplus_versions(self):
idf_manager = self.get_idf_manager()
zone = idf_manager.get_table("Zone").one()
new = zone._.copy()
for i in range(zone._._dev_fields_nb):
if i == 0:
self.assertNotEqual(zone._._get_value(i), new._._get_value(i))
else:
self.assertEqual(zone._._get_value(i), new._._get_value(i))
def test_idf_remove_record(self):
for _ in iter_eplus_versions(self):
idf_manager = self.get_idf_manager()
sch_name = "NEW TEST SCHEDULE"
sch = idf_manager.add_records(schedule_test_record_str % sch_name)
idf_manager.remove_records(sch)
self.assertEqual(
len(idf_manager.get_table("Schedule:Compact").select(lambda x: x["name"] == sch_name)),
0
)
def test_pointed(self):
for eplus_version in iter_eplus_versions(self):
epm = self.epms_d[eplus_version]
bsd = epm.BuildingSurface_Detailed.one("zn001:wall001")
pointed = bsd.get_pointed_records()
self.assertEqual(2, len(pointed))
self.assertEqual("main zone", pointed.Zone.one().name)
self.assertEqual("r13wall", pointed.Construction.one().id)
def test_table_getattr(self):
for eplus_version in iter_eplus_versions(self):
ref = "BuildingSurface_Detailed"
# exact ref
bsd = self.epms_d[eplus_version].BuildingSurface_Detailed
self.assertEqual(bsd.get_ref(), ref)
# case insensitive ref
bsd = self.epms_d[eplus_version].BuILdINGsURFaCE_DETaILED
self.assertEqual(bsd.get_ref(), ref)
def test_summary_table(self):
for eplus_version in iter_eplus_versions(self):
base_dir_path = get_eplus_base_dir_path(eplus_version)
idf_path = os.path.join(base_dir_path, "ExampleFiles", "4ZoneWithShading_Simple_1.idf")
epw_path = os.path.join(base_dir_path, "WeatherData", "USA_CO_Golden-NREL.724666_TMY3.epw")
with tempfile.TemporaryDirectory() as temp_dir_path:
idf = Epm.load(idf_path)
idf.OutputControl_Table_Style.add({0: "Comma", 1: "JtoKWH"})
idf.Output_Table_SummaryReports.add({0: "AllSummary"})
s = simulate(idf, epw_path, temp_dir_path)
self.assertIsNotNone(s.get_out_summary_table())
def test_start_dt(self):
for eplus_version in iter_eplus_versions(self):
eplus_version_str = "-".join([str(v) for v in eplus_version])
simulation_path = os.path.join(
Resources.SimulationsOutputs.one_zone_uncontrolled,
eplus_version_str)
s = Simulation(simulation_path)
start_dt = dt.datetime(2000, 1, 1)
self.assertEqual(
dt.datetime(2000, 1, 1, 1),
s.eso.get_df(time_step="Hourly", start=start_dt).index[0])
def test_check_length(self):
for _ in iter_eplus_versions(self):
# without check
epm = op.Epm(check_length=False)
# add big zone
epm.zone.add(dict(name="a" * 500))
# with check
epm = op.Epm()
self.assertRaises(op.FieldValidationError, epm.zone.add,
dict(name="a" * 500))
def test_qs_select(self):
for eplus_version in iter_eplus_versions(self):
epm = self.epms_d[eplus_version]
# get all building surfaces that have a zone with Z-Origin 0
simple_filter_l = [bsd for bsd in epm.BuildingSurface_Detailed if bsd.zone_name[4] == 0]
multi_filter_l = list(
epm.BuildingSurface_Detailed.select(
lambda x: x.zone_name[4] == 0
)
)
self.assertEqual(simple_filter_l, multi_filter_l)
def test_idf_remove_record(self):
for _ in iter_eplus_versions(self):
idf = self.get_epm()
sch_name = "NEW TEST SCHEDULE"
sch = idf.add_from_string(schedule_test_record_str % sch_name)
idf.remove(sch)
# check removed
self.assertEqual(len(idf.Schedule_Compact.select(lambda x: x.name == sch_name)), 0)
# check obsolete
self.assertRaises(ObsoleteRecordError, lambda: print(sch))
def test_simulate(self):
for eplus_version in iter_eplus_versions(self):
# prepare paths
idf_path = os.path.join(
get_eplus_base_dir_path(eplus_version),
"ExampleFiles",
"1ZoneEvapCooler.idf"
)
epw_path = os.path.join(
get_eplus_base_dir_path(eplus_version),
"WeatherData",
"USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw"
)
# prepare a quick simulation
idf = Epm.load(idf_path)
sc = idf.SimulationControl.one()
sc.run_simulation_for_sizing_periods = "No"
rp = idf.RunPeriod.one()
rp.end_month = 1
rp.end_day_of_month = 1
# prepare outputs
all_messages = []
def print_fct(message):
all_messages.append(message)
# simulate
with tempfile.TemporaryDirectory() as dir_path:
s = simulate(
idf,
epw_path,
dir_path,
print_function=print_fct,
beat_freq=0.1
)
# check one day output
eso_df = s.get_out_eso().get_data()
self.assertEqual(24, len(eso_df))
# aggregate messages
complete_message = "\n".join(all_messages)
# check subprocess is still running
self.assertIn("subprocess is still running", complete_message)
# check stdout
without_subprocess_message = complete_message.replace("subprocess is still running\n", "")
self.assertGreater(len(without_subprocess_message.split("\n")), 15) # check that more than 15 lines
