def testHeatExchanger(self):
T_1_in = 50.
P_1 = 4.e6
m_dot_1 = 1.5
fluid_1 = 'R245fa'
T_2_in = 170.
m_dot_2 = 1.
fluid_2 = 'Water'
P_2 = FluidState.getStateFromTQ(T_2_in, 0, fluid_2).P_Pa + 100e3
dT_pinch = 5.
results = heatExchanger(T_1_in, P_1, m_dot_1, fluid_1, T_2_in, P_2,
m_dot_2, fluid_2, dT_pinch)
self.assertTrue(*testAssert(results.Q_exchanged, 303373.3383,
'testHeatExchanger_Q_exchanged'))
self.assertTrue(*testAssert(results.dT_LMTD, 11.48176,
'testHeatExchanger_dT_LMTD'))
self.assertTrue(*testAssert(results.T_1_out, 159.2937,
'testHeatExchanger_T_1_out'))
self.assertTrue(*testAssert(results.T_2_out, 99.01979,
'testHeatExchanger_T_2_out'))
self.assertTrue(
*testAssert(results.T_1[3], 71.79053, 'testHeatExchanger_T_1'))
self.assertTrue(
*testAssert(results.T_2[3], 109.80985, 'testHeatExchanger_T_2'))
self.assertTrue(
*testAssert(results.Q[3], 45526.17687, 'testHeatExchanger_Q'))
def __init__(self):
self.params.T_reservoir = lambda: abs(self.params.depth) * abs(
self.params.dT_dz) + self.params.T_surface_rock
self.params.P_reservoir = lambda: abs(self.params.depth
) * 1000. * self.params.g
self.params.P_reservoir_max = lambda: abs(self.params.depth
) * 2500. * self.params.g
self.params.P_system_min = lambda: FluidState.getStateFromTQ(
self.params.T_reservoir(), 0, self.params.working_fluid).P_Pa + 1e5
def maxSubcritORCBoilTemp(orc_fluid):
P_crit = FluidState.getPcrit(orc_fluid)
# assume min pressure is condensing at 0C
P_min = FluidState.getStateFromTQ(0, 1, orc_fluid).P_Pa
dP = (P_crit - P_min) / 1000
# find pressure with maximum entropy
P = np.arange(P_min, P_crit, dP)
s = FluidState.getStateFromPQ(P, 1, orc_fluid).s_JK
max_s = np.max(s)
row_index = np.argmax(s, axis=0)
max_P = P[row_index]
return FluidState.getStateFromPS(max_P, max_s, orc_fluid).T_C
def testHeatExchangerOptMdot(self):
T_1_in = 50.
P_1 = 4.e6
fluid_1 = 'R245fa'
T_2_in = 170.
fluid_2 = 'Water'
P_2 = FluidState.getStateFromTQ(T_2_in, 0, fluid_2).P_Pa + 100e3
dT_pinch = 5.
T_min = 165.
maximizeHeatFromStream = '2'
results = heatExchangerOptMdot(T_1_in, P_1, fluid_1, T_2_in, P_2,
fluid_2, dT_pinch, T_min,
maximizeHeatFromStream)
self.assertTrue(*testAssert(results.Q_exchanged, 229529.519513,
'testHeatExchangerOptMdot_Q_exchanged'))
self.assertTrue(*testAssert(results.dT_LMTD, 12.601838,
'testHeatExchangerOptMdot_dT_LMTD'))
self.assertTrue(*testAssert(results.T_1_out, 163.475171347679,
'testHeatExchangerOptMdot_T_1_out'))
self.assertTrue(*testAssert(results.T_2_out, 131.20944977165277,
'testHeatExchangerOptMdot_T_2_out'))
self.assertTrue(*testAssert(results.T_1[3], 74.66059924618094,
'testHeatExchangerOptMdot_T_1'))
self.assertTrue(*testAssert(results.T_2[3], 137.08472742745016,
'testHeatExchangerOptMdot_T_2'))
self.assertTrue(*testAssert(results.Q[3], 34450.560624389356,
'testHeatExchangerOptMdot_Q'))
self.assertTrue(*testAssert(results.q_exchanged_1, 229529.51951325324,
'testHeatExchangerOptMdot_q_exchanged_1'))
self.assertTrue(*testAssert(results.q_exchanged_2, 167077.85548339653,
'testHeatExchangerOptMdot_q_exchanged_2'))
self.assertTrue(*testAssert(results.mdot_ratio, 1.3737878,
'testHeatExchangerOptMdot_mdot_ratio'))
self.assertTrue(*testAssert(results.m_dot_1, 1,
'testHeatExchangerOptMdot_m_dot_1'))
self.assertTrue(*testAssert(results.m_dot_2, 1.3737878,
'testHeatExchangerOptMdot_m_dot_2'))
def solve(self, initialState, T_boil_C=False, dT_pinch=False):
T_in_C = initialState.T_C
if not T_boil_C:
T_boil_C = np.interp(
T_in_C,
self.data[self.params.opt_mode][self.params.orc_fluid][:, 0],
self.data[self.params.opt_mode][self.params.orc_fluid][:, 1])
if not dT_pinch:
dT_pinch = np.interp(
T_in_C,
self.data[self.params.opt_mode][self.params.orc_fluid][:, 0],
self.data[self.params.opt_mode][self.params.orc_fluid][:, 2])
# run some checks if T_in_C and T_boil_C are valid
if np.isnan(T_in_C):
raise Exception(
'GenGeo::ORCCycleTboil:T_in_NaN - ORC input temperature is NaN!'
)
if np.isnan(T_boil_C):
raise Exception(
'GenGeo::ORCCycleTboil:T_boil_NaN - ORC boil temperature is NaN!'
)
if T_boil_C > FluidState.getTcrit(self.params.orc_fluid):
raise Exception(
'GenGeo::ORCCycleTboil:Tboil_Too_Large - Boiling temperature above critical point'
)
if dT_pinch <= 0:
raise Exception(
'GenGeo::ORCCycleTboil:dT_pinch_Negative - dT_pinch is negative!'
)
if T_in_C < T_boil_C + dT_pinch:
raise Exception(
'GenGeo::ORCCycleTboil:Tboil_Too_Large - Boiling temperature of %s is greater than input temp of %s less pinch dT of %s.'
% (T_boil_C, T_in_C, dT_pinch))
# only refresh T_boil_max if orc_fluid has changed from initial
if self.params.orc_fluid != self.orc_fluid:
self.T_boil_max = maxSubcritORCBoilTemp(self.params.orc_fluid)
self.orc_fluid = self.params.orc_fluid
if T_boil_C > self.T_boil_max:
raise Exception(
'GenGeo::ORCCycleTboil:Tboil_Too_Large - Boiling temperature of %s is greater than maximum allowed of %s.'
% (T_boil_C, self.T_boil_max))
T_condense_C = self.params.T_ambient_C + self.params.dT_approach
# create empty list to compute cycle of 6 states
state = [None] * 6
#State 1 (Condenser -> Pump)
#saturated liquid
state[0] = FluidState.getStateFromTQ(T_condense_C, 0,
self.params.orc_fluid)
#State 6 (Desuperheater -> Condenser)
#saturated vapor
state[5] = FluidState.getStateFromTQ(state[0].T_C, 1,
self.params.orc_fluid)
# state[5].P_Pa = state[0].P_Pa
#State 3 (Preheater -> Boiler)
#saturated liquid
state[2] = FluidState.getStateFromTQ(T_boil_C, 0,
self.params.orc_fluid)
#State 4 (Boiler -> Turbine)
#saturated vapor
state[3] = FluidState.getStateFromTQ(state[2].T_C, 1,
self.params.orc_fluid)
# state[3].P_Pa = state[2].P_Pa
#State 5 (Turbine -> Desuperheater)
h_5s = FluidState.getStateFromPS(state[0].P_Pa, state[3].s_JK,
self.params.orc_fluid).h_Jkg
h_5 = state[3].h_Jkg - self.params.eta_turbine_orc * (state[3].h_Jkg -
h_5s)
state[4] = FluidState.getStateFromPh(state[0].P_Pa, h_5,
self.params.orc_fluid)
# #State 2 (Pump -> Preheater)
h_2s = FluidState.getStateFromPS(state[2].P_Pa, state[0].s_JK,
self.params.orc_fluid).h_Jkg
h_2 = state[0].h_Jkg - (
(state[0].h_Jkg - h_2s) / self.params.eta_pump_orc)
state[1] = FluidState.getStateFromPh(state[2].P_Pa, h_2,
self.params.orc_fluid)
results = PowerPlantOutput()
# #Calculate orc heat/work
w_pump_orc = state[0].h_Jkg - state[1].h_Jkg
q_preheater_orc = -1 * (state[1].h_Jkg - state[2].h_Jkg)
q_boiler_orc = -1 * (state[2].h_Jkg - state[3].h_Jkg)
w_turbine_orc = state[3].h_Jkg - state[4].h_Jkg
q_desuperheater_orc = -1 * (state[4].h_Jkg - state[5].h_Jkg)
q_condenser_orc = -1 * (state[5].h_Jkg - state[0].h_Jkg)
results.dP_pump_orc = state[1].P_Pa - state[0].P_Pa
results.P_boil = state[2].P_Pa
# Cooling Tower Parasitic load
dT_range = state[4].T_C - state[5].T_C
parasiticPowerFraction = CoolingCondensingTower.parasiticPowerFraction(
self.params.T_ambient_C, self.params.dT_approach, dT_range,
self.params.cooling_mode)
w_cooler_orc = q_desuperheater_orc * parasiticPowerFraction('cooling')
w_condenser_orc = q_condenser_orc * parasiticPowerFraction(
'condensing')
#water (assume pressure 100 kPa above saturation)
P_sat = FluidState.getStateFromTQ(T_in_C, 0, 'Water').P_Pa
cp = FluidState.getStateFromPT(P_sat + 100e3, T_in_C, 'Water').cp_JK
#Water state 11, inlet, 12, mid, 13 exit
T_C_11 = T_in_C
T_C_12 = T_boil_C + dT_pinch
#mdot_ratio = mdot_orc / mdot_water
mdot_ratio = cp * (T_C_11 - T_C_12) / q_boiler_orc
T_C_13 = T_C_12 - mdot_ratio * q_preheater_orc / cp
# check that T_C(13) isn't below pinch constraint
if T_C_13 < (state[1].T_C + dT_pinch):
# pinch constraint is here, not at 12
# outlet is pump temp plus pinch
T_C_13 = state[1].T_C + dT_pinch
R = q_boiler_orc / (q_boiler_orc + q_preheater_orc)
T_C_12 = T_C_11 - (T_C_11 - T_C_13) * R
mdot_ratio = cp * (T_C_11 - T_C_12) / q_boiler_orc
#Calculate water heat/work
results.q_preheater = mdot_ratio * q_preheater_orc
results.q_boiler = mdot_ratio * q_boiler_orc
results.q_desuperheater = mdot_ratio * q_desuperheater_orc
results.q_condenser = mdot_ratio * q_condenser_orc
results.w_turbine = mdot_ratio * w_turbine_orc
results.w_pump = mdot_ratio * w_pump_orc
results.w_cooler = mdot_ratio * w_cooler_orc
results.w_condenser = mdot_ratio * w_condenser_orc
results.w_net = results.w_turbine + results.w_pump + results.w_cooler + results.w_condenser
# Calculate temperatures
results.dT_range_CT = state[4].T_C - state[5].T_C
dT_A_p = T_C_13 - state[1].T_C
dT_B_p = T_C_12 - state[2].T_C
if dT_A_p == dT_B_p:
results.dT_LMTD_preheater = dT_A_p
else:
div = dT_A_p / dT_B_p
results.dT_LMTD_preheater = (dT_A_p - dT_B_p) / (
math.log(abs(div)) * np.sign(div))
dT_A_b = T_C_12 - state[2].T_C
dT_B_b = T_C_11 - state[3].T_C
if dT_A_b == dT_B_b:
results.dT_LMTD_boiler = dT_A_b
else:
div = dT_A_b / dT_B_b
results.dT_LMTD_boiler = (dT_A_b - dT_B_b) / (math.log(abs(div)) *
np.sign(div))
# return temperature
results.state = FluidState.getStateFromPT(initialState.P_Pa, T_C_13,
self.params.working_fluid)
return results
def solve(self):
results = FluidSystemCO2Output()
results.pp = PowerPlantEnergyOutput()
# Find condensation pressure
T_condensation = self.params.T_ambient_C + self.params.dT_approach
P_condensation = FluidState.getStateFromTQ(T_condensation, 0, self.params.working_fluid).P_Pa + 50e3
dP_pump = 0
dP_downhole_threshold = 1e3
dP_downhole = np.nan
dP_loops = 1
dP_solver = Solver()
while np.isnan(dP_downhole) or np.abs(dP_downhole) >= dP_downhole_threshold:
# Find Injection Conditions
P_pump_inlet = P_condensation
# Only add pump differential if positive. If negative, add as a throttle at the bottom of the injection well
if (dP_pump > 0):
P_pump_outlet = P_pump_inlet + dP_pump
else:
P_pump_outlet = P_pump_inlet
T_pump_inlet = T_condensation
pump_inlet_state = FluidState.getStateFromPT(P_pump_inlet, T_pump_inlet, self.params.working_fluid)
if dP_pump > 0:
h_pump_outletS = FluidState.getStateFromPS(P_pump_outlet, pump_inlet_state.s_JK, self.params.working_fluid).h_Jkg
h_pump_outlet = pump_inlet_state.h_Jkg + (h_pump_outletS - pump_inlet_state.h_Jkg) / self.params.eta_pump_co2
else:
h_pump_outlet = pump_inlet_state.h_Jkg
results.pp.w_pump = -1 * (h_pump_outlet - pump_inlet_state.h_Jkg)
surface_injection_state = FluidState.getStateFromPh(P_pump_outlet, h_pump_outlet, self.params.working_fluid)
results.injection_well = self.injection_well.solve(surface_injection_state)
# if dP_pump is negative, this is a throttle after the injection well
if (dP_pump < 0):
results.injection_well_downhole_throttle = FluidState.getStateFromPh(
results.injection_well.state.P_Pa + dP_pump,
results.injection_well.state.h_Jkg,
self.params.working_fluid)
else:
results.injection_well_downhole_throttle = FluidState.getStateFromPh(
results.injection_well.state.P_Pa,
results.injection_well.state.h_Jkg,
self.params.working_fluid)
results.reservoir = self.reservoir.solve(results.injection_well_downhole_throttle)
# find downhole pressure difference (negative means
# overpressure
dP_downhole = self.params.P_reservoir() - results.reservoir.state.P_Pa
dP_pump = dP_solver.addDataAndEstimate(dP_pump, dP_downhole)
if np.isnan(dP_pump):
dP_pump = 0.5 * dP_downhole
if dP_loops > 10:
print('GenGeo::Warning::FluidSystemCO2:dP_loops is large: %s'%dP_loops)
dP_loops += 1
if results.reservoir.state.P_Pa >= self.params.P_reservoir_max():
raise Exception('GenGeo::FluidSystemCO2:ExceedsMaxReservoirPressure - '
'Exceeds Max Reservoir Pressure of %.3f MPa!'%(self.params.P_reservoir_max()/1e6))
results.production_well = self.production_well.solve(results.reservoir.state)
# Subtract surface frictional losses between production wellhead and surface plant
ff = frictionFactor(self.params.well_radius, results.production_well.state.P_Pa, results.production_well.state.h_Jkg,
self.params.m_dot_IP, self.params.working_fluid, self.params.epsilon)
if self.params.has_surface_gathering_system == True:
dP_surfacePipes = ff * self.params.well_spacing / (self.params.well_radius*2)**5 * 8 * self.params.m_dot_IP**2 / results.production_well.state.rho_kgm3 / 3.14159**2
else:
dP_surfacePipes = 0
results.surface_plant_inlet = FluidState.getStateFromPh(
results.production_well.state.P_Pa - dP_surfacePipes,
results.production_well.state.h_Jkg,
self.params.working_fluid)
# Calculate Turbine Power
h_turbine_outS = FluidState.getStateFromPS(P_condensation, results.surface_plant_inlet.s_JK, self.params.working_fluid).h_Jkg
h_turbine_out = results.surface_plant_inlet.h_Jkg - self.params.eta_turbine_co2 * (results.surface_plant_inlet.h_Jkg - h_turbine_outS)
results.pp.w_turbine = results.surface_plant_inlet.h_Jkg - h_turbine_out
if results.pp.w_turbine < 0:
raise Exception('GenGeo::FluidSystemCO2:TurbinePowerNegative - Turbine Power is Negative')
# heat rejection
h_satVapor = FluidState.getStateFromPQ(P_condensation, 1, self.params.working_fluid).h_Jkg
h_condensed = FluidState.getStateFromPQ(P_condensation, 0, self.params.working_fluid).h_Jkg
if h_turbine_out > h_satVapor:
# desuperheating needed
results.pp.q_cooler = h_satVapor - h_turbine_out
results.pp.q_condenser = h_condensed - h_satVapor
T_turbine_out = FluidState.getStateFromPh(P_condensation, h_turbine_out, self.params.working_fluid).T_C
dT_range = T_turbine_out - T_condensation
else:
# no desuperheating
results.pp.q_cooler = 0
results.pp.q_condenser = h_condensed - h_turbine_out
dT_range = 0
parasiticPowerFraction = CoolingCondensingTower.parasiticPowerFraction(self.params.T_ambient_C, self.params.dT_approach, dT_range, self.params.cooling_mode)
results.pp.w_cooler = results.pp.q_cooler * parasiticPowerFraction('cooling')
results.pp.w_condenser = results.pp.q_condenser * parasiticPowerFraction('condensing')
results.pp.w_net = results.pp.w_turbine + results.pp.w_pump + results.pp.w_cooler + results.pp.w_condenser
results.pp.dP_surface = results.surface_plant_inlet.P_Pa - P_condensation
results.pp.dP_pump = dP_pump
results.pp.state_out = surface_injection_state
return results
def solve(self, initial_state):
m_dot = self.params.m_dot_IP * self.m_dot_multiplier
# results
results = SemiAnalyticalWellResults(self.params.well_segments, self.params.working_fluid)
P_f_initial = initial_state.P_Pa
T_f_initial = initial_state.T_C
time_seconds = self.params.time_years * ConversionConstants.secPerYear
# set geometry
dz = self.dz_total/self.params.well_segments # m
dr = self.dr_total/self.params.well_segments # m
dL = (dz**2 + dr**2)**0.5 # m
A_c = np.pi * self.params.well_radius**2 # m**2
P_c = np.pi * 2 * self.params.well_radius # m
# set states
results.T_C_f[0] = T_f_initial # C
results.T_C_e[0] = self.T_e_initial # C
results.P_Pa[0] = P_f_initial # Pa
results.h_Jkg[0] = FluidState.getStateFromPT(results.P_Pa[0], results.T_C_f[0], self.params.working_fluid).h_Jkg
results.rho_kgm3[0] = FluidState.getStateFromPT(results.P_Pa[0], results.T_C_f[0], self.params.working_fluid).rho_kgm3
results.v_ms[0] = m_dot / A_c / results.rho_kgm3[0] #m/s
# Calculate the Friction Factor
# Use Colebrook-white equation for wellbore friction loss.
# Calculate for first element and assume constant in remainder
ff = frictionFactor(self.params.well_radius, results.P_Pa[0], results.h_Jkg[0], \
m_dot, self.params.working_fluid, self.params.epsilon)
alpha_rock = self.params.k_rock/self.params.rho_rock/self.params.c_rock #D rock
t_d = alpha_rock*time_seconds/(self.params.well_radius**2) #dim
if t_d < 2.8:
beta = ((np.pi*t_d)**-0.5 + 0.5 - 0.25*(t_d/np.pi)**0.5 + 0.125*t_d)
else:
beta = (2/(np.log(4*t_d)-2*0.58) - 2*0.58/(np.log(4*t_d)-2*0.58)**2)
# loop over all well segments
for i in range(1, self.params.well_segments+1):
results.z_m[i] = results.z_m[i-1] + dz
# far-field rock temp
results.T_C_e[i] = results.T_C_e[0] - results.z_m[i] * self.params.dT_dz
# fluid velocity
results.v_ms[i] = m_dot / A_c / results.rho_kgm3[i-1] #m/s
# Calculate Pressure
results.delta_P_loss[i] = ff * dL / ( 2 * self.params.well_radius) * \
results.rho_kgm3[i-1] * \
results.v_ms[i]**2. / 2. #Pa
results.rho_kgm3[i] = FluidState.getStateFromPh(results.P_Pa[i-1], results.h_Jkg[i-1], self.params.working_fluid).rho_kgm3
results.P_Pa[i] = results.P_Pa[i-1] - results.rho_kgm3[i] * \
self.params.g * dz - results.delta_P_loss[i]
# Throw exception if below saturation pressure of water at previous temperature
if self.params.working_fluid.lower() == 'water':
P_sat = FluidState.getStateFromTQ(results.T_C_f[i-1], 0, self.params.working_fluid).P_Pa
if results.P_Pa[i] < P_sat:
raise Exception('GenGeo::SemiAnalyticalWell:BelowSaturationPressure - '
'Below saturation pressure of water at %s m !' %(results.z_m[i]))
h_noHX = results.h_Jkg[i-1] - self.params.g * dz
T_noHX = FluidState.getStateFromPh(results.P_Pa[i], h_noHX, self.params.working_fluid).T_C
results.cp_JK[i] = FluidState.getStateFromPh(results.P_Pa[i], h_noHX, self.params.working_fluid).cp_JK
#Find Fluid Temp
if not self.params.useWellboreHeatLoss:
results.T_C_f[i] = T_noHX
results.h_Jkg[i] = h_noHX
results.q[i] = 0.
else:
# See Zhang, Pan, Pruess, Finsterle (2011). A time-convolution
# approach for modeling heat exchange between a wellbore and
# surrounding formation. Geothermics 40, 261-266.
x = dL * P_c * self.params.k_rock * beta / self.params.well_radius
y = m_dot * results.cp_JK[i]
if math.isinf(x):
results.T_C_f[i] = results.T_C_e[i]
else:
results.T_C_f[i] = (y * T_noHX + x *results. T_C_e[i]) / (x + y)
results.q[i] = y * (T_noHX - results.T_C_f[i])
results.h_Jkg[i] = FluidState.getStateFromPT(results.P_Pa[i], results.T_C_f[i], self.params.working_fluid).h_Jkg
# make sure state object is set
results.createFinalState()
return results
def solve(self, initialState, P_boil_Pa=False):
T_in_C = initialState.T_C
if not P_boil_Pa:
P_boil_Pa = np.interp(T_in_C, self.data[:, 0], self.data[:, 1])
# Critical point of R245fa
# if Pboil is below critical, throw error
if P_boil_Pa < FluidState.getPcrit(self.params.orc_fluid):
raise Exception(
'GenGeo::ORCCycleSupercritPboil:lowBoilingPressure - Boiling Pressure Below Critical Pressure'
)
# The line of minimum entropy to keep the fluid vapor in turbine is
# entropy at saturated vapor at 125C. So inlet temp must provide this
# minimum entropy.
s_min = FluidState.getStateFromTQ(125., 1, self.params.orc_fluid).s_JK
T_min = FluidState.getStateFromPS(P_boil_Pa, s_min,
self.params.orc_fluid).T_C
if (T_in_C - self.params.dT_pinch) < T_min:
raise Exception(
'GenGeo::ORCCycleSupercritPboil:lowInletTemp - Inlet Temp below %.1f C for Supercritical Fluid'
% (T_min + self.params.dT_pinch))
T_condense_C = self.params.T_ambient_C + self.params.dT_approach
# create empty list to compute cycle of 7 states
state = [None] * 7
#State 1 (Condenser -> Pump)
#saturated liquid
state[0] = FluidState.getStateFromTQ(T_condense_C, 0,
self.params.orc_fluid)
# State 7 (Desuperheater -> Condenser)
# saturated vapor
state[6] = FluidState.getStateFromTQ(state[0].T_C, 1,
self.params.orc_fluid)
# State 2 (Pump -> Recuperator)
h_2s = FluidState.getStateFromPS(P_boil_Pa, state[0].s_JK,
self.params.orc_fluid).h_Jkg
h2 = state[0].h_Jkg - (
(state[0].h_Jkg - h_2s) / self.params.eta_pump_orc)
state[1] = FluidState.getStateFromPh(P_boil_Pa, h2,
self.params.orc_fluid)
# water (assume pressure 100 kPa above saturation)
P_water = FluidState.getStateFromTQ(T_in_C, 0, 'Water').P_Pa + 100e3
# Guess orc_in fluid is state[1].T_C
state[2] = FluidState.getStateFromPT(state[1].P_Pa, state[1].T_C,
self.params.orc_fluid)
# Water in temp is T_in_C
T_C_11 = T_in_C
P_4 = state[1].P_Pa
# initialize state 2 with pressure state 2 and dummy temperature
state[3] = FluidState.getStateFromPT(P_4, 15., self.params.orc_fluid)
# initialize state 3 with pressure state 1 and dummy enthalpy
state[4] = FluidState.getStateFromPh(state[0].P_Pa, 1e4,
self.params.orc_fluid)
# initialize state 6 with pressure state 1 and dummy temperature
state[5] = FluidState.getStateFromPT(state[0].P_Pa, 15.,
self.params.orc_fluid)
results = PowerPlantOutput()
dT = 1
while abs(dT) >= 1:
# State 4 (Boiler -> Turbine)
# Input orc/geo heat exchanger
opt_heatExchanger_results = heatExchangerOptMdot(
state[2].T_C, P_4, self.params.orc_fluid, T_C_11, P_water,
'Water', self.params.dT_pinch, T_min)
# state[3] = FluidStateFromPT(P_4, opt_heatExchanger_results.T_1_out, self.params.orc_fluid)
state[3].T_C = opt_heatExchanger_results.T_1_out
#State 5 (Turbine -> Recuperator)
h_5s = FluidState.getStateFromPS(state[0].P_Pa, state[3].s_JK,
self.params.orc_fluid).h_Jkg
h_5 = state[3].h_Jkg - self.params.eta_turbine_orc * (
state[3].h_Jkg - h_5s)
state[4].h_Jkg = h_5
# state[4] = FluidStateFromPh(state[0].P_Pa(), h_5, self.params.orc_fluid)
# State 3 (Recuperator -> Boiler)
# State 6 (Recuperator -> Desuperheater)
# Assume m_dot for each fluid is 1, then output is specific heat
# exchange
heatExchanger_results = heatExchanger(state[1].T_C, state[1].P_Pa,
1, self.params.orc_fluid,
state[4].T_C, state[0].P_Pa,
1, self.params.orc_fluid,
self.params.dT_pinch)
# state[2] = FluidStateFromPT(state[2].P_Pa, state[2].T_C, self.params.orc_fluid)
# state[5] = FluidStateFromPT(state[0].P_Pa, heatExchanger_results.T_2_out, self.params.orc_fluid)
state[5].T_C = heatExchanger_results.T_2_out
dT = state[2].T_C - heatExchanger_results.T_1_out
state[2].T_C = heatExchanger_results.T_1_out
#Calculate orc heat/work
w_pump_orc = state[0].h_Jkg - state[1].h_Jkg
q_boiler_orc = -1 * (state[2].h_Jkg - state[3].h_Jkg)
w_turbine_orc = state[3].h_Jkg - state[4].h_Jkg
q_desuperheater_orc = -1 * (state[5].h_Jkg - state[6].h_Jkg)
q_condenser_orc = -1 * (state[6].h_Jkg - state[0].h_Jkg)
# Cooling Tower Parasitic load
results.dT_range_CT = state[5].T_C - state[6].T_C
parasiticPowerFraction = CoolingCondensingTower.parasiticPowerFraction(
self.params.T_ambient_C, self.params.dT_approach,
results.dT_range_CT, self.params.cooling_mode)
w_cooler_orc = q_desuperheater_orc * parasiticPowerFraction('cooling')
w_condenser_orc = q_condenser_orc * parasiticPowerFraction(
'condensing')
#Calculate water heat/work
results.w_pump = opt_heatExchanger_results.mdot_ratio * w_pump_orc
results.q_boiler = opt_heatExchanger_results.mdot_ratio * q_boiler_orc
results.w_turbine = opt_heatExchanger_results.mdot_ratio * w_turbine_orc
results.q_recuperator = opt_heatExchanger_results.mdot_ratio * heatExchanger_results.Q_exchanged
results.q_desuperheater = opt_heatExchanger_results.mdot_ratio * q_desuperheater_orc
results.q_condenser = opt_heatExchanger_results.mdot_ratio * q_condenser_orc
results.w_cooler = opt_heatExchanger_results.mdot_ratio * w_cooler_orc
results.w_condenser = opt_heatExchanger_results.mdot_ratio * w_condenser_orc
results.w_net = results.w_turbine + results.w_pump + results.w_cooler + results.w_condenser
results.end_T_C = opt_heatExchanger_results.T_2_out
results.dT_LMTD_boiler = opt_heatExchanger_results.dT_LMTD
results.dT_LMTD_recuperator = heatExchanger_results.dT_LMTD
# return temperature
results.state = FluidState.getStateFromPT(
initialState.P_Pa, opt_heatExchanger_results.T_2_out,
self.params.working_fluid)
return results