def main(config):
"""
This function makes the calculation of solar insolation in X sensor points for every building in the zone
of interest. the number of sensor points depends on the size of the grid selected in the SETTINGS.py file and
are generated automatically.
:param config: Configuration object with the settings (genera and radiation-daysim)
:type config: cea.config.Configuartion
:return:
"""
# reference case need to be provided here
locator = cea.inputlocator.InputLocator(scenario=config.scenario)
# the selected buildings are the ones for which the individual radiation script is run for
# this is only activated when in default.config, run_all_buildings is set as 'False'
settings = config.radiation_daysim
# BUGFIX for PyCharm: the PATH variable might not include the daysim-bin-directory, so we add it here
os.environ[
"PATH"] = settings.daysim_bin_directory + os.pathsep + os.environ[
"PATH"]
print("verifying geometry files")
print(locator.get_zone_geometry())
verify_input_geometry_zone(gpdf.from_file(locator.get_zone_geometry()))
verify_input_geometry_district(
gpdf.from_file(locator.get_district_geometry()))
# import material properties of buildings
building_surface_properties = reader_surface_properties(
locator=locator, input_shp=locator.get_building_architecture())
print("creating 3D geometry and surfaces")
# create geometrical faces of terrain and buildingsL
elevation, geometry_terrain, geometry_3D_zone, geometry_3D_surroundings = geometry_generator.geometry_main(
locator, config)
print("Sending the scene: geometry and materials to daysim")
# send materials
daysim_mat = locator.get_temporary_file('default_materials.rad')
rad = py2radiance.Rad(daysim_mat, locator.get_temporary_folder())
print("\tradiation_main: rad.base_file_path: {}".format(
rad.base_file_path))
print("\tradiation_main: rad.data_folder_path: {}".format(
rad.data_folder_path))
print("\tradiation_main: rad.command_file: {}".format(rad.command_file))
add_rad_mat(daysim_mat, building_surface_properties)
# send terrain
terrain2radiance(rad, geometry_terrain)
# send buildings
buildings2radiance(rad, building_surface_properties, geometry_3D_zone,
geometry_3D_surroundings)
# create scene out of all this
rad.create_rad_input_file()
print("\tradiation_main: rad.rad_file_path: {}".format(rad.rad_file_path))
time1 = time.time()
radiation_singleprocessing(rad, geometry_3D_zone, locator, settings)
print("Daysim simulation finished in %.2f mins" %
((time.time() - time1) / 60.0))
def main(config):
"""
This function makes the calculation of solar insolation in X sensor points for every building in the zone
of interest. The number of sensor points depends on the size of the grid selected in the config file and
are generated automatically.
:param config: Configuration object with the settings (genera and radiation)
:type config: cea.config.Configuartion
:return:
"""
# reference case need to be provided here
locator = cea.inputlocator.InputLocator(scenario=config.scenario)
# the selected buildings are the ones for which the individual radiation script is run for
# this is only activated when in default.config, run_all_buildings is set as 'False'
# BUGFIX for #2447 (make sure the Daysim binaries are there before starting the simulation)
daysim_bin_path, daysim_lib_path = check_daysim_bin_directory(config.radiation.daysim_bin_directory,
config.radiation.use_latest_daysim_binaries)
print('Using Daysim binaries from path: {}'.format(daysim_bin_path))
# Save daysim path to config
config.radiation.daysim_bin_directory = daysim_bin_path
# BUGFIX for PyCharm: the PATH variable might not include the daysim-bin-directory, so we add it here
os.environ["PATH"] = "{bin}{pathsep}{path}".format(bin=config.radiation.daysim_bin_directory, pathsep=os.pathsep,
path=os.environ["PATH"])
os.environ["RAYPATH"] = daysim_lib_path
if not "PROJ_LIB" in os.environ:
os.environ["PROJ_LIB"] = os.path.join(os.path.dirname(sys.executable), "Library", "share")
if not "GDAL_DATA" in os.environ:
os.environ["GDAL_DATA"] = os.path.join(os.path.dirname(sys.executable), "Library", "share", "gdal")
print("verifying geometry files")
print(locator.get_zone_geometry())
verify_input_geometry_zone(gpdf.from_file(locator.get_zone_geometry()))
verify_input_geometry_surroundings(gpdf.from_file(locator.get_surroundings_geometry()))
# import material properties of buildings
print("getting geometry materials")
building_surface_properties = reader_surface_properties(locator=locator,
input_shp=locator.get_building_architecture())
building_surface_properties.to_csv(locator.get_radiation_materials())
print("creating 3D geometry and surfaces")
# create geometrical faces of terrain and buildingsL
elevation, geometry_terrain, geometry_3D_zone, geometry_3D_surroundings = geometry_generator.geometry_main(locator,
config)
print("Sending the scene: geometry and materials to daysim")
# send materials
daysim_mat = locator.get_temporary_file('default_materials.rad')
rad = CEARad(daysim_mat, locator.get_temporary_folder(), debug=config.debug)
print("\tradiation_main: rad.base_file_path: {}".format(rad.base_file_path))
print("\tradiation_main: rad.data_folder_path: {}".format(rad.data_folder_path))
print("\tradiation_main: rad.command_file: {}".format(rad.command_file))
add_rad_mat(daysim_mat, building_surface_properties)
# send terrain
terrain_to_radiance(rad, geometry_terrain)
# send buildings
buildings_to_radiance(rad, building_surface_properties, geometry_3D_zone, geometry_3D_surroundings)
# create scene out of all this
rad.create_rad_input_file()
print("\tradiation_main: rad.rad_file_path: {}".format(rad.rad_file_path))
time1 = time.time()
radiation_singleprocessing(rad, geometry_3D_zone, locator, config.radiation)
print("Daysim simulation finished in %.2f mins" % ((time.time() - time1) / 60.0))
def create_new_project(locator, config):
# Local variables
zone_geometry_path = config.create_new_project.zone
surroundings_geometry_path = config.create_new_project.surroundings
street_geometry_path = config.create_new_project.streets
terrain_path = config.create_new_project.terrain
typology_path = config.create_new_project.typology
# import file
zone, lat, lon = shapefile_to_WSG_and_UTM(zone_geometry_path)
# verify if input file is correct for CEA, if not an exception will be released
verify_input_geometry_zone(zone)
zone.to_file(locator.get_zone_geometry())
# apply coordinate system of terrain into zone and save zone to disk.
terrain = raster_to_WSG_and_UTM(terrain_path, lat, lon)
driver = gdal.GetDriverByName('GTiff')
verify_input_terrain(terrain)
driver.CreateCopy(locator.get_terrain(), terrain)
# now create the surroundings file if it does not exist
if surroundings_geometry_path == '':
print(
"there is no surroundings file, we proceed to create it based on the geometry of your zone"
)
zone.to_file(locator.get_surroundings_geometry())
else:
# import file
surroundings, _, _ = shapefile_to_WSG_and_UTM(
surroundings_geometry_path)
# verify if input file is correct for CEA, if not an exception will be released
verify_input_geometry_surroundings(zone)
# create new file
surroundings.to_file(locator.get_surroundings_geometry())
# now transfer the streets
if street_geometry_path == '':
print(
"there is no street file, optimizaiton of cooling networks wont be possible"
)
else:
street, _, _ = shapefile_to_WSG_and_UTM(street_geometry_path)
street.to_file(locator.get_street_network())
## create occupancy file and year file
if typology_path == '':
print(
"there is no typology file, we proceed to create it based on the geometry of your zone"
)
zone = Gdf.from_file(zone_geometry_path).drop('geometry', axis=1)
zone['STANDARD'] = 'T6'
zone['YEAR'] = 2020
zone['1ST_USE'] = 'MULTI_RES'
zone['1ST_USE_R'] = 1.0
zone['2ND_USE'] = "NONE"
zone['2ND_USE_R'] = 0.0
zone['3RD_USE'] = "NONE"
zone['3RD_USE_R'] = 0.0
dataframe_to_dbf(zone[COLUMNS_ZONE_TYPOLOGY],
locator.get_building_typology())
else:
# import file
occupancy_file = dbf_to_dataframe(typology_path)
occupancy_file_test = occupancy_file[COLUMNS_ZONE_TYPOLOGY]
# verify if input file is correct for CEA, if not an exception will be released
verify_input_typology(occupancy_file_test)
# create new file
copyfile(typology_path, locator.get_building_typology())
# add other folders by calling the locator
locator.get_measurements()
locator.get_input_network_folder("DH", "")
locator.get_input_network_folder("DC", "")
locator.get_weather_folder()
def create_new_project(locator, config):
# Local variables
zone_geometry_path = config.create_new_project.zone
district_geometry_path = config.create_new_project.district
street_geometry_path = config.create_new_project.streets
terrain_path = config.create_new_project.terrain
occupancy_path = config.create_new_project.occupancy
age_path = config.create_new_project.age
# import file
zone, lat, lon = shapefile_to_WSG_and_UTM(zone_geometry_path)
# verify if input file is correct for CEA, if not an exception will be released
verify_input_geometry_zone(zone)
zone.to_file(locator.get_zone_geometry())
# apply coordinate system of terrain into zone and save zone to disk.
terrain = raster_to_WSG_and_UTM(terrain_path, lat, lon)
driver = gdal.GetDriverByName('GTiff')
verify_input_terrain(driver, locator.get_terrain(), terrain)
driver.CreateCopy(locator.get_terrain(), terrain)
# now create the district file if it does not exist
if district_geometry_path == '':
print("there is no district file, we proceed to create it based on the geometry of your zone")
zone.to_file(locator.get_district_geometry())
else:
# import file
district, _, _ = shapefile_to_WSG_and_UTM(district_geometry_path)
# verify if input file is correct for CEA, if not an exception will be released
verify_input_geometry_district(zone)
# create new file
district.to_file(locator.get_district_geometry())
# now transfer the streets
if street_geometry_path == '':
print("there is no street file, optimizaiton of cooling networks wont be possible")
else:
street, _, _ = shapefile_to_WSG_and_UTM(street_geometry_path)
street.to_file(locator.get_street_network())
## create occupancy file and year file
if occupancy_path == '':
print("there is no occupancy file, we proceed to create it based on the geometry of your zone")
zone = Gdf.from_file(zone_geometry_path).drop('geometry', axis=1)
for field in COLUMNS_ZONE_OCCUPANCY:
zone[field] = 0.0
zone[COLUMNS_ZONE_OCCUPANCY[:2]] = 0.5 # adding 0.5 area use to the first two uses
dataframe_to_dbf(zone[['Name'] + COLUMNS_ZONE_OCCUPANCY], locator.get_building_occupancy())
else:
# import file
occupancy_file = dbf_to_dataframe(occupancy_path)
occupancy_file_test = occupancy_file[['Name'] + COLUMNS_ZONE_OCCUPANCY]
# verify if input file is correct for CEA, if not an exception will be released
verify_input_occupancy(occupancy_file_test)
# create new file
copyfile(occupancy_path, locator.get_building_occupancy())
## create age file
if age_path == '':
print(
"there is no file with the age of the buildings, we proceed to create it based on the geometry of your zone")
zone = Gdf.from_file(zone_geometry_path).drop('geometry', axis=1)
for field in COLUMNS_ZONE_AGE:
zone[field] = 0.0
zone['built'] = 2017 # adding year of construction
dataframe_to_dbf(zone[['Name'] + COLUMNS_ZONE_AGE], locator.get_building_age())
else:
# import file
age_file = dbf_to_dataframe(age_path)
age_file_test = age_file[['Name'] + COLUMNS_ZONE_AGE]
# verify if input file is correct for CEA, if not an exception will be released
verify_input_age(age_file_test)
# create new file
copyfile(age_path, locator.get_building_age())
# add other folders by calling the locator
locator.get_measurements()
locator.get_input_network_folder("DH", "")
locator.get_input_network_folder("DC", "")
locator.get_weather_folder()
def main(config):
"""
This function makes the calculation of solar insolation in X sensor points for every building in the zone
of interest. The number of sensor points depends on the size of the grid selected in the config file and
are generated automatically.
:param config: Configuration object with the settings (genera and radiation)
:type config: cea.config.Configuartion
:return:
"""
# reference case need to be provided here
locator = cea.inputlocator.InputLocator(scenario=config.scenario)
# the selected buildings are the ones for which the individual radiation script is run for
# this is only activated when in default.config, run_all_buildings is set as 'False'
# BUGFIX for #2447 (make sure the Daysim binaries are there before starting the simulation)
daysim_bin_path, daysim_lib_path = check_daysim_bin_directory(
config.radiation.daysim_bin_directory,
config.radiation.use_latest_daysim_binaries)
print('Using Daysim binaries from path: {}'.format(daysim_bin_path))
print('Using Daysim data from path: {}'.format(daysim_lib_path))
# Save daysim path to config
config.radiation.daysim_bin_directory = daysim_bin_path
# BUGFIX for PyCharm: the PATH variable might not include the daysim-bin-directory, so we add it here
os.environ["PATH"] = "{bin}{pathsep}{path}".format(
bin=config.radiation.daysim_bin_directory,
pathsep=os.pathsep,
path=os.environ["PATH"])
os.environ["RAYPATH"] = daysim_lib_path
if not "PROJ_LIB" in os.environ:
os.environ["PROJ_LIB"] = os.path.join(os.path.dirname(sys.executable),
"Library", "share")
if not "GDAL_DATA" in os.environ:
os.environ["GDAL_DATA"] = os.path.join(os.path.dirname(sys.executable),
"Library", "share", "gdal")
print("verifying geometry files")
zone_path = locator.get_zone_geometry()
surroundings_path = locator.get_surroundings_geometry()
print("zone: {zone_path}\nsurroundings: {surroundings_path}".format(
zone_path=zone_path, surroundings_path=surroundings_path))
verify_input_geometry_zone(gpdf.from_file(zone_path))
verify_input_geometry_surroundings(gpdf.from_file(surroundings_path))
# import material properties of buildings
print("Getting geometry materials")
building_surface_properties = reader_surface_properties(locator)
building_surface_properties.to_csv(locator.get_radiation_materials())
print("Creating 3D geometry and surfaces")
geometry_pickle_dir = os.path.join(
locator.get_temporary_folder(),
"{}_radiation_geometry_pickle".format(config.scenario_name))
print("Saving geometry pickle files in: {}".format(geometry_pickle_dir))
# create geometrical faces of terrain and buildings
geometry_terrain, zone_building_names, surroundings_building_names = geometry_generator.geometry_main(
locator, config, geometry_pickle_dir)
# daysim_bin_directory might contain two paths (e.g. "C:\Daysim\bin;C:\Daysim\lib") - in which case, only
# use the "bin" folder
bin_directory = [
d for d in config.radiation.daysim_bin_directory.split(";")
if not d.endswith("lib")
][0]
daysim_staging_location = os.path.join(locator.get_temporary_folder(),
'cea_radiation')
cea_daysim = CEADaySim(daysim_staging_location, bin_directory)
# create radiance input files
print("Creating radiance material file")
cea_daysim.create_radiance_material(building_surface_properties)
print("Creating radiance geometry file")
cea_daysim.create_radiance_geometry(geometry_terrain,
building_surface_properties,
zone_building_names,
surroundings_building_names,
geometry_pickle_dir)
print("Converting files for DAYSIM")
weather_file = locator.get_weather_file()
print('Transforming weather files to daysim format')
cea_daysim.execute_epw2wea(weather_file)
print('Transforming radiance files to daysim format')
cea_daysim.execute_radfiles2daysim()
time1 = time.time()
radiation_singleprocessing(cea_daysim,
zone_building_names,
locator,
config.radiation,
geometry_pickle_dir,
num_processes=config.get_number_of_processes())
print("Daysim simulation finished in %.2f mins" %
((time.time() - time1) / 60.0))