def test_cache_on_filter(self):
for _ in iter_eplus_versions(self):
# load idf
idf = self.get_idf()
# check that cache is empty
nb = len(idf._.cache)
self.assertEqual(0, nb)
# perform request
idf["Schedule:Compact"].one(
lambda x: x["name"] == "system availability schedule")
nb = len(idf._.cache)
# check cache went up, and hits are 0
self.assertTrue(nb > 0)
self.assertEqual([0] * nb,
[v["hits"] for v in idf._.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._.cache))
self.assertEqual([1] * nb,
[v["hits"] for v in idf._.cache.values()])
# clear
idf.clear_cache()
# check cache was cleared
self.assertEqual(0, len(idf._.cache))
def test_idf_add_record(self):
for _ in iter_eplus_versions(self):
idf_manager = self.get_idf_manager()
sch_name = "NEW TEST SCHEDULE"
new_record = idf_manager.add_records(schedule_test_record_str %
sch_name)
self.assertEqual(new_record._.idf_manager, idf_manager)
def test_pop_middle(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
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_str())
# 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_str())
def test_pointing_links_l(self):
for eplus_version in iter_eplus_versions(self):
zone = self.idf_managers_d[eplus_version].get_table("Zone").one()
d = { # ref: [pointing_index, nb of records], ...
"BuildingSurface:Detailed": [3, 6], # index 3
"ZoneInfiltration:DesignFlowRate": [1, 1], # index 1
"ZoneHVAC:EquipmentConnections": [0, 1], # index 0
"ZoneControl:Thermostat": [1, 1] # index 1
}
# check all pointing
_d = {}
for pointing_record, pointing_index in zone._.get_pointing_links():
# check points
self.assertEqual(pointing_record._.get_value(pointing_index),
zone)
# verify all are identified
if pointing_record._.table.ref not in _d:
_d[pointing_record._.table.ref] = [pointing_index, 1]
else:
self.assertEqual(pointing_index,
_d[pointing_record._.table.ref][0])
_d[pointing_record._.table.ref][1] += 1
self.assertEqual(d, _d)
# check pointing on pointed_index
self.assertEqual(len(zone._.get_pointing_links(0)),
9) # 9 pointing
self.assertEqual(len(zone._.get_pointing_links(3)),
0) # no pointing
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_idf_unlink_and_remove(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
zone = idf["Zone"].one()
zone.unlink_pointing_records()
idf.remove(zone)
self.assertEqual(len(idf["Zone"].select()), 0)
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_DIR_PATH,
"simulations-outputs",
"one_zone_uncontrolled",
version_str
))
eio = s.eio
self.assertEqual(
float(eio.df("Site:GroundReflectance:SnowModifier").loc[0, "Normal"]),
1
)
df = eio.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_pop_end(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
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_extensible(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
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_qs_one(self):
for eplus_version in iter_eplus_versions(self):
idf = self.idf_managers_d[eplus_version]
obj = idf.get_table("BuildingSurface:Detailed").one(
lambda x: x["naMe"] == "zn001:roof001")
name = obj._.get_value("name")
self.assertEqual("zn001:roof001", name)
def test_set_record_wrong_type(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
def set_field():
idf["Building"].one()["North Axis"] = "I'm a text, not a real"
self.assertRaises(ValueError, set_field)
def test_idf_add_record(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
sch_name = "new test schedule"
idf.add(schedule_test_record_str % sch_name)
self.assertEqual(
idf["Schedule:Compact"].one(lambda x: x["name"] == sch_name)
["name"], sch_name)
def test_copy_record(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
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_multiple_branch_links(self):
for _ in iter_eplus_versions(self):
idf = Idf(
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_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_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._.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_set_record_broken_constructing_mode(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
supply_fan = idf["Fan:ConstantVolume"].one(
lambda x: x["name"] == "supply fan")
name = supply_fan["availability schedule name"]["name"]
with self.assertRaises(BrokenIdfError):
with idf.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_idf()
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(BrokenIdfError, raise_if_you_care)
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_DIR_PATH,
"simulations-outputs",
"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.df(time_step="Hourly", start=start_dt).index[0])
def test_multi_level_filter(self):
for eplus_version in iter_eplus_versions(self):
# get all building surfaces that have a zone with Z-Origin 0
simple_filter_l = []
for bsd in self.idfs_d[eplus_version][
"BuildingSurface:Detailed"].select():
if bsd["Zone name"][4] == 0:
simple_filter_l.append(bsd)
multi_filter_l = list(
self.idfs_d[eplus_version]["BuildingSurface:Detailed"].select(
lambda x: x["Zone Name"][4] == 0))
self.assertEqual(simple_filter_l, multi_filter_l)
def test_set_record_simple(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
new_name = "fan availability schedule - 2"
supply_fan = idf["Fan:ConstantVolume"].one(
lambda x: x["name"] == "supply fan")
supply_fan[
"availability schedule name"] = schedule_test_record_str % new_name
# check set
self.assertEqual(
idf["Fan:ConstantVolume"].one(
lambda x: x["name"] == "supply fan")
["AvaiLABIlity schedule name"]["name"], new_name)
def test_pointing_records(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
zone = idf["Zone"].one()
self.assertEqual(
{
"zn001:wall001", "zn001:wall002", "zn001:wall003",
"zn001:wall004", "zn001:flr001", "zn001:roof001"
},
set([
bsd["name"] for bsd in zone.pointing_records.select(
lambda x: x.table.ref == "BuildingSurface:Detailed")
]))
def test_idf_remove_record(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
sch_name = "NEW TEST SCHEDULE"
sch = idf.add(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_idf_add_record_broken(self):
for _ in iter_eplus_versions(self):
idf_manager = self.get_idf_manager()
self.assertRaises(
BrokenIdfError, lambda: idf_manager.add_records("""Material,
C5 - 4 IN HW CONCRETE, !- Name
MediumRough, !- Roughness
0.1014984, !- Thickness {m}
1.729577, !- Conductivity {W/m-K}
2242.585, !- Density {kg/m3}
836.8000, !- Specific Heat {J/kg-K}
0.9000000, !- Thermal Absorptance
0.6500000, !- Solar Absorptance
0.6500000; !- Visible Absorptance"""))
def test_pointed_records(self):
for _ in iter_eplus_versions(self):
idf = self.get_idf()
bsd = idf["BuildingSurface:Detailed"].one(
lambda x: x["name"] == "zn001:wall001")
zone = idf["Zone"].one(lambda x: x["name"] == "main zone")
construction = idf["Construction"].one(
lambda x: x["name"] == "r13wall")
# single pointing field
self.assertEqual(bsd["zone name"], zone)
self.assertEqual(bsd[3], zone)
# get all pointed
self.assertEqual({zone, construction}, set(bsd.pointed_records))
def test_idf_unlink_and_remove_record(self):
for _ in iter_eplus_versions(self):
idf_manager = self.get_idf_manager()
zone = idf_manager.get_table("Zone").one()
# unlink
zone.unlink_pointing_records()
# check that pointing's pointed fields have been removed
for pointing_record, pointing_index in zone._.get_pointing_links():
self.assertEqual(pointing_record._.get_value(pointing_index),
None)
# remove record should be possible
idf_manager.remove_records(zone)
def test_simulate(self):
for eplus_version in iter_eplus_versions(self):
# prepare paths
idf_path = os.path.join(CONF.eplus_base_dir_path, "ExampleFiles",
"1ZoneEvapCooler.idf")
epw_path = os.path.join(
CONF.eplus_base_dir_path, "WeatherData",
"USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw")
# prepare a quick simulation
idf = Idf(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
out_f = io.StringIO()
err_f = io.StringIO()
# simulate
with tempfile.TemporaryDirectory() as dir_path:
s = simulate(idf,
epw_path,
dir_path,
stdout=out_f,
stderr=err_f,
beat_freq=0.1)
# check one day output
eso_df = s.eso.df()
self.assertEqual(24, len(eso_df))
# check err (manage differences between eplus versions)
err_out = err_f.getvalue()
self.assertTrue(
(err_out == "")
or ("EnergyPlus Completed Successfully.\n" in err_out))
# check beat
out_str = out_f.getvalue()
self.assertIn("subprocess is still running", out_str)
# check stdout
out_str = out_str.replace("subprocess is still running\n", "")
self.assertGreater(len(out_str.split("\n")),
15) # check that more than 15 lines
def test_df_get_and_set_integrity(self):
for _ in iter_eplus_versions(self):
weather_dir = os.path.join(CONF.eplus_base_dir_path, "WeatherData")
# check sf
epw = Epw(
os.path.join(weather_dir,
"USA_CA_San.Francisco.Intl.AP.724940_TMY3.epw"))
# read
df = epw.df()
# write
epw.set_df(df)
# check
assert_frame_equal(df, epw.df())
def test_set_value_reference(self):
for _ in iter_eplus_versions(self):
idf_manager = self.get_idf_manager()
# set
new_zone_name = "new zone name"
zone = idf_manager.get_table("Zone").one()
pointing_links_l = zone._.get_pointing_links()
zone._.set_value("name", new_zone_name)
# check
self.assertEqual(zone._.get_value("name"), new_zone_name)
# check pointing
for pointing_record, pointing_index in pointing_links_l:
self.assertEqual(
pointing_record._.get_raw_value(pointing_index),
new_zone_name)
def test_set_value_record(self):
for _ in iter_eplus_versions(self):
idf_manager = self.get_idf_manager()
# set
new_name = "fan availability schedule - 2"
supply_fan = idf_manager.get_table("Fan:ConstantVolume").one(
lambda x: x["name"] == "supply fan")
supply_fan._.set_value("availability schedule name",
schedule_test_record_str % new_name)
print(idf_manager.to_str())
# get
obj = idf_manager.get_table("Fan:ConstantVolume").one(
lambda x: x["name"] == "supply fan")
name = obj._.get_value("AvaiLABIlity schedule name")._.get_value(
"NAME")
# check
self.assertEqual(new_name, name)
