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 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 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 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 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() 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 main(config): gv = cea.globalvar.GlobalVariables() locator = cea.inputlocator.InputLocator(scenario_path=config.scenario) weather_path = config.weather() building_properties, schedules_dict, date = properties_and_schedule(locator) list_building_names = building_properties.list_building_names() run_nn_resume_single(locator, random_variables, target_parameters, list_building_names, weather_path, gv)
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 main(config): settings = config.demand locator = cea.inputlocator.InputLocator(scenario=config.scenario) building_properties, schedules_dict, date = properties_and_schedule(locator) list_building_names = building_properties.list_building_names() urban_input_matrix, urban_taget_matrix = sampling_single(locator, random_variables, target_parameters, list_building_names, config=config, nn_delay=config.neural_network.nn_delay, climatic_variables=config.neural_network.climatic_variables, year=config.neural_network.year, use_stochastic_occupancy=config.demand.use_stochastic_occupancy)
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 main(config): locator = cea.inputlocator.InputLocator(scenario_path=config.scenario) settings = config.demand building_properties, schedules_dict, date = properties_and_schedule( locator) list_building_names = building_properties.list_building_names() weather_path = config.weather sampling_main(locator, random_variables, target_parameters, list_building_names, weather_path, multiprocessing=config.multiprocessing, config=config, nn_delay=config.neural_network.nn_delay, climatic_variables=config.neural_network.climatic_variables, year=config.neural_network.year)
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( locator, region, year, use_daysim_radiation) 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 main(config): gv = cea.globalvar.GlobalVariables() locator = cea.inputlocator.InputLocator(scenario_path=config.scenario) settings = config.demand building_properties, schedules_dict, date = properties_and_schedule( gv, locator) list_building_names = building_properties.list_building_names() weather_path = config.weather sampling_main(locator, random_variables, target_parameters, list_building_names, weather_path, gv, 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 input_prepare_estimate(list_building_names, locator, gv, climatic_variables, region, year, use_daysim_radiation, use_stochastic_occupancy, weather_array, weather_data): ''' 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) ''' building_properties, schedules_dict, date = properties_and_schedule(locator, region, year, use_daysim_radiation) # open multiprocessing pool pool = mp.Pool() # count number of CPUs print("Using {cpu_count} CPU's".format(cpu_count=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 for building_name in list_building_names: job = pool.apply_async(input_estimate_prepare_multi_processing, [building_name, gv, locator, 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 = 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 else: urban_input_matrix = np.concatenate((urban_input_matrix, NN_input_ready)) # close the multiprocessing pool.close() # from cea.demand.metamodel.nn_generator.input_matrix import input_prepare_multi_processing # for counter, building_name in enumerate(list_building_names): # NN_input_ready, NN_target_ready = 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) # check_nan = 1 * (np.isnan(np.sum(NN_input_ready))) # if check_nan == 0: # if counter == 0: # urban_input_matrix = NN_input_ready # # else: # urban_input_matrix = np.concatenate((urban_input_matrix, NN_input_ready)) # print (counter) model, scalerT, scalerX = nn_model_collector(locator) # reshape file to get a tensor of buildings, features, time. num_buildings = len(list_building_names) num_features = len(urban_input_matrix[0]) num_outputs = len(target_parameters) matrix = np.empty([num_buildings, 8759+warmup_period, num_outputs]) reshaped_input_matrix = urban_input_matrix.reshape(num_buildings, 8759, num_features) # including warm up period warmup_period_input_matrix = reshaped_input_matrix[:,(8759-warmup_period):,:] concat_input_matrix = np.hstack((warmup_period_input_matrix, reshaped_input_matrix)) for i in range(8759+warmup_period): one_hour_step = concat_input_matrix[:, i, :] if i<1: first_hour_step = np.empty([num_buildings, num_outputs]) first_hour_step=first_hour_step*0 one_hour_step[:, 36:41]=first_hour_step inputs_x = scalerX.transform(one_hour_step) model_estimates = model.predict(inputs_x) matrix[:, i, :] = scalerT.inverse_transform(model_estimates) else: other_hour_step = matrix[:,i-1,:] one_hour_step[:, 36:41] = other_hour_step inputs_x = scalerX.transform(one_hour_step) model_estimates = model.predict(inputs_x) matrix[:, i, :] = scalerT.inverse_transform(model_estimates) # lets save: for i, name in enumerate(list_building_names): vector = matrix[i][warmup_period-1:, :].T dict_to_dataframe = dict(zip(target_parameters, vector )) pd.DataFrame(dict_to_dataframe).to_csv(locator.get_result_building_NN(name), float_format='%.3f') print "done" return
def main(output_file): 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') locator = InputLocator(reference_case) config = cea.config.Configuration(cea.config.DEFAULT_CONFIG) weather_path = locator.get_weather('Zug') weather_data = epwreader.epw_reader(weather_path)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] # run properties script import cea.datamanagement.data_helper cea.datamanagement.data_helper.data_helper(locator, config, True, True, True, True, True, True) region = config.region year = weather_data['year'][0] use_daysim_radiation = config.demand.use_daysim_radiation resolution_outputs = config.demand.resolution_output loads_output = config.demand.loads_output massflows_output = config.demand.massflows_output temperatures_output = config.demand.temperatures_output format_output = config.demand.format_output use_dynamic_infiltration_calculation = config.demand.use_dynamic_infiltration_calculation use_stochastic_occupancy = config.demand.use_stochastic_occupancy building_properties, schedules_dict, date = properties_and_schedule( locator, region, year, use_daysim_radiation) print("data for test_calc_thermal_loads:") print(building_properties.list_building_names()) bpr = building_properties['B01'] result = calc_thermal_loads('B01', bpr, weather_data, schedules_dict, date, locator, use_stochastic_occupancy, use_dynamic_infiltration_calculation, resolution_outputs, loads_output, massflows_output, temperatures_output, format_output, region) # 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)) test_config = ConfigParser.SafeConfigParser() test_config.read(output_file) value_columns = [ u"E_sys_kWh", u"Qcdata_sys_kWh", u"Qcre_sys_kWh", u"Qcs_sys_kWh", u"Qhs_sys_kWh", u"Qww_sys_kWh", u"Tcs_sys_re_C", u"Ths_sys_re_C", u"Tww_sys_re_C", u"Tcs_sys_sup_C", u"Ths_sys_sup_C", u"Tww_sys_sup_C" ] values = [float(df[column].sum()) for column in value_columns] print("values = %s " % repr(values)) if not test_config.has_section("test_calc_thermal_loads"): test_config.add_section("test_calc_thermal_loads") test_config.set("test_calc_thermal_loads", "value_columns", json.dumps(value_columns)) print values test_config.set("test_calc_thermal_loads", "values", json.dumps(values)) print("data for test_calc_thermal_loads_other_buildings:") buildings = ['B01', 'B03', 'B02', 'B05', 'B04', 'B07', 'B06', 'B09', 'B08'] results = {} for building in buildings: bpr = building_properties[building] b, qhs_sys_kwh, qcs_sys_kwh, qww_sys_kwh = run_for_single_building( building, bpr, weather_data, schedules_dict, date, locator, use_stochastic_occupancy, use_dynamic_infiltration_calculation, resolution_outputs, loads_output, massflows_output, temperatures_output, format_output, region) print( "'%(b)s': (%(qhs_sys_kwh).5f, %(qcs_sys_kwh).5f, %(qww_sys_kwh).5f)," % locals()) results[building] = (qhs_sys_kwh, qcs_sys_kwh, qww_sys_kwh) if not test_config.has_section("test_calc_thermal_loads_other_buildings"): test_config.add_section("test_calc_thermal_loads_other_buildings") test_config.set("test_calc_thermal_loads_other_buildings", "results", json.dumps(results)) with open(output_file, 'w') as f: test_config.write(f) print("Wrote output to %(output_file)s" % locals())