+"""dragonfly_energy configurations.
+
+Import this into every module where access configurations are needed.
+
+Usage:
+
+.. code-block:: python
+
+ from dragonfly_energy.config import folders
+ print(folders.mapper_path)
+ folders.mapper_path = "C:/Urbanopt_test/Honeybee.rb"
+"""
+fromladybug.futilimportwrite_to_file
+importhoneybee_energy.configashb_energy_config
+
+importos
+importplatform
+importjson
+importsubprocess
+
+
+
+[docs]
+classFolders(object):
+"""Dragonfly_energy folders.
+
+ Args:
+ config_file: The path to the config.json file from which folders are loaded.
+ If None, the config.json module included in this package will be used.
+ Default: None.
+ mute: If False, the paths to the various folders will be printed as they
+ are found. If True, no printing will occur upon initialization of this
+ class. Default: True.
+
+ Properties:
+ * mapper_path
+ * urbanopt_gemfile_path
+ * urbanopt_cli_path
+ * urbanopt_env_path
+ * urbanopt_version
+ * urbanopt_version_str
+ * reopt_assumptions_path
+ * docker_version
+ * docker_version_str
+ * config_file
+ * mute
+ """
+ URBANOPT_VERSION=(0,12,0)
+ COMPATIBILITY_URL='https://github.com/ladybug-tools/lbt-grasshopper/wiki/' \
+ '1.4-Compatibility-Matrix'
+
+ def__init__(self,config_file=None,mute=True):
+ self.mute=bool(mute)# set the mute value
+ self.config_file=config_file# load paths from the config JSON file
+
+ @property
+ defmapper_path(self):
+"""Get or set the path to the Ruby mapper used in URBANopt workflows.
+
+ This is the Ruby file that is used to map URBANopt geoJSON features to
+ honeybee model JSONs.
+ """
+ returnself._mapper_path
+
+ @mapper_path.setter
+ defmapper_path(self,path):
+ ifnotpath:# check the default installation location
+ path=self._find_mapper_path()
+ ifpath:# check that the mapper file exists in the path
+ assertos.path.isfile(path)andpath.endswith('.rb'), \
+ '{} is not a valid path to a Ruby mapper file.'.format(path)
+ self._mapper_path=path# set the mapper_path
+ ifpathandnotself.mute:
+ print("Path to Mapper is set to: %s"%path)
+
+ @property
+ defurbanopt_gemfile_path(self):
+"""Get or set the path to the Gemfile used in URBANopt workflows.
+
+ Setting this can be used to test newer versions of URBANopt with upgraded
+ dependencies in the Gemfile.
+ """
+ returnself._urbanopt_gemfile_path
+
+ @urbanopt_gemfile_path.setter
+ defurbanopt_gemfile_path(self,path):
+ ifnotpath:# check the default installation location
+ path=self._find_urbanopt_gemfile_path()
+ ifpath:# check that the Gemfile exists at the path
+ assertos.path.isfile(path), \
+ '{} is not a valid path to an URBANopt Gemfile.'.format(path)
+ self._urbanopt_gemfile_path=path# set the urbanopt_gemfile_path
+ ifpathandnotself.mute:
+ print("Path to URBANopt Gemfile is set to: %s"%path)
+
+ @property
+ defurbanopt_cli_path(self):
+"""Get or set the path to the path where URBANopt is installed.
+
+ Setting this can be used to test newer versions of URBANopt.
+ """
+ returnself._urbanopt_cli_path
+
+ @urbanopt_cli_path.setter
+ defurbanopt_cli_path(self,path):
+ ifnotpath:# check the default installation location
+ path=self._find_urbanopt_cli_path()
+ ifpath:# check that the installation exists at the path
+ assertos.path.isdir(path), \
+ '{} is not a valid path to an URBANopt installation.'.format(path)
+ self._urbanopt_cli_path=path# set the urbanopt_cli_path
+ self._urbanopt_env_path=None
+ self._urbanopt_version=None
+ self._urbanopt_version_str=None
+ self._docker_version=None
+ self._docker_version_str=None
+ ifpathandnotself.mute:
+ print("Path to URBANopt CLI is set to: %s"%path)
+
+ @property
+ defurbanopt_env_path(self):
+"""Get or set the path to the executable used to set the URBANopt environment.
+ """
+ returnself._urbanopt_env_path
+
+ @urbanopt_env_path.setter
+ defurbanopt_env_path(self,path):
+ ifpath:# check that the file exists at the path
+ assertos.path.isfile(path), \
+ '{} is not a valid path to an URBANopt env executable.'.format(path)
+ self._urbanopt_env_path=path# set the urbanopt_env_path
+ ifpathandnotself.mute:
+ print("Path to URBANopt Environment executable is set to: %s"%path)
+
+ @property
+ defurbanopt_version(self):
+"""Get a tuple for the version of URBANopt (eg. (0, 7, 1)).
+
+ This will be None if the version could not be sensed or if no URBANopt
+ installation was found.
+ """
+ ifself._urbanopt_cli_pathandself._urbanopt_version_strisNone:
+ self._urbanopt_version_from_cli()
+ returnself._urbanopt_version
+
+ @property
+ defurbanopt_version_str(self):
+"""Get text for the full version of URBANopt (eg. "0.7.1").
+
+ This will be None if the version could not be sensed or if no URBANopt
+ installation was found.
+ """
+ ifself._urbanopt_cli_pathandself._urbanopt_version_strisNone:
+ self._urbanopt_version_from_cli()
+ returnself._urbanopt_version_str
+
+ @property
+ defreopt_assumptions_path(self):
+"""Get or set the path to the JSON file that contains base REopt assumptions.
+ """
+ returnself._reopt_assumptions_path
+
+ @reopt_assumptions_path.setter
+ defreopt_assumptions_path(self,path):
+ ifnotpath:# check the default installation location
+ path=self._find_reopt_assumptions_path()
+ ifpath:# check that the file exists at the path
+ assertos.path.isfile(path), \
+ '{} is not a valid path to a REopt assumptions JSON.'.format(path)
+ self._reopt_assumptions_path=path# set the reopt_assumptions_path
+ ifpathandnotself.mute:
+ print("Path to REopt assumptions is set to: %s"%path)
+
+ @property
+ defdocker_version(self):
+"""Get a tuple for the version of Docker installed (eg. (24, 0, 7)).
+
+ This will be None if the version could not be sensed or if no Docker
+ installation was found.
+ """
+ ifself._docker_version_strisNone:
+ self._docker_version_from_cli()
+ returnself._docker_version
+
+ @property
+ defdocker_version_str(self):
+"""Get text for the full version of Docker (eg. "24.0.7").
+
+ This will be None if the version could not be sensed or if no Docker
+ installation was found.
+ """
+ ifself._docker_version_strisNone:
+ self._docker_version_from_cli()
+ returnself._docker_version_str
+
+ @property
+ defconfig_file(self):
+"""Get or set the path to the config.json file from which folders are loaded.
+
+ Setting this to None will result in using the config.json module included
+ in this package.
+ """
+ returnself._config_file
+
+ @config_file.setter
+ defconfig_file(self,cfg):
+ ifcfgisNone:
+ cfg=os.path.join(os.path.dirname(__file__),'config.json')
+ self._load_from_file(cfg)
+ self._config_file=cfg
+
+
+[docs]
+ defgenerate_urbanopt_env_path(self):
+"""Run the URBANopt setup-env file to set this object's urbanopt_env_path."""
+ # search for the file in its default location
+ home_folder=os.getenv('HOME')oros.path.expanduser('~')
+ env_file=os.path.join(home_folder,'.env_uo.bat')ifos.name=='nt'else \
+ os.path.join(home_folder,'.env_uo.sh')
+
+ ifself.urbanopt_cli_path:# try to generate the env file
+ env_setup=os.path.join(self.urbanopt_cli_path,'setup-env.bat') \
+ ifos.name=='nt'else \
+ os.path.join(self.urbanopt_cli_path,'setup-env.sh')
+ ifos.path.isfile(env_setup):
+ ifos.name=='nt':# run the batch file on Windows
+ os.system(env_setup)
+ else:# run the sell file on Mac or Linux
+ subprocess.check_call(['chmod','u+x',env_setup])
+ subprocess.call(env_setup)
+ ifos.path.isfile(env_file):
+ self._urbanopt_env_path=env_file# the file was successfully generated
+
+
+
+[docs]
+ defcheck_urbanopt_version(self):
+"""Check if the installed version of URBANopt is the acceptable one."""
+ in_msg='Get a compatible version of URBANopt by downloading and installing\n' \
+ 'the version of URBANopt listed in the Ladybug Tools compatibility ' \
+ 'matrix\n{}.'.format(self.COMPATIBILITY_URL)
+ assertself.urbanopt_cli_pathisnotNone, \
+ 'No URBANopt installation was found on this machine.\n{}'.format(in_msg)
+ uo_version=self.urbanopt_version
+ ifuo_versionisNone:
+ ifself.urbanopt_env_pathisnotNone:
+ ext='.bat'ifos.name=='nt'else'.sh'
+ ver_file=os.path.join(
+ os.path.dirname(self.urbanopt_env_path),
+ '.check_uo_version{}'.format(ext))
+ process=subprocess.Popen(ver_file,stderr=subprocess.PIPE,shell=True)
+ _,stderr=process.communicate()
+ else:
+ stderr='Unable to set up the URBANopt environment.'
+ msg='An URBANopt installation was found at {}\n' \
+ 'but the URBANopt executable is not accessible.\n{}'.format(
+ self.urbanopt_cli_path,stderr)
+ raiseValueError(msg)
+ assertuo_version[0]==self.URBANOPT_VERSION[0]and \
+ uo_version[1]==self.URBANOPT_VERSION[1], \
+ 'The installed URBANopt is version {}.\nMust be version {} to work ' \
+ 'with dragonfly.\n{}'.format(
+ '.'.join(str(v)forvinuo_version),
+ '.'.join(str(v)forvinself.URBANOPT_VERSION),in_msg)
+
+
+ def_load_from_file(self,file_path):
+"""Set all of the the properties of this object from a config JSON file.
+
+ Args:
+ file_path: Path to a JSON file containing the file paths. A sample of this
+ JSON is the config.json file within this package.
+ """
+ # check the default file path
+ assertos.path.isfile(str(file_path)), \
+ ValueError('No file found at {}'.format(file_path))
+
+ # set the default paths to be all blank
+ default_path={
+ "mapper_path":r'',
+ "urbanopt_gemfile_path":r'',
+ "urbanopt_cli_path":r'',
+ "urbanopt_env_path":r'',
+ "reopt_assumptions_path":r''
+ }
+
+ withopen(file_path,'r')ascfg:
+ try:
+ paths=json.load(cfg)
+ exceptExceptionase:
+ print('Failed to load paths from {}.\n{}'.format(file_path,e))
+ else:
+ forkey,pinpaths.items():
+ ifisinstance(key,list)ornotkey.startswith('__'):
+ try:
+ default_path[key]=p.strip()
+ exceptAttributeError:
+ default_path[key]=p
+
+ # set paths for the configuration
+ self.mapper_path=default_path["mapper_path"]
+ self.urbanopt_gemfile_path=default_path["urbanopt_gemfile_path"]
+ self.urbanopt_cli_path=default_path["urbanopt_cli_path"]
+ self.urbanopt_env_path=default_path["urbanopt_env_path"]
+ self.reopt_assumptions_path=default_path["reopt_assumptions_path"]
+
+ def_urbanopt_version_from_cli(self):
+"""Set this object's URBANopt version by making a call to URBANopt CLI."""
+ ifnotself.urbanopt_env_path:
+ self.generate_urbanopt_env_path()
+ assertself.urbanopt_env_pathisnotNone,'Unable to set up the URBANopt ' \
+ 'environment. Make sure it is installed correctly.'
+ ifos.name=='nt':
+ working_drive=self.urbanopt_env_path[:2]
+ batch='{}\ncd {}\ncall {}\nuo --version'.format(
+ working_drive,working_drive,self.urbanopt_env_path)
+ batch_file=os.path.join(
+ os.path.dirname(self.urbanopt_env_path),'.check_uo_version.bat')
+ write_to_file(batch_file,batch,True)
+ process=subprocess.Popen(batch_file,stdout=subprocess.PIPE,shell=True)
+ stdout=process.communicate()
+ else:
+ shell='#!/usr/bin/env bash\nsource {}\nuo --version'.format(
+ self.urbanopt_env_path)
+ shell_file=os.path.join(
+ os.path.dirname(self.urbanopt_env_path),'.check_uo_version.sh')
+ write_to_file(shell_file,shell,True)
+ # make the shell script executable using subprocess.check_call
+ subprocess.check_call(['chmod','u+x',shell_file])
+ # run the shell script
+ process=subprocess.Popen(shell_file,stdout=subprocess.PIPE,shell=True)
+ stdout=process.communicate()
+ base_str=str(stdout[0]).split('--version')[-1]
+ base_str=base_str.replace(r"\r",'').replace(r"\n",'').replace(r"'",'')
+ base_str=base_str.strip()
+ try:
+ ver_nums=base_str.split('.')
+ self._urbanopt_version=tuple(int(i)foriinver_nums)
+ self._urbanopt_version_str=base_str
+ exceptException:
+ pass# failed to parse the version into integers
+
+ def_docker_version_from_cli(self):
+"""Set this object's Docker version by making a call to Docker CLI."""
+ cmds=['docker','--version']
+ use_shell=Trueifos.name=='nt'elseFalse
+ process=subprocess.Popen(cmds,stdout=subprocess.PIPE,shell=use_shell)
+ stdout=process.communicate()
+ base_str=str(stdout[0]).replace("b'",'').replace(r"\n'",'')
+ try:
+ self._docker_version_str=base_str.split(',')[0].split(' ')[-1]
+ ver_nums=self._docker_version_str.split('.')
+ self._docker_version=tuple(int(i)foriinver_nums)
+ exceptException:
+ pass# failed to parse the version into integers
+
+ @staticmethod
+ def_find_mapper_path():
+"""Find the mapper that is distributed with the honeybee-openstudio-gem."""
+ measure_install=hb_energy_config.folders.honeybee_openstudio_gem_path
+ ifmeasure_install:
+ mapper_file=os.path.join(measure_install,'files','Honeybee.rb')
+ ifos.path.isfile(mapper_file):
+ returnmapper_file
+ returnNone
+
+ @staticmethod
+ def_find_urbanopt_gemfile_path():
+"""Find the URBANopt Gemfile that's distributed with honeybee-openstudio-gem."""
+ measure_install=hb_energy_config.folders.honeybee_openstudio_gem_path
+ ifmeasure_install:
+ gem_file=os.path.join(measure_install,'files','urbanopt_Gemfile')
+ ifos.path.isfile(gem_file):
+ returngem_file
+ returnNone
+
+ @staticmethod
+ def_find_reopt_assumptions_path():
+"""Find the REopt assumptions that's distributed with honeybee-openstudio-gem."""
+ measure_install=hb_energy_config.folders.honeybee_openstudio_gem_path
+ ifmeasure_install:
+ reopt_file=os.path.join(measure_install,'files','reopt_assumptions.json')
+ ifos.path.isfile(reopt_file):
+ returnreopt_file
+ returnNone
+
+ @staticmethod
+ def_find_urbanopt_cli_path():
+"""Find the most recent URBANopt CLI in its default location."""
+ defgetversion(urbanopt_path):
+"""Get digits for the version of OpenStudio."""
+ try:
+ ver=''.join(sforsinurbanopt_pathif(s.isdigit()ors=='.'))
+ returnsum(int(d)*(10**i)
+ fori,dinenumerate(reversed(ver.split('.'))))
+ exceptValueError:# folder starting with 'openstudio' and no version
+ return0
+
+ ifos.name=='nt':# search the C:/ drive on Windows
+ uo_folders=['C:\\{}'.format(f)forfinos.listdir('C:\\')
+ if(f.lower().startswith('urbanopt')and
+ os.path.isdir('C:\\{}'.format(f)))]
+ elifplatform.system()=='Darwin':# search the Applications folder on Mac
+ uo_folders= \
+ ['/Applications/{}'.format(f)forfinos.listdir('/Applications/')
+ if(f.lower().startswith('urbanopt')and
+ os.path.isdir('/Applications/{}'.format(f)))]
+ elifplatform.system()=='Linux':# search the usr/local folder
+ uo_folders=['/usr/local/{}'.format(f)forfinos.listdir('/usr/local/')
+ if(f.lower().startswith('urbanopt')and
+ os.path.isdir('/usr/local/{}'.format(f)))]
+ else:# unknown operating system
+ uo_folders=None
+
+ ifnotuo_folders:# No Openstudio installations were found
+ returnNone
+
+ # get the most recent version of OpenStudio that was found
+ uo_path=sorted(uo_folders,key=getversion,reverse=True)[0]
+ returnuo_path
+
+
+
+"""Object possesing all key folders within the configuration."""
+folders=Folders(mute=True)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/dragonfly_energy/des/connector.html b/docs/_modules/dragonfly_energy/des/connector.html
new file mode 100644
index 00000000..5796bd56
--- /dev/null
+++ b/docs/_modules/dragonfly_energy/des/connector.html
@@ -0,0 +1,1138 @@
+
+
+
+
+
+
+ dragonfly_energy.des.connector — dragonfly-energy documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# coding=utf-8
+"""Thermal connector in a District Energy System."""
+from__future__importdivision
+
+from.._baseimport_GeometryBase
+
+fromladybug_geometry.geometry2d.lineimportLineSegment2D
+fromladybug_geometry.geometry2d.polylineimportPolyline2D
+fromdragonfly.projectionimportpolygon_to_lon_lat
+
+
+
+[docs]
+classThermalConnector(_GeometryBase):
+"""Represents a thermal connector carrying hot, chilled or ambient water in a DES.
+
+ Args:
+ identifier: Text string for a unique thermal connector ID. Must contain only
+ characters that are acceptable in a DES. This will be used to
+ identify the object across the exported geoJSON and DES files.
+ geometry: A LineSegment2D or Polyline2D representing the geometry of the
+ thermal connector.
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ """
+ __slots__=()
+
+ def__init__(self,identifier,geometry):
+"""Initialize ThermalConnector."""
+ _GeometryBase.__init__(self,identifier)# process the identifier
+ assertisinstance(geometry,(LineSegment2D,Polyline2D)),'Expected ' \
+ 'ladybug_geometry LineSegment2D or Polyline2D. Got {}'.format(type(geometry))
+ self._geometry=geometry
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize an ThermalConnector from a dictionary.
+
+ Args:
+ data: A dictionary representation of an ThermalConnector object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='ThermalConnector','Expected ThermalConnector ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ geo=LineSegment2D.from_dict(data['geometry']) \
+ ifdata['geometry']['type']=='LineSegment2D' \
+ elsePolyline2D.from_dict(data['geometry'])
+ con=cls(data['identifier'],geo)
+ if'display_name'indataanddata['display_name']isnotNone:
+ con.display_name=data['display_name']
+ returncon
+
+
+
+[docs]
+ @classmethod
+ deffrom_dict_abridged(cls,data):
+"""Initialize an ThermalConnector from an abridged dictionary.
+
+ Args:
+ data: A ThermalConnector dictionary.
+ """
+ returncls.from_dict(data)
+
+
+
+[docs]
+ @classmethod
+ deffrom_geojson_dict(
+ cls,data,origin_lon_lat,conversion_factors):
+"""Get a ThermalConnector from a dictionary as it appears in a GeoJSON.
+
+ Args:
+ data: A GeoJSON dictionary representation of an ThermalConnector feature.
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ geo=cls._geojson_coordinates_to_line2d(
+ data['geometry']['coordinates'],origin_lon_lat,conversion_factors)
+ returncls(data['properties']['id'],geo)
+
+
+ @property
+ defgeometry(self):
+"""Get a LineSegment2D or Polyline2D representing the thermal connector."""
+ returnself._geometry
+
+
+[docs]
+ defreverse(self):
+"""Reverse the direction of this object's geometry.
+
+ This is useful when trying to orient the connector to the direction
+ of flow within a larger loop.
+ """
+ self._geometry=self._geometry.flip() \
+ ifisinstance(self._geometry,LineSegment2D)elseself._geometry.reverse()
+[docs]
+ defto_geojson_dict(self,start_id,end_id,origin_lon_lat,conversion_factors,
+ start_feature_id=None,end_feature_id=None):
+"""Get ThermalConnector dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ start_id: Identifier of the junction at the start of the pipe.
+ end_id: Identifier of the junction at the end of the pipe.
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ start_feature_id: Optional identifier for a feature (Building or GHE field)
+ at the start of the pipe.
+ end_feature_id: Optional identifier for a feature (Building or GHE field)
+ at the end of the pipe.
+ """
+ # translate the geometry coordinates to latitude and longitude
+ ifisinstance(self.geometry,LineSegment2D):
+ pts=[(pt.x,pt.y)forptin(self.geometry.p1,self.geometry.p2)]
+ else:# it's a polyline
+ pts=[(pt.x,pt.y)forptinself.geometry.vertices]
+ coords=polygon_to_lon_lat(pts,origin_lon_lat,conversion_factors)
+ # assign all of the properties to the connector
+ conn_props={
+ 'id':self.identifier,
+ 'type':'ThermalConnector',
+ 'name':self.display_name,
+ 'startJunctionId':start_id,
+ 'endJunctionId':end_id,
+ 'total_length':round(self.geometry.length,2),
+ 'connector_type':'OnePipe',
+ 'fluid_temperature_type':'Ambient',
+ 'flow_direction':'Unspecified'
+
+ }
+ ifstart_feature_idisnotNone:
+ conn_props['startFeatureId']=start_feature_id
+ ifend_feature_idisnotNone:
+ conn_props['endFeatureId']=end_feature_id
+ # return the full dictionary
+ return{
+ 'type':'Feature',
+ 'properties':conn_props,
+ 'geometry':{
+ 'type':'LineString',
+ 'coordinates':coords
+ }
+ }
+# coding=utf-8
+"""Ground Heat Exchanger (GHE) in a district thermal system."""
+from.._baseimport_GeometryBase
+
+fromladybug_geometry.geometry2d.polygonimportPolygon2D
+fromhoneybee.typingimportvalid_string,float_positive,float_in_range,int_in_range
+fromhoneybee.altnumberimportautocalculate
+fromdragonfly.projectionimportpolygon_to_lon_lat
+
+
+
+[docs]
+classGroundHeatExchanger(_GeometryBase):
+"""Represents a Ground Heat Exchanger in a district thermal system.
+
+ Args:
+ identifier: Text string for a unique heat exchanger ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ geometry: A Polygon2D representing the geometry of the heat exchanger.
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ """
+ __slots__=()
+
+ def__init__(self,identifier,geometry):
+"""Initialize GroundHeatExchanger."""
+ _GeometryBase.__init__(self,identifier)# process the identifier
+ assertisinstance(geometry,Polygon2D),'Expected ladybug_geometry ' \
+ 'Polygon2D for GroundHeatExchanger geometry. Got {}'.format(type(geometry))
+ self._geometry=geometry
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize a GroundHeatExchanger from a dictionary.
+
+ Args:
+ data: A dictionary representation of an GroundHeatExchanger object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='GroundHeatExchanger','Expected GroundHeatExchanger ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ geo=Polygon2D.from_dict(data['geometry'])
+ trans=cls(data['identifier'],geo)
+ if'display_name'indataanddata['display_name']isnotNone:
+ trans.display_name=data['display_name']
+ returntrans
+
+
+
+[docs]
+ @classmethod
+ deffrom_geojson_dict(
+ cls,data,origin_lon_lat,conversion_factors):
+"""Get a GroundHeatExchanger from a dictionary as it appears in a GeoJSON.
+
+ Args:
+ data: A GeoJSON dictionary representation of an GroundHeatExchanger feature.
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ geo=cls._geojson_coordinates_to_polygon2d(
+ data['geometry']['coordinates'],origin_lon_lat,conversion_factors)
+ returncls(data['properties']['id'],geo)
+
+
+ @property
+ defgeometry(self):
+"""Get a Polygon2D representing the ground heat exchanger."""
+ returnself._geometry
+
+
+[docs]
+ defto_geojson_dict(self,origin_lon_lat,conversion_factors):
+"""Get GroundHeatExchanger dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ pts=[(pt.x,pt.y)forptinself.geometry.vertices]
+ coords=[polygon_to_lon_lat(pts,origin_lon_lat,conversion_factors)]
+ coords[0].append(coords[0][0])
+ return{
+ 'type':'Feature',
+ 'properties':{
+ 'id':self.identifier,
+ 'geometryType':'Rectangle',
+ 'name':self.display_name,
+ 'type':'District System',
+ 'footprint_area':round(self.geometry.area,1),
+ 'footprint_perimeter':round(self.geometry.perimeter,1),
+ 'floor_area':round(self.geometry.area,1),
+ 'district_system_type':'Ground Heat Exchanger',
+ },
+ 'geometry':{
+ 'type':'Polygon',
+ 'coordinates':coords
+ }
+ }
+[docs]
+classSoilParameter(object):
+"""Represents the soil properties within a ground heat exchanger field.
+
+ Args:
+ conductivity: A number for the soil conductivity in W/m-K. (Default: 2.3).
+ heat_capacity: A number for the volumetric heat capacity of the soil
+ in J/m3-K. (Default: 2,343,500).
+ undisturbed_temperature: A number for the undisturbed annual average soil
+ temperature in degrees Celsius. If autocalculate, this value will
+ automatically be replaced with the average EPW temperature before
+ simulation. (Default: Autocalculate).
+ grout_conductivity: A number for the grout conductivity in W/m-K. (Default: 1.0).
+ grout_heat_capacity: A number for the volumetric heat capacity of the grout
+ in J/m3-K. (Default: 3,901,000).
+
+ Properties:
+ * conductivity
+ * heat_capacity
+ * undisturbed_temperature
+ * grout_conductivity
+ * grout_heat_capacity
+ """
+
+ __slots__=('_conductivity','_heat_capacity','_undisturbed_temperature',
+ '_grout_conductivity','_grout_heat_capacity')
+
+ def__init__(self,conductivity=2.3,heat_capacity=2343500,
+ undisturbed_temperature=autocalculate,
+ grout_conductivity=1.0,grout_heat_capacity=3901000):
+"""Initialize SoilParameter."""
+ self.conductivity=conductivity
+ self.heat_capacity=heat_capacity
+ self.undisturbed_temperature=undisturbed_temperature
+ self.grout_conductivity=grout_conductivity
+ self.grout_heat_capacity=grout_heat_capacity
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a SoilParameter object from a dictionary
+
+ Args:
+ data: A dictionary representation of an SoilParameter object
+ in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'SoilParameter',
+ 'conductivity': 1.8, # float in W/m2-K
+ 'heat_capacity': 2100000, # float in J/m3-K
+ 'undisturbed_temperature': 18, # float in C or autocalculate
+ 'grout_conductivity': 1.0, # float in W/m2-K
+ 'grout_heat_capacity': 3901000
+ }
+ """
+ cond=data['conductivity']if'conductivity'indataelse2.3
+ cap=data['heat_capacity']if'heat_capacity'indataelse2343500
+ u_temp=autocalculateif'undisturbed_temperature'notindataor \
+ data['undisturbed_temperature']==autocalculate.to_dict() \
+ elsedata['undisturbed_temperature']
+ g_cond=data['grout_conductivity']if'grout_conductivity'indataelse1.0
+ g_cap=data['grout_heat_capacity']if'grout_heat_capacity'indataelse3901000
+ returncls(cond,cap,u_temp,g_cond,g_cap)
+
+
+ @property
+ defconductivity(self):
+"""Get or set a number for the soil conductivity in W/m-K."""
+ returnself._conductivity
+
+ @conductivity.setter
+ defconductivity(self,value):
+ self._conductivity=float_positive(value,'soil conductivity')
+
+ @property
+ defheat_capacity(self):
+"""Get or set a number for the volumetric heat capacity of the soil in J/m3-K."""
+ returnself._heat_capacity
+
+ @heat_capacity.setter
+ defheat_capacity(self,value):
+ self._heat_capacity=float_positive(value,'soil heat_capacity')
+
+ @property
+ defundisturbed_temperature(self):
+"""Get or set an integer (or Autocalculate) for the vegetation end month."""
+ returnself._undisturbed_temperatureifself._undisturbed_temperature \
+ isnotNoneelseautocalculate
+
+ @undisturbed_temperature.setter
+ defundisturbed_temperature(self,value):
+ ifvalue==autocalculate:
+ self._undisturbed_temperature=None
+ else:
+ self._undisturbed_temperature= \
+ float_in_range(value,-273,200,'undisturbed_temperature')
+
+ @property
+ defgrout_conductivity(self):
+"""Get or set a number for the grout conductivity in W/m-K."""
+ returnself._grout_conductivity
+
+ @grout_conductivity.setter
+ defgrout_conductivity(self,value):
+ self._grout_conductivity=float_positive(value,'grout conductivity')
+
+ @property
+ defgrout_heat_capacity(self):
+"""Get or set a number for the volumetric heat capacity of the grout in J/m3-K.
+ """
+ returnself._grout_heat_capacity
+
+ @grout_heat_capacity.setter
+ defgrout_heat_capacity(self,value):
+ self._grout_heat_capacity=float_positive(value,'grout heat_capacity')
+
+
+[docs]
+classFluidParameter(object):
+"""Represents the fluid properties within a ground heat exchanger field.
+
+ Args:
+ fluid_type: Text to indicate the type of fluid circulating through the
+ ground heat exchanger loop. Choose from the options
+ below. (Default: Water).
+
+ * Water
+ * EthylAlcohol
+ * EthyleneGlycol
+ * MethylAlcohol
+ * PropyleneGlycol
+
+ concentration: A number between 0 and 60 for the concentration of the
+ fluid_type in water in percent. Note that this variable has no effect
+ when the fluid_type is Water. (Default: 35).
+ temperature: A number for the average design fluid temperature at peak
+ conditions in Celsius. (Default: 20).
+
+ Properties:
+ * fluid_type
+ * concentration
+ * temperature
+ """
+
+ __slots__=('_fluid_type','_concentration','_temperature')
+ FLUID_TYPES=(
+ 'Water','EthylAlcohol','EthyleneGlycol','MethylAlcohol','PropyleneGlycol')
+
+ def__init__(self,fluid_type='Water',concentration=35,temperature=20):
+"""Initialize FluidParameter."""
+ self.fluid_type=fluid_type
+ self.concentration=concentration
+ self.temperature=temperature
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a FluidParameter object from a dictionary
+
+ Args:
+ data: A dictionary representation of an FluidParameter object
+ in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'FluidParameter',
+ 'fluid_type': 'PropyleneGlycol', # text for fluid_type
+ 'concentration': 33, # float for percentage concentration
+ 'temperature': 22 # float in C
+ }
+ """
+ ft=data['fluid_type']if'fluid_type'indataelse'Water'
+ con=data['concentration']if'concentration'indataelse35
+ temp=20if'temperature'notindataelsedata['temperature']
+ returncls(ft,con,temp)
+
+
+ @property
+ deffluid_type(self):
+"""Get or set text to indicate the type of fluid."""
+ returnself._fluid_type
+
+ @fluid_type.setter
+ deffluid_type(self,value):
+ clean_input=valid_string(value).lower()
+ forkeyinself.FLUID_TYPES:
+ ifkey.lower()==clean_input:
+ value=key
+ break
+ else:
+ raiseValueError(
+ 'fluid_type {} is not recognized.\nChoose from the '
+ 'following:\n{}'.format(value,self.FLUID_TYPES))
+ self._fluid_type=value
+
+ @property
+ defconcentration(self):
+"""Get or set a number for the concentration of the fluid_type in water [%]."""
+ returnself._concentration
+
+ @concentration.setter
+ defconcentration(self,value):
+ self._concentration=float_in_range(value,0,60,'fluid concentration')
+
+ @property
+ deftemperature(self):
+"""Get or set a number for the average design fluid temperature in Celsius."""
+ returnself._temperature
+
+ @temperature.setter
+ deftemperature(self,value):
+ self._temperature=float_positive(value,'fluid temperature')
+
+
+[docs]
+classPipeParameter(object):
+"""Represents the pipe properties within a ground heat exchanger field.
+
+ Args:
+ inner_diameter: A number for the diameter of the inner pipe surface in
+ meters. (Default: 0.0216).
+ outer_diameter: A number for the diameter of the outer pipe surface in
+ meters. (Default: 0.0266).
+ shank_spacing: A number for the spacing between the U-tube legs, as
+ referenced from outer surface of the pipes in meters. (NOT referenced
+ from each pipe's respective centerline). (Default: 0.0323).
+ roughness: A number for the linear dimension of bumps on the pipe surface
+ in meters. (Default: 1e-06)
+ conductivity: A number for the conductivity of the pipe material in
+ W/m-K. (Default: 0.4).
+ heat_capacity: A number for the volumetric heat capacity of the pipe
+ material in J/m3-K. (Default: 1,542,000).
+ arrangement: Text for the specified pipe arrangement. Choose from the
+ following options. (Default: SingleUTube).
+
+ * SingleUTube
+ * DoubleUTubeSeries
+ * DoubleUTubeParallel
+
+ Properties:
+ * inner_diameter
+ * outer_diameter
+ * shank_spacing
+ * roughness
+ * conductivity
+ * heat_capacity
+ * arrangement
+ """
+ __slots__=('_inner_diameter','_outer_diameter','_shank_spacing',
+ '_roughness','_conductivity','_heat_capacity','_arrangement')
+ ARRANGEMENT_TYPES=('SingleUTube','DoubleUTubeSeries','DoubleUTubeParallel')
+
+ def__init__(
+ self,inner_diameter=0.0216,outer_diameter=0.0266,shank_spacing=0.0323,
+ roughness=1e-06,conductivity=0.4,heat_capacity=1542000,
+ arrangement='SingleUTube'):
+"""Initialize PipeParameter."""
+ self._inner_diameter=float_positive(inner_diameter,'pipe inner_diameter')
+ self.outer_diameter=outer_diameter
+ self.shank_spacing=shank_spacing
+ self.roughness=roughness
+ self.conductivity=conductivity
+ self.heat_capacity=heat_capacity
+ self.arrangement=arrangement
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a PipeParameter object from a dictionary
+
+ Args:
+ data: A dictionary representation of an PipeParameter object
+ in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'PipeParameter',
+ 'inner_diameter': 0.0216, # float for inner diameter in meters
+ 'outer_diameter': 0.0266 # float for outer diameter in meters
+ 'shank_spacing': 0.0323, # float for spacing between outer pipes in meters
+ 'roughness': 1e-06, # float for the dimension of the surface bumps
+ 'conductivity': 0.6, # float in W/m2-K
+ 'heat_capacity': 1542000, # float in J/m3-K
+ 'arrangement': 'SingleUTube' # text for arrangement type
+ }
+ """
+ in_d=data['inner_diameter']if'inner_diameter'indataelse0.0216
+ out_d=data['outer_diameter']if'outer_diameter'indataelse0.0266
+ s_spc=data['shank_spacing']if'shank_spacing'indataelse0.0323
+ rough=data['roughness']if'roughness'indataelse1e-06
+ cond=data['conductivity']if'conductivity'indataelse2.3
+ cap=data['heat_capacity']if'heat_capacity'indataelse2343500
+ arr=data['arrangement']if'arrangement'indataelse'SingleUTube'
+ returncls(in_d,out_d,s_spc,rough,cond,cap,arr)
+
+
+ @property
+ definner_diameter(self):
+"""Get or set a number for the inner diameter of the pipe in meters."""
+ returnself._inner_diameter
+
+ @inner_diameter.setter
+ definner_diameter(self,value):
+ self._inner_diameter=float_positive(value,'pipe inner diameter')
+ self._diameter_check()
+
+ @property
+ defouter_diameter(self):
+"""Get or set a number for the outer diameter of the pipe in meters."""
+ returnself._outer_diameter
+
+ @outer_diameter.setter
+ defouter_diameter(self,value):
+ self._outer_diameter=float_positive(value,'pipe outer diameter')
+ self._diameter_check()
+
+ @property
+ defshank_spacing(self):
+"""Get or set a number for the shank spacing between the pipes in meters."""
+ returnself._shank_spacing
+
+ @shank_spacing.setter
+ defshank_spacing(self,value):
+ self._shank_spacing=float_positive(value,'pipe shank spacing')
+
+ @property
+ defroughness(self):
+"""Get or set a number for the dimension of the pipe surface bumps in meters."""
+ returnself._roughness
+
+ @roughness.setter
+ defroughness(self,value):
+ self._roughness=float_positive(value,'pipe roughness')
+
+ @property
+ defconductivity(self):
+"""Get or set a number for the conductivity of the pipe material in W/m-K."""
+ returnself._conductivity
+
+ @conductivity.setter
+ defconductivity(self,value):
+ self._conductivity=float_positive(value,'pipe conductivity')
+
+ @property
+ defheat_capacity(self):
+"""Get or set a number for the volumetric heat capacity of the pipe in J/m3-K."""
+ returnself._heat_capacity
+
+ @heat_capacity.setter
+ defheat_capacity(self,value):
+ self._heat_capacity=float_positive(value,'pipe heat_capacity')
+
+ @property
+ defarrangement(self):
+"""Get or set text for the pipe arrangement.
+
+ Choose from the following options:
+
+ * SingleUTube
+ * DoubleUTubeSeries
+ * DoubleUTubeParallel
+ """
+ returnself._arrangement
+
+ @arrangement.setter
+ defarrangement(self,value):
+ clean_input=valid_string(value).lower()
+ forkeyinself.ARRANGEMENT_TYPES:
+ ifkey.lower()==clean_input:
+ value=key
+ break
+ else:
+ raiseValueError(
+ 'arrangement {} is not recognized.\nChoose from the '
+ 'following:\n{}'.format(value,self.ARRANGEMENT_TYPES))
+ self._arrangement=value
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+
+
+ def__copy__(self):
+ returnPipeParameter(
+ self.inner_diameter,self.outer_diameter,self.shank_spacing,
+ self.roughness,self.conductivity,self.heat_capacity,self.arrangement)
+
+ def_diameter_check(self):
+"""Check that outer_diameter is greater than or equal to the inner_diameter."""
+ assertself._outer_diameter>self._inner_diameter, \
+ 'Pipe outer_diameter must be greater than or equal to inner_diameter.'
+
+
+[docs]
+classBoreholeParameter(object):
+"""Represents the borehole properties within a ground heat exchanger field.
+
+ Args:
+ min_depth: A number for the minimum depth of the heat-exchanging part
+ of the boreholes in meters. All boreholes will have a depth of
+ at least this value. So this typically represents the depth at which
+ borehole-drilling is most economical or the point at which it becomes
+ more cost effective to start a new borehole instead of making a given
+ borehole deeper. (Default: 60).
+ max_depth: A number for the maximum depth of the heat-exchanging part
+ of the boreholes in meters. When the system demand cannot be met
+ using boreholes with the min_depth, the boreholes will be extended
+ until either the loads or met or they reach this depth. So this
+ typically represents the depth of bedrock or the point at which
+ drilling deeper ceases to be practical. (Default: 135).
+ min_spacing: A number for the minimum spacing between boreholes in meters.
+ When the system demand cannot be met using boreholes with the max_spacing,
+ the borehole spacing will be reduced until either the loads or met
+ or they reach this spacing. So this typically represents the spacing
+ at which each borehole will interfere with neighboring ones so much
+ that it is not worthwhile to decrease the spacing further. (Default: 3).
+ max_spacing: A number for the maximum spacing between boreholes in meters.
+ All boreholes will have a spacing of at most this value. So this
+ typically represents the spacing at which the performance effects of
+ one borehole on a neighboring one are negligible. (Default: 25).
+ buried_depth: A number for the depth below the ground surface at which
+ the top of the heat exchanging part of the borehole sits in
+ meters. (Default: 2).
+ diameter: A number for the diameter of the borehole in meters. (Default: 0.15).
+
+ Properties:
+ * min_depth
+ * max_depth
+ * min_spacing
+ * max_spacing
+ * buried_depth
+ * diameter
+ """
+ __slots__=('_min_depth','_max_depth','_min_spacing','_max_spacing',
+ '_buried_depth','_diameter')
+
+ def__init__(self,min_depth=60,max_depth=135,min_spacing=3,max_spacing=25,
+ buried_depth=2,diameter=0.15):
+"""Initialize BoreholeParameter."""
+ self._min_depth=float_positive(min_depth,'borehole min_depth')
+ self.max_depth=max_depth
+ self._min_spacing=float_positive(min_spacing,'borehole min_spacing')
+ self.max_spacing=max_spacing
+ self.buried_depth=buried_depth
+ self.diameter=diameter
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a BoreholeParameter object from a dictionary
+
+ Args:
+ data: A dictionary representation of an BoreholeParameter object
+ in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'BoreholeParameter',
+ 'min_depth': 30, # float in meters
+ 'max_depth': 90, # float in meters
+ 'min_spacing': 2.5, # float in meters
+ 'max_spacing': 8, # float in meters
+ 'buried_depth': 4, # float in meters
+ 'diameter': 0.2 # float in meters
+ }
+ """
+ min_depth=data['min_depth']if'min_depth'indataelse60
+ max_depth=data['max_depth']if'max_depth'indataelse135
+ min_spacing=data['min_spacing']if'min_spacing'indataelse3
+ max_spacing=data['max_spacing']if'max_spacing'indataelse10
+ dth=data['buried_depth']if'buried_depth'indataelse2
+ dia=data['diameter']if'diameter'indataelse0.15
+ returncls(min_depth,max_depth,min_spacing,max_spacing,dth,dia)
+
+
+ @property
+ defmin_depth(self):
+"""Get or set a number for the minimum depth of the borehole in meters."""
+ returnself._min_depth
+
+ @min_depth.setter
+ defmin_depth(self,value):
+ self._min_depth=float_positive(value,'borehole min_depth')
+ self._depth_check()
+
+ @property
+ defmax_depth(self):
+"""Get or set a number for the maximum depth of the borehole in meters."""
+ returnself._max_depth
+
+ @max_depth.setter
+ defmax_depth(self,value):
+ self._max_depth=float_positive(value,'borehole max_depth')
+ self._depth_check()
+
+ @property
+ defmin_spacing(self):
+"""Get or set a number for the minimum spacing between boreholes in m.
+ """
+ returnself._min_spacing
+
+ @min_spacing.setter
+ defmin_spacing(self,value):
+ self._min_spacing=float_positive(value,'borehole min_spacing')
+ self._spacing_check()
+
+ @property
+ defmax_spacing(self):
+"""Get or set a number for the maximum spacing between boreholes in m.
+ """
+ returnself._max_spacing
+
+ @max_spacing.setter
+ defmax_spacing(self,value):
+ self._max_spacing=float_positive(value,'borehole max_spacing')
+ self._spacing_check()
+
+ @property
+ defburied_depth(self):
+"""Get or set a number for the depth of the top of the borehole in meters."""
+ returnself._buried_depth
+
+ @buried_depth.setter
+ defburied_depth(self,value):
+ self._buried_depth=float_positive(value,'borehole buried_depth')
+
+ @property
+ defdiameter(self):
+"""Get or set a number for the diameter of the borehole in meters."""
+ returnself._diameter
+
+ @diameter.setter
+ defdiameter(self,value):
+ self._diameter=float_positive(value,'borehole diameter')
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+
+
+ def__copy__(self):
+ returnBoreholeParameter(
+ self.min_depth,self.max_depth,self.min_spacing,self.max_spacing,
+ self.buried_depth,self.diameter)
+
+ def_depth_check(self):
+"""Check that max_depth is greater than or equal to min_depth."""
+ assertself._max_depth>=self._min_depth, \
+ 'Borehole max_depth must be greater than or equal to min_depth.'
+
+ def_spacing_check(self):
+"""Check that max_spacing is greater than or equal to min_spacing."""
+ assertself._max_spacing>=self._min_spacing, \
+ 'Borehole max_spacing must be greater than or equal to min_spacing.'
+
+
+[docs]
+classGHEDesignParameter(object):
+"""Represents criteria used to design a ground heat exchanger.
+
+ Args:
+ flow_rate: A number for the volumetric design flow rate through the
+ ground heat exchanger in L/s. The value specified will be either for
+ the entire system system or per-borehole flow rate depending on
+ the flow_type set. (Default: 0.2 L/s).
+ flow_type: Text to indicate whether the design volumetric flow rate set on
+ a per-borehole or system basis. Choose from the following
+ options. (Default: Borehole).
+
+ * Borehole
+ * System
+
+ max_eft: A number for the maximum heat pump entering fluid temperature
+ in Celsius. (Default: 35C).
+ min_eft: A number for the minimum heat pump entering fluid temperature
+ in Celsius. (Default: 5C).
+ month_count: An integer for the number of months over which the simulation
+ will be run in order to ensure stable ground temperature
+ conditions. (Default: 240).
+
+ Properties:
+ * flow_rate
+ * flow_type
+ * max_eft
+ * min_eft
+ * month_count
+ """
+ __slots__=('_flow_rate','_flow_type','_max_eft','_min_eft','_month_count')
+ FLOW_TYPES=('Borehole','System')
+
+ def__init__(self,flow_rate=0.2,flow_type='Borehole',max_eft=35,min_eft=5,
+ month_count=240):
+"""Initialize BoreholeParameter."""
+ self.flow_rate=flow_rate
+ self.flow_type=flow_type
+ self._min_eft=float_positive(min_eft,'GHE min entering fluid temperature')
+ self.max_eft=max_eft
+ self.month_count=month_count
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a GHEDesignParameter object from a dictionary
+
+ Args:
+ data: A dictionary representation of an GHEDesignParameter object
+ in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'GHEDesignParameter',
+ 'flow_rate': 30, # float in L/s
+ 'flow_type': 'Borehole', # text for the type of object flow_rate references
+ 'max_eft': 35, # float for max entering fluid temperature in C
+ 'min_eft': 5, # float for min entering fluid temperature in C
+ 'month_count': 240 # int for the number of months to run the simulation
+ }
+ """
+ flow_rate=data['flow_rate']if'flow_rate'indataelse0.2
+ flow_type=data['flow_type']if'flow_type'indataelse'Borehole'
+ max_eft=data['max_eft']if'max_eft'indataelse35
+ min_eft=data['min_eft']if'min_eft'indataelse5
+ month_count=data['month_count']if'month_count'indataelse240
+ returncls(flow_rate,flow_type,max_eft,min_eft,month_count)
+
+
+ @property
+ defflow_rate(self):
+"""Get or set a number the volumetric design flow rate in L/s."""
+ returnself._flow_rate
+
+ @flow_rate.setter
+ defflow_rate(self,value):
+ self._flow_rate=float_positive(value,'ground heat exchanger flow_rate')
+
+ @property
+ defflow_type(self):
+"""Get or set text for the type of object flow_rate references.
+
+ Choose from the following options:
+
+ * Borehole
+ * System
+ """
+ returnself._flow_type
+
+ @flow_type.setter
+ defflow_type(self,value):
+ clean_input=valid_string(value).lower()
+ forkeyinself.FLOW_TYPES:
+ ifkey.lower()==clean_input:
+ value=key
+ break
+ else:
+ raiseValueError(
+ 'Flow type {} is not recognized.\nChoose from the '
+ 'following:\n{}'.format(value,self.FLOW_TYPES))
+ self._flow_type=value
+
+ @property
+ defmin_eft(self):
+"""Get or set a number for the minimum entering fluid temperature in Celsius."""
+ returnself._min_eft
+
+ @min_eft.setter
+ defmin_eft(self,value):
+ self._min_eft=float_positive(value,'GHE min entering fluid temperature')
+ self._eft_check()
+
+ @property
+ defmax_eft(self):
+"""Get or set a number for the maximum entering fluid temperature in Celsius."""
+ returnself._max_eft
+
+ @max_eft.setter
+ defmax_eft(self,value):
+ self._max_eft=float_positive(value,'GHE max entering fluid temperature')
+ self._eft_check()
+
+ @property
+ defmonth_count(self):
+"""Get or set a number for the maximum entering fluid temperature in Celsius."""
+ returnself._month_count
+
+ @month_count.setter
+ defmonth_count(self,value):
+ self._month_count=int_in_range(value,12,input_name='GHE month count')
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+
+
+ def__copy__(self):
+ returnGHEDesignParameter(
+ self.flow_rate,self.flow_type,self.min_eft,self.max_eft,self.month_count)
+
+ def_eft_check(self):
+"""Check that max_eft is greater than or equal to min_eft."""
+ assertself._max_eft>=self._min_eft, \
+ 'GHE max_eft must be greater than or equal to min_eft.'
+
+
+# coding=utf-8
+"""Thermal junction in a District Energy System (DES)."""
+from__future__importdivision
+
+from.._baseimport_GeometryBase
+
+fromladybug_geometry.geometry2d.pointvectorimportPoint2D
+fromhoneybee.typingimportvalid_ep_string
+fromdragonfly.projectionimportpolygon_to_lon_lat
+
+
+
+[docs]
+classThermalJunction(_GeometryBase):
+"""Represents an thermal junction connecting two objects in a DES.
+
+ Args:
+ identifier: Text string for a unique thermal junction ID. Must contain only
+ characters that are acceptable in a DED. This will be used to
+ identify the object across the exported geoJSON and DES files.
+ geometry: A LineSegment2D or Polyline2D representing the geometry of the
+ thermal junction.
+ system_identifier: An optional text string for the identifier of a district
+ system object associated with the junction. District system objects
+ include Ground Heat Exchangers. (Default: None).
+ building_identifier: An optional text string for the identifier of a Building
+ object associated with the junction. (Default: None).
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ * system_identifier
+ * building_identifier
+ """
+ __slots__=('_system_identifier','_building_identifier')
+
+ def__init__(self,identifier,geometry,system_identifier=None,
+ building_identifier=None):
+"""Initialize ThermalJunction."""
+ _GeometryBase.__init__(self,identifier)# process the identifier
+ assertisinstance(geometry,Point2D),'Expected ladybug_geometry ' \
+ 'Point2D for ThermalJunction. Got {}'.format(type(geometry))
+ self._geometry=geometry
+ self.system_identifier=system_identifier
+ self.building_identifier=building_identifier
+
+ @property
+ defgeometry(self):
+"""Get a Point2D representing the ThermalJunction."""
+ returnself._geometry
+
+ @property
+ defsystem_identifier(self):
+"""Get or set a text string for the ID of a Transformer or Substation."""
+ returnself._system_identifier
+
+ @system_identifier.setter
+ defsystem_identifier(self,value):
+ self._system_identifier=valid_ep_string(value,'system_identifier') \
+ ifvalueisnotNoneelseNone
+
+ @property
+ defbuilding_identifier(self):
+"""Get or set a text string for the ID of a dragonfly Building."""
+ returnself._building_identifier
+
+ @building_identifier.setter
+ defbuilding_identifier(self,value):
+ self._building_identifier=valid_ep_string(value,'building_identifier') \
+ ifvalueisnotNoneelseNone
+
+
+[docs]
+ defto_geojson_dict(self,origin_lon_lat,conversion_factors):
+"""Get an ThermalJunction dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ pt=(self.geometry.x,self.geometry.y)
+ coord=polygon_to_lon_lat([pt],origin_lon_lat,conversion_factors)[0]
+ geo_dict={
+ 'type':'Feature',
+ 'properties':{
+ 'id':self.identifier,
+ 'type':'ThermalJunction',
+ 'junction_type':'DES',
+ 'connection_type':'Series'
+ },
+ 'geometry':{
+ 'type':'Point',
+ 'coordinates':coord
+ }
+ }
+ ifself._system_identifierisnotNone:
+ geo_dict['properties']['DSId']=self._system_identifier
+ ifself._building_identifierisnotNone:
+ geo_dict['properties']['buildingId']=self._building_identifier
+ returngeo_dict
+# coding=utf-8
+"""Thermal Loop of a District Energy System (DES)."""
+importos
+importuuid
+importjson
+
+fromladybug_geometry.geometry2dimportPoint2D,LineSegment2D,Polyline2D,Polygon2D
+fromladybug.locationimportLocation
+fromladybug.datacollectionimportHourlyContinuousCollection
+fromhoneybee.typingimportvalid_ep_string,float_in_range
+fromhoneybee.unitsimportconversion_factor_to_meters
+fromdragonfly.projectionimportmeters_to_long_lat_factors, \
+ origin_long_lat_from_location
+
+from.gheimportGroundHeatExchanger,SoilParameter,FluidParameter, \
+ PipeParameter,BoreholeParameter,GHEDesignParameter
+from.connectorimportThermalConnector
+from.junctionimportThermalJunction
+
+
+
+[docs]
+classGHEThermalLoop(object):
+"""Represents an Ground Heat Exchanger Thermal Loop in a DES.
+
+ This includes a GroundHeatExchanger and all thermal connectors needed
+ to connect these objects to Dragonfly Buildings in a loop.
+
+ Args:
+ identifier: Text string for a unique thermal loop ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ ground_heat_exchangers: An array of GroundHeatExchanger objects representing
+ the fields of boreholes that supply the loop with thermal capacity.
+ connectors: An array of ThermalConnector objects that are included
+ within the thermal loop. In order for a given connector to be
+ valid within the loop, each end of the connector must touch either
+ another connector, a building footprint, or the ground_heat_exchangers. In
+ order for the loop as a whole to be valid, the connectors must form a
+ single continuous loop when passed through the buildings and the heat
+ exchanger field.
+ clockwise_flow: A boolean to note whether the direction of flow through the
+ loop is clockwise (True) when viewed from above in the GeoJSON or it
+ is counterclockwise (False). (Default: False).
+ soil_parameters: Optional SoilParameter object to specify the properties
+ of the soil in which the loop is operating. If None, default
+ values will be used. (Default: None).
+ fluid_parameters: Optional FluidParameter object to specify the properties
+ of the fluid that is circulating through the loop. If None, default
+ values will be used. (Default: None).
+ pipe_parameters: Optional PipeParameter object to specify the properties
+ of the ground-heat-exchanging pipes used across the loop. If None,
+ default values will be used. (Default: None).
+ borehole_parameters: Optional BoreholeParameter object to specify the
+ properties of the boreholes used across the loop. If None,
+ default values will be used. (Default: None).
+ design_parameters: Optional GHEDesignParameter object to specify the
+ design constraints across the loop. If None, default values
+ will be used. (Default: None).
+
+ Properties:
+ * identifier
+ * display_name
+ * ground_heat_exchangers
+ * connectors
+ * clockwise_flow
+ * soil_parameters
+ * fluid_parameters
+ * pipe_parameters
+ * borehole_parameters
+ * design_parameters
+ """
+ __slots__=(
+ '_identifier','_display_name','_ground_heat_exchangers','_connectors',
+ '_clockwise_flow','_soil_parameters','_fluid_parameters','_pipe_parameters',
+ '_borehole_parameters','_design_parameters')
+
+ def__init__(self,identifier,ground_heat_exchangers,connectors,
+ clockwise_flow=False,soil_parameters=None,fluid_parameters=None,
+ pipe_parameters=None,borehole_parameters=None,design_parameters=None):
+"""Initialize GHEThermalLoop."""
+ self.identifier=identifier
+ self._display_name=None
+ self.ground_heat_exchangers=ground_heat_exchangers
+ self.connectors=connectors
+ self.clockwise_flow=clockwise_flow
+ self.soil_parameters=soil_parameters
+ self.fluid_parameters=fluid_parameters
+ self.pipe_parameters=pipe_parameters
+ self.borehole_parameters=borehole_parameters
+ self.design_parameters=design_parameters
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize an GHEThermalLoop from a dictionary.
+
+ Args:
+ data: A dictionary representation of an GHEThermalLoop object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='GHEThermalLoop','Expected GHEThermalLoop ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ # re-serialize geometry objects
+ ghe=[GroundHeatExchanger.from_dict(g)forgindata['ground_heat_exchangers']]
+ conns=[ThermalConnector.from_dict(c)forcindata['connectors']]
+ clock=data['clockwise_flow']if'clockwise_flow'indataelseFalse
+ soil=SoilParameter.from_dict(data['soil_parameters']) \
+ if'soil_parameters'indataelseNone
+ fluid=FluidParameter.from_dict(data['fluid_parameters']) \
+ if'fluid_parameters'indataelseNone
+ pipe=PipeParameter.from_dict(data['pipe_parameters']) \
+ if'pipe_parameters'indataelseNone
+ bore=BoreholeParameter.from_dict(data['borehole_parameters']) \
+ if'borehole_parameters'indataelseNone
+ des=GHEDesignParameter.from_dict(data['design_parameters']) \
+ if'design_parameters'indataelseNone
+ loop=cls(data['identifier'],ghe,conns,clock,soil,fluid,pipe,bore,des)
+ if'display_name'indataanddata['display_name']isnotNone:
+ loop.display_name=data['display_name']
+ returnloop
+
+
+
+[docs]
+ @classmethod
+ deffrom_geojson(
+ cls,geojson_file_path,location=None,point=None,units='Meters',
+ clockwise_flow=False):
+"""Get an GHEThermalLoop from a dictionary as it appears in a GeoJSON.
+
+ Args:
+ geojson_file_path: Text for the full path to the geojson file to load
+ as GHEThermalLoop.
+ location: An optional ladybug location object with longitude and
+ latitude data defining the origin of the geojson file. If None,
+ an attempt will be made to sense the location from the project
+ point in the GeoJSON (if it exists). If nothing is found, the
+ origin is autocalcualted as the bottom-left corner of the bounding
+ box of all building footprints in the geojson file. (Default: None).
+ point: A ladybug_geometry Point2D for where the location object exists
+ within the space of a scene. The coordinates of this point are
+ expected to be in the units input. If None, an attempt will be
+ made to sense the CAD coordinates from the GeoJSON if they
+ exist. If not found, they will default to (0, 0).
+ units: Text for the units system in which the model geometry
+ exists. Default: 'Meters'. Choose from the following:
+
+ * Meters
+ * Millimeters
+ * Feet
+ * Inches
+ * Centimeters
+
+ Note that this method assumes the point coordinates are in the
+ same units.
+ clockwise_flow: A boolean to note whether the direction of flow through the
+ loop is clockwise (True) when viewed from above in the GeoJSON or it
+ is counterclockwise (False). (Default: False).
+ """
+ # parse the geoJSON into a dictionary
+ withopen(geojson_file_path,'r')asfp:
+ data=json.load(fp)
+
+ # extract the CAD coordinates and location from the GeoJSON if they exist
+ if'project'indata:
+ prd=data['project']
+ if'latitude'inprdand'longitude'inprdandlocationisNone:
+ location=Location(latitude=prd['latitude'],longitude=prd['longitude'])
+ if'cad_coordinates'inprdandpointisNone:
+ point=Point2D(*prd['cad_coordinates'])
+ ifpointisNone:# just use the world origin if no point was found
+ point=Point2D(0,0)
+
+ # Get the list of thermal connector and GHE data
+ connector_data,ghe_data=[],[]
+ forobj_dataindata['features']:
+ if'type'inobj_data['properties']:
+ ifobj_data['properties']['type']=='ThermalConnector':
+ connector_data.append(obj_data)
+ elifobj_data['properties']['type']=='District System'and \
+ obj_data['properties']['district_system_type']== \
+ 'Ground Heat Exchanger':
+ ghe_data.append(obj_data)
+
+ # if model units is not Meters, convert non-meter user inputs to meters
+ scale_to_meters=conversion_factor_to_meters(units)
+ ifunits!='Meters':
+ point=point.scale(scale_to_meters)
+
+ # Get long and lat in the geojson that correspond to the model origin (point).
+ # If location is None, derive coordinates from the geojson geometry.
+ iflocationisNone:
+ point_lon_lat=cls._bottom_left_coordinate_from_geojson(connector_data)
+ location=Location(longitude=point_lon_lat[0],latitude=point_lon_lat[1])
+
+ # The model point may not be at (0, 0), so shift the longitude and latitude to
+ # get the equivalent point in longitude and latitude for (0, 0) in the model.
+ origin_lon_lat=origin_long_lat_from_location(location,point)
+ _convert_facs=meters_to_long_lat_factors(origin_lon_lat)
+ convert_facs=1/_convert_facs[0],1/_convert_facs[1]
+
+ # extract the connectors
+ connectors=[]
+ forcon_datainconnector_data:
+ con_obj=ThermalConnector.from_geojson_dict(
+ con_data,origin_lon_lat,convert_facs)
+ connectors.append(con_obj)
+ # extract the substation
+ ghe_field=GroundHeatExchanger.from_geojson_dict(
+ ghe_data,origin_lon_lat,convert_facs)
+
+ # create the loop and adjust for the units
+ base_name=os.path.basename(geojson_file_path)
+ loop_id=base_name.replace('.json','').replace('.geojson','')
+ loop=cls(loop_id,ghe_field,connectors,clockwise_flow)
+ ifunits!='Meters':
+ loop.convert_to_units(units)
+ returnloop
+
+
+ @staticmethod
+ def_bottom_left_coordinate_from_geojson(connector_data):
+"""Calculate the bottom-left bounding box coordinate from geojson coordinates.
+
+ Args:
+ connector_data: a list of dictionaries containing geojson geometries that
+ represent thermal connectors.
+
+ Returns:
+ The bottom-left most corner of the bounding box around the coordinates.
+ """
+ xs,ys=[],[]
+ forconninconnector_data:
+ conn_coords=conn['geometry']['coordinates']
+ ifconn['geometry']['type']=='LineString':
+ forptinconn_coords:
+ xs.append(pt[0])
+ ys.append(pt[1])
+ returnmin(xs),min(ys)
+
+ @property
+ defidentifier(self):
+"""Get or set the text string for unique object identifier."""
+ returnself._identifier
+
+ @identifier.setter
+ defidentifier(self,identifier):
+ self._identifier=valid_ep_string(identifier,'identifier')
+
+ @property
+ defdisplay_name(self):
+"""Get or set a string for the object name without any character restrictions.
+
+ If not set, this will be equal to the identifier.
+ """
+ ifself._display_nameisNone:
+ returnself._identifier
+ returnself._display_name
+
+ @display_name.setter
+ defdisplay_name(self,value):
+ try:
+ self._display_name=str(value)
+ exceptUnicodeEncodeError:# Python 2 machine lacking the character set
+ self._display_name=value# keep it as unicode
+
+ @property
+ defground_heat_exchangers(self):
+"""Get or set a tuple of GroundHeatExchanger objects for the loop's GHEs.
+ """
+ returnself._ground_heat_exchangers
+
+ @ground_heat_exchangers.setter
+ defground_heat_exchangers(self,values):
+ try:
+ ifnotisinstance(values,tuple):
+ values=tuple(values)
+ exceptTypeError:
+ raiseTypeError(
+ 'Expected list or tuple for thermal loop ground_heat_exchangers. '
+ 'Got {}'.format(type(values)))
+ forginvalues:
+ assertisinstance(g,GroundHeatExchanger),'Expected GroundHeatExchanger ' \
+ 'object for thermal loop ground_heat_exchangers. Got {}.'.format(type(g))
+ assertlen(values)>0,'ThermalLoop must possess at least one GHE.'
+ self._ground_heat_exchangers=values
+
+ @property
+ defconnectors(self):
+"""Get or set the list of ThermalConnector objects within the loop."""
+ returnself._connectors
+
+ @connectors.setter
+ defconnectors(self,values):
+ try:
+ ifnotisinstance(values,tuple):
+ values=tuple(values)
+ exceptTypeError:
+ raiseTypeError('Expected list or tuple for thermal loop connectors. '
+ 'Got {}'.format(type(values)))
+ forcinvalues:
+ assertisinstance(c,ThermalConnector),'Expected ThermalConnector ' \
+ 'object for thermal loop connectors. Got {}.'.format(type(c))
+ assertlen(values)>0,'ThermalLoop must possess at least one connector.'
+ self._connectors=values
+
+ @property
+ defclockwise_flow(self):
+"""Get or set a boolean for whether the flow through the loop is clockwise."""
+ returnself._clockwise_flow
+
+ @clockwise_flow.setter
+ defclockwise_flow(self,value):
+ self._clockwise_flow=bool(value)
+
+ @property
+ defsoil_parameters(self):
+"""Get or set a SoilParameter object for the heat exchanger field."""
+ returnself._soil_parameters
+
+ @soil_parameters.setter
+ defsoil_parameters(self,value):
+ ifvalueisNone:
+ value=SoilParameter()
+ assertisinstance(value,SoilParameter), \
+ 'Expected SoilParameter object' \
+ ' for GroundHeatExchanger. Got {}.'.format(type(value))
+ self._soil_parameters=value
+
+ @property
+ deffluid_parameters(self):
+"""Get or set a FluidParameter object for the heat exchanger field."""
+ returnself._fluid_parameters
+
+ @fluid_parameters.setter
+ deffluid_parameters(self,value):
+ ifvalueisNone:
+ value=FluidParameter()
+ assertisinstance(value,FluidParameter), \
+ 'Expected FluidParameter object' \
+ ' for GroundHeatExchanger. Got {}.'.format(type(value))
+ self._fluid_parameters=value
+
+ @property
+ defpipe_parameters(self):
+"""Get or set a PipeParameter object for the heat exchanger field."""
+ returnself._pipe_parameters
+
+ @pipe_parameters.setter
+ defpipe_parameters(self,value):
+ ifvalueisNone:
+ value=PipeParameter()
+ assertisinstance(value,PipeParameter), \
+ 'Expected PipeParameter object' \
+ ' for GroundHeatExchanger. Got {}.'.format(type(value))
+ self._pipe_parameters=value
+
+ @property
+ defborehole_parameters(self):
+"""Get or set a BoreholeParameter object for the heat exchanger field."""
+ returnself._borehole_parameters
+
+ @borehole_parameters.setter
+ defborehole_parameters(self,value):
+ ifvalueisNone:
+ value=BoreholeParameter()
+ assertisinstance(value,BoreholeParameter), \
+ 'Expected BoreholeParameter object' \
+ ' for GroundHeatExchanger. Got {}.'.format(type(value))
+ self._borehole_parameters=value
+
+ @property
+ defdesign_parameters(self):
+"""Get or set a GHEDesignParameter object for the heat exchanger field."""
+ returnself._design_parameters
+
+ @design_parameters.setter
+ defdesign_parameters(self,value):
+ ifvalueisNone:
+ value=GHEDesignParameter()
+ assertisinstance(value,GHEDesignParameter), \
+ 'Expected GHEDesignParameter object' \
+ ' for GroundHeatExchanger. Got {}.'.format(type(value))
+ self._design_parameters=value
+
+
+[docs]
+ defjunctions(self,tolerance=0.01):
+"""Get a list of ThermalJunction objects for the unique thermal loop junctions.
+
+ The resulting ThermalJunction objects will be associated with the loop's
+ GroundHeatExchanger if they are in contact with it (within the tolerance).
+ However, they won't have any building_identifier associated with them.
+ The assign_junction_buildings method on this object can be used
+ to associate the junctions with an array of Dragonfly Buildings.
+
+ Args:
+ tolerance: The minimum difference between the coordinate values of two
+ faces at which they can be considered centered adjacent. (Default: 0.01,
+ suitable for objects in meters).
+
+ Returns:
+ A tuple with two items.
+
+ - junctions - A list of lists of the unique ThermalJunction objects
+ that exist across the loop.
+
+ - connector_junction_ids - A list of lists that align with the connectors
+ in the loop. Each sub-list contains two string values for the junction
+ IDs for each of the start and end of each of the connectors.
+ """
+ returnself._junctions_from_connectors(self.connectors,tolerance)
+
+
+
+[docs]
+ defloop_polygon(self,buildings,tolerance=0.01):
+"""Get a Polygon2D for the single continuous loop formed by connectors.
+
+ This method will raise an exception if the ThermalConnectors do not form
+ a single continuous loop through the Buildings and the ground_heat_exchangers.
+ The Polygon2D will have the correct clockwise ordering according to this
+ object's clockwise_flow property.
+
+ Args:
+ buildings: An array of Dragonfly Building objects in the same units
+ system as the GHEThermalLoop geometry.
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # get the footprints of the Buildings in 2D space and the GHE field
+ footprint_2d,bldg_ids=GHEThermalLoop._building_footprints(
+ buildings,tolerance)
+ forgheinself.ground_heat_exchangers:
+ footprint_2d.append(ghe.geometry)
+ bldg_ids.append(ghe.identifier)
+
+ # determine which ThermalConnectors are linked to the buildings
+ feat_dict={}
+ forbldg_poly,bldg_idinzip(footprint_2d,bldg_ids):
+ forconninself.connectors:
+ c_p1,c_p2=conn.geometry.p1,conn.geometry.p2
+ p1_con=bldg_poly.is_point_on_edge(c_p1,tolerance)
+ p2_con=bldg_poly.is_point_on_edge(c_p2,tolerance)
+ ifp1_conorp2_con:
+ rel_pt=c_p1ifp1_conelsec_p2
+ try:# assume that the first connection has been found
+ feat_dict[bldg_id].append(rel_pt)
+ exceptKeyError:# this is the first connection
+ feat_dict[bldg_id]=[rel_pt]
+
+ # create a list with all line segment geometry in the loop
+ loop_segs=[]
+ forconninself.connectors:
+ ifisinstance(conn.geometry,LineSegment2D):
+ loop_segs.append(conn.geometry)
+ else:# assume that it is a PolyLine2D
+ loop_segs.extend(conn.geometry.segments)
+ forfeat_id,f_ptsinfeat_dict.items():
+ iflen(f_pts)==2:# valid connection with clear supply and return
+ loop_segs.append(LineSegment2D.from_end_points(f_pts[0],f_pts[1]))
+ eliflen(f_pts)<2:# only one connection; raise an error
+ msg='Feature "{}" contains only a single connection to a ' \
+ 'ThermalConnector and cannot be integrated into a valid ' \
+ 'loop.'.format(feat_id)
+ raiseValueError(msg)
+ else:# multiple connections; raise an error
+ msg='Feature "{}" contains {} connections to ThermalConnectors and ' \
+ 'cannot be integrated into a valid loop.'.format(feat_id,len(f_pts))
+ raiseValueError(msg)
+
+ # join all of the segments together into a single polygon and set the order
+ loop_geos=Polyline2D.join_segments(loop_segs,tolerance)
+ assertlen(loop_geos)==1,'A total of {} different loops were found across ' \
+ 'all ThermalConnectors.\nOnly one loop is allowed.'.format(len(loop_geos))
+ loop_geo=loop_geos[0]
+ assertloop_geo.is_closed(tolerance),'The ThermalConnectors form an ' \
+ 'open loop.\nThis loop must be closed in order to be valid.'
+ loop_poly=loop_geo.to_polygon(tolerance)
+ ifloop_poly.is_clockwiseisnotself.clockwise_flow:
+ loop_poly=loop_poly.reverse()
+ returnloop_poly
+
+
+
+[docs]
+ defordered_connectors(self,buildings,tolerance=0.01):
+"""Get the ThermalConnectors of this GHEThermalLoop correctly ordered in a loop.
+
+ The resulting connectors will not only be ordered correctly along the loop
+ but the orientation of the connector geometries will be property coordinated
+ with the clockwise_flow property on this object.
+
+ This method will raise an exception if the ThermalConnectors do not form
+ a single continuous loop through the Buildings and the ground_heat_exchangers.
+
+ Args:
+ buildings: An array of Dragonfly Building objects in the same units
+ system as the GHEThermalLoop geometry.
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # first get a Polygon2D for the continuous loop
+ loop_poly=self.loop_polygon(buildings,tolerance)
+
+ # loop through the polygon segments and find each matching thermal connector
+ ord_conns,skip_count,tol=[],0,tolerance
+ forloop_seginloop_poly.segments:
+ ifskip_count!=0:
+ skip_count-=1
+ continue
+ forconninself.connectors:
+ ifisinstance(conn.geometry,LineSegment2D)and \
+ conn.geometry.is_equivalent(loop_seg,tol):
+ ifnotconn.geometry.p1.is_equivalent(loop_seg.p1,tol):
+ conn.reverse()
+ ord_conns.append(conn)
+ break
+ elifisinstance(conn.geometry,Polyline2D)and \
+ (conn.geometry.p1.is_equivalent(loop_seg.p1,tol)or
+ conn.geometry.p2.is_equivalent(loop_seg.p1,tol)):
+ ifnotconn.geometry.p1.is_equivalent(loop_seg.p1,tol):
+ conn.reverse()
+ ord_conns.append(conn)
+ skip_count=len(conn.geometry.vertices)-1
+ break
+ returnord_conns
+
+
+
+[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.
+ """
+ forgheinself.ground_heat_exchangers:
+ ghe.move(moving_vec)
+ forconnectorinself.connectors:
+ connector.move(moving_vec)
+
+
+
+[docs]
+ defrotate_xy(self,angle,origin):
+"""Rotate this object counterclockwise in the 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.
+ """
+ forgheinself.ground_heat_exchangers:
+ ghe.rotate_xy(angle,origin)
+ forconnectorinself.connectors:
+ connector.rotate_xy(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.
+ """
+ forgheinself.ground_heat_exchangers:
+ ghe.reflect(plane)
+ forconnectorinself.connectors:
+ connector.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).
+ """
+ forgheinself.ground_heat_exchangers:
+ ghe.scale(factor,origin)
+ forconnectorinself.connectors:
+ connector.scale(factor,origin)
+
+
+
+[docs]
+ defconvert_to_units(self,units='Meters',starting_units='Meters'):
+"""Convert all of the geometry in this ThermalLoop to certain units.
+
+ Args:
+ units: Text for the units to which the Model geometry should be
+ converted. (Default: Meters). Choose from the following:
+
+ * Meters
+ * Millimeters
+ * Feet
+ * Inches
+ * Centimeters
+
+ starting_units: The starting units system of the loop. (Default: Meters).
+ """
+ ifstarting_units!=units:
+ scale_fac1=conversion_factor_to_meters(starting_units)
+ scale_fac2=conversion_factor_to_meters(units)
+ scale_fac=scale_fac1/scale_fac2
+ self.scale(scale_fac)
+[docs]
+ defto_geojson_dict(self,buildings,location,point=Point2D(0,0),tolerance=0.01):
+"""Get GHEThermalLoop dictionary as it appears in an URBANopt geoJSON.
+
+ The resulting dictionary array can be directly appended to the "features"
+ key of a base GeoJSON dict in order to represent the loop in the
+ GeoJSON. Note that, in order to successfully simulate the DES, you will also
+ have to write a system_parameter.json from this GHEThermalLoop using
+ the to_des_param_dict method.
+
+ Args:
+ buildings: An array of Dragonfly Building objects that are along
+ the GHEThermalLoop. Buildings that do not have their footprint
+ touching the loop's ThermalConnectors are automatically excluded
+ in the result.
+ location: A ladybug Location object possessing longitude and latitude data.
+ point: A ladybug_geometry Point2D for where the location object exists
+ within the space of a scene. The coordinates of this point are
+ expected to be in the units of this Model. (Default: (0, 0)).
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # get the conversion factors over to (longitude, latitude)
+ origin_lon_lat=origin_long_lat_from_location(location,point)
+ convert_facs=meters_to_long_lat_factors(origin_lon_lat)
+
+ # translate ground heat exchangers into the GeoJSON features list
+ features_list=[]
+ forgheinself.ground_heat_exchangers:
+ features_list.append(ghe.to_geojson_dict(origin_lon_lat,convert_facs))
+
+ # get the footprints of the Buildings in 2D space
+ footprint_2d,bldg_ids=GHEThermalLoop._building_footprints(
+ buildings,tolerance)
+ all_feat=footprint_2d+[ghe.geometryforgheinself.ground_heat_exchangers]
+ feat_ids=bldg_ids+[ghe.identifierforgheinself.ground_heat_exchangers]
+
+ # order the connectors correctly on the loop and translate them to features
+ ordered_conns=self.ordered_connectors(buildings,tolerance)
+ junctions,connector_jct_ids=self._junctions_from_connectors(
+ ordered_conns,tolerance)
+ forconn,jct_idsinzip(self.connectors,connector_jct_ids):
+ st_feat,end_feat,cp1,cp2=None,None,conn.geometry.p1,conn.geometry.p2
+ forf_poly,f_idinzip(all_feat,feat_ids):
+ iff_poly.is_point_on_edge(cp1,tolerance):
+ st_feat=f_id
+ eliff_poly.is_point_on_edge(cp2,tolerance):
+ end_feat=f_id
+ conn_dict=conn.to_geojson_dict(
+ jct_ids[0],jct_ids[1],origin_lon_lat,convert_facs,st_feat,end_feat)
+ features_list.append(conn_dict)
+
+ # translate junctions into the GeoJSON features list
+ forjctinjunctions:
+ forbldg_poly,bldg_idinzip(footprint_2d,bldg_ids):
+ ifbldg_poly.is_point_on_edge(jct.geometry,tolerance):
+ jct.building_identifier=bldg_id
+ break
+ fori,jctinenumerate(junctions):
+ jct_dict=jct.to_geojson_dict(origin_lon_lat,convert_facs)
+ ifi==0:
+ jct_dict['properties']['is_ghe_start_loop']=True
+ features_list.append(jct_dict)
+ returnfeatures_list
+
+
+
+[docs]
+ defto_des_param_dict(self,buildings,tolerance=0.01):
+"""Get the DES System Parameter dictionary for the ThermalLoop.
+
+ Args:
+ buildings: An array of Dragonfly Building objects that are along
+ the GHEThermalLoop. Buildings that do not have their footprint
+ touching the loop's ThermalConnectors are automatically excluded
+ in the result.
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # set up a dictionary to be updated with the params
+ des_dict={}
+
+ # add the relevant buildings to the DES parameter dictionary
+ footprint_2d,bldg_ids=GHEThermalLoop._building_footprints(
+ buildings,tolerance)
+ rel_bldg_ids=set()
+ junctions,_=self.junctions(tolerance)
+ forjctinjunctions:
+ forbldg_poly,bldg_idinzip(footprint_2d,bldg_ids):
+ ifbldg_poly.is_point_on_edge(jct.geometry,tolerance):
+ rel_bldg_ids.add(bldg_id)
+ bldg_array=[]
+ forbldg_idinrel_bldg_ids:
+ b_dict={
+ 'geojson_id':bldg_id,
+ 'load_model':'time_series',
+ 'load_model_parameters':{
+ 'time_series':{
+ 'filepath':'To be populated',
+ 'delta_temp_air_cooling':10,
+ 'delta_temp_air_heating':18,
+ 'has_liquid_cooling':True,
+ 'has_liquid_heating':True,
+ 'has_electric_cooling':False,
+ 'has_electric_heating':False,
+ 'max_electrical_load':0,
+ 'temp_chw_return':12,
+ 'temp_chw_supply':7,
+ 'temp_hw_return':35,
+ 'temp_hw_supply':40,
+ 'temp_setpoint_cooling':24,
+ 'temp_setpoint_heating':20
+ }
+ },
+ 'ets_model':'Fifth Gen Heat Pump',
+ 'fifth_gen_ets_parameters':{
+ 'supply_water_temperature_building':15,
+ 'chilled_water_supply_temp':5,
+ 'hot_water_supply_temp':50,
+ 'cop_heat_pump_heating':2.5,
+ 'cop_heat_pump_cooling':3.5,
+ 'pump_flow_rate':0.01,
+ 'pump_design_head':150000,
+ 'ets_pump_flow_rate':0.0005,
+ 'ets_pump_head':10000,
+ 'fan_design_flow_rate':0.25,
+ 'fan_design_head':150
+ }
+ }
+ bldg_array.append(b_dict)
+ des_dict['buildings']=bldg_array
+
+ # add the ground loop parameters
+ des_param={
+ 'fifth_generation':{
+ 'ghe_parameters':self.to_ghe_param_dict(tolerance)
+ }
+ }
+ des_dict['district_system']=des_param
+ returndes_dict
+
+
+
+[docs]
+ defto_ghe_param_dict(self,tolerance=0.01):
+"""Get the GroundHeatExchanger as it appears in a System Parameter dictionary.
+
+ Args:
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # compute the geometric constraints of the borehole fields
+ geo_pars=[]
+ forgheinself.ground_heat_exchangers:
+ ghe_geo=ghe.geometry
+ max_dim=max((ghe_geo.max.x-ghe_geo.min.x,ghe_geo.max.y-ghe_geo.min.y))
+ ang_tol=tolerance/max_dim
+ ifghe_geo.is_rectangle(ang_tol):
+ ghe_dims=(ghe_geo.segments[0].length,ghe_geo.segments[1].length)
+ else:
+ rect_geo=ghe_geo.rectangular_approximation()
+ ghe_dims=(rect_geo.segments[0].length,rect_geo.segments[1].length)
+ geo_par={
+ 'ghe_id':ghe.identifier,
+ 'ghe_geometric_params':{
+ 'length_of_ghe':max(ghe_dims),
+ 'width_of_ghe':min(ghe_dims)
+ },
+ 'borehole':{
+ 'buried_depth':self.borehole_parameters.buried_depth,
+ 'diameter':self.borehole_parameters.diameter
+ },
+ 'ground_loads':[]
+ }
+ geo_pars.append(geo_par)
+ # handle autocalculated soil temperatures
+ u_temp=self.soil_parameters.undisturbed_temperature \
+ ifself.soil_parameters._undisturbed_temperatureisnotNone \
+ else'Autocalculate'
+ # return a dictionary with all of the information
+ return{
+ 'fluid':{
+ 'fluid_name':self.fluid_parameters.fluid_type,
+ 'concentration_percent':self.fluid_parameters.concentration,
+ 'temperature':self.fluid_parameters.temperature
+ },
+ 'grout':{
+ 'conductivity':self.soil_parameters.grout_conductivity,
+ 'rho_cp':self.soil_parameters.grout_heat_capacity,
+ },
+ 'soil':{
+ 'conductivity':self.soil_parameters.conductivity,
+ 'rho_cp':self.soil_parameters.heat_capacity,
+ 'undisturbed_temp':u_temp
+ },
+ 'pipe':{
+ 'inner_diameter':self.pipe_parameters.inner_diameter,
+ 'outer_diameter':self.pipe_parameters.outer_diameter,
+ 'shank_spacing':self.pipe_parameters.shank_spacing,
+ 'roughness':self.pipe_parameters.roughness,
+ 'conductivity':self.pipe_parameters.conductivity,
+ 'rho_cp':self.pipe_parameters.heat_capacity,
+ 'arrangement':self.pipe_parameters.arrangement.lower()
+ },
+ 'simulation':{
+ 'num_months':self.design_parameters.month_count
+ },
+ 'geometric_constraints':{
+ 'b_min':self.borehole_parameters.min_spacing,
+ 'b_max':self.borehole_parameters.max_spacing,
+ 'max_height':self.borehole_parameters.max_depth,
+ 'min_height':self.borehole_parameters.min_depth,
+ 'method':'rectangle'
+ },
+ 'design':{
+ 'method':'AREAPROPORTIONAL',
+ 'flow_rate':self.design_parameters.flow_rate,
+ 'flow_type':self.design_parameters.flow_type.lower(),
+ 'max_eft':self.design_parameters.max_eft,
+ 'min_eft':self.design_parameters.min_eft
+ },
+ 'ghe_specific_params':geo_pars
+ }
+
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+
+
+
+[docs]
+ @staticmethod
+ defghe_designer_dict(
+ thermal_load,site_geometry,soil_parameters=None,fluid_parameters=None,
+ pipe_parameters=None,borehole_parameters=None,design_parameters=None,
+ tolerance=0.01):
+"""Get a dictionary following the schema of the input JSON for GHEDesigner.
+
+ This includes many of the same parameters that are used to size ground
+ heat exchangers in an URBANopt DES system but it requires the input of
+ hourly thermal loads.
+
+ The dictionary returned by this method can be written to a JSON and
+ passed directly to the GHEDesigner CLI in order to receive sizing
+ information for the GHE and a G-function that can be used to meet
+ the input load in a building energy simulation.
+
+ Args:
+ thermal_load: An annual data collection of hourly thermal loads on
+ the ground in Watts. These are the heat extraction and heat rejection
+ loads directly on the ground heat exchanger and should already
+ account for factors like additional heat added or removed by the
+ heat pump compressors. Positive values indicate heat extraction
+ from the ground and negative values indicate heat rejection to
+ the ground.
+ site_geometry: A list of horizontal Face3D representing the footprint
+ of the site to be populated with boreholes. These Face3D can
+ have holes in them and these holes will be excluded from
+ borehole placement. Note that it is expected that this geometry's
+ dimensions are in meters and, if they are not, then it should
+ be scaled before input to this method.
+ soil_parameters: Optional SoilParameter object to specify the properties
+ of the soil in which the loop is operating. If None, default
+ values will be used. (Default: None).
+ fluid_parameters: Optional FluidParameter object to specify the properties
+ of the fluid that is circulating through the loop. If None, default
+ values will be used. (Default: None).
+ pipe_parameters: Optional PipeParameter object to specify the properties
+ of the ground-heat-exchanging pipes used across the loop. If None,
+ default values will be used. (Default: None).
+ borehole_parameters: Optional BoreholeParameter object to specify the
+ properties of the boreholes used across the loop. If None,
+ default values will be used. (Default: None).
+ design_parameters: Optional GHEDesignParameter object to specify the
+ design constraints across the loop. If None, default values
+ will be used. (Default: None).
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # check that the inputs are what we expect
+ assertisinstance(thermal_load,HourlyContinuousCollection), \
+ 'Expected hourly continuous data collection for thermal_load. ' \
+ 'Got {}'.format(type(thermal_load))
+ period=thermal_load.header.analysis_period
+ assertperiod.is_annualandperiod.timestep==1,'Hourly thermal load ' \
+ 'is not annual. Analysis period is: {}.'.format(period)
+ assertthermal_load.header.unit=='W','Expected load data collection to be in Watts. ' \
+ 'Got {}.'.format(thermal_load.header.unit)
+
+ # process the input geometry into the format needed for GHEDesigner
+ site_boundaries,site_holes=[],[]
+ forfaceinsite_geometry:
+ bnd_poly=Polygon2D([Point2D(pt.x,pt.y)forptinface.boundary])
+ bnd_poly=bnd_poly.remove_colinear_vertices(tolerance)
+ ifbnd_poly.is_clockwise:
+ bnd_poly=bnd_poly.reverse()
+ site_boundaries.append([[pt.x,pt.y]forptinbnd_poly])
+ ifface.has_holes:
+ forholeinface.holes:
+ hole_poly=Polygon2D([Point2D(pt.x,pt.y)forptinhole])
+ hole_poly=hole_poly.remove_colinear_vertices(tolerance)
+ ifhole_poly.is_clockwise:
+ hole_poly=hole_poly.reverse()
+ site_holes.append([[pt.x,pt.y]forptinhole_poly])
+
+ # set defaults if any of the inputs are unspecified
+ soil=soil_parametersifsoil_parametersisnotNoneelseSoilParameter()
+ fluid=fluid_parametersiffluid_parametersisnotNoneelseFluidParameter()
+ pipe=pipe_parametersifpipe_parametersisnotNoneelsePipeParameter()
+ borehole=borehole_parametersifborehole_parametersisnotNone \
+ elseBoreholeParameter()
+ design=design_parametersifpipe_parametersisnotNone \
+ elseGHEDesignParameter()
+ u_temp=18.3ifsoil._undisturbed_temperatureisNone \
+ elsesoil.undisturbed_temperature
+
+ # return a dictionary with all of the inputs
+ return{
+ 'fluid':{
+ 'fluid_name':fluid.fluid_type,
+ 'concentration_percent':fluid.concentration,
+ 'temperature':fluid.temperature
+ },
+ 'grout':{
+ 'conductivity':soil.grout_conductivity,
+ 'rho_cp':soil.grout_heat_capacity
+ },
+ 'soil':{
+ 'conductivity':soil.conductivity,
+ 'rho_cp':soil.heat_capacity,
+ 'undisturbed_temp':u_temp
+ },
+ 'pipe':{
+ 'inner_diameter':pipe.inner_diameter,
+ 'outer_diameter':pipe.outer_diameter,
+ 'shank_spacing':pipe.shank_spacing,
+ 'roughness':pipe.roughness,
+ 'conductivity':pipe.conductivity,
+ 'rho_cp':pipe.heat_capacity,
+ 'arrangement':pipe.arrangement.upper()
+ },
+ 'borehole':{
+ 'buried_depth':borehole.buried_depth,
+ 'diameter':borehole.diameter
+ },
+ 'simulation':{
+ 'num_months':design.month_count
+ },
+ 'geometric_constraints':{
+ 'b_min':borehole.min_spacing,
+ 'b_max_x':borehole.max_spacing,
+ 'b_max_y':borehole.max_spacing,
+ 'max_height':borehole.max_depth,
+ 'min_height':borehole.min_depth,
+ 'property_boundary':site_boundaries,
+ 'no_go_boundaries':site_holes,
+ 'method':'BIRECTANGLECONSTRAINED'
+ },
+ 'design':{
+ 'flow_rate':design.flow_rate,
+ 'flow_type':'BOREHOLE',
+ 'max_eft':design.max_eft,
+ 'min_eft':design.min_eft
+ },
+ 'loads':{
+ 'ground_loads':thermal_load.values
+ }
+ }
+
+
+
+[docs]
+ @staticmethod
+ defassign_junction_buildings(junctions,buildings,tolerance=0.01):
+"""Assign building_identifiers to a list of junctions using dragonfly Buildings.
+
+ Junctions will be assigned to a given Building if they are touching
+ the footprint of that building in 2D space.
+
+ Args:
+ junctions: An array of ThermalJunction objects to be associated
+ with Dragonfly Buildings.
+ buildings: An array of Dragonfly Building objects in the same units
+ system as the ThermalLoop geometry.
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # get the footprints of the Buildings in 2D space
+ footprint_2d,bldg_ids=GHEThermalLoop._building_footprints(
+ buildings,tolerance)
+
+ # loop through connectors and associate them with the Buildings
+ forjctinjunctions:
+ forbldg_poly,bldg_idinzip(footprint_2d,bldg_ids):
+ ifbldg_poly.is_point_on_edge(jct.geometry,tolerance):
+ jct.building_identifier=bldg_id
+ break
+ returnjunctions
+
+
+ def_junctions_from_connectors(self,connectors,tolerance):
+"""Get a list of ThermalJunction objects given a list of ThermalConnectors.
+ """
+ # loop through the connectors and find all unique junction objects
+ junctions,connector_junction_ids=[],[]
+ forconnectorinconnectors:
+ verts=connector.geometry.vertices
+ end_pts,jct_ids=(verts[0],verts[-1]),[]
+ forjct_ptinend_pts:
+ forexist_jctinjunctions:
+ ifjct_pt.is_equivalent(exist_jct.geometry,tolerance):
+ jct_ids.append(exist_jct.identifier)
+ break
+ else:# we have found a new unique junction
+ new_jct_id=str(uuid.uuid4())
+ junctions.append(ThermalJunction(new_jct_id,jct_pt))
+ jct_ids.append(new_jct_id)
+ connector_junction_ids.append(jct_ids)
+
+ # loop through district system objects to determine adjacent junctions
+ forjctinjunctions:
+ fords_objinself.ground_heat_exchangers:
+ ifds_obj.geometry.is_point_on_edge(jct.geometry,tolerance):
+ jct.system_identifier=ds_obj.identifier
+ break
+ returnjunctions,connector_junction_ids
+
+ @staticmethod
+ def_building_footprints(buildings,tolerance=0.01):
+"""Get Polygon2Ds for each Dragonfly Building footprint."""
+ # get the footprints of the Buildings in 2D space
+ footprint_2d,bldg_ids=[],[]
+ forbldginbuildings:
+ footprint=bldg.footprint(tolerance)
+ forface3dinfootprint:
+ pts_2d=[Point2D(pt.x,pt.y)forptinface3d.vertices]
+ footprint_2d.append(Polygon2D(pts_2d))
+ bldg_ids.append(bldg.identifier)
+ returnfootprint_2d,bldg_ids
+
+ def__copy__(self):
+ new_loop=GHEThermalLoop(
+ self.identifier,
+ tuple(ghe.duplicate()forgheinself.ground_heat_exchangers),
+ tuple(conn.duplicate()forconninself.connectors),self.clockwise_flow,
+ self.soil_parameters.duplicate(),self.fluid_parameters.duplicate(),
+ self.pipe_parameters.duplicate(),self.borehole_parameters.duplicate())
+ new_loop._display_name=self._display_name
+ returnnew_loop
+
+
+[docs]
+classFourthGenThermalLoop(object):
+"""Represents a Fourth Generation Heating/Cooling Thermal Loop in a DES.
+
+ Args:
+ identifier: Text string for a unique thermal loop ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ chilled_water_setpoint: A number for the temperature of chilled water
+ in the DES in degrees C. (Default: 6).
+ hot_water_setpoint: A number for the temperature of hot water in the DES
+ in degrees C. (Default: 54).
+
+ Properties:
+ * identifier
+ * display_name
+ * chilled_water_setpoint
+ * hot_water_setpoint
+ """
+ __slots__=(
+ '_identifier','_display_name','_chilled_water_setpoint','_hot_water_setpoint')
+
+ def__init__(self,identifier,chilled_water_setpoint=6,hot_water_setpoint=54):
+"""Initialize GHEThermalLoop."""
+ self.identifier=identifier
+ self._display_name=None
+ self.chilled_water_setpoint=chilled_water_setpoint
+ self.hot_water_setpoint=hot_water_setpoint
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize an FourthGenThermalLoop from a dictionary.
+
+ Args:
+ data: A dictionary representation of an FourthGenThermalLoop object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='FourthGenThermalLoop','Expected FourthGenThermalLoop ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ cwt=data['chilled_water_setpoint']if'chilled_water_setpoint'indata \
+ anddata['chilled_water_setpoint']isnotNoneelse6
+ hwt=data['hot_water_setpoint']if'hot_water_setpoint'indata \
+ anddata['hot_water_setpoint']isnotNoneelse54
+ loop=cls(data['identifier'],cwt,hwt)
+ if'display_name'indataanddata['display_name']isnotNone:
+ loop.display_name=data['display_name']
+ returnloop
+
+
+ @property
+ defidentifier(self):
+"""Get or set the text string for unique object identifier."""
+ returnself._identifier
+
+ @identifier.setter
+ defidentifier(self,identifier):
+ self._identifier=valid_ep_string(identifier,'identifier')
+
+ @property
+ defdisplay_name(self):
+"""Get or set a string for the object name without any character restrictions.
+
+ If not set, this will be equal to the identifier.
+ """
+ ifself._display_nameisNone:
+ returnself._identifier
+ returnself._display_name
+
+ @display_name.setter
+ defdisplay_name(self,value):
+ try:
+ self._display_name=str(value)
+ exceptUnicodeEncodeError:# Python 2 machine lacking the character set
+ self._display_name=value# keep it as unicode
+
+ @property
+ defchilled_water_setpoint(self):
+"""Get or set a number for the chilled water setpoint in degrees C."""
+ returnself._chilled_water_setpoint
+
+ @chilled_water_setpoint.setter
+ defchilled_water_setpoint(self,value):
+ self._chilled_water_setpoint= \
+ float_in_range(value,0,20,'chilled water setpoint')
+
+ @property
+ defhot_water_setpoint(self):
+"""Get or set a number for the hot water setpoint in degrees C."""
+ returnself._hot_water_setpoint
+
+ @hot_water_setpoint.setter
+ defhot_water_setpoint(self,value):
+ self._hot_water_setpoint= \
+ float_in_range(value,24,100,'hot water setpoint')
+
+
+# coding=utf-8
+"""Mange OpenStudio measures that can be mapped to different buildings in a model."""
+from__future__importdivision
+
+importos
+importxml.etree.ElementTreeasElementTree
+fromhoneybee_energy.measureimportMeasure,MeasureArgument
+
+
+
+[docs]
+classMapperMeasure(Measure):
+"""An OpenStudio measure that can be mapped to different buildings in a model.
+
+ Args:
+ folder: Path to the folder in which the measure exists. This folder
+ must contain a measure.rb and a measure.xml file. Other files are
+ optional.
+
+ Properties:
+ * folder
+ * metadata_file
+ * program_file
+ * resources_folder
+ * identifier
+ * display_name
+ * description
+ * type
+ * arguments
+ """
+ __slots__=()
+
+ def__init__(self,folder):
+"""Initialize MapperMeasure."""
+ Measure.__init__(self,folder)
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data,folder='.'):
+"""Initialize a MapperMeasure from a dictionary.
+
+ Args:
+ data: A dictionary in the format below.
+ folder: Path to a destination folder to save the measure files. (Default '.')
+
+ .. code-block:: python
+
+ {
+ "type": "MapperMeasure",
+ "identifier": string, # Measure identifier
+ "xml_data": string, # XML file data as string
+ "rb_data": string, # Ruby file data as string
+ "resource_data": {}, # Dictionary of strings for any resource ruby files
+ "argument_values": [], # List of values for each of the measure arguments
+ }
+ """
+ assertdata['type']=='MapperMeasure', \
+ 'Expected MapperMeasure dictionary. Got {}.'.format(data['type'])
+ fp=os.path.join(folder,data['identifier'])
+ ifnotos.path.isdir(fp):
+ os.makedirs(fp)
+
+ # write out the contents of the measure
+ xml_fp=os.path.join(fp,'measure.xml')
+ cls._decompress_to_file(data['xml_data'],xml_fp)
+ rb_fp=os.path.join(fp,'measure.rb')
+ cls._decompress_to_file(data['rb_data'],rb_fp)
+ if'resource_data'indataanddata['resource_data']isnotNone:
+ resource_path=os.path.join(fp,'resources')
+ os.makedirs(resource_path)
+ forf_name,resindata['resource_data'].items():
+ res_fp=os.path.join(resource_path,f_name)
+ cls._decompress_to_file(res,res_fp)
+
+ # create the measure object and assign the arguments
+ new_measure=cls(fp)
+ forarg,valinzip(new_measure.arguments,data['argument_values']):
+ ifvalisnotNone:
+ arg.value=val
+ returnnew_measure
+
+
+
+[docs]
+ defto_dict(self):
+"""Convert MapperMeasure to a dictionary."""
+ base=Measure.to_dict(self)
+ base['type']='MapperMeasure'
+ returnbase
+
+
+
+[docs]
+ defto_osw_dict(self,full_path=False):
+"""Get a Python dictionary that can be written to an OSW JSON.
+
+ Specifically, this dictionary can be appended to the "steps" key of the
+ OpenStudio Workflow (.osw) JSON dictionary in order to include the measure
+ in the workflow.
+
+ Note that this method does not perform any checks to validate that the
+ Measure has all required values and only arguments with values will be
+ included in the dictionary. Validation should be done separately with
+ the validate method.
+
+ Args:
+ full_path: Boolean to note whether the full path to the measure should
+ be written under the 'measure_dir_name' key or just the measure
+ base name. (Default: False)
+ """
+ meas_dir=self.folderiffull_pathelseos.path.basename(self.folder)
+ base={'measure_dir_name':meas_dir,'arguments':{}}
+ forarginself._arguments:
+ ifarg.valueisnotNone:
+ base['arguments'][arg.identifier]=arg.value \
+ ifnotisinstance(arg.value,tuple)elsearg.value[0]
+ returnbase
+
+
+ def_parse_metadata_file(self):
+"""Parse measure properties from the measure.xml file."""
+ # create an element tree object
+ tree=ElementTree.parse(self._metadata_file)
+ root=tree.getroot()
+
+ # parse the measure properties from the element tree
+ self._identifier=root.find('name').text
+ self._display_name=root.find('display_name').text
+ self._description=root.find('description').text
+ self._type=None
+ foratrinroot.find('attributes'):
+ ifatr.find('name').text=='Measure Type':
+ self._type=atr.find('value').text
+
+ # parse the measure arguments
+ self._arguments=[]
+ forarginroot.find('arguments'):
+ arg_obj=MapperMeasureArgument(arg)
+ ifarg_obj.model_dependent:
+ # TODO: Figure out how to implement model-dependent arguments
+ raiseNotImplementedError(
+ 'Model dependent arguments are not yet supported and measure '
+ 'argument is "{}" model dependent.'.format(arg_obj.identifier))
+ self._arguments.append(arg_obj)
+
+ def__repr__(self):
+ return'MapperMeasure: {}'.format(self.display_name)
+
+
+
+
+[docs]
+classMapperMeasureArgument(MeasureArgument):
+"""Object representing a single mapper measure argument.
+
+ Args:
+ xml_element: A Python XML Element object taken from the <arguments> section
+ of the measure.xml file.
+
+ Properties:
+ * identifier
+ * display_name
+ * value
+ * default_value
+ * type
+ * type_text
+ * required
+ * description
+ * model_dependent
+ * valid_choices
+ """
+ __slots__=()
+
+ def__init__(self,xml_element):
+"""Initialize MeasureArgument."""
+ MeasureArgument.__init__(self,xml_element)
+
+ @property
+ defvalue(self):
+"""Get or set the value or list of values for the argument.
+
+ When using a list, the length of it must match the number of buildings in
+ the dragonfly Model and each value corresponds to a building under the
+ Model.buildings property.
+
+ If not set, this will be equal to the default_value and, if no default
+ value is included for this argument, it will be None.
+ """
+ ifself._valueisnotNone:
+ returnself._value
+ returnself._default_value
+
+ @value.setter
+ defvalue(self,val):
+ ifvalisnotNone:
+ e_msg='Value for measure argument "'+self.identifier+ \
+ '" must be a {}. Got {}'
+ ifnotisinstance(val,(list,tuple)):
+ val=(val,)
+ try:
+ val=tuple(self._type(v)forvinval)
+ exceptException:
+ raiseTypeError(e_msg.format(self._type,type(val)))
+ ifself._valid_choices:
+ assertall(vinself._valid_choicesforvinval), \
+ 'Choice measure argument "{}" ' \
+ 'must be one of the following:\n{}\nGot {}'.format(
+ self.identifier,self._valid_choices,val)
+ self._value=valifvalisNoneorlen(val)!=1elseval[0]
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/dragonfly_energy/opendss/colorobj.html b/docs/_modules/dragonfly_energy/opendss/colorobj.html
new file mode 100644
index 00000000..6e70d8e0
--- /dev/null
+++ b/docs/_modules/dragonfly_energy/opendss/colorobj.html
@@ -0,0 +1,1287 @@
+
+
+
+
+
+
+ dragonfly_energy.opendss.colorobj — dragonfly-energy documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[docs]
+classColorNetwork(_ColorObject):
+"""Object for visualizing ElectricalNetwork attributes.
+
+ Args:
+ network: An ElectricalNetwork object, which will be colored with the attribute.
+ attr_name: A text string of an attribute that the input network equipment has.
+ This can have '.' that separate the nested attributes from one another.
+ For example, 'properties.kva' for the kva rating of transformers.
+ legend_parameters: An optional LegendParameter object to change the display
+ of the results (Default: None).
+
+ Properties:
+ * network
+ * attr_name
+ * legend_parameters
+ * attr_name_end
+ * attributes
+ * attributes_unique
+ * attributes_original
+ * geometries
+ * graphic_container
+ * min_point
+ * max_point
+ """
+ __slots__=('_network','_geometries')
+
+ def__init__(self,network,attr_name,legend_parameters=None):
+"""Initialize ColorNetwork."""
+ assertisinstance(network,ElectricalNetwork),'Expected ElectricalNetwork for' \
+ ' ColorNetwork. Got {}.'.format(type(network))
+ self._network=network
+ all_obj=(network.substation,)+network.transformers+network.connectors
+ self._geometries=tuple(obj.geometryforobjinall_obj)
+ self._min_point,self._max_point=_calculate_min_max(all_obj)
+
+ # assign the legend parameters of this object
+ self.legend_parameters=legend_parameters
+
+ # get the attributes of the input equipment
+ self._process_attribute_name(attr_name)
+ self._process_attributes(all_obj)
+
+ @property
+ defnetwork(self):
+"""Get the ElectricalNetwork associated with this object."""
+ returnself._network
+
+ @property
+ defgeometries(self):
+"""A tuple of Polygon2D, Polyline2D and LineSegment2D aligned with attributes.
+ """
+ returnself._geometries
+
+ @property
+ defmin_point(self):
+"""Get a Point3D for the minimum of the box around the objects."""
+ returnPoint3D(self._min_point.x,self._min_point.y,0)
+
+ @property
+ defmax_point(self):
+"""Get a Point3D for the maximum of the box around the objects."""
+ returnPoint3D(self._max_point.x,self._max_point.y,0)
+
+ def__repr__(self):
+"""Color ElectricalNetwork representation."""
+ return'Color Network: {} [{}]'.format(
+ self.network.display_name,self.attr_name_end)
+
+
+
+
+[docs]
+classColorNetworkResults(object):
+"""Class for coloring ElectricalNetwork geometry with simulation results.
+
+ Args:
+ data_collections: An array of data collections of the same data type,
+ which will be used to color the network with simulation results. Data
+ collections should all have headers with metadata dictionaries with 'type'
+ and 'name' keys. These keys will be used to match the data in the collections
+ to the input electrical network.
+ network: An ElectricalNetwork object, which will be colored with the attribute.
+ legend_parameters: An optional LegendParameter object to change the display
+ of the ColorNetworkResults (Default: None).
+ attribute: Text to note the attribute of the data collections with which the
+ network geometry should be colored. Typical values are max, min, average,
+ median, or total. This input can also be an integer (greater than or equal
+ to 0) to select a specific step of the data collections for which result
+ values will be generated. (Default: "Max" to color with the peak value).
+
+ Properties:
+ * data_collections
+ * network
+ * legend_parameters
+ * attribute
+ * matched_geometries
+ * matched_data
+ * matched_values
+ * graphic_container
+ * title_text
+ * data_type_text
+ * data_type
+ * unit
+ * analysis_period
+ * min_point
+ * max_point
+ """
+ __slots__=(
+ '_data_collections','_network','_legend_parameters','_attribute',
+ '_matched_geometries','_matched_data','_matched_values',
+ '_base_collection','_base_type','_base_unit','_min_point','_max_point')
+
+ def__init__(self,data_collections,network,
+ legend_parameters=None,attribute='max'):
+"""Initialize ColorNetworkResults."""
+ # check the input collections
+ accept_cols=(HourlyContinuousCollection,HourlyDiscontinuousCollection)
+ try:
+ data_collections=list(data_collections)
+ exceptTypeError:
+ raiseTypeError('Input data_collections must be an array. Got {}.'.format(
+ type(data_collections)))
+ assertlen(data_collections)>0, \
+ 'ColorNetworkResults must have at least one data_collection.'
+ fori,collinenumerate(data_collections):
+ assertisinstance(coll,accept_cols),'Expected hourly ' \
+ 'data collection for ColorNetworkResults. Got {}.'.format(type(coll))
+ self._base_collection=data_collections[0]
+ self._base_type=self._base_collection.header.data_type
+ self._base_unit=self._base_collection.header.unit
+ forcollindata_collections[1:]:
+ assertcoll.header.unit==self._base_unit, \
+ 'ColorNetworkResults data_collections must all have matching units. ' \
+ '{} != {}.'.format(coll.header.unit,self._base_unit)
+ assertlen(coll.values)==len(self._base_collection.values), \
+ 'ColorNetworkResults data_collections must be aligned with one another' \
+ '.{} != {}'.format(len(coll.values),len(self._base_collection.values))
+ self._data_collections=data_collections
+
+ # process the input electrical network
+ assertisinstance(network,ElectricalNetwork),'Expected ElectricalNetwork for' \
+ ' ColorNetworkResults. Got {}.'.format(type(network))
+ self._network=network
+ all_obj=(network.substation,)+network.transformers+network.connectors
+ self._min_point,self._max_point=_calculate_min_max(all_obj)
+ geo_dict={obj.identifier.lower().replace(':',''):obj.geometry
+ forobjinall_obj}
+ self._matched_geometries,self._matched_data=[],[]
+ fordatinself._data_collections:
+ try:
+ self._matched_geometries.append(
+ geo_dict[dat.header.metadata['name'].replace(':','')])
+ self._matched_data.append(dat)
+ exceptKeyError:# data could not be matched
+ pass
+
+ # assign the other properties of this object
+ self.legend_parameters=legend_parameters
+ self.attribute=attribute
+
+ @property
+ defdata_collections(self):
+"""Get a tuple of data collections assigned to this object."""
+ returntuple(self._data_collections)
+
+ @property
+ defnetwork(self):
+"""Get the ElectricalNetwork associated with this object."""
+ returnself._network
+
+ @property
+ defgeometries(self):
+"""A tuple of Polygon2D, Polyline2D and LineSegment2D aligned with attributes.
+ """
+ returnself._geometries
+
+ @property
+ deflegend_parameters(self):
+"""Get or set the legend parameters."""
+ returnself._legend_parameters
+
+ @legend_parameters.setter
+ deflegend_parameters(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,LegendParameters), \
+ 'Expected LegendParameters. Got {}.'.format(type(value))
+ self._legend_parameters=value.duplicate()
+ else:
+ self._legend_parameters=LegendParameters()
+
+ @property
+ defattribute(self):
+"""Get or set text for the data attribute or an integer a specific data step."""
+ returnself._attribute
+
+ @attribute.setter
+ defattribute(self,value):
+ ifnothasattr(self._base_collection,value):
+ value=int_in_range(
+ value,0,len(self._base_collection)-1,'simulation step')
+ self._attribute=value
+
+ @property
+ defmatched_geometries(self):
+"""Get a tuple of geometries that were matched with the data collections."""
+ returntuple(self._matched_geometries)
+
+ @property
+ defmatched_data(self):
+"""Get a tuple of data collections aligned with the matched_geometries."""
+ returntuple(self._matched_data)
+
+ @property
+ defmatched_values(self):
+"""Get an array of numbers that correspond to the matched_geometries.
+
+ These values are derived from the data_collections but they will be
+ averaged/totaled or for a specific time step depending on the
+ other inputs to this object.
+ """
+ ifisinstance(self.attribute,int):# specific index from all collections
+ returntuple(data[self._attribute]fordatainself._matched_data)
+ else:# data collection property
+ returntuple(getattr(data,self._attribute)
+ fordatainself._matched_data)
+
+ @property
+ defgraphic_container(self):
+"""Get a ladybug GraphicContainer that relates to this object.
+
+ The GraphicContainer possesses almost all things needed to visualize the
+ object including the legend, value_colors, lower_title_location,
+ upper_title_location, etc.
+ """
+ returnGraphicContainer(
+ self.matched_values,self.min_point,self.max_point,
+ self.legend_parameters,self.data_type,str(self.unit))
+
+ @property
+ deftitle_text(self):
+"""Text string for the title of the object."""
+ d_type_text=self.data_type
+ ifisinstance(self.attribute,int):# specific index from all collections
+ time_text=self.time_interval_text(self.attribute)
+ else:# average or total the data
+ time_text=str(self.analysis_period).split('@')[0]
+ d_type_text='{}{}'.format(self.attribute.capitalize(),d_type_text)
+ return'{}\n{}'.format('{} ({})'.format(d_type_text,self.unit),time_text)
+
+ @property
+ defdata_type(self):
+"""Text for the data type."""
+ returnself._base_type
+
+ @property
+ defunit(self):
+"""The unit of this object's data collections."""
+ returnself._base_unit
+
+ @property
+ defanalysis_period(self):
+"""The analysis_period of this object's data collections."""
+ returnself._base_collection.header.analysis_period
+
+ @property
+ defmin_point(self):
+"""Get a Point3D for the minimum of the box around the objects."""
+ returnPoint3D(self._min_point.x,self._min_point.y,0)
+
+ @property
+ defmax_point(self):
+"""Get a Point3D for the maximum of the box around the objects."""
+ returnPoint3D(self._max_point.x,self._max_point.y,0)
+
+
+[docs]
+ deftime_interval_text(self,simulation_step):
+"""Get text for a specific time simulation_step of the data collections.
+
+ Args:
+ simulation_step: An integer for the step of simulation for which
+ text should be generated.
+ """
+ returnstr(self._base_collection.datetimes[simulation_step])
+[docs]
+classElectricalConnector(_GeometryBase):
+"""Represents an electrical connector carrying wires in OpenDSS.
+
+ Args:
+ identifier: Text string for a unique electrical connector ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ geometry: A LineSegment2D or Polyline2D representing the geometry of the
+ electrical connector.
+ power_line: A PowerLine object representing the wires carried along the
+ electrical connector and their arrangement.
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ * power_line
+ * phase_count
+ * nominal_voltage
+ """
+ __slots__=('_power_line',)
+
+ def__init__(self,identifier,geometry,power_line):
+"""Initialize ElectricalConnector."""
+ _GeometryBase.__init__(self,identifier)# process the identifier
+ assertisinstance(geometry,(LineSegment2D,Polyline2D)),'Expected ' \
+ 'ladybug_geometry LineSegment2D or Polyline2D. Got {}'.format(type(geometry))
+ self._geometry=geometry
+ self.power_line=power_line
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize an ElectricalConnector from a dictionary.
+
+ Args:
+ data: A dictionary representation of an ElectricalConnector object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='ElectricalConnector','Expected ElectricalConnector ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ power_line=PowerLine.from_dict(data['power_line'])
+ geo=LineSegment2D.from_dict(data['geometry']) \
+ ifdata['geometry']['type']=='LineSegment2D' \
+ elsePolyline2D.from_dict(data['geometry'])
+ con=cls(data['identifier'],geo,power_line)
+ if'display_name'indataanddata['display_name']isnotNone:
+ con.display_name=data['display_name']
+ returncon
+
+
+
+[docs]
+ @classmethod
+ deffrom_dict_abridged(cls,data,power_lines):
+"""Initialize an ElectricalConnector from an abridged dictionary.
+
+ Args:
+ data: A ElectricalConnectorAbridged dictionary.
+ power_lines: A dictionary with identifiers of PowerLines as keys and Python
+ PowerLine objects as values.
+ """
+ assertdata['type']=='ElectricalConnectorAbridged', \
+ 'Expected ElectricalConnectorAbridged. Got {}.'.format(data['type'])
+ try:
+ power_line=power_lines[data['power_line']]
+ exceptKeyErrorase:
+ raiseValueError('Failed to find "{}" in power lines.'.format(e))
+ geo=LineSegment2D.from_dict(data['geometry']) \
+ ifdata['geometry']['type']=='LineSegment2D' \
+ elsePolyline2D.from_dict(data['geometry'])
+ con=cls(data['identifier'],geo,power_line)
+ if'display_name'indataanddata['display_name']isnotNone:
+ con.display_name=data['display_name']
+ returncon
+
+
+
+[docs]
+ @classmethod
+ deffrom_rnm_geojson_dict(
+ cls,data,origin_lon_lat,conversion_factors,power_lines):
+"""Get an ElectricalConnector from a dictionary as it appears in an RNM GeoJSON.
+
+ Args:
+ data: A GeoJSON dictionary representation of an ElectricalConnector feature.
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ power_lines: A dictionary with identifiers of PowerLines as keys and Python
+ PowerLine objects as values.
+ """
+ geo=cls._geojson_coordinates_to_line2d(
+ data['geometry']['coordinates'],origin_lon_lat,conversion_factors)
+ try:
+ power_line=power_lines[data['properties']['Equip']]
+ exceptKeyErrorase:
+ raiseValueError('Failed to find "{}" in power lines.'.format(e))
+ returncls(data['properties']['Code'],geo,power_line)
+
+
+ @property
+ defgeometry(self):
+"""Get a LineSegment2D or Polyline2D representing the electrical connector."""
+ returnself._geometry
+
+ @property
+ defpower_line(self):
+"""Get or set the PowerLine object carried along the electrical connector."""
+ returnself._power_line
+
+ @power_line.setter
+ defpower_line(self,value):
+ assertisinstance(value,PowerLine),'Expected PowerLine object' \
+ ' for electrical connector power_line. Got {}.'.format(type(value))
+ value.lock()# lock to avoid editing
+ self._power_line=value
+
+ @property
+ defphase_count(self):
+"""Get an integer for the number of phases this connector supports."""
+ returnself._power_line.phase_count
+
+ @property
+ defnominal_voltage(self):
+"""Get an integer for the nominal voltage of this connector."""
+ returnself._power_line.nominal_voltage
+
+
+[docs]
+ defto_dict(self,abridged=False):
+"""ElectricalConnector dictionary representation.
+
+ Args:
+ abridged: Boolean to note whether the full dictionary describing the
+ object should be returned (False) or just an abridged version (True),
+ which only specifies the identifier of the power line. (Default: False).
+ """
+ base={'type':'ElectricalConnector'}ifnot \
+ abridgedelse{'type':'ElectricalConnectorAbridged'}
+ base['identifier']=self.identifier
+ base['geometry']=self.geometry.to_dict()
+ base['power_line']=self.power_line.identifierifabridged \
+ elseself.power_line.to_dict()
+ ifself._display_nameisnotNone:
+ base['display_name']=self.display_name
+ returnbase
+
+
+
+[docs]
+ defto_geojson_dict(self,start_id,end_id,origin_lon_lat,conversion_factors):
+"""Get ElectricalConnector dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ start_id: Identifier of the junction at the start of the wire.
+ end_id: Identifier of the junction at the end of the wire.
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ ifisinstance(self.geometry,LineSegment2D):
+ pts=[(pt.x,pt.y)forptin(self.geometry.p1,self.geometry.p2)]
+ else:# it's a polyline
+ pts=[(pt.x,pt.y)forptinself.geometry.vertices]
+ coords=polygon_to_lon_lat(pts,origin_lon_lat,conversion_factors)
+ return{
+ 'type':'Feature',
+ 'properties':{
+ 'id':self.identifier,
+ 'type':'ElectricalConnector',
+ 'startJunctionId':start_id,
+ 'endJunctionId':end_id,
+ 'total_length':round(self.geometry.length,2),
+ 'connector_type':'Wire',
+ 'electrical_catalog_name':self.power_line.identifier,
+ 'name':self.display_name
+ },
+ 'geometry':{
+ 'type':'LineString',
+ 'coordinates':coords
+ }
+ }
+[docs]
+classElectricalJunction(_GeometryBase):
+"""Represents an electrical junction connecting two or more objects in OpenDSS.
+
+ Args:
+ identifier: Text string for a unique electrical junction ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ geometry: A LineSegment2D or Polyline2D representing the geometry of the
+ electrical junction.
+ system_identifier: An optional text string for the identifier of a district
+ system object associated with the junction. District system objects
+ include Transformers and Substations. (Default: None).
+ building_identifier: An optional text string for the identifier of a Building
+ object associated with the junction. (Default: None).
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ * system_identifier
+ * building_identifier
+ """
+ __slots__=('_system_identifier','_building_identifier')
+
+ def__init__(self,identifier,geometry,system_identifier=None,
+ building_identifier=None):
+"""Initialize ElectricalJunction."""
+ _GeometryBase.__init__(self,identifier)# process the identifier
+ assertisinstance(geometry,Point2D),'Expected ladybug_geometry ' \
+ 'Point2D for ElectricalJunction. Got {}'.format(type(geometry))
+ self._geometry=geometry
+ self.system_identifier=system_identifier
+ self.building_identifier=building_identifier
+
+ @property
+ defgeometry(self):
+"""Get a Point2D representing the ElectricalJunction."""
+ returnself._geometry
+
+ @property
+ defsystem_identifier(self):
+"""Get or set a text string for the ID of a Transformer or Substation."""
+ returnself._system_identifier
+
+ @system_identifier.setter
+ defsystem_identifier(self,value):
+ self._system_identifier=valid_ep_string(value,'system_identifier') \
+ ifvalueisnotNoneelseNone
+
+ @property
+ defbuilding_identifier(self):
+"""Get or set a text string for the ID of a dragonfly Building."""
+ returnself._building_identifier
+
+ @building_identifier.setter
+ defbuilding_identifier(self,value):
+ self._building_identifier=valid_ep_string(value,'building_identifier') \
+ ifvalueisnotNoneelseNone
+
+
+[docs]
+ defto_geojson_dict(self,origin_lon_lat,conversion_factors):
+"""Get an ElectricalJunction dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ pt=(self.geometry.x,self.geometry.y)
+ coord=polygon_to_lon_lat([pt],origin_lon_lat,conversion_factors)[0]
+ geo_dict={
+ 'type':'Feature',
+ 'properties':{
+ 'id':self.identifier,
+ 'type':'ElectricalJunction'
+ },
+ 'geometry':{
+ 'type':'Point',
+ 'coordinates':coord
+ }
+ }
+ ifself._system_identifierisnotNone:
+ geo_dict['properties']['DSId']=self._system_identifier
+ ifself._building_identifierisnotNone:
+ geo_dict['properties']['buildingId']=self._building_identifier
+ returngeo_dict
Source code for dragonfly_energy.opendss.lib.powerlines
+"""Library of power lines that come standard with dragonfly."""
+importos
+importjson
+
+from..powerlineimportPowerLine
+from.wiresimport_wires
+
+
+# load the defaults
+_power_lines={}
+_data_path=os.path.join(os.path.dirname(__file__),'extended_catalog.json')
+withopen(_data_path)asjson_file:
+ _all_data=json.load(json_file)['LINES']
+ _default_data=_all_data[1]['#Interurban Zone A:']+ \
+ _all_data[2]['#Urban-Overhead']+_all_data[3]['#Urban-Underground']
+for_t_dictin_default_data:
+ _t_obj=PowerLine.from_electrical_database_dict(_t_dict,_wires)
+ _t_obj.lock()
+ _power_lines[_t_dict['Name']]=_t_obj
+
+POWER_LINES=tuple(_power_lines.keys())
+
+
+
+[docs]
+defpower_line_by_identifier(power_line_identifier):
+"""Get power line properties from the library given the identifier.
+
+ Args:
+ power_line_identifier: A text string for the identifier of the power line.
+ """
+ try:
+ return_power_lines[power_line_identifier]
+ exceptKeyError:
+ raiseValueError(
+ '"{}" was not found in the power line library.'.format(
+ power_line_identifier))
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/dragonfly_energy/opendss/lib/transformers.html b/docs/_modules/dragonfly_energy/opendss/lib/transformers.html
new file mode 100644
index 00000000..ccedc909
--- /dev/null
+++ b/docs/_modules/dragonfly_energy/opendss/lib/transformers.html
@@ -0,0 +1,993 @@
+
+
+
+
+
+
+ dragonfly_energy.opendss.lib.transformers — dragonfly-energy documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Source code for dragonfly_energy.opendss.lib.transformers
+"""Library of transformer properties that come standard with dragonfly."""
+from..transformerpropimportTransformerProperties
+
+importos
+importjson
+
+# load the defaults
+_transformers={}
+_data_path=os.path.join(os.path.dirname(__file__),'extended_catalog.json')
+withopen(_data_path)asjson_file:
+ _all_data=json.load(json_file)['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS']
+ fordatinreversed(_all_data):# the last interurban one has transformers
+ if'#Interurban:'indat:
+ _default_data=dat['#Interurban:']
+ break
+for_t_dictin_default_data:
+ _t_obj=TransformerProperties.from_electrical_database_dict(_t_dict)
+ _t_obj.lock()
+ _transformers[_t_dict['Name']]=_t_obj
+
+TRANSFORMER_PROPERTIES=tuple(_transformers.keys())
+
+
+
+[docs]
+deftransformer_prop_by_identifier(transformer_identifier):
+"""Get transformer properties from the library given the identifier.
+
+ Args:
+ transformer_identifier: A text string for the identifier of the transformer
+ properties.
+ """
+ try:
+ return_transformers[transformer_identifier]
+ exceptKeyError:
+ raiseValueError(
+ '"{}" was not found in the transformer property library.'.format(
+ transformer_identifier))
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/dragonfly_energy/opendss/lib/wires.html b/docs/_modules/dragonfly_energy/opendss/lib/wires.html
new file mode 100644
index 00000000..5b1324c7
--- /dev/null
+++ b/docs/_modules/dragonfly_energy/opendss/lib/wires.html
@@ -0,0 +1,987 @@
+
+
+
+
+
+
+ dragonfly_energy.opendss.lib.wires — dragonfly-energy documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Source code for dragonfly_energy.opendss.lib.wires
+"""Library of wires that come standard with dragonfly."""
+importos
+importjson
+from..wireimportWire
+
+
+# load the defaults
+_wires={}
+_data_path=os.path.join(os.path.dirname(__file__),'extended_catalog.json')
+withopen(_data_path)asjson_file:
+ _default_data=json.load(json_file)['WIRES']['WIRES CATALOG']
+for_t_dictin_default_data:
+ _t_obj=Wire.from_electrical_database_dict(_t_dict)
+ _t_obj.lock()
+ _wires[_t_dict['nameclass']]=_t_obj
+
+WIRES=tuple(_wires.keys())
+
+
+
+[docs]
+defwire_by_identifier(wire_identifier):
+"""Get wire properties from the library given the identifier.
+
+ Args:
+ wire_identifier: A text string for the identifier of the wire.
+ """
+ try:
+ return_wires[wire_identifier]
+ exceptKeyError:
+ raiseValueError(
+ '"{}" was not found in the wire library.'.format(wire_identifier))
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/dragonfly_energy/opendss/network.html b/docs/_modules/dragonfly_energy/opendss/network.html
new file mode 100644
index 00000000..a2ac2162
--- /dev/null
+++ b/docs/_modules/dragonfly_energy/opendss/network.html
@@ -0,0 +1,1805 @@
+
+
+
+
+
+
+ dragonfly_energy.opendss.network — dragonfly-energy documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[docs]
+classElectricalNetwork(object):
+"""Represents an electrical network in OpenDSS.
+
+ This includes a substation, transformers, and all electrical connectors needed
+ to connect these objects to Dragonfly Buildings.
+
+ Args:
+ identifier: Text string for a unique electrical network ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ substation: A Substation object representing the electrical substation
+ supplying the network with electricity.
+ transformers: An array of Transformer objects that are included within the
+ electrical network. Generally, there should always be a transformer
+ somewhere between the substation and a given building.
+ connectors: An array of ElectricalConnector objects that are included
+ within the electrical network. In order for a given connector to be
+ valid within the network, each end of the connector must touch either
+ another connector or a building footprint/transformer/substation. In
+ order for the network as a whole to be valid, all Buildings and
+ Transformers must be connected back to the Substation via connectors.
+
+ Properties:
+ * identifier
+ * display_name
+ * substation
+ * transformers
+ * connectors
+ * transformer_properties
+ * power_lines
+ * wires
+ """
+ __slots__=('_identifier','_display_name','_substation',
+ '_transformers','_connectors')
+
+ def__init__(self,identifier,substation,transformers,connectors):
+"""Initialize ElectricalNetwork."""
+ self.identifier=identifier
+ self._display_name=None
+ self.substation=substation
+ self.transformers=transformers
+ self.connectors=connectors
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize an ElectricalNetwork from a dictionary.
+
+ Args:
+ data: A dictionary representation of an ElectricalNetwork object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='ElectricalNetwork','Expected ElectricalNetwork ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ # re-serialize transformer properties and wires
+ t_props={tp['identifier']:TransformerProperties.from_dict(tp)
+ fortpindata['transformer_properties']}
+ wires={w['identifier']:Wire.from_dict(w)forwindata['wires']}
+ power_lines={pl['identifier']:PowerLine.from_dict_abridged(pl,wires)
+ forplindata['power_lines']}
+ # re-serialize geometry objects
+ substation=Substation.from_dict(data['substation'])
+ transformers=[Transformer.from_dict_abridged(trans,t_props)
+ fortransindata['transformers']]
+ conns=[ElectricalConnector.from_dict_abridged(c,power_lines)
+ forcindata['connectors']]
+ net=cls(data['identifier'],substation,transformers,conns)
+ if'display_name'indataanddata['display_name']isnotNone:
+ net.display_name=data['display_name']
+ returnnet
+
+
+
+[docs]
+ @classmethod
+ deffrom_rnm_geojson(
+ cls,geojson_file_path,location=None,point=None,units='Meters'):
+"""Get an ElectricalNetwork from a dictionary as it appears in an RNM GeoJSON.
+
+ Args:
+ geojson_file_path: Text for the full path to the geojson file to load
+ as a ElectricalNetwork.
+ location: An optional ladybug location object with longitude and
+ latitude data defining the origin of the geojson file. If None,
+ an attempt will be made to sense the location from the project
+ point in the GeoJSON (if it exists). If nothing is found, the
+ origin is autocalcualted as the bottom-left corner of the bounding
+ box of all building footprints in the geojson file. (Default: None).
+ point: A ladybug_geometry Point2D for where the location object exists
+ within the space of a scene. The coordinates of this point are
+ expected to be in the units input. If None, an attempt will be
+ made to sense the CAD coordinates from the GeoJSON if they
+ exist. If not found, they will default to (0, 0).
+ units: Text for the units system in which the model geometry
+ exists. Default: 'Meters'. Choose from the following:
+
+ * Meters
+ * Millimeters
+ * Feet
+ * Inches
+ * Centimeters
+
+ Note that this method assumes the point coordinates are in the
+ same units.
+ """
+ # parse the geoJSON into a dictionary
+ withopen(geojson_file_path,'r')asfp:
+ data=json.load(fp)
+
+ # extract the CAD coordinates and location from the GeoJSON if they exist
+ if'project'indata:
+ prd=data['project']
+ if'latitude'inprdand'longitude'inprdandlocationisNone:
+ location=Location(latitude=prd['latitude'],longitude=prd['longitude'])
+ if'cad_coordinates'inprdandpointisNone:
+ point=Point2D(*prd['cad_coordinates'])
+ ifpointisNone:# just use the world origin if no point was found
+ point=Point2D(0,0)
+
+ # Get the list of substation, transformer and electrical connector data
+ transf_data,connector_data,subst_data=[],[],None
+ forobj_dataindata['features']:
+ if'type'inobj_data['properties']:
+ ifobj_data['properties']['type']=='Line':
+ connector_data.append(obj_data)
+ elifobj_data['properties']['type']=='DistribTransf':
+ transf_data.append(obj_data)
+ elif'Substation'inobj_data['properties']['type']:
+ subst_data=obj_data
+
+ # if model units is not Meters, convert non-meter user inputs to meters
+ scale_to_meters=conversion_factor_to_meters(units)
+ ifunits!='Meters':
+ point=point.scale(scale_to_meters)
+
+ # Get long and lat in the geojson that correspond to the model origin (point).
+ # If location is None, derive coordinates from the geojson geometry.
+ iflocationisNone:
+ point_lon_lat=cls._bottom_left_coordinate_from_geojson(connector_data)
+ location=Location(longitude=point_lon_lat[0],latitude=point_lon_lat[1])
+
+ # The model point may not be at (0, 0), so shift the longitude and latitude to
+ # get the equivalent point in longitude and latitude for (0, 0) in the model.
+ origin_lon_lat=origin_long_lat_from_location(location,point)
+ _convert_facs=meters_to_long_lat_factors(origin_lon_lat)
+ convert_facs=1/_convert_facs[0],1/_convert_facs[1]
+
+ # extract the connectors
+ power_line_dict={
+ p['properties']['Equip']:power_line_by_identifier(p['properties']['Equip'])
+ forpinconnector_data
+ }
+ connectors=[]
+ forcon_datainconnector_data:
+ con_obj=ElectricalConnector.from_rnm_geojson_dict(
+ con_data,origin_lon_lat,convert_facs,power_line_dict)
+ connectors.append(con_obj)
+ # extract the transformers
+ transformers=[]
+ fortrn_dataintransf_data:
+ trn_obj=Transformer.from_rnm_geojson_dict(
+ trn_data,origin_lon_lat,convert_facs)
+ transformers.append(trn_obj)
+ # extract the substation
+ substation=Substation.from_rnm_geojson_dict(
+ subst_data,origin_lon_lat,convert_facs)
+
+ # create the network and adjust for the units
+ base_name=os.path.basename(geojson_file_path)
+ net_id=base_name.replace('.json','').replace('.geojson','')
+ net=cls(net_id,substation,transformers,connectors)
+ ifunits!='Meters':
+ net.convert_to_units(units)
+ returnnet
+
+
+ @staticmethod
+ def_bottom_left_coordinate_from_geojson(connector_data):
+"""Calculate the bottom-left bounding box coordinate from geojson coordinates.
+
+ Args:
+ connector_data: a list of dictionaries containing geojson geometries that
+ represent electrical connectors.
+
+ Returns:
+ The bottom-left most corner of the bounding box around the coordinates.
+ """
+ xs,ys=[],[]
+ forconninconnector_data:
+ conn_coords=conn['geometry']['coordinates']
+ ifconn['geometry']['type']=='LineString':
+ forptinconn_coords:
+ xs.append(pt[0])
+ ys.append(pt[1])
+ returnmin(xs),min(ys)
+
+ @property
+ defidentifier(self):
+"""Get or set the text string for unique object identifier."""
+ returnself._identifier
+
+ @identifier.setter
+ defidentifier(self,identifier):
+ self._identifier=valid_ep_string(identifier,'identifier')
+
+ @property
+ defdisplay_name(self):
+"""Get or set a string for the object name without any character restrictions.
+
+ If not set, this will be equal to the identifier.
+ """
+ ifself._display_nameisNone:
+ returnself._identifier
+ returnself._display_name
+
+ @display_name.setter
+ defdisplay_name(self,value):
+ try:
+ self._display_name=str(value)
+ exceptUnicodeEncodeError:# Python 2 machine lacking the character set
+ self._display_name=value# keep it as unicode
+
+ @property
+ defsubstation(self):
+"""Get or set a Substation object for the network's substation."""
+ returnself._substation
+
+ @substation.setter
+ defsubstation(self,value):
+ assertisinstance(value,Substation), \
+ 'Expected Substation for electrical network. Got {}.'.format(type(value))
+ self._substation=value
+
+ @property
+ deftransformers(self):
+"""Get or set the list of Transformer objects within the network."""
+ returnself._transformers
+
+ @transformers.setter
+ deftransformers(self,values):
+ try:
+ ifnotisinstance(values,tuple):
+ values=tuple(values)
+ exceptTypeError:
+ raiseTypeError('Expected list or tuple for electrical network '
+ 'transformers. Got {}'.format(type(values)))
+ fortinvalues:
+ assertisinstance(t,Transformer),'Expected Transformer object' \
+ ' for electrical network transformers. Got {}.'.format(type(t))
+ self._transformers=values
+
+ @property
+ defconnectors(self):
+"""Get or set the list of ElectricalConnector objects within the network."""
+ returnself._connectors
+
+ @connectors.setter
+ defconnectors(self,values):
+ try:
+ ifnotisinstance(values,tuple):
+ values=tuple(values)
+ exceptTypeError:
+ raiseTypeError('Expected list or tuple for electrical network connectors. '
+ 'Got {}'.format(type(values)))
+ forcinvalues:
+ assertisinstance(c,ElectricalConnector),'Expected ElectricalConnector ' \
+ 'object for electrical network connectors. Got {}.'.format(type(c))
+ assertlen(values)>0,'ElectricalNetwork must possess at least one connector.'
+ self._connectors=values
+
+ @property
+ deftransformer_properties(self):
+"""A list of all unique TransformerProperties in the network."""
+ t_props=[]
+ fortransinself.transformers:
+ ifnotself._instance_in_array(trans.properties,t_props):
+ t_props.append(trans.properties)
+ returnlist(set(t_props))# catch duplicated/equivalent objects
+
+ @property
+ defpower_lines(self):
+"""A list of all unique PowerLines in the network."""
+ power_lines=[]
+ forconnectorinself.connectors:
+ ifnotself._instance_in_array(connector.power_line,power_lines):
+ power_lines.append(connector.power_line)
+ returnlist(set(power_lines))# catch duplicated/equivalent objects
+
+ @property
+ defwires(self):
+"""A list of all unique Wires in the network."""
+ wires=[]
+ forp_lineinself.power_lines:
+ forwireinp_line.wires:
+ ifnotself._instance_in_array(wire,wires):
+ wires.append(wire)
+ returnlist(set(wires))# catch duplicated/equivalent objects
+
+
+[docs]
+ defjunctions(self,tolerance=0.01):
+"""Get a list of ElectricalJunction objects for the unique network junctions.
+
+ The resulting ElectricalJunction objects will be associated with Transformers
+ and Substations that they are in contact with across the network (within
+ the tolerance). However, they won't have any building_identifier associated
+ with them. The assign_junction_buildings method on this object can be used
+ to associate the junctions with an array of Dragonfly Buildings.
+
+ Args:
+ tolerance: The minimum difference between the coordinate values of two
+ faces at which they can be considered centered adjacent. (Default: 0.01,
+ suitable for objects in meters).
+
+ Returns:
+ A tuple with two items.
+
+ - junctions - A list of lists of the unique ElectricalJunction objects
+ that exist across the network.
+
+ - connector_junction_ids - A list of lists that align with the connectors
+ in the network. Each sub-list contains two string values for the junction
+ IDs for each of the start and end of each of the connectors.
+ """
+ # loop through the connectors and find all unique junction objects
+ junctions,connector_junction_ids=[],[]
+ forconnectorinself.connectors:
+ verts=connector.geometry.vertices
+ end_pts,jct_ids=(verts[0],verts[-1]),[]
+ forjct_ptinend_pts:
+ forexist_jctinjunctions:
+ ifjct_pt.is_equivalent(exist_jct.geometry,tolerance):
+ jct_ids.append(exist_jct.identifier)
+ break
+ else:# we have found a new unique junction
+ new_jct_id=str(uuid.uuid4())
+ junctions.append(ElectricalJunction(new_jct_id,jct_pt))
+ jct_ids.append(new_jct_id)
+ connector_junction_ids.append(jct_ids)
+
+ # loop through connectors and associate them with Transformers or the Substation
+ all_ds_objs=self.transformers+(self.substation,)
+ forjctinjunctions:
+ fords_objinall_ds_objs:
+ ifds_obj.geometry.is_point_on_edge(jct.geometry,tolerance):
+ jct.system_identifier=ds_obj.identifier
+ break
+ returnjunctions,connector_junction_ids
+
+
+
+[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.
+ """
+ self._substation.move(moving_vec)
+ fortransformerinself.transformers:
+ transformer.move(moving_vec)
+ forconnectorinself.connectors:
+ connector.move(moving_vec)
+
+
+
+[docs]
+ defrotate_xy(self,angle,origin):
+"""Rotate this object counterclockwise in the 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.
+ """
+ self._substation.rotate_xy(angle,origin)
+ fortransformerinself.transformers:
+ transformer.rotate_xy(angle,origin)
+ forconnectorinself.connectors:
+ connector.rotate_xy(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.
+ """
+ self._substation.reflect(plane)
+ fortransformerinself.transformers:
+ transformer.reflect(plane)
+ forconnectorinself.connectors:
+ connector.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).
+ """
+ self._substation.scale(factor,origin)
+ fortransformerinself.transformers:
+ transformer.scale(factor,origin)
+ forconnectorinself.connectors:
+ connector.scale(factor,origin)
+
+
+
+[docs]
+ defconvert_to_units(self,units='Meters',starting_units='Meters'):
+"""Convert all of the geometry in this ElectricalNetwork to certain units.
+
+ Args:
+ units: Text for the units to which the Model geometry should be
+ converted. (Default: Meters). Choose from the following:
+
+ * Meters
+ * Millimeters
+ * Feet
+ * Inches
+ * Centimeters
+
+ starting_units: The starting units system of the network. (Default: Meters).
+ """
+ ifstarting_units!=units:
+ scale_fac1=conversion_factor_to_meters(starting_units)
+ scale_fac2=conversion_factor_to_meters(units)
+ scale_fac=scale_fac1/scale_fac2
+ self.scale(scale_fac)
+[docs]
+ defto_geojson_dict(self,buildings,location,point=Point2D(0,0),tolerance=0.01):
+"""Get ElectricalNetwork dictionary as it appears in an URBANopt geoJSON.
+
+ The resulting dictionary array can be directly appended to the "features"
+ key of a base geoJSON dict in order to represent the network in the
+ geoJSON. Note that, in order to successfully run OpenDSS, you will also
+ have to write an electrical_database.json from this ElectricalNetwork using
+ the to_electrical_database_dict method.
+
+ Args:
+ buildings: An array of Dragonfly Building objects in the same units
+ system as the ElectricalNetwork geometry.
+ location: A ladybug Location object possessing longitude and latitude data.
+ point: A ladybug_geometry Point2D for where the location object exists
+ within the space of a scene. The coordinates of this point are
+ expected to be in the units of this Model. (Default: (0, 0)).
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # get the conversion factors over to (longitude, latitude)
+ origin_lon_lat=origin_long_lat_from_location(location,point)
+ convert_facs=meters_to_long_lat_factors(origin_lon_lat)
+
+ # translate substation and transformers into the geoJSON features list
+ features_list=[self.substation.to_geojson_dict(origin_lon_lat,convert_facs)]
+ fortransinself.transformers:
+ features_list.append(trans.to_geojson_dict(origin_lon_lat,convert_facs))
+
+ # translate connectors and junctions into the geoJSON features list
+ junctions,connector_jct_ids=self.junctions(tolerance)
+ forconn,jct_idsinzip(self.connectors,connector_jct_ids):
+ conn_dict=conn.to_geojson_dict(
+ jct_ids[0],jct_ids[1],origin_lon_lat,convert_facs)
+ features_list.append(conn_dict)
+ final_junctions=self.assign_junction_buildings(junctions,buildings,tolerance)
+ forjctinfinal_junctions:
+ features_list.append(jct.to_geojson_dict(origin_lon_lat,convert_facs))
+ returnfeatures_list
+
+
+
+[docs]
+ defto_electrical_database_dict(self):
+"""Get ElectricalNetwork as it should appear in the electrical_database.json."""
+ catalog_json=os.path.join(
+ os.path.dirname(__file__),'lib','extended_catalog.json')
+ withopen(catalog_json)asinf:
+ base=json.load(inf)
+ base['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS']=[
+ {
+ '#Interurban:':
+ [tp.to_electrical_database_dict()fortpinself.transformer_properties]
+ }
+ ]
+ base['LINES'][1]['#Interurban Zone A:']= \
+ [pl.to_electrical_database_dict()forplinself.power_lines]
+ base['WIRES']['WIRES CATALOG']= \
+ [wire.to_electrical_database_dict()forwireinself.wires]
+ returnbase
+
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+
+
+
+[docs]
+ @staticmethod
+ defassign_junction_buildings(junctions,buildings,tolerance=0.01):
+"""Assign building_identifiers to a list of junctions using dragonfly Buildings.
+
+ Junctions will be assigned to a given Building if they are touching
+ the footprint of that building in 2D space.
+
+ Args:
+ junctions: An array of ElectricalJunction objects to be associated
+ with Dragonfly Buildings.
+ buildings: An array of Dragonfly Building objects in the same units
+ system as the ElectricalNetwork geometry.
+ tolerance: The minimum difference between the coordinate values of two
+ geometries at which they are considered co-located. (Default: 0.01,
+ suitable for objects in meters).
+ """
+ # get the footprints of the Buildings in 2D space
+ footprint_2d,bldg_ids=[],[]
+ forbldginbuildings:
+ footprint=bldg.footprint(tolerance)
+ forface3dinfootprint:
+ pts_2d=[Point2D(pt.x,pt.y)forptinface3d.vertices]
+ footprint_2d.append(Polygon2D(pts_2d))
+ bldg_ids.append(bldg.identifier)
+
+ # loop through connectors and associate them with the Buildings
+ forjctinjunctions:
+ forbldg_poly,bldg_idinzip(footprint_2d,bldg_ids):
+ ifbldg_poly.is_point_on_edge(jct.geometry,tolerance):
+ jct.building_identifier=bldg_id
+ break
+ returnjunctions
+
+
+ @staticmethod
+ def_instance_in_array(object_instance,object_array):
+"""Check if a specific object instance is already in an array.
+
+ This can be much faster than `if object_instance in object_array`
+ when you expect to be testing a lot of the same instance of an object for
+ inclusion in an array since the builtin method uses an == operator to
+ test inclusion.
+ """
+ forvalinobject_array:
+ ifvalisobject_instance:
+ returnTrue
+ returnFalse
+
+ def__copy__(self):
+ new_net=ElectricalNetwork(
+ self.identifier,self.substation.duplicate(),
+ tuple(trans.duplicate()fortransinself.transformers),
+ tuple(conn.duplicate()forconninself.connectors))
+ new_net._display_name=self._display_name
+ returnnew_net
+
+
+[docs]
+classRoadNetwork(object):
+"""Represents a road network for RNM input.
+
+ This includes a substation and roads that will be used to lay out the
+ road network.
+
+ Args:
+ identifier: Text string for a unique road network ID. Must contain only
+ characters that are acceptable in RNM nad OpenDSS. This will be used to
+ identify the object across the exported geoJSON RNM, and OpenDSS files.
+ substation: A Substation object representing the road substation
+ supplying the network with electricity.
+ roads: An array of Road objects that are included within the road network.
+
+ Properties:
+ * identifier
+ * display_name
+ * substation
+ * roads
+ """
+ __slots__=('_identifier','_display_name','_substation','_roads')
+
+ def__init__(self,identifier,substation,roads):
+"""Initialize RoadNetwork."""
+ self.identifier=identifier
+ self._display_name=None
+ self.substation=substation
+ self.roads=roads
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize an RoadNetwork from a dictionary.
+
+ Args:
+ data: A dictionary representation of an RoadNetwork object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='RoadNetwork','Expected RoadNetwork ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ # re-serialize geometry objects
+ substation=Substation.from_dict(data['substation'])
+ roads=[Road.from_dict(r)forrindata['roads']]
+ net=cls(data['identifier'],substation,roads)
+ if'display_name'indataanddata['display_name']isnotNone:
+ net.display_name=data['display_name']
+ returnnet
+
+
+ @property
+ defidentifier(self):
+"""Get or set the text string for unique object identifier."""
+ returnself._identifier
+
+ @identifier.setter
+ defidentifier(self,identifier):
+ self._identifier=valid_ep_string(identifier,'identifier')
+
+ @property
+ defdisplay_name(self):
+"""Get or set a string for the object name without any character restrictions.
+
+ If not set, this will be equal to the identifier.
+ """
+ ifself._display_nameisNone:
+ returnself._identifier
+ returnself._display_name
+
+ @display_name.setter
+ defdisplay_name(self,value):
+ try:
+ self._display_name=str(value)
+ exceptUnicodeEncodeError:# Python 2 machine lacking the character set
+ self._display_name=value# keep it as unicode
+
+ @property
+ defsubstation(self):
+"""Get or set a Substation object for the network's substation."""
+ returnself._substation
+
+ @substation.setter
+ defsubstation(self,value):
+ assertisinstance(value,Substation), \
+ 'Expected Substation for road network. Got {}.'.format(type(value))
+ self._substation=value
+
+ @property
+ defroads(self):
+"""Get or set the list of Road objects within the network."""
+ returnself._roads
+
+ @roads.setter
+ defroads(self,values):
+ try:
+ ifnotisinstance(values,tuple):
+ values=tuple(values)
+ exceptTypeError:
+ raiseTypeError('Expected list or tuple of roads. '
+ 'Got {}'.format(type(values)))
+ forrinvalues:
+ assertisinstance(r,Road),'Expected Road ' \
+ 'object for road network. Got {}.'.format(type(r))
+ assertlen(values)>0,'RoadNetwork must possess at least one road.'
+ self._roads=values
+
+
+[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.
+ """
+ self._substation.move(moving_vec)
+ forroadinself.roads:
+ road.move(moving_vec)
+
+
+
+[docs]
+ defrotate_xy(self,angle,origin):
+"""Rotate this object counterclockwise in the 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.
+ """
+ self._substation.rotate_xy(angle,origin)
+ forroadinself.roads:
+ road.rotate_xy(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.
+ """
+ self._substation.reflect(plane)
+ forroadinself.roads:
+ road.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).
+ """
+ self._substation.scale(factor,origin)
+ forroadinself.roads:
+ road.scale(factor,origin)
+[docs]
+ defto_geojson_dict(self,location,point=Point2D(0,0)):
+"""Get RoadNetwork dictionary as it appears in an URBANopt geoJSON.
+
+ The resulting dictionary array can be directly appended to the "features"
+ key of a base geoJSON dict in order to represent the network in the
+ geoJSON.
+
+ Args:
+ location: A ladybug Location object possessing longitude and latitude data.
+ point: A ladybug_geometry Point2D for where the location object exists
+ within the space of a scene. The coordinates of this point are
+ expected to be in the units of this Model. (Default: (0, 0)).
+ """
+ # get the conversion factors over to (longitude, latitude)
+ origin_lon_lat=origin_long_lat_from_location(location,point)
+ convert_facs=meters_to_long_lat_factors(origin_lon_lat)
+
+ # translate substation and transformers into the geoJSON features list
+ features_list=[self.substation.to_geojson_dict(origin_lon_lat,convert_facs)]
+ forroadinself.roads:
+ features_list.append(road.to_geojson_dict(origin_lon_lat,convert_facs))
+ returnfeatures_list
+
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+[docs]
+@lockable
+classPowerLine(object):
+"""Represents the properties of a power line in OpenDSS.
+
+ Args:
+ identifier: Text string for a unique wire property ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ wires: An array of Wire objects for the wires contained within the power line.
+ heights: An array of numbers that align with the wires and denote the height
+ of the wire above the ground in meters. Negative values indicate wires
+ below ground.
+ relative_xs: An array of numbers that align with the wires and denote the
+ X offset relative to the wire line geometry in meters. For convenience,
+ one of the conductors in a given wire is usually assigned the 0 position.
+ phases: An array of text values that align with the wires and denote the
+ phases of the wire. Must be one of the following values (A, B, C, N, S1, S2).
+ phase_count: An optional integer for the number of phases carried along the
+ power line. If None, it wil be inferred from the phases with only
+ phases A, B, C considered distinct from one another. (Default: None).
+ nominal_voltage: An optional number for the nominal voltage along the
+ power line. This is not required for OpenDSS simulation since this
+ value can be inferred from surrounding transformers and substations
+ but it it sometimes useful to assign a value directly to the
+ power line object. (Default: None).
+
+ Properties:
+ * identifier
+ * display_name
+ * wires
+ * heights
+ * relative_xs
+ * phases
+ * phase_count
+ * nominal_voltage
+ * wire_count
+ * wire_ids
+ """
+ __slots__=(
+ '_locked','_display_name','_identifier','_wire_count','_wires','_heights',
+ '_relative_xs','_phases','_phase_count','_nominal_voltage'
+ )
+ VALID_PHASES=('A','B','C','N','S1','S2')
+
+ def__init__(self,identifier,wires,heights,relative_xs,phases,
+ phase_count=None,nominal_voltage=None):
+"""Initialize PowerLine"""
+ self._locked=False# unlocked by default
+ self._display_name=None
+ self.identifier=identifier
+ self._wire_count=len(wires)
+ assertself._wire_count>0,'PowerLine must possess at least one wire.'
+ self.wires=wires
+ self.heights=heights
+ self.relative_xs=relative_xs
+ self.phases=phases
+ self.phase_count=phase_count
+ self.nominal_voltage=nominal_voltage
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a PowerLine object from a dictionary.
+
+ Args:
+ data: A dictionary representation of a PowerLine object in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'PowerLine',
+ 'identifier': '3P_OH_AL_ACSR_477kcmil_Hawk_12_47_0', # unique identifier
+ 'wires': [{}], # a list of wire definitions for the wires in the line
+ 'heights': [16], # height of the wire above the ground in meters
+ 'relative_x': [0], # number for the x offset from the wire line in meters
+ 'phases': ['A'] # text for the phases of the wire
+ }
+ """
+ wires=[Wire.from_dict(wd)forwdindata['wires']]
+ pc=data['phase_count']if'phase_count'indataelseNone
+ vol=data['nominal_voltage']if'nominal_voltage'indataelseNone
+ p_line=cls(data['identifier'],wires,data['heights'],
+ data['relative_xs'],data['phases'],pc,vol)
+ if'display_name'indataanddata['display_name']isnotNone:
+ p_line.display_name=data['display_name']
+ returnp_line
+
+
+
+[docs]
+ @classmethod
+ deffrom_dict_abridged(cls,data,wires):
+"""Create a PowerLine object from a dictionary.
+
+ Args:
+ data: A dictionary representation of a PowerLine object in the format below.
+ wires: A dictionary with identifiers of wires as keys and Python
+ wire objects as values.
+
+ .. code-block:: python
+
+ {
+ 'type': 'PowerLine',
+ 'identifier': '3P_OH_AL_ACSR_477kcmil_Hawk_12_47_0', # unique identifier
+ 'wires': [''], # a list of wire identifiers for the wires in the line
+ 'heights': [16], # height of the wire above the ground in meters
+ 'relative_x': [0], # number for the x offset from the wire line in meters
+ 'phases': ['A'] # text for the phases of the wire
+ }
+ """
+ try:
+ wires=[wires[wd]forwdindata['wires']]
+ exceptKeyErrorase:
+ raiseValueError('Failed to find {} in wires.'.format(e))
+ pc=data['phase_count']if'phase_count'indataelseNone
+ vol=data['nominal_voltage']if'nominal_voltage'indataelseNone
+ p_line=cls(data['identifier'],wires,data['heights'],
+ data['relative_xs'],data['phases'],pc,vol)
+ if'display_name'indataanddata['display_name']isnotNone:
+ p_line.display_name=data['display_name']
+ returnp_line
+
+
+
+[docs]
+ @classmethod
+ deffrom_electrical_database_dict(cls,data,wires):
+"""Create a PowerLine from an dictionary as it appears in a database.json.
+
+ Args:
+ data: A dictionary representation of a PowerLine object in the format below.
+ wires: A dictionary with identifiers of wires as keys and Python
+ wire objects as values.
+
+ .. code-block:: python
+
+ {
+ 'Name': '3P_OH_AL_ACSR_336kcmil_Merlin_12_47_0', # unique identifier
+ "Line geometry": [
+ {
+ "wire": "OH ACSR 336kcmil",
+ "phase": "A",
+ "x (m)": 0.0,
+ "height (m)": 10
+ },
+ {
+ "wire": "OH ACSR 336kcmil",
+ "phase": "B",
+ "x (m)": 0.304,
+ "height (m)": 10
+ }
+ ]
+ }
+ """
+ try:
+ wire_ids=[w_i['wire']forw_iindata['Line geometry']]
+ wire_objs=[wires[w_id]forw_idinwire_ids]
+ exceptKeyErrorase:
+ raiseValueError('Failed to find {} in wires.'.format(e))
+ heights=[w_i['height (m)']forw_iindata['Line geometry']]
+ rel_xs=[w_i['x (m)']forw_iindata['Line geometry']]
+ phases=[w_i['phase']forw_iindata['Line geometry']]
+ pc=data['Nphases']if'Nphases'indataelseNone
+ vol=data['Voltage(kV)']if'Voltage(kV)'indataelseNone
+ returncls(data['Name'],wire_objs,heights,rel_xs,phases,pc,vol)
+
+
+ @property
+ defidentifier(self):
+"""Get or set a text string for the unique object identifier."""
+ returnself._identifier
+
+ @identifier.setter
+ defidentifier(self,value):
+ self._identifier=valid_ep_string(value,'power line identifier')
+
+ @property
+ defdisplay_name(self):
+"""Get or set a string for the object name without any character restrictions.
+
+ If not set, this will be equal to the identifier.
+ """
+ ifself._display_nameisNone:
+ returnself._identifier
+ returnself._display_name
+
+ @display_name.setter
+ defdisplay_name(self,value):
+ try:
+ self._display_name=str(value)
+ exceptUnicodeEncodeError:# Python 2 machine lacking the character set
+ self._display_name=value# keep it as unicode
+
+ @property
+ defwires(self):
+"""Get or set an array of Wire objects for the phases of the wires."""
+ returnself._wires
+
+ @wires.setter
+ defwires(self,value):
+ forwinvalue:
+ assertisinstance(w,Wire),'Expected Wire object. Got {}.'.format(type(w))
+ self._wires=tuple(value)
+ assertlen(self._wires)==self._wire_count, \
+ 'Number of wires cannot be changed from {} to {}. Initialize a new ' \
+ 'PowerLine object to change the number of wires.'.format(
+ len(self._wires),self._wire_count)
+
+ @property
+ defheights(self):
+"""Get or set an array of numbers for the heights above the ground in meters."""
+ returnself._heights
+
+ @heights.setter
+ defheights(self,value):
+ self._heights=tuple(
+ float_in_range(h,input_name='power line height')forhinvalue)
+ assertlen(self._heights)==self._wire_count, \
+ 'Number of heights [{}] does not match the number of wires [{}].'.format(
+ len(self._heights),self._wire_count)
+
+ @property
+ defrelative_xs(self):
+"""Get or set a array of numbers for the X offset relative to the wire in meters.
+ """
+ returnself._relative_xs
+
+ @relative_xs.setter
+ defrelative_xs(self,value):
+ self._relative_xs=tuple(
+ float_in_range(x,input_name='power line relative_x')forxinvalue)
+ assertlen(self._relative_xs)==self._wire_count, \
+ 'Number of heights [{}] does not match the number of wires [{}].'.format(
+ len(self._relative_xs),self._wire_count)
+
+ @property
+ defphases(self):
+"""Get or set an array of text for the phases of the wires."""
+ returnself._phases
+
+ @phases.setter
+ defphases(self,value):
+ forpinvalue:
+ assertpinself.VALID_PHASES,'Phase "{}" is not acceptable. ' \
+ 'Choose from the following:\n{}'.format(p,'\n'.join(self.VALID_PHASES))
+ self._phases=tuple(value)
+ assertlen(self._phases)==self._wire_count, \
+ 'Number of heights [{}] does not match the number of wires [{}].'.format(
+ len(self._phases),self._wire_count)
+
+ @property
+ defphase_count(self):
+"""Get or set an integer for the number of phases carried along the line."""
+ ifself._phase_countisnotNone:
+ returnself._phase_count
+ all_phases=[pforpinself._phasesifpin('A','B','C')]
+ returnlen(all_phases)iflen(all_phases)!=0else1
+
+ @phase_count.setter
+ defphase_count(self,value):
+ ifvalueisnotNone:
+ value=int_positive(value,'power line phase count')
+ self._phase_count=value
+
+ @property
+ defnominal_voltage(self):
+"""Get or set a number for nominal voltage of the power line in kiloVolts."""
+ returnself._nominal_voltage
+
+ @nominal_voltage.setter
+ defnominal_voltage(self,value):
+ ifvalueisnotNone:
+ value=float_positive(value,'nominal voltage')
+ self._nominal_voltage=value
+
+ @property
+ defwire_count(self):
+"""Get an integer for the number of wires in the power line."""
+ returnself._wire_count
+
+ @property
+ defwire_ids(self):
+"""Get a list of wire identifiers in the power line."""
+ return[wire.identifierforwireinself._wires]
+
+
+[docs]
+ defto_dict(self,abridged=False):
+"""Get PowerLine dictionary.
+
+ Args:
+ abridged: Boolean to note whether the full dictionary describing the
+ object should be returned (False) or just an abridged version (True),
+ which only specifies the identifiers of wires. (Default: False).
+ """
+ base={'type':'PowerLine'}ifnotabridgedelse{'type':'PowerLineAbridged'}
+ base['identifier']=self.identifier
+ base['wires']=self.wire_idsifabridgedelse[w.to_dict()forwinself.wires]
+ base['heights']=self.heights
+ base['relative_xs']=self.relative_xs
+ base['phases']=self.phases
+ ifself._phase_countisnotNone:
+ base['phase_count']=self._phase_count
+ ifself._nominal_voltageisnotNone:
+ base['nominal_voltage']=self._nominal_voltage
+ ifself._display_nameisnotNone:
+ base['display_name']=self._display_name
+ returnbase
+
+
+
+[docs]
+ defto_electrical_database_dict(self):
+"""Get Wire as it should appear in the URBANopt database.json."""
+ base={'Name':self.identifier}
+ line_geo=[]
+ all_props=zip(self.wires,self.heights,self.relative_xs,self.phases)
+ forwire,hgt,r_x,phainall_props:
+ w_dict={
+ 'wire':wire.identifier,
+ 'phase':pha,
+ 'x (m)':r_x,
+ 'height (m)':hgt
+ }
+ line_geo.append(w_dict)
+ base['Line geometry']=line_geo
+ ifself._phase_countisnotNone:
+ base['Nphases']=self._phase_count
+ ifself._nominal_voltageisnotNone:
+ base['Voltage(kV)']=self._nominal_voltage
+ returnbase
+
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+"""Module for parsing OpenDSS results to data collections."""
+importos
+importdatetime
+
+fromladybug.datacollectionimportHourlyContinuousCollection
+fromladybug.headerimportHeader
+fromladybug.analysisperiodimportAnalysisPeriod
+fromladybug.datatype.genericimportGenericType
+fromladybug.datatype.fractionimportFraction
+fromladybug.futilimportcsv_to_matrix
+
+
+
+[docs]
+classOpenDSSResult(object):
+"""Object for parsing OpenDSS CSV result files into Ladybug DataCollections.
+
+ Args:
+ file_paths: A list of file paths to CSV files that were generated by OpenDSS.
+
+ Properties:
+ * file_paths
+ * factor_data
+ * condition_data
+ * peak_factors
+ * average_factors
+ """
+ # data types for the various outputs from OpenDSS
+ IS_OVERLOADED=GenericType(
+ 'Is Overloaded','condition',
+ unit_descr={1:'Overloaded',0:'Normal'})
+ VOLTAGE_CONDITION=GenericType(
+ 'Voltage Condition','condition',
+ unit_descr={-1:'Undervoltage',0:'Normal',1:'Overvoltage'})
+
+ def__init__(self,file_paths):
+"""Initialize OpenDSSResult"""
+ # check the file paths
+ forfpinfile_paths:
+ assertos.path.isfile(fp),'No file was found at {}'.format(fp)
+ assertfp.endswith('.csv'), \
+ '{} is not an SQL file ending in .sql or .db.'.format(fp)
+ self._file_paths=tuple(file_paths)
+
+ # parse the csv data
+ factors,condition=[],[]
+ forresult_fileinself._file_paths:
+ # parse the data and figure out the time series properties
+ data=csv_to_matrix(result_file)
+ data.pop(0)# remove the header from the CSV column
+ a_period=self._extract_analysis_period(data)
+
+ # figure out the type of object to write into the metadata
+ obj_name=os.path.basename(result_file).replace('.csv','')
+ ifobj_name.startswith('Line.'):
+ obj_name=obj_name.replace('Line.','')
+ obj_type='Electrical Connector Loading'
+ elifobj_name.startswith('Transformer.'):
+ obj_name=obj_name.replace('Transformer.','')
+ obj_type='Transformer Loading'
+ else:
+ obj_type='Building Voltage'
+ metadata={'type':obj_type,'name':obj_name}
+
+ # output the data collection of factors
+ result_vals=[float(data[i][1])foriinrange(len(data))]
+ header=Header(Fraction('Loading Factor'),'fraction',a_period,metadata)
+ factors.append(HourlyContinuousCollection(header,result_vals))
+
+ # output the data collection of conditions
+ iflen(data[0])==4:# building voltage results
+ cond_vals=[]
+ forrowindata:
+ cond=0ifrow[2]=='False'else1
+ ifcond!=1androw[3]=='True\n':
+ cond=-1
+ cond_vals.append(cond)
+ header=Header(
+ self.VOLTAGE_CONDITION,self.VOLTAGE_CONDITION.units[0],
+ a_period,metadata)
+ condition.append(HourlyContinuousCollection(header,cond_vals))
+ else:# transformer or connector load
+ cond_vals=[]
+ forrowindata:
+ cond=0ifrow[2]=='False\n'else1
+ cond_vals.append(cond)
+ header=Header(
+ self.IS_OVERLOADED,self.IS_OVERLOADED.units[0],
+ a_period,metadata)
+ condition.append(HourlyContinuousCollection(header,cond_vals))
+ self._factor_data=tuple(factors)
+ self._condition_data=tuple(condition)
+
+ @property
+ deffile_paths(self):
+"""Get a tuple of file paths to CSV files."""
+ returnself._file_paths
+
+ @property
+ deffactor_data(self):
+"""Get a tuple of loading factors associated with the input file paths."""
+ returnself._factor_data
+
+ @property
+ defcondition_data(self):
+"""Get a tuple of conditions associated with the input file paths."""
+ returnself._condition_data
+
+ @property
+ defpeak_factors(self):
+"""Get a list of numbers for the peak factors across the data."""
+ return[dat.maxfordatinself._factor_data]
+
+ @property
+ defaverage_factors(self):
+"""Get a list of numbers for the average factors across the data."""
+ return[dat.averagefordatinself._factor_data]
+
+ @staticmethod
+ def_date_str_to_datetime(date_str):
+"""Get a datetime object from a string."""
+ returndatetime.datetime.strptime(date_str,'%Y/%m/%d %H:%M:%S')
+
+ @staticmethod
+ def_extract_analysis_period(data):
+"""Extract an AnalysisPeriod from CSV data."""
+ dts=[OpenDSSResult._date_str_to_datetime(data[i][0])foriin(0,1,-2)]
+ timestep=int(3600/(dts[1]-dts[0]).total_seconds())
+ leap_year=Trueifdts[0].year%4==0elseFalse
+ a_period=AnalysisPeriod(
+ dts[0].month,dts[0].day,0,dts[-1].month,dts[-1].day,23,
+ timestep=timestep,is_leap_year=leap_year)
+ returna_period
+
+
+# coding=utf-8
+"""Road along which RNM will place electrical connectors."""
+from__future__importdivision
+
+fromladybug_geometry.geometry2d.lineimportLineSegment2D
+fromladybug_geometry.geometry2d.polylineimportPolyline2D
+fromdragonfly.projectionimportpolygon_to_lon_lat
+
+from.._baseimport_GeometryBase
+
+
+
+[docs]
+classRoad(_GeometryBase):
+"""Represents a road along which RNM will place electrical connectors.
+
+ Args:
+ identifier: Text string for a unique road ID. Must contain only characters
+ that are acceptable in RNM and OpenDSS. This will be used to
+ identify the object across the exported geoJSON, RNM and OpenDSS files.
+ geometry: A LineSegment2D or Polyline2D representing the geometry of the road.
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ """
+ __slots__=()
+
+ def__init__(self,identifier,geometry):
+"""Initialize Road."""
+ _GeometryBase.__init__(self,identifier)# process the identifier
+ assertisinstance(geometry,(LineSegment2D,Polyline2D)),'Expected ' \
+ 'ladybug_geometry LineSegment2D or Polyline2D. Got {}'.format(type(geometry))
+ self._geometry=geometry
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize a Road from a dictionary.
+
+ Args:
+ data: A dictionary representation of a Road object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='Road','Expected Road ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ geo=LineSegment2D.from_dict(data['geometry']) \
+ ifdata['geometry']['type']=='LineSegment2D' \
+ elsePolyline2D.from_dict(data['geometry'])
+ road=cls(data['identifier'],geo)
+ if'display_name'indataanddata['display_name']isnotNone:
+ road.display_name=data['display_name']
+ returnroad
+
+
+ @property
+ defgeometry(self):
+"""Get a LineSegment2D or Polyline2D representing the road geometry."""
+ returnself._geometry
+
+
+[docs]
+ defto_geojson_dict(self,origin_lon_lat,conversion_factors):
+"""Get Road dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ ifisinstance(self.geometry,LineSegment2D):
+ pts=[(pt.x,pt.y)forptin(self.geometry.p1,self.geometry.p2)]
+ else:# it's a polyline
+ pts=[(pt.x,pt.y)forptinself.geometry.vertices]
+ coords=polygon_to_lon_lat(pts,origin_lon_lat,conversion_factors)
+ return{
+ 'type':'Feature',
+ 'properties':{
+ 'id':self.identifier,
+ 'type':'Road',
+ 'total_length':round(self.geometry.length,1),
+ 'name':self.display_name
+ },
+ 'geometry':{
+ 'type':'LineString',
+ 'coordinates':coords
+ }
+ }
+[docs]
+classSubstation(_GeometryBase):
+"""Represents a substation in OpenDSS.
+
+ Args:
+ identifier: Text string for a unique electrical substation ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ geometry: A Polygon2D representing the geometry of the electrical substation.
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ """
+ __slots__=()
+
+ def__init__(self,identifier,geometry):
+"""Initialize Substation."""
+ _GeometryBase.__init__(self,identifier)# process the identifier
+ assertisinstance(geometry,Polygon2D),'Expected ladybug_geometry ' \
+ 'Polygon2D for Substation geometry. Got {}'.format(type(geometry))
+ self._geometry=geometry
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize a Substation from a dictionary.
+
+ Args:
+ data: A dictionary representation of an Substation object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='Substation','Expected Substation ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ geo=Polygon2D.from_dict(data['geometry'])
+ trans=cls(data['identifier'],geo)
+ if'display_name'indataanddata['display_name']isnotNone:
+ trans.display_name=data['display_name']
+ returntrans
+
+
+
+[docs]
+ @classmethod
+ deffrom_rnm_geojson_dict(
+ cls,data,origin_lon_lat,conversion_factors):
+"""Get a Substation from a dictionary as it appears in an RNM GeoJSON.
+
+ Args:
+ data: A GeoJSON dictionary representation of an Substation feature.
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ geo=cls._geojson_coordinates_to_polygon2d(
+ data['geometry']['coordinates'],origin_lon_lat,conversion_factors)
+ returncls(data['properties']['Code'],geo)
+
+
+ @property
+ defgeometry(self):
+"""Get a Polygon2D representing the substation."""
+ returnself._geometry
+
+
+[docs]
+ defto_geojson_dict(self,origin_lon_lat,conversion_factors):
+"""Get Substation dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ pts=[(pt.x,pt.y)forptinself.geometry.vertices]
+ coords=[polygon_to_lon_lat(pts,origin_lon_lat,conversion_factors)]
+ coords[0].append(coords[0][0])
+ return{
+ 'type':'Feature',
+ 'properties':{
+ 'id':self.identifier,
+ 'geometryType':'Rectangle',
+ 'name':self.display_name,
+ 'type':'District System',
+ 'footprint_area':round(self.geometry.area,1),
+ 'footprint_perimeter':round(self.geometry.perimeter,1),
+ 'district_system_type':'Electrical Substation',
+ },
+ 'geometry':{
+ 'type':'Polygon',
+ 'coordinates':coords
+ }
+ }
+[docs]
+classTransformer(_GeometryBase):
+"""Represents a transformer in OpenDSS.
+
+ Args:
+ identifier: Text string for a unique electrical transformer ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ geometry: A Polygon2D representing the geometry of the electrical transformer.
+ properties: A TransformerProperties object representing the properties of
+ the electrical transformer.
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ * properties
+ * phase_count
+ * nominal_voltage
+ """
+ __slots__=('_properties',)
+
+ def__init__(self,identifier,geometry,properties):
+"""Initialize Transformer."""
+ _GeometryBase.__init__(self,identifier)# process the identifier
+ assertisinstance(geometry,Polygon2D),'Expected ladybug_geometry ' \
+ 'Polygon2D for Transformer geometry. Got {}'.format(type(geometry))
+ self._geometry=geometry
+ self.properties=properties
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize an Transformer from a dictionary.
+
+ Args:
+ data: A dictionary representation of an Transformer object.
+ """
+ assertdata['type']=='Transformer','Expected Transformer ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ props=TransformerProperties.from_dict(data['properties'])
+ geo=Polygon2D.from_dict(data['geometry'])
+ trans=cls(data['identifier'],geo,props)
+ if'display_name'indataanddata['display_name']isnotNone:
+ trans.display_name=data['display_name']
+ returntrans
+
+
+
+[docs]
+ @classmethod
+ deffrom_dict_abridged(cls,data,properties):
+"""Initialize a Transformer from an abridged dictionary.
+
+ Args:
+ data: A TransformerAbridged dictionary.
+ properties: A dictionary with identifiers of TransformerProperties
+ as keys and Python TransformerProperties objects as values.
+ """
+ assertdata['type']=='TransformerAbridged', \
+ 'Expected TransformerAbridged. Got {}.'.format(data['type'])
+ try:
+ props=properties[data['properties']]
+ exceptKeyErrorase:
+ raiseValueError('Failed to find "{}" in properties.'.format(e))
+ geo=Polygon2D.from_dict(data['geometry'])
+ trans=cls(data['identifier'],geo,props)
+ if'display_name'indataanddata['display_name']isnotNone:
+ trans.display_name=data['display_name']
+ returntrans
+
+
+
+[docs]
+ @classmethod
+ deffrom_rnm_geojson_dict(
+ cls,data,origin_lon_lat,conversion_factors):
+"""Get a Transformer from a dictionary as it appears in an RNM GeoJSON.
+
+ Args:
+ data: A GeoJSON dictionary representation of an Transformer feature.
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ geo=cls._geojson_coordinates_to_polygon2d(
+ data['geometry']['coordinates'],origin_lon_lat,conversion_factors)
+ prop=data['properties']
+ kva_rating=100if'Snom'notinpropelseprop['Snom']
+ resis=0.1if'LV_R(ohm)'notinpropelseprop['LV_R(ohm)']
+ t_props=TransformerProperties(
+ prop['Code'],kva_rating,resistance=resis,
+ reactance=prop['Xsc(pu)'],phase_count=prop['Phases'],
+ high_voltage=prop['Vnom1'],low_voltage=prop['Vnom2'])
+ returncls(prop['Code'],geo,t_props)
+
+
+ @property
+ defgeometry(self):
+"""Get a Polygon2D representing the transformer."""
+ returnself._geometry
+
+ @property
+ defproperties(self):
+"""Get or set a TransformerProperties object for the transformer."""
+ returnself._properties
+
+ @properties.setter
+ defproperties(self,value):
+ assertisinstance(value,TransformerProperties), \
+ 'Expected TransformerProperties object' \
+ ' for transformer properties. Got {}.'.format(type(value))
+ value.lock()
+ self._properties=value
+
+ @property
+ defphase_count(self):
+"""Get an integer for the number of phases this transformer supports."""
+ returnself._properties.phase_count
+
+ @property
+ defnominal_voltage(self):
+"""Get an integer for the higher voltage of this transformer."""
+ returnself._properties.high_voltage
+
+
+[docs]
+ defto_dict(self,abridged=False):
+"""Transformer dictionary representation.
+
+ Args:
+ abridged: Boolean to note whether the full dictionary describing the
+ object should be returned (False) or just an abridged version (True),
+ which only specifies the identifiers of properties. (Default: False).
+ """
+ base={'type':'Transformer'}ifnot \
+ abridgedelse{'type':'TransformerAbridged'}
+ base['identifier']=self.identifier
+ base['geometry']=self.geometry.to_dict()
+ base['properties']=self.properties.to_dict()ifnotabridged \
+ elseself.properties.identifier
+ ifself._display_nameisnotNone:
+ base['display_name']=self.display_name
+ returnbase
+
+
+
+[docs]
+ defto_geojson_dict(self,origin_lon_lat,conversion_factors):
+"""Get Transformer dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ origin_lon_lat: An array of two numbers in degrees. The first value
+ represents the longitude of the scene origin in degrees (between -180
+ and +180). The second value represents latitude of the scene origin
+ in degrees (between -90 and +90). Note that the "scene origin" is the
+ (0, 0) coordinate in the 2D space of the input polygon.
+ conversion_factors: A tuple with two values used to translate between
+ meters and longitude, latitude.
+ """
+ pts=[(pt.x,pt.y)forptinself.geometry.vertices]
+ coords=[polygon_to_lon_lat(pts,origin_lon_lat,conversion_factors)]
+ coords[0].append(coords[0][0])
+ base={
+ 'type':'Feature',
+ 'properties':{
+ 'id':self.identifier,
+ 'geometryType':'Rectangle',
+ 'name':self.display_name,
+ 'type':'District System',
+ 'footprint_area':round(self.geometry.area,1),
+ 'footprint_perimeter':round(self.geometry.perimeter,1),
+ 'district_system_type':'Transformer',
+ 'electrical_catalog_name':self.properties.identifier
+ },
+ 'geometry':{
+ 'type':'Polygon',
+ 'coordinates':coords
+ }
+ }
+ ifself.properties.phase_count==3:
+ base['properties']['phases']=['A','B','C']
+ elifself.properties.phase_count==1:
+ base['properties']['phases']=['A']
+ returnbase
+[docs]
+@lockable
+classTransformerProperties(object):
+"""Represents the properties of a Transformer in OpenDSS.
+
+ Args:
+ identifier: Text string for a unique wire property ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ kva: Base kVA rating of the transformer in kiloVolt-Amps.
+ resistance: A number for the electrical resistance of the transformer
+ in ohms. (Default: 0.1).
+ reactance: A number for the electrical reactance of the transformer
+ in per-unit values (p.u. transf). (Default: 0.1).
+ phase_count: An integer for the number of phases in the transformer. Typically,
+ this is either 1 or 3. (Default: 3).
+ high_voltage: A number for the high voltage of the transformer in
+ kiloVolts. (Default: 13.2).
+ low_voltage: A number for the low voltage of the transformer in
+ kiloVolts. (Default: 0.48).
+ is_center_tap: Boolean for whether the transformer is center-tapped
+ (True) or not (False). (Default: False).
+ connection: Text for the type of internal connection in the transformer, either
+ "Wye-Wye", "Wye-Delta", "Delta-Wye" or "Delta-Delta". (Default: "Wye-Wye").
+
+ Properties:
+ * identifier
+ * display_name
+ * kva
+ * resistance
+ * reactance
+ * phase_count
+ * high_voltage
+ * low_voltage
+ * is_center_tap
+ * connection
+ """
+ __slots__=(
+ '_locked','_display_name','_identifier','_kva','_resistance','_reactance',
+ '_phase_count','_high_voltage','_low_voltage','_is_center_tap','_connection')
+
+ VALID_CONNECTIONS=('Wye-Wye','Wye-Delta','Delta-Wye','Delta-Delta')
+
+ def__init__(self,identifier,kva,resistance=0.1,reactance=0.1,
+ phase_count=3,high_voltage=13.2,low_voltage=0.48,
+ is_center_tap=False,connection='Wye-Wye'):
+"""Initialize TransformerProperties"""
+ self._locked=False# unlocked by default
+ self._display_name=None
+ self.identifier=identifier
+ self.kva=kva
+ self.resistance=resistance
+ self.reactance=reactance
+ self.phase_count=phase_count
+ self.high_voltage=high_voltage
+ self.low_voltage=low_voltage
+ self.is_center_tap=is_center_tap
+ self.connection=connection
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a TransformerProperties object from a dictionary.
+
+ Args:
+ data: A dictionary representation of a TransformerProperties object
+ in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'TransformerProperties',
+ 'identifier': 'Transformer--50KVA PM', # unique identifier
+ 'kva': 50, # kVA rating of the transformer
+ 'resistance': 0.1, # transformer resistance in ohms
+ 'reactance': 0.1, # transformer reactance in ohms
+ 'phase_count': 3, # number of transformer phases
+ 'high_voltage': 13.2, # transformer high voltage in kV
+ 'low_voltage': 0.48, # transformer low voltage in kV
+ 'is_center_tap': False, # boolean for if the transformer is center-tapped
+ 'connection': 'Wye-Wye' # text for the type of connection
+ }
+ """
+ resistance=data['resistance']if'resistance'indataelse0.1
+ reactance=data['reactance']if'reactance'indataelse0.1
+ phases=data['phase_count']if'phase_count'indataelse3
+ hv=data['high_voltage']if'high_voltage'indataelse13.2
+ lv=data['low_voltage']if'low_voltage'indataelse0.48
+ icp=data['is_center_tap']if'is_center_tap'indataelseFalse
+ con=data['connection']if'connection'indataelse'Wye-Wye'
+ wire=cls(data['identifier'],data['kva'],resistance,reactance,
+ phases,hv,lv,icp,con)
+ if'display_name'indataanddata['display_name']isnotNone:
+ wire.display_name=data['display_name']
+ returnwire
+
+
+
+[docs]
+ @classmethod
+ deffrom_electrical_database_dict(cls,data):
+"""Create from a dictionary as it appears in electrical_database.json.
+
+ Args:
+ data: A dictionary representation of an TransformerProperties object
+ in the format below.
+
+ .. code-block:: python
+
+ {
+ 'Name': 'MAT_1I_230_69', # unique identifier
+ 'Installed Power(kVA)': 50, # kVA rating of the transformer
+ 'Low-voltage-side short-circuit resistance (ohms)': 0.1, # resistance (ohms)
+ 'Reactance (p.u. transf)': 0.1, # transformer reactance in ohms
+ 'Nphases': 3, # number of transformer phases
+ 'Primary Voltage (kV)': 13.2, # transformer high voltage in kV
+ 'Secondary Voltage (kV)': 0.48, # transformer low voltage in kV
+ 'Centertap': False, # boolean for if the transformer is center-tapped
+ 'connection': 'Wye-Wye' # text for the type of connection
+ }
+ """
+ returncls(
+ data['Name'],data['Installed Power(kVA)'],
+ data['Low-voltage-side short-circuit resistance (ohms)'],
+ data['Reactance (p.u. transf)'],data['Nphases'],
+ data['Primary Voltage (kV)'],data['Secondary Voltage (kV)'],
+ data['Centertap'],data['connection'])
+
+
+ @property
+ defidentifier(self):
+"""Get or set a text string for the unique object identifier."""
+ returnself._identifier
+
+ @identifier.setter
+ defidentifier(self,value):
+ self._identifier=valid_ep_string(value,'transformer properties identifier')
+
+ @property
+ defdisplay_name(self):
+"""Get or set a string for the object name without any character restrictions.
+
+ If not set, this will be equal to the identifier.
+ """
+ ifself._display_nameisNone:
+ returnself._identifier
+ returnself._display_name
+
+ @display_name.setter
+ defdisplay_name(self,value):
+ try:
+ self._display_name=str(value)
+ exceptUnicodeEncodeError:# Python 2 machine lacking the character set
+ self._display_name=value# keep it as unicode
+
+ @property
+ defkva(self):
+"""Get or set a number for the base kVA rating of the transformer in kVA."""
+ returnself._kva
+
+ @kva.setter
+ defkva(self,value):
+ self._kva=float_positive(value,input_name='kva')
+
+ @property
+ defresistance(self):
+"""Get or set a number for the resistance of the transformer in ohms."""
+ returnself._resistance
+
+ @resistance.setter
+ defresistance(self,value):
+ self._resistance=float_positive(value,'resistance')
+
+ @property
+ defreactance(self):
+"""Get or set a number for the reactance of the transformer in p.u. transf."""
+ returnself._reactance
+
+ @reactance.setter
+ defreactance(self,value):
+ self._reactance=float_positive(value,'reactance')
+
+ @property
+ defphase_count(self):
+"""Get or set an integer for the number of phases of the transformer."""
+ returnself._phase_count
+
+ @phase_count.setter
+ defphase_count(self,value):
+ self._phase_count=int_in_range(value,1,3,'transformer phase count')
+
+ @property
+ defhigh_voltage(self):
+"""Get or set a number for the high voltage of the transformer in kiloVolts."""
+ returnself._high_voltage
+
+ @high_voltage.setter
+ defhigh_voltage(self,value):
+ self._high_voltage=float_positive(value,'high voltage')
+
+ @property
+ deflow_voltage(self):
+"""Get or set a number for the low voltage of the transformer in kiloVolts."""
+ returnself._low_voltage
+
+ @low_voltage.setter
+ deflow_voltage(self,value):
+ self._low_voltage=float_positive(value,'low voltage')
+
+ @property
+ defis_center_tap(self):
+"""Get or set a boolean for whether the transformer is center-tapped."""
+ returnself._is_center_tap
+
+ @is_center_tap.setter
+ defis_center_tap(self,value):
+ self._is_center_tap=bool(value)
+
+ @property
+ defconnection(self):
+"""Get or set text for the type of internal connection in the transformer."""
+ returnself._connection
+
+ @connection.setter
+ defconnection(self,value):
+ assertvalueinself.VALID_CONNECTIONS,'Phase "{}" is not acceptable. ' \
+ 'Choose from the following:\n{}'.format(
+ value,'\n'.join(self.VALID_CONNECTIONS))
+ self._connection=value
+
+
+[docs]
+@lockable
+classWire(object):
+"""Represents the properties of a wire in OpenDSS.
+
+ Args:
+ identifier: Text string for a unique wire property ID. Must contain only
+ characters that are acceptable in OpenDSS. This will be used to
+ identify the object across the exported geoJSON and OpenDSS files.
+ ampacity: A number for the ampacity of the wire in amps. (Default: 220).
+ geometrical_mean_radius: A number for the geometric mean of distances between
+ the strands of the conductor in millimeters. (Default: 3.9).
+ resistance: A number for the electrical resistance of the conductor in
+ ohms per kilometer of wire. (Default: 0.3937).
+ diameter: A number for the diameter of the wire in millimeters. (Default: 10).
+ voltage_level: Text to denote the level of voltage that the wire is designed to
+ carry. Choose from ("LV", "MV", "LV or MV"). (Default: "MV").
+ wire_type: Text for the type of wire, denoting whether the wire is overhead
+ (OH) or underground (UG). Choose from ('OH', 'UG', 'UG concentric
+ neutral'). (Default: "OH").
+ concentric_properties: A ConcentricProperties object to denote the concentric
+ neutral properties of the Wire. This must be specified when the wire_type
+ is "UG concentric neutral." (Default: None).
+
+ Properties:
+ * identifier
+ * display_name
+ * ampacity
+ * geometrical_mean_radius
+ * resistance
+ * diameter
+ * voltage_level
+ * wire_type
+ * concentric_properties
+ """
+ __slots__=(
+ '_locked','_display_name','_identifier','_ampacity',
+ '_geometrical_mean_radius','_resistance','_diameter',
+ '_voltage_level','_wire_type','_concentric_properties'
+ )
+
+ VALID_VOLTAGE_LEVELS=('LV','MV','LV or MV')
+ VALID_WIRE_TYPES=('OH','UG','UG concentric neutral')
+
+ def__init__(self,identifier,ampacity=220,geometrical_mean_radius=3.9,
+ resistance=0.3937,diameter=10,voltage_level='MV',
+ wire_type='OH',concentric_properties=None):
+"""Initialize Wire"""
+ self._locked=False# unlocked by default
+ self._display_name=None
+ self.identifier=identifier
+ self.ampacity=ampacity
+ self.geometrical_mean_radius=geometrical_mean_radius
+ self.resistance=resistance
+ self.diameter=diameter
+ self.voltage_level=voltage_level
+ self.concentric_properties=concentric_properties
+ self.wire_type=wire_type
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a Wire object from a dictionary.
+
+ Args:
+ data: A dictionary representation of a Wire object in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'Wire',
+ 'identifier': 'OH AL 2/0 A', # unique wire property identifier
+ 'ampacity': 220, # ampacity of the wire in amps
+ 'geometrical_mean_radius': 3.9, # gmr in mm
+ 'resistance': 0.3937, # resistance of the wire in ohms/km
+ 'diameter': 10, # diameter of the wire in mm
+ 'voltage_level': 'LV or MV', # text for the voltage level
+ 'wire_type': 'OH' # text for the type of wire
+ }
+ """
+ amp=data['ampacity']if'ampacity'indataelse220
+ gmr=data['geometrical_mean_radius']if'geometrical_mean_radius'indata \
+ else3.9
+ res=data['resistance']if'resistance'indataelse0.3937
+ dim=data['diameter']if'diameter'indataelse10
+ vl=data['voltage_level']if'voltage_level'indataelse'MV'
+ wt=data['wire_type']if'wire_type'indataelse'OH'
+ c_prop=ConcentricProperties.from_dict(data['concentric_properties']) \
+ if'concentric_properties'indataand \
+ data['concentric_properties']isnotNoneelseNone
+ wire=cls(data['identifier'],amp,gmr,res,dim,vl,wt,c_prop)
+ if'display_name'indataanddata['display_name']isnotNone:
+ wire.display_name=data['display_name']
+ returnwire
+
+
+
+[docs]
+ @classmethod
+ deffrom_electrical_database_dict(cls,data):
+"""Create a Wire from an dictionary as it appears in electrical_database.json.
+
+ Args:
+ data: A dictionary representation of a Wire object in the format below.
+
+ .. code-block:: python
+
+ {
+ 'nameclass': 'OH AL 2/0 A', # unique wire property identifier
+ 'ampacity (A)': 220, # ampacity of the wire in amps
+ 'gmr (mm)': 3.9, # gmr in meters
+ 'resistance (ohm/km)': 0.3937, # resistance of the wire in ohms/km
+ 'diameter (mm)': 10, # diameter of the wire in meters
+ 'voltage level': 'MV',
+ 'type': 'OH'
+ }
+ """
+ c_prop=None
+ ifdata['type']=='UG concentric neutral':
+ c_prop=ConcentricProperties(
+ data['gmr neutral (mm)'],
+ data['resistance neutral (ohm/km)'],
+ data['concentric diameter neutral strand (mm)'],
+ data['concentric neutral outside diameter (mm)'],
+ data['# concentric neutral strands']
+ )
+ returncls(
+ data['nameclass'],data['ampacity (A)'],data['gmr (mm)'],
+ data['resistance (ohm/km)'],data['diameter (mm)'],
+ data['voltage level'],data['type'],c_prop)
+
+
+ @property
+ defidentifier(self):
+"""Get or set a text string for the unique object identifier."""
+ returnself._identifier
+
+ @identifier.setter
+ defidentifier(self,value):
+ self._identifier=valid_ep_string(value,'wire identifier')
+
+ @property
+ defdisplay_name(self):
+"""Get or set a string for the object name without any character restrictions.
+
+ If not set, this will be equal to the identifier.
+ """
+ ifself._display_nameisNone:
+ returnself._identifier
+ returnself._display_name
+
+ @display_name.setter
+ defdisplay_name(self,value):
+ try:
+ self._display_name=str(value)
+ exceptUnicodeEncodeError:# Python 2 machine lacking the character set
+ self._display_name=value# keep it as unicode
+
+ @property
+ defampacity(self):
+"""Get or set a number for the ampacity of the wire in amps."""
+ returnself._ampacity
+
+ @ampacity.setter
+ defampacity(self,value):
+ self._ampacity=float_positive(value,'ampacity')
+
+ @property
+ defgeometrical_mean_radius(self):
+"""Get or set a number for the geometrical mean radius of the wire in mm."""
+ returnself._geometrical_mean_radius
+
+ @geometrical_mean_radius.setter
+ defgeometrical_mean_radius(self,value):
+ self._geometrical_mean_radius=float_positive(value,'geometrical_mean_radius')
+
+ @property
+ defresistance(self):
+"""Get or set a number for the resistance of the wire in ohms per km of wire.
+ """
+ returnself._resistance
+
+ @resistance.setter
+ defresistance(self,value):
+ self._resistance=float_positive(value,'resistance')
+
+ @property
+ defdiameter(self):
+"""Get or set a number for the diameter of the wire in mm."""
+ returnself._diameter
+
+ @diameter.setter
+ defdiameter(self,value):
+ self._diameter=float_positive(value,'diameter')
+
+ @property
+ defvoltage_level(self):
+"""Get or set text for the voltage level of the wire. (LV, MV, LV or MV)."""
+ returnself._voltage_level
+
+ @voltage_level.setter
+ defvoltage_level(self,value):
+ assertvalueinself.VALID_VOLTAGE_LEVELS,'Voltage level "{}" is not ' \
+ 'acceptable. Choose from:\n{}'.format(value,'\n'.join(self.VALID_PHASES))
+ self._voltage_level=value
+
+ @property
+ defwire_type(self):
+"""Get or set a text string for the type of wire."""
+ returnself._wire_type
+
+ @wire_type.setter
+ defwire_type(self,value):
+ assertvalueinself.VALID_WIRE_TYPES,'Wire type "{}" is not acceptable. ' \
+ 'Choose from:\n{}'.format(value,'\n'.join(self.VALID_WIRE_TYPES))
+ ifvalue=='UG concentric neutral':
+ assertself.concentric_propertiesisnotNone,'Wire concentric_properties' \
+ ' must be specified in order to use "UG concentric neutral."'
+ self._wire_type=value
+
+ @property
+ defconcentric_properties(self):
+"""Get or set an array of Wire objects for the phases of the wires."""
+ returnself._concentric_properties
+
+ @concentric_properties.setter
+ defconcentric_properties(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,ConcentricProperties), \
+ 'Expected Wire ConcentricProperties. Got {}.'.format(type(value))
+ self._concentric_properties=value
+
+
+[docs]
+@lockable
+classConcentricProperties(object):
+"""Represents the concentric neutral properties of a wire in OpenDSS.
+
+ Args:
+ geometrical_mean_radius: A number for the geometric mean of distances between
+ the neutral strands in millimeters. (Default: 0.8).
+ resistance: A number for the electrical resistance of the neutral strands in
+ ohms per kilometer of wire. (Default: 5.8).
+ concentric_strand_diameter: A number for the diameter of the neutral strand
+ in millimeters. (Default: 2).
+ concentric_outside_diameter:A number for the outside diameter of the neutral
+ strand in millimeters. (Default: 45).
+ strand_count: A positive integer for the number of concentric neutral
+ strands. (Default: 24)
+
+ Properties:
+ * geometrical_mean_radius
+ * resistance
+ * concentric_strand_diameter
+ * concentric_outside_diameter
+ * strand_count
+ """
+ __slots__=(
+ '_locked','_geometrical_mean_radius','_resistance',
+ '_concentric_strand_diameter','_concentric_outside_diameter','_strand_count'
+ )
+
+ def__init__(
+ self,geometrical_mean_radius=0.8,resistance=5.8,
+ concentric_strand_diameter=2,concentric_outside_diameter=45,
+ strand_count=24):
+"""Initialize ConcentricProperties"""
+ self._locked=False# unlocked by default
+ self.geometrical_mean_radius=geometrical_mean_radius
+ self.resistance=resistance
+ self.concentric_strand_diameter=concentric_strand_diameter
+ self.concentric_outside_diameter=concentric_outside_diameter
+ self.strand_count=strand_count
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Create a ConcentricProperties object from a dictionary.
+
+ Args:
+ data: A dictionary representation of a ConcentricProperties object
+ in the format below.
+
+ .. code-block:: python
+
+ {
+ 'type': 'ConcentricProperties',
+ 'geometrical_mean_radius': 0.8, # gmr in mm
+ 'resistance': 5.8, # resistance of the wire in ohms/km
+ 'concentric_strand_diameter': 2, # diameter of the wire in mm
+ 'concentric_outside_diameter': 45, # outside diameter of the wire in mm
+ 'strand_count': 24 # integer for the number of strands
+ }
+ """
+ gmr=data['geometrical_mean_radius']if'geometrical_mean_radius'indata \
+ else0.8
+ res=data['resistance']if'resistance'indataelse5.8
+ s_dim=data['concentric_strand_diameter']if'concentric_strand_diameter' \
+ indataelse2
+ o_dim=data['concentric_outside_diameter']if'concentric_outside_diameter' \
+ indataelse45
+ sc=data['strand_count']if'strand_count'indataelse24
+ returncls(gmr,res,s_dim,o_dim,sc)
+
+
+ @property
+ defgeometrical_mean_radius(self):
+"""Get or set a number for the geometrical mean radius of the strands in mm."""
+ returnself._geometrical_mean_radius
+
+ @geometrical_mean_radius.setter
+ defgeometrical_mean_radius(self,value):
+ self._geometrical_mean_radius=float_positive(value,'geometrical_mean_radius')
+
+ @property
+ defresistance(self):
+"""Get or set a number for the resistance of the strands in ohms per km of wire.
+ """
+ returnself._resistance
+
+ @resistance.setter
+ defresistance(self,value):
+ self._resistance=float_positive(value,'resistance')
+
+ @property
+ defconcentric_strand_diameter(self):
+"""Get or set a number for the diameter of the neutral strand in mm."""
+ returnself._concentric_strand_diameter
+
+ @concentric_strand_diameter.setter
+ defconcentric_strand_diameter(self,value):
+ self._concentric_strand_diameter= \
+ float_positive(value,'concentric_strand_diameter')
+
+ @property
+ defconcentric_outside_diameter(self):
+"""Get or set a number for the outside diameter of the neutral strand in mm."""
+ returnself._concentric_outside_diameter
+
+ @concentric_outside_diameter.setter
+ defconcentric_outside_diameter(self,value):
+ self._concentric_outside_diameter= \
+ float_positive(value,'concentric_outside_diameter')
+
+ @property
+ defstrand_count(self):
+"""Get or set a positive integer for the number of concentric neutral strands.
+ """
+ returnself._strand_count
+
+ @strand_count.setter
+ defstrand_count(self,value):
+ self._strand_count=int_positive(value,'strand_count')
+
+
+[docs]
+classBuildingEnergyProperties(object):
+"""Energy Properties for Dragonfly Building.
+
+ Args:
+ host: A dragonfly_core Building object that hosts these properties.
+ construction_set: A honeybee ConstructionSet object to specify all
+ default constructions for the Faces of the Building. If None, the
+ Building will use the honeybee default construction set, which is not
+ representative of a particular building code or climate zone.
+ Default: None.
+
+ Properties:
+ * host
+ * construction_set
+ """
+ _HVAC_REGISTRY=None
+ _HVAC_TYPES_DICT=HVAC_TYPES_DICT
+ _VINTAGE_MAP={
+ 'DOE Ref Pre-1980':('pre_1980','DOE_Ref_Pre_1980'),
+ 'DOE Ref 1980-2004':('1980_2004','DOE_Ref_1980_2004'),
+ '90.1-2004':('2004','ASHRAE_2004'),
+ '90.1-2007':('2007','ASHRAE_2007'),
+ '90.1-2010':('2010','ASHRAE_2010'),
+ '90.1-2013':('2013','ASHRAE_2013'),
+ '90.1-2016':('2016','ASHRAE_2016'),
+ '90.1-2019':('2019','ASHRAE_2019')
+ }
+ __slots__=('_host','_construction_set')
+
+ def__init__(self,host,construction_set=None):
+"""Initialize Building energy properties."""
+ self._host=host
+ self.construction_set=construction_set
+
+ @property
+ defhost(self):
+"""Get the Building object hosting these properties."""
+ returnself._host
+
+ @property
+ defconstruction_set(self):
+"""Get or set the Building ConstructionSet object.
+
+ If not set, it will be the Honeybee default generic ConstructionSet.
+ """
+ ifself._construction_setisnotNone:# set by the user
+ returnself._construction_set
+ else:
+ returngeneric_construction_set
+
+ @construction_set.setter
+ defconstruction_set(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,ConstructionSet), \
+ 'Expected ConstructionSet. Got {}'.format(type(value))
+ value.lock()# lock in case construction set has multiple references
+ self._construction_set=value
+
+
+[docs]
+ defaveraged_program_type(self,identifier=None,timestep_resolution=1):
+"""Get a ProgramType that is averaged across all of the children Room2Ds.
+
+ The weights used in the averaging process are the floor area weights and they
+ account for the multipliers on the child Story objects.
+
+ Args:
+ identifier: A unique ID text string for the new averaged ProgramType.
+ Must be < 100 characters and not contain any EnergyPlus special
+ characters. This will be used to identify the object across a model
+ and in the exported IDF. If None, the resulting ProgramType will
+ use the identifier of the host Building. (Default: None)
+ timestep_resolution: An optional integer for the timestep resolution
+ at which the schedules will be averaged. Any schedule details
+ smaller than this timestep will be lost in the averaging process.
+ Default: 1.
+ """
+ # get the default identifier of the ProgramType if None
+ identifier=identifierifidentifierisnotNoneelse \
+ '{}_Program'.format(self.host.identifier)
+
+ # compute the floor area weights and programs
+ flr_areas=[]
+ program_types=[]
+ forstoryinself.host.unique_stories:
+ forroominstory.room_2ds:
+ flr_areas.append(room.floor_area*story.multiplier)
+ program_types.append(room.properties.energy.program_type)
+ total_area=sum(flr_areas)
+ weights=[room_area/total_areaforroom_areainflr_areas]
+
+ # compute the averaged program
+ returnProgramType.average(
+ identifier,program_types,weights,timestep_resolution)
+
+
+
+[docs]
+ defset_all_room_2d_program_type(self,program_type):
+"""Set all of the children Room2Ds of this Building to have the same ProgramType.
+
+ Args:
+ program_type: A ProgramType to assign to all children Room2Ds.
+ """
+ assertisinstance(program_type,ProgramType),'Expected ProgramType for ' \
+ 'Building set_all_room_2d_program_type. Got {}'.format(type(program_type))
+ forroom_2dinself.host.unique_room_2ds:
+ room_2d.properties.energy.program_type=program_type
+
+
+
+[docs]
+ defset_all_program_type_from_building_type(self,building_type):
+"""Set the children Room2Ds to have a program mix from a building_type.
+
+ Args:
+ building_type: A text string for the type of building. This must appear
+ under the BUILDING_TYPES constant of the honeybee_energy.lib.programtypes
+ module to be successful.
+ """
+ program=building_program_type_by_identifier(building_type)
+ self.set_all_room_2d_program_type(program)
+
+
+
+[docs]
+ defset_all_room_2d_hvac(self,hvac,conditioned_only=True):
+"""Set all children Room2Ds of this Building to have the same HVAC system.
+
+ Args:
+ hvac: An HVAC system with properties that will be assigned to all
+ children Room2Ds.
+ conditioned_only: Boolean to note whether the input hvac should only
+ be applied to rooms that are already conditioned. If False, the
+ hvac will be applied to all rooms. (Default: True).
+ """
+ assertisinstance(hvac,_HVACSystem),'Expected HVACSystem for Building.' \
+ 'set_all_room_2d_hvac. Got {}'.format(type(hvac))
+
+ new_hvac=hvac.duplicate()
+ new_hvac._identifier='{}_{}'.format(hvac.identifier,self.host.identifier)
+ forroom_2dinself.host.unique_room_2ds:
+ ifnotconditioned_onlyorroom_2d.properties.energy.is_conditioned:
+ room_2d.properties.energy.hvac=new_hvac
+
+
+
+[docs]
+ defadd_default_ideal_air(self):
+"""Add a default IdealAirSystem to all children Room2Ds of this Story.
+
+ The identifier of the systems will be derived from the room identifiers.
+ """
+ forroom_2dinself.host.unique_room_2ds:
+ room_2d.properties.energy.add_default_ideal_air()
+
+
+
+[docs]
+ defset_all_room_2d_shw(self,shw):
+"""Set all children Room2Ds of this Building to have the same SHW system.
+
+ Args:
+ shw: A Service Hot Water (SHW) system with properties that will be
+ assigned to all children Room2Ds.
+ """
+ assertisinstance(shw,SHWSystem),'Expected SHWSystem for Building.' \
+ 'set_all_room_2d_shw. Got {}'.format(type(shw))
+
+ new_shw=shw.duplicate()
+ new_shw._identifier='{}_{}'.format(shw.identifier,self.host.identifier)
+ forroom_2dinself.host.unique_room_2ds:
+ room_2d.properties.energy.shw=new_shw
+
+
+
+[docs]
+ defdiversify(self,occupancy_stdev=20,lighting_stdev=20,
+ electric_equip_stdev=20,gas_equip_stdev=20,hot_water_stdev=20,
+ infiltration_stdev=20,schedule_offset=1,timestep=1):
+"""Diversify the ProgramTypes assigned to this Building's Room2Ds.
+
+ This method uses a random number generator and gaussian distribution to
+ generate loads that vary about the original "mean" programs. Note that the
+ randomly generated values can be set to something predictable by using the
+ native Python random.seed() method before running this method.
+
+ In addition to diversifying load values, approximately 2/3 of the schedules
+ in the resulting Room2Ds will be offset from the mean by the input
+ schedule_offset (1/3 ahead and another 1/3 behind).
+
+ Args:
+ occupancy_stdev: A number between 0 and 100 for the percent of the
+ occupancy people_per_area representing one standard deviation
+ of diversification from the mean. (Default 20 percent).
+ lighting_stdev: A number between 0 and 100 for the percent of the
+ lighting watts_per_area representing one standard deviation
+ of diversification from the mean. (Default 20 percent).
+ electric_equip_stdev: A number between 0 and 100 for the percent of the
+ electric equipment watts_per_area representing one standard deviation
+ of diversification from the mean. (Default 20 percent).
+ gas_equip_stdev: A number between 0 and 100 for the percent of the
+ gas equipment watts_per_area representing one standard deviation
+ of diversification from the mean. (Default 20 percent).
+ hot_water_stdev: A number between 0 and 100 for the percent of the
+ service hot water flow_per_area representing one standard deviation
+ of diversification from the mean. (Default 20 percent).
+ infiltration_stdev: A number between 0 and 100 for the percent of the
+ infiltration flow_per_exterior_area representing one standard deviation
+ of diversification from the mean. (Default 20 percent).
+ schedule_offset: A positive integer for the number of timesteps at which all
+ schedules of the resulting programs will be shifted - roughly 1/3 of
+ the programs ahead and another 1/3 behind. (Default: 1).
+ timestep: An integer for the number of timesteps per hour at which the
+ shifting is occurring. This must be a value between 1 and 60, which
+ is evenly divisible by 60. 1 indicates that each step is an hour
+ while 60 indicates that each step is a minute. (Default: 1).
+ """
+ # build a dictionary with the unique ProgramTypes and their assigned rooms
+ program_dict={}
+ forroom_2dinself.host.unique_room_2ds:
+ p_type=room_2d.properties.energy.program_type
+ try:# see if we have already found the program
+ program_dict[p_type.identifier][1].append(room_2d)
+ exceptKeyError:# this is the firs time encountering the program
+ program_dict[p_type.identifier]=[p_type,[room_2d]]
+
+ # loop through the dictionary and generate + assign diversified programs
+ forprog_listinprogram_dict.values():
+ prog,rooms=prog_list[0],prog_list[1]
+ div_programs=prog.diversify(
+ len(rooms),occupancy_stdev,lighting_stdev,electric_equip_stdev,
+ gas_equip_stdev,hot_water_stdev,infiltration_stdev,
+ schedule_offset,timestep)
+ forroom,d_proginzip(rooms,div_programs):
+ room.properties.energy.program_type=d_prog
+
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data,host):
+"""Create BuildingEnergyProperties from a dictionary.
+
+ Note that the dictionary must be a non-abridged version for this
+ classmethod to work.
+
+ Args:
+ data: A dictionary representation of BuildingEnergyProperties.
+ host: A Building object that hosts these properties.
+ """
+ assertdata['type']=='BuildingEnergyProperties', \
+ 'Expected BuildingEnergyProperties. Got {}.'.format(data['type'])
+
+ new_prop=cls(host)
+ if'construction_set'indataanddata['construction_set']isnotNone:
+ new_prop.construction_set= \
+ ConstructionSet.from_dict(data['construction_set'])
+
+ returnnew_prop
+
+
+
+[docs]
+ defapply_properties_from_dict(self,abridged_data,construction_sets):
+"""Apply properties from a BuildingEnergyPropertiesAbridged dictionary.
+
+ Args:
+ abridged_data: A BuildingEnergyPropertiesAbridged dictionary (typically
+ coming from a Model).
+ construction_sets: A dictionary of ConstructionSets with identifiers
+ of the sets as keys, which will be used to re-assign construction_sets.
+ """
+ if'construction_set'inabridged_dataand \
+ abridged_data['construction_set']isnotNone:
+ self.construction_set=construction_sets[abridged_data['construction_set']]
+
+
+
+[docs]
+ defto_dict(self,abridged=False):
+"""Return Building energy properties as a dictionary.
+
+ Args:
+ abridged: Boolean for whether the full dictionary of the Building should
+ be written (False) or just the identifier of the the individual
+ properties (True). Default: False.
+ """
+ base={'energy':{}}
+ base['energy']['type']='BuildingEnergyProperties'ifnot \
+ abridgedelse'BuildingEnergyPropertiesAbridged'
+
+ # write the ConstructionSet into the dictionary
+ ifself._construction_setisnotNone:
+ base['energy']['construction_set']= \
+ self._construction_set.identifierifabridgedelse \
+ self._construction_set.to_dict()
+
+ returnbase
+
+
+
+[docs]
+ defapply_properties_from_geojson_dict(self,data):
+"""Apply properties from a geoJSON dictionary.
+
+ Args:
+ data: A dictionary representation of a geoJSON feature properties.
+ Specifically, this should be the "properties" key describing
+ a Polygon or MultiPolygon object.
+ """
+ # determine the vintage of the building
+ template=data['template']if'template'indataelse'90.1-2019'
+ vintage=self._VINTAGE_MAP[template]
+
+ # assign the construction set based on climate zone
+ if'climate_zone'indata:
+ zone_int=str(data['climate_zone'])[0]
+ c_set_id='{}::{}{}::SteelFramed'.format(
+ vintage[0],'ClimateZone',zone_int)
+ try:
+ self.construction_set=construction_set_by_identifier(c_set_id)
+ exceptValueError:# not a construction set in the library
+ pass
+
+ # assign the program based on the building type
+ if'building_type'indata:
+ try:
+ self.set_all_program_type_from_building_type(data['building_type'])
+ exceptValueError:# not a building type in the library
+ pass
+
+ # assign the HVAC based on the name
+ if'system_type'indata:
+ hvac_instance=self._hvac_from_long_name(data['system_type'],vintage[1])
+ ifhvac_instanceisnotNone:
+ self.set_all_room_2d_hvac(hvac_instance,False)
+
+
+
+[docs]
+ defduplicate(self,new_host=None):
+"""Get a copy of this object.
+
+ new_host: A new Building object that hosts these properties.
+ If None, the properties will be duplicated with the same host.
+ """
+ _host=new_hostorself._host
+ returnBuildingEnergyProperties(_host,self._construction_set)
+
+
+ def_hvac_from_long_name(self,hvac_long_name,vintage='ASHRAE_2013'):
+"""Get an HVAC class instance from it's long name (as found in a geoJSON)."""
+ hvac_reg=None
+ ifBuildingEnergyProperties._HVAC_REGISTRYisNone:
+ ext_folder=[fforfinfolders.standards_extension_folders
+ iff.endswith('honeybee_energy_standards')]
+ iflen(ext_folder)==1:
+ hvac_reg=os.path.join(ext_folder[0],'hvac_registry.json')
+ ifos.path.isfile(hvac_reg):
+ withopen(hvac_reg,'r')asf:
+ BuildingEnergyProperties._HVAC_REGISTRY=json.load(f)
+ BuildingEnergyProperties._HVAC_REGISTRY['Ideal Air System']= \
+ 'IdealAirSystem'
+ hvac_reg=BuildingEnergyProperties._HVAC_REGISTRY
+ ifhvac_regisnotNone:
+ try:
+ hvac_class=self._HVAC_TYPES_DICT[hvac_reg[hvac_long_name]]
+ exceptKeyError:# HVAC type is not in the library
+ returnNone
+ ifhvac_classisIdealAirSystem:
+ returnIdealAirSystem('{}{}'.format(self.host.identifier,'Ideal Air'))
+ else:# assume it is an HVAC template
+ hvac_id='{}{}'.format(self.host.identifier,hvac_reg[hvac_long_name])
+ returnhvac_class(hvac_id,vintage,hvac_reg[hvac_long_name])
+
+
+[docs]
+classContextShadeEnergyProperties(object):
+"""Energy Properties for Dragonfly ContextShade.
+
+ Args:
+ host_shade: A dragonfly_core ContextShade object that hosts these properties.
+ construction: An optional ShadeConstruction object to set the reflectance
+ and specularity of the ContextShade. The default is a completely
+ diffuse construction with 0.2 visible and solar reflectance.
+ transmittance_schedule: An optional schedule to set the transmittance
+ of the shade, which can vary throughout the day or year. Default
+ is a completely opaque object.
+
+ Properties:
+ * host
+ * construction
+ * transmittance_schedule
+ * is_construction_set_by_user
+ """
+
+ __slots__=('_host','_construction','_transmittance_schedule')
+
+ def__init__(self,host_shade,construction=None,transmittance_schedule=None):
+"""Initialize ContextShade energy properties."""
+ self._host=host_shade
+ self.construction=construction
+ self.transmittance_schedule=transmittance_schedule
+
+ @property
+ defhost(self):
+"""Get the Shade object hosting these properties."""
+ returnself._host
+
+ @property
+ defconstruction(self):
+"""Get or set a ShadeConstruction for the context shade."""
+ ifself._construction:# set by user
+ returnself._construction
+ else:
+ returngeneric_context
+
+ @construction.setter
+ defconstruction(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,ShadeConstruction), \
+ 'Expected ShadeConstruction. Got {}.'.format(type(value))
+ value.lock()# lock editing in case construction has multiple references
+ self._construction=value
+
+ @property
+ deftransmittance_schedule(self):
+"""Get or set the transmittance schedule of the shade."""
+ returnself._transmittance_schedule
+
+ @transmittance_schedule.setter
+ deftransmittance_schedule(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,(ScheduleRuleset,ScheduleFixedInterval)), \
+ 'Expected schedule for shade transmittance schedule. ' \
+ 'Got {}.'.format(type(value))
+ ifvalue.schedule_type_limitisnotNone:
+ assertvalue.schedule_type_limit.unit=='fraction','Transmittance ' \
+ 'schedule should be fractional [Dimensionless]. Got a schedule ' \
+ 'of unit_type [{}].'.format(value.schedule_type_limit.unit_type)
+ value.lock()# lock editing in case schedule has multiple references
+ self._transmittance_schedule=value
+
+ @property
+ defis_construction_set_by_user(self):
+"""Boolean noting if construction is user-set."""
+ returnself._constructionisnotNone
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data,host):
+"""Create ContextShadeEnergyProperties from a dictionary.
+
+ Note that the dictionary must be a non-abridged version for this
+ classmethod to work.
+
+ Args:
+ data: A dictionary representation of ContextShadeEnergyProperties.
+ host: A ContextShade object that hosts these properties.
+ """
+ assertdata['type']=='ContextShadeEnergyProperties', \
+ 'Expected ContextShadeEnergyProperties. Got {}.'.format(data['type'])
+
+ new_prop=cls(host)
+ if'construction'indataanddata['construction']isnotNone:
+ new_prop.construction=ShadeConstruction.from_dict(data['construction'])
+ if'transmittance_schedule'indataand \
+ data['transmittance_schedule']isnotNone:
+ sch_dict=data['transmittance_schedule']
+ ifsch_dict['type']=='ScheduleRuleset':
+ new_prop.transmittance_schedule= \
+ ScheduleRuleset.from_dict(data['transmittance_schedule'])
+ elifsch_dict['type']=='ScheduleFixedInterval':
+ new_prop.transmittance_schedule= \
+ ScheduleFixedInterval.from_dict(data['transmittance_schedule'])
+ else:
+ raiseValueError(
+ 'Expected non-abridged Schedule dictionary for ContextShade '
+ 'transmittance_schedule. Got {}.'.format(sch_dict['type']))
+ returnnew_prop
+
+
+
+[docs]
+ defapply_properties_from_dict(self,abridged_data,constructions,schedules):
+"""Apply properties from a ContextShadeEnergyPropertiesAbridged dictionary.
+
+ Args:
+ abridged_data: A ContextShadeEnergyPropertiesAbridged dictionary (typically
+ coming from a Model).
+ constructions: A dictionary of constructions with constructions identifiers
+ as keys, which will be used to re-assign constructions.
+ schedules: A dictionary of schedules with schedule identifiers as keys,
+ which will be used to re-assign schedules.
+ """
+ if'construction'inabridged_dataandabridged_data['construction']isnotNone:
+ self.construction=constructions[abridged_data['construction']]
+ if'transmittance_schedule'inabridged_dataand \
+ abridged_data['transmittance_schedule']isnotNone:
+ self.transmittance_schedule= \
+ schedules[abridged_data['transmittance_schedule']]
+
+
+
+[docs]
+ defto_dict(self,abridged=False):
+"""Return energy properties as a dictionary.
+
+ Args:
+ abridged: Boolean to note whether the full dictionary describing the
+ object should be returned (False) or just an abridged version (True).
+ Default: False.
+ """
+ base={'energy':{}}
+ base['energy']['type']='ContextShadeEnergyProperties'ifnot \
+ abridgedelse'ContextShadeEnergyPropertiesAbridged'
+ ifself._constructionisnotNone:
+ base['energy']['construction']=self._construction.identifierifabridged \
+ elseself._construction.to_dict()
+ ifself.transmittance_scheduleisnotNone:
+ base['energy']['transmittance_schedule']= \
+ self.transmittance_schedule.identifierifabridgedelse \
+ self.transmittance_schedule.to_dict()
+ returnbase
+
+
+
+[docs]
+ defto_honeybee(self,new_host):
+"""Get a honeybee version of this object.
+
+ Args:
+ new_host: A honeybee-core Shade object that will host these properties.
+ """
+ returnShadeEnergyProperties(new_host,self._construction,
+ self._transmittance_schedule) \
+ ifisinstance(new_host,Shade)else \
+ ShadeMeshEnergyProperties(new_host,self._construction,
+ self._transmittance_schedule)
+
+
+
+[docs]
+ deffrom_honeybee(self,hb_properties):
+"""Transfer energy attributes from a Honeybee Shade to Dragonfly ContextShade.
+
+ Args:
+ hb_properties: The ShadeEnergyProperties of the honeybee Shade that is being
+ translated to a Dragonfly ContextShade.
+ """
+ self._construction=hb_properties._construction
+ self._transmittance_schedule=hb_properties._transmittance_schedule
+
+
+
+[docs]
+ defduplicate(self,new_host=None):
+"""Get a copy of this object.
+
+ new_host: A new ContextShade object that hosts these properties.
+ If None, the properties will be duplicated with the same host.
+ """
+ _host=new_hostorself._host
+ returnContextShadeEnergyProperties(_host,self._construction,
+ self._transmittance_schedule)
+[docs]
+classModelEnergyProperties(object):
+"""Energy Properties for Dragonfly Model.
+
+ Args:
+ host: A dragonfly_core Model object that hosts these properties.
+
+ Properties:
+ * host
+ * materials
+ * constructions
+ * face_constructions
+ * shade_constructions
+ * construction_sets
+ * global_construction_set
+ * schedule_type_limits
+ * schedules
+ * construction_schedules
+ * shade_schedules
+ * program_type_schedules
+ * hvac_schedules
+ * misc_room_schedules
+ * program_types
+ * hvacs
+ * shws
+ """
+
+ def__init__(self,host):
+"""Initialize Model energy properties."""
+ self._host=host
+
+ @property
+ defhost(self):
+"""Get the Model object hosting these properties."""
+ returnself._host
+
+ @property
+ defmaterials(self):
+"""Get a list of all unique materials contained within the model.
+
+ This includes materials across all Room2Ds, Stories, and Building
+ ConstructionSets but it does NOT include the Honeybee generic default
+ construction set.
+ """
+ materials=[]
+ forconstrinself.constructions:
+ try:
+ materials.extend(constr.materials)
+ ifconstr.has_frame:
+ materials.append(constr.frame)
+ ifisinstance(constr,WindowConstructionShade):
+ ifconstr.is_switchable_glazing:
+ materials.append(constr.switched_glass_material)
+ ifconstr.shade_location=='Between':
+ materials.append(constr.window_construction.materials[-2])
+ exceptAttributeError:
+ pass# ShadeConstruction
+ returnlist(set(materials))
+
+ @property
+ defconstructions(self):
+"""Get a list of all unique constructions in the model.
+
+ This includes materials across all Room2Ds, Stories, and Building
+ ConstructionSets but it does NOT include the Honeybee generic default
+ construction set.
+ """
+ bldg_constrs=[]
+ forcnstr_setinself.construction_sets:
+ bldg_constrs.extend(cnstr_set.modified_constructions_unique)
+ all_constrs=bldg_constrs+self.face_constructions+self.shade_constructions
+ returnlist(set(all_constrs))
+
+ @property
+ defface_constructions(self):
+"""Get a list of all unique constructions assigned to Faces, Apertures and Doors.
+
+ These objects only exist under the Building.room_3ds property
+ """
+ constructions=[]
+ forbldginself.host.buildings:
+ forfaceinbldg.room_3d_faces:
+ self._check_and_add_obj_construction(face,constructions)
+ forapinface.apertures:
+ self._check_and_add_obj_construction(ap,constructions)
+ fordrinface.doors:
+ self._check_and_add_obj_construction(dr,constructions)
+ returnlist(set(constructions))
+
+ @property
+ defshade_constructions(self):
+"""Get a list of all unique constructions assigned to ContextShades in the model.
+
+ This will also include any Shade objects assigned to the 3D Honeybee Rooms
+ of any Model Buildings.
+ """
+ constructions=[]
+ forshadeinself.host.context_shades:
+ self._check_and_add_obj_construction(shade,constructions)
+ forbldginself.host.buildings:
+ forshdinbldg.room_3d_shades:
+ self._check_and_add_obj_construction(shd,constructions)
+ returnlist(set(constructions))
+
+ @property
+ defconstruction_sets(self):
+"""Get a list of all unique ConstructionSets in the Model.
+
+ Note that this includes ConstructionSets assigned to individual Stories,
+ Room2Ds and 3D Honeybee Rooms in the Model's Buildings.
+ """
+ construction_sets=[]
+ forbldginself.host.buildings:
+ self._check_and_add_obj_constr_set(bldg,construction_sets)
+ forstoryinbldg.unique_stories:
+ self._check_and_add_obj_constr_set(story,construction_sets)
+ forroominstory.room_2ds:
+ self._check_and_add_obj_constr_set(room,construction_sets)
+ forroominbldg.room_3ds:
+ self._check_and_add_obj_constr_set(room,construction_sets)
+ returnlist(set(construction_sets))# catch equivalent construction sets
+
+ @property
+ defglobal_construction_set(self):
+"""The global energy construction set.
+
+ This is what is used whenever there is no construction_set assigned to a
+ Room2D, a parent Story, or a parent Building.
+ """
+ returngeneric_construction_set
+
+ @property
+ defschedule_type_limits(self):
+"""Get a list of all unique schedule type limits contained within the model.
+
+ This includes schedules across all ContextShades and Room2Ds.
+ """
+ type_limits=[]
+ forschedinself.schedules:
+ t_lim=sched.schedule_type_limit
+ ift_limisnotNoneandnotself._instance_in_array(t_lim,type_limits):
+ type_limits.append(t_lim)
+ returnlist(set(type_limits))
+
+ @property
+ defschedules(self):
+"""Get a list of all unique schedules in the model.
+
+ This includes schedules across all ProgramTypes and ContextShades.
+ """
+ all_scheds=self.hvac_schedules+self.program_type_schedules+ \
+ self.misc_room_schedules+self.shade_schedules+self.construction_schedules
+ returnlist(set(all_scheds))
+
+ @property
+ defconstruction_schedules(self):
+"""Get a list of all unique schedules assigned to constructions in the model.
+
+ This includes schedules on al AirBoundaryConstructions, WindowConstructionShade,
+ and WindowConstructionDynamic.
+ """
+ schedules=[]
+ forconstrinself.constructions:
+ ifisinstance(constr,AirBoundaryConstruction):
+ self._check_and_add_schedule(constr.air_mixing_schedule,schedules)
+ elifisinstance(constr,WindowConstructionShade):
+ ifconstr.scheduleisnotNone:
+ self._check_and_add_schedule(constr.schedule,schedules)
+ elifisinstance(constr,WindowConstructionDynamic):
+ self._check_and_add_schedule(constr.schedule,schedules)
+ returnlist(set(schedules))
+
+ @property
+ defshade_schedules(self):
+"""Get a list of all unique schedules assigned to ContextShades in the model.
+ """
+ schedules=[]
+ forshadeinself.host._context_shades:
+ self._check_and_add_shade_schedule(shade,schedules)
+ returnlist(set(schedules))
+
+ @property
+ defprogram_type_schedules(self):
+"""A list of all unique schedules assigned to ProgramTypes in the model."""
+ schedules=[]
+ forp_typeinself.program_types:
+ forschedinp_type.schedules:
+ self._check_and_add_schedule(sched,schedules)
+ returnlist(set(schedules))
+
+ @property
+ defhvac_schedules(self):
+"""Get a list of all unique HVAC-assigned schedules in the model."""
+ schedules=[]
+ forhvacinself.hvacs:
+ forschedinhvac.schedules:
+ self._check_and_add_schedule(sched,schedules)
+ returnlist(set(schedules))
+
+ @property
+ defmisc_room_schedules(self):
+"""Get a list of all unique schedules assigned directly to Rooms in the model.
+
+ This includes schedules for process loads and window ventilation control
+ that are assigned to Room2Ds. It also includes any schedules assigned directly
+ to 3D Honeybee Rooms of the model (not through the room program).
+
+ Note that this does not include schedules from ProgramTypes assigned to the
+ rooms. For this, use the program_type_schedules property.
+ """
+ scheds=[]
+ forbldginself.host._buildings:
+ forstoryinbldg:
+ forroominstory:
+ window_vent=room.properties.energy._window_vent_control
+ processes=room.properties.energy._process_loads
+ ifwindow_ventisnotNone:
+ self._check_and_add_schedule(window_vent.schedule,scheds)
+ iflen(processes)!=0:
+ forprocessinprocesses:
+ self._check_and_add_schedule(process.schedule,scheds)
+ forroominbldg.room_3ds:
+ people=room.properties.energy._people
+ lighting=room.properties.energy._lighting
+ electric_equipment=room.properties.energy._electric_equipment
+ gas_equipment=room.properties.energy._gas_equipment
+ shw=room.properties.energy._service_hot_water
+ infiltration=room.properties.energy._infiltration
+ ventilation=room.properties.energy._ventilation
+ setpoint=room.properties.energy._setpoint
+ window_vent=room.properties.energy._window_vent_control
+ processes=room.properties.energy._process_loads
+ fans=room.properties.energy._fans
+ ifpeopleisnotNone:
+ self._check_and_add_schedule(people.occupancy_schedule,scheds)
+ self._check_and_add_schedule(people.activity_schedule,scheds)
+ iflightingisnotNone:
+ self._check_and_add_schedule(lighting.schedule,scheds)
+ ifelectric_equipmentisnotNone:
+ self._check_and_add_schedule(electric_equipment.schedule,scheds)
+ ifgas_equipmentisnotNone:
+ self._check_and_add_schedule(gas_equipment.schedule,scheds)
+ ifshwisnotNone:
+ self._check_and_add_schedule(shw.schedule,scheds)
+ ifinfiltrationisnotNone:
+ self._check_and_add_schedule(infiltration.schedule,scheds)
+ ifventilationisnotNoneandventilation.scheduleisnotNone:
+ self._check_and_add_schedule(ventilation.schedule,scheds)
+ ifsetpointisnotNone:
+ self._check_and_add_schedule(setpoint.heating_schedule,scheds)
+ self._check_and_add_schedule(setpoint.cooling_schedule,scheds)
+ ifsetpoint.humidifying_scheduleisnotNone:
+ self._check_and_add_schedule(
+ setpoint.humidifying_schedule,scheds)
+ self._check_and_add_schedule(
+ setpoint.dehumidifying_schedule,scheds)
+ ifwindow_ventisnotNone:
+ self._check_and_add_schedule(window_vent.schedule,scheds)
+ iflen(processes)!=0:
+ forprocessinprocesses:
+ self._check_and_add_schedule(process.schedule,scheds)
+ iflen(fans)!=0:
+ forfaninfans:
+ self._check_and_add_schedule(fan.control.schedule,scheds)
+ returnlist(set(scheds))
+
+ @property
+ defprogram_types(self):
+"""Get a list of all unique ProgramTypes in the Model.
+
+ This includes ProgramTypes assigned to both Room2Ds and 3D Honeybee Rooms.
+ """
+ program_types=[]
+ forbldginself.host._buildings:
+ forstoryinbldg:
+ forroominstory:
+ ifroom.properties.energy._program_typeisnotNone:
+ ifnotself._instance_in_array(
+ room.properties.energy._program_type,program_types):
+ program_types.append(room.properties.energy._program_type)
+ forroominbldg.room_3ds:
+ ifroom.properties.energy._program_typeisnotNone:
+ ifnotself._instance_in_array(
+ room.properties.energy._program_type,program_types):
+ program_types.append(room.properties.energy._program_type)
+ returnlist(set(program_types))# catch equivalent program types
+
+ @property
+ defhvacs(self):
+"""Get a list of all unique HVAC systems in the Model."""
+ hvacs=[]
+ forbldginself.host._buildings:
+ forstoryinbldg:
+ forroominstory:
+ ifroom.properties.energy._hvacisnotNone:
+ ifnotself._instance_in_array(
+ room.properties.energy._hvac,hvacs):
+ hvacs.append(room.properties.energy._hvac)
+ forroominbldg.room_3ds:
+ ifroom.properties.energy._hvacisnotNone:
+ ifnotself._instance_in_array(room.properties.energy._hvac,hvacs):
+ hvacs.append(room.properties.energy._hvac)
+ returnhvacs
+
+ @property
+ defshws(self):
+"""Get a list of all unique Service Hot Water (SHW) systems in the Model."""
+ shws=[]
+ forbldginself.host._buildings:
+ forstoryinbldg:
+ forroominstory:
+ ifroom.properties.energy._shwisnotNone:
+ ifnotself._instance_in_array(
+ room.properties.energy._shw,shws):
+ shws.append(room.properties.energy._shw)
+ forroominbldg.room_3ds:
+ ifroom.properties.energy._shwisnotNone:
+ ifnotself._instance_in_array(room.properties.energy._shw,shws):
+ shws.append(room.properties.energy._shw)
+ returnshws
+
+
+[docs]
+ defcheck_all(self,raise_exception=True):
+"""Check all of the aspects of the Model energy properties.
+
+ 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.
+
+ Returns:
+ A text string with all errors that were found. This string will be empty
+ of no errors were found.
+ """
+ msgs=[]
+ # perform checks for key honeybee model schema rules
+ msgs.append(self.check_duplicate_construction_set_identifiers(False))
+ msgs.append(self.check_duplicate_program_type_identifiers(False))
+ msgs.append(self.check_duplicate_hvac_identifiers(False))
+ msgs.append(self.check_duplicate_shw_identifiers(False))
+ # output a final report of errors or raise an exception
+ full_msgs=[msgformsginmsgsifmsg!='']
+ full_msg='\n'.join(full_msgs)
+ ifraise_exceptionandlen(full_msgs)!=0:
+ raiseValueError(full_msg)
+ returnfull_msg
+
+
+
+[docs]
+ defcheck_duplicate_construction_set_identifiers(
+ self,raise_exception=True,detailed=False):
+"""Check that there are no duplicate ConstructionSet identifiers in the model.
+
+ Args:
+ raise_exception: Boolean to note whether a ValueError should be raised
+ if duplicate identifiers are 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 string with the message or a list with a dictionary if detailed is True.
+ """
+ returncheck_duplicate_identifiers(
+ self.construction_sets,raise_exception,'ConstructionSet',
+ detailed,'020003','Energy',
+ error_type='Duplicate ConstructionSet Identifier')
+
+
+
+[docs]
+ defcheck_duplicate_program_type_identifiers(
+ self,raise_exception=True,detailed=False):
+"""Check that there are no duplicate ProgramType identifiers in the model.
+
+ Args:
+ raise_exception: Boolean to note whether a ValueError should be raised
+ if duplicate identifiers are 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 string with the message or a list with a dictionary if detailed is True.
+ """
+ returncheck_duplicate_identifiers(
+ self.program_types,raise_exception,'ProgramType',
+ detailed,'020006','Energy',error_type='Duplicate ProgramType Identifier')
+
+
+
+[docs]
+ defcheck_duplicate_hvac_identifiers(self,raise_exception=True,detailed=False):
+"""Check that there are no duplicate HVAC identifiers in the model.
+
+ Args:
+ raise_exception: Boolean to note whether a ValueError should be raised
+ if duplicate identifiers are 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 string with the message or a list with a dictionary if detailed is True.
+ """
+ returncheck_duplicate_identifiers(
+ self.hvacs,raise_exception,'HVAC',detailed,'020007','Energy',
+ error_type='Duplicate HVAC Identifier')
+
+
+
+[docs]
+ defcheck_duplicate_shw_identifiers(self,raise_exception=True,detailed=False):
+"""Check that there are no duplicate SHW identifiers in the model.
+
+ Args:
+ raise_exception: Boolean to note whether a ValueError should be raised
+ if duplicate identifiers are 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 string with the message or a list with a dictionary if detailed is True.
+ """
+ returncheck_duplicate_identifiers(
+ self.shws,raise_exception,'SHW',detailed,'020008','Energy',
+ error_type='Duplicate SHW Identifier')
+
+
+
+[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 dragonfly-core Model.
+ Note that this dictionary must have ModelEnergyProperties in order
+ for this method to successfully apply the energy properties.
+ """
+ assert'energy'indata['properties'], \
+ 'Dictionary possesses no ModelEnergyProperties.'
+ _,constructions,construction_sets,_,schedules,program_types,hvacs,shws= \
+ hb_model_properties.ModelEnergyProperties.load_properties_from_dict(data)
+
+ # collect lists of energy property dictionaries
+ building_e_dicts,story_e_dicts,room2d_e_dicts,context_e_dicts= \
+ model_extension_dicts(data,'energy',[],[],[],[])
+
+ # apply energy properties to objects using the energy property dictionaries
+ forbldg,b_dictinzip(self.host.buildings,building_e_dicts):
+ ifb_dictisnotNone:
+ bldg.properties.energy.apply_properties_from_dict(
+ b_dict,construction_sets)
+ ifbldg.has_room_3dsandb_dictisnotNoneand'room_3ds'inb_dictand \
+ b_dict['room_3ds']isnotNone:
+ room_e_dicts,face_e_dicts,shd_e_dicts,ap_e_dicts,dr_e_dicts= \
+ room_extension_dicts(b_dict['room_3ds'],'energy',[],[],[],[],[])
+ forroom,r_dictinzip(bldg.room_3ds,room_e_dicts):
+ ifr_dictisnotNone:
+ room.properties.energy.apply_properties_from_dict(
+ r_dict,construction_sets,program_types,hvacs,shws,
+ schedules,constructions)
+ forface,f_dictinzip(bldg.room_3d_faces,face_e_dicts):
+ iff_dictisnotNone:
+ face.properties.energy.apply_properties_from_dict(
+ f_dict,constructions)
+ foraperture,a_dictinzip(bldg.room_3d_apertures,ap_e_dicts):
+ ifa_dictisnotNone:
+ aperture.properties.energy.apply_properties_from_dict(
+ a_dict,constructions)
+ fordoor,d_dictinzip(bldg.room_3d_doors,dr_e_dicts):
+ ifd_dictisnotNone:
+ door.properties.energy.apply_properties_from_dict(
+ d_dict,constructions)
+ forshade,s_dictinzip(bldg.room_3d_shades,shd_e_dicts):
+ ifs_dictisnotNone:
+ shade.properties.energy.apply_properties_from_dict(
+ s_dict,constructions,schedules)
+ forstory,s_dictinzip(self.host.stories,story_e_dicts):
+ ifs_dictisnotNone:
+ story.properties.energy.apply_properties_from_dict(
+ s_dict,construction_sets)
+ forroom,r_dictinzip(self.host.room_2ds,room2d_e_dicts):
+ ifr_dictisnotNone:
+ room.properties.energy.apply_properties_from_dict(
+ r_dict,construction_sets,program_types,hvacs,shws,schedules)
+ forshade,s_dictinzip(self.host.context_shades,context_e_dicts):
+ ifs_dictisnotNone:
+ shade.properties.energy.apply_properties_from_dict(
+ s_dict,constructions,schedules)
+
+
+
+[docs]
+ defto_dict(self):
+"""Return Model energy properties as a dictionary."""
+ base={'energy':{'type':'ModelEnergyProperties'}}
+
+ # add all materials, constructions and construction sets to the dictionary
+ schs=self._add_constr_type_objs_to_dict(base)
+
+ # add all schedule type limits, schedules, and program types to the dictionary
+ self._add_sched_type_objs_to_dict(base,schs)
+
+ returnbase
+
+
+
+[docs]
+ defto_honeybee(self,new_host):
+"""Get a honeybee version of this object.
+
+ Args:
+ new_host: A honeybee-core Model object that will host these properties.
+ """
+ returnhb_model_properties.ModelEnergyProperties(new_host)
+
+
+
+[docs]
+ defduplicate(self,new_host=None):
+"""Get a copy of this Model.
+
+ Args:
+ new_host: A new Model object that hosts these properties.
+ If None, the properties will be duplicated with the same host.
+ """
+ _host=new_hostorself._host
+ returnModelEnergyProperties(_host)
+
+
+ def_add_constr_type_objs_to_dict(self,base):
+"""Add materials, constructions and construction sets to a base dictionary.
+
+ Args:
+ base: A base dictionary for a Dragonfly Model.
+ """
+ # add the global construction set to the dictionary
+ gs=self.global_construction_set.to_dict(abridged=True,none_for_defaults=False)
+ gs['type']='GlobalConstructionSet'
+ delgs['identifier']
+ g_constr=self.global_construction_set.constructions_unique
+ g_materials=[]
+ forconstring_constr:
+ try:
+ g_materials.extend(constr.materials)
+ exceptAttributeError:
+ pass# ShadeConstruction or AirBoundaryConstruction
+ gs['context_construction']=generic_context.identifier
+ gs['constructions']=[generic_context.to_dict()]
+ forcnsting_constr:
+ try:
+ gs['constructions'].append(cnst.to_dict(abridged=True))
+ exceptTypeError:# ShadeConstruction
+ gs['constructions'].append(cnst.to_dict())
+ gs['materials']=[mat.to_dict()formatinset(g_materials)]
+ base['energy']['global_construction_set']=gs
+
+ # add all ConstructionSets to the dictionary
+ base['energy']['construction_sets']=[]
+ construction_sets=self.construction_sets
+ forcnstr_setinconstruction_sets:
+ base['energy']['construction_sets'].append(cnstr_set.to_dict(abridged=True))
+
+ # add all unique Constructions to the dictionary
+ room_constrs=[]
+ forcnstr_setinconstruction_sets:
+ room_constrs.extend(cnstr_set.modified_constructions_unique)
+ mass_constrs=[]
+ forbldginself.host.buildings:
+ forroominbldg.room_3ds:
+ forint_massinroom.properties.energy._internal_masses:
+ constr=int_mass.construction
+ ifnotself._instance_in_array(constr,mass_constrs):
+ mass_constrs.append(constr)
+ all_constrs=room_constrs+self.face_constructions+self.shade_constructions
+ constructions=tuple(set(all_constrs))
+ base['energy']['constructions']=[]
+ forcnstinconstructions:
+ try:
+ base['energy']['constructions'].append(cnst.to_dict(abridged=True))
+ exceptTypeError:# ShadeConstruction
+ base['energy']['constructions'].append(cnst.to_dict())
+
+ # add all unique Materials to the dictionary
+ materials=[]
+ forcnstrinconstructions:
+ try:
+ materials.extend(cnstr.materials)
+ ifcnstr.has_frame:
+ materials.append(cnstr.frame)
+ ifisinstance(cnstr,WindowConstructionShade):
+ ifcnstr.is_switchable_glazing:
+ materials.append(cnstr.switched_glass_material)
+ ifcnstr.shade_location=='Between':
+ materials.append(cnstr.window_construction.materials[-2])
+ exceptAttributeError:
+ pass# ShadeConstruction
+ base['energy']['materials']=[mat.to_dict()formatinset(materials)]
+
+ # extract all of the schedules from the constructions
+ schedules=[]
+ forconstrinconstructions:
+ ifisinstance(constr,AirBoundaryConstruction):
+ self._check_and_add_schedule(constr.air_mixing_schedule,schedules)
+ elifisinstance(constr,WindowConstructionShade):
+ ifconstr.scheduleisnotNone:
+ self._check_and_add_schedule(constr.schedule,schedules)
+ elifisinstance(constr,WindowConstructionDynamic):
+ self._check_and_add_schedule(constr.schedule,schedules)
+ returnschedules
+
+ def_add_sched_type_objs_to_dict(self,base,schs):
+"""Add schedule type limits, schedules, and program types to a base dictionary.
+
+ Args:
+ base: A base dictionary for a Dragonfly Model.
+ schs: A list of additional schedules to be serialized to the
+ base dictionary.
+ """
+ # add all unique hvacs to the dictionary
+ hvacs=self.hvacs
+ base['energy']['hvacs']=[]
+ forhvacinhvacs:
+ base['energy']['hvacs'].append(hvac.to_dict(abridged=True))
+
+ # add all unique shws to the dictionary
+ base['energy']['shws']=[shw.to_dict()forshwinself.shws]
+
+ # add all unique ProgramTypes to the dictionary
+ program_types=self.program_types
+ base['energy']['program_types']=[]
+ forp_typeinprogram_types:
+ base['energy']['program_types'].append(p_type.to_dict(abridged=True))
+
+ # add all unique Schedules to the dictionary
+ p_type_scheds=[]
+ forp_typeinprogram_types:
+ forschedinp_type.schedules:
+ self._check_and_add_schedule(sched,p_type_scheds)
+ hvac_scheds=[]
+ forhvacinhvacs:
+ forschedinhvac.schedules:
+ self._check_and_add_schedule(sched,hvac_scheds)
+ all_scheds=hvac_scheds+p_type_scheds+self.misc_room_schedules+ \
+ self.shade_schedules+schs
+ schedules=tuple(set(all_scheds))
+ base['energy']['schedules']=[]
+ forschedinschedules:
+ base['energy']['schedules'].append(sched.to_dict(abridged=True))
+
+ # add all unique ScheduleTypeLimits to the dictionary
+ type_limits=[]
+ forschedinschedules:
+ t_lim=sched.schedule_type_limit
+ ift_limisnotNoneandnotself._instance_in_array(t_lim,type_limits):
+ type_limits.append(t_lim)
+ base['energy']['schedule_type_limits']= \
+ [s_typ.to_dict()fors_typinset(type_limits)]
+
+ def_check_and_add_obj_constr_set(self,obj,construction_sets):
+"""Check if a construction set is assigned to an object and add it to a list."""
+ c_set=obj.properties.energy._construction_set
+ ifc_setisnotNone:
+ ifnotself._instance_in_array(c_set,construction_sets):
+ construction_sets.append(c_set)
+
+ def_check_and_add_obj_construction(self,obj,constructions):
+"""Check if a construction is assigned to an object and add it to a list."""
+ constr=obj.properties.energy._construction
+ ifconstrisnotNone:
+ ifnotself._instance_in_array(constr,constructions):
+ constructions.append(constr)
+
+ def_check_and_add_shade_schedule(self,obj,schedules):
+"""Check if a schedule is assigned to a shade and add it to a list."""
+ sched=obj.properties.energy._transmittance_schedule
+ ifschedisnotNone:
+ ifnotself._instance_in_array(sched,schedules):
+ schedules.append(sched)
+
+ def_check_and_add_schedule(self,sched,schedules):
+"""Check if a schedule is in a list and add it if not."""
+ ifnotself._instance_in_array(sched,schedules):
+ schedules.append(sched)
+
+ @staticmethod
+ def_instance_in_array(object_instance,object_array):
+"""Check if a specific object instance is already in an array.
+
+ This can be much faster than `if object_instance in object_array`
+ when you expect to be testing a lot of the same instance of an object for
+ inclusion in an array since the builtin method uses an == operator to
+ test inclusion.
+ """
+ forvalinobject_array:
+ ifvalisobject_instance:
+ returnTrue
+ returnFalse
+
+
+[docs]
+classRoom2DEnergyProperties(object):
+"""Energy Properties for Dragonfly Room2D.
+
+ Args:
+ host: A dragonfly_core Room2D object that hosts these properties.
+ program_type: A honeybee ProgramType object to specify all default
+ schedules and loads for the Room2D. If None, the Room2D will have a
+ Plenum program (with no loads or setpoints). Default: None.
+ construction_set: A honeybee ConstructionSet object to specify all
+ default constructions for the Faces of the Room2D. If None, the
+ Room2D will use the honeybee default construction set, which is not
+ representative of a particular building code or climate zone.
+ Default: None.
+ hvac: A honeybee HVAC object (such as an IdealAirSystem) that specifies
+ how the Room2D is conditioned. If None, it will be assumed that the
+ Room2D is not conditioned. Default: None.
+
+ Properties:
+ * host
+ * program_type
+ * construction_set
+ * hvac
+ * shw
+ * window_vent_control
+ * window_vent_opening
+ * process_loads
+ * total_process_load
+ * is_conditioned
+ * has_window_opening
+ """
+
+ __slots__=('_host','_program_type','_construction_set','_hvac','_shw',
+ '_window_vent_control','_window_vent_opening','_process_loads')
+
+ def__init__(
+ self,host,program_type=None,construction_set=None,hvac=None,shw=None):
+"""Initialize Room2D energy properties."""
+ self._host=host
+ self.program_type=program_type
+ self.construction_set=construction_set
+ self.hvac=hvac
+ self.shw=shw
+ self._window_vent_control=None# set to None by default
+ self._window_vent_opening=None# set to None by default
+ self._process_loads=[]
+
+ @property
+ defhost(self):
+"""Get the Room2D object hosting these properties."""
+ returnself._host
+
+ @property
+ defprogram_type(self):
+"""Get or set the ProgramType object for the Room2D.
+
+ If not set, it will default to a plenum ProgramType (with no loads assigned).
+ """
+ ifself._program_typeisnotNone:# set by the user
+ returnself._program_type
+ else:
+ returnplenum_program
+
+ @program_type.setter
+ defprogram_type(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,ProgramType),'Expected ProgramType for Room2D ' \
+ 'program_type. Got {}'.format(type(value))
+ value.lock()# lock in case program type has multiple references
+ self._program_type=value
+
+ @property
+ defconstruction_set(self):
+"""Get or set the Room2D ConstructionSet object.
+
+ If not set, it will be set by the parent Story or will be the Honeybee
+ default generic ConstructionSet.
+ """
+ ifself._construction_setisnotNone:# set by the user
+ returnself._construction_set
+ elifself._host.has_parent:# set by parent story
+ returnself._host.parent.properties.energy.construction_set
+ else:
+ returngeneric_construction_set
+
+ @construction_set.setter
+ defconstruction_set(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,ConstructionSet), \
+ 'Expected ConstructionSet. Got {}'.format(type(value))
+ value.lock()# lock in case construction set has multiple references
+ self._construction_set=value
+
+ @property
+ defhvac(self):
+"""Get or set the HVAC object for the Room2D.
+
+ If None, it will be assumed that the Room2D is not conditioned.
+ """
+ returnself._hvac
+
+ @hvac.setter
+ defhvac(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,_HVACSystem), \
+ 'Expected HVACSystem for Room2D hvac. Got {}'.format(type(value))
+ value.lock()# lock in case hvac has multiple references
+ self._hvac=value
+
+ @property
+ defshw(self):
+"""Get or set the SHWSystem object for the Room2D.
+
+ If None, all hot water loads will be met with a system that doesn't compute
+ fuel or electricity usage.
+ """
+ returnself._shw
+
+ @shw.setter
+ defshw(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,SHWSystem), \
+ 'Expected SHWSystem for Room shw. Got {}'.format(type(value))
+ value.lock()# lock in case shw has multiple references
+ self._shw=value
+
+ @property
+ defwindow_vent_control(self):
+"""Get or set a VentilationControl object to dictate the opening of windows.
+
+ If None or no window_vent_opening object is assigned to this Room2D,
+ the windows will never open.
+ """
+ returnself._window_vent_control
+
+ @window_vent_control.setter
+ defwindow_vent_control(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,VentilationControl),'Expected VentilationControl' \
+ ' object for Room2D window_vent_control. Got {}'.format(type(value))
+ value.lock()# lock because we don't duplicate the object
+ self._window_vent_control=value
+
+ @property
+ defwindow_vent_opening(self):
+"""Get or set a VentilationOpening object for the operability of all windows.
+
+ If None or no window_vent_control object is assigned to this Room2D,
+ the windows will never open.
+ """
+ returnself._window_vent_opening
+
+ @window_vent_opening.setter
+ defwindow_vent_opening(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,VentilationOpening),'Expected VentilationOpening' \
+ ' for Room2D window_vent_opening. Got {}'.format(type(value))
+ self._window_vent_opening=value
+
+ @property
+ defprocess_loads(self):
+"""Get or set an array of Process objects for process loads within the Room2D."""
+ returntuple(self._process_loads)
+
+ @process_loads.setter
+ defprocess_loads(self,value):
+ forvalinvalue:
+ assertisinstance(val,Process),'Expected Process ' \
+ 'object for Room process_loads. Got {}'.format(type(val))
+ val.lock()# lock because we don't duplicate the object
+ self._process_loads=list(value)
+
+ @property
+ deftotal_process_load(self):
+"""Get a number for the total process load in W within the room."""
+ returnsum([load.wattsforloadinself._process_loads])
+
+ @property
+ defis_conditioned(self):
+"""Boolean to note whether the Room is conditioned."""
+ returnself._hvacisnotNone
+
+ @property
+ defhas_window_opening(self):
+"""Boolean to note whether the Room has operable windows with controls."""
+ returnself._window_vent_openingisnotNone
+
+
+[docs]
+ defadd_default_ideal_air(self):
+"""Add a default IdealAirSystem to this Room2D.
+
+ The identifier of this system will be derived from the room identifier
+ and will align with the naming convention that EnergyPlus uses for
+ templates Ideal Air systems.
+ """
+ hvac_id='{} Ideal Loads Air System'.format(self.host.identifier)
+ self.hvac=IdealAirSystem(hvac_id)
+
+
+
+[docs]
+ defadd_process_load(self,process_load):
+"""Add a Process load to this Room2D.
+
+ Args:
+ process_load: A Process load to add to this Room.
+ """
+ assertisinstance(process_load,Process), \
+ 'Expected Process load object. Got {}.'.format(type(process_load))
+ process_load.lock()# lock because we don't duplicate the object
+ self._process_loads.append(process_load)
+
+
+
+[docs]
+ defremove_process_loads(self):
+"""Remove all Process loads from the Room."""
+ self._process_loads=[]
+
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data,host):
+"""Create Room2DEnergyProperties from a dictionary.
+
+ Note that the dictionary must be a non-abridged version for this
+ classmethod to work.
+
+ Args:
+ data: A dictionary representation of Room2DEnergyProperties in the
+ format below.
+ host: A Room2D object that hosts these properties.
+
+ .. code-block:: python
+
+ {
+ "type": 'Room2DEnergyProperties',
+ "construction_set": {}, # A ConstructionSet dictionary
+ "program_type": {}, # A ProgramType dictionary
+ "hvac": {}, # A HVACSystem dictionary
+ "shw": {}, # A SHWSystem dictionary
+ "daylighting_control": {}, # A DaylightingControl dictionary
+ "window_vent_control": {} # A VentilationControl dictionary
+ "process_loads": [] # An array of Process dictionaries
+ }
+ """
+ assertdata['type']=='Room2DEnergyProperties', \
+ 'Expected Room2DEnergyProperties. Got {}.'.format(data['type'])
+
+ new_prop=cls(host)
+ if'construction_set'indataanddata['construction_set']isnotNone:
+ new_prop.construction_set= \
+ ConstructionSet.from_dict(data['construction_set'])
+ if'program_type'indataanddata['program_type']isnotNone:
+ new_prop.program_type=ProgramType.from_dict(data['program_type'])
+ if'hvac'indataanddata['hvac']isnotNone:
+ hvac_class=HVAC_TYPES_DICT[data['hvac']['type']]
+ new_prop.hvac=hvac_class.from_dict(data['hvac'])
+ if'shw'indataanddata['shw']isnotNone:
+ new_prop.shw=SHWSystem.from_dict(data['shw'])
+ cls._deserialize_window_vent(new_prop,data,{})
+ if'process_loads'indataanddata['process_loads']isnotNone:
+ new_prop.process_loads= \
+ [Process.from_dict(dat)fordatindata['process_loads']]
+ returnnew_prop
+
+
+
+[docs]
+ defapply_properties_from_dict(self,abridged_data,construction_sets,
+ program_types,hvacs,shws,schedules):
+"""Apply properties from a Room2DEnergyPropertiesAbridged dictionary.
+
+ Args:
+ abridged_data: A Room2DEnergyPropertiesAbridged dictionary (typically
+ coming from a Model).
+ construction_sets: A dictionary of ConstructionSets with identifiers
+ of the sets as keys, which will be used to re-assign construction_sets.
+ program_types: A dictionary of ProgramTypes with identifiers of the
+ types ask keys, which will be used to re-assign program_types.
+ hvacs: A dictionary of HVACSystems with the identifiers of the
+ systems as keys, which will be used to re-assign hvac to the Room.
+ shws: A dictionary of SHWSystems with the identifiers of the systems as
+ keys, which will be used to re-assign shw to the Room.
+ schedules: A dictionary of Schedules with identifiers of the schedules as
+ keys, which will be used to re-assign schedules.
+ """
+ if'construction_set'inabridged_dataand \
+ abridged_data['construction_set']isnotNone:
+ self.construction_set=construction_sets[abridged_data['construction_set']]
+ if'program_type'inabridged_dataandabridged_data['program_type']isnotNone:
+ self.program_type=program_types[abridged_data['program_type']]
+ if'hvac'inabridged_dataandabridged_data['hvac']isnotNone:
+ self.hvac=hvacs[abridged_data['hvac']]
+ if'shw'inabridged_dataandabridged_data['shw']isnotNone:
+ self.shw=shws[abridged_data['shw']]
+ self._deserialize_window_vent(self,abridged_data,schedules)
+ if'process_loads'inabridged_dataand \
+ abridged_data['process_loads']isnotNone:
+ fordatinabridged_data['process_loads']:
+ ifdat['type']=='Process':
+ self._process_loads.append(Process.from_dict(dat))
+ else:
+ self._process_loads.append(
+ Process.from_dict_abridged(dat,schedules)
+ )
+
+
+
+[docs]
+ defto_dict(self,abridged=False):
+"""Return Room2D energy properties as a dictionary.
+
+ Args:
+ abridged: Boolean for whether the full dictionary of the Room2D should
+ be written (False) or just the identifier of the the individual
+ properties (True). Default: False.
+ """
+ base={'energy':{}}
+ base['energy']['type']='Room2DEnergyProperties'ifnot \
+ abridgedelse'Room2DEnergyPropertiesAbridged'
+
+ # write the ProgramType into the dictionary
+ ifself._program_typeisnotNone:
+ base['energy']['program_type']=self._program_type.identifierifabridged \
+ elseself._program_type.to_dict()
+
+ # write the ConstructionSet into the dictionary
+ ifself._construction_setisnotNone:
+ base['energy']['construction_set']= \
+ self._construction_set.identifierifabridgedelse \
+ self._construction_set.to_dict()
+
+ # write the hvac into the dictionary
+ ifself._hvacisnotNone:
+ base['energy']['hvac']= \
+ self._hvac.identifierifabridgedelseself._hvac.to_dict()
+
+ # write the shw into the dictionary
+ ifself._shwisnotNone:
+ base['energy']['shw']= \
+ self._shw.identifierifabridgedelseself._shw.to_dict()
+
+ # write the window_vent_control and window_vent_opening into the dictionary
+ ifself._window_vent_controlisnotNone:
+ base['energy']['window_vent_control']= \
+ self.window_vent_control.to_dict(abridged)
+ ifself._window_vent_openingisnotNone:
+ base['energy']['window_vent_opening']=self.window_vent_opening.to_dict()
+
+ # write the process_loads into the dictionary
+ iflen(self._process_loads)!=0:
+ base['energy']['process_loads']= \
+ [p.to_dict(abridged)forpinself._process_loads]
+
+ returnbase
+
+
+
+[docs]
+ defto_honeybee(self,new_host):
+"""Get a honeybee version of this object.
+
+ Args:
+ new_host: A honeybee-core Room object that will host these properties.
+ """
+ constr_set=self.construction_set# includes story and building-assigned sets
+ hb_constr=constr_setifconstr_setisnotgeneric_construction_setelseNone
+ hb_prop=RoomEnergyProperties(
+ new_host,self._program_type,hb_constr,self._hvac,self._shw)
+ ifself._window_vent_controlisnotNone:
+ hb_prop.window_vent_control=self.window_vent_control
+ ifself._window_vent_openingisnotNone:
+ forfaceinnew_host.faces:# set all apertures to be operable
+ forapinface.apertures:
+ ifisinstance(ap.boundary_condition,Outdoors):
+ ap.is_operable=True
+ hb_prop.assign_ventilation_opening(self.window_vent_opening)
+ iflen(self._process_loads)!=0:
+ hb_prop.process_loads=self.process_loads
+ returnhb_prop
+
+
+
+[docs]
+ deffrom_honeybee(self,hb_properties):
+"""Transfer energy attributes from a Honeybee Room to Dragonfly Room2D.
+
+ Args:
+ hb_properties: The RoomEnergyProperties of the honeybee Room that is being
+ translated to a Dragonfly Room2D.
+ """
+ self._program_type=hb_properties._program_type
+ self._construction_set=hb_properties._construction_set
+ self._hvac=hb_properties._hvac
+ self._shw=hb_properties._shw
+ self._process_loads=hb_properties._process_loads[:]# copy the list
+ ifhb_properties._window_vent_controlisnotNone:
+ self._window_vent_control=hb_properties._window_vent_control
+ forfaceinhb_properties.host.faces:
+ forapinface.apertures:
+ ifap.properties.energy.vent_openingisnotNone:
+ self._window_vent_opening=ap.properties.energy.vent_opening
+ break
+ ifself._window_vent_openingisnotNone:
+ break
+
+
+
+[docs]
+ defduplicate(self,new_host=None):
+"""Get a copy of this object.
+
+ Args:
+ new_host: A new Room2D object that hosts these properties.
+ If None, the properties will be duplicated with the same host.
+ """
+ _host=new_hostorself._host
+ hb_prop=Room2DEnergyProperties(
+ _host,self._program_type,self._construction_set,self._hvac,self._shw)
+ hb_prop._window_vent_control=self._window_vent_control
+ hb_prop._window_vent_opening=self._window_vent_opening
+ hb_prop._process_loads=self._process_loads[:]# copy process load list
+ returnhb_prop
+
+
+ @staticmethod
+ def_deserialize_window_vent(new_prop,data,schedules):
+"""Re-serialize window ventilation objects from a dict and apply to new_prop.
+
+ Args:
+ new_prop: A Room2DEnergyProperties to apply the window ventilation to.
+ data: A dictionary representation of Room2DEnergyProperties.
+ """
+ if'window_vent_control'indataanddata['window_vent_control']isnotNone:
+ wvc=data['window_vent_control']
+ new_prop.window_vent_control= \
+ VentilationControl.from_dict_abridged(wvc,schedules) \
+ ifwvc['type']=='VentilationControlAbridged'else \
+ VentilationControl.from_dict(wvc)
+ if'window_vent_opening'indataanddata['window_vent_opening']isnotNone:
+ new_prop.window_vent_opening= \
+ VentilationOpening.from_dict(data['window_vent_opening'])
+
+
+[docs]
+classStoryEnergyProperties(object):
+"""Energy Properties for Dragonfly Story.
+
+ Args:
+ host: A dragonfly_core Story object that hosts these properties.
+ construction_set: A honeybee ConstructionSet object to specify all
+ default constructions for the Faces of the Story. If None, the
+ Story will use the honeybee default construction set, which is not
+ representative of a particular building code or climate zone.
+ Default: None.
+
+ Properties:
+ * host
+ * construction_set
+ """
+
+ __slots__=('_host','_construction_set')
+
+ def__init__(self,host,construction_set=None):
+"""Initialize Story energy properties."""
+ self._host=host
+ self.construction_set=construction_set
+
+ @property
+ defhost(self):
+"""Get the Story object hosting these properties."""
+ returnself._host
+
+ @property
+ defconstruction_set(self):
+"""Get or set the Story ConstructionSet object.
+
+ If not set, it will be set by the parent Building or will be the Honeybee
+ default generic ConstructionSet.
+ """
+ ifself._construction_setisnotNone:# set by the user
+ returnself._construction_set
+ elifself._host.has_parent:# set by parent building
+ returnself._host.parent.properties.energy.construction_set
+ else:
+ returngeneric_construction_set
+
+ @construction_set.setter
+ defconstruction_set(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,ConstructionSet), \
+ 'Expected ConstructionSet. Got {}'.format(type(value))
+ value.lock()# lock in case construction set has multiple references
+ self._construction_set=value
+
+
+[docs]
+ defaveraged_program_type(self,identifier=None,timestep_resolution=1):
+"""Get a ProgramType that is averaged across all of the children Room2Ds.
+
+ The weights used in the averaging process are the floor area weights.
+
+ Args:
+ identifier: A unique ID text string for the new averaged ProgramType.
+ Must be < 100 characters and not contain any EnergyPlus special
+ characters. This will be used to identify the object across a model
+ and in the exported IDF. If None, the resulting ProgramType will
+ use the identifier of the host Building. (Default: None)
+ timestep_resolution: An optional integer for the timestep resolution
+ at which the schedules will be averaged. Any schedule details
+ smaller than this timestep will be lost in the averaging process.
+ Default: 1.
+ """
+ # get the default identifier of the ProgramType if None
+ identifier=identifierifidentifierisnotNoneelse \
+ '{}_Program'.format(self.host.identifier)
+
+ # compute the floor area weights
+ flr_areas=[room.floor_areaforroominself.host.room_2ds]
+ total_area=sum(flr_areas)
+ weights=[room_area/total_areaforroom_areainflr_areas]
+
+ # compute the averaged program
+ program_types=[room.properties.energy.program_type
+ forroominself.host.room_2ds]
+ returnProgramType.average(
+ identifier,program_types,weights,timestep_resolution)
+
+
+
+[docs]
+ defset_all_room_2d_program_type(self,program_type):
+"""Set all of the children Room2Ds of this Story to have the same ProgramType.
+
+ Args:
+ program_type: A ProgramType to assign to all children Room2Ds.
+ """
+ assertisinstance(program_type,ProgramType),'Expected ProgramType for Story ' \
+ 'set_all_room_2d_program_type. Got {}'.format(type(program_type))
+ forroom_2dinself.host.room_2ds:
+ room_2d.properties.energy.program_type=program_type
+
+
+
+[docs]
+ defset_all_room_2d_hvac(self,hvac,conditioned_only=True):
+"""Set all children Room2Ds of this Story to have the same HVAC system.
+
+ Args:
+ hvac: An HVAC system with properties that will be assigned to all
+ children Room2Ds.
+ conditioned_only: Boolean to note whether the input hvac should only
+ be applied to rooms that are already conditioned. If False, the
+ hvac will be applied to all rooms. (Default: True).
+ """
+ assertisinstance(hvac,_HVACSystem),'Expected HVACSystem for Story.' \
+ 'set_all_room_2d_hvac. Got {}'.format(type(hvac))
+
+ new_hvac=hvac.duplicate()
+ new_hvac._identifier='{}_{}'.format(hvac.identifier,self.host.identifier)
+ forroom_2dinself.host.room_2ds:
+ ifnotconditioned_onlyorroom_2d.properties.energy.is_conditioned:
+ room_2d.properties.energy.hvac=new_hvac
+
+
+
+[docs]
+ defadd_default_ideal_air(self):
+"""Add a default IdealAirSystem to all children Room2Ds of this Story.
+
+ The identifier of the systems will be derived from the room identifiers.
+ """
+ forroom_2dinself.host.room_2ds:
+ room_2d.properties.energy.add_default_ideal_air()
+
+
+
+[docs]
+ defset_all_room_2d_shw(self,shw):
+"""Set all children Room2Ds of this Story to have the same HVAC system.
+
+ Args:
+ shw: An HVAC system with properties that will be assigned to all
+ children Room2Ds.
+ """
+ assertisinstance(shw,SHWSystem),'Expected SHWSystem for Story.' \
+ 'set_all_room_2d_shw. Got {}'.format(type(shw))
+
+ new_shw=shw.duplicate()
+ new_shw._identifier='{}_{}'.format(shw.identifier,self.host.identifier)
+ forroom_2dinself.host.room_2ds:
+ room_2d.properties.energy.shw=new_shw
+
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data,host):
+"""Create StoryEnergyProperties from a dictionary.
+
+ Note that the dictionary must be a non-abridged version for this
+ classmethod to work.
+
+ Args:
+ data: A dictionary representation of StoryEnergyProperties.
+ host: A Story object that hosts these properties.
+ """
+ assertdata['type']=='StoryEnergyProperties', \
+ 'Expected StoryEnergyProperties. Got {}.'.format(data['type'])
+
+ new_prop=cls(host)
+ if'construction_set'indataanddata['construction_set']isnotNone:
+ new_prop.construction_set= \
+ ConstructionSet.from_dict(data['construction_set'])
+
+ returnnew_prop
+
+
+
+[docs]
+ defapply_properties_from_dict(self,abridged_data,construction_sets):
+"""Apply properties from a StoryEnergyPropertiesAbridged dictionary.
+
+ Args:
+ abridged_data: A StoryEnergyPropertiesAbridged dictionary (typically
+ coming from a Model).
+ construction_sets: A dictionary of ConstructionSets with identifiers
+ of the sets as keys, which will be used to re-assign construction_sets.
+ """
+ if'construction_set'inabridged_dataand \
+ abridged_data['construction_set']isnotNone:
+ self.construction_set=construction_sets[abridged_data['construction_set']]
+
+
+
+[docs]
+ defto_dict(self,abridged=False):
+"""Return Story energy properties as a dictionary.
+
+ Args:
+ abridged: Boolean for whether the full dictionary of the Story should
+ be written (False) or just the identifier of the the individual
+ properties (True). Default: False.
+ """
+ base={'energy':{}}
+ base['energy']['type']='StoryEnergyProperties'ifnot \
+ abridgedelse'StoryEnergyPropertiesAbridged'
+
+ # write the ConstructionSet into the dictionary
+ ifself._construction_setisnotNone:
+ base['energy']['construction_set']= \
+ self._construction_set.identifierifabridgedelse \
+ self._construction_set.to_dict()
+
+ returnbase
+
+
+
+[docs]
+ defduplicate(self,new_host=None):
+"""Get a copy of this object.
+
+ new_host: A new Story object that hosts these properties.
+ If None, the properties will be duplicated with the same host.
+ """
+ _host=new_hostorself._host
+ returnStoryEnergyProperties(_host,self._construction_set)
+[docs]
+classREoptParameter(object):
+"""Complete set of REopt Simulation Settings.
+
+ Args:
+ financial_parameter: A FinancialParameter object to describe the parameters
+ of the financial analysis. If None, a set of defaults will be
+ generated. (Default: None).
+ wind_parameter: A WindParameter object to set the cost and max amount of
+ wind to include in the analysis. If None, no wind will be included
+ in the analysis. (Default: None).
+ pv_parameter: A PVParameter object to set the cost and max amount of
+ photovoltaic to include in the analysis. If None, no PV will be included
+ in the analysis. (Default: None).
+ storage_parameter: A StorageParameter object to set the cost and max amount of
+ electricity storage to include in the analysis. If None, no storage
+ will be included in the analysis. (Default: None).
+ generator_parameter: A GeneratorParameter object to set the cost and max amount
+ of generators to include in the analysis. If None, no generators
+ will be included in the analysis. (Default: None).
+
+ Properties:
+ * financial_parameter
+ * wind_parameter
+ * pv_parameter
+ * storage_parameter
+ * generator_parameter
+ """
+ def__init__(self,financial_parameter=None,wind_parameter=None,pv_parameter=None,
+ storage_parameter=None,generator_parameter=None):
+"""Initialize SimulationParameter."""
+ self.financial_parameter=financial_parameter
+ self.wind_parameter=wind_parameter
+ self.pv_parameter=pv_parameter
+ self.storage_parameter=storage_parameter
+ self.generator_parameter=generator_parameter
+
+ @property
+ deffinancial_parameter(self):
+"""Get or set a FinancialParameter object for financial settings."""
+ returnself._financial_parameter
+
+ @financial_parameter.setter
+ deffinancial_parameter(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,FinancialParameter),'Expected ' \
+ 'FinancialParameter. Got {}.'.format(type(value))
+ self._financial_parameter=value
+ else:
+ self._financial_parameter=FinancialParameter()
+
+ @property
+ defwind_parameter(self):
+"""Get or set a WindParameter object for wind settings."""
+ returnself._wind_parameter
+
+ @wind_parameter.setter
+ defwind_parameter(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,WindParameter),'Expected ' \
+ 'WindParameter. Got {}.'.format(type(value))
+ self._wind_parameter=value
+ else:
+ self._wind_parameter=WindParameter()
+
+ @property
+ defpv_parameter(self):
+"""Get or set a PVParameter object for photovoltaic settings."""
+ returnself._pv_parameter
+
+ @pv_parameter.setter
+ defpv_parameter(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,PVParameter),'Expected ' \
+ 'PVParameter. Got {}.'.format(type(value))
+ self._pv_parameter=value
+ else:
+ self._pv_parameter=PVParameter()
+
+ @property
+ defstorage_parameter(self):
+"""Get or set a StorageParameter object for electricity storage settings."""
+ returnself._storage_parameter
+
+ @storage_parameter.setter
+ defstorage_parameter(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,StorageParameter),'Expected ' \
+ 'StorageParameter. Got {}.'.format(type(value))
+ self._storage_parameter=value
+ else:
+ self._storage_parameter=StorageParameter()
+
+ @property
+ defgenerator_parameter(self):
+"""Get or set a GeneratorParameter object for electricity storage settings."""
+ returnself._generator_parameter
+
+ @generator_parameter.setter
+ defgenerator_parameter(self,value):
+ ifvalueisnotNone:
+ assertisinstance(value,GeneratorParameter),'Expected ' \
+ 'GeneratorParameter. Got {}.'.format(type(value))
+ self._generator_parameter=value
+ else:
+ self._generator_parameter=GeneratorParameter()
+
+
+[docs]
+ defto_assumptions_dict(self,base_file,urdb_label):
+"""Get REoptParameter as a dictionary representation in the REopt Lite schema.
+
+ Full documentation of the REopt Lite schema can be found at.
+ https://developer.nrel.gov/docs/energy-optimization/reopt-v1/
+
+ Args:
+ base_file: A JSON file in the REopt Lite schema containing a base set
+ of assumptions that will be modified based on the properties of
+ this object.
+ urdb_label: Text string for the Utility Rate Database (URDB) label
+ for the particular electrical utility rate for the
+ optimization. The label is the last term of the URL of a
+ utility rate detail page (eg. the label for the rate at
+ https://openei.org/apps/IURDB/rate/view/5b0d83af5457a3f276733305
+ is 5b0d83af5457a3f276733305).
+ """
+ # load up the base dictionary
+ assertos.path.isfile(base_file), \
+ 'No base JSON file found at {}.'.format(base_file)
+ withopen(base_file,'r')asbase_f:
+ base_dict=json.load(base_f)
+ # apply this object's properties
+ site_dict=base_dict['Scenario']['Site']
+ site_dict['ElectricTariff']['urdb_label']=urdb_label
+ self.financial_parameter.apply_to_dict(site_dict['Financial'])
+ self.wind_parameter.apply_to_dict(site_dict['Wind'])
+ self.pv_parameter.apply_to_dict(site_dict['PV'])
+ self.storage_parameter.apply_to_dict(site_dict['Storage'])
+ self.generator_parameter.apply_to_dict(site_dict['Generator'])
+ returnbase_dict
+
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+[docs]
+classFinancialParameter(object):
+"""Complete set of Financial settings for REopt.
+
+ Args:
+ analysis_years: An integer for the number of years over which cost will
+ be optimized. (Default: 25).
+ escalation_rate: A number between 0 and 1 for the escalation rate over
+ the analysis. (Default: 0.023).
+ tax_rate: A number between 0 and 1 for the rate at which the owner/host
+ of the system is taxed. (Default: 0.26).
+ discount_rate: A number between 0 and 1 for the discount rate for the
+ owner/host of the system. (Default: 0.083).
+
+ Properties:
+ * analysis_years
+ * escalation_rate
+ * tax_rate
+ * discount_rate
+ """
+ def__init__(self,analysis_years=25,escalation_rate=0.023,
+ tax_rate=0.26,discount_rate=0.083):
+"""Initialize FinancialParameter."""
+ self.analysis_years=analysis_years
+ self.escalation_rate=escalation_rate
+ self.tax_rate=tax_rate
+ self.discount_rate=discount_rate
+
+ @property
+ defanalysis_years(self):
+"""Get or set a integer for the number of years to run the analysis."""
+ returnself._analysis_years
+
+ @analysis_years.setter
+ defanalysis_years(self,value):
+ self._analysis_years=int_positive(
+ value,input_name='financial parameter analysis years')
+
+ @property
+ defescalation_rate(self):
+"""Get or set a fractional number for the escalation rate."""
+ returnself._escalation_rate
+
+ @escalation_rate.setter
+ defescalation_rate(self,value):
+ self._escalation_rate=float_in_range(
+ value,0,1,input_name='financial parameter escalation rate')
+
+ @property
+ deftax_rate(self):
+"""Get or set a fractional number for the tax rate."""
+ returnself._tax_rate
+
+ @tax_rate.setter
+ deftax_rate(self,value):
+ self._tax_rate=float_in_range(
+ value,0,1,input_name='financial parameter tax rate')
+
+ @property
+ defdiscount_rate(self):
+"""Get or set a fractional number for the discount rate."""
+ returnself._discount_rate
+
+ @discount_rate.setter
+ defdiscount_rate(self,value):
+ self._discount_rate=float_in_range(
+ value,0,1,input_name='financial parameter discount rate')
+
+
+[docs]
+ defapply_to_dict(self,base_dict):
+"""Apply this object's properties to a 'Financial' object of REopt schema."""
+ base_dict['analysis_years']=self.analysis_years
+ base_dict['escalation_pct']=self.escalation_rate
+ base_dict['offtaker_tax_pct']=self.tax_rate
+ base_dict['offtaker_discount_pct']=self.discount_rate
+
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+
+
+
+class_SourceParameter(object):
+"""Base class for all REopt energy sources.
+
+ Args:
+ max_kw: A number for the maximum installed kilowatts of the energy
+ source. (Default: 0).
+ dollars_per_kw: A number for the installation cost of the energy source in
+ US dollars. (Default: 500).
+
+ Properties:
+ * max_kw
+ * dollars_per_kw
+ """
+ def__init__(self,max_kw=0,dollars_per_kw=500):
+ self.max_kw=max_kw
+ self.dollars_per_kw=dollars_per_kw
+
+ @property
+ defmax_kw(self):
+"""Get or set a number for the maximum installed kilowatts."""
+ returnself._max_kw
+
+ @max_kw.setter
+ defmax_kw(self,value):
+ self._max_kw=float_positive(value,input_name='reopt max kw')
+
+ @property
+ defdollars_per_kw(self):
+"""Get or set a number for the installation cost in US dollars."""
+ returnself._dollars_per_kw
+
+ @dollars_per_kw.setter
+ defdollars_per_kw(self,value):
+ self._dollars_per_kw=float_positive(value,input_name='reopt dollars per kw')
+
+ defapply_to_dict(self,base_dict):
+"""Apply this object's properties to an object of REopt schema."""
+ base_dict['max_kw']=self.max_kw
+ base_dict['installed_cost_us_dollars_per_kw']=self.dollars_per_kw
+
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+
+ def__copy__(self):
+ returnself.__class__(self.max_kw,self.dollars_per_kw)
+
+
+
+[docs]
+classWindParameter(_SourceParameter):
+"""Wind settings for REopt.
+
+ Args:
+ max_kw: A number for the maximum installed kilowatts. (Default: 0).
+ dollars_per_kw: A number for installation cost in US dollars. (Default: 3013).
+
+ Properties:
+ * max_kw
+ * dollars_per_kw
+ """
+ def__init__(self,max_kw=0,dollars_per_kw=3013):
+ _SourceParameter.__init__(self,max_kw,dollars_per_kw)
+
+
+[docs]
+classPVParameter(_SourceParameter):
+"""Photovoltaic settings for REopt.
+
+ Args:
+ max_kw: A number for the maximum installed kilowatts. (Default: 0).
+ dollars_per_kw: A number for installation cost in US dollars. (Default: 1600).
+
+ Properties:
+ * max_kw
+ * dollars_per_kw
+ * max_kw_ground
+ * dollars_per_kw_ground
+ """
+ def__init__(self,max_kw=0,dollars_per_kw=1600,
+ max_kw_ground=0,dollars_per_kw_ground=2200):
+ _SourceParameter.__init__(self,max_kw,dollars_per_kw)
+ self.max_kw_ground=max_kw_ground
+ self.dollars_per_kw_ground=dollars_per_kw_ground
+
+ @property
+ defmax_kw_ground(self):
+"""Get or set a number for the maximum installed kilowatts of Ground PV."""
+ returnself._max_kw_ground
+
+ @max_kw_ground.setter
+ defmax_kw_ground(self,value):
+ self._max_kw_ground=float_positive(value,input_name='reopt max kw')
+
+ @property
+ defdollars_per_kw_ground(self):
+"""Get or set a number for the installation cost of ground PV in US dollars."""
+ returnself._dollars_per_kw_ground
+
+ @dollars_per_kw_ground.setter
+ defdollars_per_kw_ground(self,value):
+ self._dollars_per_kw_ground= \
+ float_positive(value,input_name='reopt dollars per kw')
+
+
+[docs]
+ defapply_to_dict(self,base_dict):
+"""Apply this object's properties to an object of REopt schema."""
+ ifisinstance(base_dict,dict):
+ base_dict['max_kw']=self.max_kw
+ base_dict['installed_cost_us_dollars_per_kw']=self.dollars_per_kw
+ else:
+ base_dict[0]['max_kw']=self.max_kw
+ base_dict[0]['installed_cost_us_dollars_per_kw']=self.dollars_per_kw
+ base_dict[1]['max_kw']=self.max_kw_ground
+ base_dict[1]['installed_cost_us_dollars_per_kw']=self.dollars_per_kw_ground
+[docs]
+classStorageParameter(_SourceParameter):
+"""Electrical storage settings for REopt.
+
+ Args:
+ max_kw: A number for the maximum installed kilowatts. (Default: 0).
+ dollars_per_kw: A number for installation cost in US dollars. (Default: 840).
+
+ Properties:
+ * max_kw
+ * dollars_per_kw
+ """
+ def__init__(self,max_kw=0,dollars_per_kw=840):
+ _SourceParameter.__init__(self,max_kw,dollars_per_kw)
+
+
+[docs]
+classGeneratorParameter(_SourceParameter):
+"""Generator settings for REopt.
+
+ Args:
+ max_kw: A number for the maximum installed kilowatts. (Default: 0).
+ dollars_per_kw: A number for installation cost in US dollars. (Default: 500).
+
+ Properties:
+ * max_kw
+ * dollars_per_kw
+ """
+ def__init__(self,max_kw=0,dollars_per_kw=500):
+ _SourceParameter.__init__(self,max_kw,dollars_per_kw)
+
+
+[docs]
+classGroundMountPV(object):
+"""Represents a ground-mounted photovoltaic system in REopt.
+
+ Args:
+ identifier: Text string for a unique Photovoltaic ID. Must contain only
+ characters that are acceptable in REopt. This will be used to
+ identify the object across the exported geoJSON and REopt files.
+ geometry: A Polygon2D representing the geometry of the PV field.
+ building_identifier: An optional identifier of a dragonfly Building with
+ which the photovoltaic system is associated. If None, the PV system
+ will be assumed to be a community PV field that isn't associated with
+ a particular building meter. (Default: None).
+
+ Properties:
+ * identifier
+ * display_name
+ * geometry
+ * building_identifier
+ """
+ __slots__=('_identifier','_display_name','_geometry','_building_identifier')
+
+ def__init__(self,identifier,geometry,building_identifier=None):
+"""Initialize GroundMountPV."""
+ self.identifier=identifier
+ self._display_name=None
+ assertisinstance(geometry,Polygon2D),'Expected ladybug_geometry ' \
+ 'Polygon2D for GroundMountPV geometry. Got {}'.format(type(geometry))
+ self._geometry=geometry
+ self.building_identifier=building_identifier
+
+
+[docs]
+ @classmethod
+ deffrom_dict(cls,data):
+"""Initialize an GroundMountPV from a dictionary.
+
+ Args:
+ data: A dictionary representation of an GroundMountPV object.
+ """
+ # check the type of dictionary
+ assertdata['type']=='GroundMountPV','Expected GroundMountPV ' \
+ 'dictionary. Got {}.'.format(data['type'])
+ geo=Polygon2D.from_dict(data['geometry'])
+ pv_obj=cls(data['identifier'],geo)
+ if'display_name'indataanddata['display_name']isnotNone:
+ pv_obj.display_name=data['display_name']
+ if'building_identifier'indataanddata['building_identifier']isnotNone:
+ pv_obj.building_identifier=data['building_identifier']
+ returnpv_obj
+
+
+ @property
+ defidentifier(self):
+"""Get or set the text string for unique object identifier."""
+ returnself._identifier
+
+ @identifier.setter
+ defidentifier(self,identifier):
+ self._identifier=valid_ep_string(identifier,'identifier')
+
+ @property
+ defdisplay_name(self):
+"""Get or set a string for the object name without any character restrictions.
+
+ If not set, this will be equal to the identifier.
+ """
+ ifself._display_nameisNone:
+ returnself._identifier
+ returnself._display_name
+
+ @display_name.setter
+ defdisplay_name(self,value):
+ try:
+ self._display_name=str(value)
+ exceptUnicodeEncodeError:# Python 2 machine lacking the character set
+ self._display_name=value# keep it as unicode
+
+ @property
+ defbuilding_identifier(self):
+"""Get or set the text string for a Building associated with the PV field."""
+ returnself._building_identifier
+
+ @building_identifier.setter
+ defbuilding_identifier(self,identifier):
+ ifidentifierisnotNone:
+ identifier=valid_string(identifier,'building identifier')
+ self._building_identifier=identifier
+
+ @property
+ defgeometry(self):
+"""Get a Polygon2D representing the photovoltaic field."""
+ returnself._geometry
+
+
+[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.
+ """
+ self._geometry=self._geometry.move(Vector2D(moving_vec.x,moving_vec.y))
+
+
+
+[docs]
+ defrotate_xy(self,angle,origin):
+"""Rotate this object counterclockwise in the 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.
+ """
+ self._geometry=self._geometry.rotate(
+ math.radians(angle),Point2D(origin.x,origin.y))
+
+
+
+[docs]
+ defreflect(self,plane):
+"""Reflect this object across a plane.
+
+ Args:
+ plane: A ladybug_geometry Plane across which the object will be reflected.
+ """
+ assertplane.n.z==0, \
+ 'Plane normal must be in XY plane to use it on dragonfly object reflect.'
+ norm=Vector2D(plane.n.x,plane.n.y)
+ origin=Point2D(plane.o.x,plane.o.y)
+ self._geometry=self._geometry.reflect(norm,origin)
+
+
+
+[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).
+ """
+ ori=Point2D(origin.x,origin.y)iforiginisnotNoneelseNone
+ self._geometry=self._geometry.scale(factor,ori)
+[docs]
+ defto_geojson_dict(self,location,point):
+"""Get GroundMountPV dictionary as it appears in an URBANopt geoJSON.
+
+ Args:
+ location: A ladybug Location object possessing longitude and latitude data.
+ point: A ladybug_geometry Point2D for where the location object exists
+ within the space of a scene. The coordinates of this point are
+ expected to be in the units of this Model. (Default: (0, 0)).
+ """
+ # get the conversion factors over to (longitude, latitude)
+ origin_lon_lat=origin_long_lat_from_location(location,point)
+ convert_facs=meters_to_long_lat_factors(origin_lon_lat)
+
+ # create the GeoJSON dictionary
+ pts=[(pt.x,pt.y)forptinself.geometry.vertices]
+ coords=[polygon_to_lon_lat(pts,origin_lon_lat,convert_facs)]
+ base={
+ 'type':'Feature',
+ 'properties':{
+ 'id':self.identifier,
+ 'geometryType':'Rectangle',
+ 'name':self.display_name,
+ 'type':'District System',
+ 'footprint_area':self.geometry.area,
+ 'footprint_perimeter':self.geometry.perimeter
+ },
+ 'geometry':{
+ 'type':'Polygon',
+ 'coordinates':coords
+ }
+ }
+ ifself.building_identifierisNone:
+ base['properties']['district_system_type']='Community Photovoltaic'
+ else:
+ base['properties']['district_system_type']='Ground Mount Photovoltaic'
+ base['properties']['associated_building_id']=self.building_identifier
+ returnbase
+
+
+
+[docs]
+ defduplicate(self):
+"""Get a copy of this object."""
+ returnself.__copy__()
+# coding=utf-8
+"""Module for running geoJSON and OpenStudio files through URBANopt."""
+from__future__importdivision
+
+importos
+importjson
+importshutil
+importsubprocess
+
+fromladybug.futilimportpreparedir,write_to_file
+fromladybug.epwimportEPW
+fromladybug.configimportfoldersaslb_folders
+fromhoneybee.configimportfoldersashb_folders
+fromhoneybee_energy.configimportfoldersashb_energy_folders
+fromhoneybee_energy.result.emissionsimportemissions_region
+
+from.configimportfolders
+from.measureimportMapperMeasure
+from.reoptimportREoptParameter
+
+# Custom environment used to run Python packages without conflicts
+PYTHON_ENV=os.environ.copy()
+PYTHON_ENV['PYTHONHOME']=''
+
+# Number to prevent GHE Designer simulations that would max out the memory
+MAX_BOREHOLES=10000
+
+
+
+[docs]
+defbase_honeybee_osw(
+ project_directory,sim_par_json=None,additional_measures=None,
+ additional_mapper_measures=None,base_osw=None,epw_file=None,
+ skip_report=True,emissions_year=None):
+"""Create a honeybee_workflow.osw to be used as a base in URBANopt simulations.
+
+ This method will also copy the Honeybee.rb mapper to this folder if it is
+ available in the config of this library.
+
+ Args:
+ project_directory: Full path to a folder out of which the URBANopt simulation
+ will be run. This is the folder that contains the feature geoJSON.
+ sim_par_json: Optional file path to the SimulationParameter JSON.
+ If None, the OpenStudio models generated in the URBANopt run will
+ not have everything they need to be simulate-able unless such
+ parameters are supplied from one of the additional_measures or the
+ base_osw. (Default: None).
+ additional_measures: An optional array of honeybee-energy Measure objects
+ to be included in the output osw. These Measure objects must have
+ values for all required input arguments or an exception will be
+ raised while running this function. (Default: None).
+ additional_mapper_measures: An optional array of dragonfly-energy MapperMeasure
+ objects to be included in the output osw. These MapperMeasure objects
+ must have values for all required input arguments or an exception will
+ be raised while running this function. (Default: None).
+ base_osw: Optional file path to an existing OSW JSON be used as the base
+ for the honeybee_workflow.osw. This is another way that outside measures
+ can be incorporated into the workflow. (Default: None).
+ epw_file: Optional file path to an EPW that should be associated with the
+ output energy model. (Default: None).
+ skip_report: Set to True to have the URBANopt default feature reporting
+ measure skipped as part of the workflow. If False, the measure will
+ be run after all simulations are complete. Note that this input
+ has no effect if the default_feature_reports measure is already
+ in the base_osw or additional_measures. (Default: True).
+ emissions_year: An optional integer to set the year for which carbon emissions
+ will be computed. If not for a historical year, values must be an even
+ number and be between 2020 and 2050. If None, no carbon emission
+ calculations will be included in the simulation. (Default: None).
+
+ Returns:
+ The file path to the honeybee_workflow.osw written out by this method.
+ This is used as the base for translating all features in the geoJSON.
+ """
+ # create a dictionary representation of the .osw with steps to run
+ # the model measure and the simulation parameter measure
+ ifbase_oswisNone:
+ osw_dict={'steps':[],'name':None,'description':None}
+ else:
+ assertos.path.isfile(base_osw),'No base OSW file found at {}.'.format(base_osw)
+ withopen(base_osw,'r')asbase_file:
+ osw_dict=json.load(base_file)
+
+ # add a simulation parameter step if it is specified
+ ifsim_par_jsonisnotNone:
+ sim_par_dict={
+ 'arguments':{
+ 'simulation_parameter_json':sim_par_json
+ },
+ 'measure_dir_name':'from_honeybee_simulation_parameter'
+ }
+ osw_dict['steps'].insert(0,sim_par_dict)
+
+ # add the model json serialization into the steps
+ model_measure_dict={
+ 'arguments':{
+ 'model_json':'model_json_to_be_mapped.json'
+ },
+ 'measure_dir_name':'from_honeybee_model'
+ }
+ osw_dict['steps'].insert(0,model_measure_dict)
+
+ # assign the measure_paths to the osw_dict
+ if'measure_paths'notinosw_dict:
+ osw_dict['measure_paths']=[]
+ ifhb_energy_folders.honeybee_openstudio_gem_path:# add honeybee-openstudio measure
+ m_dir=os.path.join(hb_energy_folders.honeybee_openstudio_gem_path,'measures')
+ osw_dict['measure_paths'].append(m_dir)
+
+ # add the emissions reporting if a year has been selected
+ ifemissions_yearisnotNoneandepw_fileisnotNone:
+ epw_obj=EPW(epw_file)
+ ems_region=emissions_region(epw_obj.location)
+ ifems_regionisnotNone:
+ ifemissions_year<2020:
+ hist_yr,fut_yr=emissions_year,2030
+ else:
+ hist_yr,fut_yr=2019,emissions_year
+ emissions_measure_dict={
+ 'arguments':{
+ 'future_subregion':ems_region[0],
+ 'hourly_historical_subregion':ems_region[2],
+ 'annual_historical_subregion':ems_region[1],
+ 'future_year':str(fut_yr),
+ 'hourly_historical_year':'2019',
+ 'annual_historical_year':str(hist_yr)
+ },
+ 'measure_dir_name':'add_ems_emissions_reporting'
+ }
+ osw_dict['steps'].append(emissions_measure_dict)
+
+ # add any additional measures to the osw_dict
+ ifadditional_measuresoradditional_mapper_measures:
+ measures=[]
+ ifadditional_measuresisnotNone:
+ measures.extend(additional_measures)
+ ifadditional_mapper_measuresisnotNone:
+ measures.extend(additional_mapper_measures)
+ measure_paths=set()# set of all unique measure paths
+ # ensure measures are correctly ordered
+ m_dict={'ModelMeasure':[],'EnergyPlusMeasure':[],'ReportingMeasure':[]}
+ formeasureinmeasures:
+ m_dict[measure.type].append(measure)
+ sorted_measures=m_dict['ModelMeasure']+m_dict['EnergyPlusMeasure']+ \
+ m_dict['ReportingMeasure']
+ formeasureinsorted_measures:
+ measure.validate()# ensure that all required arguments have values
+ measure_paths.add(os.path.dirname(measure.folder))
+ osw_dict['steps'].append(measure.to_osw_dict())# add measure to workflow
+ ifisinstance(measure,MapperMeasure):
+ _add_mapper_measure(project_directory,measure)
+ form_pathinmeasure_paths:# add outside measure paths
+ osw_dict['measure_paths'].append(m_path)
+
+ # add default feature reports if they aren't in the steps
+ all_measures=[step['measure_dir_name']forstepinosw_dict['steps']]
+ if'default_feature_reports'notinall_measures:
+ report_measure_dict={
+ 'arguments':{
+ 'feature_id':None,
+ 'feature_name':None,
+ 'feature_type':None,
+ 'feature_location':None
+ },
+ 'measure_dir_name':'default_feature_reports'
+ }
+ ifskip_report:
+ report_measure_dict['arguments']['__SKIP__']=True
+ osw_dict['steps'].append(report_measure_dict)
+
+ # if there is a system parameter JSON, make sure the EPW is copied and referenced
+ ifepw_fileisnotNone:
+ osw_dict['weather_file']=epw_file
+ sys_param_file=os.path.join(project_directory,'system_params.json')
+ ifos.path.isfile(sys_param_file):
+ # make sure the Modelica measure runs as part of the simulation
+ modelica_measures=[
+ {
+ 'measure_dir_name':'export_time_series_modelica',
+ 'arguments':{'__SKIP__':False}
+ },
+ {
+ 'measure_dir_name':'export_modelica_loads',
+ 'arguments':{'__SKIP__':False}
+ },
+ ]
+ osw_dict['steps'].extend(modelica_measures)
+
+ # copy the EPW to the project directory
+ epw_f_name=os.path.split(epw_file)[-1]
+ target_epw=os.path.join(project_directory,epw_f_name)
+ shutil.copy(epw_file,target_epw)
+ # create a MOS file from the EPW
+ epw_obj=EPW(target_epw)
+ mos_file=os.path.join(
+ project_directory,epw_f_name.replace('.epw','.mos'))
+ epw_obj.to_mos(mos_file)
+ # find the path to the feature GeoJSON
+ feature_geojson=None
+ forfpinos.listdir(project_directory):
+ iffp.endswith('.geojson'):
+ feature_geojson=os.path.join(project_directory,fp)
+ break
+ ifnotfeature_geojson:
+ raiseValueError(
+ 'No feature geojson file was found in: {}'.format(project_directory))
+ # write the EPW path into the GeoJSON
+ withopen(feature_geojson,'r')asgjf:
+ geo_dict=json.load(gjf)
+ if'project'ingeo_dict:
+ if'weather_filename'notingeo_dict['project']:
+ geo_dict['project']['weather_filename']=epw_f_name
+ withopen(feature_geojson,'w')asfp:
+ json.dump(geo_dict,fp,indent=4)
+
+ # if the DES system is GSHP, specify any autocalculated ground temperatures
+ withopen(sys_param_file,'r')asspf:
+ sys_dict=json.load(spf)
+ if'district_system'insys_dict:
+ if'fifth_generation'insys_dict['district_system']:
+ g5_par=sys_dict['district_system']['fifth_generation']
+ if'ghe_parameters'ing5_par:
+ ghe_par=g5_par['ghe_parameters']
+ if'soil'inghe_parand'undisturbed_temp'inghe_par['soil']:
+ soil_par=ghe_par['soil']
+ ifsoil_par['undisturbed_temp']=='Autocalculate':
+ epw_obj=EPW(epw_file)
+ soil_par['undisturbed_temp']= \
+ epw_obj.dry_bulb_temperature.average
+ withopen(sys_param_file,'w')asfp:
+ json.dump(sys_dict,fp,indent=4)
+
+ # write the dictionary to a honeybee_workflow.osw
+ mappers_dir=os.path.join(project_directory,'mappers')
+ ifnotos.path.isdir(mappers_dir):
+ preparedir(mappers_dir)
+ osw_json=os.path.join(mappers_dir,'honeybee_workflow.osw')
+ withopen(osw_json,'w')asfp:
+ json.dump(osw_dict,fp,indent=4)
+
+ # copy the Honeybee.rb mapper if it exists in the config
+ iffolders.mapper_path:
+ shutil.copy(folders.mapper_path,os.path.join(mappers_dir,'Honeybee.rb'))
+
+ returnos.path.abspath(osw_json)
+
+
+
+
+[docs]
+defprepare_urbanopt_folder(feature_geojson,cpu_count=None,verbose=False):
+"""Prepare a directory with a feature geoJSON for URBANopt simulation.
+
+ This includes copying the Gemfile to the folder and generating the runner.conf
+ to specify the number of CPUs to be used in the simulation. Lastly, the
+ the scenario .csv file will be generated from the feature_geojson.
+
+ Args:
+ feature_geojson: An URBANopt feature geoJSON to be prepared for URBANopt
+ simulation.
+ cpu_count: A positive integer for the number of CPUs to use in the
+ simulation. This number should not exceed the number of CPUs on the
+ machine running the simulation and should be lower if other tasks
+ are running while the simulation is running. If set to None, it
+ should automatically default to one less than the number of CPUs
+ currently available on the machine (or 1 if the machine has only
+ one processor). (Default: None).
+ verbose: Boolean to note if the simulation should be run with verbose
+ reporting of progress. (Default: False).
+
+ Returns:
+ Path to the .csv file for the URBANopt scenario.
+ """
+ # copy the Gemfile into the folder containing the feature_geojson
+ assertfolders.urbanopt_gemfile_path, \
+ 'No URBANopt Gemfile was found in dragonfly_energy.config.folders.\n' \
+ 'This file must exist to run URBANopt.'
+ folders.check_urbanopt_version()
+ uo_folder=os.path.dirname(feature_geojson)
+ shutil.copy(folders.urbanopt_gemfile_path,os.path.join(uo_folder,'Gemfile'))
+
+ # auto-assign the number of processors if None
+ cpu_count=_recommended_processor_count()ifcpu_countisNoneelsecpu_count
+
+ # generate the runner.conf to set the number of CPUs based on the input
+ runner_dict={
+ 'file_version':'0.1.0',
+ 'max_datapoints':1000000000,
+ 'num_parallel':cpu_count,
+ 'run_simulations':True,
+ 'verbose':verbose
+ }
+ runner_conf=os.path.join(uo_folder,'runner.conf')
+ withopen(runner_conf,'w')asfp:
+ json.dump(runner_dict,fp,indent=2)
+
+ # generate the scenario csv file
+ return_make_scenario(feature_geojson)
+
+
+
+
+[docs]
+defrun_urbanopt(feature_geojson,scenario_csv,cpu_count=None):
+"""Run a feature and scenario file through URBANopt on any operating system.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+ cpu_count: This input is deprecated and currently not used given that
+ the runner.conf generated in the prepare_urbanopt_folder step
+ correctly identifies the number of CPUs to be used.
+
+ Returns:
+ A series of file paths to the simulation output files
+
+ - osm -- Array of paths to .osm files for all generated OpenStudio models.
+
+ - idf -- Array of paths to .idf files containing the input for the
+ EnergyPlus simulation.
+
+ - sql -- Array of paths to .sqlite files containing all simulation results.
+
+ - zsz -- Array of paths to .csv files containing detailed zone load
+ information recorded over the course of the design days.
+
+ - rdd -- Array of paths to .rdd files containing all possible outputs
+ that can be requested from the simulation.
+
+ - html -- Array of paths to .html files containing all summary reports.
+
+ - err -- Array of paths to .err files containing all errors and warnings
+ from the simulation.
+ """
+ folders.check_urbanopt_version()
+ # run the simulation
+ ifos.name=='nt':# we are on Windows
+ directory,stderr= \
+ _run_urbanopt_windows(feature_geojson,scenario_csv)
+ else:# we are on Mac, Linux, or some other unix-based system
+ directory,stderr= \
+ _run_urbanopt_unix(feature_geojson,scenario_csv)
+
+ # output the simulation files
+ return_output_urbanopt_files(directory,stderr)
+
+
+
+
+[docs]
+defrun_default_report(feature_geojson,scenario_csv):
+"""Generate default reports after an URBANopt simulation is run.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ A series of file paths to the report output files
+
+ - csv -- Path to a CSV file containing default scenario results.
+
+ - report_json -- Path to a JSON file containing default scenario results.
+ """
+ folders.check_urbanopt_version()
+ assertos.path.isfile(feature_geojson), \
+ 'No feature_geojson as found at the specified path: {}.'.format(feature_geojson)
+ assertos.path.isfile(scenario_csv), \
+ 'No scenario_csv as found at the specified path: {}.'.format(scenario_csv)
+ # run the report command
+ ifos.name=='nt':# we are on Windows
+ return_run_default_report_windows(feature_geojson,scenario_csv)
+ else:# we are on Mac, Linux, or some other unix-based system
+ return_run_default_report_unix(feature_geojson,scenario_csv)
+
+
+
+
+[docs]
+defrun_reopt(feature_geojson,scenario_csv,urdb_label,reopt_parameters=None,
+ developer_key=None):
+"""Run a feature and scenario file through REopt post processing.
+
+ Note that the URBANopt simulation must already be run with the input feature_geojson
+ and scenario_csv in order for the post-processing to be successful.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+ urdb_label: Text string for the Utility Rate Database (URDB) label for the
+ particular electrical utility rate for the optimization. The label is
+ the last term of the URL of a utility rate detail page (eg. the label for
+ the rate at https://openei.org/apps/IURDB/rate/view/5b0d83af5457a3f276733305
+ is 5b0d83af5457a3f276733305). Utility rates for specific locations
+ can be looked up in the REopt Lite tool (https://reopt.nrel.gov/tool)
+ and the label can be obtained by clicking on "Rate Details" link
+ for a particular selected rate.
+ reopt_parameters: A REoptParameter object to describe the major assumptions
+ of the REopt analysis. If None some default parameters will be
+ generated for a typical analysis. (Default: None).
+ developer_key: Text string for the NREL developer key. You can get a developer
+ key at (https://developer.nrel.gov/). (Default: None).
+
+ Returns:
+ A series of file paths to the simulation output files
+
+ - csv -- Path to a CSV file containing scenario optimization results.
+
+ - report_json -- Path to a JSON file containing scenario optimization results.
+ """
+ # run checks on the inputs
+ folders.check_urbanopt_version()
+ assertfolders.reopt_assumptions_path, \
+ 'No REopt assumptions were found in dragonfly_energy.config.folders.'
+ assertos.path.isfile(feature_geojson), \
+ 'No feature_geojson as found at the specified path: {}.'.format(feature_geojson)
+ assertos.path.isfile(scenario_csv), \
+ 'No scenario_csv as found at the specified path: {}.'.format(scenario_csv)
+ developer_key=developer_keyifdeveloper_keyisnotNone \
+ else'bo8jGuFfk7DBDpTlzShuxWuAGletBq1j5AhcUhCD'
+ project_folder=os.path.dirname(feature_geojson)
+
+ # write the parameter file
+ ifreopt_parametersisNone:# generate some defaults
+ reopt_parameters=REoptParameter()
+ reopt_parameters.pv_parameter.max_kw=1000000000
+ reopt_parameters.storage_parameter.max_kw=1000000
+ reopt_parameters.generator_parameter.max_kw=1000000000
+ else:
+ assertisinstance(reopt_parameters,REoptParameter), \
+ 'Expected REoptParameter. Got {}.'.format(type(reopt_parameters))
+ reopt_folder=os.path.join(project_folder,'reopt')
+ ifnotos.path.isdir(reopt_folder):
+ os.mkdir(reopt_folder)
+ reopt_par_json=os.path.join(reopt_folder,'reopt_assumptions.json')
+ reopt_dict=reopt_parameters.to_assumptions_dict(
+ folders.reopt_assumptions_path,urdb_label)
+ withopen(reopt_par_json,'w')asfp:
+ json.dump(reopt_dict,fp,indent=4)
+
+ # run the simulation
+ ifos.name=='nt':# we are on Windows
+ directory=_run_reopt_windows(feature_geojson,scenario_csv,developer_key)
+ else:# we are on Mac, Linux, or some other unix-based system
+ directory=_run_reopt_unix(feature_geojson,scenario_csv,developer_key)
+
+ # output the simulation files
+ return_output_reopt_files(directory)
+
+
+
+
+[docs]
+defrun_rnm(feature_geojson,scenario_csv,underground_ratio=0.9,lv_only=True,
+ nodes_per_building=1):
+"""Run a feature and scenario file through RNM post processing.
+
+ Note that the URBANopt simulation must already be run with the input feature_geojson
+ and scenario_csv in order for the RNM post-processing to be successful.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+ underground_ratio: A number between 0 and 1 for the ratio of overall cables
+ that are underground vs. overhead in the analysis. (Default: 0.9).
+ lv_only: Boolean to note whether to consider only low voltage consumers
+ in the analysis. (Default: True).
+ nodes_per_building: Positive integer for the maximum number of low voltage
+ nodes to represent a single building. (Default: 1).
+
+ Returns:
+ Path to a folder that contains all of the RNM output files.
+ """
+ # load the information from the GeoJSON
+ geo_dict,project_dict=None,None
+ ifos.path.isfile(feature_geojson):
+ withopen(feature_geojson,'r')asfg:
+ geo_dict=json.load(fg)
+ project_dict=geo_dict['project']
+ # change the GeoJSON to have the RNM inputs
+ ifgeo_dictisnotNone:
+ proj=geo_dict['project']
+ if'underground_cables_ratio'notinprojor \
+ proj['underground_cables_ratio']!=underground_ratioor \
+ 'only_lv_consumers'notinprojor \
+ proj['only_lv_consumers']!=lv_onlyor \
+ 'max_number_of_lv_nodes_per_building'notinprojor \
+ proj['max_number_of_lv_nodes_per_building']!=nodes_per_building:
+ geo_dict['project']['underground_cables_ratio']=underground_ratio
+ geo_dict['project']['only_lv_consumers']=lv_only
+ geo_dict['project']['max_number_of_lv_nodes_per_building']= \
+ nodes_per_building
+ withopen(feature_geojson,'w')asfp:
+ json.dump(geo_dict,fp,indent=4)
+ # run the simulation
+ folders.check_urbanopt_version()
+ ifos.name=='nt':# we are on Windows
+ directory=_run_rnm_windows(feature_geojson,scenario_csv)
+ else:# we are on Mac, Linux, or some other unix-based system
+ directory=_run_rnm_unix(feature_geojson,scenario_csv)
+ # get the path to the results folder
+ scenario_name=os.path.basename(scenario_csv).replace('.csv','')
+ rnm_path=os.path.join(directory,'run',scenario_name,'rnm-us','results')
+ # copy the project information into the RNM GeoJSON
+ ifos.path.isdir(rnm_path):
+ rnm_geojson=os.path.join(rnm_path,'GeoJSON','Distribution_system.json')
+ withopen(rnm_geojson,'r')asfg:
+ rnm_dict=json.load(fg)
+ rnm_dict['project']=project_dict
+ withopen(rnm_geojson,'w')asfp:
+ json.dump(rnm_dict,fp,indent=4)
+ returnrnm_path
+
+
+
+
+[docs]
+defrun_des_sys_param(feature_geojson,scenario_csv):
+"""Run the GMT command to add the time series building loads to the sys param JSON.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+ """
+ # get the directory and parse the system parameter file
+ directory=os.path.dirname(feature_geojson)
+ sys_param_file=os.path.join(directory,'system_params.json')
+ assertos.path.isfile(sys_param_file), \
+ 'No DES system parameter was found for this model.\n' \
+ 'Make sure that the des_loop_ was assigned in the GeoJSON export\n' \
+ 'before running the URBANopt simulation.'
+
+ # parse the system parameter file to understand the type of system
+ withopen(sys_param_file,'r')asspf:
+ sp_dict=json.load(spf)
+ des_dict=sp_dict['district_system']
+ ghe_sys=Trueif'fifth_generation'indes_dictand \
+ 'ghe_parameters'indes_dict['fifth_generation']elseFalse
+
+ # run the command that adds the building loads to the system parameter
+ ext='.exe'ifos.name=='nt'else''
+ shell=Trueifos.name=='nt'elseFalse
+ uo_des_exe=os.path.join(
+ hb_folders.python_scripts_path,'uo_des{}'.format(ext))
+ build_cmd='"{des_exe}" build-sys-param "{sp_file}" "{scenario}" "{feature}" ' \
+ 'time_series -o'.format(
+ des_exe=uo_des_exe,sp_file=sys_param_file,
+ scenario=scenario_csv,feature=feature_geojson)
+ ifghe_sys:
+ build_cmd='{} --ghe'.format(build_cmd)
+ process=subprocess.Popen(
+ build_cmd,stderr=subprocess.PIPE,shell=shell,env=PYTHON_ENV
+ )
+ stderr=process.communicate()
+ ifnotos.path.isfile(sys_param_file):
+ msg='Failed to add building loads to the DES system parameter file.\n' \
+ 'No file found at:\n{}\n{}'.format(sys_param_file,stderr[1])
+ print(msg)
+ raiseException(msg)
+ else:
+ print(stderr[1])
+
+ # after the loads have been added, put pack the properties of the DES
+ withopen(sys_param_file,'r')asspf:
+ sp_dict=json.load(spf)
+ ifghe_sys:
+ original_ghe_par=des_dict['fifth_generation']['ghe_parameters']
+ ghe_par=sp_dict['district_system']['fifth_generation']['ghe_parameters']
+ ghe_par['fluid']=original_ghe_par['fluid']
+ ghe_par['grout']=original_ghe_par['grout']
+ ghe_par['soil']=original_ghe_par['soil']
+ ghe_par['pipe']=original_ghe_par['pipe']
+ ghe_par['geometric_constraints']=original_ghe_par['geometric_constraints']
+ ghe_par['ghe_specific_params']=original_ghe_par['ghe_specific_params']
+ else:
+ sp_dict['district_system']=des_dict
+ withopen(sys_param_file,'w')asspf:
+ json.dump(sp_dict,spf,indent=2)
+
+ # if the DES system has a ground heat exchanger, run the thermal network package
+ ifghe_sys:
+ # check to be sure the user will not max out their RAM
+ total_area=0
+ forghe_spinghe_par['ghe_specific_params']:
+ ghe_len=ghe_sp['ghe_geometric_params']['length_of_ghe']
+ ghe_wth=ghe_sp['ghe_geometric_params']['width_of_ghe']
+ total_area+=ghe_len*ghe_wth
+ bh_count=int(total_area/(ghe_par['geometric_constraints']['b_min']**2))
+ ifbh_count>MAX_BOREHOLES:
+ msg='The inputs suggest that there may be as many as {} boreholes in the ' \
+ 'GHE field\nand this will cause your machine to run out of memory.\n' \
+ 'A smaller GHE field or a larger minimum borehole spacing is needed ' \
+ 'such that fewer\nthan {} boreholes are generated and the sizing ' \
+ 'simulation can succeed.'.format(bh_count,MAX_BOREHOLES)
+ raiseValueError(msg)
+ # run the GHE Designer to size the system
+ tn_exe=os.path.join(
+ hb_folders.python_scripts_path,'thermalnetwork{}'.format(ext))
+ scn_name=os.path.basename(scenario_csv).replace('.csv','')
+ scn_dir=os.path.join(directory,'run',scn_name)
+ ghe_dir=os.path.join(scn_dir,'ghe_dir')
+ build_cmd= \
+ '"{tn_exe}" -y "{sp_file}" -s "{scenario}" -f "{feature}" -o {out_p}'.format(
+ tn_exe=tn_exe,sp_file=sys_param_file,
+ scenario=scn_dir,feature=feature_geojson,out_p=ghe_dir)
+ process=subprocess.Popen(
+ build_cmd,stderr=subprocess.PIPE,shell=False,env=PYTHON_ENV
+ )
+ # if any errors were found in the sizing simulation, raise them to the user
+ stderr=process.communicate()[1]
+ stderr_str=str(stderr.strip())
+ print(stderr_str)
+ if'ValueError'instderr_str:# pass the exception onto the user
+ msg=stderr_str.split('ValueError: ')[-1].strip()
+ raiseValueError(msg)
+ # add the borehole length and count to the system parameter file
+ withopen(sys_param_file,'r')asspf:
+ sp_dict=json.load(spf)
+ ghe_par_dict=sp_dict['district_system']['fifth_generation']['ghe_parameters']
+ forghe_s_paringhe_par_dict['ghe_specific_params']:
+ r_dir=ghe_par['ghe_dir']
+ res_file=os.path.join(r_dir,ghe_s_par['ghe_id'],'SimulationSummary.json')
+ withopen(res_file,'r')asrf:
+ res_dict=json.load(rf)
+ ghe_s_par['borehole']['length_of_boreholes']= \
+ res_dict['ghe_system']['active_borehole_length']['value']
+ ghe_s_par['borehole']['number_of_boreholes']= \
+ res_dict['ghe_system']['number_of_boreholes']
+ withopen(sys_param_file,'w')asspf:
+ json.dump(sp_dict,spf,indent=2)
+ returnsys_param_file
+
+
+
+
+[docs]
+defrun_des_modelica(sys_param_json,feature_geojson,scenario_csv):
+"""Run the GMT command to create the Modelica files from the system param JSON.
+
+ Args:
+ sys_param_json: The full path to a system parameter JSON from which the
+ Modelica files will be generated.
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ The path to the folder where the Modelica files have been written.
+ """
+ # run the simulation
+ ifos.name=='nt':# we are on Windows
+ modelica_dir,stderr= \
+ _generate_modelica_windows(sys_param_json,feature_geojson,scenario_csv)
+ else:# we are on Mac, Linux, or some other unix-based system
+ modelica_dir,stderr= \
+ _generate_modelica_unix(sys_param_json,feature_geojson,scenario_csv)
+ ifnotos.path.isdir(modelica_dir):
+ msg='Failed to translate DES to Modelica.\n' \
+ 'No results were found at:\n{}\n{}'.format(modelica_dir,stderr)
+ print(msg)
+ raiseException(msg)
+ else:
+ _add_water_heating_patch(modelica_dir)
+ returnmodelica_dir
+
+
+
+
+[docs]
+defrun_modelica_docker(modelica_project_dir):
+"""Execute Modelica files of a DES.
+
+ Args:
+ modelica_project_dir: The full path to the folder in which the Modelica
+ files were written.
+
+ Returns:
+ The path to where the results have been written.
+ """
+ # run the simulation
+ ifos.name=='nt':# we are on Windows
+ modelica_dir,stderr=_run_modelica_windows(modelica_project_dir)
+ else:# we are on Mac, Linux, or some other unix-based system
+ modelica_dir,stderr=_run_modelica_unix(modelica_project_dir)
+ ifnotos.path.isdir(modelica_dir):
+ msg='Failed to execute Modelica simulation.\n' \
+ 'No results were found at:\n{}\n{}'.format(modelica_dir,stderr)
+ print(msg)
+ raiseException(msg)
+ returnmodelica_dir
+
+
+
+def_add_mapper_measure(project_directory,mapper_measure):
+"""Add mapper measure arguments to a geoJSON and the mapper_measures.json.
+
+ Args:
+ project_directory: Full path to a folder out of which the URBANopt simulation
+ will be run. This is the folder that contains the feature geoJSON.
+ mapper_measure: A MapperMeasure object to add.
+ """
+ # find the feature geoJSON and parse in the dictionary
+ forproj_fileinos.listdir(project_directory):
+ ifproj_file.endswith('geojson'):
+ geojson_file=os.path.join(project_directory,proj_file)
+ break
+ withopen(geojson_file,'r')asbase_file:
+ geojson_dict=json.load(base_file)
+
+ # find or start the mapper_measures.json
+ mapper_dir=os.path.join(project_directory,'mappers')
+ map_meas_file=os.path.join(mapper_dir,'mapper_measures.json')
+ ifos.path.isfile(map_meas_file):
+ withopen(map_meas_file,'r')asbase_file:
+ map_meas_list=json.load(base_file)
+ else:
+ map_meas_list=[]
+
+ # loop through the mapper measure and assign any mapper arguments
+ form_arginmapper_measure.arguments:
+ ifisinstance(m_arg.value,tuple):# argument to map to buildings
+ fori,featinenumerate(geojson_dict['features']):
+ try:
+ iffeat['properties']['type']=='Building':
+ feat['properties'][m_arg.identifier]=m_arg.value[i]
+ exceptIndexError:
+ raiseValueError(
+ 'Number of MapperMeasure arguments ({}) does not equal the '
+ 'number of buildings in the model ({}).'.format(
+ len(m_arg.value),len(geojson_dict['features'])))
+ exceptKeyError:# definitely not a building
+ pass
+ m_arg_info=[
+ os.path.basename(mapper_measure.folder),
+ m_arg.identifier,m_arg.identifier]
+ map_meas_list.append(m_arg_info)
+
+ # write the geoJSON and the mapper_measures.json
+ ifnotos.path.isdir(mapper_dir):
+ os.mkdir(mapper_dir)
+ withopen(geojson_file,'w')asfp:
+ json.dump(geojson_dict,fp,indent=4)
+ withopen(map_meas_file,'w')asfp:
+ json.dump(map_meas_list,fp,indent=4)
+
+
+def_make_scenario(feature_geojson):
+"""Generate a scenario CSV file for URBANopt simulation.
+
+ Args:
+ feature_geojson: The full path to a .geojson file.
+ """
+ # load the geoJSON to a dictionary
+ withopen(feature_geojson,'r')asbase_file:
+ geo_dict=json.load(base_file)
+
+ # loop through the building features and add them to the CSV
+ scenario_matrix=[['Feature Id','Feature Name','Mapper Class']]
+ hb_mapper='URBANopt::Scenario::HoneybeeMapper'
+ forfeatureingeo_dict['features']:
+ try:
+ iffeature['properties']['type']=='Building':
+ props=feature['properties']
+ f_row=[props['id'],props['name'],hb_mapper]
+ scenario_matrix.append(f_row)
+ exceptKeyError:# definitely not a building
+ pass
+
+ # write the scenario CSV file
+ uo_folder=os.path.dirname(feature_geojson)
+ scenario=os.path.join(uo_folder,'honeybee_scenario.csv')
+ withopen(scenario,'w')asfp:
+ forrowinscenario_matrix:
+ fp.write('{}\n'.format(','.join(row)))
+ returnscenario
+
+
+def_recommended_processor_count():
+"""Get an integer for one less than the number of processors on this machine.
+
+ This method should work on all of the major operating systems and in
+ both IronPython and cPython. If, for whatever reason, the number of
+ processors could not be sensed, a value of 1 will be returned.
+ """
+ try:# assume that we are in cPython
+ cpu_count=os.cpu_count()
+ exceptAttributeError:# we are probably in IronPython
+ try:
+ fromSystem.EnvironmentimportProcessorCount
+ cpu_count=ProcessorCount
+ exceptImportError:# no idea what Python this is; let's play it safe
+ cpu_count=1
+ return1ifcpu_countisNoneorcpu_count<=1elsecpu_count-1
+
+
+def_run_urbanopt_windows(feature_geojson,scenario_csv):
+"""Run a feature and scenario file through URBANopt on a Windows-based os.
+
+ A batch file will be used to run the simulation.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ A tuple with two values.
+
+ - directory -- Path to the folder out of which the simulation was run.
+
+ - stderr -- The standard error message, which should get to the user
+ in the event of simulation failure.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # Write the batch file to call URBANopt CLI
+ working_drive=directory[:2]
+ batch='{}\ncd {}\ncall "{}"\nuo run -f "{}" -s "{}"'.format(
+ working_drive,working_drive,folders.urbanopt_env_path,
+ feature_geojson,scenario_csv)
+ batch_file=os.path.join(directory,'run_simulation.bat')
+ write_to_file(batch_file,batch,True)
+ # run the batch file
+ process=subprocess.Popen(
+ '"{}"'.format(batch_file),stderr=subprocess.PIPE,env=PYTHON_ENV
+ )
+ result=process.communicate()
+ stderr=result[1]
+ returndirectory,stderr
+
+
+def_run_urbanopt_unix(feature_geojson,scenario_csv):
+"""Run a feature and scenario file through URBANopt on a Unix-based os.
+
+ This includes both Mac OS and Linux since a shell will be used to run
+ the simulation.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ A tuple with two values.
+
+ - directory -- Path to the folder out of which the simulation was run.
+
+ - stderr -- The standard error message, which should get to the user
+ in the event of simulation failure.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # Write the shell script to call URBANopt CLI
+ shell='#!/usr/bin/env bash\nsource "{}"\nuo run -f "{}" -s "{}"'.format(
+ folders.urbanopt_env_path,feature_geojson,scenario_csv)
+ shell_file=os.path.join(directory,'run_simulation.sh')
+ write_to_file(shell_file,shell,True)
+ # make the shell script executable using subprocess.check_call
+ # this is more reliable than native Python chmod on Mac
+ subprocess.check_call(['chmod','u+x',shell_file])
+ # run the shell script
+ process=subprocess.Popen(
+ '"{}"'.format(shell_file),stderr=subprocess.PIPE,env=PYTHON_ENV,shell=True
+ )
+ result=process.communicate()
+ stderr=result[1]
+ returndirectory,stderr
+
+
+def_check_urbanopt_file(feature_geojson,scenario_csv):
+"""Prepare an OSW file to be run through URBANopt CLI.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ The folder in which the OSW exists and out of which the OpenStudio CLI
+ will operate.
+ """
+ # check the input files
+ assertos.path.isfile(feature_geojson), \
+ 'No feature file found at {}.'.format(feature_geojson)
+ assertos.path.isfile(scenario_csv), \
+ 'No scenario file found at {}.'.format(scenario_csv)
+ returnos.path.split(feature_geojson)[0]
+
+
+def_output_urbanopt_files(directory,stderr=''):
+"""Get the paths to the simulation output files given the urbanopt directory.
+
+ Args:
+ directory: The path to where the URBANopt feature and scenario files
+ were simulated.
+ stderr: The URBANopt standard error message, which will be returned to
+ the user in the event that no simulation folder was found.
+
+ Returns:
+ A series of file paths to the simulation output files
+
+ - osm -- Array of paths to .osm files for all generated OpenStudio models.
+
+ - idf -- Array of paths to .idf files containing the input for the
+ EnergyPlus simulation.
+
+ - sql -- Array of paths to .sqlite files containing all simulation results.
+
+ - zsz -- Array of paths to .csv files containing detailed zone load
+ information recorded over the course of the design days.
+
+ - rdd -- Array of paths to .rdd files containing all possible outputs
+ that can be requested from the simulation.
+
+ - html -- Array of paths to .htm files containing all summary reports.
+
+ - err -- Array of paths to .err files containing all errors and
+ warnings from the simulation.
+ """
+ # empty list which will be filled with simulation output files
+ osm=[]
+ idf=[]
+ sql=[]
+ zsz=[]
+ rdd=[]
+ html=[]
+ err=[]
+
+ # parse the GeoJSON so that we can get the correct order of result files
+ sim_dir=os.path.join(directory,'run','honeybee_scenario')
+ ifnotos.path.isdir(sim_dir):
+ msg='The URBANopt simulation failed to run.\n' \
+ 'No results were found at:\n{}\n{}'.format(sim_dir,stderr)
+ print(msg)
+ raiseException(msg)
+ geojson=[fforfinos.listdir(directory)iff.endswith('.geojson')]
+ iflen(geojson)==1:
+ geo_file=os.path.join(directory,geojson[0])
+ withopen(geo_file,'r')asbase_file:
+ geo_dict=json.load(base_file)
+ bldg_names=[]
+ forftingeo_dict['features']:
+ if'properties'inftand'type'inft['properties']:
+ ifft['properties']['type']=='Building'and'id'inft['properties']:
+ bldg_names.append(ft['properties']['id'])
+ else:
+ bldg_names=os.listdir(sim_dir)
+
+ # generate paths to the simulation files and check their existence
+ forbldg_nameinbldg_names:
+ bldg_dir=os.path.join(sim_dir,bldg_name)
+ osm_file=os.path.join(bldg_dir,'in.osm')
+ ifos.path.isfile(osm_file):
+ osm.append(osm_file)
+ idf_file=os.path.join(bldg_dir,'in.idf')
+ ifos.path.isfile(idf_file):
+ idf.append(idf_file)
+ sql_file=os.path.join(bldg_dir,'eplusout.sql')
+ ifos.path.isfile(sql_file):
+ sql.append(sql_file)
+ zsz_file=os.path.join(bldg_dir,'epluszsz.csv')
+ ifos.path.isfile(zsz_file):
+ zsz.append(zsz_file)
+ rdd_file=os.path.join(bldg_dir,'eplusout.rdd')
+ ifos.path.isfile(rdd_file):
+ rdd.append(rdd_file)
+ html_file=os.path.join(bldg_dir,'eplustbl.htm')
+ ifos.path.isfile(html_file):
+ html.append(html_file)
+ err_file=os.path.join(bldg_dir,'eplusout.err')
+ ifos.path.isfile(err_file):
+ err.append(err_file)
+
+ returnosm,idf,sql,zsz,rdd,html,err
+
+
+def_run_default_report_windows(feature_geojson,scenario_csv):
+"""Generate default reports on a Windows-based os.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ Paths to the scenario CSV and JSON reports.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # Write the batch file to call URBANopt CLI
+ working_drive=directory[:2]
+ batch='{}\ncd {}\ncall "{}"\nuo process --default -f "{}" -s "{}"'.format(
+ working_drive,working_drive,folders.urbanopt_env_path,
+ feature_geojson,scenario_csv)
+ batch_file=os.path.join(directory,'run_default_report.bat')
+ write_to_file(batch_file,batch,True)
+ # run the batch file and return output files
+ os.system('"{}"'.format(batch_file))
+ result_folder=os.path.basename(scenario_csv).lower().replace('.csv','')
+ run_folder=os.path.join(directory,'run',result_folder)
+ returnos.path.join(run_folder,'default_scenario_report.csv'), \
+ os.path.join(run_folder,'default_scenario_report.json')
+
+
+def_run_default_report_unix(feature_geojson,scenario_csv):
+"""Generate default reports on a Unix-based os.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ Paths to the scenario CSV and JSON reports.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # Write the shell script to call OpenStudio CLI
+ shell='#!/usr/bin/env bash\nsource "{}"\n' \
+ 'uo process --default -f "{}" -s "{}"'.format(
+ folders.urbanopt_env_path,feature_geojson,scenario_csv)
+ shell_file=os.path.join(directory,'run_default_report.sh')
+ write_to_file(shell_file,shell,True)
+ # make the shell script executable using subprocess.check_call
+ # this is more reliable than native Python chmod on Mac
+ subprocess.check_call(['chmod','u+x',shell_file])
+ # run the shell script
+ subprocess.call(shell_file)
+ result_folder=os.path.basename(scenario_csv).lower().replace('.csv','')
+ run_folder=os.path.join(directory,'run',result_folder)
+ returnos.path.join(run_folder,'default_scenario_report.csv'), \
+ os.path.join(run_folder,'default_scenario_report.json')
+
+
+def_run_reopt_windows(feature_geojson,scenario_csv,developer_key):
+"""Run a feature and scenario file through REopt on a Windows-based os.
+
+ A batch file will be used to run the simulation.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+ developer_key: Text string for the NREL developer key.
+
+ Returns:
+ Path to the folder in which results should be contained.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # Write the batch file to call URBANopt CLI
+ working_drive=directory[:2]
+ batch='{}\ncd {}\ncall "{}"\nSET GEM_DEVELOPER_KEY={}\n' \
+ 'uo process --reopt-scenario -f "{}" -s "{}"'.format(
+ working_drive,working_drive,folders.urbanopt_env_path,developer_key,
+ feature_geojson,scenario_csv)
+ batch_file=os.path.join(directory,'run_reopt.bat')
+ write_to_file(batch_file,batch,True)
+ # run the batch file
+ os.system('"{}"'.format(batch_file))
+ result_folder=os.path.basename(scenario_csv).lower().replace('.csv','')
+ returnos.path.join(directory,'run',result_folder)
+
+
+def_run_reopt_unix(feature_geojson,scenario_csv,developer_key):
+"""Run a feature and scenario file through REopt on a Unix-based os.
+
+ This includes both Mac OS and Linux since a shell will be used to run
+ the simulation.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+ developer_key: Text string for the NREL developer key.
+
+ Returns:
+ Path to the folder in which results should be contained.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # Write the shell script to call OpenStudio CLI
+ shell='#!/usr/bin/env bash\nsource "{}"\nGEM_DEVELOPER_KEY={}\n' \
+ 'uo process --reopt-scenario -f "{}" -s "{}"'.format(
+ folders.urbanopt_env_path,developer_key,feature_geojson,scenario_csv)
+ shell_file=os.path.join(directory,'run_reopt.sh')
+ write_to_file(shell_file,shell,True)
+ # make the shell script executable using subprocess.check_call
+ # this is more reliable than native Python chmod on Mac
+ subprocess.check_call(['chmod','u+x',shell_file])
+ # run the shell script
+ subprocess.call(shell_file)
+ result_folder=os.path.basename(scenario_csv).lower().replace('.csv','')
+ returnos.path.join(directory,'run',result_folder)
+
+
+def_output_reopt_files(directory):
+"""Get the paths to the simulation output files given the reopt directory.
+
+ Args:
+ directory: The path to the folder in which results should be contained.
+
+ Returns:
+ A series of file paths to the simulation output files
+
+ - csv -- Path to a CSV file containing scenario optimization results.
+
+ - report_json -- Path to a JSON file containing scenario optimization results.
+ """
+ # generate paths to the simulation files
+ csv_file=os.path.join(directory,'scenario_optimization.csv')
+ report_json_file=os.path.join(directory,'scenario_optimization.json')
+ # check that the simulation files exist
+ csv=csv_fileifos.path.isfile(csv_file)elseNone
+ report_json=report_json_fileifos.path.isfile(report_json_file)elseNone
+ returncsv,report_json
+
+
+def_run_rnm_windows(feature_geojson,scenario_csv):
+"""Run a feature and scenario file through RNM on a Windows-based os.
+
+ A batch file will be used to run the simulation.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ Path to the project folder.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # Write the batch file to call URBANopt CLI
+ working_drive=directory[:2]
+ batch='{}\ncd {}\ncall "{}"\nuo rnm --feature "{}" --scenario "{}"'.format(
+ working_drive,working_drive,folders.urbanopt_env_path,
+ feature_geojson,scenario_csv)
+ batch_file=os.path.join(directory,'run_rnm.bat')
+ write_to_file(batch_file,batch,True)
+ # run the batch file
+ os.system('"{}"'.format(batch_file))
+ returndirectory
+
+
+def_run_rnm_unix(feature_geojson,scenario_csv):
+"""Run a feature and scenario file through RNM on a Unix-based os.
+
+ This includes both Mac OS and Linux since a shell script will be used to run
+ the simulation.
+
+ Args:
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ Path to the project folder.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # Write the shell script to call URBANopt CLI
+ shell='#!/usr/bin/env bash\nsource "{}"\nuo rnm --feature "{}" -s-scenario ' \
+ '"{}"'.format(folders.urbanopt_env_path,feature_geojson,scenario_csv)
+ shell_file=os.path.join(directory,'run_rnm.sh')
+ write_to_file(shell_file,shell,True)
+ # make the shell script executable using subprocess.check_call
+ # this is more reliable than native Python chmod on Mac
+ subprocess.check_call(['chmod','u+x',shell_file])
+ # run the shell script
+ subprocess.call(shell_file)
+ returndirectory
+
+
+def_generate_modelica_windows(sys_param_json,feature_geojson,scenario_csv):
+"""Generate Modelica files for a DES on a Windows-based os.
+
+ A batch file will be used to run the simulation.
+
+ Args:
+ sys_param_json: The full path to a system parameter JSON from which the
+ Modelica files will be generated.
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ A tuple with two values.
+
+ - modelica_dir -- Path to the folder in which the Modelica files were written.
+
+ - stderr -- The standard error message, which should get to the user
+ in the event of simulation failure.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # get the path to the MBL installation
+ install_directory=os.path.join(lb_folders.ladybug_tools_folder,'resources')
+ mbl_dir=os.path.join(install_directory,'mbl')
+ assertos.path.isdir(mbl_dir), \
+ 'No Modelica Buildings Library installation was found on this machine.'
+ # get the paths to the output files
+ scn_name=os.path.basename(scenario_csv).replace('.csv','')
+ modelica_dir=os.path.join(directory,'run',scn_name,'des_modelica')
+ uo_des_exe=os.path.join(hb_folders.python_scripts_path,'uo_des.exe')
+ # Write the batch file to call the GMT
+ working_drive=directory[:2]
+ batch='{}\ncd {}\ncall "{}"\nSET "MODELICAPATH={}"\n"{}" create-model ' \
+ '"{}" "{}" "{}" --overwrite'.format(
+ working_drive,working_drive,folders.urbanopt_env_path,mbl_dir,
+ uo_des_exe,sys_param_json,feature_geojson,modelica_dir)
+ batch_file=os.path.join(directory,'generate_modelica.bat')
+ write_to_file(batch_file,batch,True)
+ # run the batch file
+ process=subprocess.Popen(
+ '"{}"'.format(batch_file),stderr=subprocess.PIPE,env=PYTHON_ENV
+ )
+ result=process.communicate()
+ stderr=result[1]
+ returnmodelica_dir,stderr
+
+
+def_generate_modelica_unix(sys_param_json,feature_geojson,scenario_csv):
+"""Generate Modelica files for a DES on a Unix-based os.
+
+ This includes both Mac OS and Linux since a shell will be used to run
+ the simulation.
+
+ Args:
+ sys_param_json: The full path to a system parameter JSON from which the
+ Modelica files will be generated.
+ feature_geojson: The full path to a .geojson file containing the
+ footprints of buildings to be simulated.
+ scenario_csv: The full path to a .csv file for the URBANopt scenario.
+
+ Returns:
+ A tuple with two values.
+
+ - directory -- Path to the folder out of which the simulation was run.
+
+ - stderr -- The standard error message, which should get to the user
+ in the event of simulation failure.
+ """
+ # check the input file
+ directory=_check_urbanopt_file(feature_geojson,scenario_csv)
+ # get the path to the MBL installation
+ install_directory=os.path.join(lb_folders.ladybug_tools_folder,'resources')
+ mbl_dir=os.path.join(install_directory,'mbl')
+ assertos.path.isdir(mbl_dir), \
+ 'No Modelica Buildings Library installation was found on this machine.'
+ # get the paths to the output files
+ scn_name=os.path.basename(scenario_csv).replace('.csv','')
+ modelica_dir=os.path.join(directory,'run',scn_name,'des_modelica')
+ uo_des_exe=os.path.join(hb_folders.python_scripts_path,'uo_des')
+ # write the shell script to call the GMT
+ shell='#!/usr/bin/env bash\nsource "{}"\nexport MODELICAPATH="{}"\n' \
+ '"{}" create-model "{}" "{}" "{}" --overwrite'.format(
+ folders.urbanopt_env_path,mbl_dir,
+ uo_des_exe,sys_param_json,feature_geojson,modelica_dir)
+ shell_file=os.path.join(directory,'generate_modelica.sh')
+ write_to_file(shell_file,shell,True)
+ # make the shell script executable using subprocess.check_call
+ # this is more reliable than native Python chmod on Mac
+ subprocess.check_call(['chmod','u+x',shell_file])
+ # run the shell script
+ process=subprocess.Popen(
+ '"{}"'.format(shell_file),stderr=subprocess.PIPE,env=PYTHON_ENV,shell=True
+ )
+ result=process.communicate()
+ stderr=result[1]
+ returnmodelica_dir,stderr
+
+
+def_add_water_heating_patch(modelica_dir):
+"""Add a dummy value for water heating for MBL 10 limitation."""
+ data_dir=os.path.join(modelica_dir,'Loads','Resources','Data')
+ ifos.path.isdir(data_dir):
+ forbldg_dirinos.listdir(data_dir):
+ mo_load_file=os.path.join(data_dir,bldg_dir,'modelica.mos')
+ ifos.path.isfile(mo_load_file):
+ fixed_lines,fl_found=[],False
+ withopen(mo_load_file,'r')asmlf:
+ forlineinmlf:
+ ifline=='#Peak water heating load = 0 Watts\n':
+ nl='#Peak water heating load = 1 Watts\n'
+ fixed_lines.append(nl)
+ elifnotfl_foundand';'inline:
+ split_vals=line.split(';')
+ split_vals[-1]='1.0\n'
+ fixed_lines.append(';'.join(split_vals))
+ fl_found=True
+ else:
+ fixed_lines.append(line)
+ withopen(mo_load_file,'w')asmlf:
+ mlf.write(''.join(fixed_lines))
+
+
+def_run_modelica_windows(modelica_project_dir):
+"""Execute Modelica files of a DES on a Windows-based OS.
+
+ A batch file will be used to run the simulation.
+
+ Args:
+ modelica_project_dir: The full path to the folder in which the Modelica
+ files were written.
+
+ Returns:
+ A tuple with two values.
+
+ - results -- Path to where the results were written.
+
+ - stderr -- The standard error message, which should get to the user
+ in the event of simulation failure.
+ """
+ # make sure that docker is installed
+ assertfolders.docker_version_strisnotNone, \
+ 'No Docker installation was found on this machine.\n' \
+ 'This is needed to execute Modelica simulations.'
+ # get the paths to the output files
+ directory=os.path.dirname(modelica_project_dir)
+ project_name=os.path.basename(modelica_project_dir)
+ results=os.path.join(
+ modelica_project_dir,
+ '{}.Districts.DistrictEnergySystem_results'.format(project_name))
+ uo_des_exe=os.path.join(hb_folders.python_scripts_path,'uo_des.exe')
+ # Write the batch file to call the GMT
+ working_drive=modelica_project_dir[:2]
+ batch='{}\ncd {}\ncall "{}"\n"{}" run-model "{}"'.format(
+ working_drive,working_drive,folders.urbanopt_env_path,
+ uo_des_exe,modelica_project_dir)
+ batch_file=os.path.join(directory,'run_modelica.bat')
+ write_to_file(batch_file,batch,True)
+ # run the batch file
+ process=subprocess.Popen(
+ '"{}"'.format(batch_file),stderr=subprocess.PIPE,env=PYTHON_ENV
+ )
+ result=process.communicate()
+ stderr=result[1]
+ returnresults,stderr
+
+
+def_run_modelica_unix(modelica_project_dir):
+"""Execute Modelica files of a DES on a Unix-based OS.
+
+ This includes both Mac OS and Linux since a shell will be used to run
+ the simulation.
+
+ Args:
+ modelica_project_dir: The full path to the folder in which the Modelica
+ files were written.
+
+ Returns:
+ A tuple with two values.
+
+ - results -- Path to where the results were written.
+
+ - stderr -- The standard error message, which should get to the user
+ in the event of simulation failure.
+ """
+ # make sure that docker is installed
+ assertfolders.docker_version_strisnotNone, \
+ 'No Docker installation was found on this machine.\n' \
+ 'This is needed to execute Modelica simulations.'
+ # get the paths to the output files
+ directory=os.path.dirname(modelica_project_dir)
+ project_name=os.path.basename(modelica_project_dir)
+ results=os.path.join(
+ modelica_project_dir,
+ '{}.Districts.DistrictEnergySystem_results'.format(project_name))
+ uo_des_exe=os.path.join(hb_folders.python_scripts_path,'uo_des')
+ # write the shell script to call the GMT
+ shell='#!/usr/bin/env bash\nsource "{}"\n"{}" run-model "{}"'.format(
+ folders.urbanopt_env_path,uo_des_exe,modelica_project_dir)
+ shell_file=os.path.join(directory,'run_modelica.sh')
+ write_to_file(shell_file,shell,True)
+ # make the shell script executable using subprocess.check_call
+ # this is more reliable than native Python chmod on Mac
+ subprocess.check_call(['chmod','u+x',shell_file])
+ # run the shell script
+ process=subprocess.Popen(
+ '"{}"'.format(shell_file),stderr=subprocess.PIPE,env=PYTHON_ENV,shell=True
+ )
+ result=process.communicate()
+ stderr=result[1]
+ returnresults,stderr
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/_modules/dragonfly_energy/writer.html b/docs/_modules/dragonfly_energy/writer.html
new file mode 100644
index 00000000..6fdb5fbc
--- /dev/null
+++ b/docs/_modules/dragonfly_energy/writer.html
@@ -0,0 +1,1177 @@
+
+
+
+
+
+
+ dragonfly_energy.writer — dragonfly-energy documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# coding=utf-8
+"""Methods to write files for URBANopt simulation from a Model."""
+importsys
+importos
+importre
+importjson
+
+fromladybug_geometry.geometry2dimportPoint2D
+fromladybug.futilimportnukedir,preparedir
+fromhoneybee.configimportfolders
+fromhoneybee.modelimportModelashb_model
+
+
+
+[docs]
+defmodel_to_urbanopt(
+ model,location,point=Point2D(0,0),shade_distance=None,use_multiplier=True,
+ add_plenum=False,solve_ceiling_adjacencies=False,
+ des_loop=None,electrical_network=None,road_network=None,ground_pv=None,
+ folder=None,tolerance=0.01
+):
+r"""Generate an URBANopt feature geoJSON and honeybee JSONs from a dragonfly Model.
+
+ Args:
+ model: A dragonfly Model for which an URBANopt feature geoJSON and
+ corresponding honeybee Model JSONs will be returned.
+ location: A ladybug Location object possessing longitude and latitude data.
+ point: A ladybug_geometry Point2D for where the location object exists
+ within the space of a scene. The coordinates of this point are
+ expected to be in the units of this Model. (Default: (0, 0)).
+ shade_distance: An optional number to note the distance beyond which other
+ objects' shade should not be exported into a given honeybee Model. This
+ is helpful for reducing the simulation run time of each Model when other
+ connected buildings are too far away to have a meaningful impact on
+ the results. If None, all other buildings will be included as context
+ shade in each and every Model. Set to 0 to exclude all neighboring
+ buildings from the resulting models. (Default: None).
+ use_multiplier: If True, the multipliers on the Model's Stories will be
+ passed along to the generated Honeybee Room objects, indicating the
+ simulation will be run once for each unique room and then results
+ will be multiplied. If False, full geometry objects will be written
+ for each and every floor in the building that are represented through
+ multipliers and all resulting multipliers will be 1. (Default: True).
+ add_plenum: Boolean to indicate whether ceiling/floor plenums should
+ be auto-generated for the Rooms. (Default: False).
+ solve_ceiling_adjacencies: Boolean to note whether adjacencies should be
+ solved between interior stories when Room2Ds perfectly match one
+ another in their floor plate. This ensures that Surface boundary
+ conditions are used instead of Adiabatic ones. Note that this input
+ has no effect when the object_per_model is Story. (Default: False).
+ des_loop: An optional District Energy System (DES) ThermalLoop that's
+ associated with the dragonfly Model. (Default: None).
+ electrical_network: An optional OpenDSS ElectricalNetwork that's associated
+ with the dragonfly Model. (Default: None).
+ road_network: An optional RNM RoadNetwork that's associated with the
+ dragonfly Model. (Default: None).
+ ground_pv: An optional list of REopt GroundMountPV objects representing
+ ground-mounted photovoltaic fields to be included in the REopt
+ simulation. (Default: None).
+ folder: An optional folder to be used as the root of the model's
+ URBANopt folder. If None, the files will be written into a sub-directory
+ of the honeybee-core default_simulation_folder.
+ tolerance: The minimum distance between points at which they are
+ not considered touching. (Default: 0.01, suitable for objects
+ in meters).
+
+ Returns:
+ A tuple with three values.
+
+ feature_geojson -- The path to an URBANopt feature geoJSON that has
+ been written by this method.
+
+ hb_model_jsons -- An array of file paths to honeybee Model JSONs that
+ correspond to the detailed_model_filename keys in the feature_geojson.
+
+ hb_models -- An array of honeybee Model objects that were generated in
+ process of writing the URBANopt files.
+ """
+ # make sure the model is in meters and, if it's not, duplicate and scale it
+ conversion_factor,original_units=None,'Meters'
+ ifmodel.units!='Meters':
+ original_units=model.units
+ conversion_factor=hb_model.conversion_factor_to_meters(model.units)
+ point=point.scale(conversion_factor)
+ ifshade_distanceisnotNone:
+ shade_distance=shade_distance*conversion_factor
+ tolerance=tolerance*conversion_factor
+ model=model.duplicate()# duplicate the model to avoid mutating the input
+ model.convert_to_units('Meters')
+ ifdes_loopisnotNone:
+ des_loop.scale(conversion_factor)
+ ifelectrical_networkisnotNone:
+ electrical_network.scale(conversion_factor)
+ ifroad_networkisnotNone:
+ road_network.scale(conversion_factor)
+ ifground_pvisnotNone:
+ forg_pvinground_pv:
+ g_pv.scale(conversion_factor)
+
+ # prepare the folder for simulation
+ tr_msg='The following simulation folder is too long to be used with URBANopt:' \
+ '\n{}\nSpecify a shorter folder path in which to write the GeoJSON.'
+ iffolderisNone:# use the default simulation folder
+ assertlen(folders.default_simulation_folder)<55, \
+ tr_msg.format(folders.default_simulation_folder)
+ sim_dir=re.sub(r'[^.A-Za-z0-9_-]','_',model.display_name)
+ folder=os.path.join(folders.default_simulation_folder,sim_dir)
+ iflen(folder)>=60:
+ tr_len=58-len(folders.default_simulation_folder)
+ folder=os.path.join(folders.default_simulation_folder,sim_dir[:tr_len])
+ else:
+ assertlen(folder)<60,tr_msg.format(folder)
+
+ # get rid of all simulation files that exists in the folder already
+ dir_to_delete=('hb_json','mappers','run')
+ ext_to_delete=('.bat','.geojson','.epw','.mos')
+ file_to_delete=(
+ 'Gemfile','Gemfile.lock','honeybee_scenario.csv','runner.conf',
+ 'simulation_parameter.json','system_params.json',
+ 'electrical_database.json','network.json'
+ )
+ ifos.path.isdir(folder):
+ files=os.listdir(folder)
+ forfinfiles:
+ path=os.path.join(folder,f)
+ ifos.path.isdir(path):
+ iffindir_to_delete:
+ nukedir(path,True)
+ else:
+ iffinfile_to_delete:
+ os.remove(path)
+ eliff.endswith(ext_to_delete):
+ os.remove(path)
+ else:
+ preparedir(folder)# create the directory if it's not there
+
+ # prepare the folder into which honeybee Model JSONs will be written
+ hb_model_folder=os.path.join(folder,'hb_json')# folder for honeybee JSONs
+ preparedir(hb_model_folder)
+
+ # create GeoJSON dictionary
+ geojson_dict=model.to_geojson_dict(location,point,tolerance=tolerance)
+ forfeature_dictingeojson_dict['features']:# add the detailed model filename
+ iffeature_dict['properties']['type']=='Building':
+ bldg_id=feature_dict['properties']['id']
+ feature_dict['properties']['detailed_model_filename']= \
+ os.path.join(hb_model_folder,'{}.json'.format(bldg_id))
+
+ # add the DES to the GeoJSON dictionary
+ ifdes_loopisnotNone:
+ ifhasattr(des_loop,'to_geojson_dict'):
+ des_features=des_loop.to_geojson_dict(
+ model.buildings,location,point,tolerance=tolerance)
+ geojson_dict['features'].extend(des_features)
+ sys_p_json=os.path.join(folder,'system_params.json')
+ withopen(sys_p_json,'w')asfp:
+ des_dict=des_loop.to_des_param_dict(model.buildings,tolerance=tolerance)
+ json.dump(des_dict,fp,indent=2)
+ ifconversion_factorisnotNone:
+ des_loop.scale(1/conversion_factor)
+
+ # add the electrical network to the GeoJSON dictionary
+ ifelectrical_networkisnotNone:
+ electric_features=electrical_network.to_geojson_dict(
+ model.buildings,location,point,tolerance=tolerance)
+ geojson_dict['features'].extend(electric_features)
+ electric_json=os.path.join(folder,'electrical_database.json')
+ withopen(electric_json,'w')asfp:
+ json.dump(electrical_network.to_electrical_database_dict(),fp,indent=4)
+ ifconversion_factorisnotNone:
+ electrical_network.scale(1/conversion_factor)
+
+ # add the road network to the GeoJSON dictionary
+ ifroad_networkisnotNone:
+ road_features=road_network.to_geojson_dict(location,point)
+ geojson_dict['features'].extend(road_features)
+ ifconversion_factorisnotNone:
+ road_network.scale(1/conversion_factor)
+
+ # add the ground-mounted PV to the GeoJSON dictionary
+ ifground_pvisnotNoneandlen(ground_pv)!=0:
+ pv_features=[g_pv.to_geojson_dict(location,point)forg_pvinground_pv]
+ geojson_dict['features'].extend(pv_features)
+ ifconversion_factorisnotNone:
+ forg_pvinground_pv:
+ g_pv.scale(1/conversion_factor)
+
+ # write out the GeoJSON file
+ feature_geojson=os.path.join(folder,'{}.geojson'.format(model.identifier))
+ if(sys.version_info<(3,0)):# we need to manually encode it as UTF-8
+ withopen(feature_geojson,'wb')asfp:
+ obj_str=json.dumps(geojson_dict,indent=4,ensure_ascii=False)
+ fp.write(obj_str.encode('utf-8'))
+ else:
+ withopen(feature_geojson,'w',encoding='utf-8')asfp:
+ obj_str=json.dump(geojson_dict,fp,indent=4,ensure_ascii=False)
+
+ # write out the honeybee Model JSONs from the model
+ hb_model_jsons=[]
+ hb_models=model.to_honeybee(
+ 'Building',shade_distance,use_multiplier,add_plenum,
+ solve_ceiling_adjacencies=solve_ceiling_adjacencies,tolerance=tolerance)
+ forbldg_modelinhb_models:
+ try:
+ bldg_model.remove_degenerate_geometry(0.01)
+ exceptValueError:
+ error='Failed to remove degenerate Geometry.\nYour Model units system is: {}. ' \
+ 'Is this correct?'.format(original_units)
+ raiseValueError(error)
+ model_dict=bldg_model.to_dict(triangulate_sub_faces=True)
+ bldg_model.properties.energy.add_autocal_properties_to_dict(model_dict)
+ bld_path=os.path.join(hb_model_folder,'{}.json'.format(bldg_model.identifier))
+ if(sys.version_info<(3,0)):# we need to manually encode it as UTF-8
+ withopen(bld_path,'wb')asfp:
+ obj_str=json.dumps(model_dict,indent=4,ensure_ascii=False)
+ fp.write(obj_str.encode('utf-8'))
+ else:
+ withopen(bld_path,'w',encoding='utf-8')asfp:
+ obj_str=json.dump(model_dict,fp,indent=4,ensure_ascii=False)
+ hb_model_jsons.append(bld_path)
+
+ returnfeature_geojson,hb_model_jsons,hb_models