def test_benchmark(): locator = inputlocator.InputLocator( scenario_path=r'C:\reference-case-zug\baseline') locator_list = [locator, locator, locator, locator] output_file = os.path.expandvars(r'%TEMP%\test_benchmark.pdf') benchmark(locator_list=locator_list, output_file=output_file) print 'test_benchmark() succeeded'
def run_as_script(): gv = cea.globalvar.GlobalVariables() scenario_path = gv.scenario_reference locator = inputlocator.InputLocator(scenario=scenario_path) building_name = 'B155066' # intended building cluster_labels = ss_calibrator(building_name)
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(): import cea.globalvar import cea.inputlocator as inputlocator gv = cea.globalvar.GlobalVariables() scenario_path = gv.scenario_reference locator = inputlocator.InputLocator(scenario=scenario_path) output_parameters = ['QHf_MWhyr', 'QCf_MWhyr', 'Ef_MWhyr', 'QEf_MWhyr'] method = 'sobol' # method samples = 1000 graph(locator, output_parameters, method, samples)
def run_as_script(config): scenario = config.scenario locator = inputlocator.InputLocator(scenario=scenario) # based on the variables listed in the uncertainty database and selected # through a screening process. they need to be 5. variables = ['U_win', 'U_wall', 'n50', 'Ths_set_C', 'Cm_Af'] #uncertain variables building_name = 'B155066' # intended building building_load = 'Qhsf_kWh' # target of prediction sampling_main(locator, variables, building_name, building_load, config)
def run_as_script(): import cea.globalvar as gv import cea.inputlocator as inputlocator gv = gv.GlobalVariables() scenario_path = gv.scenario_reference locator = inputlocator.InputLocator(scenario_path=scenario_path) weather_path = locator.get_default_weather() output_parameters = ['QHf_MWhyr', 'QCf_MWhyr', 'Ef_MWhyr', 'QEf_MWhyr'] method = 'morris' groups_var = ['THERMAL'] num_samples = 1000 # generally 1000 or until it converges sensitivity_main(locator, weather_path, gv, output_parameters, groups_var, num_samples, method)
def testing(): import geopandas import cea.globalvar gv = cea.globalvar.GlobalVariables() from cea import inputlocator import time import cea.geometry.geometry_reader # generate windows based on geometry of vertical surfaces in radiation file locator = inputlocator.InputLocator( scenario_path=r'C:\reference-case\baseline') surface_properties = pd.read_csv(locator.get_surface_properties()) gdf_building_architecture = geopandas.GeoDataFrame.from_file( locator.get_building_architecture()).drop('geometry', axis=1).set_index('Name') prop_geometry = geopandas.GeoDataFrame.from_file( locator.get_building_geometry()) prop_geometry['footprint'] = prop_geometry.area prop_geometry['perimeter'] = prop_geometry.length prop_geometry = prop_geometry.drop('geometry', axis=1).set_index('Name') df_windows = cea.geometry.geometry_reader.simple_window_generator.create_windows( surface_properties, gdf_building_architecture) building_test = 'B153737' # 'B154767' this building doesn't have windows # get building windows df_windows_building_test = df_windows.loc[df_windows['name_building'] == building_test].to_dict('list') # get building geometry gdf_building_test = prop_geometry.ix[building_test] gdf_building_architecture = gdf_building_architecture.ix[building_test] r_window_arg = 0.1 temp_ext = 5 temp_zone = 22 u_wind = 0.5 u_wind_10 = u_wind factor_cros = 1 # 1 = cross ventilation possible # TODO: get from building properties dict_props_nat_vent = get_properties_natural_ventilation( gdf_building_test, gdf_building_architecture, gv) qm_arg_in, qm_arg_out \ = calc_qm_arg(factor_cros, temp_ext, df_windows_building_test, u_wind_10, temp_zone, r_window_arg) t0 = time.time() res = calc_air_flows(temp_zone, u_wind, temp_ext, dict_props_nat_vent) t1 = time.time() print(res) print(['time: ', t1 - t0])
def run_as_script(scenario_path=None): """ Run the properties script with input from the reference case and compare the results. This ensures that changes made to this script (e.g. refactorings) do not stop the script from working and also that the results stay the same. """ import cea.globalvar gv = cea.globalvar.GlobalVariables() if not scenario_path: scenario_path = gv.scenario_reference locator = inputlocator.InputLocator(scenario_path=scenario_path) properties(locator=locator, prop_thermal_flag=True, prop_architecture_flag=True, prop_hvac_flag=True, prop_comfort_flag=True, prop_internal_loads_flag=True, gv=gv)
def main(config): """ run the whole network summary routine """ import cea.inputlocator as inputlocator locator = inputlocator.InputLocator(scenario=config.scenario) total_demand = pd.read_csv(locator.get_total_demand()) substation_main(locator, total_demand, total_demand['Name'], heating_configuration=7, cooling_configuration=7, Flag=False) print 'substation_main() succeeded'
def run_as_script(scenario_path=None): """ run the whole network summary routine """ import cea.globalvar import cea.inputlocator as inputlocator 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'] substation_main(locator, total_demand, total_demand['Name'], gv, False) print 'substation_main() succeeded'
def main(config): import cea.inputlocator as inputlocator locator = inputlocator.InputLocator(scenario=config.scenario) #Options optimize = False raw_data_plot = True multicriteria = False plot_pareto = False clustering = True cluster_plot = True building_names = [ 'dorm', 'lab', 'office' ] #['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B09']#['B01']#['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B09'] building_load = 'Ef_kWh' type_data = 'measured' if optimize: for name in building_names: data = demand_CEA_reader(locator=locator, building_name=name, building_load=building_load, type=type_data) start_generation = None # or the number of generation to start from number_individuals = 16 number_generations = 50 optimization_clustering_main(locator=locator, data=data, start_generation=start_generation, number_individuals=number_individuals, number_generations=number_generations, building_name=name) if multicriteria: generation = 50 weight_fitness1 = 100 # accurracy weight_fitness2 = 100 # complexity weight_fitness3 = 70 # compression what_to_plot = "paretofrontier" output_path = locator.get_calibration_cluster_mcda(generation) for i, name in enumerate(building_names): # read_checkpoint input_path = locator.get_calibration_cluster_opt_checkpoint( generation, name) result = mcda_cluster_main(input_path=input_path, what_to_plot=what_to_plot, weight_fitness1=weight_fitness1, weight_fitness2=weight_fitness2, weight_fitness3=weight_fitness3) result["name"] = name if i == 0: result_final = pd.DataFrame(result).T else: result_final = result_final.append(pd.DataFrame(result).T, ignore_index=True) result_final.to_csv(output_path) if plot_pareto: for name in building_names[:1]: data = demand_CEA_reader(locator=locator, building_name=name, building_load=building_load, type=type_data) days_of_analysis = len(data) generation_to_plot = 50 annotate_benchmarks = True annotate_fitness = False show_in_screen = False save_to_disc = True what_to_plot = "paretofrontier" #paretofrontier, halloffame, or population optimal_individual = pd.read_csv( locator.get_calibration_cluster_mcda(generation_to_plot)) optimal_individual = optimal_individual.loc[ optimal_individual["name"] == name] labelx = 'Accurracy (A) [-]' labely = 'Complexity (B) [-]' labelz = r'Compression ($\Gamma$) [-]' output = os.path.join( locator.get_calibration_clustering_plots_folder(), "plot_gen_" + str(generation_to_plot) + "_building_name_" + name + ".png") # read_checkpoint input_path = locator.get_calibration_cluster_opt_checkpoint( generation_to_plot, name) frontier_2D_3OB( input_path=input_path, what_to_plot=what_to_plot, output_path=output, labelx=labelx, labely=labely, labelz=labelz, days_of_analysis=days_of_analysis, show_benchmarks=annotate_benchmarks, show_fitness=annotate_fitness, show_in_screen=show_in_screen, save_to_disc=save_to_disc, optimal_individual=optimal_individual, ) if clustering: name = 'lab' data = demand_CEA_reader(locator=locator, building_name=name, building_load=building_load, type=type_data) word_size = 4 alphabet_size = 17 clustering_sax(locator=locator, data=data, word_size=word_size, alphabet_size=alphabet_size) if cluster_plot: show_benchmark = True save_to_disc = True show_in_screen = False show_legend = False labelx = "Hour of the day" labely = "Electrical load [kW]" input_path = locator.get_calibration_cluster('clusters_mean') data = pd.read_csv(input_path) output_path = os.path.join( locator.get_calibration_clustering_plots_folder(), "w_a_" + str(word_size) + "_" + str(alphabet_size) + "_building_name_" + name + ".png") plot_day( data=data, output_path=output_path, labelx=labelx, labely=labely, save_to_disc=save_to_disc, show_in_screen=show_in_screen, show_legend=show_legend) #, show_benchmark=show_benchmark) if raw_data_plot: name = 'lab' show_benchmark = True save_to_disc = True show_in_screen = False show_legend = True labelx = "Hour of the day" labely = "Electrical load [kW]" data = demand_CEA_reader(locator=locator, building_name=name, building_load=building_load, type=type_data) data = pd.DataFrame( dict((str(key), value) for (key, value) in enumerate(data))) # input_path = locator.get_calibration_cluster('clusters_mean') output_path = os.path.join( locator.get_calibration_clustering_plots_folder(), "raw_building_name_" + name + ".png") plot_day(data=data, output_path=output_path, labelx=labelx, labely=labely, save_to_disc=save_to_disc, show_in_screen=show_in_screen, show_legend=show_legend) # , show_benchmark=show_benchmark)
def ss_calibrator(building_name): from cea.analysis.clustering.kmeans.k_means_partitioner import partitioner list_median, cluster_labels = partitioner(building_name) intended_parameters = [ 'people', 'Eaf', 'Elf', 'Qwwf', 'I_rad', 'I_sol', 'T_ext', 'rh_ext', 'ta_hs_set', 'ta_cs_set', 'theta_a', 'Qhsf', 'Qcsf' ] # collect the simulation results gv = cea.globalvar.GlobalVariables() scenario_path = gv.scenario_reference locator = inputlocator.InputLocator(scenario=scenario_path) metered_path = r'C:\reference-case-open\baseline\inputs\building-metering' metered_building = os.path.join(metered_path, '%s.csv' % building_name) ht_cl_el = ['Qhsf'] measured_data_pd = pd.read_csv(metered_building, usecols=ht_cl_el) measured_data = np.array(measured_data_pd) test_NN_input_path = os.path.join(locator.get_calibration_folder(), "test_NN_input.csv" % locals()) test_NN_target_path = os.path.join(locator.get_calibration_folder(), "test_NN_target.csv" % locals()) input_NN_x = np.array(pd.read_csv(test_NN_input_path)) target_NN_t = np.array(pd.read_csv(test_NN_target_path)) json_NN_path = os.path.join(locator.get_calibration_folder(), "trained_network_ht.json" % locals()) weight_NN_path = os.path.join(locator.get_calibration_folder(), "trained_network_ht.h5" % locals()) json_NN_path = os.path.join(locator.get_calibration_folder(), "trained_network_ht.json" % locals()) weight_NN_path = os.path.join(locator.get_calibration_folder(), "trained_network_ht.h5" % locals()) scalerX = MinMaxScaler(feature_range=(0, 1)) inputs_x = scalerX.fit_transform(input_NN_x) scalerT = MinMaxScaler(feature_range=(0, 1)) targets_t = scalerT.fit_transform(target_NN_t) # load json and create model json_file = open(json_NN_path, 'r') loaded_model_json = json_file.read() json_file.close() perceptron_ht = model_from_json(loaded_model_json) # load weights into new model perceptron_ht.load_weights(weight_NN_path) perceptron_ht.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) file_path = os.path.join(locator.get_demand_results_folder(), "%(building_name)s.xls" % locals()) calcs_outputs_xls = pd.read_excel(file_path) temp_file = os.path.join(locator.get_temporary_folder(), "%(building_name)s.csv" % locals()) calcs_outputs_xls.to_csv(temp_file, index=False, header=True, float_format='%.3f', decimal='.') calcs_trimmed_csv = pd.read_csv(temp_file, usecols=intended_parameters) calcs_trimmed_csv[ 'I_real'] = calcs_trimmed_csv['I_rad'] + calcs_trimmed_csv['I_sol'] calcs_trimmed_csv['ta_hs_set'].fillna(0, inplace=True) calcs_trimmed_csv['ta_cs_set'].fillna(50, inplace=True) NN_input = calcs_trimmed_csv input_drops = ['I_rad', 'I_sol', 'theta_a', 'Qhsf', 'Qcsf'] NN_input = NN_input.drop(input_drops, 1) NN_input = np.array(NN_input) target1 = calcs_trimmed_csv['Qhsf'] target2 = calcs_trimmed_csv['Qcsf'] target3 = calcs_trimmed_csv['theta_a'] NN_target_ht = pd.concat([target1, target3], axis=1) NN_target_cl = pd.concat([target2, target3], axis=1) NN_target_ht = np.array(NN_target_ht) NN_target_cl = np.array(NN_target_cl) # return NN_input, NN_target_ht, NN_target_cl from cea.demand.calibration.subset_calibrator.surrogate_4_calibration import prep_NN_inputs NN_delays = 1 NN_input_ready_ht, NN_target_ready_ht = prep_NN_inputs( NN_input, NN_target_ht, NN_delays) NN_input_ready_cl, NN_target_ready_cl = prep_NN_inputs( NN_input, NN_target_cl, NN_delays) one_array_override = np.array( pd.read_csv(locator.get_building_overrides(), skiprows=1, nrows=1)) one_array_override1 = np.delete(one_array_override, 0, 1) rows_override, cols_override = one_array_override1.shape rows_NN_input, cols_NN_input = NN_input_ready_ht.shape random_variables_matrix = [] random_variables_matrix = np.array(random_variables_matrix) vector_of_ones = np.ones((rows_NN_input, 1)) for k in range(0, cols_override): random_variable_call = one_array_override1[0, k] random_variable_col = np.multiply(random_variable_call, vector_of_ones) if k < 1: random_variables_matrix = random_variable_col else: random_variables_matrix = np.append(random_variables_matrix, random_variable_col, axis=1) combined_inputs_ht = np.concatenate( (NN_input_ready_ht, random_variables_matrix), axis=1) combined_inputs_cl = np.concatenate( (NN_input_ready_cl, random_variables_matrix), axis=1) nn_X_ht = combined_inputs_ht nn_X_cl = combined_inputs_cl nn_T_ht = NN_target_ready_ht nn_T_cl = NN_target_ready_cl nn_input_rows, nn_input_cols, = NN_input.shape reshaped_nn_input = np.reshape(NN_input, (365, 24, nn_input_cols)) reshape_measured_data = np.reshape(measured_data, (365, 24)) reshape_target1 = np.reshape(target1, (365, 24)) reshape_target2 = np.reshape(target2, (365, 24)) reshape_target3 = np.reshape(target3, (365, 24)) first_cluster = cluster_labels[0] first_group = np.where(cluster_labels == first_cluster)[0] first_mat = reshaped_nn_input[first_group, :, :] measured_data_trim = reshape_measured_data[first_group, :] avg_cluster_measured = np.average(measured_data_trim, axis=0) target1 = reshape_target1[first_group, :] target2 = reshape_target2[first_group, :] target3 = reshape_target3[first_group, :] nn_input_rows, nn_input_cols, nn_input_tens = first_mat.shape #nn_input_rows=list(int(nn_input_rows)) #second_mat=np.reshape(first_mat,(nn_input_rows*nn_input_cols,nn_input_tens)) for number_samples in range(nn_input_rows): NN_input = first_mat[number_samples] NN_input = np.array(NN_input) target1a = target1[number_samples] target2a = target2[number_samples] target3a = target3[number_samples] NN_target_ht = np.vstack((target1a, target3a)) #NN_target_cl = pd.concat([target2, target3], axis=1) NN_target_ht = np.array(NN_target_ht) NN_target_ht = np.transpose(NN_target_ht) #NN_target_cl=np.array(NN_target_cl) NN_delays = 1 NN_input_ready_ht, NN_target_ready_ht = prep_NN_inputs( NN_input, NN_target_ht, NN_delays) #NN_input_ready_cl, NN_target_ready_cl = prep_NN_inputs(NN_input, NN_target_cl, NN_delays) random_variables_matrix2 = random_variables_matrix[0:23, :] combined_inputs_ht = np.concatenate( (NN_input_ready_ht, random_variables_matrix2), axis=1) #combined_inputs_cl = np.concatenate((NN_input_ready_cl, random_variables_matrix), axis=1) nn_X_ht = combined_inputs_ht #nn_X_cl = combined_inputs_cl nn_T_ht = NN_target_ready_ht #nn_T_cl = NN_target_ready_cl inputs_x = scalerX.transform(nn_X_ht) predict_NN_ht = perceptron_ht.predict(inputs_x) filtered_predict = scalerT.inverse_transform(predict_NN_ht) target_filter_node = NN_target_ready_ht[:, 0] filter_logic = np.isin(target_filter_node, 0) target_anomalies = np.asarray(np.where(filter_logic), dtype=np.int) t_anomalies_rows, t_anomalies_cols = target_anomalies.shape anomalies_replacements = np.zeros(t_anomalies_cols) anomalies_replacements = np.transpose(anomalies_replacements) filtered_predict[target_anomalies, 0] = anomalies_replacements avg_cluster_single = np.average(avg_cluster_measured) trim_avg_cluster = avg_cluster_measured[1:24] main_filtered_predict = filtered_predict[:, 0] CV_RMSE = np.divide((sqrt( mean_squared_error(trim_avg_cluster, main_filtered_predict))), avg_cluster_single) ####LHS# lhs_samples_num = 1000 #design = gmm_random_sampler(random_variables_matrix2, lhs_samples_num) design = lhs(5, samples=lhs_samples_num) lower = [ 0.5 * random_variables_matrix2[0, 0], 0.5 * random_variables_matrix2[0, 1], 0.5 * random_variables_matrix2[0, 2], 0.5 * random_variables_matrix2[0, 3], 0.5 * random_variables_matrix2[0, 4] ] upper = [ 1.5 * random_variables_matrix2[0, 0], 1.5 * random_variables_matrix2[0, 1], 1.5 * random_variables_matrix2[0, 2], 1.5 * random_variables_matrix2[0, 3], 1.5 * random_variables_matrix2[0, 4] ] for i in xrange(4): design[:, i] = uniform(loc=lower[i], scale=upper[i]).ppf(design[:, i]) CV_RMSE_mat = ss_loop(design, lhs_samples_num, NN_input_ready_ht, scalerX, perceptron_ht, scalerT, nn_T_ht, avg_cluster_measured) min_CV_RMSE = np.ndarray.min(CV_RMSE_mat) counter_while = 0 counter_max = 100 while min_CV_RMSE < 0.15 and counter_while < counter_max: # momentum_low= 0.9 + ((float(counter_while)/float(counter_max))/float(10)) # momentum_up = 1.1 - ((float(counter_while) / float(counter_max)) / float(10)) jumbo_outputs = np.concatenate((CV_RMSE_mat, design), axis=1) jumbo_outputs = jumbo_outputs[np.argsort(jumbo_outputs[:, 0])] filtered_samples = jumbo_outputs[0:10, :] # lower = [momentum_low*np.ndarray.min(filtered_samples[:,1]), momentum_low*np.ndarray.min(filtered_samples[:,2]), # momentum_low*np.ndarray.min(filtered_samples[:,3]),momentum_low *np.ndarray.min(filtered_samples[:, 4]), # momentum_low*np.ndarray.min(filtered_samples[:,5])] # upper = [momentum_up*np.ndarray.max(filtered_samples[:,1]),momentum_up*np.ndarray.max(filtered_samples[:,2]), # momentum_up*np.ndarray.max(filtered_samples[:,3]),momentum_up*np.ndarray.max(filtered_samples[:, 4]), # momentum_up*np.ndarray.max(filtered_samples[:,5])] # for i in xrange(4): # design = lhs(5, samples=lhs_samples_num) # design[:, i] = uniform(loc=lower[i], scale=upper[i]).ppf(design[:, i]) gmm_samples_num = 100 gmm_input = filtered_samples[:, 1:6] design = gmm_random_sampler(gmm_input, gmm_samples_num) #design = list(design) design = np.array(design[0]) CV_RMSE_mat = ss_loop(design, gmm_samples_num, NN_input_ready_ht, scalerX, perceptron_ht, scalerT, nn_T_ht, avg_cluster_measured) min_CV_RMSE = np.ndarray.min(CV_RMSE_mat) counter_while = counter_while + 1 print(min_CV_RMSE, counter_while)
def run_as_script(): gv = cea.globalvar.GlobalVariables() scenario_path = gv.scenario_reference locator = inputlocator.InputLocator(scenario=scenario_path) json_NN_path = os.path.join(locator.get_calibration_folder(), "trained_network_ht.json" % locals()) weight_NN_path = os.path.join(locator.get_calibration_folder(), "trained_network_ht.h5" % locals()) # load json and create model json_file = open(json_NN_path, 'r') loaded_model_json = json_file.read() json_file.close() perceptron_ht = model_from_json(loaded_model_json) # load weights into new model perceptron_ht.load_weights(weight_NN_path) # predict new outputs and estimate the error test_NN_input_path = os.path.join(locator.get_calibration_folder(), "test_NN_input.csv" % locals()) test_NN_target_path = os.path.join(locator.get_calibration_folder(), "test_NN_target.csv" % locals()) input_NN_x = np.array(pd.read_csv(test_NN_input_path)) target_NN_t = np.array(pd.read_csv(test_NN_target_path)) perceptron_ht.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) scalerX = MinMaxScaler(feature_range=(0, 1)) inputs_x = scalerX.fit_transform(input_NN_x) scalerT = MinMaxScaler(feature_range=(0, 1)) targets_t = scalerT.fit_transform(target_NN_t) predict_NN_ht = perceptron_ht.predict(inputs_x) filtered_predict = scalerT.inverse_transform(predict_NN_ht) filter_logic = np.isin(targets_t, 0) target_anomalies = np.asarray(np.where(filter_logic), dtype=np.int) t_anomalies_rows, t_anomalies_cols = target_anomalies.shape anomalies_replacements = np.zeros(t_anomalies_cols) filtered_predict[target_anomalies, 0] = anomalies_replacements final_target = pd.DataFrame(target_NN_t) final_output = pd.DataFrame(filtered_predict) save_target_path = os.path.join(locator.get_calibration_folder(), "saved_targets.csv" % locals()) save_output_path = os.path.join(locator.get_calibration_folder(), "saved_outputs.csv" % locals()) final_target.to_csv(save_target_path, index=False, header=False, float_format='%.3f', decimal='.') final_output.to_csv(save_output_path, index=False, header=False, float_format='%.3f', decimal='.') rmse = sqrt(mean_squared_error(target_NN_t[:, 0], filtered_predict[:, 0])) mean_target = np.mean(target_NN_t[:, 0]) cv_rmse = np.divide(rmse, mean_target) print(rmse, cv_rmse)
def run_as_script(): import cea.globalvar as gv import cea.inputlocator as inputlocator gv = gv.GlobalVariables() scenario_path = gv.scenario_reference locator = inputlocator.InputLocator(scenario_path=scenario_path) #Options optimize = True multicriteria = True plot_pareto = True clustering = True cluster_plot = True building_names = ['M01']#['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B09']#['B01']#['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B09'] building_load = 'Ef_kWh' type_data = 'measured' if optimize: for name in building_names: data = demand_CEA_reader(locator=locator, building_name=name, building_load=building_load, type=type_data) start_generation = None # or the number of generation to start from number_individuals = 16 number_generations = 100 optimization_clustering_main(locator=locator, data=data, start_generation=start_generation, number_individuals=number_individuals, number_generations=number_generations, building_name=name, gv=gv) if multicriteria: for i,name in enumerate(building_names): generation = 100 weight_fitness1 = 100 # accurracy weight_fitness2 = 80 # complexity weight_fitness3 = 80 # compression what_to_plot = "paretofrontier" output_path = locator.get_calibration_cluster_mcda(generation) # read_checkpoint input_path = locator.get_calibration_cluster_opt_checkpoint(generation, name) result = mcda_cluster_main(input_path=input_path, what_to_plot=what_to_plot, weight_fitness1=weight_fitness1, weight_fitness2=weight_fitness2, weight_fitness3=weight_fitness3) result["name"] = name if i ==0: result_final = pd.DataFrame(result).T else: result_final = result_final.append(pd.DataFrame(result).T, ignore_index=True) result_final.to_csv(output_path) if plot_pareto: for name in building_names: generation_to_plot = 100 annotate_benchmarks = True annotate_fitness = False show_in_screen = False save_to_disc = True what_to_plot = "paretofrontier" #paretofrontier, halloffame, or population optimal_individual = pd.read_csv(locator.get_calibration_cluster_mcda(generation_to_plot)) optimal_individual = optimal_individual.loc[optimal_individual["name"]==name] labelx = 'Accurracy (A) [-]' labely = 'Complexity (B) [-]' labelz = r'Compression ($\Gamma$) [-]' output = os.path.join(locator.get_calibration_clustering_plots_folder(), "plot_gen_"+str(generation_to_plot)+"_building_name_"+name+".png") # read_checkpoint input_path = locator.get_calibration_cluster_opt_checkpoint(generation_to_plot, name) frontier_2D_3OB(input_path=input_path, what_to_plot = what_to_plot, output_path=output, labelx= labelx, labely = labely, labelz = labelz, show_benchmarks= annotate_benchmarks, show_fitness=annotate_fitness, show_in_screen = show_in_screen, save_to_disc=save_to_disc, optimal_individual= optimal_individual) if clustering: name = 'M01' data = demand_CEA_reader(locator=locator, building_name=name, building_load=building_load, type=type_data) word_size = 9 alphabet_size = 7 clustering_main(locator=locator, data=data, word_size=word_size, alphabet_size=alphabet_size, gv=gv) if cluster_plot: show_benchmark = True save_to_disc = True show_in_screen = False show_legend = False labelx = "Hour of the day" labely = "Electrical load [kW]" # input_path = demand_CEA_reader(locator=locator, building_name=name, building_load=building_load, # type=type_data) # # input_path = pd.DataFrame(dict((str(key), value) for (key, value) in enumerate(input_path))) input_path = locator.get_calibration_cluster('clusters_mean') output_path = os.path.join(locator.get_calibration_clustering_plots_folder(), "w_a_"+str(word_size)+"_"+str(alphabet_size)+"_building_name_"+name+".png") clusters_day_mean(input_path=input_path, output_path=output_path,labelx=labelx, labely=labely, save_to_disc=save_to_disc, show_in_screen=show_in_screen, show_legend=show_legend)#, show_benchmark=show_benchmark)
return area_facade_zone, area_roof_zone, height_zone, slope_roof def get_windows_of_building(dataframe_windows, name_building): return dataframe_windows.loc[dataframe_windows['name_building'] == name_building] # TESTING if __name__ == '__main__': calc_q_m_mech() # generate windows based on geometry of vertical surfaces in radiation file locator = inputlocator.InputLocator( scenario_path=r'C:\cea-reference-case\reference-case\baseline') dataframe_radiation = pandas.read_csv(locator.get_radiation()) geodataframe_building_architecture = geopandas.GeoDataFrame.from_file( locator.get_building_architecture()) # print(geodataframe_building_architecture) geodataframe_building_geometry = geopandas.GeoDataFrame.from_file( locator.get_building_geometry()) # print(geodataframe_building_geometry) dataframe_windows = create_windows(dataframe_radiation, geodataframe_building_architecture) building_test = 'B302040213' # get building windows windows_building_test = get_windows_of_building(dataframe_windows,
from __future__ import division import pandas as pd import matplotlib.pyplot as plt from cea import config import numpy as np from cea import inputlocator configur = config.Configuration() locator = inputlocator.InputLocator(scenario=configur.scenario) # index = pd.date_range('1/1/2016', periods=8760, freq='H') file = pd.read_csv( r'C:\reference-case-open\baseline\outputs\data\demand/total_demand.csv') # file.set_index(index, inplace=True) print file[['Qhsf_MWhyr', 'Ef_MWhyr', 'Qcsf_MWhyr']].sum(axis=0) list_buildings = pd.read_csv(locator.get_total_demand())['Name'].values I_sol = np.array([]) for building in list_buildings: data = pd.read_excel( r'C:\reference-case-open\baseline\outputs\data\demand/' + building + '.xls') I_sol = np.append(I_sol, [data['I_sol_gross'].sum() / 1000]) I_sol2 = np.nansum(I_sol) print I_sol2 #print file[2300:2370] file.plot() # plt.show()
def test_benchmark_targets(): locator = inputlocator.InputLocator( scenario_path=r'C:\reference-case-zug\baseline') calc_benchmark_targets(locator)
def run_as_script(): scenario_path = config.scenario locator = inputlocator.InputLocator(scenario=scenario_path) building_name = 'B155066' # intended building cluster_labels = ss_calibrator(building_name)