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 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 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 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 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 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.clock()
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)
# 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)
for building_name in building_names:
print('running for building %s') %(building_name)
# run substation model to derive temperatures of the building
substation_results = pd.read_csv(locator.get_optimization_substations_results_file(building_name, "DH", ""))
q_load_Wh = np.vectorize(calc_new_load)(substation_results["mdot_DH_result_kgpers"],
substation_results["T_supply_DH_result_K"],
substation_results["T_return_DH_result_K"])
Qnom_W = q_load_Wh.max()
# Create empty matrices
Opex_a_var_USD = np.zeros((13, 7))
Capex_total_USD = np.zeros((13, 7))
Capex_a_USD = np.zeros((13, 7))
Opex_a_fixed_USD = np.zeros((13, 7))
Capex_opex_a_fixed_only_USD = np.zeros((13, 7))
Opex_a_USD = np.zeros((13, 7))
GHG_tonCO2 = np.zeros((13, 7))
PEN_MJoil = np.zeros((13, 7))
# indicate supply technologies for each configuration
Opex_a_var_USD[0][0] = 1 # Boiler NG
Opex_a_var_USD[1][1] = 1 # Boiler BG
Opex_a_var_USD[2][2] = 1 # Fuel Cell
resourcesRes = np.zeros((13, 4))
Q_Boiler_for_GHP_W = np.zeros((10, 1)) # Save peak capacity of GHP Backup Boilers
GHP_el_size_W = np.zeros((10, 1)) # Save peak capacity of GHP
# save supply system activation of all supply configurations
heating_dispatch = {}
# Supply with the Boiler / FC / GHP
Tret_K = substation_results["T_return_DH_result_K"].values
Tsup_K = substation_results["T_supply_DH_result_K"].values
mdot_kgpers = substation_results["mdot_DH_result_kgpers"].values
## Start Hourly calculation
print building_name, ' decentralized heating supply systems simulations...'
Tret_K = np.where(Tret_K > 0.0, Tret_K, Tsup_K)
## 0: Boiler NG
BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(q_load_Wh, Qnom_W, Tret_K)
Qgas_to_Boiler_Wh = np.divide(q_load_Wh, BoilerEff, out=np.zeros_like(q_load_Wh), where=BoilerEff != 0.0)
Boiler_Status = np.where(Qgas_to_Boiler_Wh > 0.0, 1, 0)
# add costs
Opex_a_var_USD[0][4] += sum(prices.NG_PRICE * Qgas_to_Boiler_Wh) # CHF
GHG_tonCO2[0][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_CO2_EQ) # ton CO2
PEN_MJoil[0][6] += calc_pen_Whyr_to_MJoilyr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq
# add activation
resourcesRes[0][0] += sum(q_load_Wh) # q from NG
heating_dispatch[0] = {'Q_Boiler_gen_directload_W': q_load_Wh,
'Boiler_Status': Boiler_Status,
'NG_Boiler_req_W': Qgas_to_Boiler_Wh,
'E_hs_ww_req_W': np.zeros(8760)}
## 1: Boiler BG
# add costs
Opex_a_var_USD[1][4] += sum(prices.BG_PRICE * Qgas_to_Boiler_Wh) # CHF
GHG_tonCO2[1][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_CO2_EQ) # ton CO2
PEN_MJoil[1][6] += calc_pen_Whyr_to_MJoilyr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq
# add activation
resourcesRes[1][1] += sum(q_load_Wh) # q from BG
heating_dispatch[1] = {'Q_Boiler_gen_directload_W': q_load_Wh,
'Boiler_Status': Boiler_Status,
'BG_Boiler_req_W': Qgas_to_Boiler_Wh,
'E_hs_ww_req_W': np.zeros(8760)}
## 2: Fuel Cell
(FC_Effel, FC_Effth) = np.vectorize(FC.calc_eta_FC)(q_load_Wh, Qnom_W, 1, "B")
Qgas_to_FC_Wh = q_load_Wh / (FC_Effth + FC_Effel) # FIXME: should be q_load_Wh/FC_Effth?
el_from_FC_Wh = Qgas_to_FC_Wh * FC_Effel
FC_Status = np.where(Qgas_to_FC_Wh > 0.0, 1, 0)
# add variable costs, emissions and primary energy
Opex_a_var_USD[2][4] += sum(prices.NG_PRICE * Qgas_to_FC_Wh - prices.ELEC_PRICE_EXPORT * el_from_FC_Wh) # CHF, extra electricity sold to grid
GHG_tonCO2_from_FC = (0.0874 * Qgas_to_FC_Wh * 3600E-6 + 773 * 0.45 * el_from_FC_Wh * 1E-6 -
lca.EL_TO_CO2_EQ * el_from_FC_Wh * 3600E-6) / 1E3
GHG_tonCO2[2][5] += sum(GHG_tonCO2_from_FC) # tonCO2
# Bloom box emissions within the FC: 773 lbs / MWh_el (and 1 lbs = 0.45 kg)
# http://www.carbonlighthouse.com/2011/09/16/bloom-box/
PEN_MJoil_from_FC = 1.51 * Qgas_to_FC_Wh * 3600E-6 - lca.EL_TO_OIL_EQ * el_from_FC_Wh * 3600E-6
PEN_MJoil[2][6] += sum(PEN_MJoil_from_FC) # MJ-oil-eq
# add activation
resourcesRes[2][0] = sum(q_load_Wh) # q from NG
resourcesRes[2][2] = sum(el_from_FC_Wh) # el for GHP # FIXME: el from FC
heating_dispatch[2] = {'Q_Fuelcell_gen_directload_W': q_load_Wh,
'Fuelcell_Status': FC_Status,
'NG_FuelCell_req_W': Qgas_to_FC_Wh,
'E_Fuelcell_gen_export_W': el_from_FC_Wh,
'E_hs_ww_req_W': np.zeros(8760)}
# 3-13: Boiler NG + GHP
for i in range(10):
# set nominal size for Boiler and GHP
QnomBoiler_W = i / 10.0 * Qnom_W
mdot_kgpers_Boiler = i / 10.0 * mdot_kgpers
QnomGHP_W = Qnom_W - QnomBoiler_W
# GHP operation
Texit_GHP_nom_K = QnomGHP_W / (mdot_kgpers * HEAT_CAPACITY_OF_WATER_JPERKGK) + Tret_K
el_GHP_Wh, q_load_NG_Boiler_Wh, \
qhot_missing_Wh, \
Texit_GHP_K, q_from_GHP_Wh = np.vectorize(calc_GHP_operation)(QnomGHP_W, T_ground_K, Texit_GHP_nom_K,
Tret_K, Tsup_K, mdot_kgpers, q_load_Wh)
GHP_el_size_W[i][0] = max(el_GHP_Wh)
GHP_Status = np.where(q_from_GHP_Wh > 0.0, 1, 0)
# GHP Backup Boiler operation
if max(qhot_missing_Wh) > 0.0:
print "GHP unable to cover the whole demand, boiler activated!"
Qnom_GHP_Backup_Boiler_W = max(qhot_missing_Wh)
BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(qhot_missing_Wh, Qnom_GHP_Backup_Boiler_W, Texit_GHP_K)
Qgas_to_GHPBoiler_Wh = np.divide(qhot_missing_Wh, BoilerEff,
out=np.zeros_like(qhot_missing_Wh), where=BoilerEff != 0.0)
else:
Qgas_to_GHPBoiler_Wh = np.zeros(q_load_Wh.shape[0])
Qnom_GHP_Backup_Boiler_W = 0.0
Q_Boiler_for_GHP_W[i][0] = Qnom_GHP_Backup_Boiler_W
GHPbackupBoiler_Status = np.where(qhot_missing_Wh > 0.0, 1, 0)
# NG Boiler operation
BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(q_load_NG_Boiler_Wh, QnomBoiler_W, Texit_GHP_K)
Qgas_to_Boiler_Wh = np.divide(q_load_NG_Boiler_Wh, BoilerEff,
out=np.zeros_like(q_load_NG_Boiler_Wh), where=BoilerEff != 0.0)
Boiler_Status = np.where(q_load_NG_Boiler_Wh > 0.0, 1, 0)
# add costs
# electricity
el_total_Wh = el_GHP_Wh
Opex_a_var_USD[3 + i][4] += sum(prices.ELEC_PRICE * el_total_Wh) # CHF
GHG_tonCO2[3 + i][5] += calc_emissions_Whyr_to_tonCO2yr(sum(el_total_Wh), lca.EL_TO_CO2_EQ) # ton CO2
PEN_MJoil[3 + i][6] += calc_pen_Whyr_to_MJoilyr(sum(el_total_Wh), lca.EL_TO_OIL_EQ) # MJ-oil-eq
# gas
Q_gas_total_Wh = Qgas_to_GHPBoiler_Wh + Qgas_to_Boiler_Wh
Opex_a_var_USD[3 + i][4] += sum(prices.NG_PRICE * Q_gas_total_Wh) # CHF
GHG_tonCO2[3 + i][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Q_gas_total_Wh), lca.NG_TO_CO2_EQ) # ton CO2
PEN_MJoil[3 + i][6] += calc_pen_Whyr_to_MJoilyr(sum(Q_gas_total_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq
# add activation
resourcesRes[3 + i][0] = sum(qhot_missing_Wh + q_load_NG_Boiler_Wh)
resourcesRes[3 + i][2] = sum(el_GHP_Wh)
resourcesRes[3 + i][3] = sum(q_from_GHP_Wh)
heating_dispatch[3 + i] = {'Q_GHP_gen_directload_W': q_from_GHP_Wh,
'Q_BackupBoiler_gen_directload_W': qhot_missing_Wh,
'Q_Boiler_gen_directload_W': q_load_NG_Boiler_Wh,
'GHP_Status': GHP_Status,
'BackupBoiler_Status': GHPbackupBoiler_Status,
'Boiler_Status': Boiler_Status,
'NG_BackupBoiler_req_Wh': Qgas_to_GHPBoiler_Wh,
'NG_Boiler_req_Wh': Qgas_to_Boiler_Wh,
'E_hs_ww_req_W': el_GHP_Wh}
# Add all costs
# 0: Boiler NG
Capex_a_Boiler_USD, Opex_a_fixed_Boiler_USD, Capex_Boiler_USD = Boiler.calc_Cinv_boiler(Qnom_W, locator, config,
'BO1')
Capex_total_USD[0][0] = Capex_Boiler_USD
Capex_a_USD[0][0] = Capex_a_Boiler_USD
Opex_a_fixed_USD[0][0] = Opex_a_fixed_Boiler_USD
Capex_opex_a_fixed_only_USD[0][0] = Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price?
# 1: Boiler BG
Capex_total_USD[1][0] = Capex_Boiler_USD
Capex_a_USD[1][0] = Capex_a_Boiler_USD
Opex_a_fixed_USD[1][0] = Opex_a_fixed_Boiler_USD
Capex_opex_a_fixed_only_USD[1][0] = Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price?
# 2: Fuel Cell
Capex_a_FC_USD, Opex_fixed_FC_USD, Capex_FC_USD = FC.calc_Cinv_FC(Qnom_W, locator, config)
Capex_total_USD[2][0] = Capex_FC_USD
Capex_a_USD[2][0] = Capex_a_FC_USD
Opex_a_fixed_USD[2][0] = Opex_fixed_FC_USD
Capex_opex_a_fixed_only_USD[2][0] = Capex_a_FC_USD + Opex_fixed_FC_USD # TODO:variable price?
# 3-13: BOILER + GHP
for i in range(10):
Opex_a_var_USD[3 + i][0] = i / 10.0 # Boiler share
Opex_a_var_USD[3 + i][3] = 1 - i / 10.0 # GHP share
# Get boiler costs
QnomBoiler_W = i / 10.0 * Qnom_W
Capex_a_Boiler_USD, Opex_a_fixed_Boiler_USD, Capex_Boiler_USD = Boiler.calc_Cinv_boiler(QnomBoiler_W,
locator,
config, 'BO1')
Capex_total_USD[3 + i][0] += Capex_Boiler_USD
Capex_a_USD[3 + i][0] += Capex_a_Boiler_USD
Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_Boiler_USD
Capex_opex_a_fixed_only_USD[3 + i][
0] += Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price?
# Get back up boiler costs
Qnom_Backup_Boiler_W = Q_Boiler_for_GHP_W[i][0]
Capex_a_GHPBoiler_USD, Opex_a_fixed_GHPBoiler_USD, Capex_GHPBoiler_USD = Boiler.calc_Cinv_boiler(
Qnom_Backup_Boiler_W, locator,
config, 'BO1')
Capex_total_USD[3 + i][0] += Capex_GHPBoiler_USD
Capex_a_USD[3 + i][0] += Capex_a_GHPBoiler_USD
Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_GHPBoiler_USD
Capex_opex_a_fixed_only_USD[3 + i][
0] += Capex_a_GHPBoiler_USD + Opex_a_fixed_GHPBoiler_USD # TODO:variable price?
# Get ground source heat pump costs
Capex_a_GHP_USD, Opex_a_fixed_GHP_USD, Capex_GHP_USD = HP.calc_Cinv_GHP(GHP_el_size_W[i][0], locator,
config)
Capex_total_USD[3 + i][0] += Capex_GHP_USD
Capex_a_USD[3 + i][0] += Capex_a_GHP_USD
Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_GHP_USD
Capex_opex_a_fixed_only_USD[3 + i][0] += Capex_a_GHP_USD + Opex_a_fixed_GHP_USD # TODO:variable price?
# Best configuration
Best = np.zeros((13, 1))
indexBest = 0
TAC_USD = np.zeros((13, 2))
TotalCO2 = np.zeros((13, 2))
TotalPrim = np.zeros((13, 2))
for i in range(13):
TAC_USD[i][0] = TotalCO2[i][0] = TotalPrim[i][0] = i
Opex_a_USD[i][1] = Opex_a_fixed_USD[i][0] + + Opex_a_var_USD[i][4]
TAC_USD[i][1] = Capex_opex_a_fixed_only_USD[i][0] + Opex_a_var_USD[i][4]
TotalCO2[i][1] = GHG_tonCO2[i][5]
TotalPrim[i][1] = PEN_MJoil[i][6]
CostsS = TAC_USD[np.argsort(TAC_USD[:, 1])]
CO2S = TotalCO2[np.argsort(TotalCO2[:, 1])]
PrimS = TotalPrim[np.argsort(TotalPrim[:, 1])]
el = len(CostsS)
rank = 0
Bestfound = False
optsearch = np.empty(el)
optsearch.fill(3)
indexBest = 0
geothermal_potential = geothermal_potential_data.set_index('Name')
# Check the GHP area constraint
for i in range(10):
QGHP = (1 - i / 10.0) * Qnom_W
areaAvail = geothermal_potential.ix[building_name, 'Area_geo']
Qallowed = np.ceil(areaAvail / GHP_A) * GHP_HMAX_SIZE # [W_th]
if Qallowed < QGHP:
optsearch[i + 3] += 1
Best[i + 3][0] = - 1
while not Bestfound and rank < el:
optsearch[int(CostsS[rank][0])] -= 1
optsearch[int(CO2S[rank][0])] -= 1
optsearch[int(PrimS[rank][0])] -= 1
if np.count_nonzero(optsearch) != el:
Bestfound = True
indexBest = np.where(optsearch == 0)[0][0]
rank += 1
# get the best option according to the ranking.
Best[indexBest][0] = 1
# Save results in csv file
performance_results = {
"Nominal heating load": Qnom_W,
"Capacity_BaseBoiler_NG_W": Qnom_W * Opex_a_var_USD[:, 0],
"Capacity_FC_NG_W": Qnom_W * Opex_a_var_USD[:, 2],
"Capacity_GS_HP_W": Qnom_W * Opex_a_var_USD[:, 3],
"TAC_USD": TAC_USD[:, 1],
"Capex_a_USD": Capex_a_USD[:, 0],
"Capex_total_USD": Capex_total_USD[:, 0],
"Opex_fixed_USD": Opex_a_fixed_USD[:, 0],
"Opex_var_USD": Opex_a_var_USD[:, 4],
"GHG_tonCO2": GHG_tonCO2[:, 5],
"PEN_MJoil": PEN_MJoil[:, 6],
"Best configuration": Best[:, 0]}
results_to_csv = pd.DataFrame(performance_results)
fName_result = locator.get_optimization_decentralized_folder_building_result_heating(building_name)
results_to_csv.to_csv(fName_result, sep=',')
# save activation for the best supply system configuration
best_activation_df = pd.DataFrame.from_dict(heating_dispatch[indexBest]) #
best_activation_df.to_csv(
locator.get_optimization_decentralized_folder_building_result_heating_activation(building_name))
print time.clock() - t0, "seconds process time for the Disconnected Building Routine \n"
def network_main(locator, total_demand, building_names, config, gv, key):
"""
This function summarizes the distribution demands and will give them as:
- absolute values (design values = extreme values)
- hourly operation scheme of input/output of distribution
:param locator: locator class
:param total_demand: dataframe with total demand of buildings
:param building_names: vector with names of buildings
:param gv: global variables class
:param key: when called by the optimization, a key will provide an id for the individual
and the generation.
:type locator: class
:type total_demand: list
:type building_names: vector
:type gv: class
:type key: int
:return: csv file stored in locator.get_optimization_network_results_folder() as fName_result
where fName_result: FIXME: what?
:rtype: Nonetype
"""
t0 = time.clock()
weather_data = epwreader.epw_reader(config.weather)[[
'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms',
'skytemp_C'
]]
ground_temp = calc_ground_temperature(locator,
weather_data['drybulb_C'],
depth_m=10)
# import properties of distribution
network_type = config.thermal_network.network_type
list_network_name = ['', ''] # config.thermal_network.network_names
num_buildings_network = total_demand.Name.count()
if len(list_network_name) == 0:
network_name = ''
pipes_tot_length = pd.read_csv(
locator.get_optimization_network_edge_list_file(
network_type, network_name),
usecols=['pipe length']).sum().values
else:
for i, network_name in enumerate(list_network_name):
if i == 0:
pipes_tot_length = pd.read_csv(
locator.get_optimization_network_edge_list_file(
network_type, network_name),
usecols=['pipe length']).sum().values
else:
pipes_tot_length = pipes_tot_length + pd.read_csv(
locator.get_optimization_network_edge_list_file(
network_type, network_name),
usecols=['pipe length']).sum().values
ntwk_length = pipes_tot_length.sum(
) * num_buildings_network / gv.num_tot_buildings
# empty vectors
buildings = []
substations = []
Qcdata_netw_total_kWh = np.zeros(8760)
mcpdata_netw_total_kWperC = np.zeros(8760)
Electr_netw_total_W = np.zeros(8760)
mdot_heat_netw_all_kgpers = np.zeros(8760)
mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers = np.zeros(8760)
mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers = np.zeros(
8760)
Q_DH_building_netw_total_W = np.zeros(8760)
Q_DC_building_netw_space_cooling_and_refrigeration_total_W = np.zeros(8760)
Q_DC_building_netw_space_cooling_data_center_and_refrigeration_total_W = np.zeros(
8760)
sum_tret_mdot_heat = np.zeros(8760)
sum_tret_mdot_cool_space_cooling_and_refrigeration = np.zeros(8760)
sum_tret_mdot_cool_space_cooling_data_center_and_refrigeration = np.zeros(
8760)
mdot_heat_netw_min_kgpers = np.zeros(8760) + 1E6
mdot_cool_space_cooling_and_refrigeration_netw_min_kgpers = np.zeros(
8760) + 1E6
mdot_cool_space_cooling_data_center_and_refrigeration_netw_min_kgpers = np.zeros(
8760) + 1E6
iteration = 0
for building_name in building_names:
buildings.append(
pd.read_csv(
locator.get_demand_results_file(building_name),
usecols=['DATE', 'mcpcdata_sys_kWperC', 'Qcdata_sys_kWh']))
substations.append(
pd.read_csv(
locator.get_optimization_substations_results_file(
building_name),
usecols=[
'Electr_array_all_flat_W', 'mdot_DH_result_kgpers',
'mdot_space_cooling_and_refrigeration_result_kgpers',
'mdot_space_cooling_data_center_and_refrigeration_result_kgpers',
'Q_heating_W', 'Q_dhw_W',
'Q_space_cooling_and_refrigeration_W',
'Q_space_cooling_data_center_and_refrigeration_W',
'T_return_DH_result_K',
'T_return_DC_space_cooling_and_refrigeration_result_K',
'T_return_DC_space_cooling_data_center_and_refrigeration_result_K',
'T_supply_DH_result_K',
'T_supply_DC_space_cooling_and_refrigeration_result_K',
'T_supply_DC_space_cooling_data_center_and_refrigeration_result_K'
]))
Qcdata_netw_total_kWh += buildings[iteration].Qcdata_sys_kWh.values
mcpdata_netw_total_kWperC += buildings[
iteration].mcpcdata_sys_kWperC.values
Electr_netw_total_W += substations[
iteration].Electr_array_all_flat_W.values
mdot_heat_netw_all_kgpers += substations[
iteration].mdot_DH_result_kgpers.values
mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers += substations[
iteration].mdot_space_cooling_and_refrigeration_result_kgpers.values
mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers += substations[
iteration].mdot_space_cooling_data_center_and_refrigeration_result_kgpers.values
Q_DH_building_netw_total_W += (
substations[iteration].Q_heating_W.values +
substations[iteration].Q_dhw_W.values)
Q_DC_building_netw_space_cooling_and_refrigeration_total_W += (
substations[iteration].Q_space_cooling_and_refrigeration_W.values)
Q_DC_building_netw_space_cooling_data_center_and_refrigeration_total_W += (
substations[iteration].
Q_space_cooling_data_center_and_refrigeration_W.values)
sum_tret_mdot_heat += substations[
iteration].T_return_DH_result_K.values * substations[
iteration].mdot_DH_result_kgpers.values
sum_tret_mdot_cool_space_cooling_and_refrigeration += substations[
iteration].T_return_DC_space_cooling_and_refrigeration_result_K.values * \
substations[iteration].mdot_space_cooling_and_refrigeration_result_kgpers.values
sum_tret_mdot_cool_space_cooling_data_center_and_refrigeration += substations[
iteration].T_return_DC_space_cooling_data_center_and_refrigeration_result_K.values * \
substations[iteration].mdot_space_cooling_data_center_and_refrigeration_result_kgpers.values
# evaluate minimum flows
mdot_heat_netw_min_kgpers = np.vectorize(calc_min_flow)(
mdot_heat_netw_min_kgpers,
substations[iteration].mdot_DH_result_kgpers.values)
mdot_cool_space_cooling_and_refrigeration_netw_min_kgpers = np.vectorize(
calc_min_flow)(
mdot_cool_space_cooling_and_refrigeration_netw_min_kgpers,
substations[iteration].
mdot_space_cooling_and_refrigeration_result_kgpers.values)
mdot_cool_space_cooling_data_center_and_refrigeration_netw_min_kgpers = np.vectorize(
calc_min_flow
)(mdot_cool_space_cooling_data_center_and_refrigeration_netw_min_kgpers,
substations[iteration].
mdot_space_cooling_data_center_and_refrigeration_result_kgpers.values
)
iteration += 1
# calculate thermal losses of distribution
T_DHN_withoutlosses_re_K = np.vectorize(calc_return_temp)(
sum_tret_mdot_heat, mdot_heat_netw_all_kgpers)
T_DHN_withoutlosses_sup_K = np.vectorize(calc_supply_temp)(
T_DHN_withoutlosses_re_K, Q_DH_building_netw_total_W,
mdot_heat_netw_all_kgpers, HEAT_CAPACITY_OF_WATER_JPERKGK, "DH")
T_DCN_space_cooling_and_refrigeration_withoutlosses_re_K = np.vectorize(
calc_return_temp)(
sum_tret_mdot_cool_space_cooling_and_refrigeration,
mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers)
T_DCN_space_cooling_and_refrigeration_withoutlosses_sup_K = np.vectorize(
calc_supply_temp)(
T_DCN_space_cooling_and_refrigeration_withoutlosses_re_K,
Q_DC_building_netw_space_cooling_and_refrigeration_total_W,
mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers,
HEAT_CAPACITY_OF_WATER_JPERKGK, "DC")
T_DCN_space_cooling_data_center_and_refrigeration_withoutlosses_re_K = np.vectorize(
calc_return_temp
)(sum_tret_mdot_cool_space_cooling_data_center_and_refrigeration,
mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers)
T_DCN_space_cooling_data_center_and_refrigeration_withoutlosses_sup_K = np.vectorize(
calc_supply_temp
)(T_DCN_space_cooling_data_center_and_refrigeration_withoutlosses_re_K,
Q_DC_building_netw_space_cooling_data_center_and_refrigeration_total_W,
mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers,
HEAT_CAPACITY_OF_WATER_JPERKGK, "DC")
Q_DH_losses_sup_W = np.vectorize(calc_piping_thermal_losses_heating)(
T_DHN_withoutlosses_sup_K, mdot_heat_netw_all_kgpers,
mdot_heat_netw_min_kgpers, ntwk_length, ground_temp, K_DH,
HEAT_CAPACITY_OF_WATER_JPERKGK)
Q_DH_losses_re_W = np.vectorize(calc_piping_thermal_losses_heating)(
T_DHN_withoutlosses_re_K, mdot_heat_netw_all_kgpers,
mdot_heat_netw_min_kgpers, ntwk_length, ground_temp, K_DH,
HEAT_CAPACITY_OF_WATER_JPERKGK)
Q_DH_losses_W = Q_DH_losses_sup_W + Q_DH_losses_re_W
Q_DHNf_W = Q_DH_building_netw_total_W + Q_DH_losses_W
Q_DC_space_cooling_and_refrigeration_losses_sup_W = np.vectorize(
calc_piping_thermal_losses_cooling)(
Q_DC_building_netw_space_cooling_and_refrigeration_total_W)
Q_DC_space_cooling_data_center_and_refrigeration_losses_sup_W = np.vectorize(
calc_piping_thermal_losses_cooling
)(Q_DC_building_netw_space_cooling_data_center_and_refrigeration_total_W)
Q_DC_space_cooling_and_refrigeration_losses_re_W = np.vectorize(
calc_piping_thermal_losses_cooling)(
Q_DC_building_netw_space_cooling_and_refrigeration_total_W)
Q_DC_space_cooling_data_center_and_refrigeration_losses_re_W = np.vectorize(
calc_piping_thermal_losses_cooling
)(Q_DC_building_netw_space_cooling_data_center_and_refrigeration_total_W)
Q_DC_space_cooling_and_refrigeration_losses_W = Q_DC_space_cooling_and_refrigeration_losses_sup_W + Q_DC_space_cooling_and_refrigeration_losses_re_W
Q_DC_space_cooling_data_center_and_refrigeration_losses_W = Q_DC_space_cooling_data_center_and_refrigeration_losses_sup_W + Q_DC_space_cooling_data_center_and_refrigeration_losses_re_W
Q_DCNf_space_cooling_and_refrigeration_W = Q_DC_building_netw_space_cooling_and_refrigeration_total_W + Q_DC_space_cooling_and_refrigeration_losses_W
Q_DCNf_space_cooling_data_center_and_refrigeration_W = Q_DC_building_netw_space_cooling_data_center_and_refrigeration_total_W + Q_DC_space_cooling_data_center_and_refrigeration_losses_W
T_DHN_re_K = np.vectorize(calc_temp_withlosses)(
T_DHN_withoutlosses_re_K, Q_DH_losses_re_W, mdot_heat_netw_all_kgpers,
HEAT_CAPACITY_OF_WATER_JPERKGK, "negative")
T_DHN_sup_K = np.vectorize(calc_temp_withlosses)(
T_DHN_withoutlosses_sup_K, Q_DH_losses_sup_W,
mdot_heat_netw_all_kgpers, HEAT_CAPACITY_OF_WATER_JPERKGK, "positive")
T_DCN_space_cooling_and_refrigeration_re_K = np.vectorize(
calc_temp_withlosses)(
T_DCN_space_cooling_and_refrigeration_withoutlosses_re_K,
Q_DC_space_cooling_and_refrigeration_losses_re_W,
mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers,
HEAT_CAPACITY_OF_WATER_JPERKGK, "positive")
T_DCN_space_cooling_data_center_and_refrigeration_re_K = np.vectorize(
calc_temp_withlosses
)(T_DCN_space_cooling_data_center_and_refrigeration_withoutlosses_re_K,
Q_DC_space_cooling_data_center_and_refrigeration_losses_re_W,
mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers,
HEAT_CAPACITY_OF_WATER_JPERKGK, "positive")
T_DCN_space_cooling_and_refrigeration_sup_K = np.vectorize(
calc_temp_withlosses)(
T_DCN_space_cooling_and_refrigeration_withoutlosses_sup_K,
Q_DC_space_cooling_and_refrigeration_losses_sup_W,
mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers,
HEAT_CAPACITY_OF_WATER_JPERKGK, "negative")
T_DCN_space_cooling_data_center_and_refrigeration_sup_K = np.vectorize(
calc_temp_withlosses
)(T_DCN_space_cooling_data_center_and_refrigeration_withoutlosses_sup_K,
Q_DC_space_cooling_data_center_and_refrigeration_losses_sup_W,
mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers,
HEAT_CAPACITY_OF_WATER_JPERKGK, "negative")
day_of_max_heatmassflow_fin = np.zeros(8760)
day_of_max_heatmassflow = find_index_of_max(mdot_heat_netw_all_kgpers)
day_of_max_heatmassflow_fin[:] = day_of_max_heatmassflow
for i in range(8760):
if T_DCN_space_cooling_data_center_and_refrigeration_sup_K[
i] > T_DCN_space_cooling_data_center_and_refrigeration_re_K[i]:
print(i)
if T_DCN_space_cooling_and_refrigeration_sup_K[
i] > T_DCN_space_cooling_and_refrigeration_re_K[i]:
print(i)
date = pd.read_csv(locator.get_demand_results_file(
building_names[0])).DATE.values
results = pd.DataFrame({
"DATE":
date,
"mdot_DH_netw_total_kgpers":
mdot_heat_netw_all_kgpers,
"mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers":
mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers,
"mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers":
mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers,
"Q_DHNf_W":
Q_DHNf_W,
"Q_DCNf_space_cooling_and_refrigeration_W":
Q_DCNf_space_cooling_and_refrigeration_W,
"Q_DCNf_space_cooling_data_center_and_refrigeration_W":
Q_DCNf_space_cooling_data_center_and_refrigeration_W,
"T_DHNf_re_K":
T_DHN_re_K,
"T_DCNf_space_cooling_and_refrigeration_re_K":
T_DCN_space_cooling_and_refrigeration_re_K,
"T_DCNf_space_cooling_data_center_and_refrigeration_re_K":
T_DCN_space_cooling_data_center_and_refrigeration_re_K,
"T_DHNf_sup_K":
T_DHN_sup_K,
"T_DCNf_space_cooling_and_refrigeration_sup_K":
T_DCN_space_cooling_and_refrigeration_sup_K,
"T_DCNf_space_cooling_data_center_and_refrigeration_sup_K":
T_DCN_space_cooling_data_center_and_refrigeration_sup_K,
"Qcdata_netw_total_kWh":
Qcdata_netw_total_kWh,
"day_of_max_heatmassflow":
day_of_max_heatmassflow,
"mcpdata_netw_total_kWperC":
mcpdata_netw_total_kWperC,
"Electr_netw_total_W":
Electr_netw_total_W,
"Q_DH_losses_W":
Q_DH_losses_W,
"Q_DC_space_cooling_and_refrigeration_losses_W":
Q_DC_space_cooling_and_refrigeration_losses_W,
"Q_DC_space_cooling_data_center_and_refrigeration_losses_W":
Q_DC_space_cooling_data_center_and_refrigeration_losses_W
})
# the key depicts weather this is the distribution of all customers or a distribution of a gorup of them.
if key == 'all':
results.to_csv(
locator.get_optimization_network_all_results_summary(key),
index=False)
else:
results.to_csv(locator.get_optimization_network_results_summary(key),
index=False)
print time.clock(
) - t0, "seconds process time for Network summary for configuration", key, "\n"
def extract_loads_individual(locator, DCN_barcode, DHN_barcode,
district_heating_network,
district_cooling_network,
column_names_buildings_heating,
column_names_buildings_cooling):
# local variables
weather_file = locator.get_weather_file()
network_depth_m = Z0
T_ambient = epwreader.epw_reader(weather_file)['drybulb_C']
ground_temp = calc_ground_temperature(locator,
T_ambient,
depth_m=network_depth_m)
# EVALUATE CASES TO CREATE A NETWORK OR NOT
if district_heating_network: # network exists
network_file_name_heating = "DH_Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
if not os.path.exists(
locator.get_optimization_network_results_summary(
'DH', DHN_barcode)):
total_demand = createTotalNtwCsv(DHN_barcode, locator,
column_names_buildings_heating)
num_total_buildings = len(column_names_buildings_heating)
buildings_in_heating_network = total_demand.Name.values
# Run the substation and distribution routines
substation.substation_main_heating(locator,
total_demand,
buildings_in_heating_network,
DHN_barcode=DHN_barcode)
results = summarize_network.network_main(
locator, buildings_in_heating_network, ground_temp,
num_total_buildings, "DH", DHN_barcode)
else:
results = pd.read_csv(
locator.get_optimization_network_results_summary(
'DH', DHN_barcode))
Q_DHNf_W = results['Q_DHNf_W'].values
Q_heating_max_W = Q_DHNf_W.max()
Qcdata_netw_total_kWh = results['Qcdata_netw_total_kWh'].values
Q_wasteheat_datacentre_max_W = Qcdata_netw_total_kWh.max()
else:
Q_heating_max_W = 0.0
Q_wasteheat_datacentre_max_W = 0.0
network_file_name_heating = ""
if district_cooling_network: # network exists
network_file_name_cooling = "DC_Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
if not os.path.exists(
locator.get_optimization_network_results_summary(
'DC', DCN_barcode)):
total_demand = createTotalNtwCsv(DCN_barcode, locator,
column_names_buildings_cooling)
num_total_buildings = len(column_names_buildings_cooling)
buildings_in_cooling_network = total_demand.Name.values
# Run the substation and distribution routines
substation.substation_main_cooling(locator,
total_demand,
buildings_in_cooling_network,
DCN_barcode=DCN_barcode)
results = summarize_network.network_main(
locator, buildings_in_cooling_network, ground_temp,
num_total_buildings, 'DC', DCN_barcode)
else:
results = pd.read_csv(
locator.get_optimization_network_results_summary(
'DC', DCN_barcode))
# if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = results[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"].values
Q_cooling_max_W = Q_DCNf_W.max()
else:
Q_cooling_max_W = 0.0
network_file_name_cooling = ""
Q_heating_nom_W = Q_heating_max_W * (1 + Q_MARGIN_FOR_NETWORK)
Q_cooling_nom_W = Q_cooling_max_W * (1 + Q_MARGIN_FOR_NETWORK)
return Q_cooling_nom_W, Q_heating_nom_W, Q_wasteheat_datacentre_max_W, network_file_name_cooling, network_file_name_heating
def __init__(self, weather_file, locator):
self.weather_data = epwreader.epw_reader(weather_file)
self.date = self.weather_data['date']
self.T_ambient = self.weather_data['drybulb_C']
self.ground_temp = calc_ground_temperature(locator, self.T_ambient, depth_m=Z0)
def Storage_Design(T_storage_old_K, Q_in_storage_old_W, locator,
STORAGE_SIZE_m3, solar_technologies_data,
master_to_slave_vars, P_HP_max_W):
"""
:param CSV_NAME:
:param SOLCOL_TYPE:
:param T_storage_old_K:
:param Q_in_storage_old_W:
:param locator:
:param STORAGE_SIZE_m3:
:param STORE_DATA:
:param master_to_slave_vars:
:param P_HP_max_W:
:type CSV_NAME:
:type SOLCOL_TYPE:
:type T_storage_old_K:
:type Q_in_storage_old_W:
:type locator:
:type STORAGE_SIZE_m3:
:type STORE_DATA:
:type master_to_slave_vars:
:type P_HP_max_W:
:return:
:rtype:
"""
# Get network summary
Network_Data, \
Q_DH_networkload_Wh, \
Q_wasteheatServer_Wh, \
T_DH_return_array_K, \
T_DH_supply_array_K, \
mdot_heat_netw_total_kgpers = read_data_from_Network_summary(master_to_slave_vars)
# Get ground temperatures
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)
# Calculate DH operation with on-site energy sources and storage
T_amb_K = weather_data['drybulb_C'] + 273.15 # K
T_storage_min_K = master_to_slave_vars.T_ST_MAX
Q_disc_seasonstart_W = [0]
# Get installation and production data of all types of solar technologies for every hour of the year
E_PVT_gen_Whr = solar_technologies_data['E_PVT_gen_W']
Q_PVT_gen_Whr = solar_technologies_data['Q_PVT_gen_W']
Q_SC_ET_gen_Whr = solar_technologies_data['Q_SC_ET_gen_W']
Q_SC_FP_gen_Whr = solar_technologies_data['Q_SC_FP_gen_W']
Solar_Tscr_th_PVT_K_hour = solar_technologies_data['Tscr_th_PVT_K']
Solar_Tscr_th_SC_ET_K_hour = solar_technologies_data['Tscr_th_SC_ET_K']
Solar_Tscr_th_SC_FP_K_hour = solar_technologies_data['Tscr_th_SC_FP_K']
# Initialize variables
Q_storage_content_final_Whr = np.zeros(HOURS_IN_YEAR)
T_storage_final_Khr = np.zeros(HOURS_IN_YEAR)
Q_from_storage_final_Whr = np.zeros(HOURS_IN_YEAR)
Q_to_storage_final_Whr = np.zeros(HOURS_IN_YEAR)
E_aux_ch_final_Whr = np.zeros(HOURS_IN_YEAR)
E_aux_dech_final_Whr = np.zeros(HOURS_IN_YEAR)
Q_uncontrollable_final_Whr = np.zeros(HOURS_IN_YEAR)
Q_missing_final_Whr = np.zeros(HOURS_IN_YEAR)
Q_rejected_final_W = np.zeros(HOURS_IN_YEAR)
mdot_DH_final_kgpers = np.zeros(HOURS_IN_YEAR)
E_HPSC_FP_final_req_Whr = np.zeros(HOURS_IN_YEAR)
E_HPSC_ET_final_req_Whr = np.zeros(HOURS_IN_YEAR)
E_HPPVT_final_req_Whr = np.zeros(HOURS_IN_YEAR)
E_HPServer_final_req_Whr = np.zeros(HOURS_IN_YEAR)
Q_PVT_to_directload_Whr = np.zeros(HOURS_IN_YEAR)
Q_SC_ET_to_directload_Whr = np.zeros(HOURS_IN_YEAR)
Q_SC_FP_to_directload_Whr = np.zeros(HOURS_IN_YEAR)
Q_server_to_directload_Whr = np.zeros(HOURS_IN_YEAR)
Q_PVT_to_storage_Whr = np.zeros(HOURS_IN_YEAR)
Q_SC_ET_to_storage_Whr = np.zeros(HOURS_IN_YEAR)
Q_SC_FP_to_storage_Whr = np.zeros(HOURS_IN_YEAR)
Q_server_to_storage_Whr = np.zeros(HOURS_IN_YEAR)
Q_HP_Server_Whr = np.zeros(HOURS_IN_YEAR)
Q_HP_PVT_Whr = np.zeros(HOURS_IN_YEAR)
Q_HP_SC_ET_Whr = np.zeros(HOURS_IN_YEAR)
Q_HP_SC_FP_Whr = np.zeros(HOURS_IN_YEAR)
Q_loss_Whr = np.zeros(HOURS_IN_YEAR)
for HOUR in range(
HOURS_IN_YEAR
): # no idea why, but if we try a for loop it does not work
# Get network temperatures and capacity flow rates
T_DH_sup_K = T_DH_supply_array_K[HOUR]
T_DH_return_K = T_DH_return_array_K[HOUR]
mdot_DH_kgpers = mdot_heat_netw_total_kgpers[HOUR]
Q_Server_gen_initial_W = Q_wasteheatServer_Wh[HOUR]
Q_PVT_gen_W = Q_PVT_gen_Whr[HOUR]
Q_SC_ET_gen_W = Q_SC_ET_gen_Whr[HOUR]
Q_SC_FP_gen_W = Q_SC_FP_gen_Whr[HOUR]
Solar_Tscr_th_PVT_K = Solar_Tscr_th_PVT_K_hour[HOUR]
Solar_Tscr_th_SC_ET_K = Solar_Tscr_th_SC_ET_K_hour[HOUR]
Solar_Tscr_th_SC_FP_K = Solar_Tscr_th_SC_FP_K_hour[HOUR]
# Get heating demand in DH
Q_network_demand_W = Q_DH_networkload_Wh[HOUR]
# Get heating proved by SOLAR AND DATA CENTER (IF ANY)
E_HP_solar_and_server_req_W, \
Q_PVT_gen_W, \
Q_SC_ET_gen_W, \
Q_SC_FP_gen_W, \
Q_Server_gen_W, \
E_HPSC_FP_req_W, \
E_HPSC_ET_req_W, \
E_HPPVT_reg_W, \
E_HPServer_reg_W, \
Q_HP_Server_W, \
Q_HP_PVT_W, \
Q_HP_SC_ET_W, \
Q_HP_SC_FP_W = get_heating_provided_by_onsite_energy_sources(Q_PVT_gen_W,
Q_SC_ET_gen_W,
Q_SC_FP_gen_W,
Q_Server_gen_initial_W,
Solar_Tscr_th_PVT_K,
Solar_Tscr_th_SC_ET_K,
Solar_Tscr_th_SC_FP_K,
T_DH_sup_K,
master_to_slave_vars)
# Calculate storage operation
Q_in_storage_new_W, \
T_storage_new_K, \
Q_from_storage_req_W, \
Q_to_storage_W, \
E_aux_ch_W, \
E_aux_dech_W, \
Q_missing_W, \
Q_loss_W, \
mdot_DH_missing_kgpers, \
Q_server_to_directload_W, \
Q_server_to_storage_W, \
Q_PVT_to_directload_W, \
Q_PVT_to_storage_W, \
Q_SC_ET_to_directload_W, \
Q_SC_ET_to_storage_W, \
Q_SC_FP_to_directload_W, \
Q_SC_FP_to_storage_W = SPH_fn.Storage_Operator(Q_PVT_gen_W, Q_SC_ET_gen_W, Q_SC_FP_gen_W, Q_Server_gen_W,
Q_network_demand_W, T_storage_old_K, T_DH_sup_K, T_amb_K[HOUR],
Q_in_storage_old_W, T_DH_return_K, mdot_DH_kgpers,
STORAGE_SIZE_m3,
master_to_slave_vars, P_HP_max_W, T_ground_K[HOUR])
## Modify storage level according to temeprature
if Q_in_storage_new_W < 0.0001:
Q_in_storage_new_W = 0.0
# if storage temperature too high, no more charging possible - reject energy
if T_storage_new_K >= master_to_slave_vars.T_ST_MAX - 0.001:
Q_in_storage_new_W = min(Q_in_storage_old_W, Q_in_storage_new_W)
Q_to_storage_W = max(Q_in_storage_new_W - Q_in_storage_old_W, 0)
Q_rejected_final_W[HOUR] = Q_PVT_gen_W + \
Q_SC_ET_gen_W + \
Q_SC_FP_gen_W + \
Q_Server_gen_W \
- Q_to_storage_W
T_storage_new_K = min(T_storage_old_K, T_storage_new_K)
E_aux_ch_W = 0
## Overwrite values for the calculation in the next timestep
Q_in_storage_old_W = Q_in_storage_new_W
T_storage_old_K = T_storage_new_K
# catch an error if the storage temperature is too low
# if T_storage_old_K < T_amb_K[HOUR] - 1:
# # print "Storage temperature is too lower than ambient, please check the calculation"
## Save values for the current timestep
Q_storage_content_final_Whr[HOUR] = Q_in_storage_new_W
T_storage_final_Khr[HOUR] = T_storage_new_K
Q_from_storage_final_Whr[HOUR] = Q_from_storage_req_W
Q_to_storage_final_Whr[HOUR] = Q_to_storage_W
E_aux_ch_final_Whr[HOUR] = E_aux_ch_W
E_aux_dech_final_Whr[HOUR] = E_aux_dech_W
# scale to the fraction taht goes directly to the grid. the rest is considered in the storage charging and discharging
E_HPSC_FP_final_req_Whr[HOUR] = E_HPSC_FP_req_W
E_HPSC_ET_final_req_Whr[HOUR] = E_HPSC_ET_req_W
E_HPPVT_final_req_Whr[HOUR] = E_HPPVT_reg_W
E_HPServer_final_req_Whr[HOUR] = E_HPServer_reg_W
Q_PVT_to_directload_Whr[HOUR] = Q_PVT_to_directload_W
Q_SC_ET_to_directload_Whr[HOUR] = Q_SC_ET_to_directload_W
Q_SC_FP_to_directload_Whr[HOUR] = Q_SC_FP_to_directload_W
Q_server_to_directload_Whr[HOUR] = Q_server_to_directload_W
Q_PVT_to_storage_Whr[HOUR] = Q_PVT_to_storage_W
Q_SC_ET_to_storage_Whr[HOUR] = Q_SC_ET_to_storage_W
Q_SC_FP_to_storage_Whr[HOUR] = Q_SC_FP_to_storage_W
Q_server_to_storage_Whr[HOUR] = Q_server_to_storage_W
Q_HP_Server_Whr[HOUR] = Q_HP_Server_W
Q_HP_PVT_Whr[HOUR] = Q_HP_PVT_W
Q_HP_SC_ET_Whr[HOUR] = Q_HP_SC_ET_W
Q_HP_SC_FP_Whr[HOUR] = Q_HP_SC_FP_W
Q_loss_Whr[HOUR] = Q_loss_W
# heating demand satisfied directly from these technologies
Q_uncontrollable_final_Whr[HOUR] = Q_PVT_to_directload_W + \
Q_SC_ET_to_directload_W + \
Q_SC_FP_to_directload_W + \
Q_server_to_directload_W
# heating demand required from heating plant
Q_missing_final_Whr[
HOUR] = Q_network_demand_W - Q_uncontrollable_final_Whr[
HOUR] - Q_from_storage_final_Whr[HOUR]
# amount of heat required from heating plants
mdot_DH_final_kgpers[HOUR] = mdot_DH_missing_kgpers
if T_storage_new_K <= T_storage_min_K:
T_storage_min_K = T_storage_new_K
Q_disc_seasonstart_W[0] += Q_from_storage_req_W
Q_stored_max_W = np.amax(Q_storage_content_final_Whr)
T_st_max_K = np.amax(T_storage_final_Khr)
T_st_min_K = np.amin(T_storage_final_Khr)
Q_loss_tot_W = np.sum(Q_loss_Whr)
storage_dispatch = {
# TOTAL ENERGY GENERATED
"Q_SC_ET_gen_W": Q_SC_ET_gen_Whr,
"Q_SC_FP_gen_W": Q_SC_FP_gen_Whr,
"Q_PVT_gen_W": Q_PVT_gen_Whr,
"Q_HP_Server_gen_W":
Q_server_to_storage_Whr + Q_server_to_directload_Whr,
# ENERGY GOING DIRECTLY TO CUSTOMERS
"Q_PVT_gen_directload_W": Q_PVT_to_directload_Whr,
"Q_SC_ET_gen_directload_W": Q_SC_ET_to_directload_Whr,
"Q_SC_FP_gen_directload_W": Q_SC_FP_to_directload_Whr,
"Q_HP_Server_gen_directload_W": Q_server_to_directload_Whr,
# ENERGY GOING INTO THE STORAGE
# total
"Q_Storage_req_W": Q_to_storage_final_Whr,
# per technology
"Q_PVT_gen_storage_W": Q_PVT_to_storage_Whr,
"Q_SC_ET_gen_storage_W": Q_SC_ET_to_storage_Whr,
"Q_SC_FP_gen_storage_W": Q_SC_FP_to_storage_Whr,
"Q_HP_Server_gen_storage_W": Q_server_to_storage_Whr,
# ENERGY COMMING FROM THE STORAGE
"Q_Storage_gen_W": Q_from_storage_final_Whr,
# AUXILIARY LOADS NEEDED TO CHARGE/DISCHARGE THE STORAGE
"E_Storage_charging_req_W": E_aux_ch_final_Whr,
"E_Storage_discharging_req_W": E_aux_dech_final_Whr,
"E_HP_SC_FP_req_W":
E_HPSC_FP_final_req_Whr, # this is included in charging the storage
"E_HP_SC_ET_req_W":
E_HPSC_ET_final_req_Whr, # this is included in charging the storage
"E_HP_PVT_req_W":
E_HPPVT_final_req_Whr, # this is included in charging the storage
"E_HP_Server_req_W":
E_HPServer_final_req_Whr, # this is included in charging the storage
# ENERGY THAT NEEDS TO BE SUPPLIED (NEXT)
"Q_req_after_storage_W": Q_missing_final_Whr,
# mass flow rate of the network, size and energy generated
"mdot_DH_fin_kgpers": mdot_DH_final_kgpers,
"E_PVT_gen_W":
E_PVT_gen_Whr, # useful later on for the electricity dispatch curve
"Storage_Size_m3": STORAGE_SIZE_m3,
"Q_storage_content_W": Q_storage_content_final_Whr,
"Q_storage_max_W": Q_stored_max_W,
"Q_DH_networkload_W": Q_DH_networkload_Wh,
# this helps to know the peak (thermal) of the heatpumps
"Q_HP_Server_W": Q_HP_PVT_Whr,
"Q_HP_PVT_W": Q_HP_PVT_Whr,
"Q_HP_SC_ET_W": Q_HP_SC_ET_Whr,
"Q_HP_SC_FP_W": Q_HP_SC_FP_Whr,
}
return (Q_stored_max_W, Q_rejected_final_W, Q_disc_seasonstart_W,
T_st_max_K, T_st_min_K, Q_storage_content_final_Whr,
T_storage_final_Khr, Q_loss_tot_W, mdot_DH_final_kgpers,
Q_uncontrollable_final_Whr), storage_dispatch
def preproccessing(locator, total_demand, building_names, weather_file, gv):
"""
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
:param gv: path to global variables class
:type locator: class
:type total_demand: list
:type building_names: list
:type weather_file: string
:type gv: class
: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
"""
# GET ENERGY POTENTIALS
# geothermal
T_ambient = epwreader.epw_reader(weather_file)['drybulb_C']
gv.ground_temperature = geothermal.calc_ground_temperature(
T_ambient.values, gv)
# solar
print "Solar features extraction"
solar_features = SolarFeatures(locator)
# GET LOADS IN SUBSTATIONS
# prepocess space heating, domestic hot water and space cooling to substation.
print "Run substation model for each building separately"
substation.substation_main(
locator, total_demand, building_names, gv,
Flag=True) # True if disconected buildings are calculated
# GET COMPETITIVE ALTERNATIVES TO A NETWORK
# estimate what would be the operation of single buildings only for heating.
# For cooling all buildings are assumed to be connected to the cooling distribution on site.
print "Run decentralized model for buildings"
#decentralized_buildings.decentralized_main(locator, building_names, gv)
# GET DH NETWORK
# at first estimate a distribution with all the buildings connected at it.
print "Create distribution file with all buildings connected"
summarize_network.network_main(locator, total_demand, building_names, gv,
"all") #"_all" key for all buildings
# GET EXTRAS
# estimate the extra costs, emissions and primary energy of electricity.
print "electricity"
elecCosts, elecCO2, elecPrim = electricity.calc_pareto_electricity(
locator, gv)
# estimate the extra costs, emissions and primary energy for process heat
print "Process-heat"
hpCosts, hpCO2, hpPrim = process_heat.calc_pareto_Qhp(
locator, total_demand, gv)
extraCosts = elecCosts + hpCosts
extraCO2 = elecCO2 + hpCO2
extraPrim = elecPrim + hpPrim
return extraCosts, extraCO2, extraPrim, solar_features
def Storage_Design(CSV_NAME, SOLCOL_TYPE, T_storage_old_K, Q_in_storage_old_W, locator,
STORAGE_SIZE_m3, STORE_DATA, master_to_slave_vars, P_HP_max_W, config):
"""
:param CSV_NAME:
:param SOLCOL_TYPE:
:param T_storage_old_K:
:param Q_in_storage_old_W:
:param locator:
:param STORAGE_SIZE_m3:
:param STORE_DATA:
:param master_to_slave_vars:
:param P_HP_max_W:
:param gV:
:type CSV_NAME:
:type SOLCOL_TYPE:
:type T_storage_old_K:
:type Q_in_storage_old_W:
:type locator:
:type STORAGE_SIZE_m3:
:type STORE_DATA:
:type master_to_slave_vars:
:type P_HP_max_W:
:type gV:
:return:
:rtype:
"""
# Import Network Data
Network_Data = pd.read_csv(locator.get_optimization_network_data_folder(CSV_NAME))
# recover Network Data:
mdot_heat_netw_total_kgpers = Network_Data['mdot_DH_netw_total_kgpers'].values
Q_DH_networkload_W = Network_Data['Q_DHNf_W'].values
T_DH_return_array_K = Network_Data['T_DHNf_re_K'].values
T_DH_supply_array_K = Network_Data['T_DHNf_sup_K'].values
Q_wasteheatServer_kWh = Network_Data['Qcdata_netw_total_kWh'].values
Solar_Data_SC = np.zeros((8760, 7))
Solar_Data_PVT = np.zeros((8760, 7))
Solar_Data_PV = np.zeros((8760, 7))
Solar_Tscr_th_SC_K = Solar_Data_SC[:,6]
Solar_E_aux_SC_req_kWh = Solar_Data_SC[:,1]
Solar_Q_th_SC_kWh = Solar_Data_SC[:,1]
Solar_Tscr_th_PVT_K = Solar_Data_PVT[:,6]
Solar_E_aux_PVT_kW = Solar_Data_PVT[:,1]
Solar_Q_th_SC_kWh = Solar_Data_PVT[:,2]
PVT_kWh = Solar_Data_PVT[:,5]
Solar_E_aux_PV_kWh = Solar_Data_PV[:,1]
PV_kWh = Solar_Data_PV[:,5]
# Import Solar Data
os.chdir(locator.get_potentials_solar_folder())
fNameArray = [master_to_slave_vars.SOLCOL_TYPE_PVT, master_to_slave_vars.SOLCOL_TYPE_SC_ET, master_to_slave_vars.SOLCOL_TYPE_SC_FP, master_to_slave_vars.SOLCOL_TYPE_PV]
#LOOP AROUND ALL SC TYPES
for solartype in range(4):
fName = fNameArray[solartype]
if master_to_slave_vars.SOLCOL_TYPE_SC_ET != "NONE" and fName == master_to_slave_vars.SOLCOL_TYPE_SC_ET:
Solar_Area_SC_ET_m2, Solar_E_aux_SC_ET_req_kWh, Solar_Q_th_SC_ET_kWh, Solar_Tscs_th_SC_ET, Solar_mcp_SC_ET_kWperC, SC_ET_kWh, Solar_Tscr_th_SC_ET_K\
= fn.import_solar_data(master_to_slave_vars.SOLCOL_TYPE_SC_ET)
if master_to_slave_vars.SOLCOL_TYPE_SC_FP != "NONE" and fName == master_to_slave_vars.SOLCOL_TYPE_SC_FP:
Solar_Area_SC_FP_m2, Solar_E_aux_SC_FP_req_kWh, Solar_Q_th_SC_FP_kWh, Solar_Tscs_th_SC_FP, Solar_mcp_SC_FP_kWperC, SC_FP_kWh, Solar_Tscr_th_SC_FP_K \
= fn.import_solar_data(master_to_slave_vars.SOLCOL_TYPE_SC_FP)
if master_to_slave_vars.SOLCOL_TYPE_PVT != "NONE" and fName == master_to_slave_vars.SOLCOL_TYPE_PVT:
Solar_Area_PVT_m2, Solar_E_aux_PVT_kW, Solar_Q_th_PVT_kW, Solar_Tscs_th_PVT, Solar_mcp_PVT_kWperC, PVT_kWh, Solar_Tscr_th_PVT_K \
= fn.import_solar_data(master_to_slave_vars.SOLCOL_TYPE_PVT)
if master_to_slave_vars.SOLCOL_TYPE_PV != "NONE" and fName == master_to_slave_vars.SOLCOL_TYPE_PV:
Solar_Area_PV_m2, Solar_E_aux_PV_kWh, Solar_Q_th_PV_kW, Solar_Tscs_th_PV, Solar_mcp_PV_kWperC, PV_kWh, Solar_Tscr_th_PV_K\
= fn.import_solar_data(master_to_slave_vars.SOLCOL_TYPE_PV)
# Recover Solar Data
Solar_E_aux_W = np.ravel(Solar_E_aux_SC_ET_req_kWh * 1000 * master_to_slave_vars.SOLAR_PART_SC_ET) + np.ravel(Solar_E_aux_SC_FP_req_kWh * 1000 * master_to_slave_vars.SOLAR_PART_SC_FP)\
+ np.ravel(Solar_E_aux_PVT_kW * 1000 * master_to_slave_vars.SOLAR_PART_PVT) + np.ravel(Solar_E_aux_PV_kWh * 1000 * master_to_slave_vars.SOLAR_PART_PV)
Q_SC_ET_gen_Wh = Solar_Q_th_SC_ET_kWh * 1000 * master_to_slave_vars.SOLAR_PART_SC_ET
Q_SC_FP_gen_Wh = Solar_Q_th_SC_FP_kWh * 1000 * master_to_slave_vars.SOLAR_PART_SC_FP
Q_PVT_gen_Wh = Solar_Q_th_PVT_kW * 1000 * master_to_slave_vars.SOLAR_PART_PVT
Q_SCandPVT_gen_Wh = np.zeros(8760)
weather_data = epwreader.epw_reader(config.weather)[['year', 'drybulb_C', 'wetbulb_C','relhum_percent',
'windspd_ms', 'skytemp_C']]
ground_temp = calc_ground_temperature(locator, config, weather_data['drybulb_C'], depth_m=10)
for hour in range(len(Q_SCandPVT_gen_Wh)):
Q_SCandPVT_gen_Wh[hour] = Q_SC_ET_gen_Wh[hour] + Q_SC_FP_gen_Wh[hour] + Q_PVT_gen_Wh[hour]
E_PV_Wh = PV_kWh * 1000 * master_to_slave_vars.SOLAR_PART_PV
E_PVT_Wh = PVT_kWh * 1000 * master_to_slave_vars.SOLAR_PART_PVT
HOUR = 0
Q_to_storage_avail_W = np.zeros(8760)
Q_from_storage_W = np.zeros(8760)
to_storage = np.zeros(8760)
Q_storage_content_fin_W = np.zeros(8760)
Q_server_to_directload_W = np.zeros(8760)
Q_server_to_storage_W = np.zeros(8760)
Q_compair_to_directload_W = np.zeros(8760)
Q_compair_to_storage_W = np.zeros(8760)
Q_PVT_to_directload_W = np.zeros(8760)
Q_PVT_to_storage_W = np.zeros(8760)
Q_SC_ET_to_directload_W = np.zeros(8760)
Q_SC_ET_to_storage_W = np.zeros(8760)
Q_SC_FP_to_directload_W = np.zeros(8760)
Q_SC_FP_to_storage_W = np.zeros(8760)
T_storage_fin_K = np.zeros(8760)
Q_from_storage_fin_W = np.zeros(8760)
Q_to_storage_fin_W = np.zeros(8760)
E_aux_ch_fin_W = np.zeros(8760)
E_aux_dech_fin_W = np.zeros(8760)
#E_PV_Wh_fin = np.zeros(8760)
E_aux_solar_W = np.zeros(8760)
Q_missing_fin_W = np.zeros(8760)
Q_from_storage_used_fin_W = np.zeros(8760)
Q_rejected_fin_W = np.zeros(8760)
mdot_DH_fin_kgpers = np.zeros(8760)
Q_uncontrollable_fin_Wh = np.zeros(8760)
E_aux_solar_and_heat_recovery_Wh = np.zeros(8760)
HPServerHeatDesignArray_kWh = np.zeros(8760)
HPpvt_designArray_Wh = np.zeros(8760)
HPCompAirDesignArray_kWh = np.zeros(8760)
HPScDesignArray_Wh = np.zeros(8760)
T_amb_K = 10 + 273.0 # K
T_storage_min_K = master_to_slave_vars.T_ST_MAX
Q_disc_seasonstart_W = [0]
Q_loss_tot_W = 0
while HOUR < 8760:
# Store later on this data
HPServerHeatDesign_kWh = 0
HPpvt_design_Wh = 0
HPCompAirDesign_kWh = 0
HPScDesign_Wh = 0
T_DH_sup_K = T_DH_supply_array_K[HOUR]
T_DH_return_K = T_DH_return_array_K[HOUR]
mdot_DH_kgpers = mdot_heat_netw_total_kgpers[HOUR]
if master_to_slave_vars.WasteServersHeatRecovery == 1:
Q_server_gen_kW = Q_wasteheatServer_kWh[HOUR]
else:
Q_server_gen_kW = 0
# if MS_Var.WasteCompressorHeatRecovery == 1:
# Q_compair_gen_kW= Q_wasteheatCompAir_kWh[HOUR]
# else:
# Q_compair_gen_kW = 0
Q_SC_ET_gen_W = Q_SC_ET_gen_Wh[HOUR]
Q_SC_FP_gen_W = Q_SC_FP_gen_Wh[HOUR]
Q_PVT_gen_W = Q_PVT_gen_Wh[HOUR]
# check if each source needs a heat-pump, calculate the final energy
if T_DH_sup_K > T_EL_TO_HEAT_SUP - DT_HEAT: #and checkpoint_ElToHeat == 1:
#use a heat pump to bring it to distribution temp
COP_th = T_DH_sup_K / (T_DH_sup_K - (T_EL_TO_HEAT_SUP - DT_HEAT))
COP = HP_ETA_EX * COP_th
E_aux_Server_kWh = Q_server_gen_kW * (1/COP) # assuming the losses occur after the heat pump
if E_aux_Server_kWh > 0:
HPServerHeatDesign_kWh = Q_server_gen_kW
Q_server_gen_kW += E_aux_Server_kWh
else:
E_aux_Server_kWh = 0.0
# if T_DH_sup_K > T_FROM_SERVER - DT_HEAT:# and checkpoint_QfromServer == 1:
# #use a heat pump to bring it to distribution temp
# COP_th = T_DH_sup_K / (T_DH_sup_K - (T_FROM_SERVER - DT_HEAT))
# COP = HP_ETA_EX * COP_th
# E_aux_CAH_kWh = Q_compair_gen_kW * (1/COP) # assuming the losses occur after the heat pump
# if E_aux_Server_kWh > 0:
# HPCompAirDesign_kWh = Q_compair_gen_kW
# Q_compair_gen_kW += E_aux_CAH_kWh
# else:
# E_aux_CAH_kWh = 0.0
#eliminating compressed air of the code
E_aux_CAH_kWh = 0
Q_compair_gen_kW = 0
if T_DH_sup_K > Solar_Tscr_th_PVT_K[HOUR] - DT_HEAT:# and checkpoint_PVT == 1:
#use a heat pump to bring it to distribution temp
COP_th = T_DH_sup_K / (T_DH_sup_K - (Solar_Tscr_th_PVT_K[HOUR] - DT_HEAT))
COP = HP_ETA_EX * COP_th
E_aux_PVT_Wh = Q_PVT_gen_W * (1/COP) # assuming the losses occur after the heat pump
if E_aux_PVT_Wh > 0:
HPpvt_design_Wh = Q_PVT_gen_W
Q_PVT_gen_W += E_aux_PVT_Wh
else:
E_aux_PVT_Wh = 0.0
if T_DH_sup_K > Solar_Tscr_th_SC_ET_K[HOUR] - DT_HEAT:# and checkpoint_SC == 1:
#use a heat pump to bring it to distribution temp
COP_th = T_DH_sup_K / (T_DH_sup_K - (Solar_Tscr_th_SC_ET_K[HOUR] - DT_HEAT))
COP = HP_ETA_EX * COP_th
E_aux_SC_ET_Wh = Q_SC_ET_gen_W * (1/COP) # assuming the losses occur after the heat pump
if E_aux_SC_ET_Wh > 0:
HPScDesign_Wh = Q_SC_ET_gen_W
Q_SC_ET_gen_W += E_aux_SC_ET_Wh
else:
E_aux_SC_ET_Wh = 0.0
if T_DH_sup_K > Solar_Tscr_th_SC_FP_K[HOUR] - DT_HEAT:# and checkpoint_SC == 1:
#use a heat pump to bring it to distribution temp
COP_th = T_DH_sup_K / (T_DH_sup_K - (Solar_Tscr_th_SC_FP_K[HOUR] - DT_HEAT))
COP = HP_ETA_EX * COP_th
E_aux_SC_FP_Wh = Q_SC_FP_gen_W * (1/COP) # assuming the losses occur after the heat pump
if E_aux_SC_FP_Wh > 0:
HPScDesign_Wh = Q_SC_FP_gen_W
Q_SC_FP_gen_W += E_aux_SC_FP_Wh
else:
E_aux_SC_FP_Wh = 0.0
HPServerHeatDesignArray_kWh[HOUR] = HPServerHeatDesign_kWh
HPpvt_designArray_Wh[HOUR] = HPpvt_design_Wh
HPCompAirDesignArray_kWh[HOUR] = HPCompAirDesign_kWh
HPScDesignArray_Wh[HOUR] = HPScDesign_Wh
E_aux_HP_uncontrollable_Wh = float(E_aux_SC_FP_Wh + E_aux_SC_ET_Wh + E_aux_PVT_Wh + E_aux_CAH_kWh + E_aux_Server_kWh)
# Heat Recovery has some losses, these are taken into account as "overall Losses", i.e.: from Source to DH Pipe
# hhhhhhhhhhhhhh GET VALUES
Q_server_gen_W = Q_server_gen_kW * ETA_SERVER_TO_HEAT * 1000 # converting to W
Q_compair_gen_W = Q_compair_gen_kW * ETA_EL_TO_HEAT * 1000
Q_network_demand_W = Q_DH_networkload_W[HOUR]
Storage_Data = SPH_fn.Storage_Operator(Q_PVT_gen_W, Q_SC_ET_gen_W, Q_SC_FP_gen_W, Q_server_gen_W, Q_compair_gen_W, Q_network_demand_W, T_storage_old_K, T_DH_sup_K, T_amb_K, \
Q_in_storage_old_W, T_DH_return_K, mdot_DH_kgpers, STORAGE_SIZE_m3, master_to_slave_vars, P_HP_max_W, ground_temp[HOUR])
Q_in_storage_new_W = Storage_Data[0]
T_storage_new_K = Storage_Data[1]
Q_to_storage_final_W = Storage_Data[3]
Q_from_storage_req_final_W = Storage_Data[2]
E_aux_ch_W = Storage_Data[4]
E_aux_dech_W = Storage_Data[5]
Q_missing_W = Storage_Data[6]
Q_from_storage_used_fin_W[HOUR] = Storage_Data[7]
Q_loss_tot_W += Storage_Data[8]
mdot_DH_afterSto_kgpers = Storage_Data[9]
Q_server_to_directload_W[HOUR] = Storage_Data[10]
Q_server_to_storage_W[HOUR] = Storage_Data[11]
Q_compair_to_directload_W[HOUR] = Storage_Data[12]
Q_compair_to_storage_W[HOUR] = Storage_Data[13]
Q_PVT_to_directload_W[HOUR] = Storage_Data[14]
Q_PVT_to_storage_W[HOUR] = Storage_Data[15]
Q_SC_ET_to_directload_W[HOUR] = Storage_Data[16]
Q_SC_ET_to_storage_W[HOUR] = Storage_Data[17]
Q_SC_FP_to_directload_W[HOUR] = Storage_Data[18]
Q_SC_FP_to_storage_W[HOUR] = Storage_Data[19]
if Q_in_storage_new_W < 0.0001:
Q_in_storage_new_W = 0
if T_storage_new_K >= master_to_slave_vars.T_ST_MAX-0.001: # no more charging possible - reject energy
Q_in_storage_new_W = min(Q_in_storage_old_W, Storage_Data[0])
Q_to_storage_final_W = max(Q_in_storage_new_W - Q_in_storage_old_W, 0)
Q_rejected_fin_W[HOUR] = Q_PVT_gen_W + Q_SC_ET_gen_W + Q_SC_FP_gen_W + Q_compair_gen_W + Q_server_gen_W - Storage_Data[3]
T_storage_new_K = min(T_storage_old_K, T_storage_new_K)
E_aux_ch_W = 0
Q_storage_content_fin_W[HOUR] = Q_in_storage_new_W
Q_in_storage_old_W = Q_in_storage_new_W
T_storage_fin_K[HOUR] = T_storage_new_K
T_storage_old_K = T_storage_new_K
if T_storage_old_K < T_amb_K-1: # chatch an error if the storage temperature is too low
# print "ERROR!"
break
Q_from_storage_fin_W[HOUR] = Q_from_storage_req_final_W
Q_to_storage_fin_W[HOUR] = Q_to_storage_final_W
E_aux_ch_fin_W[HOUR] = E_aux_ch_W
E_aux_dech_fin_W[HOUR] = E_aux_dech_W
E_aux_solar_W[HOUR] = Solar_E_aux_W[HOUR]
Q_uncontrollable_fin_Wh[HOUR] = Q_PVT_to_directload_W[HOUR] + Q_SC_ET_to_directload_W[HOUR] + Q_SC_FP_to_directload_W[HOUR] + Q_compair_to_directload_W[HOUR] + Q_server_to_directload_W[HOUR]
Q_missing_fin_W[HOUR] = Q_network_demand_W - Q_uncontrollable_fin_Wh[HOUR] - Q_from_storage_used_fin_W[HOUR]
E_aux_solar_and_heat_recovery_Wh[HOUR] = float(E_aux_HP_uncontrollable_Wh)
mdot_DH_fin_kgpers[HOUR] = mdot_DH_afterSto_kgpers
# Q_from_storage_fin_W[HOUR] = Q_DH_networkload_W[HOUR] - Q_missing_W
if T_storage_new_K <= T_storage_min_K:
T_storage_min_K = T_storage_new_K
Q_disc_seasonstart_W[0] += Q_from_storage_req_final_W
HOUR += 1
""" STORE DATA """
E_aux_solar_and_heat_recovery_flat_Wh = E_aux_solar_and_heat_recovery_Wh.flatten()
# Calculate imported and exported Electricity Arrays:
E_produced_total_W = np.zeros(8760)
E_consumed_for_storage_solar_and_heat_recovery_W = np.zeros(8760)
for hour in range(8760):
E_produced_total_W[hour] = E_PV_Wh[hour] + E_PVT_Wh[hour]
E_consumed_for_storage_solar_and_heat_recovery_W[hour] = E_aux_ch_fin_W[hour] + E_aux_dech_fin_W[hour] + E_aux_solar_and_heat_recovery_Wh[hour]
if STORE_DATA == "yes":
date = Network_Data.DATE.values
results = pd.DataFrame(
{"DATE": date,
"Q_storage_content_W":Q_storage_content_fin_W,
"Q_DH_networkload_W":Q_DH_networkload_W,
"Q_uncontrollable_hot_W":Q_uncontrollable_fin_Wh,
"Q_to_storage_W":Q_to_storage_fin_W,
"Q_from_storage_used_W":Q_from_storage_used_fin_W,
"Q_server_to_directload_W":Q_server_to_directload_W,
"Q_server_to_storage_W":Q_server_to_storage_W,
"Q_compair_to_directload_W":Q_compair_to_directload_W,
"Q_compair_to_storage_W":Q_compair_to_storage_W,
"Q_PVT_to_directload_W":Q_PVT_to_directload_W,
"Q_PVT_to_storage_W": Q_PVT_to_storage_W,
"Q_SC_ET_to_directload_W":Q_SC_ET_to_directload_W,
"Q_SC_ET_to_storage_W":Q_SC_ET_to_storage_W,
"Q_SC_FP_to_directload_W": Q_SC_FP_to_directload_W,
"Q_SC_FP_to_storage_W": Q_SC_FP_to_storage_W,
"E_aux_ch_W":E_aux_ch_fin_W,
"E_aux_dech_W":E_aux_dech_fin_W,
"Q_missing_W":Q_missing_fin_W,
"mdot_DH_fin_kgpers":mdot_DH_fin_kgpers,
"E_aux_solar_and_heat_recovery_Wh": E_aux_solar_and_heat_recovery_Wh,
"E_consumed_for_storage_solar_and_heat_recovery_W": E_consumed_for_storage_solar_and_heat_recovery_W,
"E_PV_Wh":E_PV_Wh,
"E_PVT_Wh":E_PVT_Wh,
"E_produced_from_solar_W": E_produced_total_W,
"Storage_Size_m3":STORAGE_SIZE_m3,
"Q_SC_ET_gen_Wh":Q_SC_ET_gen_Wh,
"Q_SC_FP_gen_Wh": Q_SC_FP_gen_Wh,
"Q_PVT_gen_Wh": Q_PVT_gen_Wh,
"HPServerHeatDesignArray_kWh":HPServerHeatDesignArray_kWh,
"HPpvt_designArray_Wh":HPpvt_designArray_Wh,
"HPCompAirDesignArray_kWh":HPCompAirDesignArray_kWh,
"HPScDesignArray_Wh":HPScDesignArray_Wh,
"Q_rejected_fin_W":Q_rejected_fin_W,
"P_HPCharge_max_W":P_HP_max_W
})
storage_operation_data_path = locator.get_optimization_slave_storage_operation_data(master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
results.to_csv(storage_operation_data_path, index=False)
Q_stored_max_W = np.amax(Q_storage_content_fin_W)
T_st_max_K = np.amax(T_storage_fin_K)
T_st_min_K = np.amin(T_storage_fin_K)
return Q_stored_max_W, Q_rejected_fin_W, Q_disc_seasonstart_W, T_st_max_K, T_st_min_K, Q_storage_content_fin_W, T_storage_fin_K, \
Q_loss_tot_W, mdot_DH_fin_kgpers, Q_uncontrollable_fin_Wh
def disconnected_buildings_heating_main(locator, 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_disconnected_folder
:rtype: Nonetype
"""
t0 = time.clock()
prop_geometry = Gdf.from_file(locator.get_zone_geometry())
restrictions = Gdf.from_file(locator.get_building_restrictions())
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').merge(restrictions,
on='Name')
geothermal_potential_data['Area_geo'] = (
1 - geothermal_potential_data['GEOTHERMAL']
) * geothermal_potential_data['Area']
weather_data = epwreader.epw_reader(config.weather)[[
'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms',
'skytemp_C'
]]
ground_temp = calc_ground_temperature(locator,
weather_data['drybulb_C'],
depth_m=10)
BestData = {}
total_demand = pd.read_csv(locator.get_total_demand())
def calc_new_load(mdot, TsupDH, Tret):
"""
This function calculates the load distribution side of the district heating distribution.
:param mdot: mass flow
:param TsupDH: supply temeperature
:param Tret: return temperature
:param gv: global variables class
:type mdot: float
:type TsupDH: float
:type Tret: float
:type gv: class
:return: Qload: load of the distribution
:rtype: float
"""
Qload = mdot * HEAT_CAPACITY_OF_WATER_JPERKGK * (TsupDH - Tret) * (
1 + Q_LOSS_DISCONNECTED)
if Qload < 0:
Qload = 0
return Qload
for building_name in building_names:
print building_name
substation.substation_main(locator,
total_demand,
building_names=[building_name],
heating_configuration=7,
cooling_configuration=7,
Flag=False)
loads = pd.read_csv(
locator.get_optimization_substations_results_file(building_name),
usecols=[
"T_supply_DH_result_K", "T_return_DH_result_K",
"mdot_DH_result_kgpers"
])
Qload = np.vectorize(calc_new_load)(loads["mdot_DH_result_kgpers"],
loads["T_supply_DH_result_K"],
loads["T_return_DH_result_K"])
Qannual = Qload.sum()
Qnom = Qload.max() * (1 + SIZING_MARGIN
) # 1% reliability margin on installed capacity
# Create empty matrices
result = np.zeros((13, 7))
result[0][0] = 1
result[1][1] = 1
result[2][2] = 1
InvCosts = np.zeros((13, 1))
resourcesRes = np.zeros((13, 4))
QannualB_GHP = np.zeros(
(10, 1)) # For the investment costs of the boiler used with GHP
Wel_GHP = np.zeros((10, 1)) # For the investment costs of the GHP
# Supply with the Boiler / FC / GHP
Tret = loads["T_return_DH_result_K"].values
TsupDH = loads["T_supply_DH_result_K"].values
mdot = loads["mdot_DH_result_kgpers"].values
for hour in range(8760):
if Tret[hour] == 0:
Tret[hour] = TsupDH[hour]
# Boiler NG
BoilerEff = Boiler.calc_Cop_boiler(Qload[hour], Qnom, Tret[hour])
Qgas = Qload[hour] / BoilerEff
result[0][4] += prices.NG_PRICE * Qgas # CHF
result[0][
5] += lca.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[0][
6] += lca.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
resourcesRes[0][0] += Qload[hour]
if DISC_BIOGAS_FLAG == 1:
result[0][4] += prices.BG_PRICE * Qgas # CHF
result[0][
5] += lca.BG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[0][
6] += lca.BG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
# Boiler BG
result[1][4] += prices.BG_PRICE * Qgas # CHF
result[1][
5] += lca.BG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[1][
6] += lca.BG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
resourcesRes[1][1] += Qload[hour]
# FC
(FC_Effel, FC_Effth) = FC.calc_eta_FC(Qload[hour], Qnom, 1, "B")
Qgas = Qload[hour] / (FC_Effth + FC_Effel)
Qelec = Qgas * FC_Effel
result[2][
4] += prices.NG_PRICE * Qgas - lca.ELEC_PRICE * Qelec # CHF, extra electricity sold to grid
result[2][
5] += 0.0874 * Qgas * 3600E-6 + 773 * 0.45 * Qelec * 1E-6 - lca.EL_TO_CO2 * Qelec * 3600E-6 # kgCO2
# Bloom box emissions within the FC: 773 lbs / MWh_el (and 1 lbs = 0.45 kg)
# http://www.carbonlighthouse.com/2011/09/16/bloom-box/
result[2][
6] += 1.51 * Qgas * 3600E-6 - lca.EL_TO_OIL_EQ * Qelec * 3600E-6 # MJ-oil-eq
resourcesRes[2][0] += Qload[hour]
resourcesRes[2][2] += Qelec
# GHP
for i in range(10):
QnomBoiler = i / 10 * Qnom
QnomGHP = Qnom - QnomBoiler
if Qload[hour] <= QnomGHP:
(wdot_el, qcolddot, qhotdot_missing,
tsup2) = HP.calc_Cop_GHP(ground_temp[hour], mdot[hour],
TsupDH[hour], Tret[hour])
if Wel_GHP[i][0] < wdot_el:
Wel_GHP[i][0] = wdot_el
result[3 + i][4] += lca.ELEC_PRICE * wdot_el # CHF
result[3 + i][
5] += lca.SMALL_GHP_TO_CO2_STD * wdot_el * 3600E-6 # kgCO2
result[3 + i][
6] += lca.SMALL_GHP_TO_OIL_STD * wdot_el * 3600E-6 # MJ-oil-eq
resourcesRes[3 + i][2] -= wdot_el
resourcesRes[3 + i][3] += Qload[hour] - qhotdot_missing
if qhotdot_missing > 0:
print "GHP unable to cover the whole demand, boiler activated!"
BoilerEff = Boiler.calc_Cop_boiler(
qhotdot_missing, QnomBoiler, tsup2)
Qgas = qhotdot_missing / BoilerEff
result[3 + i][4] += prices.NG_PRICE * Qgas # CHF
result[3 + i][
5] += lca.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3 + i][
6] += lca.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
QannualB_GHP[i][0] += qhotdot_missing
resourcesRes[3 + i][0] += qhotdot_missing
else:
# print "Boiler activated to compensate GHP", i
# if gv.DiscGHPFlag == 0:
# print QnomGHP
# QnomGHP = 0
# print "GHP not allowed 2, set QnomGHP to zero"
TexitGHP = QnomGHP / (
mdot[hour] *
HEAT_CAPACITY_OF_WATER_JPERKGK) + Tret[hour]
(wdot_el, qcolddot, qhotdot_missing,
tsup2) = HP.calc_Cop_GHP(ground_temp[hour], mdot[hour],
TexitGHP, Tret[hour])
if Wel_GHP[i][0] < wdot_el:
Wel_GHP[i][0] = wdot_el
result[3 + i][4] += lca.ELEC_PRICE * wdot_el # CHF
result[3 + i][
5] += lca.SMALL_GHP_TO_CO2_STD * wdot_el * 3600E-6 # kgCO2
result[3 + i][
6] += lca.SMALL_GHP_TO_OIL_STD * wdot_el * 3600E-6 # MJ-oil-eq
resourcesRes[3 + i][2] -= wdot_el
resourcesRes[3 + i][3] += QnomGHP - qhotdot_missing
if qhotdot_missing > 0:
print "GHP unable to cover the whole demand, boiler activated!"
BoilerEff = Boiler.calc_Cop_boiler(
qhotdot_missing, QnomBoiler, tsup2)
Qgas = qhotdot_missing / BoilerEff
result[3 + i][4] += prices.NG_PRICE * Qgas # CHF
result[3 + i][
5] += lca.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3 + i][
6] += lca.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
QannualB_GHP[i][0] += qhotdot_missing
resourcesRes[3 + i][0] += qhotdot_missing
QtoBoiler = Qload[hour] - QnomGHP
QannualB_GHP[i][0] += QtoBoiler
BoilerEff = Boiler.calc_Cop_boiler(QtoBoiler, QnomBoiler,
TexitGHP)
Qgas = QtoBoiler / BoilerEff
result[3 + i][4] += prices.NG_PRICE * Qgas # CHF
result[3 + i][
5] += lca.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3 + i][
6] += lca.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
resourcesRes[3 + i][0] += QtoBoiler
# Investment Costs / CO2 / Prim
Capex_a_Boiler, Opex_Boiler = Boiler.calc_Cinv_boiler(
Qnom, locator, config, 'BO1')
InvCosts[0][0] = Capex_a_Boiler + Opex_Boiler
InvCosts[1][0] = Capex_a_Boiler + Opex_Boiler
Capex_a_FC, Opex_FC = FC.calc_Cinv_FC(Qnom, locator, config)
InvCosts[2][0] = Capex_a_FC + Opex_FC
for i in range(10):
result[3 + i][0] = i / 10
result[3 + i][3] = 1 - i / 10
QnomBoiler = i / 10 * Qnom
Capex_a_Boiler, Opex_Boiler = Boiler.calc_Cinv_boiler(
QnomBoiler, locator, config, 'BO1')
InvCosts[3 + i][0] = Capex_a_Boiler + Opex_Boiler
Capex_a_GHP, Opex_GHP = HP.calc_Cinv_GHP(Wel_GHP[i][0], locator,
config)
InvCaGHP = Capex_a_GHP + Opex_GHP
InvCosts[3 + i][0] += InvCaGHP * prices.EURO_TO_CHF
# Best configuration
Best = np.zeros((13, 1))
indexBest = 0
TotalCosts = np.zeros((13, 2))
TotalCO2 = np.zeros((13, 2))
TotalPrim = np.zeros((13, 2))
for i in range(13):
TotalCosts[i][0] = TotalCO2[i][0] = TotalPrim[i][0] = i
TotalCosts[i][1] = InvCosts[i][0] + result[i][4]
TotalCO2[i][1] = result[i][5]
TotalPrim[i][1] = result[i][6]
CostsS = TotalCosts[np.argsort(TotalCosts[:, 1])]
CO2S = TotalCO2[np.argsort(TotalCO2[:, 1])]
PrimS = TotalPrim[np.argsort(TotalPrim[:, 1])]
el = len(CostsS)
rank = 0
Bestfound = False
optsearch = np.empty(el)
optsearch.fill(3)
indexBest = 0
geothermal_potential = geothermal_potential_data.set_index('Name')
# Check the GHP area constraint
for i in range(10):
QGHP = (1 - i / 10) * Qnom
areaAvail = geothermal_potential.ix[building_name, 'Area_geo']
Qallowed = np.ceil(areaAvail / GHP_A) * GHP_HMAX_SIZE # [W_th]
if Qallowed < QGHP:
optsearch[i + 3] += 1
Best[i + 3][0] = -1
while not Bestfound and rank < el:
optsearch[int(CostsS[rank][0])] -= 1
optsearch[int(CO2S[rank][0])] -= 1
optsearch[int(PrimS[rank][0])] -= 1
if np.count_nonzero(optsearch) != el:
Bestfound = True
indexBest = np.where(optsearch == 0)[0][0]
rank += 1
# get the best option according to the ranking.
Best[indexBest][0] = 1
Qnom_array = np.ones(len(Best[:, 0])) * Qnom
# Save results in csv file
dico = {}
dico["BoilerNG Share"] = result[:, 0]
dico["BoilerBG Share"] = result[:, 1]
dico["FC Share"] = result[:, 2]
dico["GHP Share"] = result[:, 3]
dico["Operation Costs [CHF]"] = result[:, 4]
dico["CO2 Emissions [kgCO2-eq]"] = result[:, 5]
dico["Primary Energy Needs [MJoil-eq]"] = result[:, 6]
dico["Annualized Investment Costs [CHF]"] = InvCosts[:, 0]
dico["Total Costs [CHF]"] = TotalCosts[:, 1]
dico["Best configuration"] = Best[:, 0]
dico["Nominal Power"] = Qnom_array
dico["QfromNG"] = resourcesRes[:, 0]
dico["QfromBG"] = resourcesRes[:, 1]
dico["EforGHP"] = resourcesRes[:, 2]
dico["QfromGHP"] = resourcesRes[:, 3]
results_to_csv = pd.DataFrame(dico)
fName_result = locator.get_optimization_disconnected_folder_building_result_heating(
building_name)
results_to_csv.to_csv(fName_result, sep=',')
BestComb = {}
BestComb["BoilerNG Share"] = result[indexBest, 0]
BestComb["BoilerBG Share"] = result[indexBest, 1]
BestComb["FC Share"] = result[indexBest, 2]
BestComb["GHP Share"] = result[indexBest, 3]
BestComb["Operation Costs [CHF]"] = result[indexBest, 4]
BestComb["CO2 Emissions [kgCO2-eq]"] = result[indexBest, 5]
BestComb["Primary Energy Needs [MJoil-eq]"] = result[indexBest, 6]
BestComb["Annualized Investment Costs [CHF]"] = InvCosts[indexBest, 0]
BestComb["Total Costs [CHF]"] = TotalCosts[indexBest, 1]
BestComb["Best configuration"] = Best[indexBest, 0]
BestComb["Nominal Power"] = Qnom
BestData[building_name] = BestComb
if 0:
fName = locator.get_optimization_disconnected_folder_disc_op_summary_heating(
)
results_to_csv = pd.DataFrame(BestData)
results_to_csv.to_csv(fName, sep=',')
print time.clock(
) - t0, "seconds process time for the Disconnected Building Routine \n"
def least_cost_main(locator, master_to_slave_vars, solar_features, gv, prices, lca, config):
"""
This function runs the least cost optimization code and returns cost, co2 and primary energy required. \
On the go, it saves the operation pattern
:param locator: locator class
:param master_to_slave_vars: class MastertoSlaveVars containing the value of variables to be passed to the
slave optimization for each individual
:param solar_features: solar features class
:param gv: global variables class
:type locator: class
:type master_to_slave_vars: class
:type solar_features: class
:type gv: class
:return:
- E_oil_eq_MJ: MJ oil Equivalent used during operation
- CO2_kg_eq: kg of CO2-Equivalent emitted during operation
- cost_sum: total cost in CHF used for operation
- Q_source_data[:,7]: uncovered demand
:rtype: float, float, float, array
"""
MS_Var = master_to_slave_vars
t = time.time()
# Import data from storage optimization
centralized_plant_data = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(MS_Var.individual_number,
MS_Var.generation_number))
Q_DH_networkload_W = np.array(centralized_plant_data['Q_DH_networkload_W'])
E_aux_ch_W = np.array(centralized_plant_data['E_aux_ch_W'])
E_aux_dech_W = np.array(centralized_plant_data['E_aux_dech_W'])
Q_missing_W = np.array(centralized_plant_data['Q_missing_W'])
Q_storage_content_W = np.array(centralized_plant_data['Q_storage_content_W'])
Q_to_storage_W = np.array(centralized_plant_data['Q_to_storage_W'])
Q_from_storage_W = np.array(centralized_plant_data['Q_from_storage_used_W'])
Q_uncontrollable_W = np.array(centralized_plant_data['Q_uncontrollable_hot_W'])
E_PV_gen_W = np.array(centralized_plant_data['E_PV_Wh'])
E_PVT_gen_W = np.array(centralized_plant_data['E_PVT_Wh'])
E_aux_solar_and_heat_recovery_W = np.array(centralized_plant_data['E_aux_solar_and_heat_recovery_Wh'])
Q_SC_ET_gen_Wh = np.array(centralized_plant_data['Q_SC_ET_gen_Wh'])
Q_SC_FP_gen_Wh = np.array(centralized_plant_data['Q_SC_FP_gen_Wh'])
Q_PVT_gen_Wh = np.array(centralized_plant_data['Q_PVT_gen_Wh'])
Q_SCandPVT_gen_Wh = Q_SC_ET_gen_Wh + Q_SC_FP_gen_Wh + Q_PVT_gen_Wh
E_produced_solar_W = np.array(centralized_plant_data['E_produced_from_solar_W'])
# Q_StorageToDHNpipe_sum = np.sum(E_aux_dech_W) + np.sum(Q_from_storage_W)
#
# HP_operation_Data_sum_array = np.sum(HPServerHeatDesignArray_kWh), \
# np.sum(HPpvt_designArray_Wh), \
# np.sum(HPCompAirDesignArray_kWh), \
# np.sum(HPScDesignArray_Wh)
Q_missing_copy_W = Q_missing_W.copy()
# Import Temperatures from Network Summary:
network_data = pd.read_csv(locator.get_optimization_network_data_folder(MS_Var.network_data_file_heating))
tdhret_K = network_data['T_DHNf_re_K']
mdot_DH_kgpers = network_data['mdot_DH_netw_total_kgpers']
tdhsup_K = network_data['T_DHNf_sup_K']
# import Marginal Cost of PP Data :
# os.chdir(Cost_Maps_Path)
# FIXED ORDER ACTIVATION STARTS
# Import Data - Sewage
if HP_SEW_ALLOWED == 1:
HPSew_Data = pd.read_csv(locator.get_sewage_heat_potential())
QcoldsewArray = np.array(HPSew_Data['Qsw_kW']) * 1E3
TretsewArray_K = np.array(HPSew_Data['ts_C']) + 273
# Initiation of the variables
Opex_var_HP_Sewage = []
Opex_var_HP_Lake = []
Opex_var_GHP = []
Opex_var_CHP = []
Opex_var_Furnace = []
Opex_var_BaseBoiler = []
Opex_var_PeakBoiler = []
source_HP_Sewage = []
source_HP_Lake = []
source_GHP = []
source_CHP = []
source_Furnace = []
source_BaseBoiler = []
source_PeakBoiler = []
Q_HPSew_gen_W = []
Q_HPLake_gen_W = []
Q_GHP_gen_W = []
Q_CHP_gen_W = []
Q_Furnace_gen_W = []
Q_BaseBoiler_gen_W = []
Q_PeakBoiler_gen_W = []
Q_uncovered_W = []
E_HPSew_req_W = []
E_HPLake_req_W = []
E_GHP_req_W = []
E_CHP_gen_W = []
E_Furnace_gen_W = []
E_BaseBoiler_req_W = []
E_PeakBoiler_req_W = []
E_gas_HPSew_W = []
E_gas_HPLake_W = []
E_gas_GHP_W = []
E_gas_CHP_W = []
E_gas_Furnace_W = []
E_gas_BaseBoiler_W = []
E_gas_PeakBoiler_W = []
E_wood_HPSew_W = []
E_wood_HPLake_W = []
E_wood_GHP_W = []
E_wood_CHP_W = []
E_wood_Furnace_W = []
E_wood_BaseBoiler_W = []
E_wood_PeakBoiler_W = []
E_coldsource_HPSew_W = []
E_coldsource_HPLake_W = []
E_coldsource_GHP_W = []
E_coldsource_CHP_W = []
E_coldsource_Furnace_W = []
E_coldsource_BaseBoiler_W = []
E_coldsource_PeakBoiler_W = []
Q_excess_W = np.zeros(8760)
weather_data = epwreader.epw_reader(config.weather)[['year', 'drybulb_C', 'wetbulb_C','relhum_percent',
'windspd_ms', 'skytemp_C']]
ground_temp = calc_ground_temperature(locator, weather_data['drybulb_C'], depth_m=10)
weather_data = epwreader.epw_reader(config.weather)[['year', 'drybulb_C', 'wetbulb_C',
'relhum_percent', 'windspd_ms', 'skytemp_C']]
ground_temp = calc_ground_temperature(locator, weather_data['drybulb_C'], depth_m=10)
for hour in range(8760):
Q_therm_req_W = Q_missing_W[hour]
# cost_data_centralPlant_op[hour, :], source_info[hour, :], Q_source_data_W[hour, :], E_coldsource_data_W[hour,
# :], \
# E_PP_el_data_W[hour, :], E_gas_data_W[hour, :], E_wood_data_W[hour, :], Q_excess_W[hour] = source_activator(
# Q_therm_req_W, hour, master_to_slave_vars, mdot_DH_kgpers[hour], tdhsup_K,
# tdhret_K[hour], TretsewArray_K[hour], gv, prices)
opex_output, source_output, Q_output, E_output, Gas_output, Wood_output, coldsource_output, Q_excess_W[
hour] = heating_source_activator(
Q_therm_req_W, hour, master_to_slave_vars, mdot_DH_kgpers[hour], tdhsup_K[hour],
tdhret_K[hour], TretsewArray_K[hour], gv, prices, lca, ground_temp[hour])
Opex_var_HP_Sewage.append(opex_output['Opex_var_HP_Sewage'])
Opex_var_HP_Lake.append(opex_output['Opex_var_HP_Lake'])
Opex_var_GHP.append(opex_output['Opex_var_GHP'])
Opex_var_CHP.append(opex_output['Opex_var_CHP'])
Opex_var_Furnace.append(opex_output['Opex_var_Furnace'])
Opex_var_BaseBoiler.append(opex_output['Opex_var_BaseBoiler'])
Opex_var_PeakBoiler.append(opex_output['Opex_var_PeakBoiler'])
source_HP_Sewage.append(source_output['HP_Sewage'])
source_HP_Lake.append(source_output['HP_Lake'])
source_GHP.append(source_output['GHP'])
source_CHP.append(source_output['CHP'])
source_Furnace.append(source_output['Furnace'])
source_BaseBoiler.append(source_output['BaseBoiler'])
source_PeakBoiler.append(source_output['PeakBoiler'])
Q_HPSew_gen_W.append(Q_output['Q_HPSew_gen_W'])
Q_HPLake_gen_W.append(Q_output['Q_HPLake_gen_W'])
Q_GHP_gen_W.append(Q_output['Q_GHP_gen_W'])
Q_CHP_gen_W.append(Q_output['Q_CHP_gen_W'])
Q_Furnace_gen_W.append(Q_output['Q_Furnace_gen_W'])
Q_BaseBoiler_gen_W.append(Q_output['Q_BaseBoiler_gen_W'])
Q_PeakBoiler_gen_W.append(Q_output['Q_PeakBoiler_gen_W'])
Q_uncovered_W.append(Q_output['Q_uncovered_W'])
E_HPSew_req_W.append(E_output['E_HPSew_req_W'])
E_HPLake_req_W.append(E_output['E_HPLake_req_W'])
E_GHP_req_W.append(E_output['E_GHP_req_W'])
E_CHP_gen_W.append(E_output['E_CHP_gen_W'])
E_Furnace_gen_W.append(E_output['E_Furnace_gen_W'])
E_BaseBoiler_req_W.append(E_output['E_BaseBoiler_req_W'])
E_PeakBoiler_req_W.append(E_output['E_PeakBoiler_req_W'])
E_gas_HPSew_W.append(Gas_output['E_gas_HPSew_W'])
E_gas_HPLake_W.append(Gas_output['E_gas_HPLake_W'])
E_gas_GHP_W.append(Gas_output['E_gas_GHP_W'])
E_gas_CHP_W.append(Gas_output['E_gas_CHP_W'])
E_gas_Furnace_W.append(Gas_output['E_gas_Furnace_W'])
E_gas_BaseBoiler_W.append(Gas_output['E_gas_BaseBoiler_W'])
E_gas_PeakBoiler_W.append(Gas_output['E_gas_PeakBoiler_W'])
E_wood_HPSew_W.append(Wood_output['E_wood_HPSew_W'])
E_wood_HPLake_W.append(Wood_output['E_wood_HPLake_W'])
E_wood_GHP_W.append(Wood_output['E_wood_GHP_W'])
E_wood_CHP_W.append(Wood_output['E_wood_CHP_W'])
E_wood_Furnace_W.append(Wood_output['E_wood_Furnace_W'])
E_wood_BaseBoiler_W.append(Wood_output['E_wood_BaseBoiler_W'])
E_wood_PeakBoiler_W.append(Wood_output['E_wood_PeakBoiler_W'])
E_coldsource_HPSew_W.append(coldsource_output['E_coldsource_HPSew_W'])
E_coldsource_HPLake_W.append(coldsource_output['E_coldsource_HPLake_W'])
E_coldsource_GHP_W.append(coldsource_output['E_coldsource_GHP_W'])
E_coldsource_CHP_W.append(coldsource_output['E_coldsource_CHP_W'])
E_coldsource_Furnace_W.append(coldsource_output['E_coldsource_Furnace_W'])
E_coldsource_BaseBoiler_W.append(coldsource_output['E_coldsource_BaseBoiler_W'])
E_coldsource_PeakBoiler_W.append(coldsource_output['E_coldsource_PeakBoiler_W'])
# save data
elapsed = time.time() - t
# sum up the uncovered demand, get average and peak load
Q_uncovered_design_W = np.amax(Q_uncovered_W)
Q_uncovered_annual_W = np.sum(Q_uncovered_W)
Opex_var_BackupBoiler = np.zeros(8760)
Q_BackupBoiler_W = np.zeros(8760)
E_aux_AddBoiler_req_W = []
Opex_var_Furnace_wet = np.zeros(8760)
Opex_var_Furnace_dry = np.zeros(8760)
Opex_var_CHP_NG = np.zeros(8760)
Opex_var_CHP_BG = np.zeros(8760)
Opex_var_BaseBoiler_NG = np.zeros(8760)
Opex_var_BaseBoiler_BG = np.zeros(8760)
Opex_var_PeakBoiler_NG = np.zeros(8760)
Opex_var_PeakBoiler_BG = np.zeros(8760)
Opex_var_BackupBoiler_NG = np.zeros(8760)
Opex_var_BackupBoiler_BG = np.zeros(8760)
Opex_var_PV = np.zeros(8760)
Opex_var_PVT = np.zeros(8760)
Opex_var_SC = np.zeros(8760)
if Q_uncovered_design_W != 0:
for hour in range(8760):
tdhret_req_K = tdhret_K[hour]
BoilerBackup_Cost_Data = cond_boiler_op_cost(Q_uncovered_W[hour], Q_uncovered_design_W, tdhret_req_K, \
master_to_slave_vars.BoilerBackupType,
master_to_slave_vars.EL_TYPE, gv, prices, lca)
Opex_var_BackupBoiler[hour], C_boil_per_WhBackup, Q_BackupBoiler_W[
hour], E_aux_AddBoiler_req_W_hour = BoilerBackup_Cost_Data
E_aux_AddBoiler_req_W.append(E_aux_AddBoiler_req_W_hour)
Q_BackupBoiler_sum_W = np.sum(Q_BackupBoiler_W)
Opex_var_BackupBoiler_total = np.sum(Opex_var_BackupBoiler)
else:
for hour in range(8760):
E_aux_AddBoiler_req_W.append(0)
Q_BackupBoiler_sum_W = 0.0
Opex_var_BackupBoiler_total = 0.0
if master_to_slave_vars.Furn_Moist_type == "wet":
Opex_var_Furnace_wet = Opex_var_Furnace
elif master_to_slave_vars.Furn_Moist_type == "dry":
Opex_var_Furnace_dry = Opex_var_Furnace
if master_to_slave_vars.gt_fuel == "NG":
Opex_var_CHP_NG = Opex_var_CHP
Opex_var_BaseBoiler_NG = Opex_var_BaseBoiler
Opex_var_PeakBoiler_NG = Opex_var_PeakBoiler
Opex_var_BackupBoiler_NG = Opex_var_BackupBoiler
elif master_to_slave_vars.gt_fuel == "BG":
Opex_var_CHP_BG = Opex_var_CHP
Opex_var_BaseBoiler_BG = Opex_var_BaseBoiler
Opex_var_PeakBoiler_BG = Opex_var_PeakBoiler
Opex_var_BackupBoiler_BG = Opex_var_BackupBoiler
# Sum up all electricity needs
intermediate_sum_1 = np.add(E_HPSew_req_W, E_HPLake_req_W)
intermediate_sum_2 = np.add(E_GHP_req_W, E_BaseBoiler_req_W)
intermediate_sum_3 = np.add(E_PeakBoiler_req_W, E_aux_AddBoiler_req_W)
intermediate_sum_4 = np.add(intermediate_sum_1, intermediate_sum_2)
E_aux_activation_req_W = np.add(intermediate_sum_3, intermediate_sum_4)
E_aux_storage_solar_and_heat_recovery_req_W = np.add(np.add(E_aux_ch_W, E_aux_dech_W),
E_aux_solar_and_heat_recovery_W)
# Sum up all electricity produced by CHP (CC and Furnace)
# cost already accounted for in System Models (selling electricity --> cheaper thermal energy)
E_CHP_and_Furnace_gen_W = np.add(E_CHP_gen_W, E_Furnace_gen_W)
# price from PV and PVT electricity (both are in E_PV_Wh, see Storage_Design_and..., about Line 133)
E_solar_gen_W = np.add(E_PV_gen_W, E_PVT_gen_W)
E_total_gen_W = np.add(E_produced_solar_W, E_CHP_and_Furnace_gen_W)
E_without_buildingdemand_req_W = np.add(E_aux_storage_solar_and_heat_recovery_req_W, E_aux_activation_req_W)
E_total_req_W = np.add(np.array(network_data['Electr_netw_total_W']), E_without_buildingdemand_req_W)
E_PV_to_grid_W = np.zeros(8760)
E_PVT_to_grid_W = np.zeros(8760)
E_CHP_to_grid_W = np.zeros(8760)
E_Furnace_to_grid_W = np.zeros(8760)
E_PV_directload_W = np.zeros(8760)
E_PVT_directload_W = np.zeros(8760)
E_CHP_directload_W = np.zeros(8760)
E_Furnace_directload_W = np.zeros(8760)
E_from_grid_W = np.zeros(8760)
for hour in range(8760):
E_hour_W = E_total_req_W[hour]
if E_PV_gen_W[hour] <= E_hour_W:
E_PV_directload_W[hour] = E_PV_gen_W[hour]
E_hour_W = E_hour_W - E_PV_directload_W[hour]
else:
E_PV_directload_W[hour] = E_hour_W
E_PV_to_grid_W[hour] = E_PV_gen_W[hour] - E_hour_W
E_hour_W = 0
if E_PVT_gen_W[hour] <= E_hour_W:
E_PVT_directload_W[hour] = E_PVT_gen_W[hour]
E_hour_W = E_hour_W - E_PVT_directload_W[hour]
else:
E_PVT_directload_W[hour] = E_hour_W
E_PVT_to_grid_W[hour] = E_PVT_gen_W[hour] - E_hour_W
E_hour_W = 0
if E_CHP_gen_W[hour] <= E_hour_W:
E_CHP_directload_W[hour] = E_CHP_gen_W[hour]
E_hour_W = E_hour_W - E_CHP_directload_W[hour]
else:
E_CHP_directload_W[hour] = E_hour_W
E_CHP_to_grid_W[hour] = E_CHP_gen_W[hour] - E_hour_W
E_hour_W = 0
if E_Furnace_gen_W[hour] <= E_hour_W:
E_Furnace_directload_W[hour] = E_Furnace_gen_W[hour]
E_hour_W = E_hour_W - E_Furnace_directload_W[hour]
else:
E_Furnace_directload_W[hour] = E_hour_W
E_Furnace_to_grid_W[hour] = E_Furnace_gen_W[hour] - E_hour_W
E_hour_W = 0
E_from_grid_W[hour] = E_hour_W
# saving pattern activation to disk
date = network_data.DATE.values
results = pd.DataFrame({"DATE": date,
"Q_Network_Demand_after_Storage_W": Q_missing_copy_W,
"Opex_var_HP_Sewage": Opex_var_HP_Sewage,
"Opex_var_HP_Lake": Opex_var_HP_Lake,
"Opex_var_GHP": Opex_var_GHP,
"Opex_var_CHP_BG": Opex_var_CHP_BG,
"Opex_var_CHP_NG": Opex_var_CHP_NG,
"Opex_var_Furnace_wet": Opex_var_Furnace_wet,
"Opex_var_Furnace_dry": Opex_var_Furnace_dry,
"Opex_var_BaseBoiler_BG": Opex_var_BaseBoiler_BG,
"Opex_var_BaseBoiler_NG": Opex_var_BaseBoiler_NG,
"Opex_var_PeakBoiler_BG": Opex_var_PeakBoiler_BG,
"Opex_var_PeakBoiler_NG": Opex_var_PeakBoiler_NG,
"Opex_var_BackupBoiler_BG": Opex_var_BackupBoiler_BG,
"Opex_var_BackupBoiler_NG": Opex_var_BackupBoiler_NG,
"HPSew_Status": source_HP_Sewage,
"HPLake_Status": source_HP_Lake,
"GHP_Status": source_GHP,
"CHP_Status": source_CHP,
"Furnace_Status": source_Furnace,
"BoilerBase_Status": source_BaseBoiler,
"BoilerPeak_Status": source_PeakBoiler,
"Q_HPSew_W": Q_HPSew_gen_W,
"Q_HPLake_W": Q_HPLake_gen_W,
"Q_GHP_W": Q_GHP_gen_W,
"Q_CHP_W": Q_CHP_gen_W,
"Q_Furnace_W": Q_Furnace_gen_W,
"Q_BaseBoiler_W": Q_BaseBoiler_gen_W,
"Q_PeakBoiler_W": Q_PeakBoiler_gen_W,
"Q_AddBoiler_W": Q_uncovered_W,
"Q_coldsource_HPLake_W": E_coldsource_HPLake_W,
"Q_coldsource_HPSew_W": E_coldsource_HPSew_W,
"Q_coldsource_GHP_W": E_coldsource_GHP_W,
"Q_coldsource_CHP_W": E_coldsource_CHP_W,
"Q_coldsource_Furnace_W": E_coldsource_Furnace_W,
"Q_coldsource_BaseBoiler_W": E_coldsource_BaseBoiler_W,
"Q_coldsource_PeakBoiler_W": E_coldsource_PeakBoiler_W,
"Q_excess_W": Q_excess_W
})
results.to_csv(locator.get_optimization_slave_heating_activation_pattern(MS_Var.individual_number,
MS_Var.generation_number), index=False)
results = pd.DataFrame({"DATE": date,
"E_total_req_W": E_total_req_W,
"E_HPSew_req_W": E_HPSew_req_W,
"E_HPLake_req_W": E_HPLake_req_W,
"E_GHP_req_W": E_GHP_req_W,
"E_CHP_gen_W": E_CHP_gen_W,
"E_Furnace_gen_W": E_Furnace_gen_W,
"E_BaseBoiler_req_W": E_BaseBoiler_req_W,
"E_PeakBoiler_req_W": E_PeakBoiler_req_W,
"E_AddBoiler_req_W": E_aux_AddBoiler_req_W,
"E_PV_gen_W": E_PV_gen_W,
"E_PVT_gen_W": E_PVT_gen_W,
"E_CHP_and_Furnace_gen_W": E_CHP_and_Furnace_gen_W,
"E_gen_total_W": E_total_gen_W,
"E_PV_to_directload_W": E_PV_directload_W,
"E_PVT_to_directload_W": E_PVT_directload_W,
"E_CHP_to_directload_W": E_CHP_directload_W,
"E_Furnace_to_directload_W": E_Furnace_directload_W,
"E_PV_to_grid_W": E_PV_to_grid_W,
"E_PVT_to_grid_W": E_PVT_to_grid_W,
"E_CHP_to_grid_W": E_CHP_to_grid_W,
"E_Furnace_to_grid_W": E_Furnace_to_grid_W,
"E_aux_storage_solar_and_heat_recovery_req_W": E_aux_storage_solar_and_heat_recovery_req_W,
"E_consumed_without_buildingdemand_W": E_without_buildingdemand_req_W,
"E_from_grid_W": E_from_grid_W
})
results.to_csv(locator.get_optimization_slave_electricity_activation_pattern_heating(MS_Var.individual_number,
MS_Var.generation_number), index=False)
E_aux_storage_operation_sum_W = np.sum(E_aux_storage_solar_and_heat_recovery_req_W)
E_aux_solar_and_heat_recovery_W = np.sum(E_aux_solar_and_heat_recovery_W)
CO2_emitted, Eprim_used = calc_primary_energy_and_CO2(Q_HPSew_gen_W, Q_HPLake_gen_W, Q_GHP_gen_W, Q_CHP_gen_W,
Q_Furnace_gen_W, Q_BaseBoiler_gen_W, Q_PeakBoiler_gen_W,
Q_uncovered_W,
E_coldsource_HPSew_W, E_coldsource_HPLake_W,
E_coldsource_GHP_W,
E_CHP_gen_W, E_Furnace_gen_W, E_BaseBoiler_req_W,
E_PeakBoiler_req_W,
E_gas_CHP_W, E_gas_BaseBoiler_W, E_gas_PeakBoiler_W,
E_wood_Furnace_W, Q_BackupBoiler_sum_W,
np.sum(E_aux_AddBoiler_req_W),
np.sum(E_solar_gen_W), np.sum(Q_SCandPVT_gen_Wh),
Q_storage_content_W,
master_to_slave_vars, locator,
E_aux_solar_and_heat_recovery_W,
E_aux_storage_operation_sum_W, gv, lca)
# sum up results from PP Activation
E_consumed_sum_W = np.sum(E_aux_storage_solar_and_heat_recovery_req_W) + np.sum(E_aux_activation_req_W)
# Differenciate between Normal and green electricity for
if MS_Var.EL_TYPE == 'green':
ELEC_PRICE = gv.ELEC_PRICE_GREEN
else:
ELEC_PRICE = lca.ELEC_PRICE
# Area available in NEtwork
Area_AvailablePV_m2 = solar_features.A_PV_m2 * MS_Var.SOLAR_PART_PV
Area_AvailablePVT_m2 = solar_features.A_PVT_m2 * MS_Var.SOLAR_PART_PVT
# import from master
eta_m2_to_kW = ETA_AREA_TO_PEAK # Data from Jimeno
Q_PowerPeakAvailablePV_kW = Area_AvailablePV_m2 * eta_m2_to_kW
Q_PowerPeakAvailablePVT_kW = Area_AvailablePVT_m2 * eta_m2_to_kW
# calculate with conversion factor m'2-kWPeak
KEV_RpPerkWhPVT = calc_Crem_pv(Q_PowerPeakAvailablePVT_kW * 1000.0)
KEV_RpPerkWhPV = calc_Crem_pv(Q_PowerPeakAvailablePV_kW * 1000.0)
KEV_total = KEV_RpPerkWhPVT / 100 * np.sum(E_PVT_gen_W) / 1000 + KEV_RpPerkWhPV / 100 * np.sum(E_PV_gen_W) / 1000
# Units: from Rp/kWh to CHF/Wh
price_obtained_from_KEV_for_PVandPVT = KEV_total
cost_CHP_maintenance = np.sum(E_CHP_gen_W) * prices.CC_MAINTENANCE_PER_KWHEL / 1000.0
# Fill up storage if end-of-season energy is lower than beginning of season
Q_Storage_SeasonEndReheat_W = Q_storage_content_W[-1] - Q_storage_content_W[0]
gas_price = prices.NG_PRICE
if Q_Storage_SeasonEndReheat_W > 0:
cost_Boiler_for_Storage_reHeat_at_seasonend = float(Q_Storage_SeasonEndReheat_W) / 0.8 * gas_price
else:
cost_Boiler_for_Storage_reHeat_at_seasonend = 0
# CHANGED AS THE COST_DATA INCLUDES COST_ELECTRICITY_TOTAL ALREADY! (= double accounting)
cost_HP_aux_uncontrollable = np.sum(E_aux_solar_and_heat_recovery_W) * ELEC_PRICE
cost_HP_storage_operation = np.sum(E_aux_storage_solar_and_heat_recovery_req_W) * ELEC_PRICE
cost_sum = np.sum(Opex_var_HP_Sewage) + np.sum(Opex_var_HP_Lake) + np.sum(Opex_var_GHP) + np.sum(
Opex_var_CHP) + np.sum(Opex_var_Furnace) + np.sum(Opex_var_BaseBoiler) + np.sum(
Opex_var_PeakBoiler) - price_obtained_from_KEV_for_PVandPVT - lca.ELEC_PRICE * np.sum(
E_CHP_gen_W) + Opex_var_BackupBoiler_total + cost_CHP_maintenance + \
cost_Boiler_for_Storage_reHeat_at_seasonend + cost_HP_aux_uncontrollable + cost_HP_storage_operation
save_cost = 1
E_oil_eq_MJ = Eprim_used
CO2_kg_eq = CO2_emitted
# Calculate primary energy from ressources:
E_gas_Primary_W = Q_BackupBoiler_sum_W + np.sum(E_gas_HPSew_W) + np.sum(E_gas_HPLake_W) + np.sum(
E_gas_GHP_W) + np.sum(E_gas_CHP_W) + np.sum(E_gas_Furnace_W) + np.sum(E_gas_BaseBoiler_W) + np.sum(
E_gas_PeakBoiler_W)
E_wood_Primary_W = np.sum(E_wood_HPSew_W) + np.sum(E_wood_HPLake_W) + np.sum(E_wood_GHP_W) + np.sum(
E_wood_CHP_W) + np.sum(E_wood_Furnace_W) + np.sum(E_wood_BaseBoiler_W) + np.sum(E_wood_PeakBoiler_W)
E_Import_Slave_req_W = E_consumed_sum_W + np.sum(E_aux_AddBoiler_req_W)
E_Export_gen_W = np.sum(E_total_gen_W)
E_groundheat_W = np.sum(E_coldsource_HPSew_W) + np.sum(E_coldsource_HPLake_W) + np.sum(E_coldsource_GHP_W) + np.sum(
E_coldsource_CHP_W) + np.sum(E_coldsource_Furnace_W) + np.sum(E_coldsource_BaseBoiler_W) + np.sum(
E_coldsource_PeakBoiler_W)
E_solar_gen_W = np.sum(E_solar_gen_W) + np.sum(Q_SCandPVT_gen_Wh)
intermediate_max_1 = max(np.amax(E_gas_HPSew_W), np.amax(E_gas_HPLake_W))
intermediate_max_2 = max(intermediate_max_1, np.amax(E_gas_GHP_W))
intermediate_max_3 = max(intermediate_max_2, np.amax(E_gas_CHP_W))
intermediate_max_4 = max(intermediate_max_3, np.amax(E_gas_Furnace_W))
intermediate_max_5 = max(intermediate_max_4, np.amax(E_gas_BaseBoiler_W))
intermediate_max_6 = max(intermediate_max_5, np.amax(E_gas_PeakBoiler_W))
E_gas_PrimaryPeakPower_W = intermediate_max_6 + np.amax(Q_BackupBoiler_W)
if save_cost == 1:
results = pd.DataFrame({
"total cost": [cost_sum],
"KEV_Remuneration": [price_obtained_from_KEV_for_PVandPVT],
"costAddBackup_total": [Opex_var_BackupBoiler_total],
"cost_CHP_maintenance": [cost_CHP_maintenance],
"costHPSew_sum": np.sum(Opex_var_HP_Sewage),
"costHPLake_sum": np.sum(Opex_var_HP_Lake),
"costGHP_sum": np.sum(Opex_var_GHP),
"costCHP_sum": np.sum(Opex_var_CHP),
"costFurnace_sum": np.sum(Opex_var_Furnace),
"costBaseBoiler_sum": np.sum(Opex_var_BaseBoiler),
"costPeakBoiler_sum": np.sum(Opex_var_PeakBoiler),
"cost_Boiler_for_Storage_reHeat_at_seasonend": [cost_Boiler_for_Storage_reHeat_at_seasonend],
"cost_HP_aux_uncontrollable": [cost_HP_aux_uncontrollable],
"cost_HP_storage_operation": [cost_HP_storage_operation],
"E_oil_eq_MJ": [E_oil_eq_MJ],
"CO2_kg_eq": [CO2_kg_eq],
"cost_sum": [cost_sum],
"E_gas_Primary_W": [E_gas_Primary_W],
"E_gas_PrimaryPeakPower_W": [E_gas_PrimaryPeakPower_W],
"E_wood_Primary_W": [E_wood_Primary_W],
"E_Import_Slave_req_W": [E_Import_Slave_req_W],
"E_Export_gen_W": [E_Export_gen_W],
"E_groundheat_W": [E_groundheat_W],
"E_solar_gen_Wh": [E_solar_gen_W]
})
results.to_csv(locator.get_optimization_slave_cost_prime_primary_energy_data(MS_Var.individual_number,
MS_Var.generation_number), sep=',')
return E_oil_eq_MJ, CO2_kg_eq, cost_sum, Q_uncovered_design_W, Q_uncovered_annual_W
def heating_calculations_of_DH_buildings(locator, master_to_slave_vars, gv,
config, prices, lca):
"""
Computes the parameters for the heating of the complete DHN
:param locator: locator class
:param master_to_slave_vars: class MastertoSlaveVars containing the value of variables to be passed to the
slave optimization for each individual
:param solar_features: solar features class
:param gv: global variables class
:type locator: class
:type master_to_slave_vars: class
:type solar_features: class
:type gv: class
:return:
- E_oil_eq_MJ: MJ oil Equivalent used during operation
- CO2_kg_eq: kg of CO2-Equivalent emitted during operation
- cost_sum: total cost in CHF used for operation
- Q_source_data[:,7]: uncovered demand
:rtype: float, float, float, array
"""
t = time.time()
# Import data from storage optimization
centralized_plant_data = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number))
E_aux_ch_W = np.array(centralized_plant_data['E_aux_ch_W'])
E_aux_dech_W = np.array(centralized_plant_data['E_aux_dech_W'])
Q_missing_W = np.array(centralized_plant_data['Q_missing_W'])
E_aux_solar_and_heat_recovery_W = np.array(
centralized_plant_data['E_aux_solar_and_heat_recovery_Wh'])
Q_SC_ET_gen_Wh = np.array(centralized_plant_data['Q_SC_ET_gen_Wh'])
Q_SC_FP_gen_Wh = np.array(centralized_plant_data['Q_SC_FP_gen_Wh'])
Q_PVT_gen_Wh = np.array(centralized_plant_data['Q_PVT_gen_Wh'])
Q_SCandPVT_gen_Wh = Q_SC_ET_gen_Wh + Q_SC_FP_gen_Wh + Q_PVT_gen_Wh
E_PV_gen_W = np.array(centralized_plant_data['E_PV_Wh'])
E_PVT_gen_W = np.array(centralized_plant_data['E_PVT_Wh'])
E_produced_solar_W = np.array(
centralized_plant_data['E_produced_from_solar_W'])
E_solar_gen_W = np.add(E_PV_gen_W, E_PVT_gen_W)
Q_missing_copy_W = Q_missing_W.copy()
# Import Temperatures from Network Summary:
network_data = pd.read_csv(
locator.get_optimization_network_data_folder(
master_to_slave_vars.network_data_file_heating))
tdhret_K = network_data['T_DHNf_re_K']
mdot_DH_kgpers = network_data['mdot_DH_netw_total_kgpers']
tdhsup_K = network_data['T_DHNf_sup_K']
# import Marginal Cost of PP Data :
# os.chdir(Cost_Maps_Path)
# FIXED ORDER ACTIVATION STARTS
# Import Data - Sewage
if HP_SEW_ALLOWED == 1:
HPSew_Data = pd.read_csv(locator.get_sewage_heat_potential())
QcoldsewArray = np.array(HPSew_Data['Qsw_kW']) * 1E3
TretsewArray_K = np.array(HPSew_Data['ts_C']) + 273
# Initiation of the variables
Opex_var_HP_Sewage_USD = np.zeros(8760)
Opex_var_HP_Lake_USD = np.zeros(8760)
Opex_var_GHP_USD = np.zeros(8760)
Opex_var_CHP_USD = np.zeros(8760)
Opex_var_Furnace_USD = np.zeros(8760)
Opex_var_BaseBoiler_USD = np.zeros(8760)
Opex_var_PeakBoiler_USD = np.zeros(8760)
source_HP_Sewage = np.zeros(8760)
source_HP_Lake = np.zeros(8760)
source_GHP = np.zeros(8760)
source_CHP = np.zeros(8760)
source_Furnace = np.zeros(8760)
source_BaseBoiler = np.zeros(8760)
source_PeakBoiler = np.zeros(8760)
Q_HPSew_gen_W = np.zeros(8760)
Q_HPLake_gen_W = np.zeros(8760)
Q_GHP_gen_W = np.zeros(8760)
Q_CHP_gen_W = np.zeros(8760)
Q_Furnace_gen_W = np.zeros(8760)
Q_BaseBoiler_gen_W = np.zeros(8760)
Q_PeakBoiler_gen_W = np.zeros(8760)
Q_uncovered_W = np.zeros(8760)
E_HPSew_req_W = np.zeros(8760)
E_HPLake_req_W = np.zeros(8760)
E_GHP_req_W = np.zeros(8760)
E_CHP_gen_W = np.zeros(8760)
E_Furnace_gen_W = np.zeros(8760)
E_BaseBoiler_req_W = np.zeros(8760)
E_PeakBoiler_req_W = np.zeros(8760)
NG_used_HPSew_W = np.zeros(8760)
NG_used_HPLake_W = np.zeros(8760)
NG_used_GHP_W = np.zeros(8760)
NG_used_CHP_W = np.zeros(8760)
NG_used_Furnace_W = np.zeros(8760)
NG_used_BaseBoiler_W = np.zeros(8760)
NG_used_PeakBoiler_W = np.zeros(8760)
NG_used_BackupBoiler_W = np.zeros(8760)
BG_used_HPSew_W = np.zeros(8760)
BG_used_HPLake_W = np.zeros(8760)
BG_used_GHP_W = np.zeros(8760)
BG_used_CHP_W = np.zeros(8760)
BG_used_Furnace_W = np.zeros(8760)
BG_used_BaseBoiler_W = np.zeros(8760)
BG_used_PeakBoiler_W = np.zeros(8760)
Wood_used_HPSew_W = np.zeros(8760)
Wood_used_HPLake_W = np.zeros(8760)
Wood_used_GHP_W = np.zeros(8760)
Wood_used_CHP_W = np.zeros(8760)
Wood_used_Furnace_W = np.zeros(8760)
Wood_used_BaseBoiler_W = np.zeros(8760)
Wood_used_PeakBoiler_W = np.zeros(8760)
Q_coldsource_HPSew_W = np.zeros(8760)
Q_coldsource_HPLake_W = np.zeros(8760)
Q_coldsource_GHP_W = np.zeros(8760)
Q_coldsource_CHP_W = np.zeros(8760)
Q_coldsource_Furnace_W = np.zeros(8760)
Q_coldsource_BaseBoiler_W = np.zeros(8760)
Q_coldsource_PeakBoiler_W = np.zeros(8760)
Q_excess_W = np.zeros(8760)
weather_data = epwreader.epw_reader(config.weather)[[
'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms',
'skytemp_C'
]]
ground_temp = calc_ground_temperature(locator,
weather_data['drybulb_C'],
depth_m=10)
weather_data = epwreader.epw_reader(config.weather)[[
'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms',
'skytemp_C'
]]
ground_temp = calc_ground_temperature(locator,
weather_data['drybulb_C'],
depth_m=10)
for hour in range(8760):
Q_therm_req_W = Q_missing_W[hour]
# cost_data_centralPlant_op[hour, :], source_info[hour, :], Q_source_data_W[hour, :], E_coldsource_data_W[hour,
# :], \
# E_PP_el_data_W[hour, :], E_gas_data_W[hour, :], E_wood_data_W[hour, :], Q_excess_W[hour] = source_activator(
# Q_therm_req_W, hour, master_to_slave_vars, mdot_DH_kgpers[hour], tdhsup_K,
# tdhret_K[hour], TretsewArray_K[hour], gv, prices)
opex_output, source_output, Q_output, E_output, Gas_output, Wood_output, coldsource_output, Q_excess_W[
hour] = heating_source_activator(Q_therm_req_W, hour,
master_to_slave_vars,
mdot_DH_kgpers[hour],
tdhsup_K[hour], tdhret_K[hour],
TretsewArray_K[hour], gv, prices,
lca, ground_temp[hour])
Opex_var_HP_Sewage_USD[hour] = opex_output['Opex_var_HP_Sewage_USD']
Opex_var_HP_Lake_USD[hour] = opex_output['Opex_var_HP_Lake_USD']
Opex_var_GHP_USD[hour] = opex_output['Opex_var_GHP_USD']
Opex_var_CHP_USD[hour] = opex_output['Opex_var_CHP_USD']
Opex_var_Furnace_USD[hour] = opex_output['Opex_var_Furnace_USD']
Opex_var_BaseBoiler_USD[hour] = opex_output['Opex_var_BaseBoiler_USD']
Opex_var_PeakBoiler_USD[hour] = opex_output['Opex_var_PeakBoiler_USD']
source_HP_Sewage[hour] = source_output['HP_Sewage']
source_HP_Lake[hour] = source_output['HP_Lake']
source_GHP[hour] = source_output['GHP']
source_CHP[hour] = source_output['CHP']
source_Furnace[hour] = source_output['Furnace']
source_BaseBoiler[hour] = source_output['BaseBoiler']
source_PeakBoiler[hour] = source_output['PeakBoiler']
Q_HPSew_gen_W[hour] = Q_output['Q_HPSew_gen_W']
Q_HPLake_gen_W[hour] = Q_output['Q_HPLake_gen_W']
Q_GHP_gen_W[hour] = Q_output['Q_GHP_gen_W']
Q_CHP_gen_W[hour] = Q_output['Q_CHP_gen_W']
Q_Furnace_gen_W[hour] = Q_output['Q_Furnace_gen_W']
Q_BaseBoiler_gen_W[hour] = Q_output['Q_BaseBoiler_gen_W']
Q_PeakBoiler_gen_W[hour] = Q_output['Q_PeakBoiler_gen_W']
Q_uncovered_W[hour] = Q_output['Q_uncovered_W']
E_HPSew_req_W[hour] = E_output['E_HPSew_req_W']
E_HPLake_req_W[hour] = E_output['E_HPLake_req_W']
E_GHP_req_W[hour] = E_output['E_GHP_req_W']
E_CHP_gen_W[hour] = E_output['E_CHP_gen_W']
E_Furnace_gen_W[hour] = E_output['E_Furnace_gen_W']
E_BaseBoiler_req_W[hour] = E_output['E_BaseBoiler_req_W']
E_PeakBoiler_req_W[hour] = E_output['E_PeakBoiler_req_W']
if master_to_slave_vars.gt_fuel == "NG":
NG_used_HPSew_W[hour] = Gas_output['Gas_used_HPSew_W']
NG_used_HPLake_W[hour] = Gas_output['Gas_used_HPLake_W']
NG_used_GHP_W[hour] = Gas_output['Gas_used_GHP_W']
NG_used_CHP_W[hour] = Gas_output['Gas_used_CHP_W']
NG_used_Furnace_W[hour] = Gas_output['Gas_used_Furnace_W']
NG_used_BaseBoiler_W[hour] = Gas_output['Gas_used_BaseBoiler_W']
NG_used_PeakBoiler_W[hour] = Gas_output['Gas_used_PeakBoiler_W']
elif master_to_slave_vars.gt_fuel == "BG":
BG_used_HPSew_W[hour] = Gas_output['Gas_used_HPSew_W']
BG_used_HPLake_W[hour] = Gas_output['Gas_used_HPLake_W']
BG_used_GHP_W[hour] = Gas_output['Gas_used_GHP_W']
BG_used_CHP_W[hour] = Gas_output['Gas_used_CHP_W']
BG_used_Furnace_W[hour] = Gas_output['Gas_used_Furnace_W']
BG_used_BaseBoiler_W[hour] = Gas_output['Gas_used_BaseBoiler_W']
BG_used_PeakBoiler_W[hour] = Gas_output['Gas_used_PeakBoiler_W']
Wood_used_HPSew_W[hour] = Wood_output['Wood_used_HPSew_W']
Wood_used_HPLake_W[hour] = Wood_output['Wood_used_HPLake_W']
Wood_used_GHP_W[hour] = Wood_output['Wood_used_GHP_W']
Wood_used_CHP_W[hour] = Wood_output['Wood_used_CHP_W']
Wood_used_Furnace_W[hour] = Wood_output['Wood_used_Furnace_W']
Wood_used_BaseBoiler_W[hour] = Wood_output['Wood_used_BaseBoiler_W']
Wood_used_PeakBoiler_W[hour] = Wood_output['Wood_used_PeakBoiler_W']
Q_coldsource_HPSew_W[hour] = coldsource_output['Q_coldsource_HPSew_W']
Q_coldsource_HPLake_W[hour] = coldsource_output[
'Q_coldsource_HPLake_W']
Q_coldsource_GHP_W[hour] = coldsource_output['Q_coldsource_GHP_W']
Q_coldsource_CHP_W[hour] = coldsource_output['Q_coldsource_CHP_W']
Q_coldsource_Furnace_W[hour] = coldsource_output[
'Q_coldsource_Furnace_W']
Q_coldsource_BaseBoiler_W[hour] = coldsource_output[
'Q_coldsource_BaseBoiler_W']
Q_coldsource_PeakBoiler_W[hour] = coldsource_output[
'Q_coldsource_PeakBoiler_W']
# save data
elapsed = time.time() - t
# sum up the uncovered demand, get average and peak load
Q_uncovered_design_W = np.amax(Q_uncovered_W)
Q_uncovered_annual_W = np.sum(Q_uncovered_W)
Opex_var_BackupBoiler_USD = np.zeros(8760)
Q_BackupBoiler_W = np.zeros(8760)
E_BackupBoiler_req_W = np.zeros(8760)
Opex_var_Furnace_wet_USD = np.zeros(8760)
Opex_var_Furnace_dry_USD = np.zeros(8760)
Opex_var_CHP_NG_USD = np.zeros(8760)
Opex_var_CHP_BG_USD = np.zeros(8760)
Opex_var_BaseBoiler_NG_USD = np.zeros(8760)
Opex_var_BaseBoiler_BG_USD = np.zeros(8760)
Opex_var_PeakBoiler_NG_USD = np.zeros(8760)
Opex_var_PeakBoiler_BG_USD = np.zeros(8760)
Opex_var_BackupBoiler_NG_USD = np.zeros(8760)
Opex_var_BackupBoiler_BG_USD = np.zeros(8760)
Opex_var_PV_USD = np.zeros(8760)
Opex_var_PVT_USD = np.zeros(8760)
Opex_var_SC_USD = np.zeros(8760)
if Q_uncovered_design_W != 0:
for hour in range(8760):
tdhret_req_K = tdhret_K[hour]
BoilerBackup_Cost_Data = cond_boiler_op_cost(Q_uncovered_W[hour], Q_uncovered_design_W, tdhret_req_K, \
master_to_slave_vars.BoilerBackupType,
master_to_slave_vars.EL_TYPE, gv, prices, lca)
Opex_var_BackupBoiler_USD[
hour], Opex_var_BackupBoiler_per_Wh_USD, Q_BackupBoiler_W[
hour], E_BackupBoiler_req_W_hour = BoilerBackup_Cost_Data
E_BackupBoiler_req_W[hour] = E_BackupBoiler_req_W_hour
NG_used_BackupBoiler_W[hour] = Q_BackupBoiler_W[hour]
Q_BackupBoiler_sum_W = np.sum(Q_BackupBoiler_W)
Opex_t_var_BackupBoiler_USD = np.sum(Opex_var_BackupBoiler_USD)
else:
Q_BackupBoiler_sum_W = 0.0
Opex_t_var_BackupBoiler_USD = 0.0
if master_to_slave_vars.Furn_Moist_type == "wet":
Opex_var_Furnace_wet_USD = Opex_var_Furnace_USD
elif master_to_slave_vars.Furn_Moist_type == "dry":
Opex_var_Furnace_dry_USD = Opex_var_Furnace_USD
if master_to_slave_vars.gt_fuel == "NG":
Opex_var_CHP_NG_USD = Opex_var_CHP_USD
Opex_var_BaseBoiler_NG_USD = Opex_var_BaseBoiler_USD
Opex_var_PeakBoiler_NG_USD = Opex_var_PeakBoiler_USD
Opex_var_BackupBoiler_NG_USD = Opex_var_BackupBoiler_USD
elif master_to_slave_vars.gt_fuel == "BG":
Opex_var_CHP_BG_USD = Opex_var_CHP_USD
Opex_var_BaseBoiler_BG_USD = Opex_var_BaseBoiler_USD
Opex_var_PeakBoiler_BG_USD = Opex_var_PeakBoiler_USD
Opex_var_BackupBoiler_BG_USD = Opex_var_BackupBoiler_USD
# saving pattern activation to disk
date = network_data.DATE.values
results = pd.DataFrame({
"DATE": date,
"Q_Network_Demand_after_Storage_W": Q_missing_copy_W,
"Opex_var_HP_Sewage": Opex_var_HP_Sewage_USD,
"Opex_var_HP_Lake": Opex_var_HP_Lake_USD,
"Opex_var_GHP": Opex_var_GHP_USD,
"Opex_var_CHP_BG": Opex_var_CHP_BG_USD,
"Opex_var_CHP_NG": Opex_var_CHP_NG_USD,
"Opex_var_Furnace_wet": Opex_var_Furnace_wet_USD,
"Opex_var_Furnace_dry": Opex_var_Furnace_dry_USD,
"Opex_var_BaseBoiler_BG": Opex_var_BaseBoiler_BG_USD,
"Opex_var_BaseBoiler_NG": Opex_var_BaseBoiler_NG_USD,
"Opex_var_PeakBoiler_BG": Opex_var_PeakBoiler_BG_USD,
"Opex_var_PeakBoiler_NG": Opex_var_PeakBoiler_NG_USD,
"Opex_var_BackupBoiler_BG": Opex_var_BackupBoiler_BG_USD,
"Opex_var_BackupBoiler_NG": Opex_var_BackupBoiler_NG_USD,
"HPSew_Status": source_HP_Sewage,
"HPLake_Status": source_HP_Lake,
"GHP_Status": source_GHP,
"CHP_Status": source_CHP,
"Furnace_Status": source_Furnace,
"BoilerBase_Status": source_BaseBoiler,
"BoilerPeak_Status": source_PeakBoiler,
"Q_HPSew_W": Q_HPSew_gen_W,
"Q_HPLake_W": Q_HPLake_gen_W,
"Q_GHP_W": Q_GHP_gen_W,
"Q_CHP_W": Q_CHP_gen_W,
"Q_Furnace_W": Q_Furnace_gen_W,
"Q_BaseBoiler_W": Q_BaseBoiler_gen_W,
"Q_PeakBoiler_W": Q_PeakBoiler_gen_W,
"Q_AddBoiler_W": Q_uncovered_W,
"Q_coldsource_HPLake_W": Q_coldsource_HPLake_W,
"Q_coldsource_HPSew_W": Q_coldsource_HPSew_W,
"Q_coldsource_GHP_W": Q_coldsource_GHP_W,
"Q_coldsource_CHP_W": Q_coldsource_CHP_W,
"Q_coldsource_Furnace_W": Q_coldsource_Furnace_W,
"Q_coldsource_BaseBoiler_W": Q_coldsource_BaseBoiler_W,
"Q_coldsource_PeakBoiler_W": Q_coldsource_PeakBoiler_W,
"Q_excess_W": Q_excess_W,
"E_HPSew_req_W": E_HPSew_req_W,
"E_HPLake_req_W": E_HPLake_req_W,
"E_GHP_req_W": E_GHP_req_W,
"E_CHP_gen_W": E_CHP_gen_W,
"E_Furnace_gen_W": E_Furnace_gen_W,
"E_BaseBoiler_req_W": E_BaseBoiler_req_W,
"E_PeakBoiler_req_W": E_PeakBoiler_req_W,
"E_BackupBoiler_req_W": E_BackupBoiler_req_W,
"NG_used_HPSew_W": NG_used_HPSew_W,
"NG_used_HPLake_W": NG_used_HPLake_W,
"NG_used_GHP_W": NG_used_GHP_W,
"NG_used_CHP_W": NG_used_CHP_W,
"NG_used_Furnace_W": NG_used_Furnace_W,
"NG_used_BaseBoiler_W": NG_used_BaseBoiler_W,
"NG_used_PeakBoiler_W": NG_used_PeakBoiler_W,
"NG_used_BackupBoiler_W": NG_used_BackupBoiler_W,
"BG_used_HPSew_W": BG_used_HPSew_W,
"BG_used_HPLake_W": BG_used_HPLake_W,
"BG_used_GHP_W": BG_used_GHP_W,
"BG_used_CHP_W": BG_used_CHP_W,
"BG_used_Furnace_W": BG_used_Furnace_W,
"BG_used_BaseBoiler_W": BG_used_BaseBoiler_W,
"BG_used_PeakBoiler_W": BG_used_PeakBoiler_W,
"Wood_used_HPSew_W": Wood_used_HPSew_W,
"Wood_used_HPLake_W": Wood_used_HPLake_W,
"Wood_used_GHP_W": Wood_used_GHP_W,
"Wood_used_CHP_": Wood_used_CHP_W,
"Wood_used_Furnace_W": Wood_used_Furnace_W,
"Wood_used_BaseBoiler_W": Wood_used_BaseBoiler_W,
"Wood_used_PeakBoiler_W": Wood_used_PeakBoiler_W
})
results.to_csv(locator.get_optimization_slave_heating_activation_pattern(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
index=False)
if master_to_slave_vars.gt_fuel == "NG":
CO2_emitted, PEN_used = calc_primary_energy_and_CO2(
Q_HPSew_gen_W, Q_HPLake_gen_W, Q_GHP_gen_W, Q_CHP_gen_W,
Q_Furnace_gen_W, Q_BaseBoiler_gen_W, Q_PeakBoiler_gen_W,
Q_uncovered_W, Q_coldsource_HPSew_W, Q_coldsource_HPLake_W,
Q_coldsource_GHP_W, E_CHP_gen_W, E_Furnace_gen_W,
E_BaseBoiler_req_W, E_PeakBoiler_req_W, NG_used_CHP_W,
NG_used_BaseBoiler_W, NG_used_PeakBoiler_W,
Wood_used_Furnace_W, Q_BackupBoiler_sum_W,
np.sum(E_BackupBoiler_req_W), master_to_slave_vars, locator, lca)
elif master_to_slave_vars.gt_fuel == "BG":
CO2_emitted, PEN_used = calc_primary_energy_and_CO2(
Q_HPSew_gen_W, Q_HPLake_gen_W, Q_GHP_gen_W, Q_CHP_gen_W,
Q_Furnace_gen_W, Q_BaseBoiler_gen_W, Q_PeakBoiler_gen_W,
Q_uncovered_W, Q_coldsource_HPSew_W, Q_coldsource_HPLake_W,
Q_coldsource_GHP_W, E_CHP_gen_W, E_Furnace_gen_W,
E_BaseBoiler_req_W, E_PeakBoiler_req_W, BG_used_CHP_W,
BG_used_BaseBoiler_W, BG_used_PeakBoiler_W,
Wood_used_Furnace_W, Q_BackupBoiler_sum_W,
np.sum(E_BackupBoiler_req_W), master_to_slave_vars, locator, lca)
cost_sum = np.sum(Opex_var_HP_Sewage_USD) + np.sum(
Opex_var_HP_Lake_USD) + np.sum(Opex_var_GHP_USD) + np.sum(
Opex_var_CHP_USD) + np.sum(Opex_var_Furnace_USD) + np.sum(
Opex_var_BaseBoiler_USD) + np.sum(
Opex_var_PeakBoiler_USD) + Opex_t_var_BackupBoiler_USD
E_oil_eq_MJ = PEN_used
CO2_kg_eq = CO2_emitted
return E_oil_eq_MJ, CO2_kg_eq, cost_sum, Q_uncovered_design_W, Q_uncovered_annual_W
def extract_loads_individual(locator, config, individual_with_name_dict,
DCN_barcode, DHN_barcode,
district_heating_network,
district_cooling_network,
column_names_buildings_heating,
column_names_buildings_cooling):
# local variables
weather_file = locator.get_weather_file()
network_depth_m = Z0
T_ambient = epwreader.epw_reader(weather_file)['drybulb_C']
ground_temp = calc_ground_temperature(locator,
T_ambient,
depth_m=network_depth_m)
# EVALUATE CASES TO CREATE A NETWORK OR NOT
if district_heating_network: # network exists
if DHN_barcode.count("1") == len(column_names_buildings_heating):
network_file_name_heating = "DH_Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(
'DH', DHN_barcode),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
elif DHN_barcode.count("1") == 0: # no network at all
network_file_name_heating = "DH_Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
Q_heating_max_W = 0
else:
network_file_name_heating = "DH_Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
if not os.path.exists(
locator.get_optimization_network_results_summary(
'DH', DHN_barcode)):
total_demand = createTotalNtwCsv(
DHN_barcode, locator, column_names_buildings_heating)
num_total_buildings = len(column_names_buildings_heating)
buildings_in_heating_network = total_demand.Name.values
# Run the substation and distribution routines
substation.substation_main_heating(
locator,
total_demand,
buildings_in_heating_network,
DHN_barcode=DHN_barcode)
summarize_network.network_main(locator,
buildings_in_heating_network,
ground_temp,
num_total_buildings, "DH",
DHN_barcode)
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(
'DH', DHN_barcode),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
else:
Q_heating_max_W = 0.0
network_file_name_heating = ""
if district_cooling_network: # network exists
if DCN_barcode.count("1") == len(column_names_buildings_cooling):
network_file_name_cooling = "DC_Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
if individual_with_name_dict['HPServer'] == 1:
# if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W_no_server_demand = pd.read_csv(
locator.get_optimization_network_results_summary(
'DC', DCN_barcode),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"
]).values
Q_DCNf_W_with_server_demand = pd.read_csv(
locator.get_optimization_network_results_summary(
'DC', DCN_barcode),
usecols=[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"
]).values
Q_DCNf_W = Q_DCNf_W_no_server_demand + (
(Q_DCNf_W_with_server_demand - Q_DCNf_W_no_server_demand) *
(individual_with_name_dict['HPShare']))
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(
'DC', DCN_barcode),
usecols=[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"
]).values
Q_cooling_max_W = Q_DCNf_W.max()
elif DCN_barcode.count("1") == 0:
network_file_name_cooling = "DC_Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
Q_cooling_max_W = 0.0
else:
network_file_name_cooling = "DC_Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
if not os.path.exists(
locator.get_optimization_network_results_summary(
'DC', DCN_barcode)):
total_demand = createTotalNtwCsv(
DCN_barcode, locator, column_names_buildings_cooling)
num_total_buildings = len(column_names_buildings_cooling)
buildings_in_cooling_network = total_demand.Name.values
# Run the substation and distribution routines
substation.substation_main_cooling(
locator,
total_demand,
buildings_in_cooling_network,
DCN_barcode=DCN_barcode)
summarize_network.network_main(locator,
buildings_in_cooling_network,
ground_temp,
num_total_buildings, 'DC',
DCN_barcode)
Q_DCNf_W_no_server_demand = pd.read_csv(
locator.get_optimization_network_results_summary(
'DC', DCN_barcode),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
Q_DCNf_W_with_server_demand = pd.read_csv(
locator.get_optimization_network_results_summary(
'DC', DCN_barcode),
usecols=[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"
]).values
# if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
if district_heating_network and individual_with_name_dict[
'HPServer'] == 1:
Q_DCNf_W = Q_DCNf_W_no_server_demand + (
(Q_DCNf_W_with_server_demand - Q_DCNf_W_no_server_demand) *
(individual_with_name_dict['HPShare']))
else:
Q_DCNf_W = Q_DCNf_W_with_server_demand
Q_cooling_max_W = Q_DCNf_W.max()
else:
Q_cooling_max_W = 0.0
network_file_name_cooling = ""
Q_heating_nom_W = Q_heating_max_W * (1 + Q_MARGIN_FOR_NETWORK)
Q_cooling_nom_W = Q_cooling_max_W * (1 + Q_MARGIN_FOR_NETWORK)
return Q_cooling_nom_W, Q_heating_nom_W, network_file_name_cooling, network_file_name_heating
