def __call__(self, **kwargs):
self.kwargs.update(kwargs)
if self.calculable:
# try:
self.calculo()
# except ValueError as e:
# self.msg = e
# self.status = 0
# else:
self.status = 1
self.msg = "Solved"
elif self._definition and not self._multicomponent and "ids" in kwargs:
if os.environ["CoolProp"] == "True":
fluido = self._name()
estado = CP.AbstractState("HEOS", fluido)
self.Tc = unidades.Temperature(estado.T_critical())
self.Pc = unidades.Pressure(estado.p_critical())
self.rhoc = unidades.Density(estado.rhomass_critical())
self.M = unidades.Dimensionless(estado.molar_mass()*1000)
self.R = unidades.SpecificHeat(estado.gas_constant()/self.M)
self.Tt = unidades.Temperature(estado.Ttriple())
self.f_accent = unidades.Dimensionless(
estado.acentric_factor())
self.name = fluido
self.CAS = estado.fluid_param_string("CAS")
self.synonim = estado.fluid_param_string("aliases")
self.formula = estado.fluid_param_string("formula")
self.eq = self._limit(fluido, estado)
def calculo(self):
self.entrada = self.kwargs["entrada"]
self.criterio = self.kwargs["criterio"]
self.split = [unidades.Dimensionless(i) for i in self.kwargs["split"]]
self.deltaP = unidades.DeltaP(self.kwargs["deltaP"])
#Comprobamos que las fracciones están normalizadas:
if self.criterio == 0:
if sum(self.split) != 1:
fracciones_normalizadas = []
total = sum(self.split)
for i in self.split:
fracciones_normalizadas.append(i / total)
self.split = fracciones_normalizadas
self.salida = []
if self.criterio == 0:
for i in self.split:
self.salida.append(
self.entrada.clone(P=self.entrada.P - self.deltaP,
split=i))
else:
self.entrada = self.entrada.clone(caudalmasico=sum(self.split))
for i in self.split:
self.salida.append(
self.entrada.clone(P=self.entrada.P - self.deltaP,
split=i))
self.inputMolarFlow = self.entrada.caudalmolar
self.inputMassFlow = self.entrada.caudalmasico
self.inputVolFlow = self.entrada.Q
self.inputT = self.entrada.T
self.inputP = self.entrada.P
self.output = unidades.Dimensionless(self.kwargs["salidas"])
def readStatefromJSON(self, state):
"""Load instance parameter from saved file"""
self.L = unidades.Length(state["L"])
self.rho = unidades.Density(state["rho"])
self.mu = unidades.Viscosity(state["mu"])
self.material = state["material"]
self.Dn = state["Dn"]
self.rugosidad = unidades.Length(state["rugosidad"])
self.De = unidades.Length(state["De"])
self.w = unidades.Length(state["w"])
self.Di = unidades.Length(state["Di"])
self.eD = unidades.Dimensionless(state["eD"])
self.seccion = unidades.Area(state["seccion"])
self.A = unidades.Area(state["A"])
self.V = unidades.Speed(state["V"])
self.Re = unidades.Dimensionless(state["Re"])
self.K = unidades.Dimensionless(state["K"])
self.DeltaP_h = unidades.DeltaP(state["DeltaP_h"])
self.DeltaP_ac = unidades.DeltaP(state["DeltaP_ac"])
self.f = unidades.Dimensionless(state["f"])
self.DeltaP_f = unidades.DeltaP(state["DeltaP_f"])
self.DeltaP_v = unidades.DeltaP(state["DeltaP_v"])
self.DeltaP = unidades.DeltaP(state["DeltaP"])
self.DeltaP_100ft = unidades.Dimensionless(state["DeltaP_100ft"])
self.Tout = unidades.Temperature(state["Tout"])
self.Heat = unidades.Power(state["Heat"])
self.Pin = unidades.Pressure(state["Pin"])
self.Pout = unidades.Pressure(state["Pout"])
self.statusCoste = state["statusCoste"]
if self.statusCoste:
self.C_adq = unidades.Currency(state["C_adq"])
self.C_inst = unidades.Currency(state["C_inst"])
self.salida = [None]
def calculo(self):
"""Calculate procedure, only a mass balance"""
self.entrada = self.kwargs["entrada"]
self.criterio = self.kwargs["criterio"]
self.split = [unidades.Dimensionless(i) for i in self.kwargs["split"]]
self.deltaP = unidades.DeltaP(self.kwargs["deltaP"])
# Normalize fractions
if self.criterio == 0:
if sum(self.split) != 1:
fracciones_normalizadas = []
total = sum(self.split)
for i in self.split:
fracciones_normalizadas.append(i/total)
self.split = fracciones_normalizadas
# Calculate output stream
self.salida = []
if self.criterio == 0:
for i in self.split:
self.salida.append(self.entrada.clone(
P=self.entrada.P-self.deltaP, split=i))
else:
self.entrada = self.entrada.clone(caudalmasico=sum(self.split))
for i in self.split:
self.salida.append(self.entrada.clone(
P=self.entrada.P-self.deltaP, split=i))
# Calculate other properties
self.inputMolarFlow = self.entrada.caudalmolar
self.inputMassFlow = self.entrada.caudalmasico
self.inputVolFlow = self.entrada.Q
self.inputT = self.entrada.T
self.inputP = self.entrada.P
self.output = unidades.Dimensionless(self.kwargs["salidas"])
def _fixed(self):
"""Calculate fixed properties with the chemical compound ids specified,
valid only for one component"""
x = self._x()
fluido = self._name()
refprop.setup("def", fluido)
info = refprop.info()
self.M = unidades.Dimensionless(info["wmm"])
self.Tt = unidades.Temperature(info["ttrp"])
self.Tb = unidades.Temperature(info["tnbpt"])
self.Tc = unidades.Temperature(info["tcrit"])
self.R = unidades.SpecificHeat(info["Rgas"]/self.M)
self.f_accent = unidades.Dimensionless(info["acf"])
self.momentoDipolar = unidades.DipoleMoment(info["dip"], "Debye")
self.rhoc = unidades.Density(info["Dcrit"]*self.M)
self.zc = unidades.Dimensionless(info["zcrit"])
self.Pc = unidades.Pressure(self.R*self.Tc*self.rhoc*self.zc, "kPa")
name = refprop.name()
self.name = name["hname"]
self.CAS = name["hcas"]
def calculo(self, st):
self.x = unidades.Dimensionless(st.x)
self.region = st.region
self.phase = self.getphase(phase=st.phase)
self.name = st.name
self.synonim = st.synonim
self.CAS = st.CAS
self.T = unidades.Temperature(st.T)
self.P = unidades.Pressure(st.P, "MPa")
self.Tr = unidades.Dimensionless(st.Tr)
self.Pr = unidades.Dimensionless(st.Pr)
self.v = unidades.SpecificVolume(st.v)
self.rho = unidades.Density(st.rho)
cp0 = {}
cp0["v"] = st.v0
cp0["h"] = st.h0 * 1000
cp0["s"] = st.s0 * 1000
cp0["cp"] = st.cp0 * 1000
cp0["cv"] = st.cv0 * 1000
cp0["w"] = st.w0
self._cp0(cp0)
self.Liquido = ThermoWater()
self.Gas = ThermoWater()
if self.x == 0:
# only liquid phase
self.fill(self, st.Liquid)
self.fill(self.Liquido, st.Liquid)
self.sigma = unidades.Tension(st.sigma)
self.Hvap = unidades.Enthalpy(None)
self.Svap = unidades.SpecificHeat(None)
elif self.x == 1:
# only vapor phase
self.fill(self, st.Vapor)
self.fill(self.Gas, st.Vapor)
self.Hvap = unidades.Enthalpy(None)
self.Svap = unidades.SpecificHeat(None)
else:
# two phases
self.fill(self.Liquido, st.Liquid)
self.sigma = unidades.Tension(st.sigma)
self.fill(self.Gas, st.Vapor)
self.h = unidades.Enthalpy(st.h)
self.s = unidades.SpecificHeat(st.s)
self.u = unidades.SpecificHeat(st.u)
self.a = unidades.Enthalpy(st.a)
self.g = unidades.Enthalpy(st.g)
self.cv = unidades.SpecificHeat(None)
self.cp = unidades.SpecificHeat(None)
self.cp_cv = unidades.Dimensionless(None)
self.w = unidades.Speed(None)
self.Hvap = unidades.Enthalpy(st.Hvap, "kJkg")
self.Svap = unidades.SpecificHeat(st.Svap, "kJkgK")
def calculo(self):
self.entrada = self.kwargs["entrada"]
self.L = unidades.Length(self.kwargs["l"])
if self.entrada.x == 0:
self.rho = self.entrada.Liquido.rho
self.mu = self.entrada.Liquido.mu
else:
self.rho = self.entrada.Gas.rho
self.mu = self.entrada.Gas.mu
self.material = self.kwargs["material"][0] + " " + self.kwargs[
"material"][1]
self.Dn = self.kwargs["material"][3]
self.rugosidad = unidades.Length(self.kwargs["material"][2], "mm")
self.De = unidades.Length(self.kwargs["material"][6], "mm")
self.w = unidades.Length(self.kwargs["material"][5], "mm")
self.Di = unidades.Length((self.De - 2 * self.w))
self.eD = unidades.Dimensionless(self.rugosidad / self.Di)
self.seccion = unidades.Area(pi / 4 * self.Di**2)
self.A = unidades.Area(pi * self.De * self.L)
self.V = unidades.Speed(self.entrada.Q / self.seccion)
self.Re = Re(self.Di, self.V, self.rho, self.mu)
K = 0
for accesorio in self.kwargs["accesorios"]:
K += accesorio[2] * accesorio[3]
self.K = unidades.Dimensionless(K)
self.DeltaP_h = unidades.Pressure(g * self.kwargs["h"] * self.rho)
self.DeltaP_ac = unidades.Pressure(self.K * self.V**2 / 2 * self.rho)
self.f = f_friccion(self.Re, self.eD)
self.DeltaP_f = self.__DeltaP_friccion()
#TODO:
self.DeltaP_v = unidades.Pressure(0)
self.DeltaP = unidades.Pressure(self.DeltaP_f + self.DeltaP_ac +
self.DeltaP_h)
self.DeltaP_100ft = self.DeltaP * 100 / self.L.ft
self.Pout = unidades.Pressure(self.entrada.P - self.DeltaP)
if self.kwargs["thermal"] == 0:
self.Tout = self.entrada.T
self.Heat = unidades.Power(0)
else:
cambiador = Heat_Exchanger()
cambiador.calculo(entrada=self.entrada,
modo=self.kwargs["thermal"],
Heat=self.kwargs["Q"],
deltaP=self.DeltaP,
A=self.A,
U=self.kwargs["U"],
Text=self.kwargs["Text"])
self.Tout = cambiador.salida[0].T
self.Heat = cambiador.Heat
self.salida = [self.entrada.clone(T=self.Tout, P=self.Pout)]
self.Pin = self.entrada.P
self.Pout = self.salida[0].P
def readStatefromJSON(self, fluid):
ThermoAdvanced.readStatefromJSON(self, fluid)
if fluid:
self.virialD = unidades.Dimensionless(fluid["virialD"])
self.virialBa = unidades.SpecificVolume(fluid["virialBa"])
self.virialCa = unidades.SpecificVolume_square(fluid["virialCa"])
self.dCdt = unidades.Dimensionless(fluid["dCdt"])
self.dCdt2 = unidades.Dimensionless(fluid["dCdt2"])
self.dBdt = unidades.Dimensionless(fluid["dBdt"])
def fill(self, fase, estado):
fase._bool = True
fase.M = self.M
fase.rho = unidades.Density(estado.rho)
fase.v = unidades.SpecificVolume(estado.v)
fase.Z = unidades.Dimensionless(self.P * estado.v / R / 1000 * self.M /
self.T)
fase.h = unidades.Enthalpy(estado.h)
fase.s = unidades.SpecificHeat(estado.s)
fase.u = unidades.Enthalpy(estado.u)
fase.a = unidades.Enthalpy(fase.u - self.T * fase.s)
fase.g = unidades.Enthalpy(fase.h - self.T * fase.s)
fi = exp((fase.g - self.g0) / 1000 / R * self.M / self.T)
fase.fi = [unidades.Pressure(fi)]
fase.f = [unidades.Pressure(self.P * f) for f in fase.fi]
fase.cv = unidades.SpecificHeat(estado.cv)
fase.cp = unidades.SpecificHeat(estado.cp)
fase.cp_cv = unidades.Dimensionless(fase.cp / fase.cv)
fase.gamma = fase.cp_cv
fase.w = unidades.Speed(estado.w)
fase.rhoM = unidades.MolarDensity(fase.rho / self.M)
fase.hM = unidades.MolarEnthalpy(fase.h * self.M)
fase.sM = unidades.MolarSpecificHeat(fase.s * self.M)
fase.uM = unidades.MolarEnthalpy(fase.u * self.M)
fase.aM = unidades.MolarEnthalpy(fase.a * self.M)
fase.gM = unidades.MolarEnthalpy(fase.g * self.M)
fase.cvM = unidades.MolarSpecificHeat(fase.cv * self.M)
fase.cpM = unidades.MolarSpecificHeat(fase.cp * self.M)
fase.mu = unidades.Viscosity(estado.mu)
fase.nu = unidades.Diffusivity(fase.mu / fase.rho)
fase.k = unidades.ThermalConductivity(estado.k)
fase.alfa = unidades.Diffusivity(fase.k / fase.rho / fase.cp)
fase.epsilon = unidades.Dimensionless(
iapws._Dielectric(estado.rho, self.T))
fase.Prandt = unidades.Dimensionless(estado.mu * estado.cp / estado.k)
fase.n = unidades.Dimensionless(
iapws._Refractive(fase.rho, self.T, self.kwargs["l"]))
fase.alfav = unidades.InvTemperature(estado.deriv("Tpv") / fase.v)
fase.kappa = unidades.InvPressure(-estado.deriv("pTv") / fase.v)
fase.kappas = unidades.InvPressure(
-1 / fase.v * self.derivative("v", "P", "s", fase))
fase.joule = unidades.TemperaturePressure(estado.deriv("Tph"))
fase.deltat = unidades.EnthalpyPressure(estado.deriv("pTh"))
fase.alfap = unidades.Density(fase.alfav / self.P / fase.kappa)
fase.betap = unidades.Density(-1 / self.P * estado.deriv("vTp"))
fase.fraccion = [1]
fase.fraccion_masica = [1]
def readStatefromJSON(self, state):
"""Load instance parameter from saved file"""
self.criterio = state["criterio"]
self.split = (unidades.Dimensionless(x) for x in state["split"])
self.deltaP = unidades.DeltaP(state["deltaP"])
self.inputMolarFlow = unidades.MolarFlow(state["inputMolarFlow"])
self.inputMassFlow = unidades.MassFlow(state["inputMassFlow"])
self.inputVolFlow = unidades.VolFlow(state["inputVolFlow"])
self.inputT = unidades.Temperature(state["inputT"])
self.inputP = unidades.Pressure(state["inputP"])
self.output = unidades.Dimensionless(state["output"])
self.salida = [None]*self.kwargs["salidas"]
def calculo(self):
func = [freesteam.steam_pT, freesteam.steam_ph, freesteam.steam_ps,
freesteam.steam_pv, freesteam.steam_Ts, freesteam.steam_Tx][self._thermo]
fluido = func(self.var1, self.var2)
self.M = unidades.Dimensionless(mEoS.H2O.M)
self.Pc = unidades.Pressure(freesteam.PCRIT)
self.Tc = unidades.Temperature(freesteam.TCRIT)
self.rhoc = unidades.Density(freesteam.RHOCRIT*self.M)
self.Tt = mEoS.H2O.Tt
self.Tb = mEoS.H2O.Tb
self.f_accent = unidades.Dimensionless(mEoS.H2O.f_acent)
self.momentoDipolar = mEoS.H2O.momentoDipolar
self.phase = self.getphase(fluido)
self.x = unidades.Dimensionless(fluido.x)
self.name = mEoS.H2O.name
self.synonim = mEoS.H2O.synonym
self.CAS = mEoS.H2O.CASNumber
self.T = unidades.Temperature(fluido.T)
self.P = unidades.Pressure(fluido.p)
self.rho = unidades.Density(fluido.rho)
self.v = unidades.SpecificVolume(1./self.rho)
self.Liquido = Fluid()
self.Gas = Fluid()
if self.x < 1:
# Liquid phase
liquido = freesteam.steam_Tx(fluido.T, 0.)
self.fill(self.Liquido, liquido)
self.Liquido.epsilon = unidades.Tension(iapws._Tension(self.T))
if self.x > 0:
vapor = freesteam.steam_Tx(fluido.T, 1.)
self.fill(self.Gas, vapor)
if self.x in (0, 1):
self.fill(self, fluido)
else:
self.h = unidades.Enthalpy(self.x*self.Vapor.h+(1-self.x)*self.Liquido.h)
self.s = unidades.SpecificHeat(self.x*self.Vapor.s+(1-self.x)*self.Liquido.s)
self.u = unidades.SpecificHeat(self.x*self.Vapor.u+(1-self.x)*self.Liquido.u)
self.a = unidades.Enthalpy(self.x*self.Vapor.a+(1-self.x)*self.Liquido.a)
self.g = unidades.Enthalpy(self.x*self.Vapor.g+(1-self.x)*self.Liquido.g)
self.cv = unidades.SpecificHeat(None)
self.cp = unidades.SpecificHeat(None)
self.cp_cv = unidades.Dimensionless(None)
self.w = unidades.Speed(None)
def _cp0(self, flash):
"Set ideal properties to state"""
cp0 = refprop.therm0(flash["t"], flash["D"], flash["x"])
self.v0 = unidades.SpecificVolume(self.R*self.T/self.P.kPa)
self.rho0 = unidades.Density(1/self.v0)
self.P0 = unidades.Pressure(cp0["p"], "kPa")
self.P_Pideal = unidades.Pressure(self.P-self.P0)
self.h0 = unidades.Enthalpy(cp0["h"]/self.M, "kJkg")
self.u0 = unidades.Enthalpy(cp0["e"]/self.M, "kJkg")
self.s0 = unidades.SpecificHeat(cp0["s"]/self.M, "kJkgK")
self.a0 = unidades.Enthalpy(cp0["A"]/self.M, "kJkg")
self.g0 = unidades.Enthalpy(cp0["G"]/self.M, "kJkg")
self.w0 = unidades.Speed(cp0["w"])
cp0 = refprop.therm0(float(self.T), self.rho0/self.M, flash["x"])
self.cp0 = unidades.SpecificHeat(cp0["cp"]/self.M, "kJkgK")
self.cv0 = unidades.SpecificHeat(cp0["cv"]/self.M, "kJkgK")
self.cp0_cv = unidades.Dimensionless(self.cp0/self.cv0)
self.gamma0 = self.cp0_cv
self.rhoM0 = unidades.MolarDensity(self.rho0/self.M)
self.hM0 = unidades.MolarEnthalpy(self.h0*self.M)
self.uM0 = unidades.MolarEnthalpy(self.u0*self.M)
self.sM0 = unidades.MolarSpecificHeat(self.s0*self.M)
self.aM0 = unidades.MolarEnthalpy(self.a0*self.M)
self.gM0 = unidades.MolarEnthalpy(self.g0*self.M)
self.cpM0 = unidades.MolarSpecificHeat(self.cp0*self.M)
self.cvM0 = unidades.MolarSpecificHeat(self.cv0*self.M)
def calculo(self):
tdp, tdb, twb, P, Pvs, Pv, ws, w, HR, v, h = self._lib()
self.tdp = unidades.Temperature(tdp)
self.tdb = unidades.Temperature(tdb)
self.twb = unidades.Temperature(twb)
self.P = unidades.Pressure(P)
self.Pvs = unidades.Pressure(Pvs)
self.Pv = unidades.Pressure(Pv)
self.ws = unidades.Dimensionless(ws, txt="kgw/kgda")
self.w = unidades.Dimensionless(w, txt="kgw/kgda")
self.HR = unidades.Dimensionless(HR, txt="%")
self.mu = unidades.Dimensionless(w/ws*100)
self.v = unidades.SpecificVolume(v)
self.rho = unidades.Density(1/v)
self.h = unidades.Enthalpy(h, "kJkg")
self.Xa = 1/(1+self.w/0.62198)
self.Xw = 1-self.Xa
def readStatefromJSON(self, state):
"""Load instance parameter from saved file"""
self.criterio = state["criterio"]
self.Pout = unidades.Pressure(state["Pout"])
self.outT = unidades.Temperature(state["outT"])
self.outX = unidades.Dimensionless(state["outX"])
self.outMolarFlow = unidades.MolarFlow(state["outMolarFlow"])
self.outMassFlow = unidades.MassFlow(state["outMassFlow"])
self.outVolFlow = unidades.VolFlow(state["outVolFlow"])
self.salida = [None]
def fill(self, fase, estado):
fase.M = self.M
fase.rho = unidades.Density(estado.rho)
fase.v = unidades.SpecificVolume(estado.v)
fase.Z = unidades.Dimensionless(self.P*estado.v/R/1000*self.M/self.T)
fase.h = unidades.Enthalpy(estado.h)
fase.s = unidades.SpecificHeat(estado.s)
fase.u = unidades.Enthalpy(estado.u)
fase.a = unidades.Enthalpy(fase.u-self.T*fase.s)
fase.g = unidades.Enthalpy(fase.h-self.T*fase.s)
fase.cv = unidades.SpecificHeat(estado.cv)
fase.cp = unidades.SpecificHeat(estado.cp)
fase.cp_cv = unidades.Dimensionless(fase.cp/fase.cv)
fase.w = unidades.Speed(estado.w)
fase.mu = unidades.Viscosity(estado.mu)
fase.k = unidades.ThermalConductivity(estado.k)
fase.nu = unidades.Diffusivity(fase.mu/fase.rho)
fase.dielec = unidades.Dimensionless(iapws._Dielectric(estado.rho, self.T))
fase.Prandt = unidades.Dimensionless(estado.mu*estado.cp/estado.k)
# fase.joule=unidades.TemperaturePressure(self.Liquido["hjt"], "KkPa")
# fase.xkappa=unidades.InvPressure(DerivTerms("IsothermalCompressibility", self.T, fase.rho, self.name), "kPa")
# fase.alfav=unidades.InvTemperature(-estado.PFC.drhodT_constp()/estado.rho)
cp0 = iapws.prop0(self.T, self.P)
fase.v0 = unidades.SpecificVolume(cp0.v)
fase.h0 = unidades.Enthalpy(cp0.h)
fase.u0 = unidades.Enthalpy(fase.h0-self.P*1000*fase.v0)
fase.s0 = unidades.SpecificHeat(cp0.s)
fase.a0 = unidades.Enthalpy(fase.u0-self.T*fase.s0)
fase.g0 = unidades.Enthalpy(fase.h0-self.T*fase.s0)
fase.cp0 = unidades.SpecificHeat(cp0.cp)
fase.cv0 = unidades.SpecificHeat(cp0.cv)
fase.cp0_cv = unidades.Dimensionless(fase.cp0/fase.cv0)
fase.w0 = cp0.w
# fase.gamma0 = cp0.gamma
fase.f = unidades.Pressure(self.P*exp((fase.g-fase.g0)/R/self.T))
def fill(self, fase, flash, thermo, mol, transport, dielec, thermo0):
fase.update(Fluid(thermo))
fase.fraccion = flash["xliq"]
fase.M = unidades.Dimensionless(mol["wmix"])
fase.rho = unidades.Density(flash["Dliq"] * fase.M)
fase.u = unidades.Enthalpy(fase["e"] / fase.M, "Jg")
fase.cv = unidades.SpecificHeat(fase["cv"] / fase.M, "JgK")
fase.cp = unidades.SpecificHeat(fase["cp"] / fase.M, "JgK")
fase.h = unidades.Enthalpy(fase["h"] / fase.M, "Jg")
fase.s = unidades.SpecificHeat(fase["s"] / fase.M, "JgK")
fase.w = unidades.Speed(fase["w"])
fase.joule = unidades.TemperaturePressure(fase["hjt"], "KkPa")
fase.Z = unidades.Dimensionless(fase["Z"])
fase.A = unidades.Enthalpy(fase["A"] / fase.M, "Jg")
fase.G = unidades.Enthalpy(fase["G"] / fase.M, "Jg")
fase.xkappa = unidades.InvPressure(fase["xkappa"], "kPa")
fase.alfav = unidades.InvTemperature(fase["beta"])
# fase.dpdD = fase["dpdD"] #derivative dP/dD [kPa-L/mol]
# fase.d2pdD2 = fase["d2pdD2"] #derivative d^2p/dD^2 [kPa-L^2/mol^2]
# fase.dpdt = unidades.PressureTemperature(fase["dpdt"], "kPaK")
# fase.dDdt = fase["dDdt"] #derivative dD/dt [mol/(L-K)]
# fase.dDdp = fase["dDdp"] #derivative dD/dp [mol/(L-kPa)]
#
# fluido2=refprop.therm3(flash["t"], flash["Dliq"], flash["xliq"])
# fase.xisenk = fluido2["xisenk"]
# fase.xkt = fluido2["xkt"]
# fase.betas = fluido2["betas"]
# fase.bs = fluido2["bs"]
# fase.xkkt = fluido2["xkkt"]
# fase.thrott = fluido2["thrott"]
# fase.pint = fluido2["pint"]
# fase.spht = fluido2["spht"]
# fase.fpv = refprop.fpv(flash["t"], flash["Dliq"], flash["p"], flash["xliq"])
# fase.chempot = refprop.chempot(flash["t"], flash["Dliq"], flash["xliq"])
# fase.fgcty = refprop.fgcty(flash["t"], flash["Dliq"], flash["xliq"])
# fase.fugcof = refprop.fugcof(flash["t"], flash["Dliq"], flash["xliq"])
# fase.virb = refprop.virb(flash["t"], flash["xliq"])["b"]
# fase.virc = refprop.virc(flash["t"], flash["xliq"])["c"]
# fase.vird = refprop.vird(flash["t"], flash["xliq"])["d"]
# fase.virba = refprop.virba(flash["t"], flash["xliq"])["ba"]
# fase.virca = refprop.virca(flash["t"], flash["xliq"])["ca"]
if transport:
fase.mu = unidades.Viscosity(transport["eta"], "muPas")
fase.k = unidades.ThermalConductivity(transport["tcx"])
fase.Prandt = unidades.Dimensionless(fase.mu * fase.cp / fase.k)
else:
fase.mu = unidades.Viscosity(None)
fase.k = unidades.ThermalConductivity(None)
fase.Prandt = unidades.Dimensionless(None)
fase.dielec = unidades.Dimensionless(dielec["de"])
fase.cp0 = unidades.SpecificHeat(thermo0["cp"] / fase.M)
fase.cp0_cv = unidades.Dimensionless(fase.cp0 / fase.cv)
def readStatefromJSON(self, fluid):
Thermo.readStatefromJSON(self, fluid)
if fluid:
self.betas = unidades.TemperaturePressure(fluid["betas"])
self.Gruneisen = unidades.Dimensionless(fluid["Gruneisen"])
self.virialB = unidades.SpecificVolume(fluid["virialB"])
self.virialC = unidades.SpecificVolume_square(fluid["virialC"])
self.dpdT_rho = unidades.PressureTemperature(fluid["dpdT_rho"])
self.dpdrho_T = unidades.PressureDensity(fluid["dpdrho_T"])
self.drhodT_P = unidades.DensityTemperature(fluid["drhodT_P"])
self.drhodP_T = unidades.DensityPressure(fluid["drhodP_T"])
self.dhdT_rho = unidades.SpecificHeat(fluid["dhdT_rho"])
self.dhdP_T = unidades.EnthalpyPressure(fluid["dhdP_T"])
self.dhdT_P = unidades.SpecificHeat(fluid["dhdT_P"])
self.dhdrho_T = unidades.EnthalpyDensity(fluid["dhdrho_T"])
self.dhdP_rho = unidades.EnthalpyPressure(fluid["dhdP_rho"])
self.kt = unidades.Dimensionless(fluid["kt"])
self.ks = unidades.InvPressure(fluid["ks"])
self.Ks = unidades.Pressure(fluid["Ks"])
self.Kt = unidades.Pressure(fluid["Kt"])
self.IntP = unidades.Pressure(fluid["IntP"])
self.invT = unidades.InvTemperature(fluid["invT"])
self.hInput = unidades.Enthalpy(fluid["hInput"])
self.epsilon = unidades.Dimensionless(fluid["epsilon"])
def fill(self, fase, st):
"""Fill phase properties"""
fase._bool = True
fase.M = self.M
fase.v = unidades.SpecificVolume(st.v)
fase.rho = unidades.Density(st.rho)
fase.Z = unidades.Dimensionless(st.Z)
fase.h = unidades.Enthalpy(st.h, "kJkg")
fase.s = unidades.SpecificHeat(st.s, "kJkgK")
fase.u = unidades.Enthalpy(st.u, "kJkg")
fase.a = unidades.Enthalpy(st.a, "kJkg")
fase.g = unidades.Enthalpy(st.g, "kJkg")
fase.fi = [unidades.Dimensionless(st.fi)]
fase.f = [unidades.Pressure(st.f, "MPa")]
fase.cv = unidades.SpecificHeat(st.cv, "kJkgK")
fase.cp = unidades.SpecificHeat(st.cp, "kJkgK")
fase.cp_cv = unidades.Dimensionless(st.cp_cv)
fase.gamma = fase.cp_cv
fase.w = unidades.Speed(st.w)
fase.rhoM = unidades.MolarDensity(fase.rho / self.M)
fase.hM = unidades.MolarEnthalpy(fase.h * self.M)
fase.sM = unidades.MolarSpecificHeat(fase.s * self.M)
fase.uM = unidades.MolarEnthalpy(fase.u * self.M)
fase.aM = unidades.MolarEnthalpy(fase.a * self.M)
fase.gM = unidades.MolarEnthalpy(fase.g * self.M)
fase.cvM = unidades.MolarSpecificHeat(fase.cv * self.M)
fase.cpM = unidades.MolarSpecificHeat(fase.cp * self.M)
fase.alfav = unidades.InvTemperature(st.alfav)
fase.kappa = unidades.InvPressure(st.xkappa, "MPa")
fase.kappas = unidades.InvPressure(st.kappas, "MPa")
fase.mu = unidades.Viscosity(st.mu)
fase.nu = unidades.Diffusivity(st.nu)
fase.k = unidades.ThermalConductivity(st.k)
fase.alfa = unidades.Diffusivity(st.alfa)
fase.epsilon = unidades.Dimensionless(st.epsilon)
fase.Prandt = unidades.Dimensionless(st.Prandt)
fase.n = unidades.Dimensionless(st.n)
fase.joule = unidades.TemperaturePressure(st.joule)
fase.deltat = unidades.EnthalpyPressure(st.deltat)
fase.betap = unidades.Density(st.betap)
fase.alfap = unidades.Density(st.alfap)
fase.fraccion = [1]
fase.fraccion_masica = [1]
def _cp0(self, cp0):
"Set ideal properties to state" ""
self.v0 = unidades.SpecificVolume(cp0["v"])
self.rho0 = unidades.Density(1. / cp0["v"])
self.h0 = unidades.Enthalpy(cp0["h"])
self.u0 = unidades.Enthalpy(self.h0 - self.P * self.v0)
self.s0 = unidades.SpecificHeat(cp0["s"])
self.a0 = unidades.Enthalpy(self.u0 - self.T * self.s0)
self.g0 = unidades.Enthalpy(self.h0 - self.T * self.s0)
self.cp0 = unidades.SpecificHeat(cp0["cp"])
self.cv0 = unidades.SpecificHeat(cp0["cv"])
self.cp0_cv = unidades.Dimensionless(self.cp0 / self.cv0)
self.w0 = unidades.Speed(cp0["w"])
self.gamma0 = self.cp0_cv
self.rhoM0 = unidades.MolarDensity(self.rho0 / self.M)
self.hM0 = unidades.MolarEnthalpy(self.h0 * self.M)
self.uM0 = unidades.MolarEnthalpy(self.u0 * self.M)
self.sM0 = unidades.MolarSpecificHeat(self.s0 * self.M)
self.aM0 = unidades.MolarEnthalpy(self.a0 * self.M)
self.gM0 = unidades.MolarEnthalpy(self.g0 * self.M)
self.cpM0 = unidades.MolarSpecificHeat(self.cp0 * self.M)
self.cvM0 = unidades.MolarSpecificHeat(self.cv0 * self.M)
def _cp0(self):
"Set ideal properties to state" ""
self.v0 = unidades.SpecificVolume(None)
self.rho0 = unidades.Density(None)
self.h0 = unidades.Enthalpy(None)
self.u0 = unidades.Enthalpy(None)
self.s0 = unidades.SpecificHeat(None)
self.a0 = unidades.Enthalpy(None)
self.g0 = unidades.Enthalpy(None)
self.cp0 = unidades.SpecificHeat(None)
self.cv0 = unidades.SpecificHeat(None)
self.cp0_cv = unidades.Dimensionless(None)
self.w0 = unidades.Speed(None)
self.gamma0 = self.cp0_cv
self.rhoM0 = unidades.MolarDensity(None)
self.hM0 = unidades.MolarEnthalpy(None)
self.uM0 = unidades.MolarEnthalpy(None)
self.sM0 = unidades.MolarSpecificHeat(None)
self.aM0 = unidades.MolarEnthalpy(None)
self.gM0 = unidades.MolarEnthalpy(None)
self.cpM0 = unidades.MolarSpecificHeat(None)
self.cvM0 = unidades.MolarSpecificHeat(None)
def calculo(self):
T = self.kwargs["T"]
rho = self.kwargs["rho"]
P = self.kwargs["P"]
v = self.kwargs["v"]
h = self.kwargs["h"]
s = self.kwargs["s"]
u = self.kwargs["u"]
x = self.kwargs["x"]
self.comp = []
for i in self.kwargs["componente"]:
c = self.componentes[i](eq="GERG", **self.kwargs)
self.comp.append(c)
self.id = self.kwargs["componente"]
self.xi = self.kwargs["fraccion"]
# Critic properties for mixture,
# eq. 7.9, 7.10 pag.125, Tabla 7.10 pag 136
bt = self.Prop_c["beta_t"]
bv = self.Prop_c["beta_v"]
gt = self.Prop_c["gamma_t"]
gv = self.Prop_c["gamma_v"]
c_T = zeros((len(self.comp), len(self.comp)))
c_rho = zeros((len(self.comp), len(self.comp)))
for i, cmpi in enumerate(self.comp):
for j, cmpj in enumerate(self.comp):
c_T[i, j] = 2*bt[i][j]*gt[i][j]*(cmpi.Tc*cmpj.Tc)**0.5
c_rho[i, j] = 2*bv[i][j]*gv[i][j]/8. * \
(1./cmpi.rhoc**(1./3)+1./cmpj.rhoc**(1./3))**3
f_T = zeros((len(self.comp), len(self.comp)))
f_rho = zeros((len(self.comp), len(self.comp)))
dFT_ik = zeros((len(self.comp), len(self.comp)))
dFT_ki = zeros((len(self.comp), len(self.comp)))
dFrho_ik = zeros((len(self.comp), len(self.comp)))
dFrho_ki = zeros((len(self.comp), len(self.comp)))
for i, x_i in enumerate(self.xi):
for j, x_j in enumerate(self.xi):
f_T[i, j] = x_i*x_j*(x_i+x_j)/(bt[i][j]**2*x_i+x_j)
f_rho[i, j] = x_i*x_j*(x_i+x_j)/(bv[i][j]**2*x_i+x_j)
dFT_ik[i, j] = x_j*(x_j+x_i)/(bt[i][j]**2*x_i+x_j) + \
x_j*x_i/(bt[i][j]**2*x_i+x_j) * \
(1-bt[i][j]**2*(x_j+x_i)/(bt[i][j]**2*x_i+x_j))
dFrho_ik[i, j] = x_j*(x_j+x_i)/(bv[i][j]**2*x_i+x_j) + \
x_j*x_i/(bv[i][j]**2*x_i+x_j) * \
(1-bv[i][j]**2*(x_j+x_i)/(bv[i][j]**2*x_i+x_j))
dFT_ki[j, i] = x_j*(x_j+x_i)/(bt[i][j]**2*x_j+x_i)+x_j*x_i / \
(bt[i][j]**2*x_j+x_i)*(1-(x_j+x_i)/(bt[i][j]**2*x_j+x_i))
dFrho_ki[j, i] = x_j*(x_j+x_i)/(bv[i][j]**2*x_j+x_i)+x_j*x_i /\
(bv[i][j]**2*x_j+x_i)*(1-(x_j+x_i)/(bv[i][j]**2*x_j+x_i))
sumai_v = sumaij_v = sumai_T = sumaij_T = m = 0
for i, componentei in enumerate(self.comp):
sumai_v += self.xi[i]**2/componentei.rhoc
sumai_T += self.xi[i]**2*componentei.Tc
m += self.xi[i]*componentei.M
for j, componentej in enumerate(self.comp):
if j > i:
sumaij_v += c_rho[i, j]*f_rho[i, j]
sumaij_T += c_T[i, j]*f_T[i, j]
self.rhoc = unidades.Density(1./(sumai_v+sumaij_v))
self.Tc = unidades.Temperature(sumai_T+sumaij_T)
self.M = m # g/mol
self.R = unidades.SpecificHeat(R/self.M, "kJkgK")
Tcxi = rhocxi = []
for i, componentei in enumerate(self.comp):
sumav1 = sumat1 = 0
for k in range(i):
sumav1 += c_rho[k, i]*dFrho_ki[k, i]
sumat1 += c_T[k, i]*dFT_ki[k, i]
sumav2 = sumat2 = 0
for k in range(i+1, len(self.xi)):
sumav2 += c_rho[i, k]*dFrho_ik[i, k]
sumat2 += c_T[i, k]*dFT_ik[i, k]
Tcxi.append(2*self.xi[i]*componentei.Tc+sumat1+sumat2)
rhocxi.append(2*self.xi[i]/componentei.rhoc+sumav1+sumav2)
self.Tcxi = Tcxi
self.rhocxi = rhocxi
if v and not rho:
rho = 1./v
if T and x is not None:
pass
else:
if T and P:
rhoo = 2.
rho = fsolve(lambda rho: self._solve(rho, T)["P"]-P*1e6, rhoo)
elif T and rho:
pass
elif T and h is not None:
rho = fsolve(lambda rho: self._solve(rho, T)["h"]-h, 200)
elif T and s is not None:
rho = fsolve(lambda rho: self._solve(rho, T)["s"]-s, 200)
elif T and u is not None:
rho = fsolve(lambda rho: self._solve(rho, T)["u"]-u, 200)
elif P and rho:
T = fsolve(lambda T: self._solve(rho, T)["P"]-P*1e6, 600)
elif P and h is not None:
rho, T = fsolve(lambda par: (
self._solve(par[0], par[1])["P"]-P*1e6, self._solve(
par[0], par[1])["h"]-h), [200, 600])
elif P and s is not None:
rho, T = fsolve(lambda par: (
self._solve(par[0], par[1])["P"]-P*1e6, self._solve(
par[0], par[1])["s"]-s), [200, 600])
elif P and u is not None:
rho, T = fsolve(lambda par: (
self._solve(par[0], par[1])["P"]-P*1e6, self._solve(
par[0], par[1])["u"]-u), [200, 600])
elif rho and h is not None:
T = fsolve(lambda T: self._solve(rho, T)["h"]-h, 600)
elif rho and s is not None:
T = fsolve(lambda T: self._solve(rho, T)["s"]-s, 600)
elif rho and u is not None:
T = fsolve(lambda T: self._solve(rho, T)["u"]-u, 600)
elif h is not None and s is not None:
rho, T = fsolve(lambda par: (
self._solve(par[0], par[1])["h"]-h, self._solve(
par[0], par[1])["s"]-s), [200, 600])
elif h is not None and u is not None:
rho, T = fsolve(lambda par: (
self._solve(par[0], par[1])["h"]-h, self._solve(
par[0], par[1])["u"]-u), [200, 600])
elif s is not None and u is not None:
rho, T = fsolve(lambda par: (
self._solve(par[0], par[1])["s"]-s, self._solve(
par[0], par[1])["u"]-u), [200, 600])
else:
raise IOError
fio, fiot, fiott, fiod, fiodd, fiodt, fir, firt, firtt, fird, firdd,\
firdt, firdtt, nfioni, nfirni = self._eq(rho, T)
# Tabla 7.1 pag 127
tau = self.Tc/T
delta = rho/self.rhoc
self.T = unidades.Temperature(T)
self.rho = unidades.Density(rho)
self.v = unidades.SpecificVolume(1./rho)
self.P = unidades.Pressure((1+delta*fird)*self.R.JkgK*T*rho)
self.Z = 1+delta*fird
self.s = unidades.SpecificHeat(self.R.kJkgK*(tau*(fiot+firt)-fio-fir))
self.u = unidades.Enthalpy(self.R*T*tau*(fiot+firt))
self.h = unidades.Enthalpy(self.R*T*(1+tau*(fiot+firt)+delta*fird))
self.cp = unidades.SpecificHeat(self.R*(
-tau**2*(fiott+firtt)+(1+delta*fird-delta*tau*firdt)**2 /
(1+2*delta*fird+delta**2*firdd)))
self.cv = unidades.SpecificHeat(-self.R*tau**2*(fiott+firtt))
self.g = unidades.Enthalpy(self.R*T*(1+fio+fir+delta*fird))
self.w = unidades.Speed((self.R*T*(
1+2*delta*fird+delta**2*firdd-(1+delta*fird-delta*tau*firdt)**2 /
tau**2/(fiott+firtt)))**0.5)
f, FI = self.fug(rho, T, nfirni)
Ki, xi, yi, Q = self.flash()
self.x = unidades.Dimensionless(Q)
self.xl = xi
self.xv = yi
if self.kwargs["mezcla"]:
self.Pc = self.kwargs["mezcla"].Pc
self.Liquido = ThermoAdvanced()
self.Gas = ThermoAdvanced()
def _Dielectric(self, rho, T):
try:
nu = _Dielectric(rho, T)
except NotImplementedError:
nu = None
return unidades.Dimensionless(nu)
def calculo(self):
refprop.setup(self.kwargs["ref"], self.kwargs["fluido"])
m = refprop.wmol(self.kwargs["fraccionMolar"])["wmix"]
self.M = unidades.Dimensionless(m)
crit = refprop.critp(self.kwargs["fraccionMolar"])
self.Pc = unidades.Pressure(crit["pcrit"], "kPa")
self.Tc = unidades.Temperature(crit["tcrit"])
self.rhoc = unidades.Density(crit["Dcrit"] * self.M)
args = self.args()
flash = refprop.flsh(*args)
self.phase, self.x = self.getphase(flash)
self.T = unidades.Temperature(flash["t"])
self.P = unidades.Pressure(flash["p"], "kPa")
self.rho = unidades.Density(flash["D"] * self.M)
self.v = unidades.SpecificVolume(1. / self.rho)
name = refprop.name(flash["nc"])
info = refprop.info(flash["nc"])
if flash["nc"] == 1:
self.name = name["hname"]
self.synonim = name["hn80"]
self.CAS = name["hcas"]
self.Tt = unidades.Temperature(info["ttrp"])
self.Tb = unidades.Temperature(info["tnbpt"])
self.f_accent = unidades.Dimensionless(info["acf"])
self.momentoDipolar = unidades.DipoleMoment(info["dip"], "Debye")
self.Liquido = Fluid()
self.Vapor = Fluid()
if self.x < 1.: # Hay fase liquida
liquido_thermo = refprop.therm2(flash["t"], flash["Dliq"],
flash["xliq"])
liquido_mol = refprop.wmol(flash["xliq"])
try:
liquido_transport = refprop.trnprp(flash["t"], flash["Dliq"],
flash["xliq"])
except refprop.RefpropError as e:
print e
liquido_transport = None
liquido_dielec = refprop.dielec(flash["t"], flash["Dliq"],
flash["xliq"])
liquido_thermo0 = refprop.therm0(flash["t"], flash["Dliq"],
flash["xliq"])
self.fill(self.Liquido, flash, liquido_thermo, liquido_mol,
liquido_transport, liquido_dielec, liquido_thermo0)
if self.x > 0.: # Hay fase vapor
vapor_thermo = refprop.therm2(flash["t"], flash["Dvap"],
flash["xvap"])
vapor_mol = refprop.wmol(flash["xvap"])
try:
vapor_transport = refprop.trnprp(flash["t"], flash["Dvap"],
flash["xvap"])
except refprop.RefpropError as e:
print e
vapor_transport = None
vapor_dielec = refprop.dielec(flash["t"], flash["Dvap"],
flash["xvap"])
vapor_thermo0 = refprop.therm0(flash["t"], flash["Dvap"],
flash["xvap"])
self.fill(self.Vapor, flash, vapor_thermo, vapor_mol,
vapor_transport, vapor_dielec, vapor_thermo0)
# crit = multiRP.mRP[u'process'](target=multiRP.critp, args=(self.kwargs["fraccionMolar"], setup, multiRP.mRP))
# mol = multiRP.mRP[u'process'](target=multiRP.wmol, args=(self.kwargs["fraccionMolar"], setup, multiRP.mRP))
# processlist = [crit, mol]
# multiRP.run_mRP(processlist)
# self.Pc=unidades.Pressure(multiRP.mRP[u'result'][processlist[0].name]["pcrit"], "kPa")
# self.Tc=unidades.Temperature(multiRP.mRP[u'result'][processlist[0].name]["tcrit"])
# self.rhoc=unidades.Density(multiRP.mRP[u'result'][processlist[0].name]["Dcrit"]*self.M)
# args=self.args()
# flash = multiRP.mRP[u'process'](target=multiRP.flsh, args=args, kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# name = multiRP.mRP[u'process'](target=multiRP.name, args=(1, setup, multiRP.mRP))
# info = multiRP.mRP[u'process'](target=multiRP.info, args=(1, setup, multiRP.mRP))
# processlist = [flash, name, info]
# multiRP.run_mRP(processlist)
# flash=multiRP.mRP[u'result'][processlist[0].name]
# self.phase, self.x=self.getphase(flash)
# self.nc=flash["nc"]
# self.fraccion=self.kwargs["fraccionMolar"]
# if flash["nc"] ==1:
# self.name=multiRP.mRP[u'result'][processlist[1].name]["hname"]
# self.synonim=multiRP.mRP[u'result'][processlist[1].name]["hn80"]
# self.CAS=multiRP.mRP[u'result'][processlist[1].name]["hcas"]
#
# self.Tt=unidades.Temperature(multiRP.mRP[u'result'][processlist[2].name]["ttrp"])
# self.Tb=unidades.Temperature(multiRP.mRP[u'result'][processlist[2].name]["tnbpt"])
# self.f_accent=unidades.Dimensionless(multiRP.mRP[u'result'][processlist[2].name]["acf"])
# self.momentoDipolar=unidades.DipoleMoment(multiRP.mRP[u'result'][processlist[2].name]["dip"], "Debye")
# self.Rgas=unidades.SpecificHeat(multiRP.mRP[u'result'][processlist[2].name]["Rgas"]/self.M)
# else:
# self.Rgas=unidades.SpecificHeat(refprop.rmix2(self.kwargs["fraccionMolar"])["Rgas"]/self.M)
# self.T=unidades.Temperature(flash["t"])
# self.P=unidades.Pressure(flash["p"], "kPa")
# self.rho=unidades.Density(flash["D"]*self.M)
# self.v=unidades.SpecificVolume(1./self.rho)
# self.Liquido=Fluid()
# self.Vapor=Fluid()
# if self.x<1.: #Hay fase liquida
# liquido_thermo = multiRP.mRP[u'process'](target=multiRP.therm2, args=(flash["t"], flash["Dliq"], flash["xliq"]), kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# liquido_mol = multiRP.mRP[u'process'](target=multiRP.wmol, args=(flash["xliq"], setup, multiRP.mRP))
# liquido_transport = multiRP.mRP[u'process'](target=multiRP.trnprp, args=(flash["t"], flash["Dliq"], flash["xliq"]), kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# liquido_dielec = multiRP.mRP[u'process'](target=multiRP.dielec, args=(flash["t"], flash["Dliq"], flash["xliq"]), kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# liquido_thermo0 = multiRP.mRP[u'process'](target=multiRP.therm0, args=(flash["t"], flash["Dliq"], flash["xliq"]), kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# processlist = [liquido_thermo, liquido_mol, liquido_transport, liquido_dielec, liquido_thermo0]
# try:
# multiRP.run_mRP(processlist)
# transport=multiRP.mRP[u'result'][processlist[2].name]
# except refprop.RefpropError as e:
# print e
# transport=None
# self.fill(self.Liquido, flash, multiRP.mRP[u'result'][processlist[0].name], multiRP.mRP[u'result'][processlist[1].name],
# transport, multiRP.mRP[u'result'][processlist[3].name], multiRP.mRP[u'result'][processlist[4].name])
# if self.x>0.: #Hay fase vapor
# vapor_thermo = multiRP.mRP[u'process'](target=multiRP.therm2, args=(flash["t"], flash["Dvap"], flash["xvap"]), kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# vapor_mol = multiRP.mRP[u'process'](target=multiRP.wmol, args=(flash["xvap"], setup, multiRP.mRP))
# vapor_transport = multiRP.mRP[u'process'](target=multiRP.trnprp, args=(flash["t"], flash["Dvap"], flash["xvap"]), kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# vapor_dielec = multiRP.mRP[u'process'](target=multiRP.dielec, args=(flash["t"], flash["Dvap"], flash["xvap"]), kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# vapor_thermo0 = multiRP.mRP[u'process'](target=multiRP.therm0, args=(flash["t"], flash["Dvap"], flash["xvap"]), kwargs={u'prop': setup, u'mRP': multiRP.mRP})
# processlist = [vapor_thermo, vapor_mol, vapor_transport, vapor_dielec, vapor_thermo0]
# try:
# multiRP.run_mRP(processlist)
# transport=multiRP.mRP[u'result'][processlist[2].name]
# except refprop.RefpropError as e:
# print e
# transport=None
#
# self.fill(self.Vapor, flash, multiRP.mRP[u'result'][processlist[0].name], multiRP.mRP[u'result'][processlist[1].name],
# transport, multiRP.mRP[u'result'][processlist[3].name], multiRP.mRP[u'result'][processlist[4].name])
self.h = unidades.Enthalpy(self.x * self.Vapor.h +
(1 - self.x) * self.Liquido.h)
self.s = unidades.SpecificHeat(self.x * self.Vapor.s +
(1 - self.x) * self.Liquido.s)
self.cp = unidades.SpecificHeat(self.x * self.Vapor.cp +
(1 - self.x) * self.Liquido.cp)
self.cp0 = unidades.SpecificHeat(self.x * self.Vapor.cp0 +
(1 - self.x) * self.Liquido.cp0)
self.cv = unidades.SpecificHeat(self.x * self.Vapor.cv +
(1 - self.x) * self.Liquido.cv)
self.cp_cv = unidades.Dimensionless(self.cp / self.cv)
self.cp0_cv = unidades.Dimensionless(self.cp0 / self.cv)
if self.T <= self.Tc:
surten = refprop.surten(flash["t"], flash["Dliq"], flash["Dvap"],
flash["xliq"], flash["xvap"])
self.surten = unidades.Tension(surten["sigma"])
else:
self.surten = unidades.Tension(None)
def fill(self, fase, estado):
fase._bool = True
fase.M = unidades.Dimensionless(estado.molar_mass()*1000)
fase.rho = unidades.Density(estado.rhomass())
fase.v = unidades.SpecificVolume(1./fase.rho)
fase.Z = unidades.Dimensionless(estado.keyed_output(CP.iZ))
fase.h = unidades.Enthalpy(estado.hmass())
fase.s = unidades.SpecificHeat(estado.smass())
fase.u = unidades.Enthalpy(estado.umass())
fase.a = unidades.Enthalpy(fase.u-self.T*fase.s)
fase.g = unidades.Enthalpy(fase.h-self.T*fase.s)
if self._multicomponent:
fase.fi = []
fase.f = []
for i in range(len(self.kwargs["ids"])):
fase.fi.append(unidades.Dimensionless(
estado.fugacity_coefficient(i)))
fase.f.append(unidades.Pressure(estado.fugacity(i)))
else:
fase.fi = [unidades.Dimensionless(
exp(estado.alphar()+estado.delta()*estado.dalphar_dDelta() -
log(1+estado.delta()*estado.dalphar_dDelta())))]
fase.f = [unidades.Pressure(self.P*f) for f in fase.fi]
fase.cv = unidades.SpecificHeat(estado.cvmass())
fase.cp = unidades.SpecificHeat(estado.cpmass())
fase.cp_cv = unidades.Dimensionless(fase.cp/fase.cv)
fase.gamma = fase.cp_cv
fase.w = unidades.Speed(estado.speed_sound())
fase.rhoM = unidades.MolarDensity(estado.rhomolar(), "molm3")
fase.hM = unidades.MolarEnthalpy(estado.hmolar(), "Jmol")
fase.sM = unidades.MolarSpecificHeat(estado.smolar(), "JmolK")
fase.uM = unidades.MolarEnthalpy(estado.umolar(), "Jmol")
fase.aM = unidades.MolarEnthalpy(fase.a*self.M)
fase.gM = unidades.MolarEnthalpy(fase.g*self.M)
fase.cvM = unidades.MolarSpecificHeat(estado.cvmolar(), "JmolK")
fase.cpM = unidades.MolarSpecificHeat(estado.cpmolar(), "JmolK")
fase.joule = unidades.TemperaturePressure(
estado.first_partial_deriv(CP.iT, CP.iP, CP.iHmass))
fase.Gruneisen = unidades.Dimensionless(
fase.v/fase.cv*estado.first_partial_deriv(CP.iP, CP.iT, CP.iDmass))
fase.alfav = unidades.InvTemperature(
estado.isobaric_expansion_coefficient())
fase.kappa = unidades.InvPressure(estado.isothermal_compressibility())
fase.kappas = unidades.InvPressure(
-1/fase.v*self.derivative("v", "P", "s", fase))
fase.alfap = unidades.Density(fase.alfav/self.P/fase.kappa)
fase.betap = unidades.Density(
-1/self.P*self.derivative("P", "v", "T", fase))
fase.betas = unidades.TemperaturePressure(
estado.first_partial_deriv(CP.iT, CP.iP, CP.iSmass))
fase.kt = unidades.Dimensionless(
fase.rho/self.P*estado.first_partial_deriv(
CP.iP, CP.iDmass, CP.iT))
fase.Ks = unidades.Pressure(
fase.rho*estado.first_partial_deriv(CP.iP, CP.iDmass, CP.iSmass))
fase.Kt = unidades.Pressure(
fase.rho*estado.first_partial_deriv(CP.iP, CP.iDmass, CP.iT))
fase.ks = unidades.Dimensionless(
fase.rho/self.P*estado.first_partial_deriv(
CP.iP, CP.iDmass, CP.iSmass))
fase.dhdT_rho = unidades.SpecificHeat(
estado.first_partial_deriv(CP.iHmass, CP.iT, CP.iDmass))
fase.dhdT_P = unidades.SpecificHeat(
estado.first_partial_deriv(CP.iHmass, CP.iT, CP.iP))
fase.dhdP_T = unidades.EnthalpyPressure(
estado.first_partial_deriv(CP.iHmass, CP.iP, CP.iT)) # deltat
fase.deltat = fase.dhdP_T
fase.dhdP_rho = unidades.EnthalpyPressure(
estado.first_partial_deriv(CP.iHmass, CP.iP, CP.iDmass))
fase.dhdrho_T = unidades.EnthalpyDensity(
estado.first_partial_deriv(CP.iHmass, CP.iDmass, CP.iT))
fase.dhdrho_P = unidades.EnthalpyDensity(
estado.first_partial_deriv(CP.iHmass, CP.iDmass, CP.iP))
fase.dpdT_rho = unidades.PressureTemperature(
estado.first_partial_deriv(CP.iP, CP.iT, CP.iDmass))
fase.dpdrho_T = unidades.PressureDensity(
estado.first_partial_deriv(CP.iP, CP.iDmass, CP.iT))
fase.drhodP_T = unidades.DensityPressure(
estado.first_partial_deriv(CP.iDmass, CP.iP, CP.iT))
fase.drhodT_P = unidades.DensityTemperature(
estado.first_partial_deriv(CP.iDmass, CP.iT, CP.iP))
fase.Z_rho = unidades.SpecificVolume((fase.Z-1)/fase.rho)
fase.IntP = unidades.Pressure(
self.T*estado.first_partial_deriv(CP.iP, CP.iT, CP.iDmass)-self.P)
fase.hInput = unidades.Enthalpy(
-fase.rho*estado.first_partial_deriv(CP.iHmass, CP.iDmass, CP.iP))
fase.virialB = unidades.SpecificVolume(estado.Bvirial())
fase.virialC = unidades.SpecificVolume_square(estado.Cvirial())
fase.invT = unidades.InvTemperature(-1/self.T)
fase.mu = unidades.Viscosity(estado.viscosity())
fase.nu = unidades.Diffusivity(fase.mu/fase.rho)
fase.k = unidades.ThermalConductivity(estado.conductivity())
fase.alfa = unidades.Diffusivity(fase.k/fase.rho/fase.cp)
fase.Prandt = unidades.Dimensionless(estado.Prandtl())
fase.fraccion = estado.get_mole_fractions()
fase.fraccion_masica = estado.get_mass_fractions()
fase.epsilon = unidades.Dimensionless(None)
def calculo(self):
fluido = self._name()
args = self.args()
estado = CP.AbstractState("HEOS", fluido)
if self._multicomponent:
estado.set_mole_fractions(self.kwargs["fraccionMolar"])
estado.update(self._par, *args)
self.M = unidades.Dimensionless(estado.molar_mass()*1000)
if self._multicomponent:
# Disabled CoolProp critical properties for multicomponent,
# see issue #1087
# Calculate critical properties with mezcla method
# Coolprop for mixtures can fail and it's slow
Cmps = [Componente(int(i)) for i in self.kwargs["ids"]]
# Calculate critic temperature, API procedure 4B1.1 pag 304
V = sum([xi*cmp.Vc for xi, cmp in
zip(self.kwargs["fraccionMolar"], Cmps)])
k = [xi*cmp.Vc/V for xi, cmp in
zip(self.kwargs["fraccionMolar"], Cmps)]
Tcm = sum([ki*cmp.Tc for ki, cmp in zip(k, Cmps)])
self.Tc = unidades.Temperature(Tcm)
# Calculate pseudocritic temperature
tpc = sum([x*cmp.Tc for x, cmp in
zip(self.kwargs["fraccionMolar"], Cmps)])
# Calculate pseudocritic pressure
ppc = sum([x*cmp.Pc for x, cmp in
zip(self.kwargs["fraccionMolar"], Cmps)])
# Calculate critic pressure, API procedure 4B2.1 pag 307
sumaw = 0
for xi, cmp in zip(self.kwargs["fraccionMolar"], Cmps):
sumaw += xi*cmp.f_acent
pc = ppc+ppc*(5.808+4.93*sumaw)*(self.Tc-tpc)/tpc
self.Pc = unidades.Pressure(pc)
# Calculate critic volume, API procedure 4B3.1 pag 314
sumaxvc23 = sum([xi*cmp.Vc**(2./3) for xi, cmp in
zip(self.kwargs["fraccionMolar"], Cmps)])
k = [xi*cmp.Vc**(2./3)/sumaxvc23 for xi, cmp in
zip(self.kwargs["fraccionMolar"], Cmps)]
# TODO: Calculate C value from component type.
# For now it suppose all are hidrycarbon (C=0)
C = 0
V = [[-1.4684*abs((cmpi.Vc-cmpj.Vc)/(cmpi.Vc+cmpj.Vc))+C
for cmpj in Cmps] for cmpi in Cmps]
v = [[V[i][j]*(cmpi.Vc+cmpj.Vc)/2. for j, cmpj in enumerate(
Cmps)] for i, cmpi in enumerate(Cmps)]
suma1 = sum([ki*cmp.Vc for ki, cmp in zip(k, Cmps)])
suma2 = sum([ki*kj*v[i][j] for j, kj in enumerate(k)
for i, ki in enumerate(k)])
self.rhoc = unidades.Density((suma1+suma2)*self.M)
else:
self.Tc = unidades.Temperature(estado.T_critical())
self.Pc = unidades.Pressure(estado.p_critical())
self.rhoc = unidades.Density(estado.rhomass_critical())
self.R = unidades.SpecificHeat(estado.gas_constant()/self.M)
self.Tt = unidades.Temperature(estado.Ttriple())
estado2 = CP.AbstractState("HEOS", fluido)
if self._multicomponent:
estado2.set_mole_fractions(self.kwargs["fraccionMolar"])
estado2.update(CP.PQ_INPUTS, 101325, 1)
self.Tb = unidades.Temperature(estado2.T())
self.f_accent = unidades.Dimensionless(estado.acentric_factor())
# Dipole moment only available for REFPROP backend
# self.momentoDipolar(estado.keyed_output(CP.idipole_moment))
self.phase, x = self.getphase(estado)
self.x = unidades.Dimensionless(x)
if self._multicomponent:
string = fluido.replace("&", " (%0.2f), ")
string += " (%0.2f)"
self.name = string % tuple(self.kwargs["fraccionMolar"])
self.CAS = ""
self.synonim = ""
self.formula = ""
else:
self.name = fluido
self.CAS = estado.fluid_param_string("CAS")
self.synonim = estado.fluid_param_string("aliases")
self.formula = estado.fluid_param_string("formula")
self.P = unidades.Pressure(estado.p())
self.T = unidades.Temperature(estado.T())
self.Tr = unidades.Dimensionless(self.T/self.Tc)
self.Pr = unidades.Dimensionless(self.P/self.Pc)
self.rho = unidades.Density(estado.rhomass())
self.v = unidades.SpecificVolume(1./self.rho)
cp0 = self._prop0(estado)
self._cp0(cp0)
self.Liquido = ThermoAdvanced()
self.Gas = ThermoAdvanced()
if self.x == 0:
# liquid phase
self.fill(self.Liquido, estado)
self.fill(self, estado)
self.fillNone(self.Gas)
elif self.x == 1:
# vapor phase
self.fill(self.Gas, estado)
self.fill(self, estado)
self.fillNone(self.Liquido)
else:
# Two phase
liquido = CP.AbstractState("HEOS", fluido)
if self._multicomponent:
xi = estado.mole_fractions_liquid()
liquido.set_mole_fractions(xi)
liquido.specify_phase(CP.iphase_liquid)
liquido.update(CP.QT_INPUTS, 0, self.T)
self.fill(self.Liquido, liquido)
vapor = CP.AbstractState("HEOS", fluido)
if self._multicomponent:
yi = estado.mole_fractions_vapor()
vapor.set_mole_fractions(yi)
vapor.specify_phase(CP.iphase_gas)
vapor.update(CP.QT_INPUTS, 1, self.T)
self.fill(self.Gas, vapor)
self.fill(self, estado)
# Calculate special properties useful only for one phase
if self._multicomponent:
self.sigma = unidades.Tension(None)
elif x < 1 and self.Tt <= self.T <= self.Tc:
self.sigma = unidades.Tension(estado.surface_tension())
else:
self.sigma = unidades.Tension(None)
self.virialB = unidades.SpecificVolume(estado.Bvirial())
self.virialC = unidades.SpecificVolume_square(estado.Cvirial())
self.invT = unidades.InvTemperature(-1/self.T)
if 0 < self.x < 1:
self.Hvap = unidades.Enthalpy(self.Gas.h-self.Liquido.h)
self.Svap = unidades.SpecificHeat(self.Gas.s-self.Liquido.s)
else:
self.Hvap = unidades.Enthalpy(None)
self.Svap = unidades.SpecificHeat(None)
def _Dielectric(self, rho, T):
return unidades.Dimensionless(_Dielectric(rho, T))
def calculo(self):
self.entrada = self.kwargs["entrada"]
self.LKsplit = unidades.Dimensionless(self.kwargs["LKsplit"])
self.HKsplit = unidades.Dimensionless(self.kwargs["HKsplit"])
self.RCalculada = unidades.Dimensionless(self.kwargs["R"])
self.R_Rmin = unidades.Dimensionless(self.kwargs["R_Rmin"])
if self.kwargs["Pd"]:
self.Pd = unidades.Pressure(self.kwargs["Pd"])
else:
self.Pd = self.entrada.P
self.DeltaP = unidades.Pressure(self.kwargs["DeltaP"])
#Estimate splits of components
b = []
d = []
for i, caudal_i in enumerate(self.entrada.caudalunitariomolar):
if i == self.kwargs["LK"]:
b.append(caudal_i * (1 - self.LKsplit))
d.append(caudal_i * self.LKsplit)
elif i == self.kwargs["HK"]:
d.append(caudal_i * (1 - self.HKsplit))
b.append(caudal_i * self.HKsplit)
elif self.entrada.eos.Ki[i] > self.entrada.eos.Ki[
self.kwargs["LK"]]:
b.append(0)
d.append(caudal_i)
elif self.entrada.eos.Ki[i] < self.entrada.eos.Ki[
self.kwargs["HK"]]:
d.append(0)
b.append(caudal_i)
else:
d.append(caudal_i * 0.5)
b.append(caudal_i * 0.5)
while True:
bo = b
do = d
xt = [Q / sum(d) for Q in d]
xb = [Q / sum(b) for Q in b]
Qt = sum(
[di * comp.M for di, comp in zip(d, self.entrada.componente)])
Qb = sum(
[bi * comp.M for bi, comp in zip(b, self.entrada.componente)])
destilado = Corriente(T=self.entrada.T,
P=self.Pd,
caudalMasico=Qt,
fraccionMolar=xt)
residuo = Corriente(T=self.entrada.T,
P=self.Pd,
caudalMasico=Qb,
fraccionMolar=xb)
#TODO: Add algorithm to calculate Pd and condenser type fig 12.4 pag 230
#Fenske equation for Nmin
alfam = (destilado.eos.Ki[self.kwargs["LK"]] /
destilado.eos.Ki[self.kwargs["HK"]] *
residuo.eos.Ki[self.kwargs["LK"]] /
residuo.eos.Ki[self.kwargs["HK"]])**0.5
Nmin = log10(
destilado.caudalunitariomolar[self.kwargs["LK"]] /
destilado.caudalunitariomolar[self.kwargs["HK"]] *
residuo.caudalunitariomolar[self.kwargs["HK"]] /
residuo.caudalunitariomolar[self.kwargs["LK"]]) / log10(alfam)
#Evaluación composición salidas
b = []
d = []
for i in range(len(self.entrada.ids)):
if i in [self.kwargs["LK"], self.kwargs["HK"]]:
b.append(bo[i])
d.append(do[i])
else:
alfa = (destilado.eos.Ki[i] /
destilado.eos.Ki[self.kwargs["HK"]] *
residuo.eos.Ki[i] /
residuo.eos.Ki[self.kwargs["HK"]])**0.5
b.append(self.entrada.caudalunitariomolar[i] /
(1 + do[self.kwargs["HK"]] /
bo[self.kwargs["HK"]] * alfa**Nmin))
d.append(self.entrada.caudalunitariomolar[i] *
do[self.kwargs["HK"]] / bo[self.kwargs["HK"]] *
alfa**Nmin / (1 + do[self.kwargs["HK"]] /
bo[self.kwargs["HK"]] * alfa**Nmin))
res = sum([
abs(inicial - final) for inicial, final in zip(bo, b)
]) + sum([abs(inicial - final) for inicial, final in zip(do, d)])
if res < 1e-10:
self.Nmin = Nmin - self.kwargs["condenser"] + 1
break
#Calculo de la razón de reflujo mínima, ecuación de Underwood
alfa = self.entrada.eos.Ki[self.kwargs["LK"]] / self.entrada.eos.Ki[
self.kwargs["HK"]]
self.Rmin = unidades.Dimensionless(
abs(
float(destilado.caudalmolar / self.entrada.caudalmolar *
(destilado.fraccion[self.kwargs["LK"]] /
self.entrada.Liquido.fraccion[self.kwargs["LK"]] -
alfa * destilado.fraccion[self.kwargs["HK"]] /
self.entrada.Liquido.fraccion[self.kwargs["HK"]]) /
(alfa - 1))))
#Cálculo del número de etapas reales, ecuación de Gilliland
if self.R_Rmin and not self.RCalculada:
self.RCalculada = unidades.Dimensionless(self.R_Rmin * self.Rmin)
X = (self.RCalculada - self.Rmin) / (self.RCalculada + 1)
Y = 1 - exp((1 + 54.4 * X) / (11 + 117.2 * X) * (X - 1) / X**0.5)
self.NTray = unidades.Dimensionless((Y + self.Nmin) / (1 - Y) - 1 -
self.kwargs["condenser"])
#Cálculo del piso de la alimentación
if self.kwargs["feed"]: #Ec. de Fenske
alfa_b = residuo.eos.Ki[self.kwargs["LK"]] / residuo.eos.Ki[
self.kwargs["HK"]]
alfa_d = destilado.eos.Ki[self.kwargs["LK"]] / destilado.eos.Ki[
self.kwargs["HK"]]
alfa_f = self.entrada.eos.Ki[
self.kwargs["LK"]] / self.entrada.eos.Ki[self.kwargs["HK"]]
ratio = log(destilado.fraccion[self.kwargs["LK"]] /
self.entrada.fraccion[self.kwargs["LK"]] *
self.entrada.fraccion[self.kwargs["HK"]] /
destilado.fraccion[self.kwargs["HK"]]) / log(
self.entrada.fraccion[self.kwargs["LK"]] /
residuo.fraccion[self.kwargs["LK"]] *
residuo.fraccion[self.kwargs["HK"]] /
self.entrada.fraccion[self.kwargs["HK"]]) * log(
(alfa_b * alfa_f)**0.5) / log(
(alfa_d * alfa_f)**0.5)
else: #Ec. de Kirkbride
ratio = (self.entrada.fraccion[self.kwargs["HK"]] /
self.entrada.fraccion[self.kwargs["LK"]] *
residuo.fraccion[self.kwargs["LK"]]**2 /
destilado.fraccion[self.kwargs["HK"]]**2 *
residuo.caudalmolar / destilado.caudalmolar)**0.206
self.Ns = self.NTray / (ratio + 1)
self.Nr = self.NTray - self.Ns
self.N_feed = unidades.Dimensionless(self.Ns + 1)
if self.kwargs["condenser"]: #Parcial
Tout = destilado.eos._Dew_T()
else:
Tout = destilado.eos._Bubble_T()
Tin = destilado.eos._Dew_T()
SalidaDestilado = destilado.clone(T=Tout)
#FIXME: o el ejemplo está mal planteado o este valor es ilógico
ToutReboiler = residuo.eos._Bubble_T()
ToutReboiler2 = residuo.eos._Dew_T()
print((ToutReboiler, ToutReboiler2, Tin, Tout))
SalidaResiduo = residuo.clone(T=ToutReboiler)
self.salida = [SalidaDestilado, SalidaResiduo]
inCondenser = destilado.clone(T=Tin,
P=self.entrada.P,
split=self.RCalculada + 1)
outCondenser = destilado.clone(T=Tout,
P=self.entrada.P,
split=self.RCalculada + 1)
self.DutyCondenser = unidades.Power(outCondenser.h - inCondenser.h)
self.DutyReboiler = unidades.Power(SalidaDestilado.h +
SalidaResiduo.h -
self.DutyCondenser - self.entrada.h)
self.DestiladoT = SalidaDestilado.T
self.DestiladoP = SalidaDestilado.P
self.DestiladoMassFlow = SalidaDestilado.caudalmasico
self.DestiladoMolarComposition = SalidaDestilado.fraccion
self.ResiduoT = SalidaResiduo.T
self.ResiduoP = SalidaResiduo.P
self.ResiduoMassFlow = SalidaResiduo.caudalmasico
self.ResiduoMolarComposition = SalidaResiduo.fraccion
self.LKName = self.salida[0].componente[self.kwargs["LK"]].nombre
self.HKName = self.salida[0].componente[self.kwargs["HK"]].nombre
def fill(self, fase, T, rho, x):
if sum(x) != 1:
x = [round(xi, 10) for xi in x]
mol = refprop.wmol(x)
thermo = refprop.therm2(T, rho, x)
thermo3 = refprop.therm3(T, rho, x)
fase._bool = True
fase.M = unidades.Dimensionless(mol["wmix"])
fase.rho = unidades.Density(rho*fase.M)
fase.v = unidades.SpecificVolume(1./fase.rho)
fase.Z = unidades.Dimensionless(thermo["Z"])
fase.u = unidades.Enthalpy(thermo["e"]/fase.M, "Jg")
fase.h = unidades.Enthalpy(thermo["h"]/fase.M, "Jg")
fase.s = unidades.SpecificHeat(thermo["s"]/fase.M, "JgK")
fase.a = unidades.Enthalpy(thermo["A"]/fase.M, "Jg")
fase.g = unidades.Enthalpy(thermo["G"]/fase.M, "Jg")
fase.cv = unidades.SpecificHeat(thermo["cv"]/fase.M, "JgK")
fase.cp = unidades.SpecificHeat(thermo["cp"]/fase.M, "JgK")
fase.cp_cv = unidades.Dimensionless(fase.cp/fase.cv)
fase.gamma = fase.cp_cv
fase.w = unidades.Speed(thermo["w"])
fase.rhoM = unidades.MolarDensity(fase.rho/self.M)
fase.hM = unidades.MolarEnthalpy(fase.h*self.M)
fase.sM = unidades.MolarSpecificHeat(fase.s*self.M)
fase.uM = unidades.MolarEnthalpy(fase.u*self.M)
fase.aM = unidades.MolarEnthalpy(fase.a*self.M)
fase.gM = unidades.MolarEnthalpy(fase.g*self.M)
fase.cvM = unidades.MolarSpecificHeat(fase.cv*self.M)
fase.cpM = unidades.MolarSpecificHeat(fase.cp*self.M)
residual = refprop.residual(T, rho, x)
fase.pr = unidades.Pressure(residual["pr"], "kPa")
fase.ur = unidades.Enthalpy(residual["er"]/fase.M, "Jg")
fase.hr = unidades.Enthalpy(residual["hr"]/fase.M, "Jg")
fase.sr = unidades.SpecificHeat(residual["sr"]/fase.M, "JgK")
fase.ar = unidades.Enthalpy(residual["Ar"]/fase.M, "Jg")
fase.gr = unidades.Enthalpy(residual["Gr"]/fase.M, "Jg")
fase.cvr = unidades.SpecificHeat(residual["cvr"]/fase.M, "JgK")
fase.cpr = unidades.SpecificHeat(residual["cpr"]/fase.M, "JgK")
fase.alfav = unidades.InvTemperature(thermo["beta"])
fase.kappa = unidades.InvPressure(thermo["xkappa"], "kPa")
fase.kappas = unidades.InvPressure(thermo3["betas"], "kPa")
fase.alfap = unidades.Density(fase.alfav/self.P/fase.kappa)
fase.deltat = unidades.EnthalpyPressure(
thermo3["thrott"]/fase.M, "kJkgkPa")
fase.joule = unidades.TemperaturePressure(thermo["hjt"], "KkPa")
fase.betas = unidades.TemperaturePressure(
self.derivative("T", "P", "s", fase))
fase.betap = unidades.Density(
-1/self.P*self.derivative("P", "v", "T", fase))
fase.Kt = unidades.Pressure(thermo3["xkkt"], "kPa")
fase.Ks = unidades.Pressure(thermo3["bs"], "kPa")
fase.kt = unidades.Dimensionless(thermo3["xkt"])
fase.ks = unidades.Dimensionless(thermo3["xisenk"])
dh = refprop.dhd1(T, rho, x)
fase.dhdT_rho = unidades.SpecificHeat(dh["dhdt_D"]/fase.M, "kJkgK")
fase.dhdT_P = unidades.SpecificHeat(dh["dhdt_p"]/fase.M, "kJkgK")
fase.dhdP_T = unidades.EnthalpyPressure(dh["dhdp_t"]/fase.M, "kJkgkPa")
# dhdtp_D : fix in library
fase.dhdP_rho = unidades.EnthalpyPressure(
dh["dhdtp_D"]/fase.M, "kJkgkPa")
fase.dhdrho_T = unidades.EnthalpyDensity(
dh["dhdD_t"]/fase.M**2, "kJkgkgm3")
fase.dhdrho_P = unidades.EnthalpyDensity(
dh["dhdD_p"]/fase.M**2, "kJkgkgm3")
fase.dpdT_rho = unidades.PressureTemperature(thermo["dpdt"], "kPaK")
fase.dpdrho_T = unidades.PressureDensity(
thermo["dpdD"]/fase.M, "kPakgm3")
# TODO: Add unit for derivative d^2p/dD^2 [kPa-L^2/mol^2]
# MPa·m⁶/kg²
fase.d2pdrho2 = unidades.Dimensionless(thermo["d2pdD2"]/fase.M**2/1000)
fase.drhodP_T = unidades.DensityPressure(
thermo["dDdp"]*fase.M, "kgm3kPa")
fase.drhodT_P = unidades.DensityTemperature(thermo["dDdt"]*fase.M)
fase.Gruneisen = unidades.Dimensionless(fase.v/fase.cv*fase.dpdT_rho)
fase.Z_rho = unidades.SpecificVolume((fase.Z-1)/fase.rho)
fase.IntP = unidades.Pressure(thermo3["pint"], "kPa")
fase.hInput = unidades.Enthalpy(thermo3["spht"]/fase.M, "kJkg")
fase.invT = unidades.InvTemperature(-1/self.T)
fpv = refprop.fpv(T, rho, self.P.kPa, x)["Fpv"]
fase.fpv = unidades.Dimensionless(fpv)
chempot = refprop.chempot(T, rho, x)["u"]
fase.chempot = [unidades.Enthalpy(c/fase.M) for c in chempot]
fi = refprop.fugcof(T, rho, x)["f"]
fase.fi = [unidades.Dimensionless(f) for f in fi]
f = refprop.fgcty(T, rho, x)["f"]
fase.f = [unidades.Pressure(f_i, "kPa") for f_i in f]
b = refprop.virb(T, x)["b"]
fase.virialB = unidades.SpecificVolume(b/self.M)
c = refprop.virc(T, x)["c"]
fase.virialC = unidades.SpecificVolume_square(c/self.M**2)
# viriald don't supported for windows
d = refprop.vird(T, x)["d"]
fase.virialD = unidades.Dimensionless(d/self.M**3)
ba = refprop.virba(T, x)["ba"]
fase.virialBa = unidades.SpecificVolume(ba/self.M)
ca = refprop.virca(T, x)["ca"]
fase.virialCa = unidades.SpecificVolume_square(ca/self.M**2)
dcdt = refprop.dcdt(T, x)["dct"]
fase.dCdt = unidades.Dimensionless(dcdt/self.M**2)
dcdt2 = refprop.dcdt2(T, x)["dct2"]
fase.dCdt2 = unidades.Dimensionless(dcdt2/self.M**2)
dbdt = refprop.dbdt(T, x)["dbt"]
fase.dBdt = unidades.Dimensionless(dbdt/self.M)
b12 = refprop.b12(T, x)["b"]
fase.b12 = unidades.SpecificVolume(b12*fase.M)
try:
cstar = refprop.cstar(T, self.P.kPa, 0, x)["cs"]
fase.cstar = unidades.Dimensionless(cstar)
except refprop.RefpropdllError:
fase.cstar = unidades.Dimensionless(None)
fase.fraccion = [unidades.Dimensionless(xi) for xi in x]
xg = refprop.xmass(x)["xkg"]
fase.fraccion_masica = [unidades.Dimensionless(xi) for xi in xg]
transport = refprop.trnprp(T, rho, x)
fase.mu = unidades.Viscosity(transport["eta"], "muPas")
fase.nu = unidades.Diffusivity(fase.mu/fase.rho)
fase.k = unidades.ThermalConductivity(transport["tcx"])
fase.alfa = unidades.Diffusivity(fase.k/fase.rho/fase.cp)
fase.Prandt = unidades.Dimensionless(fase.mu*fase.cp/fase.k)
dielec = refprop.dielec(T, rho, x)
fase.epsilon = unidades.Dimensionless(dielec["de"])
def calculo(self):
# TODO: Add configuration section to Preferences
# preos = Preferences.getboolean("refProp", "preos")
# aga = Preferences.getboolean("refProp", "aga")
# gerg = Preferences.getboolean("refProp", "gerg")
preos = self.kwargs["preos"]
aga = self.kwargs["aga"]
gerg = self.kwargs["gerg"]
x = self._x()
fluido = self._name()
kwmod = [self.kwargs[k] for k in ('htype', 'hmix', 'hcomp')]
refprop.setmod(*kwmod)
if gerg:
refprop.gerg04(ixflag=1)
refprop.setup("def", fluido)
# refprop.setktv()
if preos:
refprop.preos(ixflag=2)
elif aga:
refprop.setaga()
kwref = {k: self.kwargs[k] for k in (
'hrf', 'ixflag', 'x0', 'h0', 's0', 't0', 'p0')}
refprop.setref(**kwref)
m = refprop.wmol(x)["wmix"]
self.M = unidades.Dimensionless(m)
crit = refprop.critp(x)
self.Pc = unidades.Pressure(crit["pcrit"], "kPa")
self.Tc = unidades.Temperature(crit["tcrit"])
self.rhoc = unidades.Density(crit["Dcrit"]*self.M)
args = self.args()
flash = refprop.flsh(*args)
# check if ['q'] in fld
if 'q' in flash.keys():
x = flash['q']
elif 'h' in flash.keys():
x = refprop.flsh('ph', flash['p'], flash['h'], flash['x'])['q']
elif 's' in flash.keys():
x = refprop.flsh('ps', flash['p'], flash['s'], flash['x'])['q']
if 0 < x < 1:
region = 4
else:
region = 1
if x < 0:
x = 0
elif x > 1:
x = 1
self.x = unidades.Dimensionless(x)
self.T = unidades.Temperature(flash["t"])
self.P = unidades.Pressure(flash["p"], "kPa")
self.Tr = unidades.Dimensionless(self.T/self.Tc)
self.Pr = unidades.Dimensionless(self.P/self.Pc)
self.rho = unidades.Density(flash["D"]*self.M)
self.v = unidades.SpecificVolume(1./self.rho)
self.phase = self.getphase(Tc=self.Tc, Pc=self.Pc, T=self.T, P=self.Pc,
x=self.x, region=region)
if flash["nc"] == 1:
name = refprop.name(flash["nc"])
self.name = name["hname"]
self.synonim = name["hn80"]
self.CAS = name["hcas"]
info = refprop.info(flash["nc"])
self.R = unidades.SpecificHeat(info["Rgas"]/self.M)
self.Tt = unidades.Temperature(info["ttrp"])
self.Tb = unidades.Temperature(info["tnbpt"])
self.f_accent = unidades.Dimensionless(info["acf"])
self.momentoDipolar = unidades.DipoleMoment(info["dip"], "Debye")
self._doc = {}
for htype in ['EOS', 'CP0', 'ETA', 'VSK', 'TCX', 'TKK', 'STN',
'DE ', 'MLT', 'SBL', 'PS ', 'DL ', 'DV ']:
self._doc[htype] = refprop.getmod(flash["nc"], htype)["hcite"]
else:
self.name = ""
self.synonim = ""
self.CAS = ""
rmix = refprop.rmix2(flash["x"])
self.R = unidades.SpecificHeat(rmix["Rgas"]/self.M)
self.Tt = unidades.Temperature(None)
self.Tb = unidades.Temperature(None)
self.f_accent = unidades.Dimensionless(None)
self.momentoDipolar = unidades.DipoleMoment(None)
self._doc = {}
self._cp0(flash)
self.Liquido = ThermoRefProp()
self.Gas = ThermoRefProp()
if self.x == 0:
# liquid phase
self.fill(self.Liquido, flash["t"], flash["Dliq"], flash["xliq"])
self.fill(self, flash["t"], flash["Dliq"], flash["xliq"])
self.fillNone(self.Gas)
elif self.x == 1:
# vapor phase
self.fill(self.Gas, flash["t"], flash["Dvap"], flash["xvap"])
self.fill(self, flash["t"], flash["Dvap"], flash["xvap"])
self.fillNone(self.Liquido)
else:
# Two phase
self.fill(self.Liquido, flash["t"], flash["Dliq"], flash["xliq"])
self.fill(self.Gas, flash["t"], flash["Dvap"], flash["xvap"])
self.u = unidades.Enthalpy(flash["e"]/self.M, "Jg")
self.h = unidades.Enthalpy(flash["h"]/self.M, "Jg")
self.s = unidades.SpecificHeat(flash["s"]/self.M, "JgK")
self.a = unidades.Enthalpy(self.u-self.T*self.s)
self.g = unidades.Enthalpy(self.h-self.T*self.s)
if self.x < 1 and self.T <= self.Tc:
surten = refprop.surten(flash["t"], flash["Dliq"], flash["Dvap"],
flash["xliq"], flash["xvap"])
self.sigma = unidades.Tension(surten["sigma"])
else:
self.sigma = unidades.Tension(None)
if 0 < self.x < 1:
self.Hvap = unidades.Enthalpy(self.Gas.h-self.Liquido.h)
self.Svap = unidades.SpecificHeat(self.Gas.s-self.Liquido.s)
self.K = []
for x, y in zip(self.Liquido.fraccion, self.Gas.fraccion):
self.K.append(unidades.Dimensionless(y/x))
else:
self.Hvap = unidades.Enthalpy(None)
self.Svap = unidades.SpecificHeat(None)
self.K = [unidades.Dimensionless(1)]*flash["nc"]
# NOT supported on Windows
excess = refprop.excess(flash["t"], flash["D"], flash["x"])
self.vE = unidades.Volume(excess["vE"]/self.M)
self.uE = unidades.Enthalpy(excess["eE"]/self.M, "Jg")
self.hE = unidades.Enthalpy(excess["hE"]/self.M, "Jg")
self.sE = unidades.SpecificHeat(excess["sE"]/self.M, "JgK")
self.aE = unidades.Enthalpy(excess["aE"]/self.M, "Jg")
self.gE = unidades.Enthalpy(excess["gE"]/self.M, "Jg")
self.csat = []
self.dpdt_sat = []
self.cv2p = []
for i in range(1, flash["nc"]+1):
dat = refprop.dptsatk(i, flash["t"], kph=2)
self.csat.append(unidades.SpecificHeat(dat["csat"]/self.M, "JgK"))
self.dpdt_sat.append(
unidades.PressureTemperature(dat["dpdt"], "kPaK"))
cv2 = refprop.cv2pk(i, flash["t"], flash["D"])
self.cv2p.append(unidades.SpecificHeat(cv2["cv2p"]/self.M, "JgK"))
class IAPWS97(ThermoWater):
"""Class to model a state for liquid water or steam with the IAPWS-IF97
Incoming properties:
T - Temperature, K
P - Pressure, Pa
h - Specific enthalpy, kJ/kg
s - Specific entropy, kJ/kg·K
x - Quality
Optional:
l - Wavelength of light, for refractive index
Definitions options:
T, P Not valid for two-phases region
P, h
P, s
h, s
T, x Only for two-phases region
P, x Only for two-phases region
Properties:
P - Pressure, MPa
T - Temperature, K
g - Specific Gibbs free energy, kJ/kg
a - Specific Helmholtz free energy, kJ/kg
v - Specific volume, m³/kg
r - Density, kg/m³
h - Specific enthalpy, kJ/kg
u - Specific internal energy, kJ/kg
s - Specific entropy, kJ/kg·K
c - Specific isobaric heat capacity, kJ/kg·K
c - Specific isochoric heat capacity, kJ/kg·K
Z - Compression factor
f - Fugacity, MPa
gamma - Isoentropic exponent
alfav - Isobaric cubic expansion coefficient, 1/K
kappa - Isothermal compressibility, 1/MPa
alfap - Relative pressure coefficient, 1/K
betap - Isothermal stress coefficient, kg/m³
joule - Joule-Thomson coefficient, K/MPa
deltat - Isothermal throttling coefficient, kJ/kg·MPa
region - Region
v0 - Ideal specific volume, m³/kg
u0 - Ideal specific internal energy, kJ/kg
h0 - Ideal specific enthalpy, kJ/kg
s0 - Ideal specific entropy, kJ/kg·K
a0 - Ideal specific Helmholtz free energy, kJ/kg
g0 - Ideal specific Gibbs free energy, kJ/kg
cp0 - Ideal specific isobaric heat capacity, kJ/kg·K
cv0 - Ideal specific isochoric heat capacity, kJ/kg·K
w0 - Ideal speed of sound, m/s
gamma0 - Ideal isoentropic exponent
w - Speed of sound, m/s
mu - Dynamic viscosity, Pa·s
nu - Kinematic viscosity, m²/s
k - Thermal conductivity, W/m·K
alfa - Thermal diffusivity, m²/s
sigma - Surface tension, N/m
epsilon - Dielectric constant
n - Refractive index
Prandt - Prandtl number
Pr - Reduced Pressure
Tr - Reduced Temperature
Usage:
>>> water=IAPWS97(T=170+273.15,x=0.5)
>>> "%0.4f %0.4f %0.1f %0.2f" % (water.Liquido.cp.kJkgK, \
water.Gas.cp.kJkgK, water.Liquido.w, water.Gas.w)
'4.3695 2.5985 1418.3 498.78'
>>> water=IAPWS97(T=325+273.15,x=0.5)
>>> "%0.4f %0.8f %0.7f %0.2f %0.2f" % (water.P.MPa, water.Liquido.v, \
water.Gas.v, water.Liquido.h.kJkg, water.Gas.h.kJkg)
'12.0505 0.00152830 0.0141887 1493.37 2684.48'
>>> water=IAPWS97(T=50+273.15,P=611.2127)
>>> "%0.4f %0.4f %0.2f %0.3f %0.2f" % (water.cp0.kJkgK, water.cv0.kJkgK, \
water.h0.kJkg, water.s0.kJkgK, water.w0)
'1.8714 1.4098 2594.66 9.471 444.93'
"""
__doi__ = [{
"autor":
"IAPWS",
"title":
"Revised Release on the IAPWS Industrial Formulation 1997"
"for the Thermodynamic Properties of Water and Steam",
"ref":
"",
"doi":
""
}, {
"autor":
"Wagner, W., Cooper, J. R., Dittmann, A., Kijima, J., "
"Kretzschmar, H.-J., Kruse, A., Mareš, R., Oguchi, K., Sato,"
" H., Stöcker, I., Šifner, O., Takaishi, Y., Tanishita, I., "
"Trübenbach, J., and Willkommen, Th.",
"title":
"The IAPWS Industrial Formulation 1997 for the Thermodynamic"
" Properties of Water and Steam",
"ref":
"J. Eng. Gas Turbines & Power 122, 150-182 (2000)",
"doi":
"10.1115/1.483186"
}]
M = unidades.Dimensionless(M)
Pc = unidades.Pressure(Pc, "MPa")
Tc = unidades.Temperature(Tc)
rhoc = unidades.Density(rhoc)
Tt = unidades.Temperature(Tt)
Tb = unidades.Temperature(Tb)
f_accent = unidades.Dimensionless(f_acent)
momentoDipolar = unidades.DipoleMoment(Dipole, "Debye")
def __init__(self, **kwargs):
if "P" in kwargs:
kwargs["P"] /= 1e6
elif "h" in kwargs:
kwargs["h"] /= 1e3
elif "s" in kwargs:
kwargs["s"] /= 1e3
st = IAPWS(**kwargs)
self.status = st.status
self.msg = st.msg
if self.status:
self.calculo(st)
def calculo(self, st):
self.x = unidades.Dimensionless(st.x)
self.region = st.region
self.phase = self.getphase(phase=st.phase)
self.name = st.name
self.synonim = st.synonim
self.CAS = st.CAS
self.T = unidades.Temperature(st.T)
self.P = unidades.Pressure(st.P, "MPa")
self.Tr = unidades.Dimensionless(st.Tr)
self.Pr = unidades.Dimensionless(st.Pr)
self.v = unidades.SpecificVolume(st.v)
self.rho = unidades.Density(st.rho)
cp0 = {}
cp0["v"] = st.v0
cp0["h"] = st.h0 * 1000
cp0["s"] = st.s0 * 1000
cp0["cp"] = st.cp0 * 1000
cp0["cv"] = st.cv0 * 1000
cp0["w"] = st.w0
self._cp0(cp0)
self.Liquido = ThermoWater()
self.Gas = ThermoWater()
if self.x == 0:
# only liquid phase
self.fill(self, st.Liquid)
self.fill(self.Liquido, st.Liquid)
self.sigma = unidades.Tension(st.sigma)
self.Hvap = unidades.Enthalpy(None)
self.Svap = unidades.SpecificHeat(None)
elif self.x == 1:
# only vapor phase
self.fill(self, st.Vapor)
self.fill(self.Gas, st.Vapor)
self.Hvap = unidades.Enthalpy(None)
self.Svap = unidades.SpecificHeat(None)
else:
# two phases
self.fill(self.Liquido, st.Liquid)
self.sigma = unidades.Tension(st.sigma)
self.fill(self.Gas, st.Vapor)
self.h = unidades.Enthalpy(st.h)
self.s = unidades.SpecificHeat(st.s)
self.u = unidades.SpecificHeat(st.u)
self.a = unidades.Enthalpy(st.a)
self.g = unidades.Enthalpy(st.g)
self.cv = unidades.SpecificHeat(None)
self.cp = unidades.SpecificHeat(None)
self.cp_cv = unidades.Dimensionless(None)
self.w = unidades.Speed(None)
self.Hvap = unidades.Enthalpy(st.Hvap, "kJkg")
self.Svap = unidades.SpecificHeat(st.Svap, "kJkgK")
def fill(self, fase, st):
"""Fill phase properties"""
fase._bool = True
fase.M = self.M
fase.v = unidades.SpecificVolume(st.v)
fase.rho = unidades.Density(st.rho)
fase.Z = unidades.Dimensionless(st.Z)
fase.h = unidades.Enthalpy(st.h, "kJkg")
fase.s = unidades.SpecificHeat(st.s, "kJkgK")
fase.u = unidades.Enthalpy(st.u, "kJkg")
fase.a = unidades.Enthalpy(st.a, "kJkg")
fase.g = unidades.Enthalpy(st.g, "kJkg")
fase.fi = [unidades.Dimensionless(st.fi)]
fase.f = [unidades.Pressure(st.f, "MPa")]
fase.cv = unidades.SpecificHeat(st.cv, "kJkgK")
fase.cp = unidades.SpecificHeat(st.cp, "kJkgK")
fase.cp_cv = unidades.Dimensionless(st.cp_cv)
fase.gamma = fase.cp_cv
fase.w = unidades.Speed(st.w)
fase.rhoM = unidades.MolarDensity(fase.rho / self.M)
fase.hM = unidades.MolarEnthalpy(fase.h * self.M)
fase.sM = unidades.MolarSpecificHeat(fase.s * self.M)
fase.uM = unidades.MolarEnthalpy(fase.u * self.M)
fase.aM = unidades.MolarEnthalpy(fase.a * self.M)
fase.gM = unidades.MolarEnthalpy(fase.g * self.M)
fase.cvM = unidades.MolarSpecificHeat(fase.cv * self.M)
fase.cpM = unidades.MolarSpecificHeat(fase.cp * self.M)
fase.alfav = unidades.InvTemperature(st.alfav)
fase.kappa = unidades.InvPressure(st.xkappa, "MPa")
fase.kappas = unidades.InvPressure(st.kappas, "MPa")
fase.mu = unidades.Viscosity(st.mu)
fase.nu = unidades.Diffusivity(st.nu)
fase.k = unidades.ThermalConductivity(st.k)
fase.alfa = unidades.Diffusivity(st.alfa)
fase.epsilon = unidades.Dimensionless(st.epsilon)
fase.Prandt = unidades.Dimensionless(st.Prandt)
fase.n = unidades.Dimensionless(st.n)
fase.joule = unidades.TemperaturePressure(st.joule)
fase.deltat = unidades.EnthalpyPressure(st.deltat)
fase.betap = unidades.Density(st.betap)
fase.alfap = unidades.Density(st.alfap)
fase.fraccion = [1]
fase.fraccion_masica = [1]