def decentralizeCosts(individual, locator, gV):
"""
:param individual: list of all parameters corresponding to an individual configuration
:param locator: locator set to the scenario
:param gV: global variables
:type individual: list
:type locator: string
:type gV: class
:return: costsDisc
:rtype: float
"""
indCombi = sFn.individual_to_barcode(individual, gV)
buildList = sFn.extract_building_names_from_csv(locator.pathRaw +
"/Total.csv")
costsDisc = 0
for i in range(len(indCombi)):
if indCombi[i] == "0": # Decentralized building
building_name = buildList[i]
df = pd.read_csv(
locator.get_optimization_disconnected_result_file(
building_name))
dfBest = df[df["Best configuration"] == 1]
costsDisc += dfBest["Annualized Investment Costs [CHF]"].iloc[0]
print costsDisc, "costsDisc"
return costsDisc
def GHPCheck(individual, locator, Qnom, gv):
"""
This function computes the geothermal availability and modifies the individual to
comply with it
:param individual: list with variables included in each individual.
:param locator: path to the demand folder
:param Qnom: Nominal installed capacity in the district heating plant
:param gv: Global Variables
:type individual: list
:type locator: string
:type Qnom: float
:type gv: class
:return: None
:rtype: NoneType
"""
areaArray = np.array(
pd.read_csv(locator.get_geothermal_potential(), usecols=["Area_geo"]))
buildArray = np.array(
pd.read_csv(locator.get_geothermal_potential(), usecols=["Name"]))
buildList = sFn.extract_building_names_from_csv(locator.get_total_demand())
barcode = sFn.individual_to_barcode(individual)
Qallowed = 0
for index, buildName in zip(barcode, buildList):
if index == "1":
areaAvail = areaArray[np.where(buildArray == buildName)[0][0]][0]
Qallowed += np.ceil(
areaAvail / gv.GHP_A) * gv.GHP_HmaxSize #[W_th]
print Qallowed, "Qallowed"
if Qallowed < individual[11] * Qnom:
print "GHP share modified !"
if Qallowed < 1E-3:
oldValue = individual[11]
shareLoss = individual[11]
individual[10] = 0
individual[11] = 0
else:
oldValue = individual[11]
shareLoss = oldValue - Qallowed / Qnom
individual[11] = Qallowed / Qnom
# Adapt the other shares
nPlant = 0
for i in range(gv.nHeat - 1):
if individual[2 * i] > 0:
nPlant += 1
individual[2 * i +
1] += individual[2 * i + 1] * shareLoss / (1 -
oldValue)
if nPlant == 0: # there was only the GHP --> replaced by only NG Boiler
individual[2] = 1
individual[3] = 1 - individual[11]
def checkNtw(individual, DHN_network_list, DCN_network_list, locator, gv,
config, building_names):
"""
This function calls the distribution routine if necessary
:param individual: network configuration considered
:param ntwList: list of DHN configurations previously encounterd in the master
:param locator: path to the folder
:type individual: list
:type ntwList: list
:type locator: string
:return: None
:rtype: Nonetype
"""
DHN_barcode, DCN_barcode, DHN_configuration, DCN_configuration = supportFn.individual_to_barcode(
individual, building_names)
if not (DHN_barcode in DHN_network_list) and DHN_barcode.count("1") > 0:
DHN_network_list.append(DHN_barcode)
total_demand = supportFn.createTotalNtwCsv(DHN_barcode, locator)
building_names = total_demand.Name.values
# Run the substation and distribution routines
substation.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
summarize_network.network_main(locator, total_demand, building_names,
config, gv, DHN_barcode)
if not (DCN_barcode in DCN_network_list) and DCN_barcode.count("1") > 0:
DCN_network_list.append(DCN_barcode)
total_demand = supportFn.createTotalNtwCsv(DCN_barcode, locator)
building_names = total_demand.Name.values
# Run the substation and distribution routines
substation.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
summarize_network.network_main(locator, total_demand, building_names,
config, gv, DCN_barcode)
def checkNtw(individual, ntwList, locator, gv):
"""
This function calls the distribution routine if necessary
:param individual: network configuration considered
:param ntwList: list of DHN configurations previously encounterd in the master
:param locator: path to the folder
:type individual: list
:type ntwList: list
:type locator: string
:return: None
:rtype: Nonetype
"""
indCombi = sFn.individual_to_barcode(individual, gv)
print indCombi, 2
if not (indCombi in ntwList) and indCombi.count("1") > 0:
ntwList.append(indCombi)
if indCombi.count("1") == 1:
total_demand = pd.read_csv(
os.path.join(locator.get_optimization_network_results_folder(),
"Total_%(indCombi)s.csv" % locals()))
building_names = total_demand.Name.values
print "Direct launch of distribution summary routine for", indCombi
nM.network_main(locator, total_demand, building_names, gv,
indCombi)
else:
total_demand = sFn.createTotalNtwCsv(indCombi, locator)
building_names = total_demand.Name.values
# Run the substation and distribution routines
print "Re-run the substation routine for new distribution configuration", indCombi
sMain.substation_main(locator, total_demand, building_names, gv,
indCombi)
print "Launch distribution summary routine"
nM.network_main(locator, total_demand, building_names, gv,
indCombi)
def calc_master_to_slave_variables(individual, Q_heating_max_W,
Q_cooling_max_W, building_names, ind_num,
gen):
"""
This function reads the list encoding a configuration and implements the corresponding
for the slave routine's to use
:param individual: list with inidividual
:param Q_heating_max_W: peak heating demand
:param locator: locator class
:param gv: global variables class
:type individual: list
:type Q_heating_max_W: float
:type locator: string
:type gv: class
:return: master_to_slave_vars : class MasterSlaveVariables
:rtype: class
"""
# initialise class storing dynamic variables transfered from master to slave optimization
master_to_slave_vars = slave_data.SlaveData()
configkey = "".join(str(e)[0:4] for e in individual)
DHN_barcode, DCN_barcode, DHN_configuration, DCN_configuration = supportFn.individual_to_barcode(
individual, building_names)
configkey = configkey[:-2 * len(DHN_barcode)] + hex(
int(str(DHN_barcode), 2)) + hex(int(str(DCN_barcode), 2))
master_to_slave_vars.configKey = configkey
master_to_slave_vars.number_of_buildings_connected_heating = DHN_barcode.count(
"1") # counting the number of buildings connected in DHN
master_to_slave_vars.number_of_buildings_connected_cooling = DCN_barcode.count(
"1") # counting the number of buildings connectedin DCN
master_to_slave_vars.individual_number = ind_num
master_to_slave_vars.generation_number = gen
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)
# Heating systems
#CHP units with NG & furnace with biomass wet
if individual[0] == 1 or individual[0] == 3:
if FURNACE_ALLOWED == True:
master_to_slave_vars.Furnace_on = 1
master_to_slave_vars.Furnace_Q_max_W = max(
individual[1] * Q_heating_nom_W, Q_MIN_SHARE * Q_heating_nom_W)
master_to_slave_vars.Furn_Moist_type = "wet"
elif CC_ALLOWED == True:
master_to_slave_vars.CC_on = 1
master_to_slave_vars.CC_GT_SIZE_W = max(
individual[1] * Q_heating_nom_W * 1.3,
Q_MIN_SHARE * Q_heating_nom_W * 1.3)
#1.3 is the conversion factor between the GT_Elec_size NG and Q_DHN
master_to_slave_vars.gt_fuel = "NG"
#CHP units with BG& furnace with biomass dry
if individual[0] == 2 or individual[0] == 4:
if FURNACE_ALLOWED == True:
master_to_slave_vars.Furnace_on = 1
master_to_slave_vars.Furnace_Q_max_W = max(
individual[1] * Q_heating_nom_W, Q_MIN_SHARE * Q_heating_nom_W)
master_to_slave_vars.Furn_Moist_type = "dry"
elif CC_ALLOWED == True:
master_to_slave_vars.CC_on = 1
master_to_slave_vars.CC_GT_SIZE_W = max(
individual[1] * Q_heating_nom_W * 1.5,
Q_MIN_SHARE * Q_heating_nom_W * 1.5)
#1.5 is the conversion factor between the GT_Elec_size BG and Q_DHN
master_to_slave_vars.gt_fuel = "BG"
# Base boiler NG
if individual[2] == 1:
master_to_slave_vars.Boiler_on = 1
master_to_slave_vars.Boiler_Q_max_W = max(
individual[3] * Q_heating_nom_W, Q_MIN_SHARE * Q_heating_nom_W)
master_to_slave_vars.BoilerType = "NG"
# Base boiler BG
if individual[2] == 2:
master_to_slave_vars.Boiler_on = 1
master_to_slave_vars.Boiler_Q_max_W = max(
individual[3] * Q_heating_nom_W, Q_MIN_SHARE * Q_heating_nom_W)
master_to_slave_vars.BoilerType = "BG"
# peak boiler NG
if individual[4] == 1:
master_to_slave_vars.BoilerPeak_on = 1
master_to_slave_vars.BoilerPeak_Q_max_W = max(
individual[5] * Q_heating_nom_W, Q_MIN_SHARE * Q_heating_nom_W)
master_to_slave_vars.BoilerPeakType = "NG"
# peak boiler BG
if individual[4] == 2:
master_to_slave_vars.BoilerPeak_on = 1
master_to_slave_vars.BoilerPeak_Q_max_W = max(
individual[5] * Q_heating_nom_W, Q_MIN_SHARE * Q_heating_nom_W)
master_to_slave_vars.BoilerPeakType = "BG"
# lake - heat pump
if individual[6] == 1 and HP_LAKE_ALLOWED == True:
master_to_slave_vars.HP_Lake_on = 1
master_to_slave_vars.HPLake_maxSize_W = max(
individual[7] * Q_heating_nom_W, Q_MIN_SHARE * Q_heating_nom_W)
# sewage - heatpump
if individual[8] == 1 and HP_SEW_ALLOWED == True:
master_to_slave_vars.HP_Sew_on = 1
master_to_slave_vars.HPSew_maxSize_W = max(
individual[9] * Q_heating_nom_W, Q_MIN_SHARE * Q_heating_nom_W)
# Gwound source- heatpump
if individual[10] == 1 and GHP_ALLOWED == True:
master_to_slave_vars.GHP_on = 1
GHP_Qmax = max(individual[11] * Q_heating_nom_W,
Q_MIN_SHARE * Q_heating_nom_W)
master_to_slave_vars.GHP_number = GHP_Qmax / GHP_HMAX_SIZE
# heat recovery servers and compresor
irank = N_HEAT * 2
master_to_slave_vars.WasteServersHeatRecovery = individual[irank]
master_to_slave_vars.WasteCompressorHeatRecovery = 0
# Solar systems
shareAvail = 1 # all buildings in the neighborhood are connected to the solar potential
irank = N_HEAT * 2 + N_HR
heating_block = N_HEAT * 2 + N_HR + N_SOLAR * 2 + INDICES_CORRESPONDING_TO_DHN
master_to_slave_vars.DHN_supplyunits = DHN_configuration
# cooling systems
# Lake Cooling
if individual[heating_block] == 1 and LAKE_COOLING_ALLOWED is True:
master_to_slave_vars.Lake_cooling_on = 1
master_to_slave_vars.Lake_cooling_size_W = max(
individual[heating_block + 1] * Q_cooling_nom_W,
Q_MIN_SHARE * Q_cooling_nom_W)
# VCC Cooling
if individual[heating_block + 2] == 1 and VCC_ALLOWED is True:
master_to_slave_vars.VCC_on = 1
master_to_slave_vars.VCC_cooling_size_W = max(
individual[heating_block + 3] * Q_cooling_nom_W,
Q_MIN_SHARE * Q_cooling_nom_W)
# Absorption Chiller Cooling
if individual[heating_block +
4] == 1 and ABSORPTION_CHILLER_ALLOWED is True:
master_to_slave_vars.Absorption_Chiller_on = 1
master_to_slave_vars.Absorption_chiller_size_W = max(
individual[heating_block + 5] * Q_cooling_nom_W,
Q_MIN_SHARE * Q_cooling_nom_W)
# Storage Cooling
if individual[heating_block + 6] == 1 and STORAGE_COOLING_ALLOWED is True:
if (individual[heating_block + 2] == 1 and VCC_ALLOWED is True) or (
individual[heating_block + 4] == 1
and ABSORPTION_CHILLER_ALLOWED is True):
master_to_slave_vars.storage_cooling_on = 1
master_to_slave_vars.Storage_cooling_size_W = max(
individual[heating_block + 7] * Q_cooling_nom_W,
Q_MIN_SHARE * Q_cooling_nom_W)
if master_to_slave_vars.Storage_cooling_size_W > STORAGE_COOLING_SHARE_RESTRICTION * Q_cooling_nom_W:
master_to_slave_vars.Storage_cooling_size_W = STORAGE_COOLING_SHARE_RESTRICTION * Q_cooling_nom_W
master_to_slave_vars.DCN_supplyunits = DCN_configuration
master_to_slave_vars.SOLAR_PART_PV = max(
individual[irank] * individual[irank + 1] * shareAvail, 0)
master_to_slave_vars.SOLAR_PART_PVT = max(
individual[irank + 2] * individual[irank + 3] * shareAvail, 0)
master_to_slave_vars.SOLAR_PART_SC_ET = max(
individual[irank + 4] * individual[irank + 5] * shareAvail, 0)
master_to_slave_vars.SOLAR_PART_SC_FP = max(
individual[irank + 6] * individual[irank + 7] * shareAvail, 0)
return master_to_slave_vars
def evaluation_main(individual, building_names, locator, solar_features,
network_features, gv, config, prices, lca, ind_num, gen):
"""
This function evaluates an individual
:param individual: list with values of the individual
:param building_names: list with names of buildings
:param locator: locator class
:param solar_features: solar features call to class
:param network_features: network features call to class
:param gv: global variables class
:param optimization_constants: class containing constants used in optimization
:param config: configuration file
:param prices: class of prices used in optimization
:type individual: list
:type building_names: list
:type locator: string
:type solar_features: class
:type network_features: class
:type gv: class
:type optimization_constants: class
:type config: class
:type prices: class
:return: Resulting values of the objective function. costs, CO2, prim
:rtype: tuple
"""
# Check the consistency of the individual or create a new one
individual = check_invalid(individual, len(building_names), config)
# Initialize objective functions costs, CO2 and primary energy
costs_USD = 0
GHG_tonCO2 = 0
PEN_MJoil = 0
Q_heating_uncovered_design_W = 0
Q_heating_uncovered_annual_W = 0
# Create the string representation of the individual
DHN_barcode, DCN_barcode, DHN_configuration, DCN_configuration = supportFn.individual_to_barcode(
individual, building_names)
if DHN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_heating = "Network_summary_result_all.csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
elif DHN_barcode.count("1") == 0:
network_file_name_heating = "Network_summary_result_all.csv"
Q_heating_max_W = 0
else:
network_file_name_heating = "Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
if not os.path.exists(
locator.get_optimization_network_results_summary(DHN_barcode)):
total_demand = supportFn.createTotalNtwCsv(DHN_barcode, locator)
building_names = total_demand.Name.values
# Run the substation and distribution routines
substation.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
summarize_network.network_main(locator, total_demand,
building_names, config, gv,
DHN_barcode)
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DHN_barcode),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
if DCN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_cooling = "Network_summary_result_all.csv"
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
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 = "Network_summary_result_all.csv"
Q_cooling_max_W = 0
else:
network_file_name_cooling = "Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
if not os.path.exists(
locator.get_optimization_network_results_summary(DCN_barcode)):
total_demand = supportFn.createTotalNtwCsv(DCN_barcode, locator)
building_names = total_demand.Name.values
# Run the substation and distribution routines
substation.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
summarize_network.network_main(locator, total_demand,
building_names, config, gv,
DCN_barcode)
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"
]).values
Q_cooling_max_W = Q_DCNf_W.max()
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)
# Modify the individual with the extra GHP constraint
try:
check.GHPCheck(individual, locator, Q_heating_nom_W, gv)
except:
print "No GHP constraint check possible \n"
# Export to context
master_to_slave_vars = calc_master_to_slave_variables(
individual, Q_heating_max_W, Q_cooling_max_W, building_names, ind_num,
gen)
master_to_slave_vars.network_data_file_heating = network_file_name_heating
master_to_slave_vars.network_data_file_cooling = network_file_name_cooling
master_to_slave_vars.total_buildings = len(building_names)
master_to_slave_vars.DHN_barcode = DHN_barcode
master_to_slave_vars.DCN_barcode = DCN_barcode
if master_to_slave_vars.number_of_buildings_connected_heating > 1:
if DHN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DHN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DHN_barcode)
if master_to_slave_vars.number_of_buildings_connected_cooling > 1:
if DCN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DCN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DCN_barcode)
# Thermal Storage Calculations; Run storage optimization
costs_storage_USD, GHG_storage_tonCO2, PEN_storage_MJoil = storage_main.storage_optimization(
locator, master_to_slave_vars, lca, prices, config)
costs_USD += costs_storage_USD
GHG_tonCO2 += GHG_storage_tonCO2
PEN_MJoil += PEN_storage_MJoil
# District Heating Calculations
if config.district_heating_network:
if DHN_barcode.count("1") > 0:
(PEN_heating_MJoil, GHG_heating_tonCO2, costs_heating_USD,
Q_heating_uncovered_design_W, Q_heating_uncovered_annual_W
) = heating_main.heating_calculations_of_DH_buildings(
locator, master_to_slave_vars, gv, config, prices, lca)
else:
GHG_heating_tonCO2 = 0
costs_heating_USD = 0
PEN_heating_MJoil = 0
else:
GHG_heating_tonCO2 = 0
costs_heating_USD = 0
PEN_heating_MJoil = 0
costs_USD += costs_heating_USD
GHG_tonCO2 += GHG_heating_tonCO2
PEN_MJoil += PEN_heating_MJoil
# District Cooling Calculations
if gv.ZernezFlag == 1:
costs_cooling_USD, GHG_cooling_tonCO2, PEN_cooling_MJoil = 0, 0, 0
elif config.district_cooling_network:
reduced_timesteps_flag = False
(costs_cooling_USD, GHG_cooling_tonCO2, PEN_cooling_MJoil
) = cooling_main.cooling_calculations_of_DC_buildings(
locator, master_to_slave_vars, network_features, gv, prices, lca,
config, reduced_timesteps_flag)
else:
costs_cooling_USD, GHG_cooling_tonCO2, PEN_cooling_MJoil = 0, 0, 0
costs_USD += costs_cooling_USD
GHG_tonCO2 += GHG_cooling_tonCO2
PEN_MJoil += PEN_cooling_MJoil
# District Electricity Calculations
(costs_electricity_USD, GHG_electricity_tonCO2, PEN_electricity_MJoil
) = electricity_main.electricity_calculations_of_all_buildings(
DHN_barcode, DCN_barcode, locator, master_to_slave_vars,
network_features, gv, prices, lca, config)
costs_USD += costs_electricity_USD
GHG_tonCO2 += GHG_electricity_tonCO2
PEN_MJoil += PEN_electricity_MJoil
# Natural Gas Import Calculations. Prices, GHG and PEN are already included in the various sections.
# This is to save the files for further processing and plots
natural_gas_main.natural_gas_imports(master_to_slave_vars, locator, config)
# Capex Calculations
print "Add extra costs"
(costs_additional_USD,
GHG_additional_tonCO2, PEN_additional_MJoil) = cost_model.addCosts(
building_names, locator, master_to_slave_vars,
Q_heating_uncovered_design_W, Q_heating_uncovered_annual_W,
solar_features, network_features, gv, config, prices, lca)
costs_USD += costs_additional_USD
GHG_tonCO2 += GHG_additional_tonCO2
PEN_MJoil += PEN_additional_MJoil
summarize_individual.summarize_individual_main(master_to_slave_vars,
building_names, individual,
solar_features, locator,
config)
# Converting costs into float64 to avoid longer values
costs_USD = np.float64(costs_USD)
GHG_tonCO2 = np.float64(GHG_tonCO2)
PEN_MJoil = np.float64(PEN_MJoil)
print('Total costs = ' + str(costs_USD))
print('Total CO2 = ' + str(GHG_tonCO2))
print('Total prim = ' + str(PEN_MJoil))
# Saving capacity details of the individual
return costs_USD, GHG_tonCO2, PEN_MJoil, master_to_slave_vars, individual
def mcda_indicators(individual, locator, plot = 0):
"""
Computes the specific operational costs and the share of local resources
"""
configKey = "".join(str(e)[0:4] for e in individual)
print configKey
buildList = sFn.extract_building_names_from_csv(locator.pathRaw + "/Total.csv")
gv = cea.globalvar.GlobalVariables()
# Recover data from the PP activation file
resourcesFile = os.path.join(locator.get_optimization_slave_results_folder(), "%(configKey)sPPActivationPattern.csv" % locals())
resourcesdf = pd.read_csv(resourcesFile, usecols=["ESolarProducedPVandPVT", "Q_AddBoiler", "Q_BoilerBase", "Q_BoilerPeak", "Q_CC", "Q_GHP", \
"Q_HPLake", "Q_HPSew", "Q_primaryAddBackupSum", "Q_uncontrollable"])
Electricity_Solar = resourcesdf.ESolarProducedPVandPVT.sum()
Q_AddBoiler = resourcesdf.Q_AddBoiler.sum()
Q_BoilerBase = resourcesdf.Q_BoilerBase.sum()
Q_BoilerPeak = resourcesdf.Q_BoilerPeak.sum()
Q_CC = resourcesdf.Q_CC.sum()
Q_GHP = resourcesdf.Q_GHP.sum()
Q_HPLake = resourcesdf.Q_HPLake.sum()
Q_HPSew = resourcesdf.Q_HPSew.sum()
Q_storage_missmatch = resourcesdf.Q_primaryAddBackupSum.sum()
Q_uncontrollable = resourcesdf.Q_uncontrollable.sum()
# Recover data from the Storage Operation file
resourcesFile = os.path.join(locator.get_optimization_slave_results_folder(),
"%(configKey)sStorageOperationData.csv" % locals())
resourcesdf = pd.read_csv(resourcesFile, usecols=["Q_SCandPVT_coldstream"])
Q_fromSolar = resourcesdf.Q_SCandPVT_coldstream.sum()
# Recover heating needs for decentralized buildings
indCombi = sFn.individual_to_barcode(individual, gv)
QfromNG = 0
QfromBG = 0
QfromGHP = 0
for i in range(len(indCombi)):
if indCombi[i] == "0": # Decentralized building
building_name = buildList[i]
df = pd.read_csv(locator.get_optimization_disconnected_result_file(building_name))
dfBest = df[ df["Best configuration"] == 1 ]
QfromNG += dfBest["QfromNG"].iloc[0]
QfromBG += dfBest["QfromBG"].iloc[0]
QfromGHP += dfBest["QfromGHP"].iloc[0]
# Recover electricity and cooling needs
totalFile = locator.pathRaw + "/Total.csv"
df = pd.read_csv(totalFile, usecols=["Ealf", "Eauxf", "Ecaf", "Edataf", "Epf"])
arrayTotal = np.array(df)
totalElec = np.sum(arrayTotal) * 1E6 # [Wh]
df = pd.read_csv(totalFile, usecols=["Qcdataf", "Qcicef", "Qcpf", "Qcsf"])
arrayTotal = np.array(df)
if individual[12] == 0:
totalCool = ( np.sum((arrayTotal)[:,:-1]) + np.sum((arrayTotal)[:,-1:]) * (1+gv.DCNetworkLoss) ) * 1E6 # [Wh]
else:
totalCool = ( np.sum((arrayTotal)[:,1:-1]) + np.sum((arrayTotal)[:,-1:]) * (1+gv.DCNetworkLoss) ) * 1E6 # [Wh]
# Computes the specific operational costs
totalEnergy = Q_AddBoiler + Q_BoilerBase + Q_BoilerPeak + Q_CC + Q_GHP + Q_HPLake + \
Q_HPSew + Q_uncontrollable + totalElec + totalCool + \
QfromNG + QfromBG + QfromGHP# + Q_storage_missmatch
shareCC_NG = individual[0] % 2 * Q_CC / totalEnergy
shareCC_BG = ( individual[0] + 1 ) % 2 * Q_CC / totalEnergy
shareBB_NG = individual[2] % 2 * Q_BoilerBase / totalEnergy
shareBB_BG = ( individual[2] + 1 ) % 2 * Q_BoilerBase / totalEnergy
shareBP_NG = individual[4] % 2 * Q_BoilerPeak / totalEnergy
shareBP_BG = ( individual[4] + 1 ) % 2 * Q_BoilerPeak / totalEnergy
shareHPLake = Q_HPLake / totalEnergy
shareHPSew = Q_HPSew / totalEnergy
shareGHP = Q_GHP / totalEnergy
shareExtraNG = (Q_AddBoiler + Q_storage_missmatch) / totalEnergy
shareHR = (Q_uncontrollable - Q_fromSolar) / totalEnergy
shareHeatSolar = Q_fromSolar / totalEnergy
shareDecentralizedNG = QfromNG / totalEnergy
shareDecentralizedBG = QfromBG / totalEnergy
shareDecentralizedGHP = QfromGHP / totalEnergy
shareElecGrid = (totalElec - Electricity_Solar) / totalEnergy
shareElecSolar = Electricity_Solar / totalEnergy
shareCoolLake = totalCool / totalEnergy
printout = 1
if printout:
print 'CC_NG', individual[0] % 2 * Q_CC
print 'CC_BG', ( individual[0] + 1 ) % 2 * Q_CC
print 'BB_NG', individual[2] % 2 * Q_BoilerBase
print 'BB_BG', ( individual[2] + 1 ) % 2 * Q_BoilerBase
print 'BP_NG', individual[4] % 2 * Q_BoilerPeak
print 'BP_BG', ( individual[4] + 1 ) % 2 * Q_BoilerPeak
print 'HPLake', Q_HPLake
print 'HPSew', Q_HPSew
print 'GHP', Q_GHP
print 'ExtraNG', (Q_AddBoiler + Q_storage_missmatch)
print 'HR', (Q_uncontrollable - Q_fromSolar)
print 'HeatSolar', Q_fromSolar
print 'DecentralizedNG', QfromNG
print 'DecentralizedBG', QfromBG
print 'DecentralizedGHP', QfromGHP
print 'ElecGrid', (totalElec - Electricity_Solar)
print 'ElecSolar', Electricity_Solar
print 'CoolLake', totalCool
print 'shareCC_NG', shareCC_NG*100
print 'shareCC_BG', shareCC_BG*100
print 'shareBB_NG', shareBB_NG*100
print 'shareBB_BG', shareBB_BG*100
print 'shareBP_NG', shareBP_NG*100
print 'shareBP_BG', shareBP_BG*100
print 'shareHPLake', shareHPLake*100
print 'shareHPSew', shareHPSew*100
print 'shareGHP', shareGHP*100
print 'shareExtraNG', shareExtraNG*100
print 'shareHR', shareHR*100
print 'shareHeatSolar', shareHeatSolar*100
print 'shareDecentralizedNG', shareDecentralizedNG*100
print 'shareDecentralizedBG', shareDecentralizedBG*100
print 'shareDecentralizedGHP', shareDecentralizedGHP*100
print 'shareElecGrid' ,shareElecGrid*100
print 'shareElecSolar', shareElecSolar*100
print 'shareCoolLake', shareCoolLake*100
specificCosts = gv.ELEC_PRICE * shareElecGrid + \
gv.NG_PRICE * (shareCC_NG + shareBB_NG + shareBP_NG + shareExtraNG + shareDecentralizedNG) + \
gv.BG_PRICE * (shareCC_BG + shareBB_BG + shareBP_BG + shareDecentralizedBG)
# Computes the share of local resources
shareLocal = shareHPLake + shareHPSew + shareGHP + shareHR + shareHeatSolar + shareDecentralizedGHP + shareElecSolar + shareCoolLake
# Plots the pie chart for energy resources use
if plot == 1:
fig = plt.figure()
subplot = fig.add_subplot(111, adjustable = 'box', aspect = 1, title = 'Energy mix')
labels = ['Lake', 'Solar', 'HR', 'Ground', 'Gas', 'Grid']
shareLake = shareHPLake + shareCoolLake
shareSolar = shareHeatSolar + shareElecSolar
shareHRAll = shareHPSew + shareHR
shareGround = shareGHP + shareDecentralizedGHP
shareGas = 1 - shareLake - shareSolar - shareHRAll - shareGround - shareElecGrid
fracs = [ shareLake, shareSolar, shareHRAll, shareGround, shareGas, shareElecGrid ]
colors = ['RoyalBlue', 'Gold', 'LightGreen', 'SandyBrown', 'OrangeRed', 'Gray']
zipper = [ (l,f,c) for (l,f,c) in zip(labels,fracs,colors) if f > 0.001 ]
labelsPlot, fracsPlot, colorsPlot = map( list, zip(*zipper) )
subplot.pie(fracsPlot, labels = labelsPlot, colors = colorsPlot, startangle = 90, autopct='%1.1f%%', pctdistance = 0.65)
plt.show()
return specificCosts, shareLocal
def supply_calculation(individual, building_names, total_demand, locator,
extra_costs, extra_CO2, extra_primary_energy,
solar_features, network_features, gv, config, prices,
lca):
"""
This function evaluates one supply system configuration of the case study.
:param individual: a list that indicates the supply system configuration
:type individual: list
:param building_names: names of all building in the district
:type building_names: ndarray
:param locator:
:param extra_costs: cost of decentralized supply systems
:param extra_CO2: CO2 emission of decentralized supply systems
:param extra_primary_energy: Primary energy of decentralized supply systems
:param solar_features: Energy production potentials of solar technologies, including area of installed panels and annual production
:type solar_features: dict
:param network_features: hourly network operating conditions (thermal/pressure losses) and capital costs
:type network_features: dict
:param gv:
:param config:
:param prices:
:return:
"""
individual = evaluation.check_invalid(individual, len(building_names),
config)
# Initialize objective functions costs, CO2 and primary energy
costs_USD = 0.0
GHG_tonCO2 = extra_CO2
PEN_MJoil = extra_primary_energy
Q_uncovered_design_W = 0.0
Q_uncovered_annual_W = 0.0
# Create the string representation of the individual
DHN_barcode, DCN_barcode, DHN_configuration, DCN_configuration = supportFn.individual_to_barcode(
individual, building_names)
# read the total loads from buildings connected to thermal networks
if DHN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_heating = "Network_summary_result_all.csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
elif DHN_barcode.count("1") == 0:
network_file_name_heating = "Network_summary_result_all.csv"
Q_heating_max_W = 0.0
else:
# Run the substation and distribution routines
substation.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
summarize_network.network_main(locator, total_demand, building_names,
config, gv, DHN_barcode)
network_file_name_heating = "Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DHN_barcode),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
if DCN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_cooling = "Network_summary_result_all.csv"
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
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 = "Network_summary_result_none.csv"
Q_cooling_max_W = 0
else:
# Run the substation and distribution routines
substation.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
summarize_network.network_main(locator, total_demand, building_names,
config, gv, DCN_barcode)
network_file_name_cooling = "Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"
]).values
Q_cooling_max_W = Q_DCNf_W.max()
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)
# Modify the individual with the extra GHP constraint
try:
check.GHPCheck(individual, locator, Q_heating_nom_W, gv)
except:
print "No GHP constraint check possible \n"
# Export to context
individual_number = calc_individual_number(locator)
master_to_slave_vars = evaluation.calc_master_to_slave_variables(
individual, Q_heating_max_W, Q_cooling_max_W, building_names,
individual_number, GENERATION_NUMBER)
master_to_slave_vars.network_data_file_heating = network_file_name_heating
master_to_slave_vars.network_data_file_cooling = network_file_name_cooling
master_to_slave_vars.total_buildings = len(building_names)
if master_to_slave_vars.number_of_buildings_connected_heating > 1:
if DHN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DHN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DHN_barcode)
if master_to_slave_vars.number_of_buildings_connected_cooling > 1:
if DCN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DCN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DCN_barcode)
costs_storage_USD, GHG_storage_tonCO2, PEN_storage_MJoil = storage_main.storage_optimization(
locator, master_to_slave_vars, lca, prices, config)
costs_USD += costs_storage_USD
GHG_tonCO2 += GHG_storage_tonCO2
PEN_MJoil += PEN_storage_MJoil
# slave optimization of heating networks
if config.district_heating_network:
if DHN_barcode.count("1") > 0:
(PEN_heating_MJoil, GHG_heating_tonCO2, costs_heating_USD,
Q_uncovered_design_W, Q_uncovered_annual_W
) = heating_main.heating_calculations_of_DH_buildings(
locator, master_to_slave_vars, gv, config, prices, lca)
else:
GHG_heating_tonCO2 = 0.0
costs_heating_USD = 0.0
PEN_heating_MJoil = 0.0
else:
GHG_heating_tonCO2 = 0.0
costs_heating_USD = 0.0
PEN_heating_MJoil = 0.0
costs_USD += costs_heating_USD
GHG_tonCO2 += GHG_heating_tonCO2
PEN_MJoil += PEN_heating_MJoil
# slave optimization of cooling networks
if gv.ZernezFlag == 1:
costs_cooling_USD, GHG_cooling_tonCO2, PEN_cooling_MJoil = 0.0, 0.0, 0.0
elif config.district_cooling_network and DCN_barcode.count("1") > 0:
reduced_timesteps_flag = config.supply_system_simulation.reduced_timesteps
(costs_cooling_USD, GHG_cooling_tonCO2, PEN_cooling_MJoil
) = cooling_main.cooling_calculations_of_DC_buildings(
locator, master_to_slave_vars, network_features, gv, prices, lca,
config, reduced_timesteps_flag)
# if reduced_timesteps_flag:
# # reduced timesteps simulation for a month (May)
# coolCosts = coolCosts * (8760/(3624/2880))
# coolCO2 = coolCO2 * (8760/(3624/2880))
# coolPrim = coolPrim * (8760/(3624/2880))
# # FIXME: check results
else:
costs_cooling_USD, GHG_cooling_tonCO2, PEN_cooling_MJoil = 0.0, 0.0, 0.0
# District Electricity Calculations
costs_electricity_USD, GHG_electricity_tonCO2, PEN_electricity_MJoil = electricity_main.electricity_calculations_of_all_buildings(
DHN_barcode, DCN_barcode, locator, master_to_slave_vars,
network_features, gv, prices, lca, config)
costs_USD += costs_electricity_USD
GHG_tonCO2 += GHG_electricity_tonCO2
PEN_MJoil += PEN_electricity_MJoil
natural_gas_main.natural_gas_imports(master_to_slave_vars, locator, config)
# print "Add extra costs"
# add costs of disconnected buildings (best configuration)
(costs_additional_USD,
GHG_additional_tonCO2, PEN_additional_MJoil) = cost_model.addCosts(
building_names, locator, master_to_slave_vars, Q_uncovered_design_W,
Q_uncovered_annual_W, solar_features, network_features, gv, config,
prices, lca)
costs_USD += costs_additional_USD
GHG_tonCO2 += GHG_additional_tonCO2
PEN_MJoil += PEN_additional_MJoil
costs_USD = (np.float64(costs_USD) / 1e6).round(2) # $ to Mio$
GHG_tonCO2 = (np.float64(GHG_tonCO2) / 1e6).round(2) # kg to kilo-ton
PEN_MJoil = (np.float64(PEN_MJoil) / 1e6).round(2) # MJ to TJ
# add electricity costs corresponding to
# print ('Additional costs = ' + str(addCosts))
# print ('Additional CO2 = ' + str(addCO2))
# print ('Additional prim = ' + str(addPrim))
print('Total annualized costs [USD$(2015) Mio/yr] = ' + str(costs_USD))
print('Green house gas emission [kton-CO2/yr] = ' + str(GHG_tonCO2))
print('Primary energy [TJ-oil-eq/yr] = ' + str(PEN_MJoil))
results = {
'TAC_Mio_per_yr': [costs_USD.round(2)],
'CO2_kton_per_yr': [GHG_tonCO2.round(2)],
'Primary_Energy_TJ_per_yr': [PEN_MJoil.round(2)]
}
results_df = pd.DataFrame(results)
results_path = os.path.join(
locator.get_optimization_slave_results_folder(GENERATION_NUMBER),
'ind_' + str(individual_number) + '_results.csv')
results_df.to_csv(results_path)
with open(locator.get_optimization_checkpoint_initial(), "wb") as fp:
pop = []
g = GENERATION_NUMBER
epsInd = []
invalid_ind = []
fitnesses = []
capacities = []
disconnected_capacities = []
halloffame = []
halloffame_fitness = []
euclidean_distance = []
spread = []
cp = dict(population=pop,
generation=g,
epsIndicator=epsInd,
testedPop=invalid_ind,
population_fitness=fitnesses,
capacities=capacities,
disconnected_capacities=disconnected_capacities,
halloffame=halloffame,
halloffame_fitness=halloffame_fitness,
euclidean_distance=euclidean_distance,
spread=spread)
json.dump(cp, fp)
return costs_USD, GHG_tonCO2, PEN_MJoil, master_to_slave_vars, individual
def supply_calculation(individual, building_names, total_demand, locator,
extra_costs, extra_CO2, extra_primary_energy,
solar_features, network_features, gv, config, prices,
lca):
"""
This function evaluates one supply system configuration of the case study.
:param individual: a list that indicates the supply system configuration
:type individual: list
:param building_names: names of all building in the district
:type building_names: ndarray
:param locator:
:param extra_costs: cost of decentralized supply systems
:param extra_CO2: CO2 emission of decentralized supply systems
:param extra_primary_energy: Primary energy of decentralized supply systems
:param solar_features: Energy production potentials of solar technologies, including area of installed panels and annual production
:type solar_features: dict
:param network_features: hourly network operating conditions (thermal/pressure losses) and capital costs
:type network_features: dict
:param gv:
:param config:
:param prices:
:return:
"""
individual = evaluation.check_invalid(individual, len(building_names),
config)
# Initialize objective functions costs, CO2 and primary energy
costs = 0
CO2 = extra_CO2
prim = extra_primary_energy
QUncoveredDesign = 0
QUncoveredAnnual = 0
# Create the string representation of the individual
DHN_barcode, DCN_barcode, DHN_configuration, DCN_configuration = sFn.individual_to_barcode(
individual, building_names)
# read the total loads from buildings connected to thermal networks
if DHN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_heating = "Network_summary_result_all.csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
elif DHN_barcode.count("1") == 0:
network_file_name_heating = "Network_summary_result_all.csv"
Q_heating_max_W = 0
else:
# Run the substation and distribution routines
sMain.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
nM.network_main(locator, total_demand, building_names, config, gv,
DHN_barcode)
network_file_name_heating = "Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DHN_barcode),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
if DCN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_cooling = "Network_summary_result_all.csv"
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
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 = "Network_summary_result_none.csv"
Q_cooling_max_W = 0
else:
# Run the substation and distribution routines
sMain.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
nM.network_main(locator, total_demand, building_names, config, gv,
DCN_barcode)
network_file_name_cooling = "Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"
]).values
Q_cooling_max_W = Q_DCNf_W.max()
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)
# Modify the individual with the extra GHP constraint
try:
cCheck.GHPCheck(individual, locator, Q_heating_nom_W, gv)
except:
print "No GHP constraint check possible \n"
# Export to context
individual_number = calc_individual_number(locator)
master_to_slave_vars = evaluation.calc_master_to_slave_variables(
individual, Q_heating_max_W, Q_cooling_max_W, building_names,
individual_number, GENERATION_NUMBER)
master_to_slave_vars.network_data_file_heating = network_file_name_heating
master_to_slave_vars.network_data_file_cooling = network_file_name_cooling
master_to_slave_vars.total_buildings = len(building_names)
if master_to_slave_vars.number_of_buildings_connected_heating > 1:
if DHN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DHN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DHN_barcode)
if master_to_slave_vars.number_of_buildings_connected_cooling > 1:
if DCN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DCN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DCN_barcode)
# slave optimization of heating networks
if config.optimization.isheating:
if DHN_barcode.count("1") > 0:
(slavePrim, slaveCO2, slaveCosts, QUncoveredDesign,
QUncoveredAnnual) = sM.slave_main(locator, master_to_slave_vars,
solar_features, gv, config,
prices)
else:
slaveCO2 = 0
slaveCosts = 0
slavePrim = 0
else:
slaveCO2 = 0
slaveCosts = 0
slavePrim = 0
costs += slaveCosts
CO2 += slaveCO2
prim += slavePrim
# slave optimization of cooling networks
if gv.ZernezFlag == 1:
coolCosts, coolCO2, coolPrim = 0, 0, 0
elif config.optimization.iscooling and DCN_barcode.count("1") > 0:
reduced_timesteps_flag = config.supply_system_simulation.reduced_timesteps
(coolCosts, coolCO2,
coolPrim) = coolMain.coolingMain(locator, master_to_slave_vars,
network_features, gv, prices, lca,
config, reduced_timesteps_flag)
# if reduced_timesteps_flag:
# # reduced timesteps simulation for a month (May)
# coolCosts = coolCosts * (8760/(3624/2880))
# coolCO2 = coolCO2 * (8760/(3624/2880))
# coolPrim = coolPrim * (8760/(3624/2880))
# # FIXME: check results
else:
coolCosts, coolCO2, coolPrim = 0, 0, 0
# print "Add extra costs"
# add costs of disconnected buildings (best configuration)
(addCosts, addCO2,
addPrim) = eM.addCosts(DHN_barcode, DCN_barcode, building_names, locator,
master_to_slave_vars, QUncoveredDesign,
QUncoveredAnnual, solar_features, network_features,
gv, config, prices, lca)
# recalculate the addCosts by substracting the decentralized costs and add back to corresponding supply system
Cost_diff, CO2_diff, Prim_diff = calc_decentralized_building_costs(
config, locator, master_to_slave_vars, DHN_barcode, DCN_barcode,
building_names)
addCosts = addCosts + Cost_diff
addCO2 = addCO2 + CO2_diff
addPrim = addPrim + Prim_diff
# add Capex and Opex of PV
data_electricity = pd.read_csv(
os.path.join(
locator.
get_optimization_slave_electricity_activation_pattern_cooling(
individual_number, GENERATION_NUMBER)))
total_area_for_pv = data_electricity['Area_PV_m2'].max()
# remove the area installed with solar collectors
sc_installed_area = 0
if config.supply_system_simulation.decentralized_systems == 'Single-effect Absorption Chiller':
for (index, building_name) in zip(DCN_barcode, building_names):
if index == "0":
sc_installed_area = sc_installed_area + pd.read_csv(
locator.PV_results(building_name))['Area_PV_m2'].max()
pv_installed_area = total_area_for_pv - sc_installed_area
Capex_a_PV, Opex_fixed_PV = calc_Cinv_pv(pv_installed_area, locator,
config)
pv_annual_production_kWh = (data_electricity['E_PV_W'].sum()) / 1000
# electricity calculations
data_network_electricity = pd.read_csv(
os.path.join(
locator.
get_optimization_slave_electricity_activation_pattern_cooling(
individual_number, GENERATION_NUMBER)))
data_cooling = pd.read_csv(
os.path.join(
locator.get_optimization_slave_cooling_activation_pattern(
individual_number, GENERATION_NUMBER)))
total_demand = pd.read_csv(locator.get_total_demand())
building_names = total_demand.Name.values
total_electricity_demand_W = data_network_electricity['E_total_req_W']
E_decentralized_appliances_W = np.zeros(8760)
for i, name in zip(
DCN_barcode, building_names
): # adding the electricity demand from the decentralized buildings
if i is '0':
building_demand = pd.read_csv(locator.get_demand_results_folder() +
'//' + name + ".csv",
usecols=['E_sys_kWh'])
E_decentralized_appliances_W += building_demand['E_sys_kWh'] * 1000
total_electricity_demand_W = total_electricity_demand_W.add(
E_decentralized_appliances_W)
E_for_hot_water_demand_W = np.zeros(8760)
for i, name in zip(
DCN_barcode, building_names
): # adding the electricity demand for hot water from all buildings
building_demand = pd.read_csv(locator.get_demand_results_folder() +
'//' + name + ".csv",
usecols=['E_ww_kWh'])
E_for_hot_water_demand_W += building_demand['E_ww_kWh'] * 1000
total_electricity_demand_W = total_electricity_demand_W.add(
E_for_hot_water_demand_W)
# Electricity of Energy Systems
lca = lca_calculations(locator, config)
E_VCC_W = data_cooling['Opex_var_VCC'] / lca.ELEC_PRICE
E_VCC_backup_W = data_cooling['Opex_var_VCC_backup'] / lca.ELEC_PRICE
E_ACH_W = data_cooling['Opex_var_ACH'] / lca.ELEC_PRICE
E_CT_W = abs(data_cooling['Opex_var_CT']) / lca.ELEC_PRICE
total_electricity_demand_W = total_electricity_demand_W.add(E_VCC_W)
total_electricity_demand_W = total_electricity_demand_W.add(E_VCC_backup_W)
total_electricity_demand_W = total_electricity_demand_W.add(E_ACH_W)
total_electricity_demand_W = total_electricity_demand_W.add(E_CT_W)
E_from_CHP_W = data_network_electricity[
'E_CHP_to_directload_W'] + data_network_electricity['E_CHP_to_grid_W']
E_from_PV_W = data_network_electricity[
'E_PV_to_directload_W'] + data_network_electricity['E_PV_to_grid_W']
E_CHP_to_directload_W = np.zeros(8760)
E_CHP_to_grid_W = np.zeros(8760)
E_PV_to_directload_W = np.zeros(8760)
E_PV_to_grid_W = np.zeros(8760)
E_from_grid_W = np.zeros(8760)
# modify simulation timesteps
if reduced_timesteps_flag == False:
start_t = 0
stop_t = 8760
else:
# timesteps in May
start_t = 2880
stop_t = 3624
timesteps = range(start_t, stop_t)
for hour in timesteps:
E_hour_W = total_electricity_demand_W[hour]
if E_hour_W > 0:
if E_from_PV_W[hour] > E_hour_W:
E_PV_to_directload_W[hour] = E_hour_W
E_PV_to_grid_W[hour] = E_from_PV_W[
hour] - total_electricity_demand_W[hour]
E_hour_W = 0
else:
E_hour_W = E_hour_W - E_from_PV_W[hour]
E_PV_to_directload_W[hour] = E_from_PV_W[hour]
if E_from_CHP_W[hour] > E_hour_W:
E_CHP_to_directload_W[hour] = E_hour_W
E_CHP_to_grid_W[hour] = E_from_CHP_W[hour] - E_hour_W
E_hour_W = 0
else:
E_hour_W = E_hour_W - E_from_CHP_W[hour]
E_CHP_to_directload_W[hour] = E_from_CHP_W[hour]
E_from_grid_W[hour] = E_hour_W
date = data_network_electricity.DATE.values
results = pd.DataFrame(
{
"DATE": date,
"E_total_req_W": total_electricity_demand_W,
"E_from_grid_W": E_from_grid_W,
"E_VCC_W": E_VCC_W,
"E_VCC_backup_W": E_VCC_backup_W,
"E_ACH_W": E_ACH_W,
"E_CT_W": E_CT_W,
"E_PV_to_directload_W": E_PV_to_directload_W,
"E_CHP_to_directload_W": E_CHP_to_directload_W,
"E_CHP_to_grid_W": E_CHP_to_grid_W,
"E_PV_to_grid_W": E_PV_to_grid_W,
"E_for_hot_water_demand_W": E_for_hot_water_demand_W,
"E_decentralized_appliances_W": E_decentralized_appliances_W,
"E_total_to_grid_W_negative": -E_PV_to_grid_W - E_CHP_to_grid_W
}
) # let's keep this negative so it is something exported, we can use it in the graphs of likelihood
if reduced_timesteps_flag:
reduced_el_costs = ((results['E_from_grid_W'].sum() +
results['E_total_to_grid_W_negative'].sum()) *
lca.ELEC_PRICE)
electricity_costs = reduced_el_costs * (8760 / (stop_t - start_t))
else:
electricity_costs = ((results['E_from_grid_W'].sum() +
results['E_total_to_grid_W_negative'].sum()) *
lca.ELEC_PRICE)
# emission from data
data_emissions = pd.read_csv(
os.path.join(
locator.get_optimization_slave_investment_cost_detailed(
individual_number, GENERATION_NUMBER)))
update_PV_emission = abs(
2 * data_emissions['CO2_PV_disconnected']).values[0] # kg-CO2
update_PV_primary = abs(
2 * data_emissions['Eprim_PV_disconnected']).values[0] # MJ oil-eq
costs += addCosts + coolCosts + electricity_costs + Capex_a_PV + Opex_fixed_PV
CO2 = CO2 + addCO2 + coolCO2 - update_PV_emission
prim = prim + addPrim + coolPrim - update_PV_primary
# Converting costs into float64 to avoid longer values
costs = (np.float64(costs) / 1e6).round(2) # $ to Mio$
CO2 = (np.float64(CO2) / 1e6).round(2) # kg to kilo-ton
prim = (np.float64(prim) / 1e6).round(2) # MJ to TJ
# add electricity costs corresponding to
# print ('Additional costs = ' + str(addCosts))
# print ('Additional CO2 = ' + str(addCO2))
# print ('Additional prim = ' + str(addPrim))
print('Total annualized costs [USD$(2015) Mio/yr] = ' + str(costs))
print('Green house gas emission [kton-CO2/yr] = ' + str(CO2))
print('Primary energy [TJ-oil-eq/yr] = ' + str(prim))
results = {
'TAC_Mio_per_yr': [costs.round(2)],
'CO2_kton_per_yr': [CO2.round(2)],
'Primary_Energy_TJ_per_yr': [prim.round(2)]
}
results_df = pd.DataFrame(results)
results_path = os.path.join(
locator.get_optimization_slave_results_folder(GENERATION_NUMBER),
'ind_' + str(individual_number) + '_results.csv')
results_df.to_csv(results_path)
with open(locator.get_optimization_checkpoint_initial(), "wb") as fp:
pop = []
g = GENERATION_NUMBER
epsInd = []
invalid_ind = []
fitnesses = []
capacities = []
disconnected_capacities = []
halloffame = []
halloffame_fitness = []
euclidean_distance = []
spread = []
cp = dict(population=pop,
generation=g,
epsIndicator=epsInd,
testedPop=invalid_ind,
population_fitness=fitnesses,
capacities=capacities,
disconnected_capacities=disconnected_capacities,
halloffame=halloffame,
halloffame_fitness=halloffame_fitness,
euclidean_distance=euclidean_distance,
spread=spread)
json.dump(cp, fp)
return costs, CO2, prim, master_to_slave_vars, individual
def evaluation_main(individual, building_names, locator, extraCosts, extraCO2,
extraPrim, solar_features, network_features, gv, config,
prices, lca, ind_num, gen):
"""
This function evaluates an individual
:param individual: list with values of the individual
:param building_names: list with names of buildings
:param locator: locator class
:param extraCosts: costs calculated before optimization of specific energy services
(process heat and electricity)
:param extraCO2: green house gas emissions calculated before optimization of specific energy services
(process heat and electricity)
:param extraPrim: primary energy calculated before optimization ofr specific energy services
(process heat and electricity)
:param solar_features: solar features call to class
:param network_features: network features call to class
:param gv: global variables class
:param optimization_constants: class containing constants used in optimization
:param config: configuration file
:param prices: class of prices used in optimization
:type individual: list
:type building_names: list
:type locator: string
:type extraCosts: float
:type extraCO2: float
:type extraPrim: float
:type solar_features: class
:type network_features: class
:type gv: class
:type optimization_constants: class
:type config: class
:type prices: class
:return: Resulting values of the objective function. costs, CO2, prim
:rtype: tuple
"""
# Check the consistency of the individual or create a new one
individual = check_invalid(individual, len(building_names), config)
# Initialize objective functions costs, CO2 and primary energy
costs = extraCosts
CO2 = extraCO2
prim = extraPrim
QUncoveredDesign = 0
QUncoveredAnnual = 0
# Create the string representation of the individual
DHN_barcode, DCN_barcode, DHN_configuration, DCN_configuration = sFn.individual_to_barcode(
individual, building_names)
if DHN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_heating = "Network_summary_result_all.csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
elif DHN_barcode.count("1") == 0:
network_file_name_heating = "Network_summary_result_all.csv"
Q_heating_max_W = 0
else:
network_file_name_heating = "Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
if not os.path.exists(
locator.get_optimization_network_results_summary(DHN_barcode)):
total_demand = sFn.createTotalNtwCsv(DHN_barcode, locator)
building_names = total_demand.Name.values
# Run the substation and distribution routines
sMain.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
nM.network_main(locator, total_demand, building_names, config, gv,
DHN_barcode)
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DHN_barcode),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
if DCN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_cooling = "Network_summary_result_all.csv"
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
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 = "Network_summary_result_all.csv"
Q_cooling_max_W = 0
else:
network_file_name_cooling = "Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
if not os.path.exists(
locator.get_optimization_network_results_summary(DCN_barcode)):
total_demand = sFn.createTotalNtwCsv(DCN_barcode, locator)
building_names = total_demand.Name.values
# Run the substation and distribution routines
sMain.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
nM.network_main(locator, total_demand, building_names, config, gv,
DCN_barcode)
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"
]).values
Q_cooling_max_W = Q_DCNf_W.max()
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)
# Modify the individual with the extra GHP constraint
try:
cCheck.GHPCheck(individual, locator, Q_heating_nom_W, gv)
except:
print "No GHP constraint check possible \n"
# Export to context
master_to_slave_vars = calc_master_to_slave_variables(
individual, Q_heating_max_W, Q_cooling_max_W, building_names, ind_num,
gen)
master_to_slave_vars.network_data_file_heating = network_file_name_heating
master_to_slave_vars.network_data_file_cooling = network_file_name_cooling
master_to_slave_vars.total_buildings = len(building_names)
if master_to_slave_vars.number_of_buildings_connected_heating > 1:
if DHN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DHN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DHN_barcode)
if master_to_slave_vars.number_of_buildings_connected_cooling > 1:
if DCN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DCN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DCN_barcode)
if config.optimization.isheating:
if DHN_barcode.count("1") > 0:
(slavePrim, slaveCO2, slaveCosts, QUncoveredDesign,
QUncoveredAnnual) = sM.slave_main(locator, master_to_slave_vars,
solar_features, gv, config,
prices, lca)
else:
slaveCO2 = 0
slaveCosts = 0
slavePrim = 0
else:
slaveCO2 = 0
slaveCosts = 0
slavePrim = 0
costs += slaveCosts
CO2 += slaveCO2
prim += slavePrim
if gv.ZernezFlag == 1:
coolCosts, coolCO2, coolPrim = 0, 0, 0
elif config.optimization.iscooling:
reduced_timesteps_flag = False
(coolCosts, coolCO2,
coolPrim) = coolMain.coolingMain(locator, master_to_slave_vars,
network_features, gv, prices, lca,
config, reduced_timesteps_flag)
else:
coolCosts, coolCO2, coolPrim = 0, 0, 0
print "Add extra costs"
(addCosts, addCO2,
addPrim) = eM.addCosts(DHN_barcode, DCN_barcode, building_names, locator,
master_to_slave_vars, QUncoveredDesign,
QUncoveredAnnual, solar_features, network_features,
gv, config, prices, lca)
costs += addCosts + coolCosts
CO2 += addCO2 + coolCO2
prim += addPrim + coolPrim
# Converting costs into float64 to avoid longer values
costs = np.float64(costs)
CO2 = np.float64(CO2)
prim = np.float64(prim)
print('Total costs = ' + str(costs))
print('Total CO2 = ' + str(CO2))
print('Total prim = ' + str(prim))
return costs, CO2, prim, master_to_slave_vars, individual
def evaluation_main(individual, building_names, locator, extraCosts, extraCO2,
extraPrim, solar_features, network_features, gv):
"""
This function evaluates an individual
:param individual: list with values of the individual
:param building_names: list with names of buildings
:param locator: locator class
:param extraCosts: costs calculated before optimization of specific energy services
(process heat and electricity)
:param extraCO2: green house gas emissions calculated before optimization of specific energy services
(process heat and electricity)
:param extraPrim: primary energy calculated before optimization ofr specific energy services
(process heat and electricity)
:param solar_features: solar features call to class
:param network_features: network features call to class
:param gv: global variables class
:type individual: list
:type building_names: list
:type locator: string
:type extraCosts: float
:type extraCO2: float
:type extraPrim: float
:type solar_features: class
:type network_features: class
:type gv: class
:return: Resulting values of the objective function. costs, CO2, prim
:rtype: tuple
"""
# Check the consistency of the individual or create a new one
individual = check_invalid(individual, len(building_names), gv)
# Initialize objective functions costs, CO2 and primary energy
costs = extraCosts
CO2 = extraCO2
prim = extraPrim
QUncoveredDesign = 0
QUncoveredAnnual = 0
# Create the string representation of the individual
individual_barcode = sFn.individual_to_barcode(individual, gv)
if individual_barcode.count("0") == 0:
network_file_name = "Network_summary_result_all.csv"
else:
network_file_name = "Network_summary_result_" + individual_barcode + ".csv"
if individual_barcode.count("1") > 0:
Qheatmax = sFn.calcQmax(
network_file_name,
locator.get_optimization_network_results_folder(), gv)
else:
Qheatmax = 0
print Qheatmax, "Qheatmax in distribution"
Qnom = Qheatmax * (1 + gv.Qmargin_ntw)
# Modify the individual with the extra GHP constraint
try:
cCheck.GHPCheck(individual, locator, Qnom, gv)
print "GHP constraint checked \n"
except:
print "No GHP constraint check possible \n"
# Export to context
master_to_slave_vars = calc_master_to_slave_variables(
individual, Qheatmax, locator, gv)
master_to_slave_vars.NETWORK_DATA_FILE = network_file_name
if master_to_slave_vars.nBuildingsConnected > 1:
if individual_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(individual_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
individual_barcode)
if individual_barcode.count("1") > 0:
print "Slave routine on", master_to_slave_vars.configKey
(slavePrim, slaveCO2, slaveCosts, QUncoveredDesign,
QUncoveredAnnual) = sM.slave_main(locator, master_to_slave_vars,
solar_features, gv)
costs += slaveCosts
CO2 += slaveCO2
prim += slavePrim
else:
print "No buildings connected to distribution \n"
print "Add extra costs"
(addCosts, addCO2,
addPrim) = eM.addCosts(individual_barcode, building_names, locator,
master_to_slave_vars, QUncoveredDesign,
QUncoveredAnnual, solar_features, network_features,
gv)
print addCosts, addCO2, addPrim, "addCosts, addCO2, addPrim \n"
if gv.ZernezFlag == 1:
coolCosts, coolCO2, coolPrim = 0, 0, 0
else:
(coolCosts, coolCO2, coolPrim) = coolMain.coolingMain(
locator, master_to_slave_vars.configKey, network_features,
master_to_slave_vars.WasteServersHeatRecovery, gv)
print coolCosts, coolCO2, coolPrim, "coolCosts, coolCO2, coolPrim \n"
costs += addCosts + coolCosts
CO2 += addCO2 + coolCO2
prim += addPrim + coolPrim
print "Evaluation of", master_to_slave_vars.configKey, "done"
print costs, CO2, prim, " = costs, CO2, prim \n"
return costs, CO2, prim
def calc_master_to_slave_variables(individual, Qmax, locator, gv):
"""
This function reads the list encoding a configuration and implements the corresponding
for the slave routine's to use
:param individual: list with inidividual
:param Qmax: peak heating demand
:param locator: locator class
:param gv: global variables class
:type individual: list
:type Qmax: float
:type locator: string
:type gv: class
:return: master_to_slave_vars : class MasterSlaveVariables
:rtype: class
"""
# initialise class storing dynamic variables transfered from master to slave optimization
master_to_slave_vars = slave_data.SlaveData()
master_to_slave_vars.configKey = "".join(str(e)[0:4] for e in individual)
individual_barcode = sFn.individual_to_barcode(individual, gv)
master_to_slave_vars.nBuildingsConnected = individual_barcode.count(
"1") # counting the number of buildings connected
Qnom = Qmax * (1 + gv.Qmargin_ntw)
# Heating systems
#CHP units with NG & furnace with biomass wet
if individual[0] == 1 or individual[0] == 3:
if gv.Furnace_allowed == 1:
master_to_slave_vars.Furnace_on = 1
master_to_slave_vars.Furnace_Q_max = max(individual[1] * Qnom,
gv.QminShare * Qnom)
print master_to_slave_vars.Furnace_Q_max, "Furnace wet"
master_to_slave_vars.Furn_Moist_type = "wet"
elif gv.CC_allowed == 1:
master_to_slave_vars.CC_on = 1
master_to_slave_vars.CC_GT_SIZE = max(individual[1] * Qnom * 1.3,
gv.QminShare * Qnom * 1.3)
#1.3 is the conversion factor between the GT_Elec_size NG and Q_DHN
print master_to_slave_vars.CC_GT_SIZE, "CC NG"
master_to_slave_vars.gt_fuel = "NG"
#CHP units with BG& furnace with biomass dry
if individual[0] == 2 or individual[0] == 4:
if gv.Furnace_allowed == 1:
master_to_slave_vars.Furnace_on = 1
master_to_slave_vars.Furnace_Q_max = max(individual[1] * Qnom,
gv.QminShare * Qnom)
print master_to_slave_vars.Furnace_Q_max, "Furnace dry"
master_to_slave_vars.Furn_Moist_type = "dry"
elif gv.CC_allowed == 1:
master_to_slave_vars.CC_on = 1
master_to_slave_vars.CC_GT_SIZE = max(individual[1] * Qnom * 1.5,
gv.QminShare * Qnom * 1.5)
#1.5 is the conversion factor between the GT_Elec_size BG and Q_DHN
print master_to_slave_vars.CC_GT_SIZE, "CC BG"
master_to_slave_vars.gt_fuel = "BG"
# Base boiler NG
if individual[2] == 1:
master_to_slave_vars.Boiler_on = 1
master_to_slave_vars.Boiler_Q_max = max(individual[3] * Qnom,
gv.QminShare * Qnom)
print master_to_slave_vars.Boiler_Q_max, "Boiler base NG"
master_to_slave_vars.BoilerType = "NG"
# Base boiler BG
if individual[2] == 2:
master_to_slave_vars.Boiler_on = 1
master_to_slave_vars.Boiler_Q_max = max(individual[3] * Qnom,
gv.QminShare * Qnom)
print master_to_slave_vars.Boiler_Q_max, "Boiler base BG"
master_to_slave_vars.BoilerType = "BG"
# peak boiler NG
if individual[4] == 1:
master_to_slave_vars.BoilerPeak_on = 1
master_to_slave_vars.BoilerPeak_Q_max = max(individual[5] * Qnom,
gv.QminShare * Qnom)
print master_to_slave_vars.BoilerPeak_Q_max, "Boiler peak NG"
master_to_slave_vars.BoilerPeakType = "NG"
# peak boiler BG
if individual[4] == 2:
master_to_slave_vars.BoilerPeak_on = 1
master_to_slave_vars.BoilerPeak_Q_max = max(individual[5] * Qnom,
gv.QminShare * Qnom)
print master_to_slave_vars.BoilerPeak_Q_max, "Boiler peak BG"
master_to_slave_vars.BoilerPeakType = "BG"
# lake - heat pump
if individual[6] == 1 and gv.HPLake_allowed == 1:
master_to_slave_vars.HP_Lake_on = 1
master_to_slave_vars.HPLake_maxSize = max(individual[7] * Qnom,
gv.QminShare * Qnom)
print master_to_slave_vars.HPLake_maxSize, "Lake"
# sewage - heatpump
if individual[8] == 1 and gv.HPSew_allowed == 1:
master_to_slave_vars.HP_Sew_on = 1
master_to_slave_vars.HPSew_maxSize = max(individual[9] * Qnom,
gv.QminShare * Qnom)
print master_to_slave_vars.HPSew_maxSize, "Sewage"
# Gwound source- heatpump
if individual[10] == 1 and gv.GHP_allowed == 1:
master_to_slave_vars.GHP_on = 1
GHP_Qmax = max(individual[11] * Qnom, gv.QminShare * Qnom)
master_to_slave_vars.GHP_number = GHP_Qmax / gv.GHP_HmaxSize
print GHP_Qmax, "GHP"
# heat recovery servers and compresor
irank = gv.nHeat * 2
master_to_slave_vars.WasteServersHeatRecovery = individual[irank]
master_to_slave_vars.WasteCompressorHeatRecovery = individual[irank + 1]
# Solar systems
roof_area = np.array(
pd.read_csv(locator.get_total_demand(), usecols=["Aroof_m2"]))
areaAvail = 0
totalArea = 0
for i in range(len(individual_barcode)):
index = individual_barcode[i]
if index == "1":
areaAvail += roof_area[i][0]
totalArea += roof_area[i][0]
shareAvail = areaAvail / totalArea
irank = gv.nHeat * 2 + gv.nHR
master_to_slave_vars.SOLAR_PART_PV = max(
individual[irank] * individual[irank + 1] * individual[irank + 6] *
shareAvail, 0)
print master_to_slave_vars.SOLAR_PART_PV, "PV"
master_to_slave_vars.SOLAR_PART_PVT = max(
individual[irank + 2] * individual[irank + 3] * individual[irank + 6] *
shareAvail, 0)
print master_to_slave_vars.SOLAR_PART_PVT, "PVT"
master_to_slave_vars.SOLAR_PART_SC = max(
individual[irank + 4] * individual[irank + 5] * individual[irank + 6] *
shareAvail, 0)
print master_to_slave_vars.SOLAR_PART_SC, "SC"
return master_to_slave_vars