def main(config): gv = cea.globalvar.GlobalVariables() locator = cea.inputlocator.InputLocator(scenario=config.scenario) weather_data = epwreader.epw_reader(config.weather)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] year = weather_data['year'][0] region = config.region settings = config.demand use_daysim_radiation = settings.use_daysim_radiation building_properties, schedules_dict, date = properties_and_schedule( gv, locator, region, year, use_daysim_radiation) list_building_names = building_properties.list_building_names() climatic_variables = config.neural_network.climatic_variables weather_data = epwreader.epw_reader( locator.get_default_weather())[climatic_variables] input_prepare_estimate( list_building_names, locator, gv, climatic_variables=config.neural_network.climatic_variables, region=config.region, year=config.neural_network.year, use_daysim_radiation=settings.use_daysim_radiation, use_stochastic_occupancy=config.demand.use_stochastic_occupancy, weather_array=np.transpose(np.asarray(weather_data)), weather_data=epwreader.epw_reader( locator.get_default_weather())[climatic_variables])
def setUpClass(cls): import cea.examples cls.locator = cea.inputlocator.ReferenceCaseOpenLocator() cls.config = cea.config.Configuration(cea.config.DEFAULT_CONFIG) cls.config.scenario = cls.locator.scenario weather_path = cls.locator.get_weather('Zug_inducity_2009') cls.weather_data = epwreader.epw_reader(weather_path)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] year = cls.weather_data['year'][0] cls.date_range = get_date_range_hours_from_year(year) cls.test_config = configparser.ConfigParser() cls.test_config.read( os.path.join(os.path.dirname(__file__), 'test_calc_thermal_loads.config')) # run properties script import cea.datamanagement.archetypes_mapper cea.datamanagement.archetypes_mapper.archetypes_mapper( cls.locator, True, True, True, True, True, True, cls.locator.get_zone_building_names()) cls.building_properties = BuildingProperties( cls.locator, epwreader.epw_reader(cls.locator.get_weather_file())) cls.use_dynamic_infiltration_calculation = cls.config.demand.use_dynamic_infiltration_calculation cls.resolution_output = cls.config.demand.resolution_output cls.loads_output = cls.config.demand.loads_output cls.massflows_output = cls.config.demand.massflows_output cls.temperatures_output = cls.config.demand.temperatures_output cls.debug = cls.config.debug
def calc_SC(locator, sensors_data, radiation, latitude, longitude, year, gv, weather_path): # weather data weather_data = epwreader.epw_reader(weather_path) # solar properties g, Sz, Az, ha, trr_mean, worst_sh, worst_Az = solar_equations.calc_sun_properties(latitude, longitude, weather_data, gv) # read radiation file hourly_data = pd.read_csv(radiation) # get only datapoints with production beyond min_production Max_Isol = hourly_data.total.max() Min_Isol = Max_Isol * gv.min_production # 80% of the local average maximum in the area sensors_data_clean = sensors_data[sensors_data["total"] > Min_Isol] radiation_clean = radiation.loc[radiation['sensor_id'].isin(sensors_data_clean.sensor_id)] # Calculate the heights of all buildings for length of vertical pipes height = locator.get_total_demand().height.sum() # calculate optimal angle and tilt for panels optimal_angle_and_tilt(sensors_data, latitude, worst_sh, worst_Az, trr_mean, gv.grid_side, gv.module_lenght_SC, gv.angle_north, Min_Isol, Max_Isol) Number_groups, hourlydata_groups, number_points, prop_observers = calc_groups(radiation_clean, sensors_data_clean) result, Final = SC_generation(gv.type_SCpanel, hourlydata_groups, prop_observers, number_points, g, Sz, Az, ha, latitude, gv.Tin, height) Final.to_csv(locator.solar_collectors_result(), index=True, float_format='%.2f') return
def create_data(): """Create test data to compare against - run this the first time you make changes that affect the results. Note, this will overwrite the previous test data.""" test_config = ConfigParser.SafeConfigParser() test_config.read(get_test_config_path()) if not test_config.has_section('test_mixed_use_archetype_values'): test_config.add_section('test_mixed_use_archetype_values') locator = ReferenceCaseOpenLocator() expected_results = calculate_mixed_use_archetype_values_results(locator) test_config.set('test_mixed_use_archetype_values', 'expected_results', expected_results.to_json()) config = cea.config.Configuration(cea.config.DEFAULT_CONFIG) locator = ReferenceCaseOpenLocator() # calculate schedules building_properties = BuildingProperties(locator, False) bpr = building_properties['B1011'] list_uses = ['OFFICE', 'LAB', 'INDUSTRIAL', 'SERVERRROOM'] bpr.occupancy = {'OFFICE': 0.5, 'SERVERROOM': 0.5} # get year from weather file weather_path = locator.get_weather_file() weather_data = epwreader.epw_reader(weather_path)[['year']] year = weather_data['year'][0] date = pd.date_range(str(year) + '/01/01', periods=HOURS_IN_YEAR, freq='H') calculated_schedules = schedule_maker_main(locator, config) if not test_config.has_section('test_mixed_use_schedules'): test_config.add_section('test_mixed_use_schedules') test_config.set('test_mixed_use_schedules', 'reference_results', json.dumps( {schedule: calculated_schedules[schedule][REFERENCE_TIME] for schedule in calculated_schedules.keys()})) with open(get_test_config_path(), 'w') as f: test_config.write(f)
def calc_PV(locator, sensors_data, radiation, latitude, longitude, year, gv, weather_path): # weather data weather_data = epwreader.epw_reader(weather_path) # solar properties g, Sz, Az, ha, trr_mean, worst_sh, worst_Az = solar_equations.calc_sun_properties(latitude, longitude, weather_data, gv) # read radiation file hourly_data = pd.read_csv(radiation) # get only datapoints with production beyond min_production Max_Isol = hourly_data.total.max() Min_Isol = Max_Isol * gv.min_production # 80% of the local average maximum in the area sensors_data_clean = sensors_data[sensors_data["total"] > Min_Isol] radiation_clean = radiation.loc[radiation['sensor_id'].isin(sensors_data_clean.sensor_id)] # get only datapoints with aminimum 50 W/m2 of radiation for energy production radiation_clean[radiation_clean[:] <= 50] = 0 # calculate optimal angle and tilt for panels optimal_angle_and_tilt(sensors_data, latitude, worst_sh, worst_Az, trr_mean, gv.grid_side, gv.module_lenght_PV, gv.angle_north, Min_Isol, Max_Isol) Number_groups, hourlydata_groups, number_points, prop_observers = calc_groups(radiation_clean, sensors_data_clean) results, Final = Calc_pv_generation(gv.type_PVpanel, hourlydata_groups, Number_groups, number_points, prop_observers, weather_data,g, Sz, Az, ha, latitude, gv.misc_losses) Final.to_csv(locator.PV_result(), index=True, float_format='%.2f') return
def setUpClass(cls): import zipfile import tempfile import cea.examples archive = zipfile.ZipFile( os.path.join(os.path.dirname(cea.examples.__file__), 'reference-case-open.zip')) archive.extractall(tempfile.gettempdir()) reference_case = os.path.join(tempfile.gettempdir(), 'reference-case-open', 'baseline') cls.locator = InputLocator(reference_case) cls.gv = GlobalVariables() weather_path = cls.locator.get_default_weather() cls.weather_data = epwreader.epw_reader(weather_path)[[ 'drybulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] # run properties script import cea.demand.preprocessing.properties cea.demand.preprocessing.properties.properties(cls.locator, True, True, True, True) cls.building_properties = BuildingProperties(cls.locator, cls.gv) cls.date = pd.date_range(cls.gv.date_start, periods=8760, freq='H') cls.list_uses = cls.building_properties.list_uses() cls.archetype_schedules, cls.archetype_values = schedule_maker( cls.date, cls.locator, cls.list_uses) cls.occupancy_densities = cls.archetype_values['people'] cls.usage_schedules = { 'list_uses': cls.list_uses, 'archetype_schedules': cls.archetype_schedules, 'occupancy_densities': cls.occupancy_densities, 'archetype_values': cls.archetype_values }
def preproccessing(locator, total_demand, building_names, weather_file, gv): # read weather and calculate ground temperature T_ambient = epwreader.epw_reader(weather_file)['drybulb_C'] gv.ground_temperature = geothermal.calc_ground_temperature(T_ambient.values, gv) print "Run substation model for each building separately" subsM.subsMain(locator, total_demand, building_names, gv, Flag = True) # 1 if disconected buildings are calculated print "Heating operation pattern for disconnected buildings" dbM.discBuildOp(locator, building_names, gv) print "Create network file with all buildings connected" nM.Network_Summary(locator, total_demand, building_names, gv, "all") #"_all" key for all buildings print "Solar features extraction" solarFeat = sFn.solarRead(locator, gv) print "electricity" elecCosts, elecCO2, elecPrim = electricity.calc_pareto_electricity(locator, gv) print "Process Heat " hpCosts, hpCO2, hpPrim = hpMain.calc_pareto_Qhp(locator, total_demand, gv) extraCosts = elecCosts + hpCosts extraCO2 = elecCO2 + hpCO2 extraPrim = elecPrim + hpPrim return extraCosts, extraCO2, extraPrim, solarFeat
def main(config): locator = cea.inputlocator.InputLocator(scenario=config.scenario) weather_data = epwreader.epw_reader(config.weather)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] year = weather_data['year'][0] region = config.region settings = config.demand use_daysim_radiation = settings.use_daysim_radiation building_properties, schedules_dict, date = properties_and_schedule( locator, region, year, use_daysim_radiation) list_building_names = building_properties.list_building_names() eval_nn_performance( locator, random_variables, target_parameters, list_building_names, config=config, nn_delay=config.neural_network.nn_delay, climatic_variables=config.neural_network.climatic_variables, region=config.region, year=config.neural_network.year, use_daysim_radiation=settings.use_daysim_radiation, use_stochastic_occupancy=config.demand.use_stochastic_occupancy)
def setUpClass(cls): import zipfile import tempfile import cea.examples cls.locator = cea.inputlocator.ReferenceCaseOpenLocator() cls.config = cea.config.Configuration(cea.config.DEFAULT_CONFIG) weather_path = cls.locator.get_weather('Zug') cls.weather_data = epwreader.epw_reader(weather_path)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] year = cls.weather_data['year'][0] cls.region = cls.config.region cls.test_config = ConfigParser.SafeConfigParser() cls.test_config.read( os.path.join(os.path.dirname(__file__), 'test_calc_thermal_loads.config')) # run properties script import cea.datamanagement.data_helper cea.datamanagement.data_helper.data_helper(cls.locator, cls.config, True, True, True, True, True, True) use_daysim_radiation = cls.config.demand.use_daysim_radiation cls.building_properties, cls.usage_schedules, cls.date = properties_and_schedule( cls.locator, cls.region, year, use_daysim_radiation) cls.use_dynamic_infiltration_calculation = cls.config.demand.use_dynamic_infiltration_calculation cls.use_stochastic_occupancy = cls.config.demand.use_stochastic_occupancy cls.resolution_output = cls.config.demand.resolution_output cls.loads_output = cls.config.demand.loads_output cls.massflows_output = cls.config.demand.massflows_output cls.temperatures_output = cls.config.demand.temperatures_output cls.format_output = cls.config.demand.format_output
def main(config): gv = cea.globalvar.GlobalVariables() settings = config.demand use_daysim_radiation = settings.use_daysim_radiation weather_data = epwreader.epw_reader(config.weather)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] year = weather_data['year'][0] region = config.region locator = cea.inputlocator.InputLocator(scenario=config.scenario) building_properties, schedules_dict, date = properties_and_schedule( locator, region, year, use_daysim_radiation) list_building_names = building_properties.list_building_names() target_parameters = [ 'Qhsf_kWh', 'Qcsf_kWh', 'Qwwf_kWh', 'Ef_kWh', 'T_int_C' ] input_prepare_main( list_building_names, locator, target_parameters, nn_delay=config.neural_network.nn_delay, climatic_variables=config.neural_network.climatic_variables, region=config.region, year=config.neural_network.year, use_daysim_radiation=settings.use_daysim_radiation, use_stochastic_occupancy=config.demand.use_stochastic_occupancy)
def calc_SC(locator, sensors_data, radiation, latitude, longitude, year, gv, weather_path): # weather data weather_data = epwreader.epw_reader(weather_path) # solar properties g, Sz, Az, ha, trr_mean, worst_sh, worst_Az = solar_equations.calc_sun_properties(latitude, longitude, weather_data, gv) # read radiation file hourly_data = pd.read_csv(radiation) # get only datapoints with production beyond min_production Max_Isol = hourly_data.total.max() Min_Isol = Max_Isol * gv.min_production # 80% of the local average maximum in the area sensors_data_clean = sensors_data[sensors_data["total"] > Min_Isol] radiation_clean =radiation.loc[radiation['sensor_id'].isin(sensors_data_clean.sensor_id)] # Calculate the heights of all buildings for length of vertical pipes height = locator.get_total_demand().height.sum() # calculate optimal angle and tilt for panels optimal_angle_and_tilt(sensors_data, latitude, worst_sh, worst_Az, trr_mean, gv.grid_side, gv.module_lenght_SC, gv.angle_north, Min_Isol, Max_Isol) Number_groups, hourlydata_groups, number_points, prop_observers = calc_groups(radiation_clean, sensors_data_clean) result, Final = SC_generation(gv.type_SCpanel, hourlydata_groups, prop_observers, number_points, g, Sz, Az, ha, latitude, gv.Tin, height) Final.to_csv(locator.solar_collectors_result(), index=True, float_format='%.2f') return
def main(config): gv = cea.globalvar.GlobalVariables() locator = cea.inputlocator.InputLocator(scenario=config.scenario) weather_data = epwreader.epw_reader(config.weather)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] year = weather_data['year'][0] region = config.region settings = config.demand use_daysim_radiation = settings.use_daysim_radiation weather_path = config.weather building_properties, schedules_dict, date = properties_and_schedule( gv, locator, region, year, use_daysim_radiation) list_building_names = building_properties.list_building_names() scalerX_file, scalerT_file = locator.get_minmaxscalar_model() scalerX = joblib.load(scalerX_file) scalerT = joblib.load(scalerT_file) run_nn_pipeline( locator, random_variables, target_parameters, list_building_names, weather_path, gv, scalerX, scalerT, multiprocessing=config.multiprocessing, config=config, nn_delay=config.neural_network.nn_delay, climatic_variables=config.neural_network.climatic_variables, region=config.region, year=config.neural_network.year, use_daysim_radiation=settings.use_daysim_radiation)
def weather_data(self): if self.__weather_data is None: weather_path = self.locator.get_weather_file() self.__weather_data = epwreader.epw_reader(weather_path)[[ 'year', 'drybulb_C', 'wetbulb_C' ]] return self.__weather_data
def run_as_script(scenario_path=None): """ run the whole network summary routine """ import cea.globalvar import cea.inputlocator as inputlocator from geopandas import GeoDataFrame as gpdf from cea.utilities import epwreader from cea.resources import geothermal gv = cea.globalvar.GlobalVariables() if scenario_path is None: scenario_path = gv.scenario_reference locator = inputlocator.InputLocator(scenario_path=scenario_path) total_demand = pd.read_csv(locator.get_total_demand()) building_names = pd.read_csv(locator.get_total_demand())['Name'] weather_file = locator.get_default_weather() # add geothermal part of preprocessing T_ambient = epwreader.epw_reader(weather_file)['drybulb_C'] gv.ground_temperature = geothermal.calc_ground_temperature(T_ambient.values, gv) #substation_main(locator, total_demand, total_demand['Name'], gv, False) t = 1000 # FIXME T_DH = 60 # FIXME network = 'DH' # FIXME t_flag = True # FIXME substations_HEX_specs, buildings = substation_HEX_design_main(locator, total_demand, building_names, gv) substation_return_model_main(locator, gv, building_names, buildings, substations_HEX_specs, T_DH, t, network, t_flag) print 'substation_main() succeeded'
def run_as_script(config): gv = cea.globalvar.GlobalVariables() settings = config.demand use_daysim_radiation = settings.use_daysim_radiation weather_data = epwreader.epw_reader(config.weather)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] year = weather_data['year'][0] region = config.region locator = cea.inputlocator.InputLocator(scenario=config.scenario) building_properties, schedules_dict, date = properties_and_schedule( locator, region, year, use_daysim_radiation) list_building_names = building_properties.list_building_names() sampling_scaler( locator=locator, random_variables=config.neural_network.random_variables, target_parameters=config.neural_network.target_parameters, boolean_vars=config.neural_network.boolean_vars, list_building_names=list_building_names, number_samples_scaler=config.neural_network.number_samples_scaler, nn_delay=config.neural_network.nn_delay, gv=gv, config=config, climatic_variables=config.neural_network.climatic_variables, year=config.neural_network.year, use_daysim_radiation=settings.use_daysim_radiation, use_stochastic_occupancy=config.demand.use_stochastic_occupancy, region=region)
def setUpClass(cls): import cea.examples cls.locator = cea.inputlocator.ReferenceCaseOpenLocator() cls.config = cea.config.Configuration(cea.config.DEFAULT_CONFIG) weather_path = cls.locator.get_weather('Zug-inducity_1990_2010_TMY') cls.weather_data = epwreader.epw_reader(weather_path)[ ['year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C']] year = cls.weather_data['year'][0] cls.date_range = get_dates_from_year(year) cls.test_config = ConfigParser.SafeConfigParser() cls.test_config.read(os.path.join(os.path.dirname(__file__), 'test_calc_thermal_loads.config')) # run properties script import cea.datamanagement.data_helper cea.datamanagement.data_helper.data_helper(cls.locator, 'CH', True, True, True, True, True, True, True) cls.building_properties = BuildingProperties(cls.locator, cls.config.demand.override_variables) cls.use_dynamic_infiltration_calculation = cls.config.demand.use_dynamic_infiltration_calculation cls.resolution_output = cls.config.demand.resolution_output cls.loads_output = cls.config.demand.loads_output cls.massflows_output = cls.config.demand.massflows_output cls.temperatures_output = cls.config.demand.temperatures_output cls.format_output = cls.config.demand.format_output cls.write_detailed_output = cls.config.demand.write_detailed_output cls.debug = cls.config.debug
def calc_geothermal_potential(locator, config): "A very simplified calculation based on the area available" # local variables weather_file = locator.get_weather_file() buildings = config.shallow_geothermal.buildings_available extra_area = config.shallow_geothermal.extra_area_available depth_m = config.shallow_geothermal.average_probe_depth # dataprocessing area_below_buildings = calc_area_buildings(locator, buildings) T_ambient_C = epwreader.epw_reader(weather_file)[['drybulb_C']].values # total area available area_geothermal = extra_area + area_below_buildings T_ground_K = calc_ground_temperature(locator, T_ambient_C, depth_m) # convert back to degrees C t_source_final = [x[0] - 273 for x in T_ground_K] Q_max_kwh = np.ceil( area_geothermal / GHP_A) * GHP_HMAX_SIZE / 1000 # [kW th] # export output_file = locator.get_geothermal_potential() pd.DataFrame({ "Ts_C": t_source_final, "QGHP_kW": Q_max_kwh, "Area_avail_m2": area_geothermal }).to_csv(output_file, index=False, float_format='%.3f')
def preproccessing(locator, total_demand, building_names, weather_file, gv): # read weather and calculate ground temperature T_ambient = epwreader.epw_reader(weather_file)['drybulb_C'] gv.ground_temperature = geothermal.calc_ground_temperature( T_ambient.values, gv) print "Run substation model for each building separately" subsM.subsMain(locator, total_demand, building_names, gv, Flag=True) # 1 if disconected buildings are calculated print "Heating operation pattern for disconnected buildings" dbM.discBuildOp(locator, building_names, gv) print "Create network file with all buildings connected" nM.Network_Summary(locator, total_demand, building_names, gv, "all") #"_all" key for all buildings print "Solar features extraction" solarFeat = sFn.solarRead(locator, gv) print "electricity" elecCosts, elecCO2, elecPrim = electricity.calc_pareto_electricity( locator, gv) print "Process Heat " hpCosts, hpCO2, hpPrim = hpMain.calc_pareto_Qhp(locator, total_demand, gv) extraCosts = elecCosts + hpCosts extraCO2 = elecCO2 + hpCO2 extraPrim = elecPrim + hpPrim return extraCosts, extraCO2, extraPrim, solarFeat
def main(): locator = InputLocator(REFERENCE_CASE) gv = GlobalVariables() weather_path = locator.get_default_weather() weather_data = epwreader.epw_reader(weather_path)[[ 'drybulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] building_properties = BuildingProperties(locator, gv) date = pd.date_range(gv.date_start, periods=8760, freq='H') list_uses = building_properties.list_uses() schedules = schedule_maker(date, locator, list_uses) usage_schedules = {'list_uses': list_uses, 'schedules': schedules} print("data for test_calc_thermal_loads_new_ventilation:") print building_properties.list_building_names() bpr = building_properties['B01'] result = calc_thermal_loads('B01', bpr, weather_data, usage_schedules, date, gv, locator) # test the building csv file df = pd.read_csv(locator.get_demand_results_file('B01')) expected_columns = list(df.columns) print("expected_columns = %s" % repr(expected_columns)) value_columns = [ u'Ealf_kWh', u'Eauxf_kWh', u'Edataf_kWh', u'Ef_kWh', u'QCf_kWh', u'QHf_kWh', u'Qcdataf_kWh', u'Qcref_kWh', u'Qcs_kWh', u'Qcsf_kWh', u'Qhs_kWh', u'Qhsf_kWh', u'Qww_kWh', u'Qwwf_kWh', u'Tcsf_re_C', u'Thsf_re_C', u'Twwf_re_C', u'Tcsf_sup_C', u'Thsf_sup_C', u'Twwf_sup_C' ] print("values = %s " % repr([df[column].sum() for column in value_columns])) print("data for test_calc_thermal_loads_other_buildings:") # randomly selected except for B302006716, which has `Af == 0` buildings = { 'B01': (81124.39400, 150471.05200), 'B03': (81255.09200, 150520.01000), 'B02': (82176.15300, 150604.85100), 'B05': (84058.72400, 150841.56200), 'B04': (82356.22600, 150598.43400), 'B07': (81052.19000, 150490.94800), 'B06': (83108.45600, 150657.24900), 'B09': (84491.58100, 150853.54000), 'B08': (88572.59000, 151020.09300), } for building in buildings.keys(): bpr = building_properties[building] b, qcf_kwh, qhf_kwh = run_for_single_building(building, bpr, weather_data, usage_schedules, date, gv, locator) print("'%(b)s': (%(qcf_kwh).5f, %(qhf_kwh).5f)," % locals())
def schedule_maker_main(locator, config, building=None): # local variables buildings = config.schedule_maker.buildings schedule_model = config.schedule_maker.schedule_model if schedule_model == 'deterministic': stochastic_schedule = False elif schedule_model == 'stochastic': stochastic_schedule = True else: raise ValueError("Invalid schedule model: {schedule_model}".format(**locals())) if building != None: buildings = [building] # this is to run the tests # CHECK DATABASE if is_3_22(config.scenario): raise ValueError("""The data format of indoor comfort has been changed after v3.22. Please run Data migrator in Utilities.""") # get variables of indoor comfort and internal loads internal_loads = dbf_to_dataframe(locator.get_building_internal()).set_index('Name') indoor_comfort = dbf_to_dataframe(locator.get_building_comfort()).set_index('Name') architecture = dbf_to_dataframe(locator.get_building_architecture()).set_index('Name') # get building properties prop_geometry = Gdf.from_file(locator.get_zone_geometry()) prop_geometry['footprint'] = prop_geometry.area prop_geometry['GFA_m2'] = prop_geometry['footprint'] * (prop_geometry['floors_ag'] + prop_geometry['floors_bg']) prop_geometry['GFA_ag_m2'] = prop_geometry['footprint'] * prop_geometry['floors_ag'] prop_geometry['GFA_bg_m2'] = prop_geometry['footprint'] * prop_geometry['floors_bg'] prop_geometry = prop_geometry.merge(architecture, on='Name').set_index('Name') prop_geometry = calc_useful_areas(prop_geometry) # get calculation year from weather file weather_path = locator.get_weather_file() weather_data = epwreader.epw_reader(weather_path)[['year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C']] year = weather_data['year'][0] # create date range for the calculation year date_range = get_date_range_hours_from_year(year) # SCHEDULE MAKER n = len(buildings) calc_schedules_multiprocessing = cea.utilities.parallel.vectorize(calc_schedules, config.get_number_of_processes(), on_complete=print_progress) calc_schedules_multiprocessing(repeat(locator, n), buildings, repeat(date_range, n), [internal_loads.loc[b] for b in buildings], [indoor_comfort.loc[b] for b in buildings], [prop_geometry.loc[b] for b in buildings], repeat(stochastic_schedule, n)) return None
def isolation_daysim(chunk_n, rad, geometry_3D_zone, locator, weather_path, settings): # folder for data work daysim_dir = locator.get_temporary_file("temp" + str(chunk_n)) rad.initialise_daysim(daysim_dir) # calculate sensors print " calculating and sending sensor points" sensors_coords_zone, sensors_dir_zone, sensors_number_zone, names_zone, \ sensors_code_zone = calc_sensors_zone(geometry_3D_zone, locator, settings) rad.set_sensor_points(sensors_coords_zone, sensors_dir_zone) create_sensor_input_file(rad, chunk_n) num_sensors = sum(sensors_number_zone) print "Daysim simulation starts for building(s)", names_zone print "and the next number of total sensors", num_sensors if num_sensors > 50000: raise ValueError( 'You are sending more than 50000 sensors at the same time, this \ will eventually crash a daysim instance. To solve it, reduce the number of buildings \ in each chunk in the Settings.py file') # add_elevation_weather_file(weather_path) rad.execute_epw2wea(weather_path, ground_reflectance=settings.albedo) rad.execute_radfiles2daysim() rad.write_radiance_parameters( settings.rad_ab, settings.rad_ad, settings.rad_as, settings.rad_ar, settings.rad_aa, settings.rad_lr, settings.rad_st, settings.rad_sj, settings.rad_lw, settings.rad_dj, settings.rad_ds, settings.rad_dr, settings.rad_dp) rad.execute_gen_dc("w/m2") rad.execute_ds_illum() solar_res = rad.eval_ill_per_sensor() #erase daysim folder to avoid conflicts after every iteration shutil.rmtree(daysim_dir) # check inconsistencies and replace by max value of weather file # check inconsistencies and replace by max value of weather file weatherfile = epwreader.epw_reader(weather_path)['glohorrad_Whm2'].values max_global = weatherfile.max() for i, value in enumerate(solar_res): solar_res[i] = [0 if x > max_global else x for x in value] print "Writing results to disk" index = 0 for building_name, sensors_number_building, sensor_code_building in zip( names_zone, sensors_number_zone, sensors_code_zone): selection_of_results = solar_res[index:index + sensors_number_building] items_sensor_name_and_result = dict( zip(sensor_code_building, selection_of_results)) with open(locator.get_radiation_building(building_name), 'w') as outfile: json.dump(items_sensor_name_and_result, outfile) index = index + sensors_number_building
def radiation_singleprocessing(cea_daysim, zone_building_names, locator, settings, geometry_pickle_dir, num_processes): weather_path = locator.get_weather_file() # check inconsistencies and replace by max value of weather file weatherfile = epwreader.epw_reader(weather_path) max_global = weatherfile['glohorrad_Whm2'].max() list_of_building_names = [ building_name for building_name in settings.buildings if building_name in zone_building_names ] # get chunks of buildings to iterate chunks = [ list_of_building_names[i:i + settings.n_buildings_in_chunk] for i in range(0, len(list_of_building_names), settings.n_buildings_in_chunk) ] write_sensor_data = settings.write_sensor_data radiance_parameters = { "rad_ab": settings.rad_ab, "rad_ad": settings.rad_ad, "rad_as": settings.rad_as, "rad_ar": settings.rad_ar, "rad_aa": settings.rad_aa, "rad_lr": settings.rad_lr, "rad_st": settings.rad_st, "rad_sj": settings.rad_sj, "rad_lw": settings.rad_lw, "rad_dj": settings.rad_dj, "rad_ds": settings.rad_ds, "rad_dr": settings.rad_dr, "rad_dp": settings.rad_dp } grid_size = { "walls_grid": settings.walls_grid, "roof_grid": settings.roof_grid } num_chunks = len(chunks) if num_chunks == 1: for chunk_n, building_names in enumerate(chunks): daysim_main.isolation_daysim(chunk_n, cea_daysim, building_names, locator, radiance_parameters, write_sensor_data, grid_size, max_global, weatherfile, geometry_pickle_dir) else: vectorize(daysim_main.isolation_daysim, num_processes)(range(0, num_chunks), repeat(cea_daysim, num_chunks), chunks, repeat(locator, num_chunks), repeat(radiance_parameters, num_chunks), repeat(write_sensor_data, num_chunks), repeat(grid_size, num_chunks), repeat(max_global, num_chunks), repeat(weatherfile, num_chunks), repeat(geometry_pickle_dir, num_chunks))
def input_prepare_main(list_building_names, locator, target_parameters, gv, nn_delay, climatic_variables, region, year, use_daysim_radiation, use_stochastic_occupancy): ''' this function prepares the inputs and targets for the neural net by splitting the jobs between different processors :param list_building_names: a list of building names :param locator: points to the variables :param target_parameters: (imported from 'nn_settings.py') a list containing the name of desirable outputs :param gv: global variables :return: inputs and targets for the whole dataset (urban_input_matrix, urban_taget_matrix) ''' # collect weather data weather_data = epwreader.epw_reader( locator.get_default_weather())[climatic_variables] # transpose the weather array weather_array = np.transpose(np.asarray(weather_data)) building_properties, schedules_dict, date = properties_and_schedule( gv, locator, region, year, use_daysim_radiation) # ***tag (#) lines 40-68 if you DO NOT want multiprocessing*** # multiprocessing pool pool = mp.Pool() # count number of CPUs gv.log("Using %i CPU's" % mp.cpu_count()) # creat an empty job list to be filled later joblist = [] # create one job for each data preparation task i.e. each building from cea.demand.metamodel.nn_generator.input_matrix import input_prepare_multi_processing for building_name in list_building_names: job = pool.apply_async(input_prepare_multi_processing, [ building_name, gv, locator, target_parameters, nn_delay, climatic_variables, region, year, use_daysim_radiation, use_stochastic_occupancy, weather_array, weather_data, building_properties, schedules_dict, date ]) joblist.append(job) # run the input/target preperation for all buildings in the list (here called jobs) for i, job in enumerate(joblist): NN_input_ready, NN_target_ready = job.get(240) # remove buildings that have "NaN" in their input (e.g. if heating/cooling is off, the indoor temperature # will be returned as "NaN"). Afterwards, stack the inputs/targets of all buildings check_nan = 1 * (np.isnan(np.sum(NN_input_ready))) if check_nan == 0: if i == 0: urban_input_matrix = NN_input_ready urban_taget_matrix = NN_target_ready else: urban_input_matrix = np.concatenate( (urban_input_matrix, NN_input_ready)) urban_taget_matrix = np.concatenate( (urban_taget_matrix, NN_target_ready)) # close the multiprocessing pool.close() print urban_input_matrix return urban_input_matrix, urban_taget_matrix
def preproccessing(locator, total_demand, buildings_heating_demand, buildings_cooling_demand, weather_file, district_heating_network, district_cooling_network): """ This function aims at preprocessing all data for the optimization. :param locator: path to locator function :param total_demand: dataframe with total demand and names of all building in the area :param building_names: dataframe with names of all buildings in the area :param weather_file: path to wather file :type locator: class :type total_demand: list :type building_names: list :type weather_file: string :return: - extraCosts: extra pareto optimal costs due to electricity and process heat ( these are treated separately and not considered inside the optimization) - extraCO2: extra pareto optimal emissions due to electricity and process heat ( these are treated separately and not considered inside the optimization) - extraPrim: extra pareto optimal primary energy due to electricity and process heat ( these are treated separately and not considered inside the optimization) - solar_features: extraction of solar features form the results of the solar technologies calculation. :rtype: float, float, float, float """ # local variables network_depth_m = Z0 print("PRE-PROCESSING 1/2: weather properties") T_ambient = epwreader.epw_reader(weather_file)['drybulb_C'] ground_temp = calc_ground_temperature(locator, T_ambient, depth_m=network_depth_m) print("PRE-PROCESSING 2/2: thermal networks") # at first estimate a distribution with all the buildings connected if district_heating_network: num_tot_buildings = len(buildings_heating_demand) DHN_barcode = ''.join(str(1) for e in range(num_tot_buildings)) substation.substation_main_heating(locator, total_demand, buildings_heating_demand, DHN_barcode=DHN_barcode) summarize_network.network_main(locator, buildings_heating_demand, ground_temp, num_tot_buildings, "DH", DHN_barcode) # "_all" key for all buildings if district_cooling_network: num_tot_buildings = len(buildings_cooling_demand) DCN_barcode = ''.join(str(1) for e in range(num_tot_buildings)) substation.substation_main_cooling(locator, total_demand, buildings_cooling_demand, DCN_barcode=DCN_barcode) summarize_network.network_main(locator, buildings_cooling_demand, ground_temp, num_tot_buildings, "DC", DCN_barcode) # "_all" key for all buildings network_features = NetworkOptimizationFeatures(district_heating_network, district_cooling_network, locator) return network_features
def calculate_daily_transmissivity_and_daily_diffusivity(weather_path): # calcuate daily transmissivity and daily diffusivity weather_data = epwreader.epw_reader(weather_path)[['dayofyear', 'exthorrad_Whm2', 'glohorrad_Whm2', 'difhorrad_Whm2']] weather_data['diff'] = weather_data.difhorrad_Whm2 / weather_data.glohorrad_Whm2 weather_data = weather_data[np.isfinite(weather_data['diff'])] daily_transmissivity = np.round(weather_data.groupby(['dayofyear']).mean(), 2) daily_transmissivity['diff'] = daily_transmissivity['diff'].replace(1, 0.90) daily_transmissivity['trr'] = (1 - daily_transmissivity['diff']) return daily_transmissivity
def _calculate_PVT_hourly_aggregated_kW(self): # get extra data of weather and date weather_data = epwreader.epw_reader( self.weather)[["date", "drybulb_C", "wetbulb_C", "skytemp_C"]] pvt_hourly_aggregated_kW = sum( pd.read_csv(self.locator.PVT_results(building), usecols=self.pvt_analysis_fields) for building in self.buildings) pvt_hourly_aggregated_kW['DATE'] = weather_data["date"] return pvt_hourly_aggregated_kW
def main(config): assert os.path.exists( config.scenario), 'Scenario not found: %s' % config.scenario locator = cea.inputlocator.InputLocator(scenario=config.scenario) print('Running photovoltaic with scenario = %s' % config.scenario) print('Running photovoltaic with annual-radiation-threshold-kWh/m2 = %s' % config.solar.annual_radiation_threshold) print('Running photovoltaic with panel-on-roof = %s' % config.solar.panel_on_roof) print('Running photovoltaic with panel-on-wall = %s' % config.solar.panel_on_wall) print('Running photovoltaic with solar-window-solstice = %s' % config.solar.solar_window_solstice) print('Running photovoltaic with type-pvpanel = %s' % config.solar.type_pvpanel) if config.solar.custom_tilt_angle: print( 'Running photovoltaic with custom-tilt-angle = %s and panel-tilt-angle = %s' % (config.solar.custom_tilt_angle, config.solar.panel_tilt_angle)) else: print('Running photovoltaic with custom-tilt-angle = %s' % config.solar.custom_tilt_angle) if config.solar.custom_roof_coverage: print( 'Running photovoltaic with custom-roof-coverage = %s and max-roof-coverage = %s' % (config.solar.custom_roof_coverage, config.solar.max_roof_coverage)) else: print('Running photovoltaic with custom-roof-coverage = %s' % config.solar.custom_roof_coverage) building_names = locator.get_zone_building_names() zone_geometry_df = gdf.from_file(locator.get_zone_geometry()) latitude, longitude = get_lat_lon_projected_shapefile(zone_geometry_df) # list_buildings_names =['B026', 'B036', 'B039', 'B043', 'B050'] for missing buildings weather_data = epwreader.epw_reader(locator.get_weather_file()) date_local = solar_equations.calc_datetime_local_from_weather_file( weather_data, latitude, longitude) num_process = config.get_number_of_processes() n = len(building_names) cea.utilities.parallel.vectorize(calc_PV, num_process)(repeat(locator, n), repeat(config, n), repeat(latitude, n), repeat(longitude, n), repeat(weather_data, n), repeat(date_local, n), building_names) # aggregate results from all buildings write_aggregate_results(locator, building_names, num_process)
def disconnected_buildings_heating_main(locator, total_demand, building_names, config, prices, lca): """ Computes the parameters for the operation of disconnected buildings output results in csv files. There is no optimization at this point. The different technologies are calculated and compared 1 to 1 to each technology. it is a classical combinatorial problem. :param locator: locator class :param building_names: list with names of buildings :type locator: class :type building_names: list :return: results of operation of buildings located in locator.get_optimization_decentralized_folder :rtype: Nonetype """ t0 = time.perf_counter() prop_geometry = Gdf.from_file(locator.get_zone_geometry()) geometry = pd.DataFrame({ 'Name': prop_geometry.Name, 'Area': prop_geometry.area }) geothermal_potential_data = dbf.dbf_to_dataframe( locator.get_building_supply()) geothermal_potential_data = pd.merge(geothermal_potential_data, geometry, on='Name') geothermal_potential_data['Area_geo'] = geothermal_potential_data['Area'] weather_path = locator.get_weather_file() weather_data = epwreader.epw_reader(weather_path)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] T_ground_K = calc_ground_temperature(locator, weather_data['drybulb_C'], depth_m=10) supply_systems = SupplySystemsDatabase(locator) # This will calculate the substation state if all buildings where connected(this is how we study this) substation.substation_main_heating(locator, total_demand, building_names) n = len(building_names) cea.utilities.parallel.vectorize(disconnected_heating_for_building, config.get_number_of_processes())( building_names, repeat(supply_systems, n), repeat(T_ground_K, n), repeat(geothermal_potential_data, n), repeat(lca, n), repeat(locator, n), repeat(prices, n)) print(time.perf_counter() - t0, "seconds process time for the Disconnected Building Routine \n")
def calculate_ground_temperature(locator): """ calculate ground temperatures. :param locator: :return: list of ground temperatures, one for each hour of the year :rtype: list[np.float64] """ weather_file = locator.get_weather_file() T_ambient_C = epw_reader(weather_file)['drybulb_C'] network_depth_m = NETWORK_DEPTH # [m] T_ground_K = geothermal.calc_ground_temperature(locator, T_ambient_C.values, network_depth_m) return T_ground_K
def get_array_weather_variables(locator, climatic_variables): ''' this function collects the climatic features :param locator: points to the variables :return: array of climatic features and weather properties (weather_array, weather_data) ''' # collect weather data weather_data = epwreader.epw_reader( locator.get_default_weather())[climatic_variables] # transpose the weather array weather_array = np.transpose(np.asarray(weather_data)) return weather_array, weather_data
def calc_VCC_COP(config, load_types, centralized=True): """ Calculates the VCC COP based on evaporator and compressor temperatures, VCC g-value, and an assumption of auxiliary power demand for centralized and decentralized systems. This approximation only works in tropical climates Clark D (CUNDALL). Chiller energy efficiency 2013. :param load_types: a list containing the systems (aru, ahu, scu) that the chiller is supplying for :param centralized: :return: """ if centralized == True: g_value = G_VALUE_CENTRALIZED else: g_value = G_VALUE_DECENTRALIZED T_evap_K = 10000000 # some high enough value for load_type in load_types: # find minimum evap temperature of supplied loads if load_type == 'ahu': T_evap_K = min(T_evap_K, T_EVAP_AHU) elif load_type == 'aru': T_evap_K = min(T_evap_K, T_EVAP_ARU) elif load_type == 'scu': T_evap_K = min(T_evap_K, T_EVAP_SCU) else: print 'Undefined cooling load_type for chiller COP calculation.' if centralized == True: # Todo: improve this to a better approximation than a static value DT_Network # for the centralized case we have to supply somewhat colder, currently based on CEA calculation for MIX_m case T_evap_K = T_evap_K - DT_NETWORK_CENTRALIZED # read weather data for condeser temperature calculation locator = cea.inputlocator.InputLocator(config.scenario) weather_path = locator.get_weather_file() weather_data = epwreader.epw_reader(weather_path)[[ 'year', 'drybulb_C', 'wetbulb_C' ]] # calculate condenser temperature with static approach temperature assumptions # FIXME: only work for tropical climates T_cond_K = np.mean( weather_data['wetbulb_C'] ) + CHILLER_DELTA_T_APPROACH + CHILLER_DELTA_T_HEX_CT + 273.15 # calculate chiller COP cop_chiller = g_value * T_evap_K / (T_cond_K - T_evap_K) # calculate system COP with pumping power of auxiliaries if centralized == True: cop_system = 1 / (1 / cop_chiller * (1 + CENTRALIZED_AUX_PERCENTAGE / 100)) else: cop_system = 1 / (1 / cop_chiller * (1 + DECENTRALIZED_AUX_PERCENTAGE / 100)) return cop_system, cop_chiller
def main(): locator = InputLocator(REFERENCE_CASE) gv = GlobalVariables() weather_path = locator.get_default_weather() weather_data = epwreader.epw_reader(weather_path)[['drybulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C']] building_properties = BuildingProperties(locator, gv) date = pd.date_range(gv.date_start, periods=8760, freq='H') list_uses = building_properties.list_uses() schedules = schedule_maker(date, locator, list_uses) usage_schedules = {'list_uses': list_uses, 'schedules': schedules} print("data for test_calc_thermal_loads_new_ventilation:") print building_properties.list_building_names() bpr = building_properties['B01'] result = calc_thermal_loads('B01', bpr, weather_data, usage_schedules, date, gv, locator) # test the building csv file df = pd.read_csv(locator.get_demand_results_file('B01')) expected_columns = list(df.columns) print("expected_columns = %s" % repr(expected_columns)) value_columns = [u'Ealf_kWh', u'Eauxf_kWh', u'Edataf_kWh', u'Ef_kWh', u'QCf_kWh', u'QHf_kWh', u'Qcdataf_kWh', u'Qcref_kWh', u'Qcs_kWh', u'Qcsf_kWh', u'Qhs_kWh', u'Qhsf_kWh', u'Qww_kWh', u'Qwwf_kWh', u'Tcsf_re_C', u'Thsf_re_C', u'Twwf_re_C', u'Tcsf_sup_C', u'Thsf_sup_C', u'Twwf_sup_C'] print("values = %s " % repr([df[column].sum() for column in value_columns])) print("data for test_calc_thermal_loads_other_buildings:") # randomly selected except for B302006716, which has `Af == 0` buildings = {'B01': (81124.39400, 150471.05200), 'B03': (81255.09200, 150520.01000), 'B02': (82176.15300, 150604.85100), 'B05': (84058.72400, 150841.56200), 'B04': (82356.22600, 150598.43400), 'B07': (81052.19000, 150490.94800), 'B06': (83108.45600, 150657.24900), 'B09': (84491.58100, 150853.54000), 'B08': (88572.59000, 151020.09300), } for building in buildings.keys(): bpr = building_properties[building] b, qcf_kwh, qhf_kwh = run_for_single_building(building, bpr, weather_data, usage_schedules, date, gv, locator) print("'%(b)s': (%(qcf_kwh).5f, %(qhf_kwh).5f)," % locals())
def main(config): locator = cea.inputlocator.InputLocator(scenario=config.scenario) weather_data = epwreader.epw_reader(locator.get_weather_file())[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] year = weather_data['year'][0] settings = config.demand building_properties, schedules_dict, date = properties_and_schedule( locator, year) list_building_names = building_properties.list_building_names() ss_calibrator( number_samples_scaler=config.neural_network.number_samples_scaler, locator=cea.inputlocator.InputLocator(scenario=config.scenario), list_building_names=building_properties.list_building_names())
def radiation_singleprocessing(rad, geometry_3D_zone, locator, settings): weather_path = locator.get_weather_file() # check inconsistencies and replace by max value of weather file weatherfile = epwreader.epw_reader(weather_path) max_global = weatherfile['glohorrad_Whm2'].max() selected_buildings = [bldg_dict for bldg_dict in geometry_3D_zone if bldg_dict['name'] in settings.buildings] # get chunks of buildings to iterate chunks = [selected_buildings[i:i + settings.n_buildings_in_chunk] for i in range(0, len(selected_buildings), settings.n_buildings_in_chunk)] for chunk_n, building_dict in enumerate(chunks): daysim_main.isolation_daysim(chunk_n, rad, building_dict, locator, settings, max_global, weatherfile)
def setUpClass(cls): if os.environ.has_key('REFERENCE_CASE'): cls.locator = InputLocator(os.environ['REFERENCE_CASE']) else: cls.locator = InputLocator(REFERENCE_CASE) cls.gv = GlobalVariables() weather_path = cls.locator.get_default_weather() cls.weather_data = epwreader.epw_reader(weather_path)[['drybulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C']] cls.building_properties = BuildingProperties(cls.locator, cls.gv) cls.date = pd.date_range(cls.gv.date_start, periods=8760, freq='H') cls.list_uses = cls.building_properties.list_uses() cls.schedules = schedule_maker(cls.date, cls.locator, cls.list_uses) cls.usage_schedules = {'list_uses': cls.list_uses, 'schedules': cls.schedules}
def solar_radiation_vertical(locator, path_arcgis_db, latitude, longitude, year, gv, weather_path): """ algorithm to calculate the hourly solar isolation in vertical building surfaces. The algorithm is based on the Solar Analyst Engine of ArcGIS 10. For more info check the integrated demand model of Fonseca et al. 2015. Appl. energy. Parameters ---------- path_geometry : string path to file buildings_geometry.shp path_boundary: renovation path to file zone_of_study.shp path_arcgis_db: boolean path to default database of Arcgis. Generally of the form c:\users\your_name\Documents\Arcgis\Default.gdb latitude: float latitude north at the centre of the location longitude: float latitude north timezone: integer timezone (UTC) year: integer year of calculation path_dem_raster: string path to terrain file weather_daily_data: string path to weather_day.csv file prop_architecture_flag: boolean True, get properties about the construction and architecture, otherwise False. prop_HVAC_flag: boolean True, get properties about types of HVAC systems, otherwise False. gv: GlobalVariables an instance of globalvar.GlobalVariables with the constants to use (like `list_uses` etc.) Returns ------- radiation: .csv solar radiation file in vertical surfaces of buildings stored in path_output """ # Set environment settings arcpy.env.workspace = path_arcgis_db arcpy.env.overwriteOutput = True arcpy.CheckOutExtension("spatial") # local variables aspect_slope = "FROM_DEM" heightoffset = 1 Simple_CQ = path_arcgis_db + "\\" + "Simple_CQ" Simple_context = path_arcgis_db + "\\" + "Simple_context" dem_rasterfinal = path_arcgis_db + "\\" + "DEM_All2" observers = path_arcgis_db + "\\" + "observers" DataFactorsBoundaries = locator.get_temporary_file("DataFactorsBoundaries.csv") DataFactorsCentroids = locator.get_temporary_file("DataFactorsCentroids.csv") DataradiationLocation = locator.get_temporary_file("RadiationYear.csv") # calculate sunrise sunrise = calc_sunrise(range(1, 366), year, longitude, latitude, gv) # calcuate daily transmissivity and daily diffusivity weather_data = epwreader.epw_reader(weather_path)[ ["dayofyear", "exthorrad_Whm2", "glohorrad_Whm2", "difhorrad_Whm2"] ] weather_data["diff"] = weather_data.difhorrad_Whm2 / weather_data.glohorrad_Whm2 weather_data = weather_data[np.isfinite(weather_data["diff"])] T_G_day = np.round(weather_data.groupby(["dayofyear"]).mean(), 2) T_G_day["diff"] = T_G_day["diff"].replace(1, 0.90) T_G_day["trr"] = 1 - T_G_day["diff"] # T_G_day.to_csv(r'C:\Users\Jimeno\Documents/test4.csv') # Simplify building's geometry elevRaster = arcpy.sa.Raster(locator.get_terrain()) dem_raster_extent = elevRaster.extent arcpy.SimplifyBuilding_cartography( locator.get_building_geometry(), Simple_CQ, simplification_tolerance=8, minimum_area=None ) arcpy.SimplifyBuilding_cartography( locator.get_district(), Simple_context, simplification_tolerance=8, minimum_area=None ) # # burn buildings into raster Burn(Simple_context, locator.get_terrain(), dem_rasterfinal, locator.get_temporary_folder(), dem_raster_extent, gv) # Calculate boundaries of buildings CalcBoundaries( Simple_CQ, locator.get_temporary_folder(), path_arcgis_db, DataFactorsCentroids, DataFactorsBoundaries, gv ) # calculate observers CalcObservers(Simple_CQ, observers, DataFactorsBoundaries, path_arcgis_db, gv) # Calculate radiation for day in range(1, 366): result = None while result is None: # trick to avoid that arcgis stops calculating the days and tries again. try: result = CalcRadiation( day, dem_rasterfinal, observers, T_G_day, latitude, locator.get_temporary_folder(), aspect_slope, heightoffset, gv, ) except arcgisscripting.ExecuteError: # redo the calculation pass gv.log("complete raw radiation files") # run the transformation of files appending all and adding non-sunshine hours radiations = [] for day in range(1, 366): radiations.append(calc_radiation_day(day, sunrise, locator.get_temporary_folder())) radiationyear = radiations[0] for r in radiations[1:]: radiationyear = radiationyear.merge(r, on="ID", how="outer") radiationyear.fillna(value=0, inplace=True) radiationyear.to_csv(DataradiationLocation, Index=False) radiationyear = radiations = None gv.log("complete transformation radiation files") # Assign radiation to every surface of the buildings Data_radiation_path = CalcRadiationSurfaces( observers, DataFactorsCentroids, DataradiationLocation, locator.get_temporary_folder(), path_arcgis_db ) # get solar insolation @ daren: this is a A BOTTLE NECK CalcIncidentRadiation(Data_radiation_path, locator.get_radiation(), locator.get_surface_properties(), gv) gv.log("done")
def demand_calculation(locator, weather_path, gv): """ Algorithm to calculate the hourly demand of energy services in buildings using the integrated model of Fonseca et al. 2015. Applied energy. (http://dx.doi.org/10.1016/j.apenergy.2014.12.068) PARAMETERS ---------- :param locator: An InputLocator to locate input files :type locator: inputlocator.InputLocator :param weather_path: A path to the EnergyPlus weather data file (.epw) :type weather_path: str :param gv: A GlobalVariable (context) instance :type gv: globalvar.GlobalVariable RETURNS ------- :returns: None :rtype: NoneType INPUT / OUTPUT FILES -------------------- - get_radiation: c:\reference-case\baseline\outputs\data\solar-radiation\radiation.csv - get_surface_properties: c:\reference-case\baseline\outputs\data\solar-radiation\properties_surfaces.csv - get_building_geometry: c:\reference-case\baseline\inputs\building-geometry\zone.shp - get_building_hvac: c:\reference-case\baseline\inputs\building-properties\technical_systems.shp - get_building_thermal: c:\reference-case\baseline\inputs\building-properties\thermal_properties.shp - get_building_occupancy: c:\reference-case\baseline\inputs\building-properties\occupancy.shp - get_building_architecture: c:\reference-case\baseline\inputs\building-properties\architecture.shp - get_building_age: c:\reference-case\baseline\inputs\building-properties\age.shp - get_building_comfort: c:\reference-case\baseline\inputs\building-properties\indoor_comfort.shp - get_building_internal: c:\reference-case\baseline\inputs\building-properties\internal_loads.shp SIDE EFFECTS ------------ Produces a demand file per building and a total demand file for the whole zone of interest. B153767T.csv: csv file for every building with hourly demand data Total_demand.csv: csv file of yearly demand data per buidling. """ t0 = time.clock() date = pd.date_range(gv.date_start, periods=8760, freq='H') # weather model weather_data = epwreader.epw_reader(weather_path)[['drybulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C']] # building properties model building_properties = BuildingProperties(locator, gv) # schedules model list_uses = list(building_properties._prop_occupancy.drop('PFloor', axis=1).columns) schedules = occupancy_model.schedule_maker(date, locator, list_uses) schedules_dict = {'list_uses': list_uses, 'schedules': schedules} # demand model num_buildings = len(building_properties) if gv.multiprocessing and mp.cpu_count() > 1: thermal_loads_all_buildings_multiprocessing(building_properties, date, gv, locator, num_buildings, schedules_dict, weather_data) else: thermal_loads_all_buildings(building_properties, date, gv, locator, num_buildings, schedules_dict, weather_data) totals = write_totals_csv(building_properties, locator, gv) gv.log('done - time elapsed: %(time_elapsed).2f seconds', time_elapsed=time.clock() - t0) return totals