def setUp(self):
self.gas = ct.importPhase('h2o2.cti')
# create a reservoir for the fuel inlet, and set to pure methane.
self.gas.set(T=300.0, P=ct.OneAtm, X='H2:1.0')
fuel_in = reactors.Reservoir(self.gas)
fuel_mw = self.gas.meanMolarMass()
# Oxidizer inlet
self.gas.set(T=300.0, P=ct.OneAtm, X='O2:1.0, AR:3.0')
oxidizer_in = reactors.Reservoir(self.gas)
oxidizer_mw = self.gas.meanMolarMass()
# to ignite the fuel/air mixture, we'll introduce a pulse of radicals.
# The steady-state behavior is independent of how we do this, so we'll
# just use a stream of pure atomic hydrogen.
self.gas.set(T=300.0, P=ct.OneAtm, X='H:1.0')
self.igniter = reactors.Reservoir(self.gas)
# create the combustor, and fill it in initially with a diluent
self.gas.set(T=300.0, P=ct.OneAtm, X='AR:1.0')
self.combustor = reactors.Reactor(contents=self.gas, volume=1.0)
# create a reservoir for the exhaust
self.exhaust = reactors.Reservoir(self.gas)
# compute fuel and air mass flow rates
factor = 0.1
oxidizer_mdot = 4 * factor * oxidizer_mw
fuel_mdot = factor * fuel_mw
# create and install the mass flow controllers. Controllers
# m1 and m2 provide constant mass flow rates, and m3 provides
# a short Gaussian pulse only to ignite the mixture
m1 = reactors.MassFlowController(upstream=fuel_in,
downstream=self.combustor,
mdot=fuel_mdot)
m2 = reactors.MassFlowController(upstream=oxidizer_in,
downstream=self.combustor,
mdot=oxidizer_mdot)
# The igniter will use a Gaussian 'functor' object to specify the
# time-dependent igniter mass flow rate.
igniter_mdot = Gaussian(t0=0.1, FWHM=0.05, A=0.1)
m3 = reactors.MassFlowController(upstream=self.igniter,
downstream=self.combustor,
mdot=igniter_mdot)
# put a valve on the exhaust line to regulate the pressure
self.v = reactors.Valve(upstream=self.combustor,
downstream=self.exhaust,
Kv=1.0)
# the simulation only contains one reactor
self.sim = reactors.ReactorNet([self.combustor])
def AIT(x2,end_t):
#comp = 'CH4:1.0, O2:2, N2:7.52'
tempx = 980
gasx.set(T = tempx, P = OneAtm, X = x2)
r = Reactor(gasx)
try:
sim = ReactorNet([r])
sim.advance(time)
except:
pass
t_x=r.temperature()
print t_x-tempx
return t_x-tempx
def setUp(self):
# reservoir to represent the environment
self.gas0 = ct.importPhase('air.cti')
self.gas0.set(T=300, P=ct.OneAtm)
self.env = reactors.Reservoir(self.gas0)
# reactor to represent the side filled with Argon
self.gas1 = ct.importPhase('air.cti')
self.gas1.set(T=1000.0, P=30 * ct.OneAtm, X='AR:1.0')
self.r1 = reactors.Reactor(self.gas1)
# reactor to represent the combustible mixture
self.gas2 = ct.importPhase('h2o2.cti')
self.gas2.set(T=500.0, P=1.5 * ct.OneAtm, X='H2:0.5, O2:1.0, AR:10.0')
self.r2 = reactors.Reactor(self.gas2)
# Wall between the two reactors
self.w1 = reactors.Wall(self.r2, self.r1)
self.w1.set(area=1.0, K=2e-4, U=400.0)
# Wall to represent heat loss to the environment
self.w2 = reactors.Wall(self.r2, self.env)
self.w2.set(area=1.0, U=2000.0)
# Create the reactor network
self.sim = reactors.ReactorNet([self.r1, self.r2])
gas.set(T=300, P = ct.OneAtm, X='CH4:0.9, H2:0.1')
fuel_in = Reservoir(gas)
fuel_mw = gas.meanMolarMass()
#create a reservoir of H atoms to use to ignite the mixture
gas.set(T=300, P=ct.OneAtm, X = 'H:1.0')
igniter = Reservoir(gas)
# use predefined Air for the air inlet
gas.set(T=300, P=ct.OneAtm, X = 'N2:70,O2:20')
air = Reservoir(gas)
air_in = Reservoir(gas)
air_mw = gas.meanMolarMass()
gas.set(T=300, P=ct.OneAtm, X = 'N2:1')
combustor = Reactor(contents = gas, volume =1.0)
exhaust = Reservoir(gas)
equiv_ration = 0.6
factor = 0.1
air_mdot = factor * 9.52 * air_mw
fuel_mdot = factor * equiv_ration * fuel_mw
print air_mdot,fuel_mdot
# create and install the mass flow controllers
m1 = MassFlowController(upstream = fuel_in, downstream = combustor, mdot = fuel_mdot)
m2 = MassFlowController(upstream = air_in, downstream = combustor, mdot = air_mdot)
igniter_mdot = Gaussian(t0=1.0, FWHM = 0.04, A = 0.1)
rho_b = gas_b.density()
# Create reservoirs for the two inlet streams and for the outlet
# stream. The upsteam reservoirs could be replaced by reactors, which
# might themselves be connected to reactors further upstream. The
# outlet reservoir could be replaced with a reactor with no outlet, if
# it is desired to integrate the composition leaving the mixer in
# time, or by an arbitrary network of downstream reactors.
res_a = Reservoir(gas_a)
res_b = Reservoir(gas_b)
downstream = Reservoir(gas_b)
# Create a reactor for the mixer. A reactor is required instead of a
# reservoir, since the state will change with time if the inlet mass
# flow rates change or if there is chemistry occurring.
mixer = Reactor(gas_b)
# create two mass flow controllers connecting the upstream reservoirs
# to the mixer, and set their mass flow rates to values corresponding
# to stoichiometric combustion.
mfc1 = MassFlowController(upstream=res_a,
downstream=mixer,
mdot=rho_a * 2.5 / 0.21)
mfc2 = MassFlowController(upstream=res_b, downstream=mixer, mdot=rho_b * 1.0)
# connect the mixer to the downstream reservoir with a valve.
outlet = Valve(upstream=mixer, downstream=downstream, Kv=1.0)
sim = ReactorNet([mixer])
"""
return N.array(data)
gas2 = GRI30()
# Umwelt definieren
gas2.set(T=290, P=OneAtm, X="N2:1")
env = Reservoir(gas2)
# Reaktorgemisch vorlegen // 1m3
# gas2.set(T=400+273.75, P=OneAtm/1.3, X='CO:20, CO2:60, O2:4.2, N2:15.8')
# 24.334 0.7311988
# 25.215 0.5627019
gas2.set(T=25.215 + 273.15, P=56270, X="O2:21.6, N2:79.1")
# gas2.set(T=900, P=OneAtm, X='CO:20, CO2:60, N2:15.8 , O2:4.2')
r2 = Reactor(gas2, volume=0.025)
heatrate = Polynomial([-64.0e-1, 0.0, 0.0])
wall = Wall(left=r2, right=env)
# in Joule
print " Heizrate in MW ", heatrate(1) / 1000
print " Heizrate in MW/m3 ", heatrate(1) / r2.volume() / 1000
wall.set(Q=heatrate)
sim = ReactorNet([r2])
print "H20", r2.moleFraction("H2O")
print "CH4", r2.moleFraction("CH4")
print "CO2", r2.moleFraction("CO2")
print "CO", r2.moleFraction("CO")
print "O2", r2.moleFraction("O2")
# use predefined function Air() for the air inlet air = Air() air_in = Reservoir(air) air_mw = air.meanMolarMass() # to ignite the fuel/air mixture, we'll introduce a pulse of radicals. # The steady-state behavior is independent of how we do this, so we'll # just use a stream of pure atomic hydrogen. gas.set(T = 300.0, P = OneAtm, X = 'H:1.0') igniter = Reservoir(gas) # create the combustor, and fill it in initially with N2 gas.set(T = 300.0, P = OneAtm, X = 'N2:1.0') combustor = Reactor(contents = gas, volume = 1.0) # create a reservoir for the exhaust exhaust = Reservoir(gas) # lean combustion, phi = 0.5 equiv_ratio = 0.5 # compute fuel and air mass flow rates factor = 0.1 air_mdot = factor*9.52*air_mw fuel_mdot = factor*equiv_ratio*fuel_mw # create and install the mass flow controllers. Controllers # m1 and m2 provide constant mass flow rates, and m3 provides # a short Gaussian pulse only to ignite the mixture
from matplotlib.mlab import normpdf
def list_to_array(data):
'''
Wandelt die Liste in Numpyarray um und schneidet erste Datensatz ab
'''
return N.array(data)
gas = importPhase('h2o2.cti')
gas.set(T = 300, P=OneAtm, X='H2:10, AR:70, O2:16')
gas2 = GRI30()
gas2.set(T=300, P=OneAtm, X='N2:80, O2=20')
r1 = Reactor(gas,volume = 1 )
r2 = Reactor(gas2,volume = 0.05 )
gas.set(T = 300, P = OneAtm, X = 'H:1.0')
igniter = Reservoir(gas)
gas_sink = Reservoir(gas2)
igniter_mdot= Gaussian(t0=2.0, FWHM = 0.04, A=0.02)
m3 = MassFlowController (upstream = igniter, downstream = r1, mdot = igniter_mdot)
v1=Valve(r1,gas_sink)
v1.setValveCoeff(0)
# Create reservoirs for the two inlet streams and for the outlet
# stream. The upsteam reservoirs could be replaced by reactors, which
# might themselves be connected to reactors further upstream. The
# outlet reservoir could be replaced with a reactor with no outlet, if
# it is desired to integrate the composition leaving the mixer in
# time, or by an arbitrary network of downstream reactors.
res_a = Reservoir(gas_a)
res_b = Reservoir(gas_b)
downstream = Reservoir(gas_b)
# Create a reactor for the mixer. A reactor is required instead of a
# reservoir, since the state will change with time if the inlet mass
# flow rates change or if there is chemistry occurring.
gas_b.set(T = 300.0, P = OneAtm, X = 'N2:0.78, AR:0.01')
mixer = Reactor(gas_b,volume = 0.125)
# create two mass flow controllers connecting the upstream reservoirs
# to the mixer, and set their mass flow rates to values corresponding
# to stoichiometric combustion.
mfc1 = MassFlowController(upstream = res_a,
downstream = mixer,
mdot = 720*rho_a)
#CO_Peak = Gaussian(t0 = 1, FWHM = 0.32, A=0.05)
mfc2 = MassFlowController(upstream = res_b,
downstream = mixer,
mdot = 0)
Constant-pressure, adiabatic kinetics simulation with sensitivity analysis """ import sys from Cantera import * from Cantera.Reactor import * from Cantera.Func import * gri3 = GRI30() temp = 1500.0 pres = OneAtm gri3.set(T = temp, P = pres, X = 'CH4:0.1, O2:2, N2:7.52') r = Reactor(gri3) air = Air() air.set(T = temp, P = pres) env = Reservoir(air) # Define a wall between the reactor and the environment, and # make it flexible, so that the pressure in the reactor is held # at the environment pressure. w = Wall(r,env) w.set(K = 1.0e6) # set expansion parameter. dV/dt = KA(P_1 - P_2) w.set(A = 1.0) # enable sensitivity with respect to the rates of the first 10 # reactions (reactions 0 through 9) r.addSensitivityReaction(reactions = range(10))
file2 = open('results.csv', 'w')
speciesandtemp = range(num_species + 1)
speciesandtemp = ['Time (s)'] + ['Temp (K)'] + ['Pressure (Pa)'] + species
writeCSV(file2, speciesandtemp)
## Define a two-dimensional array to hold mole-fractions and temps of each species at all time steps
#Changed to + 3 to add pressure into the mix ...
num_speciesplusthree = num_species + 3 # + 1 for time and + 1 for temp and + 1 for pressure
for i in range(Ntimesteps):
mf_species[i] = range(0, num_speciesplusthree)
## set initial conditions!
gas.set(T=Tini, P=P1, X="%s" % (initialcomposition))
######################### SET UP THE REACTOR
r = Reactor(gas, energy="off")
gas_b = Air()
gas_b.set(P=P1)
env = Reservoir(gas_b)
# Define a wall between the reactor and the environment, and
# make it flexible, so that the pressure in the reactor is held
# at the environment pressure.
w = Wall(r, env)
w.set(K=1.0e6) # set expansion parameter. dV/dt = KA(P_1 - P_2)
w.set(A=1.0)
######################### SET UP THE REACTOR
sim = ReactorNet([r])
time = 0.0
p0 = 101325.
tFinal = 100.0
R = 0.60 # Hydrogen-fuel ratio.
b = R/(2.0*(1.0-R))
c = (4.0-3.0*R)/(4.0*(1.0-R))
e = c/phi
d = 3.7*e
comp = 'CH4:0.5, H2:%(b)f, O2:%(e)f, N2:%(d)f'% vars()
print '#'+comp
gas = GRI30()
gas.set(T = T0, P = OneAtm, X = comp)
r = Reactor(gas)
env = Reservoir(Air())
w = Wall(r,env)
w.set(K = 0) # set expansion parameter. dV/dt = KA(P_1 - P_2)
w.set(A = 1.0)
sim = ReactorNet([r])
time = 0.0
#Told = r.temperature()
#print '%10.3e %10.3f %10.3f %14.6e' % (sim.time(), r.temperature(), r.pressure(), r.intEnergy_mass())
for n in range(36):
time = (n+1)*0.0005
""" Constant-pressure, adiabatic kinetics simulation. """ import sys from Cantera import * from Cantera.Reactor import * from Cantera.Func import * from Cantera import rxnpath gri3 = GRI30() gri3.set(T = 1001.0, P = OneAtm, X = 'H2:2,O2:1,N2:4') r = Reactor(gri3) env = Reservoir(Air()) # Define a wall between the reactor and the environment, and # make it flexible, so that the pressure in the reactor is held # at the environment pressure. w = Wall(r,env) w.set(K = 1.0e6) # set expansion parameter. dV/dt = KA(P_1 - P_2) w.set(A = 1.0) sim = ReactorNet([r]) time = 0.0 tim = zeros(100,'d') data = zeros([100,5],'d')
from Cantera import *
from Cantera.Reactor import *
import sys
fmt = '%10.3f %10.1f %10.4f %10.4g %10.4g %10.4g %10.4g'
print '%10s %10s %10s %10s %10s %10s %10s' % ('time [s]','T1 [K]','T2 [K]',
'V1 [m^3]', 'V2 [m^3]',
'V1+V2 [m^3]','X(CO)')
gas1 = importPhase('h2o2.cti')
gas1.set(T = 900.0, P = OneAtm, X = 'H2:2, O2:1, AR:20')
gas2 = GRI30()
gas2.set(T = 900.0, P = OneAtm, X = 'CO:2, H2O:0.01, O2:5')
r1 = Reactor(gas1, volume = 0.5)
r2 = Reactor(gas2, volume = 0.1)
w = Wall(left = r1, right = r2, K = 1.0e3)
reactors = ReactorNet([r1, r2])
tim = []
t1 = []
t2 = []
v1 = []
v2 = []
v = []
xco = []
xh2 = []
for n in range(30):
Constant-pressure, adiabatic kinetics simulation with sensitivity analysis """ import sys from Cantera import * from Cantera.Reactor import * from Cantera.Func import * gri3 = GRI30() temp = 1500.0 pres = OneAtm gri3.set(T=temp, P=pres, X='CH4:0.1, O2:2, N2:7.52') r = Reactor(gri3) air = Air() air.set(T=temp, P=pres) env = Reservoir(air) # Define a wall between the reactor and the environment, and # make it flexible, so that the pressure in the reactor is held # at the environment pressure. w = Wall(r, env) w.set(K=1.0e6) # set expansion parameter. dV/dt = KA(P_1 - P_2) w.set(A=1.0) # enable sensitivity with respect to the rates of the first 10 # reactions (reactions 0 through 9) r.addSensitivityReaction(reactions=range(10))
# First create each gas needed, and a reactor or reservoir for each one.
# -----------------------------------------------------------------------
# create an argon gas object and set its state. This function is
# defined in module Cantera.gases, as are functions 'Air()', and
# 'GRI30()'
ar = Argon()
ar.set(T=800.0, P=0.5 * OneAtm)
""" Tiegelraum gefuellt mit Argon
800K , 51mbar Druck
"""
# create a reactor to represent the side of the cylinder filled with argon
r1 = Reactor(ar, volume=0.150, name="Tiegelraum")
# create a reservoir for the environment, and fill it with air.
env = Reservoir(Air())
# use GRI-Mech 3.0 for the methane/air mixture, and set its initial state
h2o = importPhase("liquidvapor.cti", "water")
h2o.set(T=300.0, P=OneAtm, X="H2O:1")
# create a reactor for the methane/air side
r2 = Reactor(h2o, volume=0.50, name="Wassermenge")
# ---------------------------------------------------------------------
# Now couple the reactors by defining common walls that may move (a piston)
@author: rened """ from Cantera import * from Cantera.Reactor import * from Cantera.Func import * # Luftdefinition air = Air() air_in = Reservoir(air) air_out = Reservoir(air) air_mw = air.meanMolarMass() # Der Ofen hat ein Volumen von 125 L gas = GRI30() gas.set(T=300.0, P = OneAtm, X ='N2:1.0,CO:0.0000001') ofen = Reactor(contents = gas, volume = 0.125) # Zwei weitere Reaktor stellen das Rohr da. rohr1 = Reactor(contents = gas, volume = 0.025) rohr2 = Reactor(contents = gas, volume = 0.025) # CO Quelle gas.set(T=300.0, P = OneAtm, X ='CO:1.0') CO_Quelle = Reactor(contents = gas, volume = 0.025) ZuGabe_CO = Gaussian(t0=1.0, FWHM = 0.4, A = 0.1) m1 = MassFlowController(upstream = CO_Quelle, downstream = ofen, mdot = ZuGabe_CO) air_mdot = 1 m2 = MassFlowController(upstream = air_in, downstream = ofen, mdot = air_mdot) m3 = Valve(upstream = ofen, downstream = rohr1, Kv=10.0)
def list_to_array(data):
"""
Wandelt die Liste in Numpyarray um und schneidet erste Datensatz ab
"""
return N.array(data)
gas = importPhase("h2o2.cti")
gas.set(T=300, P=OneAtm, X="H2:7, AR:70, O2:8")
gas2 = GRI30()
gas2.set(T=300, P=OneAtm, X="N2:80, O2=20")
r1 = Reactor(gas, volume=1)
r2 = Reactor(gas2, volume=0.3)
gas.set(T=300, P=OneAtm, X="H:1.0")
igniter = Reservoir(gas)
igniter_mdot = Gaussian(t0=2.0, FWHM=0.05, A=0.05)
m3 = MassFlowController(upstream=igniter, downstream=r1, mdot=igniter_mdot)
wall = Wall(left=r1, right=r2, K=1.0e3)
sim = ReactorNet([r1, r2])
time_list = []
temp_list = []
time_list2 = []
from Cantera.Reactor import * from Cantera.Func import * #----------------------------------------------------------------------- # First create each gas needed, and a reactor or reservoir for each one. #----------------------------------------------------------------------- # create an argon gas object and set its state. This function is # defined in module Cantera.gases, as are functions 'Air()', and # 'GRI30()' ar = Argon() ar.set(T=1000.0, P=20.0 * OneAtm, X='AR:1') # create a reactor to represent the side of the cylinder filled with argon r1 = Reactor(ar) # create a reservoir for the environment, and fill it with air. env = Reservoir(Air()) # use GRI-Mech 3.0 for the methane/air mixture, and set its initial state gri3 = GRI30() gri3.set(T=500.0, P=0.2 * OneAtm, X='CH4:1.1, O2:2, N2:7.52') # create a reactor for the methane/air side r2 = Reactor(gri3) #--------------------------------------------------------------------- # Now couple the reactors by defining common walls that may move (a piston) # or conduct heat
""" Constant-pressure, adiabatic kinetics simulation. """ import sys from Cantera import * from Cantera.Reactor import * from Cantera.Func import * from Cantera import rxnpath gri3 = GRI30() gri3.set(T=1001.0, P=OneAtm, X='H2:2,O2:1,N2:4') r = Reactor(gri3) env = Reservoir(Air()) # Define a wall between the reactor and the environment, and # make it flexible, so that the pressure in the reactor is held # at the environment pressure. w = Wall(r, env) w.set(K=1.0e6) # set expansion parameter. dV/dt = KA(P_1 - P_2) w.set(A=1.0) sim = ReactorNet([r]) time = 0.0 tim = zeros(100, 'd') data = zeros([100, 5], 'd')
from Cantera.Reactor import * from Cantera.Func import * #----------------------------------------------------------------------- # First create each gas needed, and a reactor or reservoir for each one. #----------------------------------------------------------------------- # create an argon gas object and set its state. This function is # defined in module Cantera.gases, as are functions 'Air()', and # 'GRI30()' ar = Argon() ar.set(T = 1000.0, P = 20.0*OneAtm, X = 'AR:1') # create a reactor to represent the side of the cylinder filled with argon r1 = Reactor(ar) # create a reservoir for the environment, and fill it with air. env = Reservoir(Air()) # use GRI-Mech 3.0 for the methane/air mixture, and set its initial state gri3 = GRI30() gri3.set(T = 500.0, P = 0.2*OneAtm, X = 'CH4:1.1, O2:2, N2:7.52') # create a reactor for the methane/air side r2 = Reactor(gri3)
def list_to_array(data):
'''
Wandelt die Liste in Numpyarray um und schneidet erste Datensatz ab
'''
return N.array(data)
from string import *
time = 10.0
gas = GRI30()
comp = 'CH4:1.0, O2:2, N2:7.52'
for n in range(45):
t = 800.0 + 2.0*n
gas.setState_TPX(t, OneAtm, comp)
r = Reactor(gas)
sim = ReactorNet([r])
sim.setTolerances(rtol=1E-12, atol=1E-22, rtolsens=-1, atolsens=-1)
while sim.time()<time:
sim.step(1)
dt = r.temperature() - t
print t-273.15, dt,sim.time()
if dt > 600.0:
print '!!'
break
if dt > 600.0:
print '!!'
break
# use predefined function Air() for the air inlet air = Air() air_in = Reservoir(air) air_mw = air.meanMolarMass() # to ignite the fuel/air mixture, we'll introduce a pulse of radicals. # The steady-state behavior is independent of how we do this, so we'll # just use a stream of pure atomic hydrogen. gas.set(T = 300.0, P = OneAtm, X = 'H:1.0') igniter = Reservoir(gas) # create the combustor, and fill it in initially with N2 gas.set(T = 300.0, P = OneAtm, X = 'N2:1.0') combustor = Reactor(contents = gas, volume = 1.0) # create a reservoir for the exhaust exhaust = Reservoir(gas) # lean combustion, phi = 0.5 equiv_ratio = 0.5 # compute fuel and air mass flow rates factor = 0.1 air_mdot = factor*9.52*air_mw fuel_mdot = factor*equiv_ratio*fuel_mw # create and install the mass flow controllers. Controllers # m1 and m2 provide constant mass flow rates, and m3 provides # a short Gaussian pulse only to ignite the mixture
from Cantera import *
from Cantera.Reactor import *
import sys
fmt = '%10.3f %10.1f %10.4f %10.4g %10.4g %10.4g %10.4g'
print '%10s %10s %10s %10s %10s %10s %10s' % ('time [s]','T1 [K]','T2 [K]',
'V1 [m^3]', 'V2 [m^3]',
'V1+V2 [m^3]','X(CO)')
gas1 = importPhase('h2o2.cti')
gas1.set(T = 900.0, P = OneAtm, X = 'H2:2, O2:1, AR:20')
gas2 = GRI30()
gas2.set(T = 900.0, P = OneAtm, X = 'CO:2, H2O:0.01, O2:5')
r1 = Reactor(gas1, volume = 0.5)
r2 = Reactor(gas2, volume = 0.1)
w = Wall(left = r1, right = r2, K = 1.0e3)
reactors = ReactorNet([r1, r2])
tim = []
t1 = []
t2 = []
v1 = []
v2 = []
v = []
xco = []
xh2 = []
for n in range(30):
def PSRCalc(self, volume, tfinal):
initial_gas = self.InitialGas()
gas = self._gas1
NoGas = 0 ## Ignition isn't provided if NoGas = 0
mass_flow = 0
upstreams = numpy.empty(self._code, dtype=object)
ms = numpy.empty(self._code, dtype=object)
reactor = Reactor(initial_gas, volume=volume, energy='on')
ControllerCount = 0
for code in range(0, self._argslength, 2):
upstreams[ControllerCount] = Reservoir(self._args[code])
ms[ControllerCount] = MassFlowController()
ms[ControllerCount].install(upstreams[ControllerCount], reactor)
ms[ControllerCount].set(self._args[code + 1])
mass_flow += self._args[code + 1]
ControllerCount += 1
exhaust = Reservoir(gas)
v = Valve()
v.install(reactor, exhaust)
v.setValveCoeff(Kv=0.5) #Change made from 1.0 to 0.5
sim = ReactorNet([reactor])
tnow = 0.0
tracker = datetime.now()
LoopCounter = 0
while (tnow < tfinal):
LoopCounter += 1
tnow = sim.step(tfinal)
tres = reactor.mass() / mass_flow
currenttime = datetime.now()
d = reactor.massFractions()
IndexCounter = 0
for item in d:
if item > 1:
badguy = 1
baditem = item
break
else:
badguy = 0
IndexCounter += 1
if badguy:
break
b = (currenttime.time().minute - tracker.time().minute)
if (b > 2):
break
if (IndexCounter >= gas.nSpecies()):
badSpecie = 'No Bad Species present'
baditem = 'None'
else:
badSpecie = gas.speciesName(IndexCounter)
tres = reactor.mass() / v.massFlowRate()
T = reactor.temperature()
P = reactor.pressure()
reactor = Reactor(initial_gas)
x = reactor.contents().moleFractions()
initial_gas.setState_TPX(T, P, x)
return initial_gas, mass_flow, tres
mass_flow_rate = velocity * rho0 * area
# The plug flow reactor is represented by a linear chain of
# zero-dimensional reactors. The gas at the inlet to the first one has
# the specified inlet composition, and for all others the inlet
# composition is fixed at the composition of the reactor immediately
# upstream. Since in a PFR model there is no diffusion, the upstream
# reactors are not affected by any downstream reactors, and therefore
# the problem may be solved by simply marching from the first to last
# reactor, integrating each one to steady state.
for n in range(NReactors):
# create a new reactor
r = Reactor(contents = gas, energy = 'off', volume = rvol)
# create a reservoir to represent the reactor immediately
# upstream. Note that the gas object is set already to the
# state of the upstream reactor
upstream = Reservoir(gas, name = 'upstream')
# create a reservoir for the reactor to exhaust into. The
# composition of this reservoir is irrelevant.
downstream = Reservoir(gas, name = 'downstream')
# use a 'Wall' object to implement the reacting surface in the
# reactor. Since walls have to be installed between two
# reactors/reserviors, we'll install it between the upstream
# reservoir and the reactor. The area is set to the desired
# catalyst area in the reactor, and surface reactions are
def PFR(self, volume, NReactors):
initial_gas = self.InitialGas()
gas = self._gas1
T = gas.temperature()
P = gas.pressure()
x = gas.moleFractions()
initial_gas.setState_TPX(T, P, x)
upstreams = numpy.empty(self._code - 1, dtype=object)
ms = numpy.empty(self._code - 1, dtype=object)
mass_flow = self._args[1]
TOL = 1.0E-10
Niter = 20
nsp = gas.nSpecies()
wdot = [''] * nsp
wold = [''] * nsp
volume_n = volume / NReactors
tres = 0.0
for i in range(0, NReactors):
reactor = Reactor(initial_gas, volume=volume_n, energy='on')
upstream = Reservoir(initial_gas)
downstream = Reservoir(initial_gas)
m = MassFlowController()
m.install(upstream, reactor)
m.set(mass_flow)
if (i == 0):
ControllerCount = 0
for code in range(2, self._argslength, 2):
upstreams[ControllerCount] = Reservoir(self._args[code])
ms[ControllerCount] = MassFlowController()
ms[ControllerCount].install(upstreams[ControllerCount],
reactor)
ms[ControllerCount].set(self._args[code + 1])
mass_flow += self._args[code + 1]
ControllerCount += 1
v = Valve()
v.install(reactor, downstream)
v.setValveCoeff(Kv=0.1)
sim = ReactorNet([reactor])
dt = reactor.mass() / mass_flow
tnow = 0.0
wold = initial_gas.netProductionRates()
while (tnow < Niter * dt):
tnow += dt
sim.advance(tnow)
max_change = 0.0
wdot = initial_gas.netProductionRates()
for k in range(0, nsp):
max_change = max(math.fabs(wdot[k] - wold[k]), max_change)
wold[k] = wdot[k]
if (max_change < TOL):
break
tres += reactor.mass() / mass_flow
T = reactor.temperature()
P = reactor.pressure()
reactor = Reactor(initial_gas)
x = reactor.contents().moleFractions()
initial_gas.setState_TPX(T, P, x)
f = self.FuelMassAnalyzer(initial_gas, mass_flow)
return initial_gas, mass_flow, tres, f
mass_flow_rate = velocity * rho0 * area
# The plug flow reactor is represented by a linear chain of
# zero-dimensional reactors. The gas at the inlet to the first one has
# the specified inlet composition, and for all others the inlet
# composition is fixed at the composition of the reactor immediately
# upstream. Since in a PFR model there is no diffusion, the upstream
# reactors are not affected by any downstream reactors, and therefore
# the problem may be solved by simply marching from the first to last
# reactor, integrating each one to steady state.
for n in range(NReactors):
# create a new reactor
r = Reactor(contents=gas, energy='off', volume=rvol)
# create a reservoir to represent the reactor immediately
# upstream. Note that the gas object is set already to the
# state of the upstream reactor
upstream = Reservoir(gas, name='upstream')
# create a reservoir for the reactor to exhaust into. The
# composition of this reservoir is irrelevant.
downstream = Reservoir(gas, name='downstream')
# use a 'Wall' object to implement the reacting surface in the
# reactor. Since walls have to be installed between two
# reactors/reserviors, we'll install it between the upstream
# reservoir and the reactor. The area is set to the desired
# catalyst area in the reactor, and surface reactions are
# Create reservoirs for the two inlet streams and for the outlet
# stream. The upsteam reservoirs could be replaced by reactors, which
# might themselves be connected to reactors further upstream. The
# outlet reservoir could be replaced with a reactor with no outlet, if
# it is desired to integrate the composition leaving the mixer in
# time, or by an arbitrary network of downstream reactors.
res_a = Reservoir(gas_a)
res_b = Reservoir(gas_b)
downstream = Reservoir(gas_b)
# Create a reactor for the mixer. A reactor is required instead of a
# reservoir, since the state will change with time if the inlet mass
# flow rates change or if there is chemistry occurring.
mixer = Reactor(gas_b)
# create two mass flow controllers connecting the upstream reservoirs
# to the mixer, and set their mass flow rates to values corresponding
# to stoichiometric combustion.
mfc1 = MassFlowController(upstream = res_a,
downstream = mixer,
mdot = rho_a*2.5/0.21)
mfc2 = MassFlowController(upstream = res_b,
downstream = mixer,
mdot = rho_b*1.0)
# add an igniter to ignite the mixture. The 'igniter' consists of a
# Create reservoirs for the two inlet streams and for the outlet
# stream. The upsteam reservoirs could be replaced by reactors, which
# might themselves be connected to reactors further upstream. The
# outlet reservoir could be replaced with a reactor with no outlet, if
# it is desired to integrate the composition leaving the mixer in
# time, or by an arbitrary network of downstream reactors.
res_a = Reservoir(gas_a)
res_b = Reservoir(gas_b)
downstream = Reservoir(gas_b)
# Create a reactor for the mixer. A reactor is required instead of a
# reservoir, since the state will change with time if the inlet mass
# flow rates change or if there is chemistry occurring.
mixer = Reactor(gas_b)
# create two mass flow controllers connecting the upstream reservoirs
# to the mixer, and set their mass flow rates to values corresponding
# to stoichiometric combustion.
mfc1 = MassFlowController(upstream = res_a,
downstream = mixer,
mdot = rho_a*2.5/0.21)
mfc2 = MassFlowController(upstream = res_b,
downstream = mixer,
mdot = rho_b*1.0)
# add an igniter to ignite the mixture. The 'igniter' consists of a
def list_to_array(data):
'''
Wandelt die Liste in Numpyarray um und schneidet erste Datensatz ab
'''
return N.array(data)
# Luftdefinition
air = Air()
air_in = Reservoir(air)
air_out = Reservoir(air)
air_mw = air.meanMolarMass()
# Der Ofen hat ein Volumen von 125 L
gas = GRI30()
gas.set(T=300.0, P = OneAtm, X ='N2:1.0,CO:0.0000001')
ofen = Reactor(contents = gas, volume = 0.125)
# Zwei weitere Reaktor stellen das Rohr da.
rohr1 = Reactor(contents = gas, volume = 0.025)
rohr2 = Reactor(contents = gas, volume = 0.025)
# CO Quelle
gas.set(T=300.0, P = OneAtm, X ='CO:1.0')
CO_Quelle = Reactor(contents = gas, volume = 0.025)
ZuGabe_CO = Gaussian(t0=1.0, FWHM = 0.3, A = 0.1)
m1 = MassFlowController(upstream = CO_Quelle, downstream = ofen, mdot = ZuGabe_CO)
air_mdot = 2
m2 = MassFlowController(upstream = air_in, downstream = ofen, mdot = air_mdot)
m3 = Valve(upstream = ofen, downstream = rohr1, Kv=10.0)
