def building_program_type_by_identifier(building_type):
"""Get a program_type representing the program mix of a building_type.
Args:
building_type: A text string for the type of building. This must appear
under the BUILDING_TYPES contant of this module.
"""
program_id = '{} Building'.format(building_type)
try:
return _program_types[program_id]
except KeyError:
try: # search the extension data
bld_mix_dict = _building_programs_dict[building_type]
progs, ratios = [], []
for key, val in bld_mix_dict.items():
progs.append(program_type_by_identifier(key))
ratios.append(val)
bld_program = ProgramType.average(program_id, progs, ratios)
bld_program.lock()
_program_types[
program_id] = bld_program # cache the object for next time
return bld_program
except KeyError: # construction is nowhere to be found; raise an error
raise ValueError(
'"{}" was not found in the building types.\nChoose from:\n{}'.
format(building_type, '\n'.join(BUILDING_TYPES)))
def averaged_program_type(self, identifier=None, timestep_resolution=1):
"""Get a ProgramType that is averaged across all of the children Room2Ds.
The weights used in the averaging process are the floor area weights and they
account for the multipliers on the child Story objects.
Args:
identifier: A unique ID text string for the new averaged ProgramType.
Must be < 100 characters and not contain any EnergyPlus special
characters. This will be used to identify the object across a model
and in the exported IDF. If None, the resulting ProgramType will
use the identifier of the host Building. (Default: None)
timestep_resolution: An optional integer for the timestep resolution
at which the schedules will be averaged. Any schedule details
smaller than this timestep will be lost in the averaging process.
Default: 1.
"""
# get the default identifier of the ProgramType if None
identifier = identifier if identifier is not None else \
'{}_Program'.format(self.host.identifier)
# compute the floor area weights and programs
flr_areas = []
program_types = []
for story in self.host.unique_stories:
for room in story.room_2ds:
flr_areas.append(room.floor_area * story.multiplier)
program_types.append(room.properties.energy.program_type)
total_area = sum(flr_areas)
weights = [room_area / total_area for room_area in flr_areas]
# compute the averaged program
return ProgramType.average(
identifier, program_types, weights, timestep_resolution)
try: # import the core honeybee dependencies
from honeybee.typing import clean_and_id_ep_string, clean_ep_string
except ImportError as e:
raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
try:
from honeybee_energy.programtype import ProgramType
from honeybee_energy.lib.programtypes import program_type_by_identifier
except ImportError as e:
raise ImportError('\nFailed to import honeybee_energy:\n\t{}'.format(e))
try:
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# set default ratios to None
_ratios_ = _ratios_ if len(_ratios_) != 0 else None
name = clean_and_id_ep_string('ProgramType') if _name_ is None else \
clean_ep_string(_name_)
# get programs from library if a name is input
for i, prog in enumerate(_programs):
if isinstance(prog, str):
_programs[i] = program_type_by_identifier(prog)
# create blended program
program = ProgramType.average(name, _programs, _ratios_)
if _name_ is not None:
program.display_name = _name_
def test_program_type_average():
"""Test the ProgramType.average method."""
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.0002, inf_schedule)
ventilation = Ventilation('Office Ventilation', 0.005, 0.0003)
setpoint = Setpoint('Office Setpoints', heat_setpt, cool_setpt)
office_program = ProgramType('Open Office Program', people, lighting,
equipment, None, None, infiltration,
ventilation, setpoint)
plenum_program = ProgramType('Plenum Program')
office_avg = ProgramType.average('Office Average Program',
[office_program, plenum_program])
assert office_avg.people.people_per_area == pytest.approx(0.025, rel=1e-3)
assert office_avg.people.occupancy_schedule.default_day_schedule.values == \
office_program.people.occupancy_schedule.default_day_schedule.values
assert office_avg.people.latent_fraction == \
office_program.people.latent_fraction
assert office_avg.people.radiant_fraction == \
office_program.people.radiant_fraction
assert office_avg.lighting.watts_per_area == pytest.approx(5, rel=1e-3)
assert office_avg.lighting.schedule.default_day_schedule.values == \
office_program.lighting.schedule.default_day_schedule.values
assert office_avg.lighting.return_air_fraction == \
office_program.lighting.return_air_fraction
assert office_avg.lighting.radiant_fraction == \
office_program.lighting.radiant_fraction
assert office_avg.lighting.visible_fraction == \
office_program.lighting.visible_fraction
assert office_avg.electric_equipment.watts_per_area == pytest.approx(
5, rel=1e-3)
assert office_avg.electric_equipment.schedule.default_day_schedule.values == \
office_program.electric_equipment.schedule.default_day_schedule.values
assert office_avg.electric_equipment.radiant_fraction == \
office_program.electric_equipment.radiant_fraction
assert office_avg.electric_equipment.latent_fraction == \
office_program.electric_equipment.latent_fraction
assert office_avg.electric_equipment.lost_fraction == \
office_program.electric_equipment.lost_fraction
assert office_avg.gas_equipment is None
assert office_avg.infiltration.flow_per_exterior_area == \
pytest.approx(0.0001, rel=1e-3)
assert office_avg.infiltration.schedule.default_day_schedule.values == \
office_program.infiltration.schedule.default_day_schedule.values
assert office_avg.infiltration.constant_coefficient == \
office_program.infiltration.constant_coefficient
assert office_avg.infiltration.temperature_coefficient == \
office_program.infiltration.temperature_coefficient
assert office_avg.infiltration.velocity_coefficient == \
office_program.infiltration.velocity_coefficient
assert office_avg.ventilation.flow_per_person == pytest.approx(0.0025,
rel=1e-3)
assert office_avg.ventilation.flow_per_area == pytest.approx(0.00015,
rel=1e-3)
assert office_avg.ventilation.flow_per_zone == pytest.approx(0, rel=1e-3)
assert office_avg.ventilation.air_changes_per_hour == pytest.approx(
0, rel=1e-3)
assert office_avg.ventilation.schedule is None
assert office_avg.setpoint.heating_setpoint == pytest.approx(21, rel=1e-3)
assert office_avg.setpoint.cooling_setpoint == pytest.approx(24, rel=1e-3)
ghenv.Component.AdditionalHelpFromDocStrings = "2"
try: # import the core honeybee dependencies
from honeybee.typing import clean_and_id_ep_string
except ImportError as e:
raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
try:
from honeybee_energy.programtype import ProgramType
from honeybee_energy.lib.programtypes import program_type_by_identifier
except ImportError as e:
raise ImportError('\nFailed to import honeybee_energy:\n\t{}'.format(e))
try:
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# set default ratios to None
_ratios_ = _ratios_ if len(_ratios_) != 0 else None
# get programs from library if a name is input
for i, prog in enumerate(_programs):
if isinstance(prog, str):
_programs[i] = program_type_by_identifier(prog)
# create blended program
program = ProgramType.average(clean_and_id_ep_string(_name), _programs,
_ratios_)
program.display_name = _name
