def simulate_demand_sample(locator, building_name, output_parameters): """ This script runs the cea demand tool in series and returns a single value of cvrmse and rmse. :param locator: pointer to location of files in CEA :param building_name: name of building :param output_parameters: building load to consider in the anlysis :return: """ # force simulation to be sequential and to only do one building gv = cea.globalvar.GlobalVariables() gv.multiprocessing = False gv.print_totals = False gv.simulate_building_list = [building_name] gv.testing = True #import weather and measured data weather_path = locator.get_default_weather() #weather_path = 'C:\CEAforArcGIS\cea\databases\weather\Zurich.epw' #calculate demand timeseries for buidling an calculate cvrms demand_main.demand_calculation(locator, gv) output_folder = locator.get_demand_results_folder() file_path = os.path.join(output_folder, "%(building_name)s.xls" % locals()) #file_path=locator.get_demand_results_file(building_name) new_calcs = pd.read_excel(file_path) #cv_rmse, rmse = calc_cv_rmse(time_series_simulation[output_parameters].values, time_series_measured[output_parameters].values) return new_calcs #cv_rmse, rmse
def simulate_demand_sample(locator, building_name, output_parameters, config): """ This script runs the cea demand tool in series and returns a single value of cvrmse and rmse. :param locator: pointer to location of files in CEA :param building_name: name of building :param output_parameters: building load to consider in the anlysis :return: """ # force simulation to be sequential and to only do one building config.multiprocessing = False config.demand.buildings = [building_name] config.demand.massflows_output = [] config.demand.temperatures_output = [] config.demand.format_output = "csv" config.demand.override_variables = True #import weather and measured data weather_path = locator.get_default_weather() #weather_path = 'C:\CEAforArcGIS\cea\databases\weather\Zurich.epw' #calculate demand timeseries for buidling an calculate cvrms demand_main.demand_calculation(locator, config) output_folder = locator.get_demand_results_folder() file_path = os.path.join(output_folder, "%(building_name)s.xls" % locals()) #file_path=locator.get_demand_results_file(building_name) new_calcs = pd.read_excel(file_path) #cv_rmse, rmse = calc_cv_rmse(time_series_simulation[output_parameters].values, time_series_measured[output_parameters].values) return new_calcs #cv_rmse, rmse
def sampling_scaler(locator, random_variables, target_parameters, boolean_vars, list_building_names, number_samples_scaler, nn_delay, gv, config, climatic_variables, year, use_daysim_radiation, use_stochastic_occupancy, region): ''' this function creates a number of random samples for the entire district (city) :param locator: points to the variables :param random_variables: a list containing the names of variables associated with uncertainty (can be accessed from 'nn_settings.py') :param target_parameters: a list containing the name of desirable outputs (can be accessed from 'nn_settings.py') :param list_building_names: a list containing the name of desired buildings :param weather_path: weather path :param gv: global variables :return: - ''' # get number of buildings size_city = np.shape(list_building_names) size_city = size_city[0] # create random samples of the entire district for i in range( number_samples_scaler ): # the parameter "number_samples" is accessible from 'nn_settings.py' bld_counter = 0 # create list of samples with a LHC sampler and save to disk samples, samples_norm, pdf_list = latin_sampler( locator, size_city, random_variables, region) # create a file of overides with the samples dictionary = dict(zip(random_variables, samples.transpose())) overides_dataframe = pd.DataFrame(dictionary) overides_dataframe['Name'] = list_building_names # replace the 1, 0 with True and False for var in boolean_vars: somthing = overides_dataframe['ECONOMIZER'] overides_dataframe[var].replace(1, 'True', inplace=True) overides_dataframe[var].replace(0, 'False', inplace=True) overides_dataframe[var].replace(0.0, 'False', inplace=True) # save file so the demand calculation can know about it. overides_dataframe.to_csv(locator.get_building_overrides()) # run cea demand config.demand.override_variables = True demand_main.demand_calculation(locator, config) urban_input_matrix, urban_taget_matrix = input_prepare_main( list_building_names, locator, target_parameters, nn_delay, climatic_variables, config.region, year, use_daysim_radiation, use_stochastic_occupancy) scaler_inout_path = locator.get_minmaxscaler_folder() file_path_inputs = os.path.join(scaler_inout_path, "input%(i)s.csv" % locals()) data_file_inputs = pd.DataFrame(urban_input_matrix) data_file_inputs.to_csv(file_path_inputs, header=False, index=False) file_path_targets = os.path.join(scaler_inout_path, "target%(i)s.csv" % locals()) data_file_targets = pd.DataFrame(urban_taget_matrix) data_file_targets.to_csv(file_path_targets, header=False, index=False)
def sampling_single(locator, random_variables, target_parameters, list_building_names, gv, config, nn_delay, climatic_variables, region, year, use_daysim_radiation, use_stochastic_occupancy): size_city = np.shape(list_building_names) size_city = size_city[0] bld_counter = 0 # create list of samples with a LHC sampler and save to disk (*.csv) samples, samples_norm, pdf_list = latin_sampler(locator, size_city, random_variables, region) for building_name in (list_building_names): np.save(locator.get_calibration_folder(), samples) building_load = config.single_calibration.load override_file = Gdf.from_file( locator.get_zone_geometry()).set_index('Name') override_file = pd.DataFrame(index=override_file.index) problem = { 'variables': random_variables, 'building_load': target_parameters, 'probabiltiy_vars': pdf_list } pickle.dump( problem, file(locator.get_calibration_problem(building_name, building_load), 'w')) sample = np.asarray(zip(random_variables, samples[bld_counter, :])) apply_sample_parameters(locator, sample, override_file) bld_counter = bld_counter + 1 # read the saved *.csv file and replace Boolean with logical (True/False) overwritten = pd.read_csv(locator.get_building_overrides()) bld_counter = 0 for building_name in (list_building_names): sample = np.asarray(zip(random_variables, samples[bld_counter, :])) for boolean_mask in (boolean_vars): indices = np.where(sample == boolean_mask) if sample[indices[0], 1] == '0.0': sample[indices[0], 1] = 'False' else: sample[indices[0], 1] = 'True' overwritten.loc[overwritten.Name == building_name, random_variables] = sample[:, 1] bld_counter = bld_counter + 1 # write to csv format overwritten.to_csv(locator.get_building_overrides()) # run cea demand demand_main.demand_calculation(locator, config) # prepare the inputs for feeding into the neural network urban_input_matrix, urban_taget_matrix = input_prepare_main( list_building_names, locator, target_parameters, gv, nn_delay, climatic_variables, region, year, use_daysim_radiation, use_stochastic_occupancy) return urban_input_matrix, urban_taget_matrix
def screening_cea(counter, sample, var_names, output_parameters, locator, weather_path, gv): """ :param counter: counter keepin gth enumber of samples analyzed. it serves to sort the results from asynchronous multiprocessing in order :param sample: sample to simulate :param var_names: names of variables to analyze :param output_parameters: list of output parameters to analyse :param locator: path to locator class :param weather_path: path to weather file :param gv: global variables class :return: Dataframes with output of simulation of a building. It relates the results of every outputparameter. """ # create a dict with the new input vatiables form the sample and pass in gv gv.samples = dict(zip(var_names, sample)) result = None while result is None: # trick to avoid that arcgis stops calculating the days and tries again. try: result = demand_main.demand_calculation(locator, weather_path, gv)[output_parameters] except Exception, e: print e, result pass
def simulate_demand_sample(locator, building_name, building_load, config): """ This script runs the cea demand tool in series and returns a single value of cvrmse and rmse. :param locator: pointer to location of files in CEA :param building_name: name of building :param output_parameters: building load to consider in the anlysis :return: """ # force simulation to be sequential, for only one building and to override variables gv = cea.globalvar.GlobalVariables() config.demand.override_variables = True # true so it reads the overrides file created config.multiprocessing = False config.demand.buildings = [building_name] config.demand.resolution_output = "hourly" config.demand.loads_output = [building_load] config.demand.massflows_output = [ "mcphs_sys" ] # give one entry so it doe snot plot all ( it saves memory) config.demand.temperatures_output = [ "Tww_sys_sup" ] # give one entry so it doe snot plot all ( it saves memory) config.demand.format_output = "csv" _, time_series = demand_main.demand_calculation(locator, config) return time_series[0][building_load + "_kWh"].values
def simulate_demand_sample(locator, config, output_parameters): """ Run a demand simulation for a single sample. This function expects a locator that is already initialized to the simulation folder, that has already been prepared with `apply_sample_parameters`. :param locator: The InputLocator to use for the simulation :type locator: InputLocator :param weather: The path to the weather file (``*.epw``) to use for simulation. See the `weather_path` parameter in `cea.demand.demand_main.demand_calculation` for more information. :type weather: str :param output_parameters: The list of output parameters to save to disk. This is a column-wise subset of the output of `cea.demand.demand_main.demand_calculation`. :type output_parameters: list of str :return: Returns the columns of the results of `cea.demand.demand_main.demand_calculation` as defined in `output_parameters`. :rtype: pandas.DataFrame """ # MODIFY CONFIG FILE TO RUN THE DEMAND FOR ONLY SPECIFIC QUANTITIES config.demand.resolution_output = "monthly" config.multiprocessing = False config.demand.massflows_output = [] config.demand.temperatures_output = [] config.demand.format_output = "csv" config.demand.override_variables = True # force simulation to be sequential totals, time_series = demand_main.demand_calculation(locator, config) return totals[output_parameters], time_series
def simulate_demand_sample(locator, weather_path, output_parameters): """ Run a demand simulation for a single sample. This function expects a locator that is already initialized to the simulation folder, that has already been prepared with `apply_sample_parameters`. :param locator: The InputLocator to use for the simulation :type locator: InputLocator :param weather: The path to the weather file (``*.epw``) to use for simulation. See the `weather_path` parameter in `cea.demand.demand_main.demand_calculation` for more information. :type weather: str :param output_parameters: The list of output parameters to save to disk. This is a column-wise subset of the output of `cea.demand.demand_main.demand_calculation`. :type output_parameters: list of str :return: Returns the columns of the results of `cea.demand.demand_main.demand_calculation` as defined in `output_parameters`. :rtype: pandas.DataFrame """ gv = cea.globalvar.GlobalVariables() gv.demand_writer = cea.demand.demand_writers.MonthlyDemandWriter(gv) # force simulation to be sequential gv.multiprocessing = False totals, time_series = demand_main.demand_calculation( locator, weather_path, gv) return totals[output_parameters], time_series
def sampling_main(locator, random_variables, target_parameters, list_building_names, weather_path, multiprocessing, config, nn_delay, climatic_variables, year): ''' this function creates a number of random samples for the entire district (city) :param locator: points to the variables :param random_variables: a list containing the names of variables associated with uncertainty (can be accessed from 'nn_settings.py') :param target_parameters: a list containing the name of desirable outputs (can be accessed from 'nn_settings.py') :param list_building_names: a list containing the name of desired buildings :param weather_path: weather path :return: - ''' # get number of buildings size_city = np.shape(list_building_names) size_city = size_city[0] # create random samples of the entire district for i in range( number_samples ): # the parameter "number_samples" is accessible from 'nn_settings.py' bld_counter = 0 # create list of samples with a LHC sampler and save to disk samples, samples_norm, pdf_list = latin_sampler( locator, size_city, random_variables) #samples = samples[0] # extract the non-normalized samples # create a file of overides with the samples dictionary = dict(zip(random_variables, samples.transpose())) overides_dataframe = pd.DataFrame(dictionary) overides_dataframe['Name'] = list_building_names # replace the 1, 0 with True and False for var in boolean_vars: overides_dataframe[var].replace(1, "True", inplace=True) overides_dataframe[var].replace(0, "False", inplace=True) overides_dataframe[var].replace(0.0, "False", inplace=True) # save file so the demand calculation can know about it. overides_dataframe.to_csv(locator.get_building_overrides()) # run cea demand config.demand.override_variables = True demand_main.demand_calculation(locator, config) # prepare the inputs for feeding into the neural network urban_input_matrix, urban_taget_matrix = input_prepare_main( list_building_names, locator, target_parameters, nn_delay, climatic_variables, year) # drop half the inputs and targets to avoid overfitting and save RAM / Disk space urban_input_matrix, urban_taget_matrix = input_dropout( urban_input_matrix, urban_taget_matrix) # get the pathfor saving the files nn_inout_path = locator.get_nn_inout_folder() # save inputs with sequential naming file_path_inputs = os.path.join(nn_inout_path, "input%(i)s.csv" % locals()) data_file_inputs = pd.DataFrame(urban_input_matrix) data_file_inputs.to_csv(file_path_inputs, header=False, index=False) # save inputs with sequential naming file_path_targets = os.path.join(nn_inout_path, "target%(i)s.csv" % locals()) data_file_targets = pd.DataFrame(urban_taget_matrix) data_file_targets.to_csv(file_path_targets, header=False, index=False)
def calc_score(static_params, dynamic_params): """ This tool reduces the error between observed (real life measured data) and predicted (output of the model data) values by changing some of CEA inputs. Annual data is compared in terms of MBE and monthly data in terms of NMBE and CvRMSE (follwing ASHRAE Guideline 14-2002). A new input folder with measurements has to be created, with a csv each for monthly and annual data provided as input for this tool. A new output csv is generated providing the calibration results (iteration number, parameters tested and results(score metric)) """ ## define set of CEA inputs to be calibrated and initial guess values SEED = dynamic_params['SEED'] np.random.seed( SEED ) #initalize seed numpy randomly npy.random.seed (once call the function) - inside put the seed #import random (initialize) npy.random.randint(low=1, high=100, size= number of buildings)/1000 - for every parameter. Hs_ag = dynamic_params['Hs_ag'] Tcs_set_C = dynamic_params['Tcs_set_C'] Es = dynamic_params['Es'] Ns = dynamic_params['Ns'] Occ_m2pax = dynamic_params['Occ_m2pax'] Vww_lpdpax = dynamic_params['Vww_lpdpax'] Ea_Wm2 = dynamic_params['Ea_Wm2'] El_Wm2 = dynamic_params['El_Wm2'] ##define fixed constant parameters (to be redefined by CEA config file) #Hs_ag = 0.15 #Tcs_set_C = 28 Tcs_setb_C = 40 void_deck = 1 height_bg = 0 floors_bg = 0 scenario_list = static_params['scenario_list'] config = static_params['config'] locators_of_scenarios = [] measured_building_names_of_scenarios = [] for scenario in scenario_list: config.scenario = scenario locator = cea.inputlocator.InputLocator(config.scenario) measured_building_names = get_measured_building_names(locator) modify_monthly_multiplier(locator, config, measured_building_names) # store for later use locators_of_scenarios.append(locator) measured_building_names_of_scenarios.append(measured_building_names) ## overwrite inputs with corresponding initial values # Changes and saves variables related to the architecture df_arch = dbf_to_dataframe(locator.get_building_architecture()) number_of_buildings = df_arch.shape[0] Rand_it = np.random.randint(low=-30, high=30, size=number_of_buildings) / 100 df_arch.Es = Es * (1 + Rand_it) df_arch.Ns = Ns * (1 + Rand_it) df_arch.Hs_ag = Hs_ag * (1 + Rand_it) df_arch.void_deck = void_deck dataframe_to_dbf(df_arch, locator.get_building_architecture()) # Changes and saves variables related to intetnal loads df_intload = dbf_to_dataframe(locator.get_building_internal()) df_intload.Occ_m2pax = Occ_m2pax * (1 + Rand_it) df_intload.Vww_lpdpax = Vww_lpdpax * (1 + Rand_it) df_intload.Ea_Wm2 = Ea_Wm2 * (1 + Rand_it) df_intload.El_Wm2 = El_Wm2 * (1 + Rand_it) dataframe_to_dbf(df_intload, locator.get_building_internal()) #Changes and saves variables related to comfort df_comfort = dbf_to_dataframe(locator.get_building_comfort()) df_comfort.Tcs_set_C = Tcs_set_C * (1 + Rand_it) df_comfort.Tcs_setb_C = Tcs_setb_C dataframe_to_dbf(df_comfort, locator.get_building_comfort()) # Changes and saves variables related to zone df_zone = dbf_to_dataframe(locator.get_zone_geometry().split('.')[0] + '.dbf') df_zone.height_bg = height_bg df_zone.floors_bg = floors_bg dataframe_to_dbf(df_zone, locator.get_zone_geometry().split('.')[0] + '.dbf') ## run building schedules and energy demand config.schedule_maker.buildings = measured_building_names schedule_maker.schedule_maker_main(locator, config) config.demand.buildings = measured_building_names demand_main.demand_calculation(locator, config) # calculate the score score = validation.validation(scenario_list=scenario_list, locators_of_scenarios=locators_of_scenarios, measured_building_names_of_scenarios= measured_building_names_of_scenarios) return score