def custom_sim_par(ddy_file, output_names, run_period_json, filter_des_days,
output_file):
"""Get a SimulationParameter JSON with outputs for thermal load balances.
\n
Args:
ddy_file: Full path to a DDY file that will be used to specify design days
within the simulation parameter.
output_names: A list of EnergyPlus output names as strings (eg.
'Surface Window System Solar Transmittance'. These outputs will be
requested from the simulation.
"""
try:
assert os.path.isfile(ddy_file), 'No DDY file found at {}.'.format(
ddy_file)
sim_par = SimulationParameter()
for output_name in output_names:
sim_par.output.add_output(output_name)
if run_period_json:
assert os.path.isfile(run_period_json), \
'No run period JSON file found at {}.'.format(run_period_json)
with open(run_period_json) as json_file:
data = json.load(json_file)
sim_par.run_period = RunPeriod.from_dict(data)
if filter_des_days:
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
else:
sim_par.sizing_parameter.add_from_ddy(ddy_file)
output_file.write(json.dumps(sim_par.to_dict()))
except Exception as e:
_logger.exception(
'Failed to generate simulation parameter.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def load_balance_sim_par(ddy_file, load_type, run_period_json, filter_des_days,
output_file):
"""Get a SimulationParameter JSON with outputs for thermal load balances.
\n
Args:
ddy_file: Full path to a DDY file that will be used to specify design days
within the simulation parameter.
"""
try:
assert os.path.isfile(ddy_file), 'No DDY file found at {}.'.format(
ddy_file)
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use(load_type)
gl_load_type = load_type if load_type != 'All' else 'Total'
sim_par.output.add_gains_and_losses(gl_load_type)
sim_par.output.add_surface_energy_flow()
if run_period_json:
assert os.path.isfile(run_period_json), \
'No run period JSON file found at {}.'.format(run_period_json)
with open(run_period_json) as json_file:
data = json.load(json_file)
sim_par.run_period = RunPeriod.from_dict(data)
if filter_des_days:
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
else:
sim_par.sizing_parameter.add_from_ddy(ddy_file)
output_file.write(json.dumps(sim_par.to_dict()))
except Exception as e:
_logger.exception(
'Failed to generate simulation parameter.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def default_sim_par(ddy_file, run_period_json, filter_des_days, output_file):
"""Get a SimulationParameter JSON with default outputs for energy use only.
\n
Args:
ddy_file: Full path to a DDY file that will be used to specify design days
within the simulation parameter.
"""
try:
assert os.path.isfile(ddy_file), 'No DDY file found at {}.'.format(
ddy_file)
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
sim_par.output.add_hvac_energy_use()
if run_period_json:
assert os.path.isfile(run_period_json), \
'No run period JSON file found at {}.'.format(run_period_json)
with open(run_period_json) as json_file:
data = json.load(json_file)
sim_par.run_period = RunPeriod.from_dict(data)
if filter_des_days:
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
else:
sim_par.sizing_parameter.add_from_ddy(ddy_file)
output_file.write(json.dumps(sim_par.to_dict()))
except Exception as e:
_logger.exception(
'Failed to generate simulation parameter.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def validate_sim_par(sim_par_json):
"""Validate all properties of a SimulationParameter JSON against the Honeybee schema.
\b
Args:
sim_par_json: Full path to a SimulationParameter JSON file.
"""
try:
# first check the JSON against the OpenAPI specification
click.echo('Validating SimulationParameter JSON ...')
schema_simulation_parameter.SimulationParameter.parse_file(
sim_par_json)
click.echo('Pydantic validation passed.')
# re-serialize to make sure no errors are found in re-serialization
with open(sim_par_json) as json_file:
data = json.load(json_file)
SimulationParameter.from_dict(data)
click.echo('Python re-serialization passed.')
# if we made it to this point, report that the object is valid
click.echo('Congratulations! Your SimulationParameter JSON is valid!')
except Exception as e:
_logger.exception(
'SimulationParameter validation failed.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_run_idf():
"""Test the prepare_idf_for_simulation and run_idf methods."""
# Get input Model
room = Room.from_box('TinyHouseZone', 5, 10, 3)
room.properties.energy.program_type = office_program
room.properties.energy.add_default_ideal_air()
model = Model('TinyHouse', [room])
# Get the input SimulationParameter
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
ddy_file = './tests/ddy/chicago.ddy'
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
sim_par.run_period.end_date = Date(1, 7)
# create the IDF string for simulation paramters and model
idf_str = '\n\n'.join((sim_par.to_idf(), model.to.idf(model)))
# write the final string into an IDF
idf = os.path.join(folders.default_simulation_folder, 'test_file',
'in.idf')
write_to_file(idf, idf_str, True)
# prepare the IDF for simulation
epw_file = './tests/simulation/chicago.epw'
prepare_idf_for_simulation(idf, epw_file)
# run the IDF through EnergyPlus
sql, zsz, rdd, html, err = run_idf(idf, epw_file)
assert os.path.isfile(sql)
assert os.path.isfile(err)
err_obj = Err(err)
assert 'EnergyPlus Completed Successfully' in err_obj.file_contents
def custom_sim_par(ddy_file, output_names, run_period, north, filter_des_days,
output_file):
"""Get a SimulationParameter JSON with an option for custom outputs.
\b
Args:
ddy_file: Full path to a DDY file that will be used to specify design days
within the simulation parameter.
output_names: Any number of EnergyPlus output names as strings (eg.
'Surface Window System Solar Transmittance'. These outputs will be
requested from the simulation.
"""
try:
sim_par = SimulationParameter()
for output_name in output_names:
sim_par.output.add_output(output_name)
_apply_run_period(run_period, sim_par)
sim_par.north_angle = north
_apply_design_days(ddy_file, filter_des_days, sim_par)
output_file.write(json.dumps(sim_par.to_dict()))
except Exception as e:
_logger.exception(
'Failed to generate simulation parameter.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_run_idf_5vertex():
"""Test the run_idf methods with 5-vertex apertures."""
# Get input Model
input_hb_model = './tests/json/model_colinear_verts.json'
with open(input_hb_model) as json_file:
data = json.load(json_file)
model = Model.from_dict(data)
# Get the input SimulationParameter
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
ddy_file = './tests/ddy/chicago.ddy'
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
sim_par.run_period.end_date = Date(1, 7)
# create the IDF string for simulation paramters and model
idf_str = '\n\n'.join((sim_par.to_idf(), model.to.idf(model)))
# write the final string into an IDF
idf = os.path.join(folders.default_simulation_folder, 'test_file_5verts',
'in.idf')
write_to_file(idf, idf_str, True)
# prepare the IDF for simulation
epw_file = './tests/simulation/chicago.epw'
prepare_idf_for_simulation(idf, epw_file)
# run the IDF through EnergyPlus
sql, zsz, rdd, html, err = run_idf(idf, epw_file)
assert os.path.isfile(sql)
assert os.path.isfile(err)
err_obj = Err(err)
assert 'EnergyPlus Completed Successfully' in err_obj.file_contents
def sizing_sim_par(ddy_file, load_type, north, filter_des_days, output_file):
"""Get a SimulationParameter JSON with outputs and run period for HVAC sizing.
\b
Args:
ddy_file: Full path to a DDY file that will be used to specify design days
within the simulation parameter.
"""
try:
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use(load_type)
gl_load_type = load_type if load_type != 'All' else 'Total'
sim_par.output.add_gains_and_losses(gl_load_type)
sim_par.output.add_surface_energy_flow()
sim_par.simulation_control = SimulationControl(True, True, True, True,
False)
sim_par.north_angle = north
_apply_design_days(ddy_file, filter_des_days, sim_par)
output_file.write(json.dumps(sim_par.to_dict()))
except Exception as e:
_logger.exception(
'Failed to generate simulation parameter.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_simulation_parameter_setability():
"""Test the setting of properties of SimulationParameter."""
sim_par = SimulationParameter()
output = SimulationOutput()
output.add_zone_energy_use()
sim_par.output = output
assert sim_par.output == output
run_period = RunPeriod(Date(1, 1), Date(6, 21))
sim_par.run_period = run_period
assert sim_par.run_period == run_period
sim_par.timestep = 4
assert sim_par.timestep == 4
sim_control_alt = SimulationControl(run_for_sizing_periods=True,
run_for_run_periods=False)
sim_par.simulation_control = sim_control_alt
assert sim_par.simulation_control == sim_control_alt
shadow_calc_alt = ShadowCalculation('FullExteriorWithReflections')
sim_par.shadow_calculation = shadow_calc_alt
assert sim_par.shadow_calculation == shadow_calc_alt
sizing_alt = SizingParameter(None, 1, 1)
relative_path = './tests/ddy/chicago_monthly.ddy'
sizing_alt.add_from_ddy(relative_path)
sim_par.sizing_parameter = sizing_alt
assert sim_par.sizing_parameter == sizing_alt
sim_par.north_angle = 20
assert sim_par.north_angle == 20
sim_par.terrain_type = 'Ocean'
assert sim_par.terrain_type == 'Ocean'
def orientation_sim_pars(ddy_file, north_angles, output_name, run_period,
start_north, filter_des_days, folder, log_file):
"""Get SimulationParameter JSONs with different north angles for orientation studies.
\b
Args:
ddy_file: Full path to a DDY file that will be used to specify design days
within the simulation parameter.
north_angles: Any number of values between -360 and 360 for the counterclockwise
difference between the North and the positive Y-axis in degrees. 90 is
West and 270 is East.
"""
try:
# get a default folder if none was specified
if folder is None:
folder = os.path.join(folders.default_simulation_folder,
'orientation_study')
preparedir(folder, remove_content=False)
# create a base set of simulation parameters to be edited parametrically
sim_par = SimulationParameter()
for out_name in output_name:
sim_par.output.add_output(out_name)
_apply_run_period(run_period, sim_par)
_apply_design_days(ddy_file, filter_des_days, sim_par)
# shift all of the north angles by the start_north if specified
if start_north != 0:
north_angles = [angle + start_north for angle in north_angles]
for i, angle in enumerate(north_angles):
angle = angle - 360 if angle > 360 else angle
angle = angle + 360 if angle < -360 else angle
north_angles[i] = angle
# loop through the north angles and write a simulation parameter for each
json_files = []
for angle in north_angles:
sim_par.north_angle = angle
base_name = 'sim_par_north_{}'.format(int(angle))
file_name = '{}.json'.format(base_name)
file_path = os.path.join(folder, file_name)
with open(file_path, 'w') as fp:
json.dump(sim_par.to_dict(), fp)
sp_info = {
'id': base_name,
'path': file_name,
'full_path': os.path.abspath(file_path)
}
json_files.append(sp_info)
log_file.write(json.dumps(json_files))
except Exception as e:
_logger.exception(
'Failed to generate simulation parameters.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def simulation_par_detailed(directory):
sim_par = SimulationParameter()
output = SimulationOutput()
output.add_zone_energy_use()
output.include_html = True
output.reporting_frequency = 'Daily'
output.add_summary_report('Annual Building Utility Performance Summary')
output.add_summary_report('Climatic Data Summary')
output.add_summary_report('Envelope Summary')
sim_par.output = output
run_period = RunPeriod(Date(1, 1), Date(6, 21))
run_period.daylight_saving_time = DaylightSavingTime(Date(3, 12), Date(11, 5))
run_period.start_day_of_week = 'Monday'
run_period.holidays = [Date(1, 1), Date(3, 17), Date(7, 4)]
sim_par.run_period = run_period
sim_par.timestep = 4
sim_control_alt = SimulationControl(run_for_sizing_periods=True,
run_for_run_periods=False)
sim_par.simulation_control = sim_control_alt
shadow_calc_alt = ShadowCalculation(
solar_distribution='FullInteriorAndExteriorWithReflections',
calculation_method='PixelCounting', calculation_update_method='Timestep')
sim_par.shadow_calculation = shadow_calc_alt
sizing_alt = SizingParameter(None, 1, 1)
relative_path = './scripts/ddy/chicago.ddy'
sizing_alt.add_from_ddy_996_004(relative_path)
sim_par.sizing_parameter = sizing_alt
dest_file = os.path.join(directory, 'simulation_par_detailed.json')
with open(dest_file, 'w') as fp:
json.dump(sim_par.to_dict(), fp, indent=4)
def test_simulation_parameter_to_dict_detailed():
"""Test the to_dict method with a detailed SimulationParameter."""
sim_par = SimulationParameter()
output = SimulationOutput()
output.add_zone_energy_use()
output.include_html = True
output.reporting_frequency = 'Daily'
output.add_summary_report('Annual Building Utility Performance Summary')
output.add_summary_report('Climatic Data Summary')
output.add_summary_report('Envelope Summary')
sim_par.output = output
run_period = RunPeriod(Date(1, 1), Date(6, 21))
run_period.daylight_saving_time = DaylightSavingTime(
Date(3, 12), Date(11, 5))
run_period.start_day_of_week = 'Monday'
run_period.holidays = [Date(1, 1), Date(3, 17), Date(7, 4)]
sim_par.run_period = run_period
sim_par.timestep = 4
sim_control_alt = SimulationControl(run_for_sizing_periods=True,
run_for_run_periods=False)
sim_par.simulation_control = sim_control_alt
shadow_calc_alt = ShadowCalculation(calculation_frequency=20)
sim_par.shadow_calculation = shadow_calc_alt
sizing_alt = SizingParameter(None, 1, 1)
relative_path = './tests/ddy/chicago.ddy'
sizing_alt.add_from_ddy_996_004(relative_path)
sim_par.sizing_parameter = sizing_alt
sim_par_dict = sim_par.to_dict()
assert 'outputs' in sim_par_dict['output']
assert 'holidays' in sim_par_dict['run_period']
assert 'daylight_saving_time' in sim_par_dict['run_period']
assert 'design_days' in sim_par_dict['sizing_parameter']
def test_simulation_parameter_to_dict_simple():
"""Test the to_dict method with a simple SimulationParameter."""
sim_par = SimulationParameter()
sim_par_dict = sim_par.to_dict()
assert 'output' in sim_par_dict
assert 'run_period' in sim_par_dict
assert 'timestep' in sim_par_dict
assert 'simulation_control' in sim_par_dict
assert 'shadow_calculation' in sim_par_dict
assert 'sizing_parameter' in sim_par_dict
def test_run_idf_window_ventilation():
"""Test the Model.to.idf and run_idf method with a model possessing operable windows."""
room = Room.from_box('TinyHouseZone', 5, 10, 3)
room.properties.energy.add_default_ideal_air()
south_face = room[3]
north_face = room[1]
south_face.apertures_by_ratio(0.4, 0.01)
north_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].is_operable = True
north_face.apertures[0].is_operable = True
heat_setpt = ScheduleRuleset.from_constant_value(
'House Heating', 20, schedule_types.temperature)
cool_setpt = ScheduleRuleset.from_constant_value(
'House Cooling', 28, schedule_types.temperature)
setpoint = Setpoint('House Setpoint', heat_setpt, cool_setpt)
room.properties.energy.setpoint = setpoint
vent_control = VentilationControl(22, 27, 12, 30)
room.properties.energy.window_vent_control = vent_control
ventilation = VentilationOpening(wind_cross_vent=True)
op_aps = room.properties.energy.assign_ventilation_opening(ventilation)
assert len(op_aps) == 2
model = Model('TinyHouse', [room])
# Get the input SimulationParameter
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
ddy_file = './tests/ddy/chicago.ddy'
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
sim_par.run_period.end_date = Date(6, 7)
sim_par.run_period.start_date = Date(6, 1)
# create the IDF string for simulation paramters and model
idf_str = '\n\n'.join((sim_par.to_idf(), model.to.idf(model)))
# write the final string into an IDF
idf = os.path.join(folders.default_simulation_folder,
'test_file_window_vent', 'in.idf')
write_to_file(idf, idf_str, True)
# prepare the IDF for simulation
epw_file = './tests/simulation/chicago.epw'
prepare_idf_for_simulation(idf, epw_file)
# run the IDF through EnergyPlus
sql, zsz, rdd, html, err = run_idf(idf, epw_file)
assert os.path.isfile(sql)
assert os.path.isfile(err)
err_obj = Err(err)
assert 'EnergyPlus Completed Successfully' in err_obj.file_contents
def test_run_idf_window_shade():
"""Test the Model.to.idf and run_idf method with a model that has a window shade."""
# Get input Model
room = Room.from_box('TinyHouseZone', 5, 10, 3)
room.properties.energy.program_type = office_program
room.properties.energy.add_default_ideal_air()
double_clear = WindowConstruction('Double Pane Clear',
[clear_glass, air_gap, clear_glass])
shade_mat = EnergyWindowMaterialShade('Low-e Diffusing Shade', 0.005, 0.15,
0.5, 0.25, 0.5, 0, 0.4, 0.2, 0.1,
0.75, 0.25)
sched = ScheduleRuleset.from_daily_values('NighSched', [
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1
])
double_ec = WindowConstructionShade('Double Low-E Inside EC', double_clear,
shade_mat, 'Interior',
'OnIfHighSolarOnWindow', 200, sched)
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
south_face.apertures[0].properties.energy.construction = double_ec
north_face = room[1]
north_face.apertures_by_ratio(0.4, 0.01)
model = Model('TinyHouse', [room])
# Get the input SimulationParameter
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
ddy_file = './tests/ddy/chicago.ddy'
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
sim_par.run_period.end_date = Date(1, 7)
# create the IDF string for simulation paramters and model
idf_str = '\n\n'.join((sim_par.to_idf(), model.to.idf(model)))
# write the final string into an IDF
idf = os.path.join(folders.default_simulation_folder, 'test_file_shd',
'in.idf')
write_to_file(idf, idf_str, True)
# prepare the IDF for simulation
epw_file = './tests/simulation/chicago.epw'
prepare_idf_for_simulation(idf, epw_file)
# run the IDF through EnergyPlus
sql, zsz, rdd, html, err = run_idf(idf, epw_file)
assert os.path.isfile(sql)
assert os.path.isfile(err)
err_obj = Err(err)
assert 'EnergyPlus Completed Successfully' in err_obj.file_contents
def test_simulation_parameter_equality():
"""Test the equality of SimulationParameter objects."""
sim_par = SimulationParameter()
sim_par_dup = sim_par.duplicate()
sim_par_alt = SimulationParameter(timestep=4)
assert sim_par is sim_par
assert sim_par is not sim_par_dup
assert sim_par == sim_par_dup
sim_par_dup.timestep = 12
assert sim_par != sim_par_dup
assert sim_par != sim_par_alt
def model_to_osm(model_json, sim_par_json, folder, check_model, log_file):
"""Translate a Model JSON file into an OpenStudio Model and corresponding IDF.
\n
Args:
model_json: Full path to a Model JSON file.
"""
try:
# check that the model JSON is there
assert os.path.isfile(model_json), \
'No Model JSON file found at {}.'.format(model_json)
# set the default folder if it's not specified
if folder is None:
folder = os.path.dirname(os.path.abspath(model_json))
# check that the simulation parameters are there
if sim_par_json is not None:
assert os.path.isfile(sim_par_json), \
'No simulation parameter file found at {}.'.format(sim_par_json)
else:
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
sim_par.output.add_hvac_energy_use()
sim_par_dict = sim_par.to_dict()
sp_json = os.path.abspath(
os.path.join(folder, 'simulation_parameter.json'))
with open(sp_json, 'w') as fp:
json.dump(sim_par_dict, fp)
# run the Model re-serialization and check if specified
if check_model:
model_json = measure_compatible_model_json(model_json, folder)
# Write the osw file to translate the model to osm
osw = to_openstudio_osw(folder, model_json, sim_par_json)
# run the measure to translate the model JSON to an openstudio measure
if osw is not None and os.path.isfile(osw):
osm, idf = run_osw(osw)
# run the resulting idf through EnergyPlus
if idf is not None and os.path.isfile(idf):
log_file.write(json.dumps([osm, idf]))
else:
raise Exception('Running OpenStudio CLI failed.')
else:
raise Exception('Writing OSW file failed.')
except Exception as e:
_logger.exception('Model translation failed.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def model_to_idf(model_json, sim_par_json, additional_str, output_file):
"""Translate a Model JSON file to an IDF using direct-to-idf translators.
\n
The resulting IDF should be simulate-able but not all Model properties might
make it into the IDF given that the direct-to-idf translators are used.
\n
Args:
model_json: Full path to a Model JSON file.
"""
try:
# check that the model JSON is there
assert os.path.isfile(model_json), \
'No Model JSON file found at {}.'.format(model_json)
# check that the simulation parameters are there and load them
if sim_par_json is not None:
assert os.path.isfile(sim_par_json), \
'No simulation parameter file found at {}.'.format(sim_par_json)
with open(sim_par_json) as json_file:
data = json.load(json_file)
sim_par = SimulationParameter.from_dict(data)
else:
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
sim_par.output.add_hvac_energy_use()
# re-serialize the Model to Python
with open(model_json) as json_file:
data = json.load(json_file)
model = Model.from_dict(data)
# set the schedule directory in case it is needed
sch_path = os.path.abspath(model_json) if 'stdout' in str(output_file) \
else os.path.abspath(str(output_file))
sch_directory = os.path.join(os.path.split(sch_path)[0], 'schedules')
# create the strings for simulation paramters and model
ver_str = energyplus_idf_version() if folders.energyplus_version \
is not None else energyplus_idf_version((9, 2, 0))
sim_par_str = sim_par.to_idf()
model_str = model.to.idf(model, schedule_directory=sch_directory)
idf_str = '\n\n'.join(
[ver_str, sim_par_str, model_str, additional_str])
# write out the IDF file
output_file.write(idf_str)
except Exception as e:
_logger.exception('Model translation failed.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def dict_to_simulation(sim_dict, raise_exception=True):
"""Get a Python object of any Simulation object from a dictionary.
Args:
sim_dict: A dictionary of any Honeybee energy simulation object. Note
that this should be a non-abridged dictionary to be valid.
raise_exception: Boolean to note whether an excpetion should be raised
if the object is not identified as a simulation object. Default: True.
Returns:
A Python object derived from the input sim_dict.
"""
try: # get the type key from the dictionary
sim_type = sim_dict['type']
except KeyError:
raise ValueError('Simulation dictionary lacks required "type" key.')
if sim_type == 'SimulationControl':
return SimulationControl.from_dict(sim_dict)
elif sim_type == 'RunPeriod':
return RunPeriod.from_dict(sim_dict)
elif sim_type == 'DaylightSavingTime':
return DaylightSavingTime.from_dict(sim_dict)
elif sim_type == 'ShadowCalculation':
return ShadowCalculation.from_dict(sim_dict)
elif sim_type == 'SizingParameter':
return SizingParameter.from_dict(sim_dict)
elif sim_type == 'SimulationOutput':
return SimulationOutput.from_dict(sim_dict)
elif sim_type == 'SimulationParameter':
return SimulationParameter.from_dict(sim_dict)
elif raise_exception:
raise ValueError(
'{} is not a recognized energy Simulation type'.format(sim_type))
def model_to_idf(model_json, sim_par_json, additional_str, output_file):
"""Translate a Model JSON file to an IDF using direct-to-idf translators.
If the model contains a feature that is not translate-able through direct-to-idf
translators, an exception will be raised.
\b
Args:
model_json: Full path to a Model JSON file.
"""
try:
# load simulation parameters or generate default ones
if sim_par_json is not None:
with open(sim_par_json) as json_file:
data = json.load(json_file)
sim_par = SimulationParameter.from_dict(data)
else:
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
sim_par.output.add_hvac_energy_use()
# re-serialize the Model to Python
with open(model_json) as json_file:
data = json.load(json_file)
model = Model.from_dict(data)
# set the schedule directory in case it is needed
sch_path = os.path.abspath(model_json) if 'stdout' in str(output_file) \
else os.path.abspath(str(output_file))
sch_directory = os.path.join(os.path.split(sch_path)[0], 'schedules')
# create the strings for simulation paramters and model
ver_str = energyplus_idf_version() if folders.energyplus_version \
is not None else ''
sim_par_str = sim_par.to_idf()
model_str = model.to.idf(model, schedule_directory=sch_directory)
idf_str = '\n\n'.join(
[ver_str, sim_par_str, model_str, additional_str])
# write out the IDF file
output_file.write(idf_str)
except Exception as e:
_logger.exception('Model translation failed.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_run_idf_daylight_control():
"""Test Model.to.idf and run_idf with a model possessing daylight controls."""
room = Room.from_box('TinyHouseZone', 5, 10, 3)
room.properties.energy.program_type = office_program
room.properties.energy.add_default_ideal_air()
south_face = room[3]
south_face.apertures_by_ratio(0.4, 0.01)
room.properties.energy.add_daylight_control_to_center(0.8, 500, 0.5)
sens_pt = room.properties.energy.daylighting_control.sensor_position
assert sens_pt.x == pytest.approx(2.5, rel=1e-3)
assert sens_pt.y == pytest.approx(5, rel=1e-3)
assert sens_pt.z == pytest.approx(0.8, rel=1e-3)
room.move(Vector3D(5, 5, 0))
assert room.properties.energy.daylighting_control.sensor_position == \
sens_pt.move(Vector3D(5, 5, 0))
model = Model('TinyHouse', [room])
# Get the input SimulationParameter
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
ddy_file = './tests/ddy/chicago.ddy'
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
sim_par.run_period.end_date = Date(6, 7)
sim_par.run_period.start_date = Date(6, 1)
# create the IDF string for simulation paramters and model
idf_str = '\n\n'.join((sim_par.to_idf(), model.to.idf(model)))
# write the final string into an IDF
idf = os.path.join(folders.default_simulation_folder, 'test_file_daylight',
'in.idf')
write_to_file(idf, idf_str, True)
# prepare the IDF for simulation
epw_file = './tests/simulation/chicago.epw'
prepare_idf_for_simulation(idf, epw_file)
# run the IDF through EnergyPlus
sql, zsz, rdd, html, err = run_idf(idf, epw_file)
assert os.path.isfile(sql)
assert os.path.isfile(err)
err_obj = Err(err)
assert 'EnergyPlus Completed Successfully' in err_obj.file_contents
def test_run_idf_hot_water():
"""Test the Model.to.idf and run_idf method with a model possessing hot water."""
# Get input Model
room = Room.from_box('TinyHouseZone', 5, 10, 3)
room.properties.energy.program_type = office_program
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)
room.properties.energy.service_hot_water = shw
room.properties.energy.add_default_ideal_air()
model = Model('TinyHouse', [room])
# Get the input SimulationParameter
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
ddy_file = './tests/ddy/chicago.ddy'
sim_par.sizing_parameter.add_from_ddy_996_004(ddy_file)
sim_par.run_period.end_date = Date(1, 7)
# create the IDF string for simulation paramters and model
idf_str = '\n\n'.join((sim_par.to_idf(), model.to.idf(model)))
# write the final string into an IDF
idf = os.path.join(folders.default_simulation_folder, 'test_file_shw',
'in.idf')
write_to_file(idf, idf_str, True)
# prepare the IDF for simulation
epw_file = './tests/simulation/chicago.epw'
prepare_idf_for_simulation(idf, epw_file)
# run the IDF through EnergyPlus
sql, zsz, rdd, html, err = run_idf(idf, epw_file)
assert os.path.isfile(sql)
assert os.path.isfile(err)
err_obj = Err(err)
assert 'EnergyPlus Completed Successfully' in err_obj.file_contents
def test_default_sim_par():
"""Test the default_sim_par command."""
runner = CliRunner()
ddy_path = './tests/ddy/chicago.ddy'
result = runner.invoke(default_sim_par, [ddy_path])
assert result.exit_code == 0
simpar_dict = json.loads(result.output)
sim_par = SimulationParameter.from_dict(simpar_dict)
assert 'Zone Ideal Loads Supply Air Total Cooling Energy' in sim_par.output.outputs
assert 'Chiller Electricity Energy' in sim_par.output.outputs
def test_comfort_sim_par():
"""Test the comfort_sim_par command."""
runner = CliRunner()
ddy_path = './tests/ddy/chicago.ddy'
result = runner.invoke(comfort_sim_par, [ddy_path])
assert result.exit_code == 0
simpar_dict = json.loads(result.output)
sim_par = SimulationParameter.from_dict(simpar_dict)
assert 'Zone Mean Air Temperature' in sim_par.output.outputs
assert 'Surface Inside Face Temperature' in sim_par.output.outputs
def test_custom_sim_par():
"""Test the custom_sim_par command."""
runner = CliRunner()
ddy_path = './tests/ddy/chicago.ddy'
result = runner.invoke(
custom_sim_par,
[ddy_path, 'Surface Window Transmitted Beam Solar Radiation Energy'])
assert result.exit_code == 0
simpar_dict = json.loads(result.output)
sim_par = SimulationParameter.from_dict(simpar_dict)
assert 'Surface Window Transmitted Beam Solar Radiation Energy' in sim_par.output.outputs
def default_sim_par(ddy_file, run_period, north, filter_des_days, output_file):
"""Get a SimulationParameter JSON with default outputs for energy use only.
\b
Args:
ddy_file: Full path to a DDY file that will be used to specify design days
within the simulation parameter.
"""
try:
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
sim_par.output.add_hvac_energy_use()
_apply_run_period(run_period, sim_par)
sim_par.north_angle = north
_apply_design_days(ddy_file, filter_des_days, sim_par)
output_file.write(json.dumps(sim_par.to_dict()))
except Exception as e:
_logger.exception(
'Failed to generate simulation parameter.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_to_openstudio_osw():
"""Test to_openstudio_osw."""
# create the model
room = Room.from_box('TinyHouseZone', 5, 10, 3)
model = Model('TinyHouse', [room])
model_json_path = './tests/simulation/model_osw_test.json'
with open(model_json_path, 'w') as fp:
json.dump(model.to_dict(included_prop=['energy']), fp)
# create the simulation parameter
sim_par = SimulationParameter()
sim_par.output.add_zone_energy_use()
simpar_json_path = './tests/simulation/simpar_osw_test.json'
with open(simpar_json_path, 'w') as fp:
json.dump(sim_par.to_dict(), fp)
# create additional measures
measure_path = './tests/measure/edit_fraction_radiant_of_lighting_and_equipment'
measure = Measure(measure_path)
measure.arguments[0].value = 0.25
measure.arguments[1].value = 0.25
# test it without measures
folder = './tests/simulation/'
osw_path = os.path.join(folder, 'workflow.osw')
osw = to_openstudio_osw(folder, model_json_path, simpar_json_path)
assert os.path.isfile(osw_path)
os.remove(osw_path)
# test it with measures
osw = to_openstudio_osw(folder,
model_json_path,
additional_measures=[measure])
assert os.path.isfile(osw_path)
os.remove(osw_path)
os.remove(model_json_path)
os.remove(simpar_json_path)
def test_load_balance_sim_par():
"""Test the load_balance_sim_par command."""
runner = CliRunner()
ddy_path = './tests/ddy/chicago.ddy'
result = runner.invoke(load_balance_sim_par, [ddy_path, '--load-type', 'Sensible'])
assert result.exit_code == 0
simpar_dict = json.loads(result.output)
sim_par = SimulationParameter.from_dict(simpar_dict)
assert 'Zone Ideal Loads Supply Air Sensible Cooling Energy' \
in sim_par.output.outputs
assert 'Zone People Sensible Heating Energy' in sim_par.output.outputs
def comfort_sim_par(ddy_file, run_period, north, filter_des_days, output_file):
"""Get a SimulationParameter JSON with outputs for thermal comfort mapping.
\b
Args:
ddy_file: Full path to a DDY file that will be used to specify design days
within the simulation parameter.
"""
try:
sim_par = SimulationParameter()
sim_par.output.add_comfort_metrics()
sim_par.output.add_surface_temperature()
_apply_run_period(run_period, sim_par)
sim_par.north_angle = north
_apply_design_days(ddy_file, filter_des_days, sim_par)
output_file.write(json.dumps(sim_par.to_dict()))
except Exception as e:
_logger.exception(
'Failed to generate simulation parameter.\n{}'.format(e))
sys.exit(1)
else:
sys.exit(0)
def test_simulation_parameter_init():
"""Test the initialization of SimulationParameter and basic properties."""
sim_par = SimulationParameter()
str(sim_par) # test the string representation
assert sim_par.output == SimulationOutput()
assert sim_par.run_period == RunPeriod()
assert sim_par.timestep == 6
assert sim_par.simulation_control == SimulationControl()
assert sim_par.shadow_calculation == ShadowCalculation()
assert sim_par.sizing_parameter == SizingParameter()
assert sim_par.north_angle == 0
assert sim_par.north_vector == Vector2D(0, 1)
assert sim_par.terrain_type == 'City'
