+"""honeybee-doe2 translation commands."""
+importsys
+importos
+importjson
+importlogging
+importclick
+
+fromhoneybee.typingimportclean_doe2_string
+fromhoneybee.modelimportModel
+fromhoneybee_energy.schedule.rulesetimportScheduleRuleset
+fromhoneybee_energy.schedule.dictutilimportdict_to_schedule
+
+fromhoneybee_doe2.configimportRES_CHARS
+fromhoneybee_doe2.utilimportheader_comment_minor
+fromhoneybee_doe2.scheduleimportextract_all_schedule_ruleset_from_inp_file
+fromhoneybee_doe2.simulationimportSimulationPar
+
+_logger=logging.getLogger(__name__)
+
+
+@click.group(help='Commands for translating Honeybee Model to DOE-2 formats.')
+deftranslate():
+ pass
+
+
+@translate.command('model-to-inp')
+@click.argument('model-file',type=click.Path(
+ exists=True,file_okay=True,dir_okay=False,resolve_path=True))
+@click.option(
+ '--sim-par-json','-sp',help='Full path to a honeybee-doe2 SimulationPar '
+ 'JSON that describes all of the settings for the simulation. If unspecified, '
+ 'default parameters will be generated.',default=None,show_default=True,
+ type=click.Path(exists=True,file_okay=True,dir_okay=False,resolve_path=True))
+@click.option(
+ '--hvac-mapping','-hm',help='Text to indicate how HVAC systems should be '
+ 'assigned to the exported model. Story will assign one HVAC system for each '
+ 'distinct level polygon, Model will use only one HVAC system for the whole model '
+ 'and AssignedHVAC will follow how the HVAC systems have been assigned to the'
+ 'Rooms.properties.energy.hvac. Choose from: Room, Story, Model, AssignedHVAC',
+ default='Story',show_default=True,type=str)
+@click.option(
+ '--include-interior-walls/--exclude-interior-walls',' /-xw',help='Flag to note '
+ 'whether interior walls should be excluded from the export.',
+ default=True,show_default=True)
+@click.option(
+ '--include-interior-ceilings/--exclude-interior-ceilings',' /-xc',help='Flag to '
+ 'note whether interior ceilings should be excluded from the export.',
+ default=True,show_default=True)
+@click.option(
+ '--equest-version','-eq',help='Optional text string to denote the version '
+ 'of eQuest for which the INP definition will be generated. If unspecified '
+ 'or unrecognized, the latest version of eQuest will be used.',
+ default='3.65',show_default=True,type=str)
+@click.option(
+ '--output-file','-o',help='Optional INP file path to output the INP string '
+ 'of the translation. By default this will be printed out to stdout.',
+ type=click.File('w'),default='-',show_default=True)
+defmodel_to_inp_cli(
+ model_file,sim_par_json,hvac_mapping,include_interior_walls,
+ include_interior_ceilings,equest_version,output_file
+):
+"""Translate a Honeybee Model to an INP file.
+
+ \b
+ Args:
+ model_file: Full path to a Honeybee Model file (HBJSON or HBpkl).
+ """
+ try:
+ exclude_interior_walls=notinclude_interior_walls
+ exclude_interior_ceilings=notinclude_interior_ceilings
+ model_to_inp(
+ model_file,sim_par_json,hvac_mapping,
+ exclude_interior_walls,exclude_interior_ceilings,
+ equest_version,output_file)
+ exceptExceptionase:
+ _logger.exception(f'Model translation failed:\n{e}')
+ sys.exit(1)
+ else:
+ sys.exit(0)
+
+
+
+[docs]
+defmodel_to_inp(
+ model_file,sim_par_json=None,hvac_mapping='Story',
+ exclude_interior_walls=False,exclude_interior_ceilings=False,
+ equest_version='3.65',output_file=None,
+ include_interior_walls=True,include_interior_ceilings=True):
+"""Translate a Honeybee Model to an INP file.
+
+ Args:
+ model_file: Full path to a Honeybee Model file (HBJSON or HBpkl).
+ sim_par_json: Full path to a honeybee-doe2 SimulationPar JSON that
+ describes all of the settings for the simulation. If None,
+ default parameters will be generated. (Default: None).
+ hvac_mapping: Text to indicate how HVAC systems should be assigned to
+ the exported model. Story will assign one HVAC system for each distinct
+ level polygon, Model will use only one HVAC system for the whole model
+ and AssignedHVAC will follow how the HVAC systems have been assigned
+ to the Rooms.properties.energy.hvac. Choose from the following.
+
+ * Room
+ * Story
+ * Model
+ * AssignedHVAC
+
+ exclude_interior_walls: Boolean to note whether interior walls should
+ be excluded from the export. (Default: False).
+ exclude_interior_ceilings: Boolean to note whether interior ceilings
+ should be excluded from the export. (Default: False).
+ equest_version: Optional text string to denote the version of eQuest for
+ which the INP definition will be generated. If unspecified or
+ unrecognized, the latest version of eQuest will be used. (Default: False).
+ output_file: Optional INP file path to output the INP string of the
+ translation. If None, the string will be returned from this function.
+ """
+ # load simulation parameters if specified
+ sim_par=None
+ ifsim_par_jsonisnotNone:
+ withopen(sim_par_json)asjson_file:
+ data=json.load(json_file)
+ sim_par=SimulationPar.from_dict(data)
+
+ # re-serialize the Model to Python
+ model=Model.from_file(model_file)
+
+ # create the strings for the model
+ inp_str=model.to.inp(
+ model,sim_par,hvac_mapping,
+ exclude_interior_walls,exclude_interior_ceilings,equest_version)
+
+ # write out the INP file
+ return_process_content_to_output(inp_str,output_file)
+
+
+
+@translate.command('schedules-to-inp')
+@click.argument('schedule-json',type=click.Path(
+ exists=True,file_okay=True,dir_okay=False,resolve_path=True))
+@click.option('--output-file','-f',help='Optional INP file to output the INP '
+ 'string of the translation. By default this will be printed out to stdout',
+ type=click.File('w'),default='-',show_default=True)
+defschedule_to_inp_cli(schedule_json,output_file):
+"""Translate a Schedule JSON file to an INP.
+
+ \b
+ Args:
+ schedule_json: Full path to a Schedule JSON file. This file should
+ either be an array of non-abridged Schedules or a dictionary where
+ the values are non-abridged Schedules.
+ """
+ try:
+ schedule_to_inp(schedule_json,output_file)
+ exceptExceptionase:
+ _logger.exception('Schedule translation failed.\n{}'.format(e))
+ sys.exit(1)
+ else:
+ sys.exit(0)
+
+
+
+[docs]
+defschedule_to_inp(schedule_json,output_file=None):
+"""Translate a Schedule JSON file to an INP.
+
+ Args:
+ schedule_json: Full path to a Schedule JSON file. This file should
+ either be an array of non-abridged Schedules or a dictionary where
+ the values are non-abridged Schedules.
+ output_file: Optional INP file path to output the INP string of the
+ translation. If None, the string will be returned from this function.
+ """
+ # re-serialize the Schedule to Python
+ withopen(schedule_json)asjson_file:
+ data=json.load(json_file)
+ sch_list=data.values()ifisinstance(data,dict)elsedata
+ sch_objs=[dict_to_schedule(sch)forschinsch_list]
+ type_objs=set()
+ forschinsch_objs:
+ type_objs.add(sch.schedule_type_limit)
+
+ # create the INP strings
+ all_day_scheds,all_week_scheds,all_year_scheds=[],[],[]
+ used_day_sched_ids,used_day_count={},1
+ all_scheds=sch_objs
+ forschedinall_scheds:
+ ifisinstance(sched,ScheduleRuleset):
+ year_schedule,week_schedules=sched.to_inp()
+ # check that day schedules aren't referenced by other model schedules
+ day_scheds=[]
+ fordayinsched.day_schedules:
+ ifday.identifiernotinused_day_sched_ids:
+ day_scheds.append(day.to_inp(sched.schedule_type_limit))
+ used_day_sched_ids[day.identifier]=day
+ elifday!=used_day_sched_ids[day.identifier]:
+ new_day=day.duplicate()
+ new_day.identifier='Schedule Day {}'.format(used_day_count)
+ day_scheds.append(new_day.to_inp(sched.schedule_type_limit))
+ fori,week_schinenumerate(week_schedules):
+ old_day_id=clean_doe2_string(day.identifier,RES_CHARS)
+ new_day_id=clean_doe2_string(new_day.identifier,RES_CHARS)
+ week_schedules[i]=week_sch.replace(old_day_id,new_day_id)
+ used_day_count+=1
+ all_day_scheds.extend(day_scheds)
+ all_week_scheds.extend(week_schedules)
+ all_year_scheds.append(year_schedule)
+ else:# ScheduleFixedInterval
+ year_schedule,week_schedules,year_schedule=sched.to_inp()
+ all_day_scheds.extend(day_scheds)
+ all_week_scheds.extend(week_schedules)
+ all_year_scheds.append(year_schedule)
+ inp_str_list=['INPUT ..\n\n']
+ inp_str_list.append(header_comment_minor('Day Schedules'))
+ inp_str_list.extend(all_day_scheds)
+ inp_str_list.append(header_comment_minor('Week Schedules'))
+ inp_str_list.extend(all_week_scheds)
+ inp_str_list.append(header_comment_minor('Annual Schedules'))
+ inp_str_list.extend(all_year_scheds)
+ inp_str_list.append('END ..\nCOMPUTE ..\nSTOP ..\n')
+ inp_str='\n'.join(inp_str_list)
+
+ # write out the INP file
+ return_process_content_to_output(inp_str,output_file)
+
+
+
+@translate.command('schedules-from-inp')
+@click.argument('schedule-inp',type=click.Path(
+ exists=True,file_okay=True,dir_okay=False,resolve_path=True))
+@click.option(
+ '--dictionary/--array',' /-a',help='Flag to note whether a the output JSON '
+ 'should be an array of schedule objects or whether it should be a dictionary '
+ 'where each key is the identifier of the schedule and each value is the '
+ 'schedule object. The dictionary format is the one used by honeybee-standards '
+ 'and is recommended when writing INP schedules into the user standards library.',
+ default=True,show_default=True)
+@click.option(
+ '--output-file','-f',help='Optional JSON file to output the JSON string of '
+ 'the translation. By default this will be printed out to stdout',
+ type=click.File('w'),default='-',show_default=True)
+defschedule_from_inp_cli(schedule_inp,dictionary,output_file):
+"""Translate a schedule INP file to a honeybee JSON as an array of schedules.
+
+ \b
+ Args:
+ schedule_inp: Full path to a Schedule INP file.
+ """
+ try:
+ array=notdictionary
+ schedule_from_inp(schedule_inp,array,output_file)
+ exceptExceptionase:
+ _logger.exception('Schedule translation failed.\n{}'.format(e))
+ sys.exit(1)
+ else:
+ sys.exit(0)
+
+
+
+[docs]
+defschedule_from_inp(schedule_inp,array=False,output_file=None,dictionary=True):
+"""Translate a schedule INP file to a honeybee JSON as an array of schedules.
+
+ Args:
+ schedule_inp: Full path to a Schedule INP file.
+ array: Boolean to note whether a the output JSON should be an array of
+ schedule objects or whether it should be a dictionary where each key
+ is the identifier of the schedule and each value is the schedule object.
+ The dictionary format is the one used by honeybee-standards and is
+ recommended when writing INP schedules into the user standards
+ library. (Default: False).
+ output_file: Optional JSON file path to output the JSON string of the
+ translation. If None, the string will be returned from this function.
+ """
+ # re-serialize the schedules to Python
+ schedules=extract_all_schedule_ruleset_from_inp_file(schedule_inp)
+ # create the honeybee dictionaries
+ ifarray:
+ hb_objs=[sch.to_dict()forschinschedules]
+ else:
+ hb_objs={sch.identifier:sch.to_dict()forschinschedules}
+ # write out the JSON file
+ content_str=json.dumps(hb_objs)
+ return_process_content_to_output(content_str,output_file)
+"""honeybee-inp construction translators."""
+from__future__importdivision
+
+fromladybug.datatype.uvalueimportUValue
+fromladybug.datatype.rvalueimportRValue
+fromladybug.datatype.distanceimportDistance
+fromhoneybee.typingimportclean_doe2_string
+fromhoneybee_energy.material.opaqueimportEnergyMaterialNoMass
+
+from.configimportRES_CHARS,MIN_LAYER_THICKNESS
+from.utilimportgenerate_inp_string,generate_inp_string_list_format
+
+# dictionary to map between E+ and DOE-2 roughness types
+ROUGHNESS_MAP={
+ 'VeryRough':1,'Rough':2,'MediumRough':3,
+ 'MediumSmooth':4,'Smooth':5,'VerySmooth':6
+}
+
+
+
+[docs]
+defopaque_material_to_inp(material):
+"""Convert an EnergyMaterial or EnergyMaterialNoMass into a MATERIAL INP string.
+
+ Note that EnergyMaterials that are below a certain thickness will be automatically
+ converted to No Mass materials for compatibility with DOE-2. Also note that
+ this does not work for any materials that can be a part of a window constructions.
+ """
+ doe2_id=clean_doe2_string(material.identifier,RES_CHARS)
+ # check if the material should be translated as a no mass material
+ ifisinstance(material,EnergyMaterialNoMass)or \
+ material.thickness<MIN_LAYER_THICKNESS:
+ r_val=RValue().to_unit([material.r_value],'h-ft2-F/Btu','m2-K/W')[0]
+ keywords=('TYPE','RESISTANCE')
+ values=('RESISTANCE',round(r_val,6))
+ returngenerate_inp_string(doe2_id,'MATERIAL',keywords,values)
+ # write out detailed properties for the material
+ thickness=round(Distance().to_unit([material.thickness],'ft','m')[0],3)
+ conduct=round(material.conductivity*0.578176,3)# convert to BTU/h-ft-F
+ density=round(material.density/16.018,3)# convert to lb/ft3
+ spec_en=round(material.specific_heat*0.0002388459,3)# convert to BTU/lb-F
+ keywords=('TYPE','THICKNESS','CONDUCTIVITY','DENSITY','SPECIFIC-HEAT')
+ values=('PROPERTIES',thickness,conduct,density,spec_en)
+ returngenerate_inp_string(doe2_id,'MATERIAL',keywords,values)
+
+
+
+
+[docs]
+defopaque_construction_to_inp(construction):
+"""Convert an OpaqueConstruction into a CONSTRUCTION INP string.
+
+ This will include both the LAYERS definition as well as the CONSTRUCTION but
+ it does NOT include the constituent MATERIAL definitions and their properties.
+ """
+ doe2_id=clean_doe2_string(construction.identifier,RES_CHARS)
+ # if the construction has no heat capacity, simply make a U-VALUE construction
+ ifconstruction.area_heat_capacity==0or \
+ construction.thickness<=MIN_LAYER_THICKNESS*len(construction.materials):
+ con_cond=UValue().to_unit([construction.u_factor],'Btu/h-ft2-F','W/m2-K')[0]
+ keywords=('TYPE','U-VALUE')
+ values=('U-VALUE',round(con_cond,6))
+ returngenerate_inp_string(doe2_id,'CONSTRUCTION',keywords,values)
+ # create the specification of material layers
+ layer_id='{}_l'.format(doe2_id)
+ layers=['"{}"'.format(clean_doe2_string(mat,RES_CHARS))
+ formatinconstruction.layers]
+ layer_str=generate_inp_string_list_format(
+ layer_id,'LAYERS',['MATERIAL'],[layers])
+ # create the construction specification
+ roughness=ROUGHNESS_MAP[construction.materials[0].roughness]
+ sol_absorb=round(1-construction.outside_solar_reflectance,3)
+ keywords=('TYPE','ABSORPTANCE','ROUGHNESS','LAYERS')
+ values=('LAYERS',sol_absorb,roughness,'"{}"'.format(layer_id))
+ constr_str=generate_inp_string(doe2_id,'CONSTRUCTION',keywords,values)
+ return''.join((layer_str,constr_str))
+
+
+
+
+[docs]
+defwindow_construction_to_inp(construction):
+"""Convert a WindowConstruction (or its variants) into a GLASS-TYPE INP string."""
+ doe2_id=clean_doe2_string(construction.identifier,RES_CHARS)
+ shading_coef=construction.shgc/0.87
+ glass_cond=UValue().to_unit([construction.u_factor],'Btu/h-ft2-F','W/m2-K')[0]
+ keywords=('TYPE','SHADING-COEF','GLASS-CONDUCT')
+ values=('SHADING-COEF',round(shading_coef,3),round(glass_cond,6))
+ returngenerate_inp_string(doe2_id,'GLASS-TYPE',keywords,values)
+
+
+
+
+[docs]
+defdoor_construction_to_inp(construction):
+"""Convert an OpaqueConstruction or WindowConstruction to a CONSTRUCTION INP string.
+
+ This translation pathway always uses a NoMass U-VALUE Construction.
+ """
+ doe2_id=clean_doe2_string(construction.identifier,RES_CHARS)
+ constr_cond=UValue().to_unit([construction.u_factor],'Btu/h-ft2-F','W/m2-K')[0]
+ keywords=('TYPE','U-VALUE')
+ values=('U-VALUE',round(constr_cond,6))
+ returngenerate_inp_string(doe2_id,'CONSTRUCTION',keywords,values)
+
+
+
+
+[docs]
+defair_construction_to_inp(construction):
+"""Convert an AirBoundaryConstruction to a CONSTRUCTION INP string.
+
+ This translation pathway always uses a NoMass U-VALUE Construction.
+ """
+ doe2_id=clean_doe2_string(construction.identifier,RES_CHARS)
+ constr_cond=1.0# default U-Value in Btu/h-ft2-F
+ keywords=('TYPE','U-VALUE')
+ values=('U-VALUE',constr_cond)
+ returngenerate_inp_string(doe2_id,'CONSTRUCTION',keywords,values)
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/honeybee_doe2/grouping.html b/docs/_modules/honeybee_doe2/grouping.html
new file mode 100644
index 0000000..8db552d
--- /dev/null
+++ b/docs/_modules/honeybee_doe2/grouping.html
@@ -0,0 +1,554 @@
+
+
+
+
+
+
+ honeybee_doe2.grouping — honeybee-doe2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# coding=utf-8
+"""Methods for grouping rooms to comply with INP rules."""
+from__future__importdivision
+importmath
+
+fromladybug_geometry.geometry2dimportPoint2D,Polygon2D
+fromladybug_geometry.geometry3dimportVector3D,Point3D,Face3D
+fromhoneybee.typingimportclean_doe2_string
+fromhoneybee.roomimportRoom
+
+from.configimportDOE2_TOLERANCE,FLOOR_LEVEL_TOL,RES_CHARS
+
+
+
+[docs]
+defgroup_rooms_by_doe2_level(rooms,model_tolerance):
+"""Group Honeybee Rooms according to acceptable floor levels in DOE-2.
+
+ This means that not only will Rooms be on separate DOE-2 levels if their floor
+ heights differ but also Rooms that share the same floor height but are
+ disconnected from one another in plan will also be separate levels.
+ For example, when the model is of two towers on a plinth, each tower will
+ get its own separate level group.
+
+ Args:
+ rooms: A list of Honeybee Rooms to be grouped.
+ model_tolerance: The tolerance of the model that the Rooms originated from.
+
+ Returns:
+ A tuple with three elements.
+
+ - room_groups: A list of lists where each sub-list contains Honeybee
+ Rooms that should be on the same DOE-2 level.
+
+ - level_geometries: A list of Face3D with the same length as the
+ room_groups, which contains the geometry that represents each floor
+ level. These geometries will always be pointing upwards so that
+ their vertices are counter-clockwise when viewed from above. They
+ will also have colinear vertices removed such that they are ready
+ to be translated to INP POLYGONS.
+
+ - level_names: A list of text strings that align with the level
+ geometry and contain suggested names for the DOE-2 levels.
+ """
+ # set up lists of the outputs to be populated
+ room_groups,level_geometries,level_names,existing_levels=[],[],[],{}
+
+ # first group the rooms by floor height
+ grouped_rooms,_=Room.group_by_floor_height(rooms,FLOOR_LEVEL_TOL)
+ forfi,room_groupinenumerate(grouped_rooms):
+ # determine a base name for the level using the story assigned to the rooms
+ level_name=clean_doe2_string(room_group[0].story,RES_CHARS-8) \
+ ifroom_group[0].storyisnotNoneelse'Level_{}'.format(fi)
+ iflevel_nameinexisting_levels:
+ existing_levels[level_name]+=1
+ level_name=level_name+str(existing_levels[level_name])
+ else:
+ existing_levels[level_name]=1
+
+ # then, group the rooms by contiguous horizontal boundary
+ floor_geos=[]
+ forroominroom_group:
+ ifroom.properties.doe2.space_polygon_geometryisnotNone:
+ floor_geos.append(room.properties.doe2.space_polygon_geometry)
+ else:
+ try:
+ flr_geo=room.horizontal_floor_boundaries(tolerance=model_tolerance)
+ iflen(flr_geo)==0:# possible when Rooms have no floors
+ flr_geo=room.horizontal_boundary(tolerance=model_tolerance)
+ floor_geos.append(flr_geo)
+ else:
+ floor_geos.extend(flr_geo)
+ exceptException:# level geometry is overlapping or not clean
+ pass
+
+ # join all of the floors into horizontal boundaries
+ hor_bounds=_grouped_floor_boundary(floor_geos,model_tolerance)
+
+ # if we got lucky and everything is one contiguous polygon, we're done!
+ iflen(hor_bounds)==0:# we will write the story with NO-SHAPE
+ room_groups.append(room_group)
+ level_geometries.append(None)
+ level_names.append(level_name)
+ eliflen(hor_bounds)==1:# just one clean polygon for the level
+ flr_geo=hor_bounds[0]
+ flr_geo=flr_geoifflr_geo.normal.z>=0elseflr_geo.flip()
+ ifflr_geo.has_holes:# remove holes as we only care about the boundary
+ flr_geo=Face3D(flr_geo.boundary,flr_geo.plane)
+ flr_geo=flr_geo.remove_colinear_vertices(tolerance=DOE2_TOLERANCE)
+ room_groups.append(room_group)
+ level_geometries.append(flr_geo)
+ level_names.append(level_name)
+ else:# we need to figure out which Room belongs to which geometry
+ # first get a set of Point2Ds that are inside each room in plan
+ room_pts,z_axis=[],Vector3D(0,0,1)
+ forroominroom_group:
+ forfaceinroom.faces:
+ ifmath.degrees(z_axis.angle(face.normal))>=91:
+ down_geo=face.geometry
+ break
+ room_pt3d=down_geo.centerifdown_geo.is_convexelse \
+ down_geo.pole_of_inaccessibility(DOE2_TOLERANCE)
+ room_pts.append(Point2D(room_pt3d.x,room_pt3d.y))
+ # loop through floor geometries and determine all rooms associated with them
+ forsi,flr_geoinenumerate(hor_bounds):
+ flr_geo=flr_geoifflr_geo.normal.z>=0elseflr_geo.flip()
+ ifflr_geo.has_holes:# remove holes as we only care about the boundary
+ flr_geo=Face3D(flr_geo.boundary,flr_geo.plane)
+ flr_geo=flr_geo.remove_colinear_vertices(tolerance=DOE2_TOLERANCE)
+ flr_poly=Polygon2D([Point2D(pt.x,pt.y)forptinflr_geo.boundary])
+ flr_rooms=[]
+ forroom,room_ptinzip(room_group,room_pts):
+ ifflr_poly.is_point_inside_bound_rect(room_pt):
+ flr_rooms.append(room)
+ room_groups.append(flr_rooms)
+ level_geometries.append(flr_geo)
+ level_names.append('{}_Section{}'.format(level_name,si))
+
+ # return all of the outputs
+ returnroom_groups,level_geometries,level_names
+
+
+
+
+[docs]
+defgroup_rooms_by_doe2_hvac(model,hvac_mapping):
+"""Group Honeybee Rooms according to HVAC logic.
+
+ Args:
+ model: A Honeybee Model for which Rooms will be grouped for HVAC assignment.
+ hvac_mapping: Text to indicate how HVAC systems should be assigned.
+ Model will use only one HVAC system for the whole model and
+ AssignedHVAC will follow how the HVAC systems have been assigned
+ to the Rooms.properties.energy.hvac. Choose from the options below.
+
+ * Room
+ * Model
+ * AssignedHVAC
+
+ Returns:
+ A tuple with three elements.
+
+ - room_groups: A list of lists where each sub-list contains Honeybee
+ Rooms that should ave the same HVAC system.
+
+ - hvac_names: A list of text strings that align with the room_groups
+ and contain suggested names for the DOE-2 HVAC systems.
+ """
+ # clean up the hvac_mapping text
+ hvac_mapping=hvac_mapping.upper().replace('-','').replace(' ','')
+
+ # determine the mapping to be used
+ ifhvac_mapping=='MODEL':
+ hvac_name=clean_doe2_string('{}_Sys'.format(model.display_name),RES_CHARS)
+ return[model.rooms],[hvac_name]
+ elifhvac_mapping=='ROOM':
+ hvac_names=[clean_doe2_string('{}_Sys'.format(room.identifier),RES_CHARS)
+ forroominmodel.rooms]
+ room_groups=[[room]forroominmodel.rooms]
+ else:# assume that it is the assigned HVAC
+ hvac_dict={}
+ forroominmodel.rooms:
+ ifroom.properties.energy.hvacisnotNone:
+ hvac_id=room.properties.energy.hvac.display_name
+ try:
+ hvac_dict[hvac_id].append(room)
+ exceptKeyError:# the first time that we are encountering the HVAC
+ hvac_dict[hvac_id]=[room]
+ else:
+ try:
+ hvac_dict['Unassigned'].append(room)
+ exceptKeyError:# the first time that we have an unassigned room
+ hvac_dict['Unassigned']=[room]
+ room_groups,hvac_names,existing_dict=[],[],{}
+ forhvac_name,roomsinhvac_dict.items():
+ room_groups.append(rooms)
+ hvac_doe2_name=clean_doe2_string(hvac_name,RES_CHARS-2)
+ ifhvac_doe2_nameinexisting_dict:
+ existing_dict[hvac_doe2_name]+=1
+ hvac_names.append(hvac_doe2_name+str(existing_dict[hvac_doe2_name]))
+ else:
+ existing_dict[hvac_doe2_name]=1
+ hvac_names.append(hvac_doe2_name)
+
+ returnroom_groups,hvac_names
+
+
+
+def_grouped_floor_boundary(floor_geos,tolerance=0.01):
+"""Get a list of Face3D for the boundary around several horizontal Face3Ds.
+
+ Args:
+ floor_geos: A list of Honeybee Rooms for which the horizontal boundary will
+ be computed.
+ tolerance: The maximum difference between coordinate values of two
+ vertices at which they can be considered equivalent. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # remove colinear vertices and degenerate faces
+ clean_floor_geos=[]
+ forgeoinfloor_geos:
+ try:
+ clean_floor_geos.append(geo.remove_colinear_vertices(tolerance))
+ exceptAssertionError:# degenerate geometry to ignore
+ pass
+ iflen(clean_floor_geos)==0:
+ return[]# no Room boundary to be found
+
+ # convert the floor Face3Ds into counterclockwise Polygon2Ds
+ floor_polys,z_vals=[],[]
+ forflr_geoinclean_floor_geos:
+ z_vals.append(flr_geo.min.z)
+ b_poly=Polygon2D([Point2D(pt.x,pt.y)forptinflr_geo.boundary])
+ floor_polys.append(b_poly)
+ ifflr_geo.has_holes:
+ forholeinflr_geo.holes:
+ h_poly=Polygon2D([Point2D(pt.x,pt.y)forptinhole])
+ floor_polys.append(h_poly)
+ z_min=min(z_vals)
+
+ # find the joined intersected boundary
+ closed_polys=Polygon2D.joined_intersected_boundary(floor_polys,tolerance)
+
+ # remove colinear vertices from the resulting polygons
+ clean_polys=[]
+ forpolyinclosed_polys:
+ try:
+ clean_polys.append(poly.remove_colinear_vertices(tolerance))
+ exceptAssertionError:
+ pass# degenerate polygon to ignore
+
+ # figure out if polygons represent holes in the others and make Face3D
+ iflen(clean_polys)==0:
+ return[]
+ eliflen(clean_polys)==1:# can be represented with a single Face3D
+ pts3d=[Point3D(pt.x,pt.y,z_min)forptinclean_polys[0]]
+ return[Face3D(pts3d)]
+ else:# need to separate holes from distinct Face3Ds
+ bound_faces=[]
+ forpolyinclean_polys:
+ pts3d=tuple(Point3D(pt.x,pt.y,z_min)forptinpoly)
+ bound_faces.append(Face3D(pts3d))
+ returnFace3D.merge_faces_to_holes(bound_faces,tolerance)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/honeybee_doe2/load.html b/docs/_modules/honeybee_doe2/load.html
new file mode 100644
index 0000000..78006a9
--- /dev/null
+++ b/docs/_modules/honeybee_doe2/load.html
@@ -0,0 +1,613 @@
+
+
+
+
+
+
+ honeybee_doe2.load — honeybee-doe2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+"""honeybee-doe2 load translators."""
+from__future__importdivision
+
+fromladybug.datatype.areaimportArea
+fromladybug.datatype.powerimportPower
+fromladybug.datatype.energyfluximportEnergyFlux
+fromladybug.datatype.volumeflowrateimportVolumeFlowRate
+fromladybug.datatype.volumeflowrateintensityimportVolumeFlowRateIntensity
+fromhoneybee.typingimportclean_doe2_string
+
+from.configimportRES_CHARS
+
+# list of all keywords associated with different load types
+PEOPLE_KEYS=('AREA/PERSON','PEOPLE-SCHEDULE')
+LIGHTING_KEYS=('LIGHTING-W/AREA','LIGHTING-SCHEDULE','LIGHT-TO-RETURN',
+ 'LIGHT-RAD-FRAC')
+EQUIP_KEYS=('EQUIPMENT-W/AREA','EQUIP-SCHEDULE',
+ 'EQUIP-SENSIBLE','EQUIP-LATENT','EQUIP-RAD-FRAC')
+SOURCE_KEYS=('SOURCE-TYPE','SOURCE-POWER','SOURCE-SCHEDULE',
+ 'SOURCE-SENSIBLE','SOURCE-RAD-FRAC','SOURCE-LATENT')
+INFILTRATION_KEYS=('INF-METHOD','INF-FLOW/AREA','INF-SCHEDULE')
+SETPOINT_KEYS=('DESIGN-HEAT-T','DESIGN-COOL-T','HEAT-TEMP-SCH','COOL-TEMP-SCH')
+VENTILATION_KEYS=('OA-FLOW/PER','OA-FLOW/AREA','OA-CHANGES','OUTSIDE-AIR-FLOW',
+ 'MIN-FLOW-SCH')
+MECH_AIRFLOW_KEYS=('ASSIGNED-FLOW','FLOW/AREA','MIN-FLOW-RATIO','MIN-FLOW/AREA',
+ 'HMAX-FLOW-RATIO')
+SPACE_KEYS=PEOPLE_KEYS+LIGHTING_KEYS+EQUIP_KEYS+INFILTRATION_KEYS
+ZONE_KEYS=SETPOINT_KEYS+VENTILATION_KEYS+MECH_AIRFLOW_KEYS
+SCHEDULE_KEYS=(
+ 'PEOPLE-SCHEDULE','LIGHTING-SCHEDULE','EQUIP-SCHEDULE','SOURCE-SCHEDULE',
+ 'INF-SCHEDULE','HEAT-TEMP-SCH','COOL-TEMP-SCH','MIN-FLOW-SCH')
+
+# TODO: Add methods to map honeybee_energy process loads to SOURCE-TYPE PROCESS
+# TODO: Add methods to translate daylight sensors
+
+
+
+[docs]
+defpeople_to_inp(people):
+"""Translate a People definition into INP (Keywords, Values).
+
+ Args:
+ people: A honeybee-energy People definition. None is allowed.
+
+ Returns:
+ A tuple with two elements.
+
+ - keywords: A tuple of text strings for keywords related to defining
+ people for a Space.
+
+ - values: A tuple of text strings that aligns with the keywords and
+ denotes the value for each keyword.
+ """
+ ifpeopleisNone:
+ return(),()
+ ppl_den=Area().to_unit([people.area_per_person],'ft2','m2')[0]
+ ppl_den=round(ppl_den,3)
+ ppl_sch=clean_doe2_string(people.occupancy_schedule.identifier,RES_CHARS)
+ ppl_sch='"{}"'.format(ppl_sch)
+ returnPEOPLE_KEYS,(ppl_den,ppl_sch)
+
+
+
+
+[docs]
+deflighting_to_inp(lighting):
+"""Translate a Lighting definition into INP (Keywords, Values).
+
+ Args:
+ lighting: A honeybee-energy Lighting definition. None is allowed.
+
+ Returns:
+ A tuple with two elements.
+
+ - keywords: A tuple of text strings for keywords related to defining
+ lighting for a Space.
+
+ - values: A tuple of text strings that aligns with the keywords and
+ denotes the value for each keyword.
+ """
+ iflightingisNone:
+ return(),()
+ lpd=EnergyFlux().to_unit([lighting.watts_per_area],'W/ft2','W/m2')[0]
+ lpd=round(lpd,3)
+ lgt_sch=clean_doe2_string(lighting.schedule.identifier,RES_CHARS)
+ lgt_sch='"{}"'.format(lgt_sch)
+ ret_fract=round(lighting.return_air_fraction,3)
+ rad_fract=round(lighting.radiant_fraction,3)
+ returnLIGHTING_KEYS,(lpd,lgt_sch,ret_fract,rad_fract)
+
+
+
+
+[docs]
+defelectric_equipment_to_inp(electric_equip):
+"""Translate an ElectricEquipment into INP (Keywords, Values).
+
+ Args:
+ electric_equip: A honeybee-energy ElectricEquipment definition.
+
+ Returns:
+ A tuple with two elements.
+
+ - keywords: A tuple of text strings for keywords related to defining
+ the equipment for a Space.
+
+ - values: A tuple of text strings that aligns with the keywords and
+ denotes the value for each keyword.
+ """
+ ifelectric_equipisNone:
+ return(),()
+ epd=EnergyFlux().to_unit([electric_equip.watts_per_area],'W/ft2','W/m2')[0]
+ epd=round(epd,3)
+ eqp_sch=clean_doe2_string(electric_equip.schedule.identifier,RES_CHARS)
+ eqp_sch='("{}")'.format(eqp_sch)
+ sens_fract=1-electric_equip.latent_fraction-electric_equip.lost_fraction
+ values=(epd,eqp_sch,sens_fract,electric_equip.latent_fraction,
+ electric_equip.radiant_fraction)
+ returnEQUIP_KEYS,values
+
+
+
+
+[docs]
+defhot_water_and_gas_to_inp(hot_water,gas_equip,room_floor_area):
+"""Translate a ServiceHotWater and/or GasEquipment into INP (Keywords, Values).
+
+ Args:
+ hot_water: A honeybee-energy ServiceHotWater definition. None is allowed.
+ None is allowed.
+ gas_equip: gas_equip: A honeybee-energy GasEquipment definition.
+ None is allowed.
+ room_floor_area: The host Room floor area in square feet, which will
+ be used to convert the hot water flow per unit floor area to an
+ absolute load in BTU/h.
+
+ Returns:
+ A tuple with two elements.
+
+ - keywords: A tuple of text strings for keywords related to defining
+ the hot water SOURCE load for a Space.
+
+ - values: A tuple of text strings that aligns with the keywords and
+ denotes the value for each keyword.
+ """
+ # first check whether anything is assigned
+ ifhot_waterisNoneandgas_equipisNone:
+ return(),()
+
+ # process the hot water and gas into absolute values in Btu/h
+ shw_values,gas_values=None,None
+ ifhot_waterisnotNone:
+ flow_den=hot_water.flow_per_area# L/h-m2
+ flr_area=Area().to_unit([room_floor_area],'m2','ft2')[0]# m2
+ total_flow=flow_den*flr_area# L/h
+ delta_t=50# assume the water heater must heat water from 10C to 60C
+ c_water=4.186# J/g-C, the specific heat of water
+ shw_heat=total_flow*c_water*delta_t# J/h using Q = m * c * deltaT
+ shw_heat=shw_heat/3600.# Watts
+ shw_power=round(Power().to_unit([shw_heat],'Btu/h','W')[0],3)
+ shw_sch=clean_doe2_string(hot_water.schedule.identifier,RES_CHARS)
+ shw_sch='"{}"'.format(shw_sch)
+ sens_fract=round(hot_water.sensible_fraction,3)
+ lat_fract=round(hot_water.latent_fraction,3)
+ shw_values=('HOT-WATER',shw_power,shw_sch,sens_fract,0.0,lat_fract)
+ ifgas_equipisnotNone:
+ epd=EnergyFlux().to_unit([gas_equip.watts_per_area],'Btu/h-ft2','W/m2')[0]
+ total_power=round(epd*flr_area,3)# Btu/h
+ eqp_sch=clean_doe2_string(gas_equip.schedule.identifier,RES_CHARS)
+ eqp_sch='"{}"'.format(eqp_sch)
+ sens_fract=round(1-gas_equip.latent_fraction-gas_equip.lost_fraction,3)
+ rad_fract=round(gas_equip.radiant_fraction,3)
+ lat_fract=round(gas_equip.latent_fraction,3)
+ gas_values=('GAS',total_power,eqp_sch,sens_fract,rad_fract,lat_fract)
+
+ # if both were specified, format them into a single set of numbers
+ ifshw_valuesisnotNoneandgas_valuesisnotNone:
+ total_load=round(shw_values[1]+gas_values[1],3)
+ shw_weight=shw_values[1]/total_load
+ gas_weight=gas_values[1]/total_load
+ ifgas_weight>shw_weight:
+ values=['GAS',total_load,gas_values[2]]
+ else:
+ values=['HOT-WATER',total_load,shw_values[2]]
+ forshw_v,gas_vinzip(shw_values[3:],gas_values[3:]):
+ new_v=(shw_v*shw_weight)+(gas_v*gas_weight)
+ values.append(round(new_v,3))
+ else:
+ values=shw_valuesifshw_valuesisnotNoneelsegas_values
+
+ returnSOURCE_KEYS,values
+
+
+
+
+[docs]
+definfiltration_to_inp(infiltration):
+"""Translate an Infiltration definition into INP (Keywords, Values).
+
+ Args:
+ infiltration: A honeybee-energy Infiltration definition. None is allowed.
+
+ Returns:
+ A tuple with two elements.
+
+ - keywords: A tuple of text strings for keywords related to defining
+ infiltration for a Space.
+
+ - values: A tuple of text strings that aligns with the keywords and
+ denotes the value for each keyword.
+ """
+ ifinfiltrationisNone:
+ return(),()
+ inf_den=infiltration.flow_per_exterior_area
+ inf_den=VolumeFlowRateIntensity().to_unit([inf_den],'cfm/ft2','m3/s-m2')[0]
+ inf_den=round(inf_den,3)
+ inf_sch=clean_doe2_string(infiltration.schedule.identifier,RES_CHARS)
+ inf_sch='"{}"'.format(inf_sch)
+ returnINFILTRATION_KEYS,('AIR-CHANGE',inf_den,inf_sch)
+
+
+
+
+[docs]
+defsetpoint_to_inp(setpoint):
+"""Translate a Setpoint definition into INP (Keywords, Values).
+
+ Args:
+ setpoint: A honeybee-energy Setpoint definition. None is allowed.
+
+ Returns:
+ A tuple with two elements.
+
+ - keywords: A tuple of text strings for keywords related to defining
+ setpoints for a Zone.
+
+ - values: A tuple of text strings that aligns with the keywords and
+ denotes the value for each keyword.
+ """
+ ifsetpointisNone:# use some default setpoints
+ return('DESIGN-HEAT-T','DESIGN-COOL-T'),(72,75)
+ heat_setpt=round(setpoint.heating_setpoint*(9./5.)+32.,2)
+ cool_setpt=round(setpoint.cooling_setpoint*(9./5.)+32.,2)
+ heat_sch=clean_doe2_string(setpoint.heating_schedule.identifier,RES_CHARS)
+ heat_sch='"{}"'.format(heat_sch)
+ cool_sch=clean_doe2_string(setpoint.cooling_schedule.identifier,RES_CHARS)
+ cool_sch='"{}"'.format(cool_sch)
+ returnSETPOINT_KEYS,(heat_setpt,cool_setpt,heat_sch,cool_sch)
+
+
+
+
+[docs]
+defventilation_to_inp(ventilation):
+"""Translate a Ventilation definition into INP (Keywords, Values).
+
+ Args:
+ ventilation: A honeybee-energy Ventilation definition. None is allowed.
+
+ Returns:
+ A tuple with two elements.
+
+ - keywords: A list of text strings for keywords related to defining
+ ventilation for a Space.
+
+ - values: A list of text strings that aligns with the keywords and
+ denotes the value for each keyword.
+ """
+ keywords,values=[],[]
+ ifventilationisNone:
+ returnkeywords,values
+ # check the flow per person
+ ppl_den=ventilation.flow_per_person
+ ifppl_den!=0:
+ keywords.append('OA-FLOW/PER')
+ ppl_den=VolumeFlowRate().to_unit([ppl_den],'cfm','m3/s')[0]
+ values.append(round(ppl_den,3))
+ # check the flow per floor area
+ vent_den=ventilation.flow_per_area
+ ifvent_den!=0:
+ keywords.append('OA-FLOW/AREA')
+ vent_den=VolumeFlowRateIntensity().to_unit([vent_den],'cfm/ft2','m3/s-m2')[0]
+ values.append(round(vent_den,3))
+ # check the air changes per hour
+ ach=ventilation.air_changes_per_hour
+ ifach!=0:
+ keywords.append('OA-CHANGES')
+ values.append(round(ach,3))
+ # check the flow per zone
+ total_flow=ventilation.flow_per_zone
+ iftotal_flow!=0:
+ keywords.append('OUTSIDE-AIR-FLOW')
+ total_flow=VolumeFlowRate().to_unit([total_flow],'cfm','m3/s')[0]
+ values.append(round(total_flow,3))
+ # check the schedule
+ vent_sch=ventilation.schedule
+ ifvent_schisnotNone:
+ keywords.append('MIN-FLOW-SCH')
+ vent_sch=clean_doe2_string(vent_sch.identifier,RES_CHARS)
+ values.append('"{}"'.format(vent_sch))
+ returnkeywords,values
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/honeybee_doe2/programtype.html b/docs/_modules/honeybee_doe2/programtype.html
new file mode 100644
index 0000000..9d62102
--- /dev/null
+++ b/docs/_modules/honeybee_doe2/programtype.html
@@ -0,0 +1,492 @@
+
+
+
+
+
+
+ honeybee_doe2.programtype — honeybee-doe2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+"""honeybee-doe2 program type translators."""
+from__future__importdivision
+
+from.utilimportswitch_statement_id
+from.loadimportpeople_to_inp,lighting_to_inp,electric_equipment_to_inp, \
+ infiltration_to_inp,setpoint_to_inp,ventilation_to_inp, \
+ SPACE_KEYS,ZONE_KEYS,SCHEDULE_KEYS,MECH_AIRFLOW_KEYS
+SCH_KEY_SET=set(SCHEDULE_KEYS)
+
+
+
+[docs]
+defprogram_type_to_inp(program_type,switch_dict=None):
+"""Translate a ProgramType into a dictionary used to write INP switch statements.
+
+ Args:
+ program_type: A honeybee-energy ProgramType definition.
+ switch_dict: An optional dictionary with INP keywords as keys (such as
+ PEOPLE-SCHEDULE or AREA/PERSON or LIGHTING-W/AREA). The values of the
+ dictionary should be lists of switch statement text strings, such as
+ 'case "conf": #SI("Small Off Occ", "SPACE", "PEOPLE-SCHEDULE")'.
+ Specifying an input dictionary here can be used to build up switch
+ statements for all program types across a model.
+
+ Returns:
+ An dictionary with INP keywords as keys (such as PEOPLE-SCHEDULE or AREA/PERSON).
+ The values of the dictionary are lists of switch statement text strings,
+ such as 'case "conf": #SI("Small Off Occ", "SPACE", "PEOPLE-SCHEDULE")'.
+ """
+ # set up the switch statement dictionary to be filled
+ switch_dict=switch_dictifswitch_dictisnotNoneelse{}
+ prog_uid=switch_statement_id(program_type.identifier)
+ base_switch='case "{}": '.format(prog_uid)
+
+ def_format_schedule(sch_key,sch_uid,obj_type='SPACE'):
+"""Format schedules in the way they are written into switch statements."""
+ return'{}#SI({}, "{}", "{}")'.format(base_switch,sch_uid,obj_type,sch_key)
+
+ def_add_to_switch_dict(keyword,value):
+"""Add a key: value pair to the switch dictionary with a check."""
+ try:
+ switch_dict[keyword].append(value)
+ exceptKeyError:# the first time this key was encountered in the dict
+ switch_dict[keyword]=[value]
+
+ # write the people into the dictionary
+ ppl_kwd,ppl_val=people_to_inp(program_type.people)
+ forkey,valinzip(ppl_kwd,ppl_val):
+ ifkeyinSCH_KEY_SET:
+ _add_to_switch_dict(key,_format_schedule(key,val,'SPACE'))
+ else:
+ _add_to_switch_dict(key,'{}{}'.format(base_switch,val))
+
+
+ # write the lighting into the dictionary
+ lgt_kwd,lgt_val=lighting_to_inp(program_type.lighting)
+ forkey,valinzip(lgt_kwd,lgt_val):
+ ifkey=='LIGHTING-SCHEDULE':
+ key='LIGHTING-SCHEDUL'# there's a typo in DOE-2 that was never fixed
+ _add_to_switch_dict(key,_format_schedule(key,val,'SPACE'))
+ else:
+ _add_to_switch_dict(key,'{}{}'.format(base_switch,val))
+
+ # write the equipment into the dictionary
+ eq_kwd,eq_val=electric_equipment_to_inp(program_type.electric_equipment)
+ forkey,valinzip(eq_kwd,eq_val):
+ ifkeyinSCH_KEY_SET:
+ _add_to_switch_dict(key,_format_schedule(key,val,'SPACE'))
+ else:
+ _add_to_switch_dict(key,'{}{}'.format(base_switch,val))
+
+ # write the infiltration into the dictionary
+ inf_kwd,inf_val=infiltration_to_inp(program_type.infiltration)
+ forkey,valinzip(inf_kwd,inf_val):
+ ifkeyinSCH_KEY_SET:
+ _add_to_switch_dict(key,_format_schedule(key,val,'SPACE'))
+ elifkey=='INF-METHOD':
+ continue# DOE-2 does not like when we define this key
+ else:
+ _add_to_switch_dict(key,'{}{}'.format(base_switch,val))
+
+ # write the setpoint into the dictionary
+ stp_kwd,stp_val=setpoint_to_inp(program_type.setpoint)
+ forkey,valinzip(stp_kwd,stp_val):
+ ifkeyinSCH_KEY_SET:
+ _add_to_switch_dict(key,_format_schedule(key,val,'ZONE'))
+ else:
+ _add_to_switch_dict(key,'{}{}'.format(base_switch,val))
+
+ # write the ventilation into the dictionary
+ vt_kwd,vt_val=ventilation_to_inp(program_type.ventilation)
+ forkey,valinzip(vt_kwd,vt_val):
+ ifkeyinSCH_KEY_SET:
+ _add_to_switch_dict(key,_format_schedule(key,val,'ZONE'))
+ else:
+ _add_to_switch_dict(key,'{}{}'.format(base_switch,val))
+
+ # if the user_data of the ProgramType has Mech AirFlow keys, add them
+ ifprogram_type.user_dataisnotNone:
+ forair_keyinMECH_AIRFLOW_KEYS:
+ ifair_keyinprogram_type.user_data:
+ val=program_type.user_data[air_key]
+ _add_to_switch_dict(air_key,'{}{}'.format(base_switch,val))
+
+ returnswitch_dict
+
+
+
+
+[docs]
+defswitch_dict_to_space_inp(switch_dict):
+"""Translate a switch statement dictionary into INP strings for the SPACE.
+
+ Args:
+ switch_dict: An dictionary with INP keywords as keys (such as
+ PEOPLE-SCHEDULE or AREA/PERSON or LIGHTING-W/AREA). The values of the
+ dictionary should be lists of switch statement text strings, such as
+ 'case "conf": #SI("Small Off Occ", "SPACE", "PEOPLE-SCHEDULE")'.
+
+ Returns:
+ A text string to be written into an INP file. This should go at the top
+ of the description of Floors / Spaces.
+ """
+ # loop through the space keys and build a list of all switch statement keys
+ all_switch_strs=[]
+ fors_keyinSPACE_KEYS:
+ try:
+ iflen(s_key)>16:# switch statements limit characters to 16
+ s_key=s_key[:16]
+ switch_progs=switch_dict[s_key]
+ switch_strs=['SET-DEFAULT FOR SPACE']
+ switch_strs.append(' {} ='.format(s_key))
+ switch_strs.append('{switch(#L("C-ACTIVITY-DESC"))')
+ switch_strs.extend(switch_progs)
+ switch_strs.append('default: no_default')
+ switch_strs.append('endswitch}')
+ switch_strs.append('..\n')
+ all_switch_strs.append('\n'.join(switch_strs))
+ exceptKeyError:
+ pass# none of the programs types have this space key
+ # add something to set the INF-METHOD for all spaces
+ inf_str='SET-DEFAULT FOR SPACE\n' \
+ ' INF-METHOD = AIR-CHANGE\n' \
+ '..\n'
+ all_switch_strs.append(inf_str)
+ return'\n'.join(all_switch_strs)
+
+
+
+
+[docs]
+defswitch_dict_to_zone_inp(switch_dict):
+"""Translate a switch statement dictionary into INP strings for the ZONE.
+
+ Args:
+ switch_dict: An dictionary with INP keywords as keys (such as
+ HEAT-TEMP-SCH or DESIGN-HEAT-T or OUTSIDE-AIR-FLOW). The values of the
+ dictionary should be lists of switch statement text strings, such as
+ 'case "conf": #SI("Small Off HtgStp", "SPACE", "HEAT-TEMP-SCH")'.
+
+ Returns:
+ A text string to be written into an INP file. This should go at the top
+ of the description of HVAC Systems / Zones.
+ """
+ # loop through the space keys and build a list of all switch statement keys
+ all_switch_strs=[]
+ fors_keyinZONE_KEYS:
+ try:
+ switch_progs=switch_dict[s_key]
+ switch_strs=['SET-DEFAULT FOR ZONE',' TYPE = CONDITIONED']
+ switch_strs.append(' {} ='.format(s_key))
+ switch_strs.append('{switch(#LR("SPACE", "C-ACTIVITY-DESC"))')
+ switch_strs.extend(switch_progs)
+ switch_strs.append('default: no_default')
+ switch_strs.append('endswitch}')
+ switch_strs.append('..\n')
+ all_switch_strs.append('\n'.join(switch_strs))
+ exceptKeyError:
+ pass# none of the programs types have this space key
+ return'\n'.join(all_switch_strs)
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/honeybee_doe2/properties/model.html b/docs/_modules/honeybee_doe2/properties/model.html
new file mode 100644
index 0000000..41ab7bc
--- /dev/null
+++ b/docs/_modules/honeybee_doe2/properties/model.html
@@ -0,0 +1,446 @@
+
+
+
+
+
+
+ honeybee_doe2.properties.model — honeybee-doe2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[docs]
+classModelDoe2Properties(object):
+"""DOE-2 Properties for Honeybee Model.
+
+ Args:
+ host: A honeybee_core Model object that hosts these properties.
+
+ Properties:
+ * host
+ """
+
+ def__init__(self,host):
+"""Initialize ModelDoe2Properties."""
+ self._host=host
+
+ @property
+ defhost(self):
+"""Get the Model object hosting these properties."""
+ returnself._host
+
+
+[docs]
+ defcheck_for_extension(self,raise_exception=True,detailed=False):
+"""Check that the Model is valid for DOE-2 simulation.
+
+ This process includes all relevant honeybee-core checks as well as checks
+ that apply only for DOE-2.
+
+ Args:
+ raise_exception: Boolean to note whether a ValueError should be raised
+ if any errors are found. If False, this method will simply
+ return a text string with all errors that were found. (Default: True).
+ detailed: Boolean for whether the returned object is a detailed list of
+ dicts with error info or a string with a message. (Default: False).
+
+ Returns:
+ A text string with all errors that were found or a list if detailed is True.
+ This string (or list) will be empty if no errors were found.
+ """
+ # set up defaults to ensure the method runs correctly
+ detailed=Falseifraise_exceptionelsedetailed
+ msgs=[]
+ tol=self.host.tolerance
+ ang_tol=self.host.angle_tolerance
+
+ # perform checks for duplicate identifiers, which might mess with other checks
+ msgs.append(self.host.check_all_duplicate_identifiers(False,detailed))
+
+ # perform several checks for the Honeybee schema geometry rules
+ msgs.append(self.host.check_planar(tol,False,detailed))
+ msgs.append(self.host.check_self_intersecting(tol,False,detailed))
+ msgs.append(self.host.check_degenerate_rooms(tol,False,detailed))
+
+ # perform geometry checks related to parent-child relationships
+ msgs.append(self.host.check_sub_faces_valid(tol,ang_tol,False,detailed))
+ msgs.append(self.host.check_sub_faces_overlapping(tol,False,detailed))
+ msgs.append(self.host.check_rooms_solid(tol,ang_tol,False,detailed))
+ msgs.append(self.host.check_upside_down_faces(ang_tol,False,detailed))
+
+ # perform checks related to adjacency relationships
+ msgs.append(self.host.check_room_volume_collisions(tol,False,detailed))
+ msgs.append(self.host.check_missing_adjacencies(False,detailed))
+ msgs.append(self.host.check_matching_adjacent_areas(tol,False,detailed))
+ msgs.append(self.host.check_all_air_boundaries_adjacent(False,detailed))
+
+ # perform checks that are specific to DOE-2
+ # perform checks for duplicate identifiers
+ e_prop=self.host.properties.energy
+ msgs.append(e_prop.check_duplicate_material_identifiers(False,detailed))
+ msgs.append(e_prop.check_duplicate_construction_identifiers(False,detailed))
+ msgs.append(e_prop.check_duplicate_construction_set_identifiers(False,detailed))
+ msgs.append(
+ e_prop.check_duplicate_schedule_type_limit_identifiers(False,detailed))
+ msgs.append(e_prop.check_duplicate_schedule_identifiers(False,detailed))
+ msgs.append(e_prop.check_duplicate_program_type_identifiers(False,detailed))
+ msgs.append(e_prop.check_duplicate_hvac_identifiers(False,detailed))
+ msgs.append(e_prop.check_duplicate_shw_identifiers(False,detailed))
+ # perform checks for specific energy simulation rules
+ msgs.append(e_prop.check_interior_constructions_reversed(False,detailed))
+
+ # output a final report of errors or raise an exception
+ full_msgs=[msgformsginmsgsifmsg]
+ ifdetailed:
+ return[mformsginfull_msgsforminmsg]
+ full_msg='\n'.join(full_msgs)
+ ifraise_exceptionandlen(full_msgs)!=0:
+ raiseValueError(full_msg)
+ returnfull_msg
+
+
+
+[docs]
+ defto_dict(self):
+"""Return Model DOE-2 properties as a dictionary."""
+ return{'doe2':{'type':'ModelDoe2Properties'}}
+
+
+
+[docs]
+ defapply_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'doe2'indata['properties'], \
+ 'Dictionary possesses no ModelDoe2Properties.'
+ room_doe2_dicts=[]
+ if'rooms'indataanddata['rooms']isnotNone:
+ forroom_dictindata['rooms']:
+ try:
+ room_doe2_dicts.append(room_dict['properties']['doe2'])
+ exceptKeyError:
+ room_doe2_dicts.append(None)
+ forroom,r_dictinzip(self.host.rooms,room_doe2_dicts):
+ ifr_dictisnotNone:
+ room.properties.doe2.apply_properties_from_dict(r_dict)
+[docs]
+classRoomDoe2Properties(object):
+"""DOE-2 Properties for Honeybee Room.
+
+ Args:
+ host: A honeybee_core Room object that hosts these properties.
+ assigned_flow: A number for the design supply air flow rate for the zone
+ the Room is assigned to (cfm). This establishes the minimum allowed
+ design air flow. Note that the actual design flow may be larger. If
+ None, this parameter will not be written into the INP. (Default: None).
+ flow_per_area: A number for the design supply air flow rate to
+ the zone per unit floor area (cfm/ft2). If None, this parameter
+ will not be written into the INP. (Default: None).
+ min_flow_ratio: A number between 0 and 1 for the minimum allowable zone
+ air supply flow rate, expressed as a fraction of design flow rate.
+ Applicable to variable-volume type systems only. If None, this parameter
+ will not be written into the INP. (Default: None).
+ min_flow_per_area: A number for the minimum air flow per square foot of
+ floor area (cfm/ft2). This is an alternative way of specifying the
+ min_flow_ratio. If None, this parameter will not be written into
+ the INP. (Default: None).
+ hmax_flow_ratio: A number between 0 and 1 for the ratio of the maximum
+ (or fixed) heating airflow to the cooling airflow. The specific
+ meaning varies according to the type of zone terminal. If None, this
+ parameter will not be written into the INP. (Default: None).
+ space_polygon_geometry: An optional horizontal Face3D object, which will
+ be used to set the SPACE polygon during export to INP. If None,
+ the SPACE polygon is auto-calculated from the 3D Room geometry.
+ Specifying a geometry here can help overcome some limitations of
+ this auto-calculation, particularly for cases where the floors
+ of the Room are composed of AirBoundaries. (Default: None).
+
+ Properties:
+ * host
+ * assigned_flow
+ * flow_per_area
+ * min_flow_ratio
+ * min_flow_per_area
+ * hmax_flow_ratio
+ * space_polygon_geometry
+ """
+ __slots__=(
+ '_host','_assigned_flow','_flow_per_area','_min_flow_ratio',
+ '_min_flow_per_area','_hmax_flow_ratio','_space_polygon_geometry'
+ )
+
+ def__init__(
+ self,host,assigned_flow=None,flow_per_area=None,min_flow_ratio=None,
+ min_flow_per_area=None,hmax_flow_ratio=None,space_polygon_geometry=None
+ ):
+"""Initialize Room DOE-2 properties."""
+ # set the main properties of the Room
+ self._host=host
+ self.assigned_flow=assigned_flow
+ self.flow_per_area=flow_per_area
+ self.min_flow_ratio=min_flow_ratio
+ self.min_flow_per_area=min_flow_per_area
+ self.hmax_flow_ratio=hmax_flow_ratio
+ self.space_polygon_geometry=space_polygon_geometry
+
+ @property
+ defhost(self):
+"""Get the Room object hosting these properties."""
+ returnself._host
+
+ @property
+ defassigned_flow(self):
+"""Get or set the design supply air flow rate for the zone (cfm)."""
+ returnself._assigned_flow
+
+ @assigned_flow.setter
+ defassigned_flow(self,value):
+ ifvalueisnotNone:
+ value=float_positive(value,'zone assigned flow')
+ self._assigned_flow=value
+
+ @property
+ defflow_per_area(self):
+"""Get or set the design supply air flow rate per unit floor area (cfm/ft2).
+ """
+ returnself._flow_per_area
+
+ @flow_per_area.setter
+ defflow_per_area(self,value):
+ ifvalueisnotNone:
+ value=float_positive(value,'zone flow per area')
+ self._flow_per_area=value
+
+ @property
+ defmin_flow_ratio(self):
+"""Get or set the the min supply airflow rate as a fraction of design flow rate.
+ """
+ returnself._min_flow_ratio
+
+ @min_flow_ratio.setter
+ defmin_flow_ratio(self,value):
+ ifvalueisnotNone:
+ value=float_in_range(value,0.0,1.0,'zone min flow ratio')
+ self._min_flow_ratio=value
+
+ @property
+ defmin_flow_per_area(self):
+"""Get or set the minimum air flow per square foot of floor area (cfm/ft2)."""
+ returnself._min_flow_per_area
+
+ @min_flow_per_area.setter
+ defmin_flow_per_area(self,value):
+ ifvalueisnotNone:
+ value=float_positive(value,'zone min flow per area')
+ self._min_flow_per_area=value
+
+ @property
+ defhmax_flow_ratio(self):
+"""Get or set the ratio of the maximum heating airflow to the cooling airflow.
+ """
+ returnself._hmax_flow_ratio
+
+ @hmax_flow_ratio.setter
+ defhmax_flow_ratio(self,value):
+ ifvalueisnotNone:
+ value=float_in_range(value,0.0,1.0,'zone heating max flow ratio')
+ self._hmax_flow_ratio=value
+
+ @property
+ defspace_polygon_geometry(self):
+"""Get or set a horizontal Face3D to set the space polygon geometry."""
+ returnself._space_polygon_geometry
+
+ @space_polygon_geometry.setter
+ defspace_polygon_geometry(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,Face3D), \
+ 'Expected ladybug_geometry Face3D. Got {}'.format(type(value))
+ ifvalue.normal.z<0:# ensure upward-facing Face3D
+ self._floor_geometry=value.flip()
+ self._space_polygon_geometry=value
+
+
+[docs]
+ defmove(self,moving_vec):
+"""Move this object along a vector.
+
+ Args:
+ moving_vec: A ladybug_geometry Vector3D with the direction and distance
+ to move the object.
+ """
+ ifself.space_polygon_geometryisnotNone:
+ self._space_polygon_geometry=self.space_polygon_geometry.move(moving_vec)
+
+
+
+[docs]
+ defrotate(self,angle,axis,origin):
+"""Rotate this object by a certain angle around an axis and origin.
+
+ Args:
+ angle: An angle for rotation in degrees.
+ axis: Rotation axis as a Vector3D.
+ origin: A ladybug_geometry Point3D for the origin around which the
+ object will be rotated.
+ """
+ ifself.space_polygon_geometryisnotNone:
+ self._space_polygon_geometry= \
+ self.space_polygon_geometry.rotate(math.radians(angle),axis,origin)
+
+
+
+[docs]
+ defrotate_xy(self,angle,origin):
+"""Rotate this object counterclockwise in the world XY plane by a certain angle.
+
+ Args:
+ angle: An angle in degrees.
+ origin: A ladybug_geometry Point3D for the origin around which the
+ object will be rotated.
+ """
+ ifself.space_polygon_geometryisnotNone:
+ self._space_polygon_geometry= \
+ self.space_polygon_geometry.rotate_xy(math.radians(angle),origin)
+
+
+
+[docs]
+ defreflect(self,plane):
+"""Reflect this object across a plane.
+
+ Args:
+ plane: A ladybug_geometry Plane across which the object will
+ be reflected.
+ """
+ ifself.space_polygon_geometryisnotNone:
+ self._space_polygon_geometry=self.space_polygon_geometry.reflect(plane)
+
+
+
+[docs]
+ defscale(self,factor,origin=None):
+"""Scale this object by a factor from an origin point.
+
+ Args:
+ factor: A number representing how much the object should be scaled.
+ origin: A ladybug_geometry Point3D representing the origin from which
+ to scale. If None, it will be scaled from the World origin (0, 0, 0).
+ """
+ ifself.space_polygon_geometryisnotNone:
+ self._space_polygon_geometry= \
+ self.space_polygon_geometry.scale(factor,origin)
+
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data,host):
+"""Create RoomDoe2Properties from a dictionary.
+
+ Args:
+ data: A dictionary representation of RoomDoe2Properties with the
+ format below.
+ host: A Room object that hosts these properties.
+
+ .. code-block:: python
+
+ {
+ "type": 'RoomDoe2Properties',
+ "assigned_flow": 100, # number in cfm
+ "flow_per_area": 1, # number in cfm/ft2
+ "min_flow_ratio": 0.3, # number between 0 and 1
+ "min_flow_per_area": 0.3, # number in cfm/ft2
+ "hmax_flow_ratio": 0.3, # number between 0 and 1
+ "space_polygon_geometry": {} # optional Face3D dictionary
+ }
+ """
+ assertdata['type']=='RoomDoe2Properties', \
+ 'Expected RoomDoe2Properties. Got {}.'.format(data['type'])
+ new_prop=cls(host)
+ auto_dict=autocalculate.to_dict()
+ if'assigned_flow'indataanddata['assigned_flow']!=auto_dict:
+ new_prop.assigned_flow=data['assigned_flow']
+ if'flow_per_area'indataanddata['flow_per_area']!=auto_dict:
+ new_prop.flow_per_area=data['flow_per_area']
+ if'min_flow_ratio'indataanddata['min_flow_ratio']!=auto_dict:
+ new_prop.min_flow_ratio=data['min_flow_ratio']
+ if'min_flow_per_area'indataanddata['min_flow_per_area']!=auto_dict:
+ new_prop.min_flow_per_area=data['min_flow_per_area']
+ if'hmax_flow_ratio'indataanddata['hmax_flow_ratio']!=auto_dict:
+ new_prop.hmax_flow_ratio=data['hmax_flow_ratio']
+ if'space_polygon_geometry'indataand \
+ data['space_polygon_geometry']isnotNone:
+ new_prop.space_polygon_geometry= \
+ Face3D.from_dict(data['space_polygon_geometry'])
+ returnnew_prop
+[docs]
+ defapply_properties_from_user_data(self):
+"""Apply properties from a the user_data assigned to the host room.
+
+ For this method to successfully assign properties from user_data, the
+ properties on this object must currently be None and the keys in
+ user_data must use the INP convention for each of the attributes,
+ which must be CAPITALIZED like the following:
+
+ .. code-block:: python
+
+ {
+ "ASSIGNED-FLOW": 100, # number in cfm
+ "FLOW/AREA": 1, # number in cfm/ft2
+ "MIN-FLOW-RATIO": 0.3, # number between 0 and 1
+ "MIN-FLOW/AREA": 0.3, # number in cfm/ft2
+ "HMAX-FLOW-RATIO": 0.3 # number between 0 and 1
+ }
+ """
+ attrs=('assigned_flow','flow_per_area','min_flow_ratio',
+ 'min_flow_per_area','hmax_flow_ratio')
+ data=self.host.user_data
+ ifdataisnotNone:
+ forkey,attrinzip(MECH_AIRFLOW_KEYS,attrs):
+ ifkeyindataandgetattr(self,attr)isNone:
+ try:
+ setattr(self,attr,data[key])
+ exceptException:
+ pass# it's user_data; users are allowed to make mistakes
+[docs]
+ defto_inp(self):
+"""Get RoomDoe2Properties as INP (Keywords, Values).
+
+ Returns:
+ A tuple with two elements.
+
+ - keywords: A list of text strings for keywords to assign to the room.
+
+ - values: A list of text strings that aligns with the keywords and
+ denotes the value for each keyword.
+ """
+ keywords=[]
+ values=[]
+ attrs=('assigned_flow','flow_per_area','min_flow_ratio',
+ 'min_flow_per_area','hmax_flow_ratio')
+ forkey,attrinzip(MECH_AIRFLOW_KEYS,attrs):
+ attr_value=getattr(self,attr)
+ ifattr_valueisnotNone:
+ keywords.append(key)
+ values.append(attr_value)
+ returnkeywords,values
+
+
+
+[docs]
+ defduplicate(self,new_host=None):
+"""Get a copy of this object.
+
+ Args:
+ new_host: A new Room object that hosts these properties.
+ If None, the properties will be duplicated with the same host.
+ """
+ _host=new_hostorself._host
+ new_room=RoomDoe2Properties(
+ _host,self.assigned_flow,self.flow_per_area,self.min_flow_ratio,
+ self.min_flow_per_area,self.hmax_flow_ratio,self.space_polygon_geometry)
+ returnnew_room
+[docs]
+defschedule_type_limit_to_inp(type_limit):
+"""Get the DOE-2 type for a honeybee-energy ScheduleTypeLimit."""
+ iftype_limitisNone:
+ return'FRACTION'
+ eliftype_limit.display_name=='Multiplier':
+ return"MULTIPLIER"
+ eliftype_limit.unit_type=='Temperature':
+ return'TEMPERATURE'
+ else:
+ iftype_limit.numeric_type=='Discrete':
+ return'ON/OFF'
+ else:
+ return'FRACTION'
+
+
+
+
+[docs]
+defschedule_day_to_inp(day_schedule,type_limit=None):
+"""Convert a ScheduleDay into a DAY-SCHEDULE INP string."""
+ # setup the DOE-2 identifier and lists for keywords and values
+ doe2_id=clean_doe2_string(day_schedule.identifier,RES_CHARS)
+ type_text=schedule_type_limit_to_inp(type_limit)
+ keywords,values=['TYPE'],[type_text]
+ hour_values=day_schedule.values_at_timestep(1)
+
+ # convert temperature to fahrenheit if the type if temperature
+ iftype_text=='TEMPERATURE':
+ hour_values=[round(v*(9./5.)+32.,2)forvinhour_values]
+
+ # setup a function to format list of values correctly
+ def_format_day_values(values_to_format):
+ iflen(values_to_format)==1:
+ return'({})'.format(round(values_to_format[0],3))
+ eliflen(values_to_format)<5:
+ returnstr(tuple(round(v,3)forvinvalues_to_format))
+ else:# we have to format it with multiple lines
+ spc=' '*31
+ full_str='('
+ fori,vinenumerate(values_to_format):
+ ifi==len(values_to_format)-1:
+ full_str+=str(round(v,3))+')'
+ elif(i+1)%5==0:
+ full_str+=str(round(v,3))+',\n'+spc
+ else:
+ full_str+=str(round(v,3))+', '
+ returnfull_str
+
+ # loop through the hourly values and write them in the format DOE-2 likes
+ prev_count,prev_hour,prev_values=0,1,[hour_values[0]]
+ fori,valinenumerate(hour_values):
+ ifi==0:
+ continue# ignore the first value already in the list
+ ifval==prev_values[-1]:
+ prev_count+=1
+ iflen(prev_values)>1:
+ keywords.append('HOURS')
+ ifprev_hour!=i-1:
+ values.append('({}, {})'.format(prev_hour,i-1))
+ keywords.append('VALUES')
+ values.append(_format_day_values(prev_values[:-1]))
+ prev_values=[prev_values[-1]]
+ prev_hour=i
+ else:
+ values.append('({}, {})'.format(prev_hour,i))
+ keywords.append('VALUES')
+ values.append(_format_day_values(prev_values))
+ prev_values=[prev_values[-1]]
+ prev_hour=i+1
+ continue# wait for the value to change
+ ifprev_count==0:# just keep assembling the list of values
+ prev_values.append(val)
+ else:
+ keywords.append('HOURS')
+ values.append('({}, {})'.format(prev_hour,i))
+ keywords.append('VALUES')
+ values.append(_format_day_values(prev_values))
+ prev_values=[val]
+ prev_hour=i+1
+ prev_count=0
+ keywords.append('HOURS')
+ values.append('({}, {})'.format(prev_hour,24))
+ keywords.append('VALUES')
+ values.append(_format_day_values(prev_values))
+
+ # return the INP string
+ returngenerate_inp_string(doe2_id,'DAY-SCHEDULE',keywords,values)
+
+
+
+
+[docs]
+defschedule_ruleset_to_inp(schedule):
+"""Convert a ScheduleRuleset into a WEEK-SCHEDULE-PD and SCHEDULE INP strings.
+
+ Note that this method only outputs SCHEDULE and WEEK-SCHEDULE objects
+ However, to write the full schedule into an INP, the schedules's
+ day_schedules must also be written.
+
+ Returns:
+ A tuple with two elements
+
+ - year_schedule: Text string representation of the SCHEDULE
+ describing this schedule.
+
+ - week_schedules: A list of WEEK-SCHEDULE-PD text strings that are
+ referenced in the year_schedule.
+ """
+ # setup the DOE-2 identifier and lists for keywords and values
+ doe2_id=clean_doe2_string(schedule.identifier,RES_CHARS)
+ type_text=schedule_type_limit_to_inp(schedule.schedule_type_limit)
+ day_types=[
+ 'Monday','Tuesday','Wednesday','Thursday','Friday','Saturday',
+ 'Sunday','Holiday','Winter Design Day','Summer Design Day'
+ ]
+
+ def_get_week_list(schedule,rule_indices):
+"""Get a list of the ScheduleDay identifiers applied on each day of the week."""
+ week_list=[]
+ fordowinrange(7):
+ foriinrule_indices:
+ ifschedule._schedule_rules[i].week_apply_tuple[dow]:
+ day_sch_id=schedule._schedule_rules[i].schedule_day.identifier
+ week_list.append(clean_doe2_string(day_sch_id,RES_CHARS))
+ break
+ else:# no rule applies; use default_day_schedule.
+ day_sch_id=schedule.default_day_schedule.identifier
+ week_list.append(clean_doe2_string(day_sch_id,RES_CHARS))
+ week_list.append(week_list.pop(0))# DOE-2 starts week on Monday; not Sunday
+ returnweek_list
+
+ def_get_extra_week_fields(schedule):
+"""Get schedule identifiers of extra days in Schedule:Week."""
+ # add summer and winter design days
+ week_fields=[]
+ ifschedule._holiday_scheduleisnotNone:
+ day_sch_id=schedule._holiday_schedule.identifier
+ week_fields.append(clean_doe2_string(day_sch_id,RES_CHARS))
+ else:
+ day_sch_id=schedule._default_day_schedule.identifier
+ week_fields.append(clean_doe2_string(day_sch_id,RES_CHARS))
+ ifschedule._winter_designday_scheduleisnotNone:
+ day_sch_id=schedule._winter_designday_schedule.identifier
+ week_fields.append(clean_doe2_string(day_sch_id,RES_CHARS))
+ else:
+ day_sch_id=schedule._default_day_schedule.identifier
+ week_fields.append(clean_doe2_string(day_sch_id,RES_CHARS))
+ ifschedule._summer_designday_scheduleisnotNone:
+ day_sch_id=schedule._summer_designday_schedule.identifier
+ week_fields.append(clean_doe2_string(day_sch_id,RES_CHARS))
+ else:
+ day_sch_id=schedule._default_day_schedule.identifier
+ week_fields.append(clean_doe2_string(day_sch_id,RES_CHARS))
+ returnweek_fields
+
+ def_inp_week_schedule_from_rule_indices(schedule,rule_indices,week_index):
+"""Create an INP string of a week schedule from a list of rules indices."""
+ week_sch_id='{}_Week {}'.format(schedule.identifier,week_index)
+ week_sch_id=clean_doe2_string(week_sch_id,RES_CHARS)
+ week_fields=[]
+ # check rules that apply for the days of the week
+ week_fields.extend(_get_week_list(schedule,rule_indices))
+ # add extra days (including summer and winter design days)
+ week_fields.extend(_get_extra_week_fields(schedule))
+ week_keywords,week_values=['TYPE'],[type_text]
+ day_list=[]
+ forday_type,day_schinzip(day_types,week_fields):
+ day_list.append('"{}", $ {}'.format(day_sch,day_type))
+ week_keywords.append('DAY-SCHEDULES')
+ week_values.append(day_list)
+ week_schedule=generate_inp_string_list_format(
+ week_sch_id,'WEEK-SCHEDULE-PD',week_keywords,week_values)
+ returnweek_schedule,week_sch_id
+
+ def_inp_week_schedule_from_week_list(schedule,week_list,week_index):
+"""Create an INP string of a week schedule from a list ScheduleDay identifiers.
+ """
+ week_sch_id='{}_Week {}'.format(schedule.identifier,week_index)
+ week_sch_id=clean_doe2_string(week_sch_id,RES_CHARS)
+ week_fields=list(week_list)
+ week_fields.append(week_fields.pop(0))# DOE-2 starts week on Monday; not Sunday
+ week_fields.extend(_get_extra_week_fields(schedule))
+ week_keywords,week_values=['TYPE'],[type_text]
+ day_list=[]
+ forday_type,day_schinzip(day_types,week_fields):
+ day_list.append('"{}", $ {}'.format(day_sch,day_type))
+ week_keywords.append('DAY-SCHEDULES')
+ week_values.append(day_list)
+ week_schedule=generate_inp_string_list_format(
+ week_sch_id,'WEEK-SCHEDULE-PD',week_keywords,week_values)
+ returnweek_schedule,week_sch_id
+
+ # prepare to create a full Schedule:Year
+ week_schedules=[]
+ ifschedule.is_single_week:# create the only one week schedule
+ wk_sch,wk_sch_id= \
+ _inp_week_schedule_from_rule_indices(schedule,range(len(schedule)),1)
+ week_schedules.append(wk_sch)
+ yr_wk_s_ids=[wk_sch_id]
+ yr_wk_dt_range=[[Date(1,1),Date(12,31)]]
+ else:# create a set of week schedules throughout the year
+ # loop through 365 days of the year to find unique combinations of rules
+ rules_each_day=[]
+ fordoyinrange(1,366):
+ rules_on_doy=tuple(ifori,ruleinenumerate(schedule._schedule_rules)
+ ifrule.does_rule_apply_doy(doy))
+ rules_each_day.append(rules_on_doy)
+ unique_rule_sets=set(rules_each_day)
+ # check if any combination yield the same week schedule and remove duplicates
+ week_tuples=[tuple(_get_week_list(schedule,rule_set))
+ forrule_setinunique_rule_sets]
+ unique_week_tuples=list(set(week_tuples))
+ # create the unique week schedules from the combinations of rules
+ week_sched_ids=[]
+ fori,week_listinenumerate(unique_week_tuples):
+ wk_schedule,wk_sch_id= \
+ _inp_week_schedule_from_week_list(schedule,week_list,i+1)
+ week_schedules.append(wk_schedule)
+ week_sched_ids.append(wk_sch_id)
+ # create a dictionary mapping unique rule index lists to week schedule ids
+ rule_set_map={}
+ forrule_i,week_listinzip(unique_rule_sets,week_tuples):
+ unique_week_i=unique_week_tuples.index(week_list)
+ rule_set_map[rule_i]=week_sched_ids[unique_week_i]
+ # loop through all 365 days of the year to find when rules change
+ yr_wk_s_ids=[]
+ yr_wk_dt_range=[]
+ prev_week_sched=None
+ fordoyinrange(1,366):
+ week_sched=rule_set_map[rules_each_day[doy-1]]
+ ifweek_sched!=prev_week_sched:# change to a new rule set
+ yr_wk_s_ids.append(week_sched)
+ ifdoy!=1:
+ yr_wk_dt_range[-1].append(Date.from_doy(doy-1))
+ yr_wk_dt_range.append([Date.from_doy(doy)])
+ else:
+ yr_wk_dt_range.append([Date(1,1)])
+ prev_week_sched=week_sched
+ yr_wk_dt_range[-1].append(Date(12,31))
+
+ # create the year fields
+ keywords,values=['TYPE'],[type_text]
+ fori,(wk_sch_id,dt_range)inenumerate(zip(yr_wk_s_ids,yr_wk_dt_range)):
+ end_date=dt_range[1]
+ thru='THRU {}{}'.format(MONTHNAMES[end_date.month-1].upper(),end_date.day)
+ keywords.append(thru)
+ values.append('"{}"'.format(wk_sch_id))
+ year_schedule=generate_inp_string(doe2_id,'SCHEDULE',keywords,values)
+ returnyear_schedule,week_schedules
+
+
+
+
+[docs]
+defschedule_fixed_interval_to_inp(schedule):
+"""Convert a ScheduleFixedInterval to INP strings.
+
+ Note that true Fixed Interval schedules are not supported by DOE-2 and there
+ is no way to faithfully translate them given that DOE-2 SCHEDULE objects have
+ a hard limit of 12 THRU statements. This method tries to write as best of
+ an approximation for the schedule as possible by averaging the hourly values
+ from each day of the fixed interval schedule. A separate day schedule will
+ be used for each month in an attempt to account for changes in the fixed
+ interval schedule over the year.
+
+ All of this will allow the translation to succeed and gives roughly matching
+ behavior of the DOE-2 simulation to the EnergyPlus simulation. However, it is
+ recommended that users replace ScheduleFixedIntervals with ScheduleRulesets
+ that they know best represents the schedule. Or EnergyPlus should be used for
+ the simulation instead of DOE-2.
+
+ Returns:
+ A tuple with three elements
+
+ - year_schedule: Text string representation of the SCHEDULE
+ describing this schedule.
+
+ - week_schedules: A list of WEEK-SCHEDULE text strings that are
+ referenced in the year_schedule.
+
+ - day_schedules: A list of DAY-SCHEDULE-PD text strings that are
+ referenced in the week_schedules.
+ """
+ # setup the DOE-2 identifier and lists for keywords and values
+ doe2_id=clean_doe2_string(schedule.identifier,RES_CHARS)
+ base_id=clean_doe2_string(schedule.identifier,RES_CHARS-6)
+ type_text=schedule_type_limit_to_inp(schedule.schedule_type_limit)
+
+ # loop through the months of the year and create appropriate schedules
+ day_schedules,week_schedules=[],[]
+ year_keywords,year_values=['TYPE'],[type_text]
+ sch_data=schedule.data_collection
+ ifsch_data.header.analysis_period.timestep!=1:
+ sch_data=sch_data.cull_to_timestep(1)
+ formonth_iinrange(1,13):
+ # create the day schedules
+ month_name=AnalysisPeriod.MONTHNAMES[month_i]
+ month_days=AnalysisPeriod.NUMOFDAYSEACHMONTH[month_i-1]
+ week_id='{}{}'.format(base_id,month_name)
+ day_id='{}{}'.format(week_id,'Day')
+ period=AnalysisPeriod(st_month=month_i,end_month=month_i,end_day=month_days)
+ month_data=sch_data.filter_by_analysis_period(period)
+ mon_per_hr=month_data.average_monthly_per_hour()
+ hour_values=[round(v,3)forvinmon_per_hr.values]
+ iftype_text=='TEMPERATURE':
+ hour_values=[round(v*(9./5.)+32.,2)forvinhour_values]
+ day_keywords,day_values=['TYPE','VALUES'],[type_text,hour_values]
+ day_inp_str=generate_inp_string_list_format(
+ day_id,'DAY-SCHEDULE-PD',day_keywords,day_values)
+ day_schedules.append(day_inp_str)
+ # create week schedule
+ week_keywords=['TYPE','DAYS','DAY-SCHEDULES']
+ week_values=[type_text,'(ALL)','("{}")'.format(day_id)]
+ week_sch=generate_inp_string(
+ week_id,'WEEK-SCHEDULE',week_keywords,week_values)
+ week_schedules.append(week_sch)
+ # add values to the year schedules
+ thru='THRU {}{}'.format(month_name.upper(),period.end_day)
+ year_keywords.append(thru)
+ year_values.append('"{}"'.format(week_id))
+
+ # return all of the strings
+ year_schedule=generate_inp_string(doe2_id,'SCHEDULE',year_keywords,year_values)
+ returnyear_schedule,week_schedules,day_schedules
+
+
+
+"""____________TRANSLATORS FROM INP TO HONEYBEE____________"""
+
+
+
+[docs]
+defschedule_type_limit_from_inp(inp_type_string):
+"""Get a honeybee-energy ScheduleTypeLimit for a given DOE-2 schedule type."""
+ clean_type=inp_type_string.strip().upper()
+ ifclean_type=='ON/OFF':
+ returnon_off
+ elifclean_type=='TEMPERATURE':
+ returntemperature
+ else:
+ returnfractional
+
+
+
+
+[docs]
+defschedule_day_from_inp(inp_string):
+"""Create a Honeybee ScheduleDay from a DOE-2 INP text string.
+
+ Note that this method can accept both types of DOE-2 Day Schedules
+ (DAY-SCHEDULE, DAY-SCHEDULE-PD).
+
+ Args:
+ inp_string: A text string fully describing a DOE-2 DAY-SCHEDULE.
+ """
+ # parse the string into properties
+ u_name,command,keywords,values=parse_inp_string(inp_string)
+ # extract the hourly values of the schedule
+ hour_vals,sch_type=[],'FRACTIONAL'
+ ifcommand.upper()=='DAY-SCHEDULE-PD':
+ field_dict={k:vfork,vinzip(keywords,values)}
+ sch_type=field_dict['TYPE'].upper()
+ hour_vals_init=eval(field_dict['VALUES'].replace('&D','"&D"'),{})
+ ifisinstance(hour_vals_init,tuple):
+ forvalinhour_vals_init:
+ ifval=='&D':
+ hour_vals.append(hour_vals[-1])
+ else:
+ hour_vals.append(float(val))
+ iflen(hour_vals)<24:
+ for_inrange(24-len(hour_vals)):
+ hour_vals.append(hour_vals[-1])
+ else:# a constant schedule
+ hour_vals=[hour_vals_init]*24
+ elifcommand.upper()=='DAY-SCHEDULE':
+ prev_count=0
+ forkey,valinzip(keywords,values):
+ ifkey=='HOURS':
+ hr_range=eval(val,{})
+ prev_count=hr_range[-1]-hr_range[0]+1
+ elifkey=='VALUES':
+ hr_vals=eval(val,{})
+ ifisinstance(hr_vals,tuple):
+ hour_vals.extend(hr_vals)
+ else:
+ hour_vals.extend([hr_vals]*prev_count)
+ elifkey=='TYPE':
+ sch_type=val.upper()
+ else:
+ raiseValueError('Schedule type "{}" is not recognized.'.format(command))
+ # convert temperature values from F to C if type is TEMPERATURE
+ ifsch_type=='TEMPERATURE':
+ hour_vals=[round((v-32.)*(5./9.),2)forvinhour_vals]
+ returnScheduleDay.from_values_at_timestep(clean_ep_string(u_name),hour_vals)
+
+
+
+def_inp_day_schedule_dictionary(day_inp_strings):
+"""Get a dictionary of DaySchedule objects from an INP string list."""
+ day_schedule_dict={}
+ forsch_strinday_inp_strings:
+ sch_str=sch_str.strip()
+ try:
+ sch_obj=schedule_day_from_inp(sch_str)
+ day_schedule_dict[sch_obj.identifier]=sch_obj
+ exceptException:
+ pass# not a schedule that can be converted
+ returnday_schedule_dict
+
+
+
+[docs]
+defextract_all_rules_from_inp_schedule_week(
+ week_inp_string,day_schedule_dict,start_date=None,end_date=None):
+"""Extract all ScheduleRule objects from an INP string of a WEEK-SCHEDULE-PD.
+
+ Args:
+ week_inp_string: A text string fully describing a DOE-2 WEEK-SCHEDULE-PD.
+ day_schedule_dict: A dictionary with the identifiers of ScheduleDay objects
+ as keys and the corresponding ScheduleDay objects as values. These objects
+ will be used to build the ScheduleRules using the week_idf_string.
+ start_date: A ladybug Date object for the start of the period over which
+ the ScheduleRules apply. If None, Jan 1 will be used.
+ end_date: A ladybug Date object for the end of the period over which
+ the ScheduleRules apply. If None, Dec 31 will be used.
+
+ Returns:
+ A tuple with five elements
+
+ - u_name: The unique name of the WEEK-SCHEDULE-PD.
+
+ - schedule_rules: A list of ScheduleRule objects that together describe
+ the WEEK-SCHEDULE-PD.
+
+ - holiday: Text for the name of the SCHEDULE-DAY for the Holiday.
+
+ - winter_dd: Text for the name of the SCHEDULE-DAY for the Winter Design Day.
+
+ - summer_dd: Text for the name of the SCHEDULE-DAY for the Summer Design Day.
+ """
+ # parse the string into properties
+ u_name,command,keywords,values=parse_inp_string(week_inp_string)
+ assertcommand.upper()=='WEEK-SCHEDULE-PD','Week schedule must be in ' \
+ 'WEEK-SCHEDULE-PD format. Got "{}".'.format(command)
+ # create the ScheduleRule objects from the parsed properties
+ schedule_rules=[]
+ field_dict={k:vfork,vinzip(keywords,values)}
+ week_vals=eval(field_dict['DAY-SCHEDULES'].replace('&D','"&D"'),{})
+ applied_day_ids,prev_day=[],None
+ fori,day_sch_idinenumerate(week_vals[:7]):
+ day_sch_id=day_sch_id.replace('"','')
+ day_sch_id=prev_dayifday_sch_id=='&D'elseday_sch_id
+ prev_day=day_sch_id# increment it for the next item
+ ifday_sch_idnotinapplied_day_ids:# make a new rule
+ rule=ScheduleRule(day_schedule_dict[clean_ep_string(day_sch_id)],
+ start_date=start_date,end_date=end_date)
+ ifi==6:
+ rule.apply_day_by_dow(1)
+ else:
+ rule.apply_day_by_dow(i+2)
+ schedule_rules.append(rule)
+ applied_day_ids.append(day_sch_id)
+ else:# edit one of the existing rules to apply it to the new day
+ sch_rule_index=applied_day_ids.index(day_sch_id)
+ rule=schedule_rules[sch_rule_index]
+ ifi==6:
+ rule.apply_day_by_dow(1)
+ else:
+ rule.apply_day_by_dow(i+2)
+ # process any of the specified Holiday or Design Day schedules
+ holiday=week_vals[7]iflen(week_vals)>7andweek_vals[7]!='&D' \
+ elseprev_day
+ winter_dd=week_vals[8]iflen(week_vals)>8andweek_vals[8]!='&D' \
+ elseholiday
+ summer_dd=week_vals[9]iflen(week_vals)>9andweek_vals[9]!='&D' \
+ elsewinter_dd
+ returnu_name,schedule_rules,holiday,winter_dd,summer_dd
+
+
+
+def_inp_week_schedule_dictionary(week_inp_strings,day_sch_dict):
+"""Get a dictionary of ScheduleRule objects from WEEK-SCHEDULE-PD strings."""
+ week_schedule_dict={}
+ week_designday_dict={}
+ forsch_strinweek_inp_strings:
+ sch_str=sch_str.strip()
+ try:
+ u_name,rules,holiday,winter_dd,summer_dd= \
+ extract_all_rules_from_inp_schedule_week(sch_str,day_sch_dict)
+ week_schedule_dict[u_name]=rules
+ week_designday_dict[u_name]=[
+ day_sch_dict[clean_ep_string(holiday)],
+ day_sch_dict[clean_ep_string(summer_dd)],
+ day_sch_dict[clean_ep_string(winter_dd)]
+ ]
+ exceptException:
+ pass# schedule is not translate-able
+ returnweek_schedule_dict,week_designday_dict
+
+
+def_convert_schedule_year(year_inp_string,week_sch_dict,week_dd_dict):
+"""Convert an INP string of a year SCHEDULE or SCHEDULE-PD to a ScheduleRuleset.
+
+ Args:
+ year_inp_string: An INP text string describing a DOE-2 SCHEDULE or SCHEDULE-PD.
+ week_sch_dict: A dictionary of ScheduleRules from _inp_week_schedule_dictionary.
+ week_dd_dict: A dictionary of design day ScheduleDay output from the
+ _inp_week_schedule_dictionary method.
+ """
+ # use the year schedule to bring it all together
+ u_name,command,keywords,values=parse_inp_string(year_inp_string)
+ field_dict={k:vfork,vinzip(keywords,values)}
+ schedule_type=schedule_type_limit_from_inp(field_dict['TYPE'])
+ all_rules=[]
+ ifcommand.upper()=='SCHEDULE-PD':
+ week_vals=eval(field_dict['WEEK-SCHEDULES'],{})
+ ifnotisinstance(week_vals,tuple):# only one week for the whole year
+ week_id=week_vals.replace('"','')
+ rules=week_sch_dict[week_id]
+ all_rules.extend(rules)
+ else:
+ month_vals=eval(field_dict['MONTH'],{})
+ day_vals=eval(field_dict['DAY'],{})
+ prev_month,prev_day=1,1
+ formonth,day,weekinzip(month_vals,day_vals,week_vals):
+ week_id=week.replace('"','')
+ rules=week_sch_dict[week_id]
+ st_date=Date(int(prev_month),int(prev_day))
+ end_date=Date(int(month),int(day))
+ forruleinrules:
+ rule.start_date=st_date
+ rule.end_date=end_date
+ all_rules.extend(rules)
+ end_doy=end_date.doy+1ifend_date.doy!=365else365
+ next_day=Date.from_doy(end_doy)
+ prev_month,prev_day=next_day.month,next_day.day
+ elifcommand.upper()=='SCHEDULE':
+ prev_month,prev_day=1,1
+ forkey,valinzip(keywords,values):
+ ifkey.startswith('THRU'):
+ week_id=val.replace('"','')
+ rules=week_sch_dict[week_id]
+ st_date=Date(int(prev_month),int(prev_day))
+ date_vals=key.replace('THRU ','').split(' ')
+ date_str='{}{}'.format(date_vals[1],date_vals[0].title())
+ end_date=Date.from_date_string(date_str)
+ forruleinrules:
+ rule.start_date=st_date
+ rule.end_date=end_date
+ all_rules.extend(rules)
+ end_doy=end_date.doy+1ifend_date.doy!=365else365
+ next_day=Date.from_doy(end_doy)
+ prev_month,prev_day=next_day.month,next_day.day
+
+ # check to be sure the schedule days don't already have a parent
+ forruleinall_rules:
+ ifrule.schedule_day._parentisnotNone:
+ rule.schedule_day=rule.schedule_day.duplicate()
+ default_day_schedule=all_rules[0].schedule_day
+ holiday_sch,summer_dd_sch,winter_dd_sch=week_dd_dict[week_id]
+ ifholiday_sch._parentisnotNone:
+ holiday_sch=holiday_sch.duplicate()
+ ifsummer_dd_sch._parentisnotNone:
+ summer_dd_sch=summer_dd_sch.duplicate()
+ ifwinter_dd_sch._parentisnotNone:
+ winter_dd_sch=summer_dd_sch.duplicate()
+
+ # create the ScheduleRuleset and apply the design days
+ sched=ScheduleRuleset(clean_ep_string(u_name),default_day_schedule,
+ all_rules[1:],schedule_type)
+ ScheduleRuleset._apply_designdays_with_check(
+ sched,holiday_sch,summer_dd_sch,winter_dd_sch)
+ returnsched
+
+
+
+[docs]
+defschedule_ruleset_from_inp(year_inp_string,week_inp_strings,day_inp_strings):
+"""Create a ScheduleRuleset from a DOE-2 INP text strings.
+
+ Args:
+ year_inp_string: An INP text string describing a DOE-2 SCHEDULE or SCHEDULE-PD.
+ week_inp_strings: A list of INP text strings for all of the WEEK-SCHEDULE-PD
+ objects used in the SCHEDULE.
+ day_inp_strings: A list of text strings for all of the DAY-SCHEDULE or
+ DAY-SCHEDULE-PD objects used in the week_inp_strings.
+ """
+ # process the schedule components
+ day_schedule_dict=_inp_day_schedule_dictionary(day_inp_strings)
+ week_sch_dict,week_dd_dict=_inp_week_schedule_dictionary(
+ week_inp_strings,day_schedule_dict)
+
+ # convert the year_inp_string into a ScheduleRuleset
+ return_convert_schedule_year(year_inp_string,week_sch_dict,week_dd_dict)
+
+
+
+
+[docs]
+defextract_all_schedule_ruleset_from_inp_file(inp_file):
+"""Extract all ScheduleRuleset objects from a DOE-2 INP file.
+
+ Args:
+ inp_file: A path to an INP file containing objects for SCHEDULE
+ (or SCHEDULE-PD) and corresponding WEEK-SCHEDULE-PD and DAY-SCHEDULE
+ (or DAY-SCHEDULE-PD) objects. The SCHEDULE will be used to assemble
+ all of these into a ScheduleRuleset.
+
+ Returns:
+ schedules -- A list of all Schedule objects in the INP file as
+ honeybee_energy ScheduleRuleset objects.
+ """
+ # read the file and remove lines of comments
+ file_contents=clean_inp_file_contents(inp_file)
+ # extract all of the DAY-SCHEDULE objects
+ day_pattern1=re.compile(r'(?i)(".*=.*DAY-SCHEDULE\n[\s\S]*?\.\.)')
+ day_pattern2=re.compile(r'(?i)(".*=.*DAY-SCHEDULE-PD\n[\s\S]*?\.\.)')
+ day_sch_str=day_pattern1.findall(file_contents)+ \
+ day_pattern2.findall(file_contents)
+ day_schedule_dict=_inp_day_schedule_dictionary(day_sch_str)
+ # extract all of the WEEK-SCHEDULE-PD objects
+ week_pattern=re.compile(r'(?i)(".*=.*WEEK-SCHEDULE-PD\n[\s\S]*?\.\.)')
+ week_sch_str=week_pattern.findall(file_contents)
+ week_sch_dict,week_dd_dict=_inp_week_schedule_dictionary(
+ week_sch_str,day_schedule_dict)
+ # extract all of the SCHEDULE objects and convert to ScheduleRuleset
+ year_pattern1=re.compile(r'(?i)(".*=.*SCHEDULE\n[\s\S]*?\.\.)')
+ year_pattern2=re.compile(r'(?i)(".*=.*SCHEDULE-PD\n[\s\S]*?\.\.)')
+ year_sch_str=year_pattern1.findall(file_contents)+ \
+ year_pattern2.findall(file_contents)
+
+ # translate each SCHEDULE and check to be sure ScheduleDay objects are unique
+ schedules=[]
+ foryear_schinyear_sch_str:
+ try:
+ yr_sch=_convert_schedule_year(year_sch,week_sch_dict,week_dd_dict)
+ schedules.append(yr_sch)
+ exceptException:
+ pass# schedule is not translate-able
+ returnschedules
+
+
+
+"""______EXTRA UTILITY FUNCTIONS RELATED TO SCHEDULES______"""
+
+
+
+[docs]
+defenergy_trans_sch_to_transmittance(shade_obj):
+"""Try to extract the transmittance from the shade energy properties."""
+ trans=0
+ trans_sch=shade_obj.properties.energy.transmittance_schedule
+ iftrans_schisnotNone:
+ iftrans_sch.is_constant:
+ try:# assume ScheduleRuleset
+ trans=trans_sch.default_day_schedule[0]
+ exceptAttributeError:# ScheduleFixedInterval
+ trans=trans_sch.values[0]
+ else:# not a constant schedule; use the average transmittance
+ try:# assume ScheduleRuleset
+ sch_vals=trans_sch.values()
+ exceptException:# ScheduleFixedInterval
+ sch_vals=trans_sch.values
+ trans=round(sum(sch_vals)/len(sch_vals),3)
+ returntrans
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/honeybee_doe2/simulation.html b/docs/_modules/honeybee_doe2/simulation.html
new file mode 100644
index 0000000..b3922a3
--- /dev/null
+++ b/docs/_modules/honeybee_doe2/simulation.html
@@ -0,0 +1,615 @@
+
+
+
+
+
+
+ honeybee_doe2.simulation — honeybee-doe2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[docs]
+classSimulationPar(object):
+"""Complete set of DOE-2 Simulation Settings.
+
+ Args:
+ title: Text for the title of the project. (Default: *Unnamed*).
+ run_period: A honeybee-energy RunPeriod object to describe the time period
+ over which to run the simulation. (Default: Run for the whole year).
+ site: A SiteData object describing the site where the simulation is
+ run. (Default: HArtford, CT).
+
+ Properties:
+ * title
+ * run_period
+ * site
+ """
+ __slots__=('_title','_run_period','_site')
+
+ def__init__(self,title='Unnamed',run_period=None,site=None):
+"""Initialize SimulationPar."""
+ self.title=title
+ self.run_period=run_period
+ self.site=site
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a SimulationPar object from a dictionary.
+
+ Args:
+ data: A SimulationPar dictionary in following the format below.
+
+ .. code-block:: python
+
+ {
+ "type": "SimulationPar",
+ "title": 'sample_project', # Text for the title
+ "run_period": {}, # Honeybee RunPeriod dictionary
+ "site": {}, # Honeybee SiteData dictionary
+ }
+ """
+ assertdata['type']=='SimulationPar', \
+ 'Expected SimulationPar dictionary. Got {}.'.format(data['type'])
+ title=data['title']if'title'indataelse'Unnamed'
+ run_period=None
+ if'run_period'indataanddata['run_period']isnotNone:
+ run_period=RunPeriod.from_dict(data['run_period'])
+ site=None
+ if'site'indataanddata['site']isnotNone:
+ site=SiteData.from_dict(data['site'])
+ returncls(title,run_period,site)
+
+
+ @property
+ deftitle(self):
+"""Get or set text for the title of the project."""
+ returnself._title
+
+ @title.setter
+ deftitle(self,value):
+ ifvalue:
+ value=clean_doe2_string(value,GEO_CHARS)
+ else:
+ value=None
+ self._title=value
+
+ @property
+ defrun_period(self):
+"""Get or set a RunPeriod object for the time period to run the simulation."""
+ returnself._run_period
+
+ @run_period.setter
+ defrun_period(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,RunPeriod),'Expected RunPeriod for ' \
+ 'SimulationPar run_period. Got {}.'.format(type(value))
+ self._run_period=value
+ else:
+ self._run_period=RunPeriod()
+
+ @property
+ defsite(self):
+"""Get or set a SiteData object for the project site of the simulation."""
+ returnself._site
+
+ @site.setter
+ defsite(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,SiteData),'Expected SiteData for ' \
+ 'SimulationPar site. Got {}.'.format(type(value))
+ self._site=value
+ else:
+ self._site=SiteData()
+
+
+[docs]
+ defto_inp(self):
+"""Get an DOE-2 INP string representation of the SimulationPar."""
+ # add the starting headers
+ sp_str=[]
+ sp_str.append(header_comment_minor('Abort, Diagnostics'))
+ sp_str.append(header_comment_minor('Global Parameters'))
+ sp_str.append(header_comment_minor('Title, Run Periods, Design Days, Holidays'))
+ # add the title and run period
+ title_str= \
+ 'TITLE\n' \
+ ' LINE-1 = *{}*\n' \
+ ' ..\n'.format(self.title)
+ sp_str.append(title_str)
+ sp_str.append(self.run_period.to_inp())
+ # add the site and building data
+ sp_str.append(header_comment_minor('Compliance Data'))
+ sp_str.append(header_comment_minor('Site and Building Data'))
+ sp_str.append(self.site.to_inp())
+ return'\n'.join(sp_str)
+[docs]
+classSiteData(object):
+"""Object to describe the project site of the simulation.
+
+ Args:
+ altitude: A number for the altitude of the location above sea level
+ in Feet. (Default: 150).
+
+ Properties:
+ * altitude
+ """
+ __slots__=('_altitude',)
+
+ def__init__(self,altitude=150):
+"""Initialize SimulationPar."""
+ self.altitude=altitude
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a SiteData object from a dictionary.
+
+ Args:
+ data: A SiteData dictionary in following the format below.
+
+ .. code-block:: python
+
+ {
+ "type": "SiteData",
+ "altitude": 100 # altitude above sea level (ft)
+ }
+ """
+ assertdata['type']=='SiteData', \
+ 'Expected SiteData dictionary. Got {}.'.format(data['type'])
+ altitude=data['altitude']if'altitude'indataelse150
+ returncls(altitude)
+
+
+ @property
+ defaltitude(self):
+"""A number for the altitude of the location above sea level in Feet."""
+ returnself._altitude
+
+ @altitude.setter
+ defaltitude(self,value):
+ self._altitude=int_in_range(value,input_name='site data altitude')
+
+
+[docs]
+ defto_inp(self):
+"""Get an DOE-2 INP string representation of the SiteData."""
+ # create the INP string for the site
+ keywords=('ALTITUDE','C-STATE','C-WEATHER-FILE',
+ 'C-COUNTRY','C-901-LOCATION')
+ values=(self.altitude,'21','*TMY2\\HARTFOCT.bin*','1','1092')
+ site_str=generate_inp_string('Site Data','SITE-PARAMETERS',keywords,values)
+ # create the INP string for the building data
+ keywords,values=('HOLIDAYS',),('"Standard US Holidays"',)
+ bldg_str=generate_inp_string(
+ 'Building Data','BUILD-PARAMETERS',keywords,values)
+ returnsite_str+bldg_str
+[docs]
+defrun_period_to_inp(run_period):
+"""Translate a honeybee-energy RunPeriod object to a DOE-2 INP string"""
+ # create the string for the run period
+ year=2020ifrun_period.is_leap_yearelse2021
+ keywords=('BEGIN-MONTH','BEGIN-DAY','BEGIN-YEAR',
+ 'END-MONTH','END-DAY','END-YEAR')
+ values=(run_period.start_date.month,run_period.start_date.day,year,
+ run_period.end_date.month,run_period.end_date.day,year)
+ rp_str=generate_inp_string('Default Run Period','RUN-PERIOD-PD',keywords,values)
+ # create the string for the holidays
+ keywords,values=('LIBRARY-ENTRY',),('"US"',)
+ hol_str=generate_inp_string('Standard US Holidays','HOLIDAYS',keywords,values)
+ returnrp_str+hol_str
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/honeybee_doe2/util.html b/docs/_modules/honeybee_doe2/util.html
new file mode 100644
index 0000000..ae762d7
--- /dev/null
+++ b/docs/_modules/honeybee_doe2/util.html
@@ -0,0 +1,537 @@
+
+
+
+
+
+
+ honeybee_doe2.util — honeybee-doe2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# coding=utf-8
+"""Various utilities used throughout the package."""
+from__future__importdivision
+
+importre
+importos
+
+
+
+[docs]
+defgenerate_inp_string(u_name,command,keywords,values):
+"""Get an INP string representation of a DOE-2 object.
+
+ This method is written in a generic way so that it can describe practically
+ any element of the INP Building Description Language (BDL).
+
+ Args:
+ u_name: Text for the unique, user-specified name of the object being created.
+ This must be 32 characters or less and not contain special or non-ASCII
+ characters. The clean_doe2_string method may be used to convert
+ strings to a format that is acceptable here. For example, a U-Name
+ of a space might be "Floor2W ClosedOffice5".
+ command: Text indicating the type of instruction that the DOE-2 object
+ executes. Commands are typically in capital letters and examples
+ include POLYGON, FLOOR, SPACE, EXTERIOR-WALL, WINDOW, CONSTRUCTION, etc.
+ keywords: A list of text with the same length as the values that denote
+ the attributes of the DOE-2 object.
+ values: A list of values with the same length as the keywords that describe
+ the values of the attributes for the object.
+
+ Returns:
+ inp_str -- A DOE-2 INP string representing a single object.
+ """
+ space_count=tuple((25-len(str(n)))forninkeywords)
+ spc=tuple(s_c*' 'ifs_c>0else' 'fors_cinspace_count)
+ body_str='\n'.join(' {}{}= {}'.format(kwd,s,val)
+ forkwd,s,valinzip(keywords,spc,values))
+ inp_str='"{}" = {}\n{}\n ..\n'.format(u_name,command,body_str)
+ returninp_str
+
+
+
+
+[docs]
+defgenerate_inp_string_list_format(u_name,command,keywords,values):
+"""Get an INP string of a DOE-2 object with nicer formatting for list values.
+
+ This method will process any values that are a list or tuple and format them
+ such that they are indented and more readable. This method is written in a
+ generic way so that it can describe practically any element of the INP Building
+ Description Language (BDL).
+
+ Args:
+ u_name: Text for the unique, user-specified name of the object being created.
+ This must be 32 characters or less and not contain special or non-ASCII
+ characters. The clean_doe2_string method may be used to convert
+ strings to a format that is acceptable here. For example, a U-Name
+ of a space might be "Floor2W ClosedOffice5".
+ command: Text indicating the type of instruction that the DOE-2 object
+ executes. Commands are typically in capital letters and examples
+ include POLYGON, FLOOR, SPACE, EXTERIOR-WALL, WINDOW, CONSTRUCTION, etc.
+ keywords: A list of text with the same length as the values that denote
+ the attributes of the DOE-2 object.
+ values: A list of values with the same length as the keywords that describe
+ the values of the attributes for the object. The items in this list
+ can be list themselves, in which case they will be translated with
+ nice indented formatting.
+
+ Returns:
+ inp_str -- A DOE-2 INP string representing a single object.
+ """
+ space_count=tuple((25-len(str(n)))forninkeywords)
+ spc=tuple(s_c*' 'ifs_c>0else' 'fors_cinspace_count)
+ body_strs=[]
+ forkwd,s,valinzip(keywords,spc,values):
+ ifisinstance(val,(list,tuple)):
+ body_strs.append(' {}{}= ('.format(kwd,s))
+ forvinval:
+ body_strs.append(' {},'.format(v))
+ body_strs.append(' )')
+ else:
+ body_strs.append(' {}{}= {}'.format(kwd,s,val))
+ body_str='\n'.join(body_strs)
+ inp_str='"{}" = {}\n{}\n ..\n'.format(u_name,command,body_str)
+ returninp_str
+
+
+
+
+[docs]
+defclean_inp_file_contents(inp_file):
+"""Get the contents of an INP file without any commented lines.
+
+ These comment lines might interfere with regex parsing if they are present.
+
+ Args:
+ inp_file: A path to an IDF file containing objects to be parsed.
+
+ Returns:
+ A single string for the clean IDF file contents.
+ """
+ assertos.path.isfile(inp_file),'Cannot find an INP file at: {}'.format(inp_file)
+ file_lines=[]
+ withopen(inp_file,'r')asep_file:
+ forlineinep_file:
+ ifnotline.startswith('$'):
+ file_lines.append(line)
+ return''.join(file_lines)
+
+
+
+
+[docs]
+defparse_inp_string(inp_string):
+"""Parse an INP string of a single DOE-2 object into a list of values.
+
+ Note that this method is only equipped to parse DOE-2 test strings
+ that originate from eQuest or from this package. It has not yet
+ been generalized to parse all formats of text formats that can
+ appear in a DOE-2 file.
+
+ Args:
+ inp_string: An INP string for a single DOE-2 object.
+
+ Returns:
+ A tuple with four elements.
+
+ - u_name: Text for the unique name of the object.
+
+ - command: Text for the type of instruction that the DOE-2 object executes.
+
+ - keywords: A list of text with the same length as the values that denote
+ the attributes of the DOE-2 object.
+
+ - values: A list of values with the same length as the keywords that describe
+ the values of the attributes for the object.
+ """
+ inp_string=inp_string.strip()
+ inp_strings=inp_string.split('..')
+ assertlen(inp_strings)==2,'Received more than one object in inp_string.'
+ inp_string=re.sub(r'\$.*\n','\n',inp_strings[0])# remove all comments
+ doe2_fields=[e_str.strip()fore_strininp_string.split('=')]
+ u_name=doe2_fields.pop(0).replace('"','')
+ split_field_1=doe2_fields[0].split('\n')
+ command=split_field_1[0].strip()
+ keywords=[split_field_1[1].strip()]
+ values=[]
+ forfieldindoe2_fields[1:]:
+ split_field=[f.strip()forfinfield.split('\n')]
+ iflen(split_field)==1:
+ values.append(split_field[0])
+ eliflen(split_field)==2andnotsplit_field[0].endswith(','):
+ values.append(split_field[0])
+ keywords.append(split_field[1])
+ else:
+ v_lines,end_val=[],False
+ forrowinsplit_field:
+ ifrow.endswith(',')orrow.endswith('('):
+ v_lines.append(row)
+ elifnotend_val:
+ v_lines.append(row)
+ end_val=True
+ else:
+ keywords.append(row)
+ values.append(' '.join(v_lines))
+ returnu_name,command,keywords,values
+
+
+
+
+[docs]
+defheader_comment_minor(header_text):
+"""Create a header given header_text, which can help organize the INP file contents.
+ """
+ return \
+ '$ ---------------------------------------------------------\n' \
+ '$ {}\n' \
+ '$ ---------------------------------------------------------\n'\
+ '\n'.format(header_text)
+
+
+
+
+[docs]
+defheader_comment_major(header_text):
+"""Create a header given header_text, which can help organize the INP file contents.
+ """
+ return \
+ '$ *********************************************************\n' \
+ '$ ** **\n' \
+ '$ {}\n' \
+ '$ ** **\n' \
+ '$ *********************************************************\n'\
+ '\n'.format(header_text)
+
+
+
+
+[docs]
+defswitch_statement_id(value):
+"""Convert a string into a 4-character ID that can be used for switch statements.
+
+ This is needed to deal with the major limitations that DOE-2 places on
+ switch statement IDs, where every ID must be 4 characters
+ """
+ # first remove dangerous characters
+ val=re.sub(r'[^.A-Za-z0-9:]','',value)# remove all unusable characters
+ val=val.replace(' ','').replace('_','')# remove spaces and underscores
+
+ # the user has formatted their program id specifically for switch statements
+ iflen(val)<=4:
+ returnval
+
+ # remove lower-case vowels for readability
+ val=re.sub(r'[aeiouy_\-]','',val)
+ if'::'inval:# program id originating from openstudio-standards
+ val=val.split('::')[-1]
+ iflen(val)>=4:
+ returnval[:4]
+
+ # some special user-generated program id
+ val=val.replace(':','')
+ iflen(val)>=4:
+ returnval[-4:]
+ returnval
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/honeybee_doe2/writer.html b/docs/_modules/honeybee_doe2/writer.html
new file mode 100644
index 0000000..d254934
--- /dev/null
+++ b/docs/_modules/honeybee_doe2/writer.html
@@ -0,0 +1,1385 @@
+
+
+
+
+
+
+ honeybee_doe2.writer — honeybee-doe2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[docs]
+defface_3d_to_inp(face_3d,parent_name='HB object'):
+"""Convert a Face3D into a DOE-2 POLYGON string and info to position it in space.
+
+ In this operation, all holes in the Face3D are ignored since they are not
+ supported by DOE-2. Collapsing the boundary and holes into a single list
+ that winds inward to cut out the holes will cause eQuest to raise an error.
+
+ Args:
+ face_3d: A ladybug-geometry Face3D object for which a INP POLYGON
+ string will be generated.
+ parent_name: The name of the parent object that will reference this
+ POLYGON. This will be used to generate a name for the polygon.
+ Note that this should ideally have 24 characters or less so that
+ the result complies with the strict 32 character limit of DOE-2
+ identifiers.
+
+ Returns:
+ A tuple with two elements.
+
+ - polygon_str: Text string for the INP polygon.
+
+ - position_info: A tuple of values used to locate the Polygon in 3D space.
+ The order of properties in the tuple is as follows: (ORIGIN, TILT, AZIMUTH).
+ """
+ # TODO: Consider adding a workaround for the DOE-2 limit of 40 vertices
+ # perhaps we can just say NO-SHAPE and specify AREA, VOLUME, and HEIGHT
+ # get the main properties that place the geometry in 3D space
+ pts_3d=face_3d.lower_left_counter_clockwise_boundary
+ tilt,azimuth=math.degrees(face_3d.tilt),math.degrees(face_3d.azimuth)
+ llc_origin=face_3d.lower_left_corner
+ llc_coords=[]
+ forcoordinllc_origin:# avoid signed zero
+ coord=round(coord,GEO_DEC_COUNT)
+ clean_coord=0.0ifcoord==0elsecoord
+ llc_coords.append(clean_coord)
+ llc_origin=Point3D.from_array(llc_coords)
+
+ # get the 2D vertices in the plane of the Face
+ ifDOE2_ANGLE_TOL<=tilt<=180-DOE2_ANGLE_TOL:# vertical or tilted
+ proj_y=Vector3D(0,0,1).project(face_3d.normal)
+ proj_x=proj_y.rotate(face_3d.normal,math.pi/-2)
+ ref_plane=Plane(face_3d.normal,llc_origin,proj_x)
+ vertices=[ref_plane.xyz_to_xy(pt)forptinpts_3d]
+ else:# horizontal; ensure vertices are always counterclockwise from above
+ azimuth=180.0
+ llc=Point2D(llc_origin.x,llc_origin.y)
+ vertices=[Point2D(v.x-llc.x,v.y-llc.y)forvinpts_3d]
+ iftilt>180-DOE2_ANGLE_TOL:
+ vertices=[Point2D(v.x,-v.y)forvinvertices]
+
+ # format the vertices into a POLYGON string
+ verts_values=[]
+ forptinvertices:
+ x_coord=round(pt.x,GEO_DEC_COUNT)
+ y_coord=round(pt.y,GEO_DEC_COUNT)
+ ifx_coord==0:# avoid signed zero
+ x_coord=0.0
+ ify_coord==0:# avoid signed zero
+ y_coord=0.0
+ verts_values.append('({}, {})'.format(x_coord,y_coord))
+ verts_keywords=tuple('V{}'.format(i+1)foriinrange(len(verts_values)))
+ poly_name='{} Plg'.format(parent_name)
+ polygon_str=generate_inp_string(poly_name,'POLYGON',verts_keywords,verts_values)
+ position_info=(llc_origin,tilt,azimuth)
+ returnpolygon_str,position_info
+
+
+
+
+[docs]
+defface_3d_to_inp_rectangle(face_3d):
+"""Convert a Face3D into parameters needed to represent it as a rectangle in INP.
+
+ The output of this function will be None if the Face3D cannot be represented
+ as an INP rectangle without alteration of the geometry.
+
+ Args:
+ face_3d: A ladybug-geometry Face3D object which will be tested for whether
+ it can be represented as a rectangle in INP.
+
+ Returns:
+ Will be None if the Face3D cannot be translated to a WIDTH and HEIGHT
+ without alteration of the geometry. If the geometry can be successfully
+ translated, this will be a tuple with five elements.
+
+ - width: A number for the width of the rectangle.
+
+ - height: A number for the height of the rectangle.
+
+ - llc_origin: A Point3D for the lower-left corner of the Shade
+ geometry origin.
+
+ - tilt: A number for the tilt of the rectangle in degrees.
+
+ - azimuth: A number for the azimuth of the rectangle in degrees.
+ """
+ ifface_3d.boundary_polygon2d.is_rectangle(math.radians(DOE2_ANGLE_TOL)):
+ # check to see at least one of the segments is horizontal
+ are_segs_hor=[seg.max.z-seg.min.z<=DOE2_TOLERANCE
+ forseginface_3d.boundary_segments]
+ ifTrueinare_segs_hor:
+ pts_3d=face_3d.lower_left_counter_clockwise_boundary
+ llc_origin=pts_3d[0]
+ width=llc_origin.distance_to_point(pts_3d[1])
+ height=llc_origin.distance_to_point(pts_3d[-1])
+ ifall(is_horizforis_horizinare_segs_hor):# horizontal; adjust azimuth
+ tilt=0.0
+ hgt_vec=llc_origin-pts_3d[-1]
+ hgt_vec_2d=Vector2D(hgt_vec.x,hgt_vec.y)
+ azimuth=math.degrees(Vector2D(0,1).angle_clockwise(hgt_vec_2d))
+ else:# vertical or tilted; use Face3D azimuth
+ tilt=math.degrees(face_3d.tilt)
+ azimuth=math.degrees(face_3d.azimuth)
+ returnwidth,height,llc_origin,tilt,azimuth
+ returnNone
+
+
+
+
+[docs]
+defshade_mesh_to_inp(shade_mesh,equest_version=None):
+"""Generate an INP string representation of a ShadeMesh.
+
+ Args:
+ shade_mesh: A honeybee ShadeMesh for which an INP representation
+ will be returned.
+ equest_version: An optional text string to denote the version of eQuest
+ for which the Shade INP definition will be generated. If unspecified
+ or unrecognized, the latest version of eQuest will be used.
+
+ Returns:
+ A tuple with two elements.
+
+ - shade_polygons: A list of text strings for the INP polygons needed
+ to represent the ShadeMesh.
+
+ - shade_defs: A list of text strings for the INP definitions needed
+ to represent the ShadeMesh.
+ """
+ # extract the transmittance properties of the shade
+ base_id=clean_doe2_string(shade_mesh.identifier,GEO_CHARS)
+ trans_kwd=['TRANSMITTANCE']
+ trans_vals=[energy_trans_sch_to_transmittance(shade_mesh)]
+ t_sch_obj=shade_mesh.properties.energy.transmittance_schedule
+ ift_sch_objisnotNoneandnott_sch_obj.is_constant:
+ trans_kwd.append('SHADE-SCHEDULE')
+ t_shc_id=clean_doe2_string(t_sch_obj.identifier,RES_CHARS)
+ trans_vals.append('"{}"'.format(t_shc_id))
+
+ # set up collector lists and properties for all shades
+ shade_polygons,shade_defs=[],[]
+
+ # loop through the mesh faces and create individual shade objects
+ fori,faceinenumerate(shade_mesh.geometry.face_vertices):
+ doe2_id='{}{}'.format(base_id,i)
+ f_geo=Face3D(face)
+ shd_geo=f_geoiff_geo.altitude>0elsef_geo.flip()
+ clean_geo=shd_geo.remove_colinear_vertices(DOE2_TOLERANCE)
+ rect_info=face_3d_to_inp_rectangle(clean_geo)
+ ifequest_version=='3.64':
+ shade_polygon=''
+ ifrect_infoisnotNone:
+ width,height,origin,tilt,az=rect_info
+ else:# take the bounding rectangle around the Face3D
+ min_pt,max_pt=clean_geo.min,clean_geo.max
+ f_tilt=math.degrees(clean_geo.tilt)
+ if90-DOE2_ANGLE_TOL<=f_tilt<=90+DOE2_ANGLE_TOL:# vertical
+ seg_dir=Vector3D(max_pt.x-min_pt.x,max_pt.y-min_pt.y,0)
+ seg=LineSegment3D(min_pt,seg_dir)
+ ext_dir=Vector3D(0,0,max_pt.z-min_pt.z)
+ else:# horizontal or tilted
+ seg=LineSegment3D(min_pt,Vector3D(max_pt.x-min_pt.x,0,0))
+ ext_dir=Vector3D(0,max_pt.y-min_pt.y,max_pt.z-min_pt.z)
+ rect_geo=Face3D.from_extrusion(seg,ext_dir)
+ width,height,origin,tilt,az=face_3d_to_inp_rectangle(rect_geo)
+ geo_kwd,geo_vals=['HEIGHT','WIDTH'],[height,width]
+ elifrect_infoisnotNone:# shade is a rectangle; translate it without POLYGON
+ width,height,origin,tilt,az=rect_info
+ geo_kwd=['SHAPE','HEIGHT','WIDTH']
+ geo_vals=['RECTANGLE',height,width]
+ else:# otherwise, create the polygon string from the geometry
+ shade_polygon,pos_info=face_3d_to_inp(clean_geo,doe2_id)
+ shade_polygons.append(shade_polygon)
+ origin,tilt,az=pos_info
+ geo_kwd=['SHAPE','POLYGON']
+ geo_vals=['POLYGON','"{} Plg"'.format(doe2_id)]
+ geo_kwd.extend(('X-REF','Y-REF','Z-REF','TILT','AZIMUTH'))
+ geo_vals.extend((round(origin.x,GEO_DEC_COUNT),round(origin.y,GEO_DEC_COUNT),
+ round(origin.z,GEO_DEC_COUNT),tilt,az))
+ # create the final shade definition, which includes the position information
+ keywords=geo_kwd+trans_kwd
+ values=geo_vals+trans_vals
+ shade_def=generate_inp_string(doe2_id,'FIXED-SHADE',keywords,values)
+ shade_defs.append(shade_def)
+
+ returnshade_polygons,shade_defs
+
+
+
+
+[docs]
+defshade_to_inp(shade,equest_version=None):
+"""Generate an INP string representation of a Shade.
+
+ Args:
+ shade: A honeybee Shade for which an INP representation will be returned.
+ equest_version: An optional text string to denote the version of eQuest
+ for which the Shade INP definition will be generated. If unspecified
+ or unrecognized, the latest version of eQuest will be used.
+
+ Returns:
+ A tuple with two elements.
+
+ - shade_polygon: Text string for the INP polygon for the Shade.
+
+ - shade_def: Text string for the INP definition of the Shade.
+ """
+ # extract the transmittance properties of the shade
+ doe2_id=clean_doe2_string(shade.identifier,GEO_CHARS)
+ trans_kwd=['TRANSMITTANCE']
+ trans_vals=[energy_trans_sch_to_transmittance(shade)]
+ t_sch_obj=shade.properties.energy.transmittance_schedule
+ ift_sch_objisnotNoneandnott_sch_obj.is_constant:
+ trans_kwd.append('SHADE-SCHEDULE')
+ t_shc_id=clean_doe2_string(t_sch_obj.identifier,RES_CHARS)
+ trans_vals.append('"{}"'.format(t_shc_id))
+
+ # extract the geometry properties of the shade
+ shd_geo=shade.geometryifshade.altitude>0elseshade.geometry.flip()
+ clean_geo=shd_geo.remove_colinear_vertices(DOE2_TOLERANCE)
+ rect_info=face_3d_to_inp_rectangle(clean_geo)
+ ifequest_version=='3.64':
+ shade_polygon=''
+ ifrect_infoisnotNone:
+ width,height,origin,tilt,az=rect_info
+ else:# take the bounding rectangle around the Face3D
+ min_pt,max_pt=clean_geo.min,clean_geo.max
+ f_tilt=math.degrees(clean_geo.tilt)
+ if90-DOE2_ANGLE_TOL<=f_tilt<=90+DOE2_ANGLE_TOL:# vertical
+ seg_dir=Vector3D(max_pt.x-min_pt.x,max_pt.y-min_pt.y,0)
+ seg=LineSegment3D(min_pt,seg_dir)
+ ext_dir=Vector3D(0,0,max_pt.z-min_pt.z)
+ else:# horizontal or tilted
+ seg=LineSegment3D(min_pt,Vector3D(max_pt.x-min_pt.x,0,0))
+ ext_dir=Vector3D(0,max_pt.y-min_pt.y,max_pt.z-min_pt.z)
+ rect_geo=Face3D.from_extrusion(seg,ext_dir)
+ width,height,origin,tilt,az=face_3d_to_inp_rectangle(rect_geo)
+ geo_kwd,geo_vals=['HEIGHT','WIDTH'],[height,width]
+ elifrect_infoisnotNone:# shade is a rectangle; translate it without POLYGON
+ width,height,origin,tilt,az=rect_info
+ geo_kwd=['SHAPE','HEIGHT','WIDTH']
+ geo_vals=['RECTANGLE',height,width]
+ shade_polygon=''
+ else:# otherwise, create the polygon string from the geometry
+ shade_polygon,pos_info=face_3d_to_inp(clean_geo,doe2_id)
+ origin,tilt,az=pos_info
+ geo_kwd=['SHAPE','POLYGON']
+ geo_vals=['POLYGON','"{} Plg"'.format(doe2_id)]
+ geo_kwd.extend(('X-REF','Y-REF','Z-REF','TILT','AZIMUTH'))
+ geo_vals.extend((round(origin.x,GEO_DEC_COUNT),round(origin.y,GEO_DEC_COUNT),
+ round(origin.z,GEO_DEC_COUNT),tilt,az))
+
+ # create the final shade definition, which includes the position information
+ keywords=geo_kwd+trans_kwd
+ values=geo_vals+trans_vals
+ shade_def=generate_inp_string(doe2_id,'FIXED-SHADE',keywords,values)
+ returnshade_polygon,shade_def
+
+
+
+
+[docs]
+defdoor_to_inp(door):
+"""Generate an INP string representation of a Door.
+
+ Doors assigned to a parent Face will use the parent Face plane in order to
+ determine their XY coordinates. Otherwise, the Door's own plane will be used.
+
+ Note that the resulting string does not include full construction definitions.
+ Also note that shades assigned to the Door are not included in the resulting
+ string. To write these objects into a final string, you must loop through the
+ Door.shades, and call the to.inp method on each one.
+
+ Args:
+ door: A honeybee Door for which an INP representation will be returned.
+
+ Returns:
+ Text string for the INP definition of the Door.
+ """
+ # extract the plane information from the parent geometry
+ ifdoor.has_parent:
+ parent_llc=door.parent.geometry.lower_left_corner
+ rel_plane=door.parent.geometry.plane
+ else:
+ parent_llc=door.geometry.lower_left_corner
+ rel_plane=door.geometry.plane
+ # get the LLC and URC of the bounding rectangle of the door
+ apt_llc=door.geometry.lower_left_corner
+ apt_urc=door.geometry.upper_right_corner
+
+ # determine the width and height and origin in the parent coordinate system
+ ifDOE2_ANGLE_TOL<=door.tilt<=180-DOE2_ANGLE_TOL:# vertical or tilted
+ proj_y=Vector3D(0,0,1).project(rel_plane.n)
+ proj_x=proj_y.rotate(rel_plane.n,math.pi/-2)
+ else:# located within the XY plane
+ proj_x=Vector3D(1,0,0)
+ ref_plane=Plane(rel_plane.n,parent_llc,proj_x)
+ min_2d=ref_plane.xyz_to_xy(apt_llc)
+ max_2d=ref_plane.xyz_to_xy(apt_urc)
+ width=round(max_2d.x-min_2d.x,GEO_DEC_COUNT)
+ height=round(max_2d.y-min_2d.y,GEO_DEC_COUNT)
+
+ # create the aperture definition
+ doe2_id=clean_doe2_string(door.identifier,GEO_CHARS)
+ dr_con=door.properties.energy.construction
+ constr_o_name=dr_con.identifierifisinstance(dr_con,OpaqueConstruction) \
+ elsedr_con.identifier+'_d'
+ constr=clean_doe2_string(constr_o_name,RES_CHARS)
+ keywords=('X','Y','WIDTH','HEIGHT','CONSTRUCTION')
+ values=(round(min_2d.x,GEO_DEC_COUNT),round(min_2d.y,GEO_DEC_COUNT),
+ width,height,'"{}"'.format(constr))
+ door_def=generate_inp_string(doe2_id,'DOOR',keywords,values)
+ returndoor_def
+
+
+
+
+[docs]
+defaperture_to_inp(aperture):
+"""Generate an INP string representation of a Aperture.
+
+ Apertures assigned to a parent Face will use the parent Face plane in order to
+ determine their XY coordinates. Otherwise, the Aperture's own plane will be used.
+
+ Note that the resulting string does not include full construction definitions.
+ Also note that shades assigned to the Aperture are not included in the resulting
+ string. To write these objects into a final string, you must loop through the
+ Aperture.shades, and call the to.inp method on each one.
+
+ Args:
+ aperture: A honeybee Aperture for which an INP representation will be returned.
+
+ Returns:
+ Text string for the INP definition of the Aperture.
+ """
+ # extract the plane information from the parent geometry
+ ifaperture.has_parent:
+ parent_llc=aperture.parent.geometry.lower_left_corner
+ rel_plane=aperture.parent.geometry.plane
+ else:
+ parent_llc=aperture.geometry.lower_left_corner
+ rel_plane=aperture.geometry.plane
+ # get the LLC and URC of the bounding rectangle of the aperture
+ apt_llc=aperture.geometry.lower_left_corner
+ apt_urc=aperture.geometry.upper_right_corner
+
+ # determine the width and height and origin in the parent coordinate system
+ ifDOE2_ANGLE_TOL<=aperture.tilt<=180-DOE2_ANGLE_TOL:# vertical or tilted
+ proj_y=Vector3D(0,0,1).project(rel_plane.n)
+ proj_x=proj_y.rotate(rel_plane.n,math.pi/-2)
+ else:# located within the XY plane
+ proj_x=Vector3D(1,0,0)
+ ref_plane=Plane(rel_plane.n,parent_llc,proj_x)
+ min_2d=ref_plane.xyz_to_xy(apt_llc)
+ max_2d=ref_plane.xyz_to_xy(apt_urc)
+ width=round(max_2d.x-min_2d.x,GEO_DEC_COUNT)
+ height=round(max_2d.y-min_2d.y,GEO_DEC_COUNT)
+
+ # create the aperture definition
+ doe2_id=clean_doe2_string(aperture.identifier,GEO_CHARS)
+ constr_o_name=aperture.properties.energy.construction.identifier
+ constr=clean_doe2_string(constr_o_name,RES_CHARS)
+ keywords=('X','Y','WIDTH','HEIGHT','GLASS-TYPE')
+ values=(round(min_2d.x,GEO_DEC_COUNT),round(min_2d.y,GEO_DEC_COUNT),
+ width,height,'"{}"'.format(constr))
+ aperture_def=generate_inp_string(doe2_id,'WINDOW',keywords,values)
+ returnaperture_def
+
+
+
+
+[docs]
+defface_to_inp(face,space_origin=Point3D(0,0,0),location=None):
+"""Generate an INP string representation of a Face.
+
+ Note that the resulting string does not include full construction definitions.
+
+ Also note that this does not include any of the shades assigned to the Face
+ in the resulting string. Nor does it include the strings for the
+ apertures or doors. To write these objects into a final string, you must
+ loop through the Face.apertures, and Face.doors and call the to.inp method
+ on each one.
+
+ Args:
+ face: A honeybee Face for which an INP representation will be returned.
+ space_origin: A ladybug-geometry Point3D for the origin of the space
+ to which the Face is assigned. (Default: (0, 0, 0)).
+ location: An optional text string to note the DOE-2 LOCATION of the
+ Face on the parent Room. When this is specified, the Face will be
+ written without using a POLYGON. (Default: None).
+
+ Returns:
+ A tuple with two elements.
+
+ - face_polygon: Text string for the INP polygon for the Face.
+
+ - face_def: Text string for the INP definition of the Face.
+ """
+ # set up attributes based on the face type and boundary condition
+ f_type_str,bc_str=str(face.type),str(face.boundary_condition)
+ ifbc_str=='Outdoors':
+ doe2_type='EXTERIOR-WALL'# DOE2 uses walls for a lot of things
+ iff_type_str=='RoofCeiling':
+ doe2_type='ROOF'
+ elifbc_strinDOE2_INTERIOR_BCSorf_type_str=='AirBoundary':
+ doe2_type='INTERIOR-WALL'# DOE2 uses walls for a lot of things
+ else:# likely ground or some other fancy ground boundary condition
+ doe2_type='UNDERGROUND-WALL'
+
+ # process the face identifier and the construction
+ doe2_id=clean_doe2_string(face.identifier,GEO_CHARS)
+ constr_o_name=face.properties.energy.construction.identifier
+ constr=clean_doe2_string(constr_o_name,RES_CHARS)
+
+ # process the geometry
+ iflocationisnotNone:
+ keywords=['CONSTRUCTION','LOCATION']
+ values=['"{}"'.format(constr),location]
+ face_polygon=''
+ else:# create the polygon string from the geometry
+ f_geo=face.geometry.remove_colinear_vertices(DOE2_TOLERANCE)
+ face_polygon,pos_info=face_3d_to_inp(f_geo,doe2_id)
+ face_origin,tilt,az=pos_info
+ origin=face_origin-space_origin
+ keywords=['POLYGON','CONSTRUCTION','TILT','AZIMUTH','X','Y','Z']
+ values=['"{} Plg"'.format(doe2_id),'"{}"'.format(constr),tilt,az,
+ round(origin.x,GEO_DEC_COUNT),
+ round(origin.y,GEO_DEC_COUNT),
+ round(origin.z,GEO_DEC_COUNT)]
+
+ # add information related to the boundary condition
+ ifbc_str=='Surface':
+ adj_room=face.boundary_condition.boundary_condition_objects[-1]
+ adj_id=clean_doe2_string(adj_room,GEO_CHARS)
+ values.append('"{}"'.format(adj_id))
+ keywords.append('NEXT-TO')
+ elifdoe2_type=='INTERIOR-WALL':# assume that it is adiabatic
+ keywords.append('INT-WALL-TYPE')
+ values.append('ADIABATIC')
+ iflocationisNoneandf_type_str=='Floor'anddoe2_type!='INTERIOR-WALL':
+ keywords.append('LOCATION')
+ values.append('BOTTOM')
+
+ # create the face definition
+ face_def=generate_inp_string(doe2_id,doe2_type,keywords,values)
+ returnface_polygon,face_def
+
+
+
+
+[docs]
+defroom_to_inp(room,floor_origin=Point3D(0,0,0),floor_height=None,
+ exclude_interior_walls=False,exclude_interior_ceilings=False):
+"""Generate an INP string representation of a Room.
+
+ This will include the Room's constituent Faces, Apertures and Doors with
+ each of these elements being a separate item in the list of strings returned.
+ However, any shades assigned to the Room or its constituent elements are
+ excluded and should be written by looping through the shades on the parent model.
+
+ The resulting string will also include all internal gain definitions for the
+ Room (people, lights, equipment), infiltration definitions, ventilation
+ requirements, and thermostat objects.
+
+ However, complete schedule definitions assigned to these load objects are
+ excluded as well as any construction or material definitions.
+
+ Args:
+ floor_origin: A ladybug-geometry Point3D for the origin of the
+ floor (aka. story) to which the Room is a part of. (Default: (0, 0, 0)).
+ floor_height: An optional number for the parent story SPACE-HEIGHT,
+ which will be used to check the Room geometry to determine if
+ it must be written using POLYGONs. If None, no check will be
+ performed. (Default: None)
+ exclude_interior_walls: Boolean to note whether interior wall Faces
+ should be excluded from the resulting string. (Default: False).
+ exclude_interior_ceilings: Boolean to note whether interior ceiling
+ Faces should be excluded from the resulting string. (Default: False).
+
+ Returns:
+ A tuple with two elements.
+
+ - room_polygons: A list of text strings for the INP polygons needed
+ to represent the Room and all of its constituent Faces.
+
+ - room_defs: A list of text strings for the INP definitions needed
+ to represent the Room and all of its constituent Faces, Apertures
+ and Doors.
+ """
+ # process the room identifier
+ doe2_id=clean_doe2_string(room.identifier,GEO_CHARS)
+
+ # set up attributes based on the Room's energy properties
+ energy_attr_keywords=['ZONE-TYPE']
+ energy_attr_values=[room_doe2_conditioning_type(room)]
+ ifroom.properties.energy._program_typeisnotNone:
+ energy_attr_keywords.append('C-ACTIVITY-DESC')
+ prog_uid=switch_statement_id(room.properties.energy.program_type.identifier)
+ energy_attr_values.append('*{}*'.format(prog_uid))
+ # people
+ ppl_kwd,ppl_val=people_to_inp(room.properties.energy._people)
+ energy_attr_keywords.extend(ppl_kwd)
+ energy_attr_values.extend(ppl_val)
+ # lighting
+ lgt_kwd,lgt_val=lighting_to_inp(room.properties.energy._lighting)
+ energy_attr_keywords.extend(lgt_kwd)
+ energy_attr_values.extend(lgt_val)
+ # equipment
+ eq_kwd,eq_val=electric_equipment_to_inp(
+ room.properties.energy._electric_equipment)
+ energy_attr_keywords.extend(eq_kwd)
+ energy_attr_values.extend(eq_val)
+ # hot water and gas usage
+ shw_gas_kwd,shw_gas_val=hot_water_and_gas_to_inp(
+ room.properties.energy.service_hot_water,
+ room.properties.energy.gas_equipment,room.floor_area)
+ energy_attr_keywords.extend(shw_gas_kwd)
+ energy_attr_values.extend(shw_gas_val)
+ # infiltration
+ inf_kwd,inf_val=infiltration_to_inp(room.properties.energy._infiltration)
+ energy_attr_keywords.extend(inf_kwd)
+ energy_attr_values.extend(inf_val)
+
+ def_is_room_3d_extruded(hb_room):
+"""Test if a Room is a pure extrusion.
+
+ Args:
+ hb_room: The Honeybee Room to be tested.
+
+ Returns:
+ A tuple with two elements.
+
+ - is_extrusion: True if the geometry is an extrusion. False if not.
+
+ - face_orientations: A list of integers that aligns with the Room.faces
+ and denotes whether each face is downward (-1), vertical (0) or
+ upward (+1).
+ """
+ # first check if we have to use POLYGONS because of the parent SPACE-HEIGHT
+ iffloor_heightisnotNone:
+ room_height=room.max.z-room.min.z
+ ifabs(room_height-floor_height)>DOE2_TOLERANCE:
+ returnFalse,[]
+
+ # set up the parameters for evaluating vertical or horizontal
+ vert_vec=Vector3D(0,0,1)
+ min_v_ang=math.radians(DOE2_ANGLE_TOL)
+ max_v_ang=math.pi-min_v_ang
+ min_h_ang=(math.pi/2)-min_v_ang
+ max_h_ang=(math.pi/2)+min_v_ang
+
+ # loop through the Room faces and test them
+ face_orientations=[]
+ forfaceinhb_room.faces:
+ try:# first make sure that the geometry is not degenerate
+ clean_geo=face.geometry.remove_colinear_vertices(DOE2_TOLERANCE)
+ v_ang=clean_geo.normal.angle(vert_vec)
+ ifv_ang<=min_v_ang:
+ face_orientations.append(1)
+ continue
+ elifv_ang>=max_v_ang:
+ face_orientations.append(-1)
+ continue
+ elifmin_h_ang<=v_ang<=max_h_ang:
+ face_orientations.append(0)
+ continue
+ returnFalse,[]
+ exceptAssertionError:# degenerate face to ignore
+ pass
+ returnTrue,face_orientations
+
+ # if the room is extruded, determine the locations of each face
+ face_locations=[]
+ is_extrusion,face_orientations=_is_room_3d_extruded(room)
+ ifis_extrusion:# try to translate without using POLYGON for the Room faces
+ ifroom.properties.doe2.space_polygon_geometryisnotNone:
+ r_geo=room.properties.doe2.space_polygon_geometry
+ else:
+ try:
+ r_geo=room.horizontal_boundary(
+ match_walls=True,tolerance=DOE2_TOLERANCE)
+ exceptException:# we may need to write it with NO-SHAPE
+ r_geo=None
+ ifr_geoisnotNone:
+ r_geo=r_geoifr_geo.normal.z>=0elser_geo.flip()
+ r_geo=r_geo.remove_duplicate_vertices(DOE2_TOLERANCE)
+ rm_pts=r_geo.lower_left_counter_clockwise_boundary
+ rm_height=room.max.z-room.min.z
+ ceil_count=len([orientfororientinface_orientationsiforient==1])
+ floor_count=len([orientfororientinface_orientationsiforient==-1])
+ forface,orientinzip(room.faces,face_orientations):
+ iforient==0:# wall to associate with a room vertex
+ clean_geo=face.geometry.remove_colinear_vertices(DOE2_TOLERANCE)
+ face_height=face.max.z-face.min.z
+ ifclean_geo.boundary_polygon2d.is_rectangle(DOE2_ANGLE_TOL)and \
+ abs(rm_height-face_height)<=DOE2_TOLERANCE:
+ f_origin=face.geometry.lower_left_corner
+ fori,r_ptinenumerate(rm_pts):
+ iff_origin.is_equivalent(r_pt,DOE2_TOLERANCE):
+ face_locations.append('SPACE-V{}'.format(i+1))
+ break
+ else:# not associated with any Room vertex
+ face_locations.append(None)
+ else:# not a rectangular geometry
+ face_locations.append(None)
+ eliforient==1:
+ loc='TOP'ifceil_count==1andnotr_geo.has_holeselseNone
+ face_locations.append(loc)
+ else:
+ loc='BOTTOM'iffloor_count==1elseNone
+ face_locations.append(loc)
+
+ # if the room is not extruded, just use the generic horizontal boundary
+ iflen(face_locations)==0:
+ ifroom.properties.doe2.space_polygon_geometryisnotNone:
+ r_geo=room.properties.doe2.space_polygon_geometry
+ else:
+ try:
+ r_geo=room.horizontal_boundary(
+ match_walls=False,tolerance=DOE2_TOLERANCE)
+ r_geo=r_geoifr_geo.normal.z>=0elser_geo.flip()
+ r_geo=r_geo.remove_colinear_vertices(tolerance=DOE2_TOLERANCE)
+ exceptException:# we may need to write it with NO-SHAPE
+ r_geo=None
+ face_locations=[None]*len(room.faces)
+
+ # create the space definition
+ ifr_geoisNone:# we have to use NO-SHAPE
+ msg='Using NO-SHAPE for SPACE "{}".'.format(room.display_name)
+ print(msg)
+ space_origin=room.min
+ origin=space_origin-floor_origin
+ keywords=['SHAPE','AZIMUTH','X','Y','Z','AREA','VOLUME']
+ values=['NO-SHAPE',0,round(origin.x,GEO_DEC_COUNT),
+ round(origin.y,GEO_DEC_COUNT),round(origin.z,GEO_DEC_COUNT),
+ round(room.floor_area,GEO_DEC_COUNT),
+ round(room.volume,GEO_DEC_COUNT)]
+ ifroom.multiplier!=1:
+ keywords.append('MULTIPLIER')
+ values.append(room.multiplier)
+ keywords.extend(energy_attr_keywords)
+ values.extend(energy_attr_values)
+ space_def=generate_inp_string(doe2_id,'SPACE',keywords,values)
+ room_polygons=[]
+ room_defs=[space_def]
+ else:
+ # create the room polygon string from the geometry
+ room_polygon,pos_info=face_3d_to_inp(r_geo,doe2_id)
+ space_origin,_,_=pos_info
+ origin=space_origin-floor_origin
+ # create the space definition, which includes the position info
+ keywords=['SHAPE','POLYGON','AZIMUTH','X','Y','Z','VOLUME']
+ values=['POLYGON','"{} Plg"'.format(doe2_id),0,
+ round(origin.x,GEO_DEC_COUNT),round(origin.y,GEO_DEC_COUNT),
+ round(origin.z,GEO_DEC_COUNT),round(room.volume,GEO_DEC_COUNT)]
+ ifroom.multiplier!=1:
+ keywords.append('MULTIPLIER')
+ values.append(room.multiplier)
+ keywords.extend(energy_attr_keywords)
+ values.extend(energy_attr_values)
+ space_def=generate_inp_string(doe2_id,'SPACE',keywords,values)
+ room_polygons=[room_polygon]
+ room_defs=[space_def]
+
+ # gather together all face definitions and polygons to define the room
+ forface,f_locinzip(room.faces,face_locations):
+ # first check if this is a face that should be excluded
+ ifisinstance(face.boundary_condition,Surface):
+ ifexclude_interior_wallsandisinstance(face.type,Wall):
+ continue
+ elifexclude_interior_ceilingsand \
+ isinstance(face.type,(Floor,RoofCeiling)):
+ continue
+ # add the face definition along with all apertures and doors
+ face_polygon,face_def=face_to_inp(face,space_origin,f_loc)
+ ifface_polygon!='':
+ room_polygons.append(face_polygon)
+ room_defs.append(face_def)
+ forapinface.apertures:
+ ap_def=aperture_to_inp(ap)
+ room_defs.append(ap_def)
+ ifnotisinstance(face.boundary_condition,Surface):
+ fordrinface.doors:
+ dr_def=door_to_inp(dr)
+ room_defs.append(dr_def)
+ returnroom_polygons,room_defs
+
+
+
+
+[docs]
+defmodel_to_inp(
+ model,simulation_par=None,hvac_mapping='Story',
+ exclude_interior_walls=False,exclude_interior_ceilings=False,equest_version=None
+):
+"""Generate an INP string representation of a Model.
+
+ The resulting string will include all geometry (Rooms, Faces, Apertures,
+ Doors, Shades), all fully-detailed constructions + materials, all fully-detailed
+ schedules, and the room properties. It will also include the simulation
+ parameters. Essentially, the string includes everything needed to simulate
+ the model.
+
+ Args:
+ model: A honeybee Model for which an INP representation will be returned.
+ simulation_par: A honeybee-doe2 SimulationPar object to specify how the
+ DOE-2 simulation should be run. If None, default simulation
+ parameters will be generated, which will run the simulation for the
+ full year. (Default: None).
+ hvac_mapping: Text to indicate how HVAC systems should be assigned to the
+ exported model. Story will assign one HVAC system for each distinct
+ level polygon, Model will use only one HVAC system for the whole model
+ and AssignedHVAC will follow how the HVAC systems have been assigned
+ to the Rooms.properties.energy.hvac. Choose from the options
+ below. (Default: Story).
+
+ * Room
+ * Story
+ * Model
+ * AssignedHVAC
+
+ exclude_interior_walls: Boolean to note whether interior wall Faces
+ should be excluded from the resulting string. (Default: False).
+ exclude_interior_ceilings: Boolean to note whether interior ceiling
+ Faces should be excluded from the resulting string. (Default: False).
+ equest_version: An optional text string to denote the version of eQuest
+ for which the INP definition will be generated. If unspecified
+ or unrecognized, the latest version of eQuest will be used.
+
+ Usage:
+
+ .. code-block:: python
+
+ import os
+ from ladybug.futil import write_to_file
+ from honeybee.model import Model
+ from honeybee.room import Room
+ from honeybee.config import folders
+
+ # Crate an input Model
+ room = Room.from_box('Tiny House Zone', 5, 10, 3)
+ room.properties.energy.program_type = office_program
+ room.properties.energy.add_default_ideal_air()
+ model = Model('Tiny House', [room])
+
+ # create the INP string for the model
+ inp_str = model.to.inp(model)
+
+ # write the final string into an INP
+ inp = os.path.join(folders.default_simulation_folder, 'test_file', 'in.inp')
+ write_to_file(inp, inp_str, True)
+ """
+ # duplicate model to avoid mutating it as we edit it for INP export
+ original_model=model
+ model=model.duplicate()
+ # scale the model if the units are not feet
+ ifmodel.units!='Feet':
+ model.convert_to_units('Feet')
+ # remove degenerate geometry within native DOE-2 tolerance
+ try:
+ model.remove_degenerate_geometry(DOE2_TOLERANCE)
+ exceptValueError:
+ error='Failed to remove degenerate Rooms.\nYour Model units system is: {}. ' \
+ 'Is this correct?'.format(original_model.units)
+ raiseValueError(error)
+ # convert all of the Aperture geometries to rectangles so they can be translated
+ model.rectangularize_apertures(
+ subdivision_distance=RECT_WIN_SUBD,max_separation=0.0,
+ merge_all=True,resolve_adjacency=False
+ )
+ # reset identifiers to valid DOE-2 U-Names that are derived from the display names
+ forroominmodel.rooms:
+ base_name=clean_doe2_string(room.display_name,GEO_CHARS-2)
+ room.display_name=clean_string(base_name)
+ forfaceinroom.faces:
+ base_name=clean_doe2_string(face.display_name,GEO_CHARS-2)
+ face.display_name=clean_string(base_name)
+ forapinface.apertures:
+ base_name=clean_doe2_string(ap.display_name,GEO_CHARS-2)
+ ap.display_name=clean_string(base_name)
+ fordrinface.doors:
+ base_name=clean_doe2_string(dr.display_name,GEO_CHARS-2)
+ dr.display_name=clean_string(base_name)
+ forshadeinmodel.shades:
+ base_name=clean_doe2_string(shade.display_name,GEO_CHARS-2)
+ shade.display_name=clean_string(base_name)
+ forshd_meshinmodel.shade_meshes:
+ base_name=clean_doe2_string(shd_mesh.display_name,GEO_CHARS-2)
+ shd_mesh.display_name=clean_string(base_name)
+ model.reset_ids()
+ # assign any doe2 properties previously supported through user_data
+ forroominmodel.rooms:
+ room.properties.doe2.apply_properties_from_user_data()
+
+ # write the simulation parameters into the string
+ model_str=['INPUT ..\n\n']
+ sim_par=simulation_parifsimulation_parisnotNoneelseSimulationPar()
+ model_str.append(sim_par.to_inp())
+
+ # write all of the schedules
+ all_day_scheds,all_week_scheds,all_year_scheds=[],[],[]
+ used_day_sched_ids,used_day_count={},1
+ all_scheds=model.properties.energy.schedules
+ forschedinall_scheds:
+ ifisinstance(sched,ScheduleRuleset):
+ year_schedule,week_schedules=sched.to_inp()
+ # check that day schedules aren't referenced by other model schedules
+ day_scheds=[]
+ fordayinsched.day_schedules:
+ sch_doe2_id=clean_doe2_string(day.identifier,RES_CHARS)
+ ifsch_doe2_idnotinused_day_sched_ids:
+ day_scheds.append(day.to_inp(sched.schedule_type_limit))
+ used_day_sched_ids[sch_doe2_id]=day
+ elifday!=used_day_sched_ids[sch_doe2_id]:
+ new_day=day.duplicate()
+ new_day.identifier='Schedule Day {}'.format(used_day_count)
+ day_scheds.append(new_day.to_inp(sched.schedule_type_limit))
+ fori,week_schinenumerate(week_schedules):
+ old_day_id=clean_doe2_string(day.identifier,RES_CHARS)
+ new_day_id=clean_doe2_string(new_day.identifier,RES_CHARS)
+ week_schedules[i]=week_sch.replace(old_day_id,new_day_id)
+ used_day_count+=1
+ all_day_scheds.extend(day_scheds)
+ all_week_scheds.extend(week_schedules)
+ all_year_scheds.append(year_schedule)
+ else:# ScheduleFixedInterval
+ year_schedule,week_schedules,year_schedule=sched.to_inp()
+ all_day_scheds.extend(day_scheds)
+ all_week_scheds.extend(week_schedules)
+ all_year_scheds.append(year_schedule)
+ model_str.append(header_comment_minor('Day Schedules'))
+ model_str.extend(all_day_scheds)
+ model_str.append(header_comment_minor('Week Schedules'))
+ model_str.extend(all_week_scheds)
+ model_str.append(header_comment_minor('Annual Schedules'))
+ model_str.extend(all_year_scheds)
+
+ # write all of the materials and constructions
+ window_constructions=model.properties.energy.aperture_constructions()
+ door_constructions=model.properties.energy.door_constructions()
+ drc_ids=set([con.identifierforconindoor_constructions])
+ materials=[]
+ construction_strs=[]
+ all_constrs=model.properties.energy.constructions+ \
+ generic_construction_set.constructions_unique
+ forconstrinset(all_constrs):
+ ifisinstance(constr,OpaqueConstruction)andconstr.identifiernotindrc_ids:
+ materials.extend(constr.materials)
+ construction_strs.append(opaque_construction_to_inp(constr))
+ elifisinstance(constr,AirBoundaryConstruction):
+ construction_strs.append(air_construction_to_inp(constr))
+ model_str.append(header_comment_minor('Materials / Layers / Constructions'))
+ model_str.extend([opaque_material_to_inp(mat)formatinset(materials)])
+ model_str.extend(construction_strs)
+ model_str.append(header_comment_minor('Glass Types'))
+ forw_coninwindow_constructions:
+ model_str.append(window_construction_to_inp(w_con))
+ model_str.append(header_comment_minor('Door Construction'))
+ fordr_conindoor_constructions:
+ ifnotisinstance(dr_con,OpaqueConstruction):
+ dr_con=dr_con.duplicate()
+ dr_con.identifier=dr_con.identifier+'_d'
+ model_str.append(door_construction_to_inp(dr_con))
+
+ # gather together all of the program types in a dictionary for switch statements
+ switch_dict={}
+ forprograminmodel.properties.energy.program_types:
+ program_type_to_inp(program,switch_dict)
+
+ # loop through rooms grouped by floor level and boundary to get polygons
+ level_room_groups,level_geos,level_names= \
+ group_rooms_by_doe2_level(model.rooms,model.tolerance)
+ bldg_polygons,bldg_geo_defs=[],[]
+ forflr_rooms,flr_geo,flr_nameinzip(level_room_groups,level_geos,level_names):
+ # create the story definition
+ rooms_f2c=[room.max.z-room.min.zforroominflr_rooms]
+ sotry_f2f=max(rooms_f2c)
+ median_room_f2c=sorted(rooms_f2c)[int(len(rooms_f2c)/2)]
+ ifflr_geoisNone:# write the level with NO-SHAPE
+ msg='Using NO-SHAPE for FLOOR "{}".'.format(flr_name)
+ print(msg)
+ flr_origin,_=bounding_box([room.minforroominflr_rooms])
+ flr_area=sum(room.floor_areaforroominflr_rooms)
+ flr_volume=sum(room.volumeforroominflr_rooms)
+ flr_keys=['SHAPE','AREA','VOLUME','AZIMUTH','X','Y','Z',
+ 'SPACE-HEIGHT','FLOOR-HEIGHT']
+ flr_vals=['NO-SHAPE',round(flr_area,GEO_DEC_COUNT),
+ round(flr_volume,GEO_DEC_COUNT),0,
+ flr_origin.x,flr_origin.y,flr_origin.z,
+ round(median_room_f2c,3),round(sotry_f2f,3)]
+ else:# write the level with a POLYGON
+ flr_polygon,pos_info=face_3d_to_inp(flr_geo,flr_name)
+ flr_origin,_,_=pos_info
+ flr_keys=['SHAPE','POLYGON','AZIMUTH','X','Y','Z',
+ 'SPACE-HEIGHT','FLOOR-HEIGHT']
+ flr_vals=['POLYGON','"{} Plg"'.format(flr_name),0,
+ flr_origin.x,flr_origin.y,flr_origin.z,
+ round(median_room_f2c,3),round(sotry_f2f,3)]
+ bldg_polygons.append(flr_polygon)
+ r_mult=flr_rooms[0].multiplier
+ ifr_mult!=1andall(room.multiplier==r_multforroominflr_rooms):
+ # set the multiplier for the entire story instead of room-by-room
+ flr_keys.append('MULTIPLIER')
+ flr_vals.append(r_mult)
+ forroominflr_rooms:
+ room.multiplier=1
+ flr_def=generate_inp_string(flr_name,'FLOOR',flr_keys,flr_vals)
+ bldg_geo_defs.append(flr_def)
+ # add the room and face definitions + polygons
+ forroominflr_rooms:
+ room_polygons,room_defs=room_to_inp(
+ room,flr_origin,median_room_f2c,
+ exclude_interior_walls,exclude_interior_ceilings)
+ bldg_polygons.extend(room_polygons)
+ bldg_geo_defs.extend(room_defs)
+
+ # loop through the shades and get their definitions and polygons
+ shade_polygons,shade_geo_defs=[],[]
+ forshadeinmodel.shades:
+ shade_polygon,shade_def=shade_to_inp(shade,equest_version)
+ ifshade_polygon!='':# shade written with a RECTANGLE
+ shade_polygons.append(shade_polygon)
+ shade_geo_defs.append(shade_def)
+ forshadeinmodel.shade_meshes:
+ shade_polygon,shade_def=shade_mesh_to_inp(shade,equest_version)
+ shade_polygons.extend(shade_polygon)
+ shade_geo_defs.extend(shade_def)
+
+ # write the building and shade geometry into the INP
+ model_str.append(header_comment_minor('Polygons'))
+ model_str.extend(bldg_polygons)
+ model_str.append(header_comment_minor('Wall Parameters'))
+ model_str.append(header_comment_minor('Fixed and Building Shades'))
+ model_str.extend(shade_polygons)
+ model_str.extend(shade_geo_defs)
+ model_str.append(header_comment_minor('Misc Cost Related Objects'))
+ model_str.append(header_comment_major('Performance Curves'))
+ model_str.append(header_comment_major('Floors / Spaces / Walls / Windows / Doors'))
+ model_str.append(switch_dict_to_space_inp(switch_dict))
+ model_str.extend(bldg_geo_defs)
+
+ # write in placeholder headers for various HVAC components
+ model_str.append(header_comment_major('Electric & Fuel Meters'))
+ formeterin('Electric Meters','Fuel Meters','Master Meters'):
+ model_str.append(header_comment_minor(meter))
+ model_str.append(header_comment_major('HVAC Circulation Loops / Plant Equipment'))
+ hvac_comp_types=(
+ 'Pumps','Heat Exchangers','Circulation Loops','Chillers','Boilers',
+ 'Domestic Water Heaters','Heat Rejection','Tower Free Cooling',
+ 'Photovoltaic Modules','Electric Generators','Thermal Storage',
+ 'Ground Loop Heat Exchangers','Compliance DHW (residential dwelling units)')
+ forcompinhvac_comp_types:
+ model_str.append(header_comment_minor(comp))
+ model_str.append(header_comment_major('Steam & Chilled Water Meters'))
+ model_str.append(header_comment_minor('Steam Meters'))
+ model_str.append(header_comment_minor('Chilled Water Meters'))
+ model_str.append(header_comment_major('HVAC Systems / Zones'))
+ model_str.append(switch_dict_to_zone_inp(switch_dict))
+
+ # assign HVAC systems given the specified hvac_mapping
+ ifhvac_mapping.upper()=='STORY':
+ hvac_rooms=level_room_groups
+ hvac_names=['{}_Sys'.format(name)fornameinlevel_names]
+ else:
+ hvac_rooms,hvac_names=group_rooms_by_doe2_hvac(model,hvac_mapping)
+ forhvac_name,roomsinzip(hvac_names,hvac_rooms):
+ # create the definition of the HVAC
+ hvac_keys=('TYPE','HEAT-SOURCE','SYSTEM-REPORTS')
+ hvac_vals=('SUM','NONE','NO')
+ hvac_def=generate_inp_string(hvac_name,'SYSTEM',hvac_keys,hvac_vals)
+ model_str.append(hvac_def)
+ forroominrooms:
+ space_name=clean_doe2_string(room.identifier,GEO_CHARS)
+ zone_name='{}_Zn'.format(space_name)
+ zone_type=room_doe2_conditioning_type(room)
+ zone_keys=['TYPE','SIZING-OPTION','SPACE']
+ zone_vals=[zone_type,'ADJUST-LOADS','"{}"'.format(space_name)]
+ ifroom.properties.energy.is_conditioned:
+ ifroom.properties.energy._setpointisnotNone:
+ stp_kwd,stp_val=setpoint_to_inp(room.properties.energy._setpoint)
+ zone_keys.extend(stp_kwd)
+ zone_vals.extend(stp_val)
+ vt_kwd,vt_val=ventilation_to_inp(room.properties.energy._ventilation)
+ zone_keys.extend(vt_kwd)
+ zone_vals.extend(vt_val)
+ hvac_kwd,hvac_val=room.properties.doe2.to_inp()
+ zone_keys.extend(hvac_kwd)
+ zone_vals.extend(hvac_val)
+ zone_def=generate_inp_string(zone_name,'ZONE',zone_keys,zone_vals)
+ model_str.append(zone_def)
+
+ # provide a few last comment headers and end the file
+ model_str.append(header_comment_major('Metering & Misc HVAC'))
+ model_str.append(header_comment_minor('Equipment Controls'))
+ model_str.append(header_comment_minor('Load Management'))
+ model_str.append(header_comment_major('Utility Rates'))
+ forratein('Ratchets','Block Charges','Utility Rates'):
+ model_str.append(header_comment_minor(rate))
+ model_str.append(header_comment_major('Output Reporting'))
+ report_types=(
+ 'Loads Non-Hourly Reporting','Systems Non-Hourly Reporting',
+ 'Plant Non-Hourly Reporting','Economics Non-Hourly Reporting',
+ 'Hourly Reporting','THE END')
+ forreportinreport_types:
+ model_str.append(header_comment_minor(report))
+ model_str.append('END ..\nCOMPUTE ..\nSTOP ..\n')
+
+ # create the final string and ensure that it is windows-compatible
+ inp_str='\n'.join(model_str)
+ ifos.name!='nt':# we are on a unix-based system
+ inp_str=inp_str.replace('\n','\r\n')
+ returninp_str
+
+
+
+
+[docs]
+defroom_doe2_conditioning_type(room):
+"""Get the DOE-2 conditioning type to be assigned to both the Space and Zone.
+
+ Args:
+ room: A Honeybee Room for which the conditioning type will be returned.
+ """
+ ifroom.exclude_floor_area:
+ return'PLENUM'
+ elifroom.properties.energy.is_conditioned:
+ return'CONDITIONED'
+ else:
+ return'UNCONDITIONED'