def test_water_backends(self): w = ct.Water(backend='Reynolds') self.assertEqual(w.thermo_model, 'PureFluid') w = ct.Water(backend='IAPWS95') self.assertEqual(w.thermo_model, 'liquid-water-IAPWS95') with self.assertRaisesRegex(KeyError, 'Unknown backend'): ct.Water('foobar')
def test_water_iapws(self): w = ct.Water(backend='IAPWS95') self.assertNear(w.critical_density, 322.) self.assertNear(w.critical_temperature, 647.096) self.assertNear(w.critical_pressure, 22064000.0) # test internal TP setters (setters update temperature at constant # density before updating pressure) w.TP = 300, ct.one_atm dens = w.density w.TP = 2000, ct.one_atm # supercritical self.assertEqual(w.phase_of_matter, "supercritical") w.TP = 300, ct.one_atm # state goes from supercritical -> gas -> liquid self.assertNear(w.density, dens) self.assertEqual(w.phase_of_matter, "liquid") # test setters for critical conditions w.TP = w.critical_temperature, w.critical_pressure self.assertNear(w.density, 322.) w.TP = 2000, ct.one_atm # uses current density as initial guess w.TP = 273.16, ct.one_atm # uses fixed density as initial guess self.assertNear(w.density, 999.84376) self.assertEqual(w.phase_of_matter, "liquid") w.TP = w.T, w.P_sat self.assertEqual(w.phase_of_matter, "liquid") with self.assertRaisesRegex(ct.CanteraError, "assumes liquid phase"): w.TP = 273.1599999, ct.one_atm with self.assertRaisesRegex(ct.CanteraError, "assumes liquid phase"): w.TP = 500, ct.one_atm
def test_import_no_norm_water(self): outfile = self.test_work_path / "solutionarray.h5" # In Python >= 3.8, this can be replaced by the missing_ok argument if outfile.is_file(): outfile.unlink() w = ct.Water() w.TQ = 300, 0.5 states = ct.SolutionArray(w, 5) states.write_hdf(outfile) w_new = ct.Water() c = ct.SolutionArray(w_new) c.read_hdf(outfile, normalize=False) self.assertArrayNear(states.T, c.T) self.assertArrayNear(states.P, c.P) self.assertArrayNear(states.Q, c.Q)
def test_append_no_norm_water(self): w = ct.Water() states = ct.SolutionArray(w) w.TQ = 300, 0.5 states.append(w.state) self.assertEqual(states[0].T, w.T) self.assertEqual(states[0].P, w.P) self.assertEqual(states[0].Q, w.Q)
def test_purefluid(self): water = ct.Water() states = ct.SolutionArray(water, 5) states.TX = 400, np.linspace(0, 1, 5) P = states.P for i in range(1, 5): self.assertNear(P[0], P[i]) states.TP = np.linspace(400, 500, 5), 101325 self.assertArrayNear(states.X.squeeze(), np.ones(5))
def test_saturated_mixture(self): self.water.TP = 300, ct.one_atm with self.assertRaisesRegex(ct.CanteraError, 'Saturated mixture detected'): self.water.TP = 300, self.water.P_sat w = ct.Water() # Saturated vapor self.water.TQ = 373.15, 1. self.assertEqual(self.water.phase_of_matter, 'liquid-gas-mix') w.TP = self.water.T, .999 * self.water.P_sat self.assertNear(self.water.cp, w.cp, 1.e-3) self.assertNear(self.water.cv, w.cv, 1.e-3) self.assertNear(self.water.thermal_expansion_coeff, w.thermal_expansion_coeff, 1.e-3) self.assertNear(self.water.isothermal_compressibility, w.isothermal_compressibility, 1.e-3) # Saturated mixture self.water.TQ = 373.15, .5 self.assertEqual(self.water.phase_of_matter, 'liquid-gas-mix') self.assertEqual(self.water.cp, np.inf) self.assertTrue(np.isnan(self.water.cv)) self.assertEqual(self.water.isothermal_compressibility, np.inf) self.assertEqual(self.water.thermal_expansion_coeff, np.inf) # Saturated liquid self.water.TQ = 373.15, 0. self.assertEqual(self.water.phase_of_matter, 'liquid-gas-mix') w.TP = self.water.T, 1.001 * self.water.P_sat self.assertNear(self.water.cp, w.cp, 1.e-3) self.assertNear(self.water.cv, w.cv, 1.e-3) self.assertNear(self.water.thermal_expansion_coeff, w.thermal_expansion_coeff, 1.e-3) self.assertNear(self.water.isothermal_compressibility, w.isothermal_compressibility, 1.e-3)
def setUp(self): self.fluid = ct.Water()
def setUpClass(cls): utilities.CanteraTest.setUpClass() cls.water = ct.Water()
# Set reactants state gas.TPX = 298, 101325, 'CH4:1, O2:2' h1 = gas.enthalpy_mass Y_CH4 = gas['CH4'].Y[ 0] # returns an array, of which we only want the first element # set state to complete combustion products without changing T or P gas.TPX = None, None, 'CO2:1, H2O:2' h2 = gas.enthalpy_mass print('LHV = {:.3f} MJ/kg'.format(-(h2 - h1) / Y_CH4 / 1e6)) # LHV # In[2]: # get the HHV including heat in water vapor water = ct.Water() # Set liquid water state, with vapor fraction x = 0 water.TX = 298, 0 h_liquid = water.h # Set gaseous water state, with vapor fraction x = 1 water.TX = 298, 1 h_gas = water.h # Calculate higher heating value Y_H2O = gas['H2O'].Y[0] print('HHV = {:.3f} MJ/kg'.format(-(h2 - h1 + (h_liquid - h_gas) * Y_H2O) / Y_CH4 / 1e6)) # ## Generalizing to arbitrary species # In[4]:
def setUp(self): self.water = ct.Water()
def test_invalid_phase_type(self): water = ct.Water() with self.assertRaises(ct.CanteraError): self.mix = ct.Mixture([(self.phase1, 1.0), (water, 2.0)])
def test_invalid_phase_type(self): water = ct.Water() with self.assertRaisesRegex(ct.CanteraError, 'not compatible'): self.mix = ct.Mixture([(self.phase1, 1.0), (water, 2.0)])
mr = [] cst = [] ben = [] n_cc = [] prs = [] mdots = [] #Define Fluid States airCompIn = ct.Nitrogen() airCompOut = ct.Nitrogen() airTurbIn = ct.Nitrogen() airTurbOut = ct.Nitrogen() airHrsgOut = ct.Nitrogen() waterPumpIn = ct.Water() waterPumpOut = ct.Water() waterTurbIn = ct.Water() waterTurbOut = ct.Water() #Define Efficiencies n_comp = 0.8 n_turb_a = 0.85 n_Hrsg = 0.86 n_pump = 0.9 n_turb_w = 0.9 for pr in range(3, 20): cost = 0 #cost per air mass flow rate benefit = 0 #benefit per air mass flow rate
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sun Apr 19 20:07:38 2020 @author: mohith_sai """ """ Print the critical state properties for the fluids for which Cantera has built-in liquid/vapor equations of state. """ import cantera as ct fluids = { 'water': ct.Water(), 'nitrogen': ct.Nitrogen(), 'methane': ct.Methane(), 'hydrogen': ct.Hydrogen(), 'oxygen': ct.Oxygen(), 'carbon dioxide': ct.CarbonDioxide(), 'heptane': ct.Heptane(), 'hfc134a': ct.Hfc134a() } print('Critical State Properties') print('%20s %10s %10s %10s' % ('Fluid', 'Tc [K]', 'Pc [Pa]', 'Zc')) for name in fluids: f = fluids[name] tc = f.critical_temperature pc = f.critical_pressure
#Define Arrays aPressureRatios = [] aMDotRatios = [] aCycleEfficiency = [] aNetPower = [] aQin = [] aQout = [] #Define Fluid States air5 = ct.Solution('air.cti') air6 = ct.Solution('air.cti') air7 = ct.Solution('air.cti') air8 = ct.Solution('air.cti') air9 = ct.Solution('air.cti') water1 = ct.Water() water2 = ct.Water() water3 = ct.Water() water4 = ct.Water() #Define Efficiencies n_compressor = 0.8 n_turbineAir = 0.85 n_HRSG = 0.86 n_pump = 0.9 n_turb_w = 0.9 for pr in range(3, 20): "State 5 - AIR - Inlet to Compressor" P5 = 101325
import cantera as ct import matplotlib.pyplot as plt import Dome as Dome # create figure and subplots fig = plt.figure() ax1 = plt.subplot(311) ax2 = plt.subplot(312) ax3 = plt.subplot(313) # plot using Dome command P, v = Dome.Dome(ct.Water(), 'P', 'v') ax1.loglog(v, P, 'k-') # add plot using Plot command Dome.Plot(ax2, ct.Water(), 'v', 'P') # add second plot using Plot command Dome.Plot(ax3, ct.Water(), 's', 'T') # display figure plt.show()
import numpy import cantera H2O = cantera.Water() Xi = 0.62345 Pi = 0.6E5 H2O.PX = Pi, Xi Ti = H2O.T Ts = 473 #Surface temperature of Al spheres [K] Ti = 273 #[K] V = 0.3735 #Fluid Velocity [m/s] D = 0.01 #Al sphere Diamemter [m] L = 0.1 #Length of Bed [m] W = 0.75 #Width of Bed H = 0.5 #Height of Bed N = round(W / D, 0) * round(L / D, 0) * round(H / D, 0) #Number of spheres N = round(N - N * 0.05, 0) #Reduction in 5% of spheres due to packing v_d = numpy.interp(Ti, temperature, Viscosity_dyn) #Dynamic Viscosity of Fluid [m²/s] v_g = numpy.interp(Ti, temperature, vg) #Density of fluid Pr = numpy.interp(Ti, temperature, Pr) #Prandtl Number of Fluid Kf = numpy.interp(Ti, temperature, conductivity) #Conductivity of Fluid rho = 1 / v_g v_ds = numpy.interp( Ts, temperature, Viscosity_dyn) #Dynamic viscosity of air at surface temperature vg_s = numpy.interp(Ts, temperature,
def test_invalid_phase_type(self): water = ct.Water() with self.assertRaises(Exception): self.mix = ct.Mixture([(self.phase1, 1.0), (water, 2.0)])
""" Print the critical state properties for the fluids for which Cantera has built-in liquid/vapor equations of state. """ import cantera as ct fluids = {'water': ct.Water(), 'nitrogen': ct.Nitrogen(), 'methane': ct.Methane(), 'hydrogen': ct.Hydrogen(), 'oxygen': ct.Oxygen(), 'carbon dioxide': ct.CarbonDioxide(), 'heptane': ct.Heptane(), 'hfc134a': ct.Hfc134a() } print('Critical State Properties') print('%20s %10s %10s %10s' % ('Fluid','Tc [K]', 'Pc [Pa]', 'Zc')) for name in fluids: f = fluids[name] tc = f.critical_temperature pc = f.critical_pressure rc = f.critical_density mw = f.mean_molecular_weight zc = pc * mw / (rc * ct.gas_constant * tc) print('%20s %10.4g %10.4G %10.4G' % (name, tc, pc, zc))
def setUpClass(cls): cls.water = ct.Water()
_X2 = [] _X3 = [] _X4 = [] _h12 = [] _h23 = [] _h34 = [] _h41 = [] _s12 = [] _s23 = [] _s34 = [] _s41 = [] "Define Fluids" air_1 = ct.Solution('air.cti') air_2 = ct.Solution('air.cti') WF_1 = ct.Water() WF_2 = ct.Water() WF_3 = ct.Water() WF_4 = ct.Water() "Knowns" T1_air = 0 + 273.15 # T1 ambient = 0C P1_air = 1 * 10**5 # P1 ambient = 1 bar T2_air = 40 + 273.15 # T2 into cabin = 40C P2_air = P1_air # P2 = 1 bar air_1.TP = T1_air, P1_air # Define state air_2.TP = T2_air, P2_air # Define state h1_air = air_1.h h2_air = air_2.h "Set variables"
""" This example generates a saturated steam table and plots the vapor dome. The steam table corresponds to data typically found in thermodynamic text books and uses the same customary units. Requires: Cantera >= 2.5.0, matplotlib >= 2.0, pandas >= 1.1.0, numpy >= 1.12 """ import cantera as ct import pandas as pd import numpy as np from matplotlib import pyplot as plt w = ct.Water() # create colums columns = ['T', 'P', 'vf', 'vfg', 'vg', 'uf', 'ufg', 'ug', 'hf', 'hfg', 'hg', 'sf', 'sfg', 'sg'] # temperatures correspond to Engineering Thermodynamics, Moran et al. (9th ed), # Table A-2; additional data points are added close to the critical point; # w.min_temp is equal to the triple point temperature degc = np.hstack([np.array([w.min_temp - 273.15, 4, 5, 6, 8]), np.arange(10, 37), np.array([38]), np.arange(40, 100, 5), np.arange(100, 300, 10), np.arange(300, 380, 20), np.arange(370, 374), np.array([w.critical_temperature - 273.15])])
eBalanceTurbine = sympy.Eq(W, m_turbine * (h_inTurbine - h_isentropicTurbine)) print('\n', eBalanceTurbine, '\n') eBalancePump = sympy.Eq(W, m_pump * (h_isentropicPump - h_inPump)) print(eBalancePump, '\n') eCombined = sympy.Eq(-eBalanceTurbine.lhs + eBalancePump.lhs, -eBalanceTurbine.rhs + eBalancePump.rhs) print(eCombined, '\n') mass_Ratio = sympy.Eq(m_ratio, (eBalanceTurbine.rhs / m_turbine) / (eBalancePump.rhs / m_pump)) print(mass_Ratio, '\n') inSteamValue_Turbine = cantera.Water() P_inTurbine = 10 * 10**5 T_inTurbine = 240 + 273 inSteamValue_Turbine.TP = T_inTurbine, P_inTurbine hTi = inSteamValue_Turbine.enthalpy_mass outWaterValue_Turbine = cantera.Water() P_OutTurbine = 1.5 * 10**5 S_OutTurbine = inSteamValue_Turbine.entropy_mass outWaterValue_Turbine.SP = S_OutTurbine, P_OutTurbine hTo = outWaterValue_Turbine.enthalpy_mass inWaterValue_Pump = cantera.Water() T_inPump = 15 + 273 P_inPump = 1 * 10**5 inWaterValue_Pump.TP = T_inPump, P_inPump
h8_IS = air8.enthalpy_mass h8.append(h_OutTurbine(n_turbine_Brayton, h8_IS, h7[-1])) air8.HP = h8[-1], p8[-1] t8.append(air8.T) s8.append(air8.entropy_mass) #State After HRSG air9 = cantera.Solution('air.cti') p9.append(atm2Pa(1)) t9.append(450) air9.TP = t9[-1], p9[-1] h9.append(air9.enthalpy_mass) s9.append(air9.entropy_mass) #State after the Condensor water1 = cantera.Water() p1.append(5 * 10**3) water1.PX = p1[-1], 0.0 h1.append(water1.enthalpy_mass) s1.append(water1.entropy_mass) t1.append(water1.T) #State after Pump water2 = cantera.Water() p2.append(7 * 10**6) water2.SP = s1[-1], p2[-1] h2_IS = water2.enthalpy_mass h2.append(h_OutCompressor(n_pump_Rankine, h2_IS, h1[-1])) water2.HP = h2[-1], p2[-1] t2.append(water2.T)
Flux_exp = exp_data['Flux_p2 [L/m2/h]'] elif membrane=='450nm': Flux_exp = exp_data['Flux_p45 [L/m2/h]'] SV_0, _, _ = init(membrane, 1.0, 'DGM', T_feed, T_perm) # Depending on transport flags, one of these outputs may be all zeros: data_Fick, data_DGM = run_tortuosities(tau_g_vec_0, membrane, DGM, Fick, SV_0, T_feed, T_perm) # Check to see if the intended folder exists. If not, create it: ensure_dir(membrane_folder) save_string = (membrane_folder+'TortuosityVariation_T_f_'+str(T_feed) +'_T_p_'+str(T_perm)) # Calculate the density of the permeate water: liq = ct.Water() liq.TP = T_perm + 273.15, ct.one_atm rho = liq.density # Set up plot color: dT = T_feed - T_perm i_color = int(dT/10 - 1) if DGM: np.savetxt(save_string+'_DGM.csv', data_DGM, delimiter=',') Fluxes = 3600*1000*data_DGM[1,:]/rho tau_fit = np.interp(Flux_exp, np.flip(Fluxes,0), np.flip(tau_g_vec_0,0)) tau_Fitting_DGM[index,:] = tau_fit[0], T_feed, T_perm