def apply_properties_from_dict(self, data):
"""Apply the energy properties of a dictionary to the host Model of this object.
Args:
data: A dictionary representation of an entire honeybee-core Model.
Note that this dictionary must have ModelEnergyProperties in order
for this method to successfully apply the energy properties.
"""
assert 'energy' in data['properties'], \
'Dictionary possesses no ModelEnergyProperties.'
_, constructions, construction_sets, _, schedules, program_types, hvacs = \
self.load_properties_from_dict(data)
# collect lists of energy property dictionaries
room_e_dicts, face_e_dicts, shd_e_dicts, ap_e_dicts, dr_e_dicts = \
model_extension_dicts(data, 'energy', [], [], [], [], [])
# apply energy properties to objects using the energy property dictionaries
for room, r_dict in zip(self.host.rooms, room_e_dicts):
if r_dict is not None:
room.properties.energy.apply_properties_from_dict(
r_dict, construction_sets, program_types, hvacs, schedules,
constructions)
for face, f_dict in zip(self.host.faces, face_e_dicts):
if f_dict is not None:
face.properties.energy.apply_properties_from_dict(
f_dict, constructions)
for shade, s_dict in zip(self.host.shades, shd_e_dicts):
if s_dict is not None:
shade.properties.energy.apply_properties_from_dict(
s_dict, constructions, schedules)
for aperture, a_dict in zip(self.host.apertures, ap_e_dicts):
if a_dict is not None:
aperture.properties.energy.apply_properties_from_dict(
a_dict, constructions)
for door, d_dict in zip(self.host.doors, dr_e_dicts):
if d_dict is not None:
door.properties.energy.apply_properties_from_dict(
d_dict, constructions)
# re-serialize the ventilation_simulation_control
energy_prop = data['properties']['energy']
if 'ventilation_simulation_control' in energy_prop and \
energy_prop['ventilation_simulation_control'] is not None:
self.ventilation_simulation_control = \
VentilationSimulationControl.from_dict(
energy_prop['ventilation_simulation_control'])
def apply_properties_from_dict(self, data):
"""Apply the radiance properties of a dictionary to the host Model of this object.
Args:
data: A dictionary representation of an entire honeybee-core Model.
Note that this dictionary must have ModelRadianceProperties in order
for this method to successfully apply the radiance properties.
"""
assert 'radiance' in data['properties'], \
'Dictionary possesses no ModelRadianceProperties.'
modifiers, modifier_sets = self.load_properties_from_dict(data)
# collect lists of radiance property dictionaries
room_e_dicts, face_e_dicts, shd_e_dicts, ap_e_dicts, dr_e_dicts = \
model_extension_dicts(data, 'radiance', [], [], [], [], [])
# apply radiance properties to objects using the radiance property dictionaries
for room, r_dict in zip(self.host.rooms, room_e_dicts):
if r_dict is not None:
room.properties.radiance.apply_properties_from_dict(
r_dict, modifier_sets)
for face, f_dict in zip(self.host.faces, face_e_dicts):
if f_dict is not None:
face.properties.radiance.apply_properties_from_dict(
f_dict, modifiers)
for aperture, a_dict in zip(self.host.apertures, ap_e_dicts):
if a_dict is not None:
aperture.properties.radiance.apply_properties_from_dict(
a_dict, modifiers)
for door, d_dict in zip(self.host.doors, dr_e_dicts):
if d_dict is not None:
door.properties.radiance.apply_properties_from_dict(
d_dict, modifiers)
for shade, s_dict in zip(self.host.shades, shd_e_dicts):
if s_dict is not None:
shade.properties.radiance.apply_properties_from_dict(
s_dict, modifiers)
# apply the sensor grids and views if they are in the data.
rad_data = data['properties']['radiance']
if 'sensor_grids' in rad_data and rad_data['sensor_grids'] is not None:
self.sensor_grids = \
[SensorGrid.from_dict(grid) for grid in rad_data['sensor_grids']]
if 'views' in rad_data and rad_data['views'] is not None:
self.views = [View.from_dict(view) for view in rad_data['views']]
def apply_properties_from_dict(self, data):
"""Apply the energy properties of a dictionary to the host Model of this object.
Args:
data: A dictionary representation of an entire honeybee-core Model.
Note that this dictionary must have ModelEnergyProperties in order
for this method to successfully apply the energy properties.
"""
assert 'energy' in data['properties'], \
'Dictionary possesses no ModelEnergyProperties.'
# set the terrain
if 'terrain_type' in data['properties']['energy']:
self.terrain_type = data['properties']['energy']['terrain_type']
# process all materials in the ModelEnergyProperties dictionary
materials = {}
for mat in data['properties']['energy']['materials']:
if mat['type'] == 'EnergyMaterial':
materials[mat['name']] = EnergyMaterial.from_dict(mat)
elif mat['type'] == 'EnergyMaterialNoMass':
materials[mat['name']] = EnergyMaterialNoMass.from_dict(mat)
elif mat['type'] == 'EnergyWindowMaterialSimpleGlazSys':
materials[mat[
'name']] = EnergyWindowMaterialSimpleGlazSys.from_dict(mat)
elif mat['type'] == 'EnergyWindowMaterialGlazing':
materials[mat['name']] = EnergyWindowMaterialGlazing.from_dict(
mat)
elif mat['type'] == 'EnergyWindowMaterialGas':
materials[mat['name']] = EnergyWindowMaterialGas.from_dict(mat)
elif mat['type'] == 'EnergyWindowMaterialGasMixture':
materials[mat[
'name']] = EnergyWindowMaterialGasMixture.from_dict(mat)
elif mat['type'] == 'EnergyWindowMaterialGasCustom':
materials[
mat['name']] = EnergyWindowMaterialGasCustom.from_dict(mat)
elif mat['type'] == 'EnergyWindowMaterialShade':
materials[mat['name']] = EnergyWindowMaterialShade.from_dict(
mat)
elif mat['type'] == 'EnergyWindowMaterialBlind':
materials[mat['name']] = EnergyWindowMaterialBlind.from_dict(
mat)
else:
raise NotImplementedError(
'Material {} is not supported.'.format(mat['type']))
# process all constructions in the ModelEnergyProperties dictionary
constructions = {}
for cnstr in data['properties']['energy']['constructions']:
if cnstr['type'] == 'OpaqueConstructionAbridged':
mat_layers = [
materials[mat_name] for mat_name in cnstr['layers']
]
constructions[cnstr['name']] = \
OpaqueConstruction(cnstr['name'], mat_layers)
elif cnstr['type'] == 'WindowConstructionAbridged':
mat_layers = [
materials[mat_name] for mat_name in cnstr['layers']
]
constructions[cnstr['name']] = \
WindowConstruction(cnstr['name'], mat_layers)
elif cnstr['type'] == 'ShadeConstruction':
constructions[cnstr['name']] = ShadeConstruction.from_dict(
cnstr)
else:
raise NotImplementedError(
'Construction {} is not supported.'.format(cnstr['type']))
# process all construction sets in the ModelEnergyProperties dictionary
construction_sets = {}
for c_set in data['properties']['energy']['construction_sets']:
construction_sets[c_set['name']] = \
ConstructionSet.from_dict_abridged(c_set, constructions)
# process all schedule type limits in the ModelEnergyProperties dictionary
schedule_type_limits = {}
for t_lim in data['properties']['energy']['schedule_type_limits']:
schedule_type_limits[t_lim['name']] = ScheduleTypeLimit.from_dict(
t_lim)
# process all schedules in the ModelEnergyProperties dictionary
schedules = {}
for sched in data['properties']['energy']['schedules']:
sched = sched.copy(
) # copy the original dictionary so that we don't edit it
# process the schedule type limits
typ_lim = None
if 'schedule_type_limit' in sched:
typ_lim = sched['schedule_type_limit']
sched['schedule_type_limit'] = None
# create the schedule objects
if sched['type'] == 'ScheduleRulesetAbridged':
sched['type'] = 'ScheduleRuleset'
schedules[sched['name']] = ScheduleRuleset.from_dict(sched)
elif sched['type'] == 'ScheduleFixedIntervalAbridged':
sched['type'] = 'ScheduleFixedInterval'
schedules[sched['name']] = ScheduleFixedInterval.from_dict(
sched)
else:
raise NotImplementedError(
'Schedule {} is not supported.'.format(sched['type']))
# asign the schedule type limits
schedules[sched['name']].schedule_type_limit = \
schedule_type_limits[typ_lim] if typ_lim is not None else None
# process all ProgramType in the ModelEnergyProperties dictionary
program_types = {}
if 'program_types' in data['properties']['energy']:
for p_typ in data['properties']['energy']['program_types']:
program_types[p_typ['name']] = \
ProgramType.from_dict_abridged(p_typ, schedules)
# collect lists of energy property dictionaries
room_e_dicts, face_e_dicts, shd_e_dicts, ap_e_dicts, dr_e_dicts = \
model_extension_dicts(data, 'energy')
# apply energy properties to objects uwing the energy property dictionaries
for room, r_dict in zip(self.host.rooms, room_e_dicts):
room.properties.energy.apply_properties_from_dict(
r_dict, construction_sets, program_types, schedules)
for face, f_dict in zip(self.host.faces, face_e_dicts):
face.properties.energy.apply_properties_from_dict(
f_dict, constructions)
for shade, s_dict in zip(self.host.shades, shd_e_dicts):
shade.properties.energy.apply_properties_from_dict(
s_dict, constructions, schedules)
for aperture, a_dict in zip(self.host.apertures, ap_e_dicts):
aperture.properties.energy.apply_properties_from_dict(
a_dict, constructions)
for aperture, a_dict in zip(self.host.apertures, ap_e_dicts):
aperture.properties.energy.apply_properties_from_dict(
a_dict, constructions)