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())
