Added basic implementation of Reactor, ReactorNet and Wall to the Python module

interfaces/cython/cantera/_cantera.pxd

@@ -1,5 +1,6 @@
 from libcpp.vector cimport vector
 from libcpp.string cimport string
+from libcpp cimport bool as cbool
 
 cdef extern from "cantera/base/xml.h" namespace "Cantera":
     cdef cppclass XML_Node:
@@ -55,6 +56,34 @@ cdef extern from "cantera/numerics/Func1.h":
     cdef cppclass CxxSin1 "Cantera::Sin1":
         CxxSin1(double)
 
+cdef extern from "cantera/zeroD/ReactorBase.h" namespace "Cantera":
+    cdef cppclass CxxWall "Cantera::Wall"
+    cdef cppclass CxxReactorBase "Cantera::ReactorBase":
+        CxxReactorBase()
+        void setThermoMgr(CxxThermoPhase&)
+        double volume()
+
+cdef extern from "cantera/zeroD/Reactor.h":
+    cdef cppclass CxxReactor "Cantera::Reactor":
+        CxxReactor()
+        void setKineticsMgr(CxxKinetics&)
+
+cdef extern from "cantera/zeroD/Wall.h":
+    cdef cppclass CxxWall "Cantera::Wall":
+        CxxWall()
+        cbool install(CxxReactorBase&, CxxReactorBase&)
+        void setExpansionRateCoeff(double)
+        double area()
+        void setArea(double)
+
+cdef extern from "cantera/zeroD/ReactorNet.h":
+    cdef cppclass CxxReactorNet "Cantera::ReactorNet":
+        CxxReactorNet()
+        void addReactor(CxxReactorBase*)
+        void initialize(double)
+        void advance(double)
+        double step(double)
+
 cdef extern from "cantera/thermo/ThermoFactory.h" namespace "Cantera":
     cdef CxxThermoPhase* newPhase(string, string) except +
     cdef CxxThermoPhase* newPhase(XML_Node&) except +
@@ -66,6 +95,9 @@ cdef extern from "cantera/transport/TransportFactory.h" namespace "Cantera":
     cdef CxxTransport* newDefaultTransportMgr(CxxThermoPhase*) except +
     cdef CxxTransport* newTransportMgr(string, CxxThermoPhase*) except +
 
+cdef extern from "cantera/zeroD/ReactorFactory.h" namespace "Cantera":
+    cdef CxxReactorBase* newReactor(string) except +
+
 cdef string stringify(x)
 
 cdef class _SolutionBase:
@@ -79,3 +111,10 @@ cdef class Mixture:
 
 cdef class Func1:
     cdef CxxFunc1* func
+
+cdef class ReactorBase:
+    cdef CxxReactorBase* rbase
+
+cdef class Wall:
+    cdef CxxWall* wall
+    cdef double _expansionRateCoeff

interfaces/cython/cantera/_cantera.pyx

@@ -16,3 +16,5 @@ include "transport.pyx"
 include "composite.pyx"
 
 include "mixture.pyx"
+
+include "reactor.pyx"

interfaces/cython/cantera/reactor.pyx

@@ -0,0 +1,70 @@
+cdef class ReactorBase:
+    reactorType = "None"
+    def __cinit__(self, *args, **kwargs):
+        self.rbase = newReactor(stringify(self.reactorType))
+
+    def __init__(self, *args, **kwargs):
+        if args and isinstance(args[0], _SolutionBase):
+            self.insert(args[0])
+
+    def __dealloc__(self):
+        del self.rbase
+
+    def insert(self, _SolutionBase solution):
+        self.rbase.setThermoMgr(deref(solution.thermo))
+
+    def volume(self):
+        return self.rbase.volume()
+
+
+cdef class Reactor(ReactorBase):
+    reactorType = "Reactor"
+    cdef CxxReactor* reactor
+
+    def __cinit__(self, *args, **kwargs):
+        self.reactor = <CxxReactor*>(self.rbase)
+
+    def insert(self, _SolutionBase solution):
+        ReactorBase.insert(self, solution)
+        self.reactor.setKineticsMgr(deref(solution.kinetics))
+
+
+cdef class Wall:
+    def __cinit__(self, *args, **kwargs):
+        self.wall = new CxxWall()
+
+    def __init__(self, *args, **kwargs):
+        self._expansionRateCoeff = 0.0
+
+    def install(self, ReactorBase left, ReactorBase right):
+        self.wall.install(deref(left.rbase), deref(right.rbase))
+
+    property expansionRateCoeff:
+        def __get__(self):
+            return self._expansionRateCoeff
+        def __set__(self, double val):
+            self._expansionRateCoeff = val
+            self.wall.setExpansionRateCoeff(val)
+
+    property area:
+        def __get__(self):
+            return self.wall.area()
+        def __set__(self, double value):
+            self.wall.setArea(value)
+
+cdef class ReactorNet:
+    cdef CxxReactorNet* net
+    def __cinit__(self, *args, **kwargs):
+        self.net = new CxxReactorNet()
+
+    def addReactor(self, ReactorBase r):
+        self.net.addReactor(r.rbase)
+
+    def initialize(self, double t=0.0):
+        self.net.initialize(t)
+
+    def advance(self, double t):
+        self.net.advance(t)
+
+    def step(self, double t):
+        return self.net.step(t)