def __init__(self, temporary, number):
chp = CHPInternalCombustionEngine(temporary, number)
heat_pump = HeatPump(temporary)
elestorage = EleStorage(temporary)
coldstorage = ColdStorage(temporary)
absorption_chiller = DoubleEffectAbsorptionChiller(temporary)
ice = InternalCombustionEngine(number, temporary)
demand = DemandData()
time = demand.E_sheetnrows - 1
cold_stor = 0
ele_stor = 0
fuel = []
ele_bought = []
ele_ice = []
cold_absorption_chiller = []
for t in range(0, time, Parameters.delttime):
judge_ele = min(demand.E[t] - elestorage.get_E_out_max(ele_stor), ice.nominal)
judge_cold = chp.get_cold_through_ele(judge_ele)
if demand.C[t] > coldstorage.get_C_out_max(cold_stor) + judge_cold + heat_pump.nominal:
self.judge = 0
break
else:
self.judge = 1
ele_drive = EleDrive(t, temporary, number, ele_stor)
if ele_drive.ele == 0:
cold_drive = ColdDrive(t, temporary, number, cold_stor)
cold_stor = cold_drive.cold_stor
self.cold = cold_drive.cold
self.ele = ice.get_ele_out_through_cold(self.cold)
pl = self.ele / ice.nominal
ele_stor = elestorage.get_S(ele_stor, self.ele, ele_drive.elestorage_out)
fuel.append(ice.get_fuel(pl))
ele_bought.append(heat_pump.get_E_in(cold_drive.heat_pump_out))
else:
self.ele = ele_drive.ele
pl = self.ele / ice.nominal
exhaust_gas = ice.get_exhaust_gas_pl(pl)
jacket_water = ice.get_jacket_water_pl(pl)
self.cold = absorption_chiller.get_cold_out(exhaust_gas, jacket_water)
cold_follow = ColdFollow(t, temporary, cold_stor, self.cold)
cold_stor = cold_follow.cold_stor
ele_stor = elestorage.get_S(ele_stor, 0, ele_drive.elestorage_out)
fuel.append(ice.get_fuel(pl))
ele_bought.append(ele_drive.ele_bought + heat_pump.get_E_in(cold_follow.heat_pump_out))
ele_ice.append(self.ele)
cold_absorption_chiller.append(self.cold)
if cold_stor > coldstorage.nominal:
cold_stor = coldstorage.nominal
if ele_stor > elestorage.nominal:
ele_stor = elestorage.nominal
self.fuel = sum(fuel)
self.ele_bought = sum(ele_bought)
self.emission_calculate_ice = sum(ele_ice)
self.emission_calculate_boiler = 0
self.emission_calculate_absorption_chiller = sum(cold_absorption_chiller)
self.emission_calculate_grid = self.ele_bought
def signal_cold(t, temporary, cold_stor, season): # 储电够，储热够，储冷不够
chp = CHP(temporary)
gasturbine = GasTurbine(temporary)
boiler = Boiler(temporary)
absorptionchiller = AbsorptionChiller(temporary)
gasboiler = GasBoiler(temporary)
heatpump = HeatPump(temporary)
coldstorage = ColdStorage(temporary)
demand = DemandData()
if season == 0:
demand_ele = demand.cold_E
elif season == 1:
demand_ele = demand.heat_E
else:
demand_ele = demand.transition_E
elestorage_ele_out = demand_ele[t]
heatstorage_heat_out = demand.H[t]
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
coldstorage_cold_in = 0
powergrid_ele_out = 0
gasboiler_heat_out = 0
gasboiler_fuel = gasboiler.get_Fuel_in(gasboiler_heat_out)
if demand.C[t] <= coldstorage_cold_out + chp.C_out_max:
absorptionchiller_cold_out = demand.C[t] - coldstorage_cold_out
heatpump_cold_out = 0
else:
absorptionchiller_cold_out = chp.C_out_max
heatpump_cold_out = demand.C[t] - coldstorage_cold_out - absorptionchiller_cold_out
absorptionchiller_heat_in = absorptionchiller.get_H_in(absorptionchiller_cold_out)
boiler_heat_out = absorptionchiller_heat_in / Parameters.k
boiler_heat_out_users = boiler_heat_out * (1 - Parameters.k)
heatstorage_heat_in = boiler_heat_out_users
boiler_heat_in = boiler.get_H_in(boiler_heat_out)
gasturbine_ele_out = boiler_heat_in / chp.heat_ele_ratio
gasturbine_fuel = gasturbine.get_fuel(gasturbine_ele_out)
heatpump_ele_in = heatpump.get_E_in(heatpump_cold_out)
if heatpump_ele_in <= gasturbine_ele_out:
elestorage_ele_in = gasturbine_ele_out - heatpump_ele_in
heatpump_powergrid = 0
else:
elestorage_ele_in = 0
heatpump_powergrid = heatpump_ele_in - gasturbine_ele_out
result = (coldstorage_cold_in, coldstorage_cold_out, heatstorage_heat_in, heatstorage_heat_out,
elestorage_ele_in, elestorage_ele_out, absorptionchiller_cold_out, boiler_heat_out, gasturbine_ele_out,
heatpump_cold_out, gasboiler_heat_out, powergrid_ele_out, gasboiler_fuel, gasturbine_fuel,
heatpump_powergrid)
return result
def __init__(self, temporary, t, cold_stor):
heat_pump = HeatPump(temporary)
coldstorage = ColdStorage(temporary)
demand = DemandData()
if coldstorage.get_C_out_max(cold_stor) > 0:
if demand.C[t] <= coldstorage.get_C_out_max(cold_stor):
coldstorage_cold_out = demand.C[t]
self.cold_heat_pump = 0
else:
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
self.cold_heat_pump = demand.C[t] - coldstorage_cold_out
self.cold_stor = coldstorage.get_S(cold_stor, 0,
coldstorage_cold_out)
else:
self.cold_heat_pump = demand.C[t]
self.cold_stor = coldstorage.get_S(cold_stor, 0, 0)
self.ele_bought_for_heat_pump = heat_pump.get_E_in(self.cold_heat_pump)
def mode_base_load(t, temporary, cold_stor, heat_stor, ele_stor, season):
chp = CHP(temporary)
gasturbine = GasTurbine(temporary)
gasboiler = GasBoiler(temporary)
heatpump = HeatPump(temporary)
elestorage = EleStorage(temporary)
heatstorage = HeatStorage(temporary)
coldstorage = ColdStorage(temporary)
demand = DemandData()
if season == 0:
demand_ele = demand.cold_E
elif season == 1:
demand_ele = demand.heat_E
else:
demand_ele = demand.transition_E
remainder = t % 24
if (remainder >= 8) & (remainder <= 19): # 8:00-20:00
gasturbine_ele_out = gasturbine.nominal
gasturbine_fuel = gasturbine.get_fuel(gasturbine_ele_out)
boiler_heat_out_users = chp.H_out_max
boiler_heat_out = boiler_heat_out_users / (1 - Parameters.k)
absorptionchiller_cold_out = chp.C_out_max
if demand_ele[t] <= gasturbine_ele_out: # 电量先由chp提供，再由储能提供
elestorage_ele_in = gasturbine_ele_out - demand_ele[t]
elestorage_ele_out = 0
powergrid_ele_out = 0
elif ((demand_ele[t] > gasturbine_ele_out)
& (demand_ele[t] <=
gasturbine_ele_out + elestorage.get_E_out_max(ele_stor))):
elestorage_ele_in = 0
elestorage_ele_out = gasturbine_ele_out + elestorage.get_E_out_max(
ele_stor) - demand_ele[t]
powergrid_ele_out = 0
else:
elestorage_ele_in = 0
elestorage_ele_out = elestorage.get_E_out_max(ele_stor)
powergrid_ele_out = demand_ele[
t] - gasturbine_ele_out - elestorage_ele_out
if demand.H[t] <= boiler_heat_out_users:
heatstorage_heat_in = boiler_heat_out_users - demand.H[t]
heatstorage_heat_out = 0
gasboiler_heat_out = 0
elif ((demand.H[t] > boiler_heat_out_users)
& (demand.H[t] <= boiler_heat_out_users +
heatstorage.get_H_out_max(heat_stor))):
heatstorage_heat_in = 0
heatstorage_heat_out = demand.H[t] - boiler_heat_out_users
gasboiler_heat_out = 0
else:
heatstorage_heat_in = 0
heatstorage_heat_out = heatstorage.get_H_out_max(heat_stor)
gasboiler_heat_out = demand.H[
t] - boiler_heat_out_users - heatstorage_heat_out
gasboiler_fuel = gasboiler.get_Fuel_in(gasboiler_heat_out)
if demand.C[t] <= absorptionchiller_cold_out:
coldstorage_cold_in = absorptionchiller_cold_out - demand.C[t]
coldstorage_cold_out = 0
heatpump_cold_out = 0
elif ((demand.C[t] > absorptionchiller_cold_out)
& (demand.C[t] <= absorptionchiller_cold_out +
coldstorage.get_C_out_max(cold_stor))):
coldstorage_cold_in = 0
coldstorage_cold_out = demand.C[t] - absorptionchiller_cold_out
heatpump_cold_out = 0
else:
coldstorage_cold_in = 0
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
heatpump_cold_out = demand.C[
t] - absorptionchiller_cold_out - coldstorage_cold_out
heatpump_powergrid = heatpump.get_E_in(heatpump_cold_out)
else: # 20:00-凌晨8：00
gasturbine_ele_out = 0
boiler_heat_out = 0
absorptionchiller_cold_out = 0
gasturbine_fuel = 0
elestorage_ele_in = 0
heatstorage_heat_in = 0
coldstorage_cold_in = 0
if demand_ele[t] <= elestorage.get_E_out_max(ele_stor):
elestorage_ele_out = demand_ele[t]
powergrid_ele_out = 0
else:
elestorage_ele_out = elestorage.get_E_out_max(ele_stor)
powergrid_ele_out = demand_ele[t] - elestorage_ele_out
if demand.H[t] <= heatstorage.get_H_out_max(heat_stor):
heatstorage_heat_out = demand.H[t]
gasboiler_heat_out = 0
else:
heatstorage_heat_out = heatstorage.get_H_out_max(heat_stor)
gasboiler_heat_out = demand.H[t] - heatstorage_heat_out
gasboiler_fuel = gasboiler.get_Fuel_in(gasboiler_heat_out)
if demand.C[t] <= coldstorage.get_C_out_max(cold_stor):
coldstorage_cold_out = demand.C[t]
heatpump_cold_out = 0
else:
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
heatpump_cold_out = demand.C[t] - coldstorage_cold_out
heatpump_powergrid = heatpump.get_E_in(heatpump_cold_out)
result = (coldstorage_cold_in, coldstorage_cold_out, heatstorage_heat_in,
heatstorage_heat_out, elestorage_ele_in, elestorage_ele_out,
absorptionchiller_cold_out, boiler_heat_out, gasturbine_ele_out,
heatpump_cold_out, gasboiler_heat_out, powergrid_ele_out,
gasboiler_fuel, gasturbine_fuel, heatpump_powergrid)
return result
def signal_heat(t, temporary, cold_stor, heat_stor): # 储电够，储热不够
chp = CHP(temporary)
gasturbine = GasTurbine(temporary)
boiler = Boiler(temporary)
absorptionchiller = AbsorptionChiller(temporary)
gasboiler = GasBoiler(temporary)
heatpump = HeatPump(temporary)
heatstorage = HeatStorage(temporary)
coldstorage = ColdStorage(temporary)
demand = DemandData()
elestorage_ele_out = demand.E[t]
heatstorage_heat_out = heatstorage.get_H_out_max(heat_stor)
heatstorage_heat_in = 0
powergrid_ele_out = 0
if demand.H[t] <= heatstorage_heat_out + chp.H_out_max:
boiler_heat_out_users = demand.H[t] - heatstorage_heat_out
gasboiler_heat_out = 0
else:
boiler_heat_out_users = chp.H_out_max
gasboiler_heat_out = demand.H[
t] - heatstorage_heat_out - boiler_heat_out_users
boiler_heat_out = boiler_heat_out_users / (1 - Parameters.k)
boiler_heat_in = boiler.get_H_in(boiler_heat_out)
gasturbine_ele_out = boiler_heat_in / chp.heat_ele_ratio
gasturbine_fuel = gasturbine.get_fuel(gasturbine_ele_out)
absorptionchiller_cold_out = absorptionchiller.get_C_out(boiler_heat_out *
Parameters.k)
gasboiler_fuel = gasboiler.get_Fuel_in(gasboiler_heat_out)
if demand.C[t] <= coldstorage.get_C_out_max(cold_stor):
coldstorage_cold_out = demand.C[t]
coldstorage_cold_in = absorptionchiller_cold_out
heatpump_cold_out = 0
elif (
(demand.C[t] > coldstorage.get_C_out_max(cold_stor) &
(demand.C[t] <=
coldstorage.get_C_out_max(cold_stor) + absorptionchiller_cold_out))):
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
coldstorage_cold_in = coldstorage_cold_out + absorptionchiller_cold_out - demand.C[
t]
heatpump_cold_out = 0
else:
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
coldstorage_cold_in = 0
heatpump_cold_out = demand.C[
t] - coldstorage_cold_out - absorptionchiller_cold_out
heatpump_ele_in = heatpump.get_E_in(heatpump_cold_out)
if heatpump_ele_in <= gasturbine_ele_out: # 热泵的电首先由chp供电
heatpump_powergrid = 0
elestorage_ele_in = gasturbine_ele_out - heatpump_ele_in
else:
heatpump_powergrid = heatpump_ele_in - gasturbine_ele_out
elestorage_ele_in = 0
result = (coldstorage_cold_in, coldstorage_cold_out, heatstorage_heat_in,
heatstorage_heat_out, elestorage_ele_in, elestorage_ele_out,
absorptionchiller_cold_out, boiler_heat_out, gasturbine_ele_out,
heatpump_cold_out, gasboiler_heat_out, powergrid_ele_out,
gasboiler_fuel, gasturbine_fuel, heatpump_powergrid)
return result
def signal_ele(t, temporary, cold_stor, heat_stor, ele_stor): # 储电不够
chp = CHP(temporary)
gasturbine = GasTurbine(temporary)
boiler = Boiler(temporary)
absorptionchiller = AbsorptionChiller(temporary)
gasboiler = GasBoiler(temporary)
heatpump = HeatPump(temporary)
elestorage = EleStorage(temporary)
heatstorage = HeatStorage(temporary)
coldstorage = ColdStorage(temporary)
demand = DemandData()
elestorage_ele_out = elestorage.get_E_out_max(ele_stor)
elestorage_ele_in = 0
if demand.E[t] > elestorage_ele_out + chp.E_out_max:
powergrid_ele_out = demand.E[t] - elestorage_ele_out - chp.E_out_max
gasturbine_ele_out = gasturbine.nominal
else: # 可由chp系统满足
gasturbine_ele_out = demand.E[t] - elestorage_ele_out
powergrid_ele_out = 0
gasturbine_fuel = gasturbine.get_fuel(gasturbine_ele_out)
gasturbine_heat_out = gasturbine.get_H_out(gasturbine_ele_out)
boiler_heat_out = boiler.get_H_out(gasturbine_heat_out)
boiler_heat_out_users = boiler_heat_out * (1 - Parameters.k)
absorptionchiller_heat_in = boiler_heat_out * Parameters.k
absorptionchiller_cold_out = absorptionchiller.get_C_out(
absorptionchiller_heat_in)
if demand.H[t] <= heatstorage.get_H_out_max(heat_stor):
heatstorage_heat_out = demand.H[t]
heatstorage_heat_in = boiler_heat_out_users
gasboiler_heat_out = 0
elif ((demand.H[t] > heatstorage.get_H_out_max(heat_stor))
& (demand.H[t] <=
heatstorage.get_H_out_max(heat_stor) + boiler_heat_out_users)):
heatstorage_heat_out = heatstorage.get_H_out_max(heat_stor)
heatstorage_heat_in = boiler_heat_out_users + heatstorage_heat_out - demand.H[
t]
gasboiler_heat_out = 0
else: # 要用燃气锅炉
heatstorage_heat_out = heatstorage.get_H_out_max(heat_stor)
heatstorage_heat_in = 0
gasboiler_heat_out = demand.H[
t] - heatstorage_heat_out - boiler_heat_out_users
gasboiler_fuel = gasboiler.get_Fuel_in(gasboiler_heat_out)
if demand.C[t] <= coldstorage.get_C_out_max(cold_stor):
coldstorage_cold_out = demand.C[t]
coldstorage_cold_in = absorptionchiller_cold_out
heatpump_cold_out = 0
elif ((demand.C[t] > coldstorage.get_C_out_max(cold_stor)) &
(demand.C[t] <=
coldstorage.get_C_out_max(cold_stor) + absorptionchiller_cold_out)):
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
coldstorage_cold_in = coldstorage_cold_out + absorptionchiller_cold_out - demand.C[
t] / Parameters.delttime
heatpump_cold_out = 0
else:
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
coldstorage_cold_in = 0
heatpump_cold_out = (demand.C[t] -
coldstorage.get_C_out_max(cold_stor) -
absorptionchiller_cold_out)
heatpump_powergrid = heatpump.get_E_in(heatpump_cold_out) # 此时热泵耗电全部由电网提供
result = (coldstorage_cold_in, coldstorage_cold_out, heatstorage_heat_in,
heatstorage_heat_out, elestorage_ele_in, elestorage_ele_out,
absorptionchiller_cold_out, boiler_heat_out, gasturbine_ele_out,
heatpump_cold_out, gasboiler_heat_out, powergrid_ele_out,
gasboiler_fuel, gasturbine_fuel, heatpump_powergrid)
return result
def signal_cold(t, temporary, cold_stor, heat_stor, ele_stor): # 储冷不够
chp = CHP(temporary)
gasturbine = GasTurbine(temporary)
boiler = Boiler(temporary)
absorptionchiller = AbsorptionChiller(temporary)
gasboiler = GasBoiler(temporary)
heatpump = HeatPump(temporary)
elestorage = EleStorage(temporary)
heatstorage = HeatStorage(temporary)
coldstorage = ColdStorage(temporary)
demand = DemandData()
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
coldstorage_cold_in = 0
if demand.C[t] > (coldstorage.get_C_out_max(cold_stor) + chp.C_out_max):
# 储冷 + CHP + 热泵满足
heatpump_cold_out = demand.C[t] - coldstorage.get_C_out_max(
cold_stor) - chp.C_out_max
# 热泵产冷
absorptionchiller_cold_out = chp.C_out_max
else: # 储冷+ CHP 满足
heatpump_cold_out = 0
absorptionchiller_cold_out = demand.C[t] - coldstorage.get_C_out_max(
cold_stor)
heatpump_ele_in = heatpump.get_E_in(heatpump_cold_out) # 热泵耗电
absorptionchiller_heat_in = absorptionchiller.get_H_in(
absorptionchiller_cold_out)
boiler_heat_out = absorptionchiller_heat_in / Parameters.k
boiler_heat_out_users = boiler_heat_out * (1 - Parameters.k)
boiler_heat_in = boiler.get_H_in(boiler_heat_out)
gasturbine_heat_out = boiler_heat_in
gasturbine_ele_out = gasturbine_heat_out / chp.heat_ele_ratio
gasturbine_fuel = gasturbine.get_fuel(gasturbine_ele_out)
if gasturbine_ele_out >= heatpump_ele_in:
gasturbine_ele_out_users = gasturbine_ele_out - heatpump_ele_in # 别忘了
heatpump_powergrid = 0
else:
gasturbine_ele_out_users = 0
heatpump_powergrid = heatpump_ele_in - gasturbine_ele_out
if demand.H[t] <= heatstorage.get_H_out_max(heat_stor): # 储热即可满足
heatstorage_heat_in = boiler_heat_out_users
heatstorage_heat_out = demand.H[t]
gasboiler_heat_out = 0
elif ((demand.H[t] > heatstorage.get_H_out_max(heat_stor)) &
(demand.H[t] <=
boiler_heat_out_users + heatstorage.get_H_out_max(heat_stor))):
# 储热+ CHP 满足，多余存入储热
heatstorage_heat_in = boiler_heat_out_users + heatstorage.get_H_out_max(
heat_stor) - demand.H[t]
# 储热先供热，CHP产热再存入储热
heatstorage_heat_out = heatstorage.get_H_out_max(heat_stor)
gasboiler_heat_out = 0
else: # DemandData.H[t] > (boiler_heat_out_users + heatstorage.get_H_out_max(heat_stor)): # 储热+ CHP + 燃气锅炉 满足
gasboiler_heat_out = demand.H[
t] - boiler_heat_out_users - heatstorage.get_H_out_max(heat_stor)
heatstorage_heat_in = 0
heatstorage_heat_out = heatstorage.get_H_out_max(heat_stor)
gasboiler_fuel = gasboiler.get_Fuel_in(gasboiler_heat_out)
if demand.E[t] <= elestorage.get_E_out_max(ele_stor): # 储电满足
elestorage_ele_in = gasturbine_ele_out_users
elestorage_ele_out = demand.E[t]
powergrid_ele_out = 0
elif ((demand.E[t] > elestorage.get_E_out_max(ele_stor)) &
(demand.E[t] <=
elestorage.get_E_out_max(ele_stor) + gasturbine_ele_out_users)):
# 储电 + CHP 满足，多余存入储电
elestorage_ele_in = elestorage.get_E_out_max(
ele_stor) + gasturbine_ele_out_users - demand.E[t]
elestorage_ele_out = elestorage.get_E_out_max(ele_stor)
powergrid_ele_out = 0
else: # 储电+ CHP + 电网
elestorage_ele_in = 0
elestorage_ele_out = elestorage.get_E_out_max(ele_stor)
powergrid_ele_out = (demand.E[t] - elestorage.get_E_out_max(ele_stor) -
gasturbine_ele_out_users)
result = (coldstorage_cold_in, coldstorage_cold_out, heatstorage_heat_in,
heatstorage_heat_out, elestorage_ele_in, elestorage_ele_out,
absorptionchiller_cold_out, boiler_heat_out, gasturbine_ele_out,
heatpump_cold_out, gasboiler_heat_out, powergrid_ele_out,
gasboiler_fuel, gasturbine_fuel, heatpump_powergrid) # 15 项
return result
def __init__(self, temporary, number):
heat_stor = 0
cold_stor = 0
ele_stor = 0
chp = CHPInternalCombustionEngine(temporary, number)
ice = InternalCombustionEngine(number, temporary)
absorption_chiller = DoubleEffectAbsorptionChiller(temporary)
gas_boiler = GasBoiler(temporary)
heat_pump = HeatPump(temporary)
heatstorage = HeatStorage(temporary)
coldstorage = ColdStorage(temporary)
elestorage = EleStorage(temporary)
demand = DemandData()
time = demand.E_sheetnrows - 1
self.fuel = []
self.ele_bought = []
self.ele_ice = []
self.heat = []
self.heat_gas_boiler = []
self.cold_absorption_chiller = []
self.cold_heat_pump = []
self.cold_waste = []
self.heat_waste = []
self.ele_waste = []
for t in range(0, time, Parameters.delttime):
if demand.C[t] > coldstorage.get_C_out_max(
cold_stor
) + chp.cold_out_max_exhaust_gas + heat_pump.nominal:
self.judge = 0
else:
judge_cold = min(
demand.C[t] - coldstorage.get_C_out_max(cold_stor),
chp.cold_out_max_exhaust_gas)
judge_heat = chp.get_heat_water_though_cold(judge_cold)
if demand.H[t] > heatstorage.get_H_out_max(
heat_stor) + judge_heat + gas_boiler.nominal:
self.judge = 0
else:
self.judge = 1
if self.judge == 0:
break
else:
heat_drive = HeatDriveJW(t, temporary, number, heat_stor)
if heat_drive.heat == 0:
cold_drive = ColdDrive(t, temporary, number, cold_stor)
if cold_drive.cold == 0:
ele_drive = EleDrive(t, temporary, number, ele_stor, 2)
ele_stor = ele_drive.ele_stor
ele = ele_drive.ele
pl = ele / ice.nominal
heat = ice.get_jacket_water_pl(pl)
cold = ice.get_exhaust_gas_pl(
pl) * absorption_chiller.COP_double
cold_heat_pump = []
cold_stor = coldstorage.get_S(
cold_stor, cold, cold_drive.coldstorage_out)
heat_stor = heatstorage.get_S(
heat_stor, heat, heat_drive.heatstorage_out)
self.fuel.append(ice.get_fuel(ele / ice.nominal))
self.ele_bought.append(ele_drive.ele_bought)
else:
cold = cold_drive.cold
cold_heat_pump = cold_drive.heat_pump_out
cold_stor = cold_drive.cold_stor
exhaust_gas = cold_drive.cold / absorption_chiller.COP_double
pl = ice.get_pl_through_exhaust_gas(exhaust_gas)
ele = pl * ice.nominal
heat = ice.get_jacket_water_pl(pl)
heat_stor = heatstorage.get_S(
heat_stor, heat, heat_drive.heatstorage_out)
ele_follow = EleFollow(t, temporary, ele_stor, ele, 2)
ele_stor = ele_follow.ele_stor
self.fuel.append(ice.get_fuel(pl))
self.ele_bought.append(
ele_follow.ele_bought +
heat_pump.get_E_in(cold_drive.heat_pump_out))
gas_boiler_out = 0
else:
heat_stor = heat_drive.heat_stor
heat = heat_drive.heat
pl = ice.get_pl_through_jacket_water(heat_drive.heat)
ele = pl * ice.nominal
cold = ice.get_exhaust_gas_pl(
pl) * absorption_chiller.COP_double
cold_follow = ColdFollow(t, temporary, cold_stor, cold)
cold_heat_pump = cold_follow.heat_pump_out
cold_stor = cold_follow.cold_stor
ele_follow = EleFollow(t, temporary, ele_stor, ele, 2)
ele_stor = ele_follow.ele_stor
gas_boiler_out = heat_drive.gas_boiler_out
self.fuel.append(
ice.get_fuel(pl) +
gas_boiler.get_Fuel_in(heat_drive.gas_boiler_out))
self.ele_bought.append(
ele_follow.ele_bought +
heat_pump.get_E_in(cold_follow.heat_pump_out))
self.ele_ice.append(ele)
self.heat.append(heat)
self.heat_gas_boiler.append(gas_boiler_out)
self.cold_absorption_chiller.append(cold)
self.cold_heat_pump.append(cold_heat_pump)
if cold_stor > coldstorage.nominal:
self.cold_waste.append(cold_stor - coldstorage.nominal)
cold_stor = coldstorage.nominal
else:
self.cold_waste.append(0)
if heat_stor > heatstorage.nominal:
self.heat_waste.append(heat_stor - heatstorage.nominal)
heat_stor = heatstorage.nominal
else:
self.heat_waste.append(0)
if ele_stor > elestorage.nominal:
self.ele_waste.append(ele_stor - elestorage.nominal)
ele_stor = elestorage.nominal
else:
self.ele_waste.append(0)
def __init__(self, temporary, number):
cold_stor = 0
ele_stor = 0
chp = CHPInternalCombustionEngine(temporary, number)
heat_pump = HeatPump(temporary)
absorption_chiller = DoubleEffectAbsorptionChiller(temporary)
coldstorage = ColdStorage(temporary)
elestorage = EleStorage(temporary)
ice = InternalCombustionEngine(number, temporary)
demand = DemandData()
time = demand.E_sheetnrows - 1
self.ele_bought = []
self.fuel = []
self.ele_ice = []
self.cold_absorption_chiller = []
self.cold_heat_pump = []
self.cold_waste = []
self.ele_waste = []
for t in range(0, time, Parameters.delttime):
if demand.C[t] > coldstorage.get_C_out_max(
cold_stor) + chp.cold_out_max + heat_pump.nominal:
self.judge = 0
break
else:
self.judge = 1
cold_drive = ColdDrive(t, temporary, number, cold_stor)
if cold_drive.cold == 0:
ele_drive = EleDrive(t, temporary, number, ele_stor, 0)
ele_stor = ele_drive.ele_stor
ele = ele_drive.ele
pl = ele / ice.nominal
exhaust_gas = ice.get_exhaust_gas_pl(pl)
jacket_water = ice.get_jacket_water_pl(pl)
cold = absorption_chiller.get_cold_out(
exhaust_gas, jacket_water)
cold_stor = coldstorage.get_S(cold_stor, cold,
cold_drive.coldstorage_out)
self.cold_heat_pump.append(0)
self.ele_bought.append(ele_drive.ele_bought)
self.fuel.append(ice.get_fuel(ele_drive.ele / ice.nominal))
else:
cold = cold_drive.cold
cold_stor = cold_drive.cold_stor
ele = ice.get_ele_out_through_cold(cold_drive.cold)
ele_follow = EleFollow(t, temporary, ele_stor, ele, 0)
ele_stor = ele_follow.ele_stor
self.cold_heat_pump.append(cold_drive.heat_pump_out)
self.ele_bought.append(
heat_pump.get_E_in(cold_drive.heat_pump_out) +
ele_follow.ele_bought)
self.fuel.append(ice.get_fuel(ele / ice.nominal))
self.ele_ice.append(ele)
self.cold_absorption_chiller.append(cold)
if cold_stor > coldstorage.nominal:
self.cold_waste.append(cold_stor - coldstorage.nominal)
cold_stor = coldstorage.nominal
else:
self.cold_waste.append(0)
if ele_stor > elestorage.nominal:
self.ele_waste.append(ele_stor - elestorage.nominal)
ele_stor = elestorage.nominal
else:
self.ele_waste.append(0)
def __init__(self, temporary, number):
demand = DemandData()
heatstorage = HeatStorage(temporary)
coldstorage = ColdStorage(temporary)
elestorage = EleStorage(temporary)
gas_boiler = GasBoiler(temporary)
heat_pump = HeatPump(temporary)
ice = InternalCombustionEngine(number, temporary)
chp = CHPInternalCombustionEngine(temporary, number)
heat_stor = 0
ele_stor = 0
cold_stor = 0
self.fuel = []
self.ele_bought = []
self.ele_ice = []
self.heat_jacket_water = []
self.heat_gas_boiler = []
self.cold_absorption_chiller = []
self.cold_heat_pump = []
self.cold_waste = []
self.heat_waste = []
self.ele_waste = []
for t in range(7, 23, Parameters.delttime):
if ((demand.C[t] > chp.cold_out_max_exhaust_gas +
coldstorage.get_C_out_max(cold_stor) + heat_pump.nominal)
|
(demand.H[t] >
(ice.get_jacket_water_pl(1) +
heatstorage.get_H_out_max(heat_stor) + gas_boiler.nominal))):
self.judge = 0
break
else:
self.judge = 1
ele = ice.nominal
heat = ice.get_jacket_water_pl(1)
cold = chp.cold_out_max_exhaust_gas
if demand.C[t] <= cold:
coldstorage_cold_in = cold - demand.C[t]
coldstorage_cold_out = 0
cold_heat_pump = 0
ele_needed_for_heat_pump = 0
elif (demand.C[t] >
cold) & (demand.C[t] <=
cold + coldstorage.get_C_out_max(cold_stor)):
coldstorage_cold_out = coldstorage.get_C_out_max(
cold_stor) + cold - demand.C[t]
coldstorage_cold_in = 0
cold_heat_pump = 0
ele_needed_for_heat_pump = 0
else:
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
coldstorage_cold_in = 0
cold_heat_pump = demand.C[t] - coldstorage_cold_out - cold
ele_needed_for_heat_pump = heat_pump.get_E_in(
cold_heat_pump)
cold_stor = coldstorage.get_S(cold_stor, coldstorage_cold_in,
coldstorage_cold_out)
if demand.transition_E <= ele:
ele_bought_for_ele = 0
if ele_needed_for_heat_pump > 0:
if ele - demand.transition_E[
t] >= ele_needed_for_heat_pump:
elestorage_ele_in = ele - demand.transition_E[
t] - ele_needed_for_heat_pump
elestorage_ele_out = 0
ele_bought_for_heat_pump = 0
else:
elestorage_ele_in = 0
elestorage_ele_out = 0
ele_bought_for_heat_pump = ele_needed_for_heat_pump - (
ele - demand.transition_E[t])
else:
ele_bought_for_heat_pump = 0
elestorage_ele_out = 0
elestorage_ele_in = ele - demand.transition_E[t]
elif(demand.transition_E[t] > ele) \
& (demand.transition_E[t] < ele + elestorage.get_E_out_max(ele_stor)):
ele_bought_for_ele = 0
elestorage_ele_out = demand.transition_E[t] - ele
elestorage_ele_in = 0
ele_bought_for_heat_pump = ele_needed_for_heat_pump
else:
ele_bought_for_ele = demand.transition_E[
t] - ele - elestorage.get_E_out_max(ele_stor)
elestorage_ele_out = elestorage.get_E_out_max(ele_stor)
elestorage_ele_in = 0
ele_bought_for_heat_pump = ele_needed_for_heat_pump
ele_stor = elestorage.get_S(ele_stor, elestorage_ele_in,
elestorage_ele_out)
ele_bought = ele_bought_for_heat_pump + ele_bought_for_ele
if demand.H[t] <= heat:
heatstorage_heat_out = 0
heatstorage_heat_in = heat - demand.H[t]
heat_gas_boiler = 0
elif (demand.H[t] >
heat) & (demand.H[t] <=
heat + heatstorage.get_H_out_max(heat_stor)):
heatstorage_heat_out = demand.H[t] - heat
heatstorage_heat_in = 0
heat_gas_boiler = 0
else:
heatstorage_heat_out = heatstorage.get_H_out_max(heat_stor)
heatstorage_heat_in = 0
heat_gas_boiler = demand.H[
t] - heat - heatstorage.get_H_out_max(heat_stor)
heat_stor = heatstorage.get_S(heat_stor, heatstorage_heat_in,
heatstorage_heat_out)
if cold_stor > coldstorage.nominal:
self.cold_waste.append(cold_stor - coldstorage.nominal)
cold_stor = coldstorage.nominal
else:
self.cold_waste.append(0)
if heat_stor > heatstorage.nominal:
self.heat_waste.append(heat_stor - heatstorage.nominal)
heat_stor = heatstorage.nominal
else:
self.heat_waste.append(0)
if ele_stor > elestorage.nominal:
self.ele_waste.append(ele_stor - elestorage.nominal)
ele_stor = elestorage.nominal
else:
self.ele_waste.append(0)
self.ele_ice.append(ele)
self.heat_jacket_water.append(heat)
self.cold_absorption_chiller.append(cold)
self.cold_heat_pump.append(cold_heat_pump)
self.heat_gas_boiler.append(heat_gas_boiler)
self.ele_bought.append(ele_bought)
self.fuel.append(
ice.get_fuel(1) + gas_boiler.get_Fuel_in(heat_gas_boiler))
if self.judge == 1:
for t in range(23, 24, Parameters.delttime):
cold_during_shut_down = ColdDuringShutDown(
temporary, t, cold_stor)
heat_during_sut_down = HeatDuringShutDown(
temporary, t, heat_stor)
ele_during_shut_down = EleDuringShutDown(
temporary, t, ele_stor, 2)
cold_stor = cold_during_shut_down.cold_stor
heat_stor = heat_during_sut_down.heat_stor
ele_stor = ele_during_shut_down.ele_stor
self.cold_heat_pump.append(
cold_during_shut_down.cold_heat_pump)
self.heat_gas_boiler.append(
heat_during_sut_down.heat_gas_boiler)
self.fuel.append(heat_during_sut_down.fuel)
self.ele_bought.append(
cold_during_shut_down.ele_bought_for_heat_pump +
ele_during_shut_down.ele_bought_for_ele)
for t in range(0, 7, Parameters.delttime):
cold_during_shut_down = ColdDuringShutDown(
temporary, t, cold_stor)
heat_during_sut_down = HeatDuringShutDown(
temporary, t, heat_stor)
ele_during_shut_down = EleDuringShutDown(
temporary, t, ele_stor, 2)
cold_stor = cold_during_shut_down.cold_stor
heat_stor = heat_during_sut_down.heat_stor
ele_stor = ele_during_shut_down.ele_stor
self.cold_heat_pump.append(
cold_during_shut_down.cold_heat_pump)
self.heat_gas_boiler.append(
heat_during_sut_down.heat_gas_boiler)
self.fuel.append(heat_during_sut_down.fuel)
self.ele_bought.append(
cold_during_shut_down.ele_bought_for_heat_pump +
ele_during_shut_down.ele_bought_for_ele)
def __init__(self, temporary, number):
chp = CHPInternalCombustionEngine(temporary, number)
heat_pump = HeatPump(temporary)
elestorage = EleStorage(temporary)
coldstorage = ColdStorage(temporary)
ice = InternalCombustionEngine(number, temporary)
demand = DemandData()
cold_stor = 0
ele_stor = 0
self.fuel = []
self.ele_bought = []
self.ele_ice = []
self.cold_absorption_chiller = []
self.cold_heat_pump = []
self.cold_waste = []
self.ele_waste = []
for t in range(7, 23, Parameters.delttime):
ele = ice.nominal
cold = chp.cold_out_max
if demand.C[t] > cold + coldstorage.get_C_out_max(
cold_stor) + heat_pump.nominal:
self.judge = 0
break
else:
self.judge = 1
if demand.C[t] <= cold:
cold_stor = coldstorage.get_S(cold_stor,
cold - demand.C[t], 0)
cold_heat_pump = 0
ele_needed_for_heat_pump = 0
elif (demand.C[t] >
cold) & (demand.C[t] <=
(cold + coldstorage.get_C_out_max(cold_stor))):
coldstorage_cold_out = coldstorage.get_C_out_max(
cold_stor) + cold - demand.C[t]
cold_stor = coldstorage.get_S(cold_stor, 0,
coldstorage_cold_out)
cold_heat_pump = 0
ele_needed_for_heat_pump = 0
else:
coldstorage_cold_out = coldstorage.get_C_out_max(cold_stor)
cold_heat_pump = demand.C[t] - coldstorage.get_C_out_max(
cold_stor) - cold
ele_needed_for_heat_pump = heat_pump.get_E_in(
cold_heat_pump)
cold_stor = coldstorage.get_S(cold_stor, 0,
coldstorage_cold_out)
if demand.cold_E[t] <= ele:
ele_bought_for_ele = 0
if ele_needed_for_heat_pump > 0:
if ele - demand.cold_E[t] >= ele_needed_for_heat_pump:
elestorage_ele_in = ele - demand.cold_E[
t] - ele_needed_for_heat_pump
ele_bought_for_heat_pump = 0
else:
elestorage_ele_in = 0
ele_bought_for_heat_pump = ele_needed_for_heat_pump - (
ele - demand.cold_E[t])
else:
elestorage_ele_in = ele - demand.cold_E[t]
ele_bought_for_heat_pump = 0
ele_stor = elestorage.get_S(ele_stor, elestorage_ele_in, 0)
elif (demand.cold_E[t] >
ele) & (demand.cold_E[t] <=
(ele + elestorage.get_E_out_max(ele_stor))):
ele_bought_for_ele = 0
ele_bought_for_heat_pump = ele_needed_for_heat_pump
elestorage_ele_out = ele + elestorage.get_E_out_max(
ele_stor) - demand.cold_E[t]
ele_stor = elestorage.get_S(ele_stor, 0,
elestorage_ele_out)
else:
ele_bought_for_heat_pump = ele_needed_for_heat_pump
ele_bought_for_ele = demand.cold_E[
t] - ele - elestorage.get_E_out_max(ele_stor)
elestorage_ele_out = elestorage.get_E_out_max(ele_stor)
ele_stor = elestorage.get_S(ele_stor, 0,
elestorage_ele_out)
if cold_stor > coldstorage.nominal:
self.cold_waste.append(cold_stor - coldstorage.nominal)
cold_stor = coldstorage.nominal
else:
self.cold_waste.append(0)
if ele_stor > elestorage.nominal:
self.ele_waste.append(ele_stor - elestorage.nominal)
ele_stor = elestorage.nominal
else:
self.ele_waste.append(0)
self.ele_ice.append(ele)
self.cold_absorption_chiller.append(cold)
self.cold_heat_pump.append(cold_heat_pump)
self.ele_bought.append(ele_bought_for_heat_pump +
ele_bought_for_ele)
self.fuel.append(ice.get_fuel(1))
if self.judge == 1:
for t in range(23, 24, Parameters.delttime):
# 把以下cold，ele，heat部分写成class
cold_during_shut_down = ColdDuringShutDown(
temporary, t, cold_stor)
ele_during_shut_down = EleDuringShutDown(
temporary, t, ele_stor, 0)
cold_stor = cold_during_shut_down.cold_stor
ele_stor = ele_during_shut_down.ele_stor
self.ele_ice.append(0)
self.cold_absorption_chiller.append(0)
self.cold_heat_pump.append(
cold_during_shut_down.cold_heat_pump)
self.ele_bought.append(
ele_during_shut_down.ele_bought_for_ele +
cold_during_shut_down.ele_bought_for_heat_pump)
self.fuel.append(0)
for t in range(0, 7, Parameters.delttime):
cold_during_shut_down = ColdDuringShutDown(
temporary, t, cold_stor)
ele_during_shut_down = EleDuringShutDown(
temporary, t, ele_stor, 0)
cold_stor = cold_during_shut_down.cold_stor
ele_stor = ele_during_shut_down.ele_stor
self.ele_ice.append(0)
self.cold_absorption_chiller.append(0)
self.cold_heat_pump.append(
cold_during_shut_down.cold_heat_pump)
self.ele_bought.append(
ele_during_shut_down.ele_bought_for_ele +
cold_during_shut_down.ele_bought_for_heat_pump)
self.fuel.append(0)
def __init__(self, temporary, number):
demand = DemandData()
heatstorage = HeatStorage(temporary)
coldstorage = ColdStorage(temporary)
elestorage = EleStorage(temporary)
gas_boiler = GasBoiler(temporary)
heat_pump = HeatPump(temporary)
ice = InternalCombustionEngine(number, temporary)
absorption_chiller = DoubleEffectAbsorptionChiller(temporary)
chp = CHPInternalCombustionEngine(temporary, number)
time = demand.E_sheetnrows - 1
heat_stor = 0
ele_stor = 0
cold_stor = 0
self.fuel = []
self.ele_bought = []
self.ele_ice = []
self.heat = []
self.heat_gas_boiler = []
self.cold_absorption_chiller = []
self.cold_heat_pump = []
self.cold_waste = []
self.heat_waste = []
self.ele_waste = []
for t in range(0, time, Parameters.delttime):
ele = min(demand.transition_E[t] - elestorage.get_E_out_max(ele_stor), ice.nominal)
cold_heat = chp.get_cold_and_heat_through_ele(ele)
judge_cold = cold_heat[0]
judge_heat = cold_heat[1]
if ((demand.C[t] > coldstorage.get_C_out_max(cold_stor) + judge_cold + heat_pump.nominal)
| (demand.H[t] > heatstorage.get_H_out_max(heat_stor) + judge_heat + gas_boiler.nominal)):
self.judge = 0
break
else:
self.judge = 1
ele_drive = EleDrive(t, temporary, number, ele_stor, 2)
if ele_drive == 0:
heat_drive = HeatDriveJW(t, temporary, number, heat_stor)
gas_boiler_out = heat_drive.gas_boiler_out
if heat_drive == 0:
cold_drive = ColdDrive(t, temporary, number, cold_stor)
cold = cold_drive.cold
exhaust_gas = cold / absorption_chiller.COP_double
pl = ice.get_pl_through_exhaust_gas(exhaust_gas)
ele = pl * ice.nominal
heat = ice.get_jacket_water_pl(pl)
cold_stor = cold_drive.cold_stor
heat_stor = heatstorage.get_S(heat_stor, heat, heat_drive.heatstorage_out)
ele_stor = elestorage.get_S(ele_stor, ele, ele_drive.elestorage_out)
self.cold_heat_pump.append(cold_drive.heat_pump_out)
self.fuel.append(ice.get_fuel(pl))
self.ele_bought.append(heat_pump.get_E_in(cold_drive.heat_pump_out))
else:
heat = heat_drive.heat
pl = ice.get_pl_through_jacket_water(heat)
ele = pl * ice.nominal
exhaust_gas = ice.get_exhaust_gas_pl(pl)
cold = exhaust_gas * absorption_chiller.COP_double
cold_follow = ColdFollow(t, temporary, cold_stor, cold)
cold_stor = cold_follow.cold_stor
heat_stor = heat_drive.heat_stor
ele_stor = elestorage.get_S(ele_stor, ele, ele_drive.elestorage_out)
self.cold_heat_pump.append(cold_follow.heat_pump_out)
self.fuel.append(ice.get_fuel(pl) + gas_boiler.get_Fuel_in(heat_drive.gas_boiler_out))
self.ele_bought.append(heat_pump.get_E_in(cold_follow.heat_pump_out))
else:
ele = ele_drive.ele
pl = ele / ice.nominal
heat = ice.get_jacket_water_pl(pl)
cold = ice.get_exhaust_gas_pl(pl) * absorption_chiller.COP_double
heat_follow = HeatFollow(t, temporary, heat_stor, heat)
cold_follow = ColdFollow(t, temporary, cold_stor, cold)
gas_boiler_out = heat_follow.gas_boiler_out
cold_stor = cold_follow.cold_stor
heat_stor = heat_follow.heat_stor
ele_stor = ele_drive.ele_stor
self.cold_heat_pump.append(cold_follow.heat_pump_out)
self.fuel.append(ice.get_fuel(pl) + gas_boiler.get_Fuel_in(heat_follow.gas_boiler_out))
self.ele_bought.append(ele_drive.ele_bought + heat_pump.get_E_in(cold_follow.heat_pump_out))
self.ele_ice.append(ele)
self.heat.append(heat)
self.heat_gas_boiler.append(gas_boiler_out)
self.cold_absorption_chiller.append(cold)
if cold_stor > coldstorage.nominal:
self.cold_waste.append(cold_stor - coldstorage.nominal)
cold_stor = coldstorage.nominal
else:
self.cold_waste.append(0)
if heat_stor > heatstorage.nominal:
self.heat_waste.append(heat_stor - heatstorage.nominal)
heat_stor = heatstorage.nominal
else:
self.heat_waste.append(0)
if ele_stor > elestorage.nominal:
self.ele_waste.append(ele_stor - elestorage.nominal)
ele_stor = elestorage.nominal
else:
self.ele_waste.append(0)
def __init__(self, temporary, number):
heat_stor = 0
cold_stor = 0
ele_stor = 0
chp = CHPInternalCombustionEngine(temporary, number)
ice = InternalCombustionEngine(number, temporary)
boiler = Boiler(temporary)
absorption_chiller = DoubleEffectAbsorptionChiller(temporary)
gas_boiler = GasBoiler(temporary)
heat_pump = HeatPump(temporary)
heatstorage = HeatStorage(temporary)
coldstorage = ColdStorage(temporary)
elestorage = EleStorage(temporary)
demand = DemandData()
time = demand.E_sheetnrows - 1
sum_heat = sum(demand.H)
sum_cold = sum(demand.C)
jacket_water_k = sum_cold / (sum_cold + sum_heat)
fuel = []
ele_bought = []
ele_ice = []
heat_boiler = []
cold_absorption_chiller = []
for t in range(0, time, Parameters.delttime):
if demand.H_steam[t] > chp.heat_steam_out_max + gas_boiler.nominal:
self.judge = 0
else:
judge_heat_steam = min(demand.H_steam[t],
chp.heat_steam_out_max)
judge_heat = chp.get_heat_through_steam(
judge_heat_steam, jacket_water_k)
judge_cold = chp.get_cold_through_steam(
judge_heat_steam, jacket_water_k)
if ((demand.H[t] + demand.H_steam[t] >
heatstorage.get_H_out_max(heat_stor) + judge_heat +
chp.heat_steam_out_max + gas_boiler.nominal)
| (demand.C[t] > coldstorage.get_C_out_max(cold_stor) +
judge_cold + heat_pump.nominal)):
self.judge = 0
else:
self.judge = 1
if self.judge == 0:
break
else:
heat_steam_drive = HeatSteamDrive(t, temporary, number)
self.heat_steam = heat_steam_drive.steam
self.gas_boiler_for_steam = heat_steam_drive.gas_boiler_out_for_steam
exhaust_gas = boiler.get_H_in(self.heat_steam)
pl = ice.get_pl_through_exhaust_gas(exhaust_gas)
self.ele = pl * ice.nominal
jacket_water = ice.get_jacket_water_pl(pl)
self.heat_for_other = jacket_water * (1 - jacket_water_k)
if jacket_water * jacket_water_k * absorption_chiller.COP_single >= absorption_chiller.nominal:
self.cold = absorption_chiller.nominal
else:
self.cold = jacket_water * jacket_water_k * absorption_chiller.COP_single
heat_follow = HeatFollow(t, temporary, heat_stor,
self.heat_for_other)
heat_stor = heat_follow.heat_stor
self.gas_boiler_for_other = heat_follow.gas_boiler_out
self.gas_boiler_total = self.gas_boiler_for_steam + self.gas_boiler_for_other
cold_follow = ColdFollow(t, temporary, cold_stor, self.cold)
cold_stor = cold_follow.cold_stor
ele_follow = EleFollow(t, temporary, ele_stor, self.ele)
ele_stor = ele_follow.ele_stor
fuel.append(
ice.get_fuel(pl) +
gas_boiler.get_Fuel_in(self.gas_boiler_total))
ele_bought.append(
ele_follow.ele_bought +
heat_pump.get_E_in(cold_follow.heat_pump_out))
ele_ice.append(self.ele)
heat_boiler.append(self.heat_steam + self.gas_boiler_total)
cold_absorption_chiller.append(self.cold)
if cold_stor > coldstorage.nominal:
cold_stor = coldstorage.nominal
if heat_stor > heatstorage.nominal:
heat_stor = heatstorage.nominal
if ele_stor > elestorage.nominal:
ele_stor = elestorage.nominal
self.fuel = sum(fuel)
self.ele_bought = sum(ele_bought)
self.emission_calculate_ice = sum(ele_ice)
self.emission_calculate_boiler = sum(heat_boiler)
self.emission_calculate_absorption_chiller = sum(
cold_absorption_chiller)
self.emission_calculate_grid = self.ele_bought