def calc_pareto_Qhp(locator, total_demand, gv):
"""
This function calculates the contribution to the pareto optimal results of process heating,
:param locator: locator class
:param total_demand: dataframe with building demand
:param gv: global variables
:type locator: class
:type total_demand: class
:type gv: class
:return: hpCosts, hpCO2, hpPrim
:rtype: tuple
"""
hpCosts = 0
hpCO2 = 0
hpPrim = 0
if total_demand["Qhprof_MWhyr"].sum() > 0:
df = total_demand[total_demand.Qhprof_kWh != 0]
for name in df.Name:
# Extract process heat needs
Qhprof = pd.read_csv(locator.get_demand_results_file(name),
usecols=["Qhprof_kWh"]).Qhprof_kWh.values
Qnom = 0
Qannual = 0
# Operation costs / CO2 / Prim
for i in range(8760):
Qgas = Qhprof[
i] * 1E3 / gv.Boiler_eta_hp # [Wh] Assumed 0.9 efficiency
if Qgas < Qnom:
Qnom = Qgas * (1 + gv.Qmargin_Disc)
Qannual += Qgas
hpCosts += Qgas * gv.NG_PRICE # [CHF]
hpCO2 += Qgas * 3600E-6 * gv.NG_BACKUPBOILER_TO_CO2_STD # [kg CO2]
hpPrim += Qgas * 3600E-6 * gv.NG_BACKUPBOILER_TO_OIL_STD # [MJ-oil-eq]
# Investment costs
hpCosts += boilers.calc_Cinv_boiler(Qnom, Qannual, gv)
else:
hpCosts = hpCO2 = hpPrim = 0
return hpCosts, hpCO2, hpPrim
def addCosts(indCombi, buildList, locator, dicoSupply, Q_uncovered_design_W,
Q_uncovered_annual_W, solarFeat, ntwFeat, gv):
"""
Computes additional costs / GHG emisions / primary energy needs
for the individual
addCosts = additional costs
addCO2 = GHG emissions
addPrm = primary energy needs
:param indCombi: parameter indicating if the building is connected or not
:param buildList: list of buildings in the district
:param locator: input locator set to scenario
:param dicoSupply: class containing the features of a specific individual
:param Q_uncovered_design_W: hourly max of the heating uncovered demand
:param Q_uncovered_annual_W: total heating uncovered
:param solarFeat: solar features
:param ntwFeat: network features
:param gv: global variables
:type indCombi: string
:type buildList: list
:type locator: string
:type dicoSupply: class
:type Q_uncovered_design_W: float
:type Q_uncovered_annual_W: float
:type solarFeat: class
:type ntwFeat: class
:type gv: class
:return: returns the objectives addCosts, addCO2, addPrim
:rtype: tuple
"""
addCosts = 0
addCO2 = 0
addPrim = 0
nBuildinNtw = 0
# Add the features from the disconnected buildings
print "\n COSTS FROM DISCONNECTED BUILDINGS"
os.chdir(locator.get_optimization_disconnected_folder())
CostDiscBuild = 0
CO2DiscBuild = 0
PrimDiscBuild = 0
FurnaceInvCost = 0
CCInvCost = 0
BoilerBInvCost = 0
BoilerPInvCost = 0
HPLakeInvC = 0
HPSewInvC = 0
GHPInvC = 0
PVInvC = 0
SCInvC = 0
PVTInvC = 0
BoilerAddInvC = 0
StorageHEXCost = 0
StorageHPCost = 0
StorageInvC = 0
NetworkCost = 0
SubstHEXCost = 0
PVTHEXCost = 0
SCHEXCost = 0
pumpCosts = 0
GasConnectionInvCost = 0
for (index, building_name) in zip(indCombi, buildList):
if index == "0":
discFileName = "DiscOp_" + building_name + "_result.csv"
df = pd.read_csv(discFileName)
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest["Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
print dfBest["Total Costs [CHF]"].iloc[
0], building_name, "disconnected"
else:
nBuildinNtw += 1
addCosts += CostDiscBuild
addCO2 += CO2DiscBuild
addPrim += PrimDiscBuild
# Add the features for the distribution
if indCombi.count("1") > 0:
os.chdir(locator.get_optimization_slave_results_folder())
print " \n MACHINERY COSTS"
# Add the investment costs of the energy systems
# Furnace
if dicoSupply.Furnace_on == 1:
P_design_W = dicoSupply.Furnace_Q_max
fNameSlavePP = locator.get_optimization_slave_pp_activation_pattern(
dicoSupply.configKey)
dfFurnace = pd.read_csv(fNameSlavePP, usecols=["Q_Furnace_W"])
arrayFurnace_W = np.array(dfFurnace)
Q_annual_W = 0
for i in range(int(np.shape(arrayFurnace_W)[0])):
Q_annual_W += arrayFurnace_W[i][0]
FurnaceInvCost = furnace.calc_Cinv_furnace(P_design_W, Q_annual_W,
gv)
addCosts += FurnaceInvCost
print furnace.calc_Cinv_furnace(P_design_W, Q_annual_W,
gv), " Furnace"
# CC
if dicoSupply.CC_on == 1:
CC_size_W = dicoSupply.CC_GT_SIZE
CCInvCost = chp.calc_Cinv_CCT(CC_size_W, gv)
addCosts += CCInvCost
print chp.calc_Cinv_CCT(CC_size_W, gv), " CC"
# Boiler Base
if dicoSupply.Boiler_on == 1:
Q_design_W = dicoSupply.Boiler_Q_max
fNameSlavePP = locator.get_optimization_slave_pp_activation_pattern(
dicoSupply.configKey)
dfBoilerBase = pd.read_csv(fNameSlavePP,
usecols=["Q_BoilerBase_W"])
arrayBoilerBase_W = np.array(dfBoilerBase)
Q_annual_W = 0
for i in range(int(np.shape(arrayBoilerBase_W)[0])):
Q_annual_W += arrayBoilerBase_W[i][0]
BoilerBInvCost = boiler.calc_Cinv_boiler(Q_design_W, Q_annual_W,
gv)
addCosts += BoilerBInvCost
print boiler.calc_Cinv_boiler(Q_design_W, Q_annual_W,
gv), " Boiler Base "
# Boiler Peak
if dicoSupply.BoilerPeak_on == 1:
Q_design_W = dicoSupply.BoilerPeak_Q_max
fNameSlavePP = locator.get_optimization_slave_pp_activation_pattern(
dicoSupply.configKey)
dfBoilerPeak = pd.read_csv(fNameSlavePP,
usecols=["Q_BoilerPeak_W"])
arrayBoilerPeak_W = np.array(dfBoilerPeak)
Q_annual_W = 0
for i in range(int(np.shape(arrayBoilerPeak_W)[0])):
Q_annual_W += arrayBoilerPeak_W[i][0]
BoilerPInvCost = boiler.calc_Cinv_boiler(Q_design_W, Q_annual_W,
gv)
addCosts += BoilerPInvCost
print boiler.calc_Cinv_boiler(Q_design_W, Q_annual_W,
gv), " Boiler Peak"
# HP Lake
if dicoSupply.HP_Lake_on == 1:
HP_Size_W = dicoSupply.HPLake_maxSize
HPLakeInvC = hp.calc_Cinv_HP(HP_Size_W, gv)
addCosts += HPLakeInvC
print hp.calc_Cinv_HP(HP_Size_W, gv), " HP Lake"
# HP Sewage
if dicoSupply.HP_Sew_on == 1:
HP_Size_W = dicoSupply.HPSew_maxSize
HPSewInvC = hp.calc_Cinv_HP(HP_Size_W, gv)
addCosts += HPSewInvC
print hp.calc_Cinv_HP(HP_Size_W, gv), "HP Sewage"
# GHP
if dicoSupply.GHP_on == 1:
fNameSlavePP = locator.get_optimization_slave_pp_activation_pattern(
dicoSupply.configKey)
dfGHP = pd.read_csv(fNameSlavePP, usecols=["E_GHP_req_W"])
arrayGHP_W = np.array(dfGHP)
GHP_Enom_W = np.amax(arrayGHP_W)
GHPInvC = hp.calc_Cinv_GHP(GHP_Enom_W, gv) * gv.EURO_TO_CHF
addCosts += GHPInvC
print hp.calc_Cinv_GHP(GHP_Enom_W, gv) * gv.EURO_TO_CHF, " GHP"
# Solar technologies
PV_peak_kW = dicoSupply.SOLAR_PART_PV * solarFeat.A_PV_m2 * gv.nPV #kW
PVInvC = pv.calc_Cinv_pv(PV_peak_kW)
addCosts += PVInvC
print pv.calc_Cinv_pv(PV_peak_kW), "PV peak"
SC_area_m2 = dicoSupply.SOLAR_PART_SC * solarFeat.A_SC_m2
SCInvC = stc.calc_Cinv_SC(SC_area_m2, gv)
addCosts += SCInvC
print stc.calc_Cinv_SC(SC_area_m2, gv), "SC area"
PVT_peak_kW = dicoSupply.SOLAR_PART_PVT * solarFeat.A_PVT_m2 * gv.nPVT #kW
PVTInvC = pvt.calc_Cinv_PVT(PVT_peak_kW, gv)
addCosts += PVTInvC
print pvt.calc_Cinv_PVT(PVT_peak_kW, gv), "PVT peak"
# Back-up boiler
BoilerAddInvC = boiler.calc_Cinv_boiler(Q_uncovered_design_W,
Q_uncovered_annual_W, gv)
addCosts += BoilerAddInvC
print boiler.calc_Cinv_boiler(Q_uncovered_design_W,
Q_uncovered_annual_W,
gv), "backup boiler"
# Hex and HP for Heat recovery
print "\n STORAGE PART COSTS"
if dicoSupply.WasteServersHeatRecovery == 1:
df = pd.read_csv(os.path.join(
locator.get_optimization_network_results_folder(),
dicoSupply.NETWORK_DATA_FILE),
usecols=["Qcdata_netw_total_kWh"])
array = np.array(df)
Q_HEX_max_kWh = np.amax(array)
StorageHEXCost += hex.calc_Cinv_HEX(Q_HEX_max_kWh, gv)
print hex.calc_Cinv_HEX(Q_HEX_max_kWh, gv), "Hex for data center"
df = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(
dicoSupply.configKey),
usecols=["HPServerHeatDesignArray_kWh"])
array = np.array(df)
Q_HP_max_kWh = np.amax(array)
StorageHEXCost += hp.calc_Cinv_HP(Q_HP_max_kWh, gv)
print hp.calc_Cinv_HP(Q_HP_max_kWh, gv), "HP for data center"
if dicoSupply.WasteCompressorHeatRecovery == 1:
df = pd.read_csv(os.path.join(
locator.get_optimization_network_results_folder(),
dicoSupply.NETWORK_DATA_FILE),
usecols=["Ecaf_netw_total_kWh"])
array = np.array(df)
Q_HEX_max_kWh = np.amax(array)
StorageHEXCost += hex.calc_Cinv_HEX(Q_HEX_max_kWh, gv)
print hex.calc_Cinv_HEX(Q_HEX_max_kWh,
gv), "Hex for compressed air"
df = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(
dicoSupply.configKey),
usecols=["HPCompAirDesignArray_kWh"])
array = np.array(df)
Q_HP_max_kWh = np.amax(array)
StorageHEXCost += hp.calc_Cinv_HP(Q_HP_max_kWh, gv)
print hp.calc_Cinv_HP(Q_HP_max_kWh, gv), "HP for compressed air"
addCosts += StorageHEXCost
# Heat pump solar to storage
df = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(
dicoSupply.configKey),
usecols=["HPScDesignArray_Wh", "HPpvt_designArray_Wh"])
array = np.array(df)
Q_HP_max_PVT_Wh = np.amax(array[:, 1])
QhpMax_SC_Wh = np.amax(array[:, 0])
StorageHPCost += hp.calc_Cinv_HP(Q_HP_max_PVT_Wh, gv)
print hp.calc_Cinv_HP(Q_HP_max_PVT_Wh, gv), "HP for PVT"
StorageHPCost += hp.calc_Cinv_HP(QhpMax_SC_Wh, gv)
print hp.calc_Cinv_HP(QhpMax_SC_Wh, gv), "HP for SC"
# HP for storage operation
df = pd.read_csv(locator.get_optimization_slave_storage_operation_data(
dicoSupply.configKey),
usecols=[
"E_aux_ch_W", "E_aux_dech_W",
"Q_from_storage_used_W", "Q_to_storage_W"
])
array = np.array(df)
Q_HP_max_storage_W = 0
for i in range(gv.DAYS_IN_YEAR * gv.HOURS_IN_DAY):
if array[i][0] > 0:
Q_HP_max_storage_W = max(Q_HP_max_storage_W,
array[i][3] + array[i][0])
elif array[i][1] > 0:
Q_HP_max_storage_W = max(Q_HP_max_storage_W,
array[i][2] + array[i][1])
StorageHPCost += hp.calc_Cinv_HP(Q_HP_max_storage_W, gv)
addCosts += StorageHPCost
print hp.calc_Cinv_HP(Q_HP_max_storage_W, gv), "HP for storage"
# Storage
df = pd.read_csv(locator.get_optimization_slave_storage_operation_data(
dicoSupply.configKey),
usecols=["Storage_Size_m3"],
nrows=1)
StorageVol_m3 = np.array(df)[0][0]
StorageInvC += storage.calc_Cinv_storage(StorageVol_m3, gv)
addCosts += StorageInvC
print storage.calc_Cinv_storage(StorageVol_m3, gv), "Storage Costs"
# Costs from distribution configuration
print "\n COSTS FROM NETWORK CONFIGURATION"
if gv.ZernezFlag == 1:
NetworkCost += network.calc_Cinv_network_linear(
gv.NetworkLengthZernez, gv) * nBuildinNtw / len(buildList)
else:
NetworkCost += ntwFeat.pipesCosts_DHN * nBuildinNtw / len(
buildList)
addCosts += NetworkCost
print ntwFeat.pipesCosts_DHN * nBuildinNtw / len(
buildList), "Pipes Costs"
# HEX (1 per building in ntw)
for (index, building_name) in zip(indCombi, buildList):
if index == "1":
df = pd.read_csv(
locator.get_optimization_substations_results_file(
building_name),
usecols=["Q_dhw_W", "Q_heating_W"])
subsArray = np.array(df)
Q_max_W = np.amax(subsArray[:, 0] + subsArray[:, 1])
SubstHEXCost += hex.calc_Cinv_HEX(Q_max_W, gv)
print hex.calc_Cinv_HEX(Q_max_W, gv), "Hex", building_name
addCosts += SubstHEXCost
# HEX for solar
roof_area_m2 = np.array(
pd.read_csv(locator.get_total_demand(), usecols=["Aroof_m2"]))
areaAvail = 0
for i in range(len(indCombi)):
index = indCombi[i]
if index == "1":
areaAvail += roof_area_m2[i][0]
for i in range(len(indCombi)):
index = indCombi[i]
if index == "1":
share = roof_area_m2[i][0] / areaAvail
#print share, "solar area share", buildList[i]
Q_max_SC_Wh = solarFeat.Q_nom_SC_Wh * dicoSupply.SOLAR_PART_SC * share
SCHEXCost += hex.calc_Cinv_HEX(Q_max_SC_Wh, gv)
print hex.calc_Cinv_HEX(Q_max_SC_Wh,
gv), "Hex SC", buildList[i]
Q_max_PVT_Wh = solarFeat.Q_nom_PVT_Wh * dicoSupply.SOLAR_PART_PVT * share
PVTHEXCost += hex.calc_Cinv_HEX(Q_max_PVT_Wh, gv)
print hex.calc_Cinv_HEX(Q_max_PVT_Wh,
gv), "Hex PVT", buildList[i]
addCosts += SCHEXCost
addCosts += PVTHEXCost
print addCosts, "addCosts in extraCostsMain"
# Pump operation costs
pumpCosts = pumps.calc_Ctot_pump(
dicoSupply, buildList,
locator.get_optimization_network_results_folder(), ntwFeat, gv)
addCosts += pumpCosts
print pumpCosts, "Pump Operation costs in extraCostsMain\n"
# import gas consumption data from:
if indCombi.count("1") > 0:
# import gas consumption data from:
E_gas_PrimaryDataframe_W = pd.read_csv(
locator.get_optimization_slave_primary_energy_by_source(
dicoSupply.configKey),
usecols=["E_gas_PrimaryPeakPower_W"])
E_gas_primary_peak_power_W = float(np.array(E_gas_PrimaryDataframe_W))
GasConnectionInvCost = ngas.calc_Cinv_gas(E_gas_primary_peak_power_W,
gv)
else:
GasConnectionInvCost = 0.0
addCosts += GasConnectionInvCost
# Save data
results = pd.DataFrame({
"SCInvC": [SCInvC],
"PVTInvC": [PVTInvC],
"BoilerAddInvC": [BoilerAddInvC],
"StorageHEXCost": [StorageHEXCost],
"StorageHPCost": [StorageHPCost],
"StorageInvC": [StorageInvC],
"StorageCostSum": [StorageInvC + StorageHPCost + StorageHEXCost],
"NetworkCost": [NetworkCost],
"SubstHEXCost": [SubstHEXCost],
"DHNInvestCost": [addCosts - CostDiscBuild],
"PVTHEXCost": [PVTHEXCost],
"CostDiscBuild": [CostDiscBuild],
"CO2DiscBuild": [CO2DiscBuild],
"PrimDiscBuild": [PrimDiscBuild],
"FurnaceInvCost": [FurnaceInvCost],
"BoilerBInvCost": [BoilerBInvCost],
"BoilerPInvCost": [BoilerPInvCost],
"HPLakeInvC": [HPLakeInvC],
"HPSewInvC": [HPSewInvC],
"SCHEXCost": [SCHEXCost],
"pumpCosts": [pumpCosts],
"SumInvestCost": [addCosts],
"GasConnectionInvCa": [GasConnectionInvCost]
})
results.to_csv(locator.get_optimization_slave_investment_cost_detailed(
dicoSupply.configKey),
sep=',')
return (addCosts, addCO2, addPrim)
def decentralized_main(locator, building_names, gv):
"""
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
:param gv: global variables class
:type locator: class
:type building_names: list
:type gv: class
:return: results of operation of buildings located in locator.get_optimization_disconnected_folder
:rtype: Nonetype
"""
t0 = time.clock()
geothermal_potential = pd.read_csv(locator.get_geothermal_potential(), index_col="Name")
BestData = {}
def calc_new_load(mdot, TsupDH, Tret, gv):
"""
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 * gv.cp * (TsupDH - Tret) * (1 + gv.Qloss_Disc)
if Qload < 0:
Qload = 0
if Qload < -1E-5:
print "Error in discBuildMain, negative heat requirement at hour", hour, building_name
return Qload
for building_name in building_names:
print building_name
loads = pd.read_csv(locator.get_optimization_substations_results_file(building_name),
usecols=["T_supply_DH_result", "T_return_DH_result", "mdot_DH_result"])
Qload = np.vectorize(calc_new_load)(loads["mdot_DH_result"], loads["T_supply_DH_result"],
loads["T_return_DH_result"], gv)
Qannual = Qload.sum()
Qnom = Qload.max()* (1+gv.Qmargin_Disc) # 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"].values
TsupDH = loads["T_supply_DH_result"].values
mdot = loads["mdot_DH_result"].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] += gv.NG_PRICE * Qgas # CHF
result[0][5] += gv.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[0][6] += gv.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
resourcesRes[0][0] += Qload[hour]
if gv.DiscBioGasFlag == 1:
result[0][4] += gv.BG_PRICE * Qgas # CHF
result[0][5] += gv.BG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[0][6] += gv.BG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
# Boiler BG
result[1][4] += gv.BG_PRICE * Qgas # CHF
result[1][5] += gv.BG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[1][6] += gv.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] += gv.NG_PRICE * Qgas - gv.ELEC_PRICE * Qelec # CHF, extra electricity sold to grid
result[2][5] += 0.0874 * Qgas * 3600E-6 + 773 * 0.45 * Qelec * 1E-6 - gv.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 - gv.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(mdot[hour], TsupDH[hour], Tret[hour],
gv.TGround, gv)
if Wel_GHP[i][0] < wdot_el:
Wel_GHP[i][0] = wdot_el
result[3+i][4] += gv.ELEC_PRICE * wdot_el # CHF
result[3+i][5] += gv.SMALL_GHP_TO_CO2_STD * wdot_el * 3600E-6 # kgCO2
result[3+i][6] += gv.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] += gv.NG_PRICE * Qgas # CHF
result[3+i][5] += gv.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3+i][6] += gv.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] * gv.cp) + Tret[hour]
(wdot_el, qcolddot, qhotdot_missing, tsup2) = HP.calc_Cop_GHP(mdot[hour], TexitGHP, Tret[hour], gv.TGround, gv)
if Wel_GHP[i][0] < wdot_el:
Wel_GHP[i][0] = wdot_el
result[3+i][4] += gv.ELEC_PRICE * wdot_el # CHF
result[3+i][5] += gv.SMALL_GHP_TO_CO2_STD * wdot_el * 3600E-6 # kgCO2
result[3+i][6] += gv.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] += gv.NG_PRICE * Qgas # CHF
result[3+i][5] += gv.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3+i][6] += gv.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] += gv.NG_PRICE * Qgas # CHF
result[3+i][5] += gv.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3+i][6] += gv.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
resourcesRes[3+i][0] += QtoBoiler
# Investment Costs / CO2 / Prim
InvCaBoiler = Boiler.calc_Cinv_boiler(Qnom, Qannual, gv)
InvCosts[0][0] = InvCaBoiler
InvCosts[1][0] = InvCaBoiler
InvCosts[2][0] = FC.calc_Cinv_FC(Qnom, gv)
for i in range(10):
result[3+i][0] = i/10
result[3+i][3] = 1-i/10
QnomBoiler = i/10 * Qnom
InvCaBoiler = Boiler.calc_Cinv_boiler(QnomBoiler, QannualB_GHP[i][0], gv)
InvCosts[3+i][0] = InvCaBoiler
InvCaGHP = HP.GHP_InvCost( Wel_GHP[i][0] , gv)
InvCosts[3+i][0] += InvCaGHP * gv.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
# 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/gv.GHP_A) * gv.GHP_HmaxSize #[W_th]
if Qallowed < QGHP:
optsearch[i+3] += 1
Best[i+3][0] = - 1
while not Bestfound and rank<el:
optsearch[CostsS[rank][0]] -= 1
optsearch[CO2S[rank][0]] -= 1
optsearch[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(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()
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 addCosts(indCombi, buildList, locator, dicoSupply, QUncoveredDesign, QUncoveredAnnual, solarFeat, ntwFeat, gv):
"""
Computes additional costs / GHG emisions / primary energy needs
for the individual
Parameters
----------
indCombi : string
with 0 if disconnected building, 1 if connected
buildList : list
list of buildings in the district
locator : string
path to folders
dicoSupply : class context
with the features of the specific individual
QuncoveredDesign : float
hourly max of the heating uncovered demand
QuncoveredAnnual : float
total heating uncovered
solarFeat / ntwFeat : class solarFeatures / ntwFeatures
Returns
-------
(addCosts, addCO2, addPrim) : tuple
"""
addCosts = 0
addCO2 = 0
addPrim = 0
nBuildinNtw = 0
# Add the features from the disconnected buildings
print "\n COSTS FROM DISCONNECTED BUILDINGS"
os.chdir(locator.pathDiscRes)
CostDiscBuild = 0
CO2DiscBuild = 0
PrimDiscBuild = 0
FurnaceInvCost = 0
CCInvCost = 0
BoilerBInvCost = 0
BoilerPInvCost = 0
HPLakeInvC = 0
HPSewInvC = 0
GHPInvC = 0
PVInvC = 0
SCInvC = 0
PVTInvC = 0
BoilerAddInvC = 0
StorageHEXCost = 0
StorageHPCost = 0
StorageInvC = 0
NetworkCost = 0
SubstHEXCost = 0
PVTHEXCost = 0
SCHEXCost = 0
pumpCosts = 0
GasConnectionInvCost = 0
for (index, buildName) in zip(indCombi, buildList):
if index == "0":
discFileName = "DiscOp_" + buildName + "_result.csv"
df = pd.read_csv(discFileName)
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[0] # [kg CO2]
PrimDiscBuild += dfBest["Primary Energy Needs [MJoil-eq]"].iloc[0] # [MJ-oil-eq]
print dfBest["Total Costs [CHF]"].iloc[0], buildName, "disconnected"
else:
nBuildinNtw += 1
addCosts += CostDiscBuild
addCO2 += CO2DiscBuild
addPrim += PrimDiscBuild
# Add the features for the network
if indCombi.count("1") > 0:
os.chdir(locator.pathSlaveRes)
print " \n MACHINERY COSTS"
# Add the investment costs of the energy systems
# Furnace
if dicoSupply.Furnace_on == 1:
P_design = dicoSupply.Furnace_Q_max
fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv"
dfFurnace = pd.read_csv(fNameSlavePP, usecols=["Q_Furnace"])
arrayFurnace = np.array(dfFurnace)
Q_annual = 0
for i in range(int(np.shape(arrayFurnace)[0])):
Q_annual += arrayFurnace[i][0]
FurnaceInvCost = furnace.calc_Cinv_furnace(P_design, Q_annual, gv)
addCosts += FurnaceInvCost
print furnace.calc_Cinv_furnace(P_design, Q_annual, gv), " Furnace"
# CC
if dicoSupply.CC_on == 1:
CC_size = dicoSupply.CC_GT_SIZE
CCInvCost = chp.calc_Cinv_CCT(CC_size, gv)
addCosts += CCInvCost
print chp.calc_Cinv_CCT(CC_size, gv), " CC"
# Boiler Base
if dicoSupply.Boiler_on == 1:
Q_design = dicoSupply.Boiler_Q_max
fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv"
dfBoilerBase = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerBase"])
arrayBoilerBase = np.array(dfBoilerBase)
Q_annual = 0
for i in range(int(np.shape(arrayBoilerBase)[0])):
Q_annual += arrayBoilerBase[i][0]
BoilerBInvCost = boiler.calc_Cinv_boiler(Q_design, Q_annual, gv)
addCosts += BoilerBInvCost
print boiler.calc_Cinv_boiler(Q_design, Q_annual, gv), " Boiler Base "
# Boiler Peak
if dicoSupply.BoilerPeak_on == 1:
Q_design = dicoSupply.BoilerPeak_Q_max
fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv"
dfBoilerPeak = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerPeak"])
arrayBoilerPeak = np.array(dfBoilerPeak)
Q_annual = 0
for i in range(int(np.shape(arrayBoilerPeak)[0])):
Q_annual += arrayBoilerPeak[i][0]
BoilerPInvCost = boiler.calc_Cinv_boiler(Q_design, Q_annual, gv)
addCosts += BoilerPInvCost
print boiler.calc_Cinv_boiler(Q_design, Q_annual, gv), " Boiler Peak"
# HP Lake
if dicoSupply.HP_Lake_on == 1:
HP_Size = dicoSupply.HPLake_maxSize
HPLakeInvC = hp.calc_Cinv_HP(HP_Size, gv)
addCosts += HPLakeInvC
print hp.calc_Cinv_HP(HP_Size, gv), " HP Lake"
# HP Sewage
if dicoSupply.HP_Sew_on == 1:
HP_Size = dicoSupply.HPSew_maxSize
HPSewInvC = hp.calc_Cinv_HP(HP_Size, gv)
addCosts += HPSewInvC
print hp.calc_Cinv_HP(HP_Size, gv), "HP Sewage"
# GHP
if dicoSupply.GHP_on == 1:
fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv"
dfGHP = pd.read_csv(fNameSlavePP, usecols=["E_GHP"])
arrayGHP = np.array(dfGHP)
GHP_Enom = np.amax(arrayGHP)
GHPInvC = hp.calc_Cinv_GHP(GHP_Enom, gv) * gv.EURO_TO_CHF
addCosts += GHPInvC
print hp.calc_Cinv_GHP(GHP_Enom, gv) * gv.EURO_TO_CHF, " GHP"
# Solar technologies
PV_peak = dicoSupply.SOLAR_PART_PV * solarFeat.SolarAreaPV * gv.nPV #kW
PVInvC = pv.calc_Cinv_PV(PV_peak)
addCosts += PVInvC
print pv.calc_Cinv_PV(PV_peak), "PV peak"
SC_area = dicoSupply.SOLAR_PART_SC * solarFeat.SolarAreaSC
SCInvC = stc.calc_Cinv_SC(SC_area)
addCosts += SCInvC
print stc.calc_Cinv_SC(SC_area), "SC area"
PVT_peak = dicoSupply.SOLAR_PART_PVT * solarFeat.SolarAreaPVT * gv.nPVT #kW
PVTInvC = pvt.calc_Cinv_PVT(PVT_peak)
addCosts += PVTInvC
print pvt.calc_Cinv_PVT(PVT_peak), "PVT peak"
# Back-up boiler
BoilerAddInvC = boiler.calc_Cinv_boiler(QUncoveredDesign, QUncoveredAnnual, gv)
addCosts += BoilerAddInvC
print boiler.calc_Cinv_boiler(QUncoveredDesign, QUncoveredAnnual, gv), "backup boiler"
# Hex and HP for Heat recovery
print "\n STORAGE PART COSTS"
if dicoSupply.WasteServersHeatRecovery == 1:
df = pd.read_csv(locator.pathNtwRes + "/" + dicoSupply.NETWORK_DATA_FILE, usecols = ["Qcdata_netw_total"])
array = np.array(df)
QhexMax = np.amax(array)
StorageHEXCost += hex.calc_Cinv_HEX(QhexMax, gv)
print hex.calc_Cinv_HEX(QhexMax, gv), "Hex for data center"
df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["HPServerHeatDesignArray"])
array = np.array(df)
QhpMax = np.amax(array)
StorageHEXCost += hp.calc_Cinv_HP(QhpMax, gv)
print hp.calc_Cinv_HP(QhpMax, gv), "HP for data center"
if dicoSupply.WasteCompressorHeatRecovery == 1:
df = pd.read_csv(locator.pathNtwRes + "/" + dicoSupply.NETWORK_DATA_FILE, usecols = ["Ecaf_netw_total"])
array = np.array(df)
QhexMax = np.amax(array)
StorageHEXCost += hex.calc_Cinv_HEX(QhexMax, gv)
print hex.calc_Cinv_HEX(QhexMax, gv), "Hex for compressed air"
df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["HPCompAirDesignArray"])
array = np.array(df)
QhpMax = np.amax(array)
StorageHEXCost += hp.calc_Cinv_HP(QhpMax, gv)
print hp.calc_Cinv_HP(QhpMax, gv), "HP for compressed air"
addCosts += StorageHEXCost
# Heat pump solar to storage
df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["HPScDesignArray", "HPpvt_designArray"])
array = np.array(df)
QhpMax_PVT = np.amax(array[:,1])
QhpMax_SC = np.amax(array[:,0])
StorageHPCost += hp.calc_Cinv_HP(QhpMax_PVT, gv)
print hp.calc_Cinv_HP(QhpMax_PVT, gv), "HP for PVT"
StorageHPCost += hp.calc_Cinv_HP(QhpMax_SC, gv)
print hp.calc_Cinv_HP(QhpMax_SC, gv), "HP for SC"
# HP for storage operation
df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["E_aux_ch", "E_aux_dech", "Q_from_storage_used", "Q_to_storage"])
array = np.array(df)
QmaxHPStorage = 0
for i in range(gv.DAYS_IN_YEAR * gv.HOURS_IN_DAY):
if array[i][0] > 0:
QmaxHPStorage = max(QmaxHPStorage, array[i][3] + array[i][0])
elif array[i][1] > 0:
QmaxHPStorage = max(QmaxHPStorage, array[i][2] + array[i][1])
StorageHPCost += hp.calc_Cinv_HP(QmaxHPStorage, gv)
addCosts += StorageHPCost
print hp.calc_Cinv_HP(QmaxHPStorage, gv), "HP for storage"
# Storage
df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["Storage_Size"], nrows = 1)
StorageVol = np.array(df)[0][0]
StorageInvC += storage.calc_Cinv_storage(StorageVol, gv)
addCosts += StorageInvC
print storage.calc_Cinv_storage(StorageVol, gv), "Storage Costs"
# Costs from network configuration
print "\n COSTS FROM NETWORK CONFIGURATION"
if gv.ZernezFlag == 1:
NetworkCost += network.calc_Cinv_network_linear(gv.NetworkLengthZernez, gv) * nBuildinNtw / len(buildList)
else:
NetworkCost += ntwFeat.pipesCosts_DHN * nBuildinNtw / len(buildList)
addCosts += NetworkCost
print ntwFeat.pipesCosts_DHN * nBuildinNtw / len(buildList), "Pipes Costs"
# HEX (1 per building in ntw)
for (index, buildName) in zip(indCombi, buildList):
if index == "1":
subsFileName = buildName + "_result.csv"
df = pd.read_csv(locator.pathSubsRes + "/" + subsFileName, usecols = ["Q_dhw", "Q_heating"])
subsArray = np.array(df)
Qmax = np.amax( subsArray[:,0] + subsArray[:,1] )
SubstHEXCost += hex.calc_Cinv_HEX(Qmax, gv)
print hex.calc_Cinv_HEX(Qmax, gv), "Hex", buildName
addCosts += SubstHEXCost
# HEX for solar
roof_area = np.array(pd.read_csv(locator.get_total_demand(), usecols=["Aroof_m2"]))
areaAvail = 0
for i in range( len(indCombi) ):
index = indCombi[i]
if index == "1":
areaAvail += roof_area[i][0]
for i in range( len(indCombi) ):
index = indCombi[i]
if index == "1":
share = roof_area[i][0] / areaAvail
#print share, "solar area share", buildList[i]
SC_Qmax = solarFeat.SC_Qnom * dicoSupply.SOLAR_PART_SC * share
SCHEXCost += hex.calc_Cinv_HEX(SC_Qmax, gv)
print hex.calc_Cinv_HEX(SC_Qmax, gv), "Hex SC", buildList[i]
PVT_Qmax = solarFeat.PVT_Qnom * dicoSupply.SOLAR_PART_PVT * share
PVTHEXCost += hex.calc_Cinv_HEX(PVT_Qmax, gv)
print hex.calc_Cinv_HEX(PVT_Qmax, gv), "Hex PVT", buildList[i]
addCosts += SCHEXCost
addCosts += PVTHEXCost
print addCosts,"addCosts in extraCostsMain"
# Pump operation costs
pumpCosts = pumps.calc_Ctot_pump(dicoSupply, buildList, locator.pathNtwRes, ntwFeat, gv)
addCosts += pumpCosts
print pumpCosts, "Pump Operation costs in extraCostsMain\n"
# import gas consumption data from:
if indCombi.count("1") > 0:
# import gas consumption data from:
FileName = locator.pathSlaveRes + "/" + dicoSupply.configKey + "PrimaryEnergyBySource.csv"
colName = "EgasPrimaryPeakPower"
EgasPrimaryDataframe = pd.read_csv(FileName, usecols=[colName])
#print EgasPrimaryDataframe
#print np.array(EgasPrimaryDataframe)
#print float(np.array(EgasPrimaryDataframe))
EgasPrimaryPeakPower = float(np.array(EgasPrimaryDataframe))
GasConnectionInvCost = ngas.calc_Cinv_gas(EgasPrimaryPeakPower, gv)
else:
GasConnectionInvCost = 0.0
addCosts += GasConnectionInvCost
# Save data
results = pd.DataFrame({
"SCInvC":[SCInvC],
"PVTInvC":[PVTInvC],
"BoilerAddInvC":[BoilerAddInvC],
"StorageHEXCost":[StorageHEXCost],
"StorageHPCost":[StorageHPCost],
"StorageInvC":[StorageInvC],
"StorageCostSum":[StorageInvC+StorageHPCost+StorageHEXCost],
"NetworkCost":[NetworkCost],
"SubstHEXCost":[SubstHEXCost],
"DHNInvestCost":[addCosts - CostDiscBuild],
"PVTHEXCost":[PVTHEXCost],
"CostDiscBuild":[CostDiscBuild],
"CO2DiscBuild":[CO2DiscBuild],
"PrimDiscBuild":[PrimDiscBuild],
"FurnaceInvCost":[FurnaceInvCost],
"BoilerBInvCost":[BoilerBInvCost],
"BoilerPInvCost":[BoilerPInvCost],
"HPLakeInvC":[HPLakeInvC],
"HPSewInvC":[HPSewInvC],
"SCHEXCost":[SCHEXCost],
"pumpCosts":[pumpCosts],
"SumInvestCost":[addCosts],
"GasConnectionInvCa":[GasConnectionInvCost]
})
Name = "/" + dicoSupply.configKey + "_InvestmentCostDetailed.csv"
results.to_csv(locator.pathSlaveRes + Name, sep=',')
return (addCosts, addCO2, addPrim)
def addCosts(indCombi, buildList, locator, dicoSupply, QUncoveredDesign,
QUncoveredAnnual, solarFeat, ntwFeat, gv):
"""
Computes additional costs / GHG emisions / primary energy needs
for the individual
Parameters
----------
indCombi : string
with 0 if disconnected building, 1 if connected
buildList : list
list of buildings in the district
locator : string
path to folders
dicoSupply : class context
with the features of the specific individual
QuncoveredDesign : float
hourly max of the heating uncovered demand
QuncoveredAnnual : float
total heating uncovered
solarFeat / ntwFeat : class solarFeatures / ntwFeatures
Returns
-------
(addCosts, addCO2, addPrim) : tuple
"""
addCosts = 0
addCO2 = 0
addPrim = 0
nBuildinNtw = 0
# Add the features from the disconnected buildings
print "\n COSTS FROM DISCONNECTED BUILDINGS"
os.chdir(locator.pathDiscRes)
CostDiscBuild = 0
CO2DiscBuild = 0
PrimDiscBuild = 0
FurnaceInvCost = 0
CCInvCost = 0
BoilerBInvCost = 0
BoilerPInvCost = 0
HPLakeInvC = 0
HPSewInvC = 0
GHPInvC = 0
PVInvC = 0
SCInvC = 0
PVTInvC = 0
BoilerAddInvC = 0
StorageHEXCost = 0
StorageHPCost = 0
StorageInvC = 0
NetworkCost = 0
SubstHEXCost = 0
PVTHEXCost = 0
SCHEXCost = 0
pumpCosts = 0
GasConnectionInvCost = 0
for (index, buildName) in zip(indCombi, buildList):
if index == "0":
discFileName = "DiscOp_" + buildName + "_result.csv"
df = pd.read_csv(discFileName)
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest["Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
print dfBest["Total Costs [CHF]"].iloc[
0], buildName, "disconnected"
else:
nBuildinNtw += 1
addCosts += CostDiscBuild
addCO2 += CO2DiscBuild
addPrim += PrimDiscBuild
# Add the features for the network
if indCombi.count("1") > 0:
os.chdir(locator.pathSlaveRes)
print " \n MACHINERY COSTS"
# Add the investment costs of the energy systems
# Furnace
if dicoSupply.Furnace_on == 1:
P_design = dicoSupply.Furnace_Q_max
fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv"
dfFurnace = pd.read_csv(fNameSlavePP, usecols=["Q_Furnace"])
arrayFurnace = np.array(dfFurnace)
Q_annual = 0
for i in range(int(np.shape(arrayFurnace)[0])):
Q_annual += arrayFurnace[i][0]
FurnaceInvCost = furnace.calc_Cinv_furnace(P_design, Q_annual, gv)
addCosts += FurnaceInvCost
print furnace.calc_Cinv_furnace(P_design, Q_annual, gv), " Furnace"
# CC
if dicoSupply.CC_on == 1:
CC_size = dicoSupply.CC_GT_SIZE
CCInvCost = chp.calc_Cinv_CCT(CC_size, gv)
addCosts += CCInvCost
print chp.calc_Cinv_CCT(CC_size, gv), " CC"
# Boiler Base
if dicoSupply.Boiler_on == 1:
Q_design = dicoSupply.Boiler_Q_max
fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv"
dfBoilerBase = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerBase"])
arrayBoilerBase = np.array(dfBoilerBase)
Q_annual = 0
for i in range(int(np.shape(arrayBoilerBase)[0])):
Q_annual += arrayBoilerBase[i][0]
BoilerBInvCost = boiler.calc_Cinv_boiler(Q_design, Q_annual, gv)
addCosts += BoilerBInvCost
print boiler.calc_Cinv_boiler(Q_design, Q_annual,
gv), " Boiler Base "
# Boiler Peak
if dicoSupply.BoilerPeak_on == 1:
Q_design = dicoSupply.BoilerPeak_Q_max
fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv"
dfBoilerPeak = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerPeak"])
arrayBoilerPeak = np.array(dfBoilerPeak)
Q_annual = 0
for i in range(int(np.shape(arrayBoilerPeak)[0])):
Q_annual += arrayBoilerPeak[i][0]
BoilerPInvCost = boiler.calc_Cinv_boiler(Q_design, Q_annual, gv)
addCosts += BoilerPInvCost
print boiler.calc_Cinv_boiler(Q_design, Q_annual,
gv), " Boiler Peak"
# HP Lake
if dicoSupply.HP_Lake_on == 1:
HP_Size = dicoSupply.HPLake_maxSize
HPLakeInvC = hp.calc_Cinv_HP(HP_Size, gv)
addCosts += HPLakeInvC
print hp.calc_Cinv_HP(HP_Size, gv), " HP Lake"
# HP Sewage
if dicoSupply.HP_Sew_on == 1:
HP_Size = dicoSupply.HPSew_maxSize
HPSewInvC = hp.calc_Cinv_HP(HP_Size, gv)
addCosts += HPSewInvC
print hp.calc_Cinv_HP(HP_Size, gv), "HP Sewage"
# GHP
if dicoSupply.GHP_on == 1:
fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv"
dfGHP = pd.read_csv(fNameSlavePP, usecols=["E_GHP"])
arrayGHP = np.array(dfGHP)
GHP_Enom = np.amax(arrayGHP)
GHPInvC = hp.calc_Cinv_GHP(GHP_Enom, gv) * gv.EURO_TO_CHF
addCosts += GHPInvC
print hp.calc_Cinv_GHP(GHP_Enom, gv) * gv.EURO_TO_CHF, " GHP"
# Solar technologies
PV_peak = dicoSupply.SOLAR_PART_PV * solarFeat.SolarAreaPV * gv.nPV #kW
PVInvC = pv.calc_Cinv_PV(PV_peak)
addCosts += PVInvC
print pv.calc_Cinv_PV(PV_peak), "PV peak"
SC_area = dicoSupply.SOLAR_PART_SC * solarFeat.SolarAreaSC
SCInvC = stc.calc_Cinv_SC(SC_area)
addCosts += SCInvC
print stc.calc_Cinv_SC(SC_area), "SC area"
PVT_peak = dicoSupply.SOLAR_PART_PVT * solarFeat.SolarAreaPVT * gv.nPVT #kW
PVTInvC = pvt.calc_Cinv_PVT(PVT_peak)
addCosts += PVTInvC
print pvt.calc_Cinv_PVT(PVT_peak), "PVT peak"
# Back-up boiler
BoilerAddInvC = boiler.calc_Cinv_boiler(QUncoveredDesign,
QUncoveredAnnual, gv)
addCosts += BoilerAddInvC
print boiler.calc_Cinv_boiler(QUncoveredDesign, QUncoveredAnnual,
gv), "backup boiler"
# Hex and HP for Heat recovery
print "\n STORAGE PART COSTS"
if dicoSupply.WasteServersHeatRecovery == 1:
df = pd.read_csv(locator.pathNtwRes + "/" +
dicoSupply.NETWORK_DATA_FILE,
usecols=["Qcdata_netw_total"])
array = np.array(df)
QhexMax = np.amax(array)
StorageHEXCost += hex.calc_Cinv_HEX(QhexMax, gv)
print hex.calc_Cinv_HEX(QhexMax, gv), "Hex for data center"
df = pd.read_csv(locator.pathSlaveRes + "/" +
dicoSupply.configKey + "StorageOperationData.csv",
usecols=["HPServerHeatDesignArray"])
array = np.array(df)
QhpMax = np.amax(array)
StorageHEXCost += hp.calc_Cinv_HP(QhpMax, gv)
print hp.calc_Cinv_HP(QhpMax, gv), "HP for data center"
if dicoSupply.WasteCompressorHeatRecovery == 1:
df = pd.read_csv(locator.pathNtwRes + "/" +
dicoSupply.NETWORK_DATA_FILE,
usecols=["Ecaf_netw_total"])
array = np.array(df)
QhexMax = np.amax(array)
StorageHEXCost += hex.calc_Cinv_HEX(QhexMax, gv)
print hex.calc_Cinv_HEX(QhexMax, gv), "Hex for compressed air"
df = pd.read_csv(locator.pathSlaveRes + "/" +
dicoSupply.configKey + "StorageOperationData.csv",
usecols=["HPCompAirDesignArray"])
array = np.array(df)
QhpMax = np.amax(array)
StorageHEXCost += hp.calc_Cinv_HP(QhpMax, gv)
print hp.calc_Cinv_HP(QhpMax, gv), "HP for compressed air"
addCosts += StorageHEXCost
# Heat pump solar to storage
df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey +
"StorageOperationData.csv",
usecols=["HPScDesignArray", "HPpvt_designArray"])
array = np.array(df)
QhpMax_PVT = np.amax(array[:, 1])
QhpMax_SC = np.amax(array[:, 0])
StorageHPCost += hp.calc_Cinv_HP(QhpMax_PVT, gv)
print hp.calc_Cinv_HP(QhpMax_PVT, gv), "HP for PVT"
StorageHPCost += hp.calc_Cinv_HP(QhpMax_SC, gv)
print hp.calc_Cinv_HP(QhpMax_SC, gv), "HP for SC"
# HP for storage operation
df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey +
"StorageOperationData.csv",
usecols=[
"E_aux_ch", "E_aux_dech", "Q_from_storage_used",
"Q_to_storage"
])
array = np.array(df)
QmaxHPStorage = 0
for i in range(gv.DAYS_IN_YEAR * gv.HOURS_IN_DAY):
if array[i][0] > 0:
QmaxHPStorage = max(QmaxHPStorage, array[i][3] + array[i][0])
elif array[i][1] > 0:
QmaxHPStorage = max(QmaxHPStorage, array[i][2] + array[i][1])
StorageHPCost += hp.calc_Cinv_HP(QmaxHPStorage, gv)
addCosts += StorageHPCost
print hp.calc_Cinv_HP(QmaxHPStorage, gv), "HP for storage"
# Storage
df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey +
"StorageOperationData.csv",
usecols=["Storage_Size"],
nrows=1)
StorageVol = np.array(df)[0][0]
StorageInvC += storage.calc_Cinv_storage(StorageVol, gv)
addCosts += StorageInvC
print storage.calc_Cinv_storage(StorageVol, gv), "Storage Costs"
# Costs from network configuration
print "\n COSTS FROM NETWORK CONFIGURATION"
if gv.ZernezFlag == 1:
NetworkCost += network.calc_Cinv_network_linear(
gv.NetworkLengthZernez, gv) * nBuildinNtw / len(buildList)
else:
NetworkCost += ntwFeat.pipesCosts_DHN * nBuildinNtw / len(
buildList)
addCosts += NetworkCost
print ntwFeat.pipesCosts_DHN * nBuildinNtw / len(
buildList), "Pipes Costs"
# HEX (1 per building in ntw)
for (index, buildName) in zip(indCombi, buildList):
if index == "1":
subsFileName = buildName + "_result.csv"
df = pd.read_csv(locator.pathSubsRes + "/" + subsFileName,
usecols=["Q_dhw", "Q_heating"])
subsArray = np.array(df)
Qmax = np.amax(subsArray[:, 0] + subsArray[:, 1])
SubstHEXCost += hex.calc_Cinv_HEX(Qmax, gv)
print hex.calc_Cinv_HEX(Qmax, gv), "Hex", buildName
addCosts += SubstHEXCost
# HEX for solar
roof_area = np.array(
pd.read_csv(locator.get_total_demand(), usecols=["Aroof_m2"]))
areaAvail = 0
for i in range(len(indCombi)):
index = indCombi[i]
if index == "1":
areaAvail += roof_area[i][0]
for i in range(len(indCombi)):
index = indCombi[i]
if index == "1":
share = roof_area[i][0] / areaAvail
#print share, "solar area share", buildList[i]
SC_Qmax = solarFeat.SC_Qnom * dicoSupply.SOLAR_PART_SC * share
SCHEXCost += hex.calc_Cinv_HEX(SC_Qmax, gv)
print hex.calc_Cinv_HEX(SC_Qmax, gv), "Hex SC", buildList[i]
PVT_Qmax = solarFeat.PVT_Qnom * dicoSupply.SOLAR_PART_PVT * share
PVTHEXCost += hex.calc_Cinv_HEX(PVT_Qmax, gv)
print hex.calc_Cinv_HEX(PVT_Qmax, gv), "Hex PVT", buildList[i]
addCosts += SCHEXCost
addCosts += PVTHEXCost
print addCosts, "addCosts in extraCostsMain"
# Pump operation costs
pumpCosts = pumps.calc_Ctot_pump(dicoSupply, buildList,
locator.pathNtwRes, ntwFeat, gv)
addCosts += pumpCosts
print pumpCosts, "Pump Operation costs in extraCostsMain\n"
# import gas consumption data from:
if indCombi.count("1") > 0:
# import gas consumption data from:
FileName = locator.pathSlaveRes + "/" + dicoSupply.configKey + "PrimaryEnergyBySource.csv"
colName = "EgasPrimaryPeakPower"
EgasPrimaryDataframe = pd.read_csv(FileName, usecols=[colName])
#print EgasPrimaryDataframe
#print np.array(EgasPrimaryDataframe)
#print float(np.array(EgasPrimaryDataframe))
EgasPrimaryPeakPower = float(np.array(EgasPrimaryDataframe))
GasConnectionInvCost = ngas.calc_Cinv_gas(EgasPrimaryPeakPower, gv)
else:
GasConnectionInvCost = 0.0
addCosts += GasConnectionInvCost
# Save data
results = pd.DataFrame({
"SCInvC": [SCInvC],
"PVTInvC": [PVTInvC],
"BoilerAddInvC": [BoilerAddInvC],
"StorageHEXCost": [StorageHEXCost],
"StorageHPCost": [StorageHPCost],
"StorageInvC": [StorageInvC],
"StorageCostSum": [StorageInvC + StorageHPCost + StorageHEXCost],
"NetworkCost": [NetworkCost],
"SubstHEXCost": [SubstHEXCost],
"DHNInvestCost": [addCosts - CostDiscBuild],
"PVTHEXCost": [PVTHEXCost],
"CostDiscBuild": [CostDiscBuild],
"CO2DiscBuild": [CO2DiscBuild],
"PrimDiscBuild": [PrimDiscBuild],
"FurnaceInvCost": [FurnaceInvCost],
"BoilerBInvCost": [BoilerBInvCost],
"BoilerPInvCost": [BoilerPInvCost],
"HPLakeInvC": [HPLakeInvC],
"HPSewInvC": [HPSewInvC],
"SCHEXCost": [SCHEXCost],
"pumpCosts": [pumpCosts],
"SumInvestCost": [addCosts],
"GasConnectionInvCa": [GasConnectionInvCost]
})
Name = "/" + dicoSupply.configKey + "_InvestmentCostDetailed.csv"
results.to_csv(locator.pathSlaveRes + Name, sep=',')
return (addCosts, addCO2, addPrim)
def discBuildOp(locator, building_names, gv):
"""
Computes the parameters for the operation of disconnected buildings
output results in csv files
Parameters
----------
locator : string
path to folders
"""
print "Start Disconnected Building Routine \n"
t0 = time.clock()
geothermal_potential = pd.read_csv(locator.get_geothermal_potential, index_col="Name")
BestData = {}
def calc_new_load(mdot, TsupDH, Tret, gv):
Qload = mdot * gv.cp * (TsupDH - Tret) * (1 + gv.Qloss_Disc)
if Qload < 0:
Qload = 0
if Qload < -1E-5:
print "Error in discBuildMain, negative heat requirement at hour", hour, buildName
return Qload
for buildName in building_names:
fName = locator.pathSubsRes + "/" + buildName + "_result.csv"
loads = pd.read_csv(fName, usecols=["T_supply_DH_result", "T_return_DH_result", "mdot_DH_result"])
Qload = np.vectorize(calc_new_load)(loads["mdot_DH_result"], loads["T_supply_DH_result"], loads["T_return_DH_result"], gv)
Qannual = Qload.sum()
Qnom = Qload.max()* (1+gv.Qmargin_Disc) # 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
print "Operation with the Boiler / FC / GHP"
Tret = loads["T_return_DH_result"].values
TsupDH = loads["T_supply_DH_result"].values
mdot = loads["mdot_DH_result"].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] += gv.NG_PRICE * Qgas # CHF
result[0][5] += gv.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[0][6] += gv.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
resourcesRes[0][0] += Qload[hour]
if gv.DiscBioGasFlag == 1:
result[0][4] += gv.BG_PRICE * Qgas # CHF
result[0][5] += gv.BG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[0][6] += gv.BG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
# Boiler BG
result[1][4] += gv.BG_PRICE * Qgas # CHF
result[1][5] += gv.BG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[1][6] += gv.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] += gv.NG_PRICE * Qgas - gv.ELEC_PRICE * Qelec # CHF, extra electricity sold to grid
result[2][5] += 0.0874 * Qgas * 3600E-6 + 773 * 0.45 * Qelec * 1E-6 - gv.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 - gv.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(mdot[hour], TsupDH[hour], Tret[hour], gv.TGround, gv)
if Wel_GHP[i][0] < wdot_el:
Wel_GHP[i][0] = wdot_el
result[3+i][4] += gv.ELEC_PRICE * wdot_el # CHF
result[3+i][5] += gv.SMALL_GHP_TO_CO2_STD * wdot_el * 3600E-6 # kgCO2
result[3+i][6] += gv.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] += gv.NG_PRICE * Qgas # CHF
result[3+i][5] += gv.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3+i][6] += gv.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] * gv.cp) + Tret[hour]
(wdot_el, qcolddot, qhotdot_missing, tsup2) = HP.calc_Cop_GHP(mdot[hour], TexitGHP, Tret[hour], gv.TGround, gv)
if Wel_GHP[i][0] < wdot_el:
Wel_GHP[i][0] = wdot_el
result[3+i][4] += gv.ELEC_PRICE * wdot_el # CHF
result[3+i][5] += gv.SMALL_GHP_TO_CO2_STD * wdot_el * 3600E-6 # kgCO2
result[3+i][6] += gv.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] += gv.NG_PRICE * Qgas # CHF
result[3+i][5] += gv.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3+i][6] += gv.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] += gv.NG_PRICE * Qgas # CHF
result[3+i][5] += gv.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2
result[3+i][6] += gv.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq
resourcesRes[3+i][0] += QtoBoiler
print time.clock() - t0, "seconds process time for the operation \n"
# Investment Costs / CO2 / Prim
InvCaBoiler = Boiler.calc_Cinv_boiler(Qnom, Qannual, gv)
InvCosts[0][0] = InvCaBoiler
InvCosts[1][0] = InvCaBoiler
InvCosts[2][0] = FC.calc_Cinv_FC(Qnom, gv)
for i in range(10):
result[3+i][0] = i/10
result[3+i][3] = 1-i/10
QnomBoiler = i/10 * Qnom
InvCaBoiler = Boiler.calc_Cinv_boiler(QnomBoiler, QannualB_GHP[i][0], gv)
InvCosts[3+i][0] = InvCaBoiler
InvCaGHP = HP.GHP_InvCost( Wel_GHP[i][0] , gv)
InvCosts[3+i][0] += InvCaGHP * gv.EURO_TO_CHF
# Best configuration
print "Find the 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
# Check the GHP area constraint
for i in range(10):
QGHP = (1-i/10) * Qnom
areaAvail = geothermal_potential.ix[buildName,"Area_geo"]
Qallowed = np.ceil(areaAvail/gv.GHP_A) * gv.GHP_HmaxSize #[W_th]
if Qallowed < QGHP:
optsearch[i+3] += 1
Best[i+3][0] = -1
while not Bestfound and rank<el:
optsearch[CostsS[rank][0]] -= 1
optsearch[CO2S[rank][0]] -= 1
optsearch[PrimS[rank][0]] -= 1
if np.count_nonzero(optsearch) != el:
Bestfound = True
indexBest = np.where(optsearch == 0)[0][0]
rank += 1
Best[indexBest][0] = 1
print indexBest, "Best"
Qnom_array = np.ones(len(Best[:,0])) * Qnom
# Save results in csv file
print "Save the results for", buildName, "\n"
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]
os.chdir(locator.pathDiscRes)
fName = buildName + "_result.csv"
results_to_csv = pd.DataFrame(dico)
fName_result = "DiscOp_" + fName[0:(len(fName)-4)] + ".csv"
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[buildName] = BestComb
if 0:
os.chdir(locator.pathDiscRes)
fName = "DiscOpSummary.csv"
results_to_csv = pd.DataFrame(BestData)
results_to_csv.to_csv(fName, sep= ',')
print "Disconnected Building Routine Completed"
print time.clock() - t0, "seconds process time for the Disconnected Building Routine \n"