def Validate(self):
"""
Check that all required fields are included, and no extra fields not listed here are added
This is quite strict, but for the best to avoid typos
"""
reqFields = [('RH', float, 0, 1),
('Tdb', float, -80 + 273.15, 200 + 273.15),
('FanPower', float, 0, 4000), ('p', float, 10, 10000000),
('Vdot_ha', float, 0.001, 10)]
optFields = ['RHmean', 'Tmean']
d = dict(self.Air.__dict__) #The current values
ValidateFields(d, reqFields, optFields)
reqFields = [('FPI', float, 0.1, 100), ('Pd', float, 0.000001, 0.1),
('xf', float, 0.000001, 0.1), ('t', float, 0.00001, 0.01),
('k_fin', float, 0.01, 10000)]
optFields = None
d = dict(self.Fins.__dict__) #The current values
ValidateFields(d, reqFields, optFields)
reqFields = [('NTubes_per_bank', int, 0.1, 100),
('Ncircuits', int, 1, 50), ('Nbank', float, 1, 50),
('Ltube', float, 0.001, 10), ('ID', float, 0.0001, 1),
('OD', float, 0.0001, 1), ('Pl', float, 0.0001, 1),
('Pt', float, 0.0001, 1), ('kw', float, 0.01, 10000)]
optFields = None
d = dict(self.Tubes.__dict__) #The current values
ValidateFields(d, reqFields, optFields)
def Validate(self):
"""
Check that all required fields are included, and no extra fields not listed here are added
This is quite strict, but for the best to avoid typos
"""
reqFields=[
('RH',float,0,1),
('Tdb',float,-80+273.15,200+273.15),
('FanPower',float,0,4000),
('p',float,10,10000000),
('Vdot_ha',float,0.001,10)
]
optFields=['RHmean','Tmean']
d=dict(self.Air.__dict__) #The current values
ValidateFields(d,reqFields,optFields)
reqFields=[
('FPI',float,0.1,100),
('Lf',float,0.0001,1),
('t',float,0.00001,0.01),
('k_fin',float,0.01,10000)
]
optFields=None
d=dict(self.Fins.__dict__) #The current values
ValidateFields(d,reqFields,optFields)
reqFields=[
('NTubes',float,0.1,100),
('Nbank',float,1,50),
('Npass',float,1,50),
('Nports',float,1,50),
('Ltube',float,0.001,10),
('Td',float,0.0001,1),
('Ht',float,0.0001,1),
('b',float,0.0001,1),
('tw',float,0.00001,0.01),
('twp',float,0.00001,0.01),
('beta',float,0.00001,100),
('kw',float,0.01,10000)
]
optFields=None
d=dict(self.Tubes.__dict__) #The current values
ValidateFields(d,reqFields,optFields)
reqFields=[
('Lalpha',float,1,89),
('lp',float,0.0001,1),
]
optFields=['Llouv']
d=dict(self.Louvers.__dict__) #The current values
ValidateFields(d,reqFields,optFields)
def Initialize(self):
#Only validate the first time
if not hasattr(self, 'IsValidated'):
self.Fins.Validate()
reqFields = [('Ref', str, None, None),
('Fins', IsFinsClass, None, None),
('FinsType', str, None, None),
('mdot_r', float, 0.00001, 20),
('Tin_r', float, 200, 500),
('psat_r', float, 0.01, 20000000)]
optFields = ['Verbosity', 'Backend']
ValidateFields(self.__dict__, reqFields, optFields)
self.IsValidated = True
#AbstractState
if hasattr(self, 'Backend'): #check if backend is given
AS = CP.AbstractState(self.Backend, self.Ref)
else: #otherwise, use the defualt backend
AS = CP.AbstractState('HEOS', self.Ref)
self.AS = AS
# Retrieve some parameters from nested structures
# for code compactness
self.ID = self.Fins.Tubes.ID
self.OD = self.Fins.Tubes.OD
self.Ltube = self.Fins.Tubes.Ltube
self.NTubes_per_bank = self.Fins.Tubes.NTubes_per_bank
self.Nbank = self.Fins.Tubes.Nbank
self.Ncircuits = self.Fins.Tubes.Ncircuits
self.Tin_a = self.Fins.Air.Tdb
# Calculate an effective length of circuit if circuits are
# not all the same length
TotalLength = self.Ltube * self.NTubes_per_bank * self.Nbank
self.Lcircuit = TotalLength / self.Ncircuits
self.V_r = pi * self.ID**2 / 4.0 * self.Lcircuit * self.Ncircuits
self.A_r_wetted = pi * self.ID * self.Ncircuits * self.Lcircuit
self.G_r = self.mdot_r / (self.Ncircuits * pi * self.ID**2 / 4.0)
# Define known parameters
AS.update(CP.PT_INPUTS, self.psat_r, self.Tin_r)
self.hin_r = AS.hmass() #[J/kg]
self.sin_r = AS.smass() #[J/kg-K]
# Define critical pressure and temperature
self.Pcr = AS.p_critical() #[Pa]
self.Tcr = AS.T_critical() #[K]
self.Fins.Air.RHmean = self.Fins.Air.RH
#Update with user FinType
if self.FinsType == 'WavyLouveredFins':
WavyLouveredFins(self.Fins)
elif self.FinsType == 'HerringboneFins':
HerringboneFins(self.Fins)
elif self.FinsType == 'PlainFins':
PlainFins(self.Fins)
self.mdot_ha = self.Fins.mdot_ha #[kg_ha/s]
self.mdot_da = self.Fins.mdot_da #[kg_da/s]
def Initialize(self):
#Only validate the first time
if not hasattr(self, 'IsValidated'):
self.Fins.Validate()
reqFields = [('Fins', IsFinsClass, None, None),
('FinsType', str, None, None),
('mdot_r', float, 0.00001, 20),
('Tin_r', float, 200, 500),
('psat_r', float, 0.01, 20000000)]
optFields = [
'Verbosity', 'AS', 'h_a_tuning', 'h_r_tuning', 'DP_tuning'
]
ValidateFields(self.__dict__, reqFields, optFields)
self.IsValidated = True
#set tuning factors to 1 in case not given by user
if not hasattr(self, 'h_a_tuning'):
self.h_a_tuning = 1
if not hasattr(self, 'h_r_tuning'):
self.h_r_tuning = 1
if not hasattr(self, 'DP_tuning'):
self.DP_tuning = 1
#AbstractState
AS = self.AS
# Retrieve some parameters from nested structures
# for code compactness
self.ID = self.Fins.Tubes.ID
self.OD = self.Fins.Tubes.OD
self.Ltube = self.Fins.Tubes.Ltube
self.NTubes_per_bank = self.Fins.Tubes.NTubes_per_bank
self.Nbank = self.Fins.Tubes.Nbank
self.Ncircuits = self.Fins.Tubes.Ncircuits
self.Tin_a = self.Fins.Air.Tdb
self.kw = self.Fins.Tubes.kw #thermal conductivity of tube wall
# Calculate an effective length of circuit if circuits are
# not all the same length
TotalLength = self.Ltube * self.NTubes_per_bank * self.Nbank
self.Lcircuit = TotalLength / self.Ncircuits
self.V_r = pi * self.ID**2 / 4.0 * self.Lcircuit * self.Ncircuits
self.A_r_wetted = pi * self.ID * self.Ncircuits * self.Lcircuit
self.G_r = self.mdot_r / (self.Ncircuits * pi * self.ID**2 / 4.0)
# Thermal resistance at the wall
self.Rw = log(self.OD / self.ID) / (2 * pi * self.kw * self.Lcircuit *
self.Ncircuits)
# Define known parameters
AS.update(CP.PT_INPUTS, self.psat_r, self.Tin_r)
self.hin_r = AS.hmass() #[J/kg]
self.sin_r = AS.smass() #[J/kg-K]
# Define critical pressure and temperature
self.Pcr = AS.p_critical() #[Pa]
self.Tcr = AS.T_critical() #[K]
#critical enthalpy at defined pressure
AS.update(CP.PT_INPUTS, self.psat_r, self.Tcr)
self.hcr = AS.hmass() #[J/kg]
#triple temperature
self.Ttriple = AS.Ttriple()
self.Fins.Air.RHmean = self.Fins.Air.RH
#Update with user FinType
if self.FinsType == 'WavyLouveredFins':
WavyLouveredFins(self.Fins)
elif self.FinsType == 'HerringboneFins':
HerringboneFins(self.Fins)
elif self.FinsType == 'PlainFins':
PlainFins(self.Fins)
self.mdot_ha = self.Fins.mdot_ha #[kg_ha/s]
self.mdot_da = self.Fins.mdot_da #[kg_da/s]
def Calculate(self):
#Only validate the first time
if not hasattr(self, 'IsValidated'):
self.Fins.Validate()
reqFields = [('Fins', IsFinsClass, None, None),
('FinsType', str, None, None),
('mdot_r', float, 0.00001, 20),
('Tin_r', float, 200, 500),
('psat_r', float, 0.01, 20000000)]
optFields = [
'Verbosity', 'AS', 'h_a_tuning', 'h_tp_tuning', 'DP_tuning'
]
ValidateFields(self.__dict__, reqFields, optFields)
self.IsValidated = True
#set tuning factors to 1 in case not given by user
if not hasattr(self, 'h_a_tuning'):
self.h_a_tuning = 1
if not hasattr(self, 'h_tp_tuning'):
self.h_tp_tuning = 1
if not hasattr(self, 'DP_tuning'):
self.DP_tuning = 1
#AbstractState
AS = self.AS
# Retrieve some parameters from nested structures
# for code compactness
self.Ltube = self.Fins.Tubes.Ltube #tube length
self.NTubes = self.Fins.Tubes.NTubes #number of tube (per bank)
self.Nbank = self.Fins.Tubes.Nbank #number of banks
self.Tin_a = self.Fins.Air.Tdb #inlet air temperature
self.Pin_a = self.Fins.Air.p #inlet air pressure
self.RHin_a = self.Fins.Air.RH #inlet air relative humidity
self.Td = self.Fins.Tubes.Td #tube outside width (depth)
self.Ht = self.Fins.Tubes.Ht #tube outside height (major diameter)
self.b = self.Fins.Tubes.b #tube spacing
self.tw = self.Fins.Tubes.tw #tube thickness
self.Npass = self.Fins.Tubes.Npass #Number of passes on ref-side (per bank)
self.kw = self.Fins.Tubes.kw #thermal conductivity of tube wall
self.Nports = self.Fins.Tubes.Nports #Number of rectangular ports
self.twp = self.Fins.Tubes.twp #Port wall thickness
self.beta = self.Fins.Tubes.beta #channel (port) aspect ratio (=width/height)
## Bubble and dew temperatures (same for fluids without glide)
AS.update(CP.PQ_INPUTS, self.psat_r, 0.0)
self.Tbubble = AS.T() #[K]
self.h_l = AS.hmass() #[J/kg]
self.cp_satL = AS.cpmass() #[J/kg-K]
AS.update(CP.PQ_INPUTS, self.psat_r, 1.0)
self.Tdew = AS.T() #[K]
self.h_v = AS.hmass() #[J/kg]
# Define Number of circuits (=number of tubes per pass)
self.Ncircuits = self.NTubes / self.Npass
# Calculate an effective length of circuit if circuits are
# not all the same length
TotalLength = self.Ltube * self.NTubes * self.Nbank
self.Lcircuit = TotalLength / self.Ncircuits
# Volume of refrigerant = rectangle of tube + circular part at the ends - thickness between ports
self.V_r = ((self.Td - self.Ht) * (self.Ht - 2.0 * self.tw) +
(pi / 4.0) * (self.Ht - 2.0 * self.tw)**2 -
(self.Ht - 2.0 * self.tw) * self.twp *
(self.Nports - 1)) * self.Lcircuit * self.Ncircuits
# Tube wetted area = tube straight length + circular shape at the ends - horizontal port thickness + vertical thickness between ports
self.A_r_wetted = (2.0 * (self.Td - self.Ht) + pi *
(self.Ht - 2.0 * self.tw) - 2.0 * self.twp *
(self.Nports - 1) + 2.0 *
(self.Ht - 2.0 * self.tw) *
(self.Nports - 1)) * self.Lcircuit * self.Ncircuits
# Free-flow area on refrigerant-side = area of rectangle tube + circular parts at end - area thickness between ports
self.A_c = ((self.Td - self.Ht) * (self.Ht - 2.0 * self.tw) +
(pi / 4.0) * (self.Ht - 2.0 * self.tw)**2 - self.twp *
(self.Ht - 2.0 * self.tw) *
(self.Nports - 1)) * self.Ncircuits
# Hydraulic diameter on ref-side
self.Dh = 4 * self.A_c * self.Lcircuit / self.A_r_wetted
# Mass flux ref-side
self.G_r = self.mdot_r / self.A_c
# Total conduction area (exclude port's thickness)
self.Aw = 2 * (self.Td - self.twp *
(self.Nports - 1)) * self.Lcircuit * self.Ncircuits
# Thermal resistance at the wall
self.Rw = self.tw / (self.kw * self.Aw)
#Definitely have a superheated portion
self._Superheat_Forward()
#Maybe have a full two-phase section
#First try to run with a full two-phase section from quality of 1 to quality of 0
self._TwoPhase_Forward()
#If we have already used too much of the HX (max possible sum of w is 1.0)
if self.w_2phase + self.w_superheat > 1:
#There is no subcooled portion, solve for outlet quality
brentq(self._TwoPhase_Forward, 0.0000001, 0.9999999)
#Zero out all the subcooled parameters
self.Q_subcool = 0.0
self.DP_r_subcool = 0.0
self.Charge_subcool = 0.0
self.w_subcool = 0.0
self.h_r_subcool = 0.0
self.existsSubcooled = False
else:
#By definition then we have a subcooled portion, solve for it
self.existsSubcooled = True
self._Subcool_Forward()
#Overall calculations
self.Q = self.Q_superheat + self.Q_2phase + self.Q_subcool
self.DP_r = self.DP_r_superheat + self.DP_r_2phase + self.DP_r_subcool
self.DP_r = self.DP_r * self.DP_tuning #correcting the pressure drop
self.Charge = self.Charge_2phase + self.Charge_subcool + self.Charge_superheat
#define known parameters
AS.update(CP.PT_INPUTS, self.psat_r, self.Tin_r)
self.hin_r = AS.hmass() #[J/kg]
self.sin_r = AS.smass() #[J/kg-K]
if self.existsSubcooled == True:
AS.update(CP.PT_INPUTS, self.psat_r, self.Tout_r)
self.hout_r = AS.hmass() #[J/kg]
self.sout_r = AS.smass() #[J/kg-K]
else:
self.Tout_r = self.xout_2phase * self.Tdew + (
1 - self.xout_2phase) * self.Tbubble
AS.update(CP.QT_INPUTS, 0.0, self.Tbubble)
h_l = AS.hmass() #[J/kg]
s_l = AS.smass() #[J/kg-K]
AS.update(CP.QT_INPUTS, 1.0, self.Tdew)
h_v = AS.hmass() #[J/kg]
s_v = AS.smass() #[J/kg-K]
self.hout_r = h_l + self.xout_2phase * (h_v - h_l)
self.sout_r = s_l + self.xout_2phase * (s_v - s_l)
#Use the effective subcooling
self.DT_sc = self.DT_sc_2phase
#Calculate the mean outlet air temperature [K]
self.Tout_a = self.Tin_a - self.Q / (self.Fins.cp_da *
self.Fins.mdot_da)
self.hmean_r = self.w_2phase * self.h_r_2phase + self.w_superheat * self.h_r_superheat + self.w_subcool * self.h_r_subcool
self.UA_r = self.hmean_r * self.A_r_wetted
self.UA_a = (self.Fins.h_a *
self.h_a_tuning) * self.Fins.A_a * self.Fins.eta_a
self.UA_w = 1 / self.Rw
#Upadte air-side pressure drop based on the outlet air temperature
#the air-side pressure drop here include momentum, contraction and expansion effects
#Objective function
def OBJECTIVE(x):
Pair_o = x[0]
W = x[1]
if W < 0: #to ensure that the humidty ratio is
print(
'Microchannel Condensder -- Humidity ratio for air pressure drop is less than zero. Humidity ratio is set to 0.0'
)
W = 0.0
v_da = HAPropsSI('V', 'T', self.Tout_a, 'P', Pair_o, 'W', W)
W_new = HAPropsSI('W', 'T', self.Tout_a, 'P', Pair_o, 'V', v_da)
#outlet air density
rho_o = 1 / v_da * (1 + W_new) #[m^3/kg_ha]
#mean air density
rho_m = pow(0.5 * (1 / self.Fins.rho_i_air + 1 / rho_o), -1)
#air-side pressure drop including momentum, expansion and contraction effects
DeltaP_air = self.Fins.G_air**2 / 2 / self.Fins.rho_i_air * (
(1 - self.Fins.sigma**2 + self.Fins.Kc_tri) + 2 *
(self.Fins.rho_i_air / rho_o - 1) +
self.Fins.f_a * self.Fins.A_a / self.Fins.A_a_c *
(self.Fins.rho_i_air / rho_m) -
(1 - self.Fins.sigma**2 - self.Fins.Ke_tri) *
(self.Fins.rho_i_air / rho_o))
resids = [(self.Pin_a - Pair_o) - DeltaP_air, W - W_new]
return resids
#Initial guesses
P_init = self.Pin_a
w_init = HAPropsSI('W', 'T', self.Tin_a, 'P', self.Pin_a, 'R',
self.RHin_a)
#solve for outlet air pressure and outlet humidity ratio
x = fsolve(OBJECTIVE, [P_init, w_init])
#update the air-side pressure drop
self.dP_a = self.Pin_a - x[0]
def Initialize(self):
#Input validation the first call of Initialize
if False: #not hasattr(self,'IsValidated'):
self.Fins.Validate()
reqFields = [
('psat_r', float, 0.001, 100000000),
('Fins', IsFinsClass, None, None),
('FinsType', str, None, None),
('hin_r', float, -100000, 10000000),
('mdot_r', float, 0.000001, 10),
]
optFields = [
'Verbosity', 'AS', 'h_a_tuning', 'h_tp_tuning', 'DP_tuning'
]
d = self.__dict__ #Current fields in model
ValidateFields(d, reqFields, optFields)
self.IsValidated = True
#set tuning factors to 1 in case not given by user
if not hasattr(self, 'h_a_tuning'):
self.h_a_tuning = 1
if not hasattr(self, 'h_tp_tuning'):
self.h_tp_tuning = 1
if not hasattr(self, 'DP_tuning'):
self.DP_tuning = 1
# Make sure AbstractState is passed
assert hasattr(self, 'AS'), 'Please specify the Abstract State'
# Retrieve some parameters from nested structures
# for code compactness
self.ID = self.Fins.Tubes.ID
self.OD = self.Fins.Tubes.OD
self.Ltube = self.Fins.Tubes.Ltube
self.NTubes_per_bank = self.Fins.Tubes.NTubes_per_bank
self.Nbank = self.Fins.Tubes.Nbank
self.Ncircuits = self.Fins.Tubes.Ncircuits
self.Tin_a = self.Fins.Air.Tdb
self.kw = self.Fins.Tubes.kw #thermal conductivity of tube wall
# Calculate an effective length of circuit if circuits are
# not all the same length
TotalLength = self.Ltube * self.NTubes_per_bank * self.Nbank
self.Lcircuit = TotalLength / self.Ncircuits
# Wetted area on the refrigerant side
self.A_r_wetted = self.Ncircuits * pi * self.ID * self.Lcircuit
self.V_r = self.Ncircuits * self.Lcircuit * pi * self.ID**2 / 4.0
#Average mass flux of refrigerant in circuit
self.G_r = self.mdot_r / (self.Ncircuits * pi * self.ID**2 / 4.0
) #[kg/m^2-s]
# Thermal resistance at the wall
self.Rw = log(self.OD / self.ID) / (2 * pi * self.kw * self.Lcircuit *
self.Ncircuits)
## Bubble and dew temperatures (same for fluids without glide)
self.AS.update(CP.PQ_INPUTS, self.psat_r, 0.0)
self.Tbubble_r = self.AS.T() #[K]
h_l = self.AS.hmass() #[J/kg]
self.AS.update(CP.PQ_INPUTS, self.psat_r, 1.0)
self.Tdew_r = self.AS.T() #[K]
h_v = self.AS.hmass() #[J/kg]
## Mean temperature for use in HT relationships
self.Tsat_r = (self.Tbubble_r + self.Tdew_r) / 2
# Latent heat
self.h_fg = h_v - h_l #[J/kg]
self.Fins.Air.RHmean = self.Fins.Air.RH
#Update with user FinType
if self.FinsType == 'WavyLouveredFins':
WavyLouveredFins(self.Fins)
elif self.FinsType == 'HerringboneFins':
HerringboneFins(self.Fins)
elif self.FinsType == 'PlainFins':
PlainFins(self.Fins)
self.mdot_ha = self.Fins.mdot_ha #[kg_ha/s]
self.mdot_da = self.Fins.mdot_da #[kg_da/s]
def Calculate(self):
#Only validate the first time
if not hasattr(self, 'IsValidated'):
self.Fins.Validate()
reqFields = [('Fins', IsFinsClass, None, None),
('FinsType', str, None, None),
('mdot_r', float, 0.00001, 20),
('Tin_r', float, 200, 500),
('psat_r', float, 0.01, 20000000)]
optFields = [
'Verbosity', 'AS', 'h_a_tuning', 'h_tp_tuning', 'DP_tuning'
]
ValidateFields(self.__dict__, reqFields, optFields)
self.IsValidated = True
#set tuning factors to 1 in case not given by user
if not hasattr(self, 'h_a_tuning'):
self.h_a_tuning = 1
if not hasattr(self, 'h_tp_tuning'):
self.h_tp_tuning = 1
if not hasattr(self, 'DP_tuning'):
self.DP_tuning = 1
#AbstractState
AS = self.AS
# Retrieve some parameters from nested structures
# for code compactness
self.ID = self.Fins.Tubes.ID
self.OD = self.Fins.Tubes.OD
self.Ltube = self.Fins.Tubes.Ltube
self.NTubes_per_bank = self.Fins.Tubes.NTubes_per_bank
self.Nbank = self.Fins.Tubes.Nbank
self.Ncircuits = self.Fins.Tubes.Ncircuits
self.Tin_a = self.Fins.Air.Tdb
self.kw = self.Fins.Tubes.kw #thermal conductivity of tube wall
## Bubble and dew temperatures (same for fluids without glide)
AS.update(CP.PQ_INPUTS, self.psat_r, 0.0)
self.Tbubble = AS.T() #[K]
self.h_l = AS.hmass() #[J/kg]
self.cp_satL = AS.cpmass() #[J/kg-K]
AS.update(CP.PQ_INPUTS, self.psat_r, 1.0)
self.Tdew = AS.T() #[K]
self.h_v = AS.hmass() #[J/kg]
# Calculate an effective length of circuit if circuits are
# not all the same length
TotalLength = self.Ltube * self.NTubes_per_bank * self.Nbank
self.Lcircuit = TotalLength / self.Ncircuits
self.V_r = pi * self.ID**2 / 4.0 * self.Lcircuit * self.Ncircuits
self.A_r_wetted = pi * self.ID * self.Ncircuits * self.Lcircuit
self.G_r = self.mdot_r / (self.Ncircuits * pi * self.ID**2 / 4.0)
# Thermal resistance at the wall
self.Rw = log(self.OD / self.ID) / (2 * pi * self.kw * self.Lcircuit *
self.Ncircuits)
#define known parameters
AS.update(CP.PT_INPUTS, self.psat_r, self.Tin_r)
self.hin_r = AS.hmass() #[J/kg]
self.sin_r = AS.smass() #[J/kg-K]
#Definitely have a superheated portion
self._Superheat_Forward()
#Maybe have a full two-phase section
#First try to run with a full two-phase section from quality of 1 to quality of 0
self._TwoPhase_Forward()
#If we have already used too much of the HX (max possible sum of w is 1.0)
if self.w_2phase + self.w_superheat > 1:
#There is no subcooled portion, solve for outlet quality
brentq(self._TwoPhase_Forward, 0.0000001, 0.9999999)
#Zero out all the subcooled parameters
self.Q_subcool = 0.0
self.DP_r_subcool = 0.0
self.Charge_subcool = 0.0
self.w_subcool = 0.0
self.h_r_subcool = 0.0
self.existsSubcooled = False
else:
#By definition then we have a subcooled portion, solve for it
self.existsSubcooled = True
self._Subcool_Forward()
#Overall calculations
self.Q = self.Q_superheat + self.Q_2phase + self.Q_subcool
self.DP_r = self.DP_r_superheat + self.DP_r_2phase + self.DP_r_subcool
self.DP_r = self.DP_r * self.DP_tuning #correcting the pressure drop
self.Charge = self.Charge_2phase + self.Charge_subcool + self.Charge_superheat
if self.existsSubcooled == True:
AS.update(CP.PT_INPUTS, self.psat_r, self.Tout_r)
self.hout_r = AS.hmass() #[J/kg]
self.sout_r = AS.smass() #[J/kg-K]
else:
self.Tout_r = self.xout_2phase * self.Tdew + (
1 - self.xout_2phase) * self.Tbubble
AS.update(CP.QT_INPUTS, 0.0, self.Tout_r)
h_l = AS.hmass() #[J/kg]
s_l = AS.smass() #[J/kg-K]
AS.update(CP.QT_INPUTS, 1.0, self.Tout_r)
h_v = AS.hmass() #[J/kg]
s_v = AS.smass() #[J/kg-K]
self.hout_r = h_l + self.xout_2phase * (h_v - h_l)
self.sout_r = s_l + self.xout_2phase * (s_v - s_l)
#Use the effective subcooling
self.DT_sc = self.DT_sc_2phase
#Calculate the mean outlet air temperature [K]
self.Tout_a = self.Tin_a - self.Q / (self.Fins.cp_da *
self.Fins.mdot_da)
self.hmean_r = self.w_2phase * self.h_r_2phase + self.w_superheat * self.h_r_superheat + self.w_subcool * self.h_r_subcool
self.UA_r = self.hmean_r * self.A_r_wetted
self.UA_a = (self.Fins.h_a *
self.h_a_tuning) * self.Fins.A_a * self.Fins.eta_a
self.UA_w = 1 / self.Rw
def Initialize(self):
#Input validation the first call of Initialize
if False:#not hasattr(self,'IsValidated'):
self.Fins.Validate()
reqFields=[
('psat_r',float,0.001,100000000),
('Fins',IsFinsClass,None,None),
('FinsType',str,None,None),
('hin_r',float,-100000,10000000),
('mdot_r',float,0.000001,10),
]
optFields=['Verbosity','AS','h_a_tuning','h_tp_tuning','DP_tuning']
d=self.__dict__ #Current fields in model
ValidateFields(d,reqFields,optFields)
self.IsValidated=True
#set tuning factors to 1 in case not given by user
if not hasattr(self,'h_a_tuning'):
self.h_a_tuning = 1
if not hasattr(self,'h_tp_tuning'):
self.h_tp_tuning = 1
if not hasattr(self,'DP_tuning'):
self.DP_tuning = 1
# Make sure AbstractState is passed
assert hasattr(self,'AS'), 'Please specify the Abstract State'
# Retrieve some parameters from nested structures
# for code compactness
self.Ltube=self.Fins.Tubes.Ltube #tube length
self.NTubes=self.Fins.Tubes.NTubes #number of tube (per bank)
self.Nbank=self.Fins.Tubes.Nbank #number of banks
self.Tin_a=self.Fins.Air.Tdb #inlet air temperature
self.Pin_a=self.Fins.Air.p #inlet air pressure
self.RHin_a=self.Fins.Air.RH #inlet air relative humidity
self.Td=self.Fins.Tubes.Td #tube outside width (depth)
self.Ht=self.Fins.Tubes.Ht #tube outside height (major diameter)
self.b=self.Fins.Tubes.b #tube spacing
self.tw=self.Fins.Tubes.tw #tube thickness
self.Npass=self.Fins.Tubes.Npass #Number of passes on ref-side (per bank)
self.kw=self.Fins.Tubes.kw #thermal conductivity of tube wall
self.Nports=self.Fins.Tubes.Nports #Number of rectangular ports
self.twp=self.Fins.Tubes.twp #Port wall thickness
self.beta=self.Fins.Tubes.beta #channel (port) aspect ratio (=width/height)
# Define Number of circuits (=number of tubes per pass)
self.Ncircuits = self.NTubes/self.Npass
# Calculate an effective length of circuit if circuits are
# not all the same length
TotalLength=self.Ltube*self.NTubes*self.Nbank
self.Lcircuit=TotalLength/self.Ncircuits
# Volume of refrigerant = rectangle of tube + circular part at the ends - thickness between ports
self.V_r = ((self.Td-self.Ht)*(self.Ht-2.0*self.tw) + (pi/4.0) * (self.Ht - 2.0*self.tw)**2 - (self.Ht-2.0*self.tw)*self.twp*(self.Nports-1)) * self.Lcircuit * self.Ncircuits
# Tube wetted area = tube straight length + circular shape at the ends - horizontal port thickness + vertical thickness between ports
self.A_r_wetted = (2.0*(self.Td - self.Ht) + pi*(self.Ht-2.0*self.tw) - 2.0*self.twp*(self.Nports-1) + 2.0*(self.Ht-2.0*self.tw)*(self.Nports-1)) * self.Lcircuit * self.Ncircuits
# Free-flow area on refrigerant-side = area of rectangle tube + circular parts at end - area thickness between ports
self.A_c = ((self.Td-self.Ht)*(self.Ht-2.0*self.tw) + (pi/4.0) * (self.Ht - 2.0*self.tw)**2 - self.twp*(self.Ht-2.0*self.tw)*(self.Nports-1)) * self.Ncircuits
# Hydraulic diameter on ref-side
self.Dh = 4*self.A_c*self.Lcircuit/self.A_r_wetted
# Mass flux ref-side
self.G_r = self.mdot_r / self.A_c
# Total conduction area (exclude port's thickness)
self.Aw = 2 * (self.Td - self.twp*(self.Nports-1)) * self.Lcircuit * self.Ncircuits
# Thermal resistance at the wall
self.Rw = self.tw /(self.kw*self.Aw)
# Ratio of PH over PF where PH: heated perimeter of channel, PF: wetted perimeter of channel
# In this application, heated perimeter = wetted perimeter, times the number of ports
self.PH_PF = 1*self.Nports
## Bubble and dew temperatures (same for fluids without glide)
self.AS.update(CP.PQ_INPUTS, self.psat_r, 0.0)
self.Tbubble_r=self.AS.T() #[K]
h_l = self.AS.hmass() #[J/kg]
self.AS.update(CP.PQ_INPUTS, self.psat_r, 1.0)
self.Tdew_r=self.AS.T() #[K]
h_v = self.AS.hmass() #[J/kg]
## Mean temperature for use in HT relationships
self.Tsat_r=(self.Tbubble_r+self.Tdew_r)/2
# Latent heat
self.h_fg=h_v - h_l #[J/kg]
self.Fins.Air.RHmean=self.Fins.Air.RH
#Update with user FinType
if self.FinsType == 'MultiLouveredMicroFins':
MultiLouveredMicroFins(self.Fins)
self.mdot_ha=self.Fins.mdot_ha #[kg_ha/s]
self.mdot_da=self.Fins.mdot_da #[kg_da/s]
def Initialize(self):
#Only validate the first time
if not hasattr(self, 'IsValidated'):
self.Fins.Validate()
reqFields = [('Fins', IsFinsClass, None, None),
('FinsType', str, None, None),
('mdot_r', float, 0.00001, 20),
('Tin_r', float, 200, 500),
('psat_r', float, 0.01, 200000000)]
optFields = [
'Verbosity', 'AS', 'h_a_tuning', 'h_r_tuning', 'DP_tuning'
]
ValidateFields(self.__dict__, reqFields, optFields)
self.IsValidated = True
#set tuning factors to 1 in case not given by user
if not hasattr(self, 'h_a_tuning'):
self.h_a_tuning = 1
if not hasattr(self, 'h_r_tuning'):
self.h_r_tuning = 1
if not hasattr(self, 'DP_tuning'):
self.DP_tuning = 1
#AbstractState
assert hasattr(self, 'AS'), 'Please specify the Abstract State'
# Retrieve some parameters from nested structures
# for code compactness
self.Ltube = self.Fins.Tubes.Ltube #tube length
self.NTubes = self.Fins.Tubes.NTubes #number of tube (per bank)
self.Nbank = self.Fins.Tubes.Nbank #number of banks
self.Tin_a = self.Fins.Air.Tdb #inlet air temperature
self.Pin_a = self.Fins.Air.p #inlet air pressure
self.RHin_a = self.Fins.Air.RH #inlet air relative humidity
self.Td = self.Fins.Tubes.Td #tube outside width (depth)
self.Ht = self.Fins.Tubes.Ht #tube outside height (major diameter)
self.b = self.Fins.Tubes.b #tube spacing
self.tw = self.Fins.Tubes.tw #tube thickness
self.Npass = self.Fins.Tubes.Npass #Number of passes on ref-side (per bank)
self.kw = self.Fins.Tubes.kw #thermal conductivity of tube wall
self.Nports = self.Fins.Tubes.Nports #Number of rectangular ports
self.twp = self.Fins.Tubes.twp #Port wall thickness
self.beta = self.Fins.Tubes.beta #channel (port) aspect ratio (=width/height)
# Define Number of circuits (=number of tubes per pass)
self.Ncircuits = self.NTubes / self.Npass
# Calculate an effective length of circuit if circuits are
# not all the same length
TotalLength = self.Ltube * self.NTubes * self.Nbank
self.Lcircuit = TotalLength / self.Ncircuits
# Volume of refrigerant = rectangle of tube + circular part at the ends - thickness between ports
self.V_r = ((self.Td - self.Ht) * (self.Ht - 2.0 * self.tw) +
(pi / 4.0) * (self.Ht - 2.0 * self.tw)**2 -
(self.Ht - 2.0 * self.tw) * self.twp *
(self.Nports - 1)) * self.Lcircuit * self.Ncircuits
# Tube wetted area = tube straight length + circular shape at the ends - horizontal port thickness + vertical thickness between ports
self.A_r_wetted = (2.0 * (self.Td - self.Ht) + pi *
(self.Ht - 2.0 * self.tw) - 2.0 * self.twp *
(self.Nports - 1) + 2.0 *
(self.Ht - 2.0 * self.tw) *
(self.Nports - 1)) * self.Lcircuit * self.Ncircuits
# Free-flow area on refrigerant-side = area of rectangle tube + circular parts at end - area thickness between ports
self.A_c = ((self.Td - self.Ht) * (self.Ht - 2.0 * self.tw) +
(pi / 4.0) * (self.Ht - 2.0 * self.tw)**2 - self.twp *
(self.Ht - 2.0 * self.tw) *
(self.Nports - 1)) * self.Ncircuits
# Hydraulic diameter on ref-side
self.Dh = 4 * self.A_c * self.Lcircuit / self.A_r_wetted
# Mass flux ref-side
self.G_r = self.mdot_r / self.A_c
# Total conduction area (exclude port's thickness)
self.Aw = 2 * (self.Td - self.twp *
(self.Nports - 1)) * self.Lcircuit * self.Ncircuits
# Thermal resistance at the wall
self.Rw = self.tw / (self.kw * self.Aw)
# Define known parameters
self.AS.update(CP.PT_INPUTS, self.psat_r, self.Tin_r)
self.hin_r = self.AS.hmass() #[J/kg]
self.sin_r = self.AS.smass() #[J/kg-K]
# Define critical pressure and temperature
self.Pcr = self.AS.p_critical() #[Pa]
self.Tcr = self.AS.T_critical() #[K]
#critical enthalpy at defined pressure
self.AS.update(CP.PT_INPUTS, self.psat_r, self.Tcr)
self.hcr = self.AS.hmass() #[J/kg]
#triple temperature
self.Ttriple = self.AS.Ttriple()
self.Fins.Air.RHmean = self.Fins.Air.RH
#Update with user FinType
if self.FinsType == 'MultiLouveredMicroFins':
MultiLouveredMicroFins(self.Fins)
self.mdot_ha = self.Fins.mdot_ha #[kg_ha/s]
self.mdot_da = self.Fins.mdot_da #[kg_da/s]