[Reactor] finalize and add unit tests

Author: ischoegl

include/cantera/zeroD/ReactorNet.h

@@ -31,7 +31,6 @@ class ReactorNet : public FuncEval
     //! @name Methods to set up a simulation.
     //@{
 
-
     //! Set initial time. Default = 0.0 s. Restarts integration from this time
     //! using the current mixture state as the initial condition.
     void setInitialTime(double time);

interfaces/cython/cantera/_cantera.pxd

@@ -620,7 +620,7 @@ cdef extern from "cantera/zerodim.h" namespace "Cantera":
     cdef cppclass CxxReactorNet "Cantera::ReactorNet":
         CxxReactorNet()
         void addReactor(CxxReactor&)
-        string toYAML()
+        string toYAML() except +translate_exception
         double advance(double, cbool) except +translate_exception
         double step() except +translate_exception
         void initialize() except +translate_exception

interfaces/cython/cantera/reactor.pyx

@@ -7,6 +7,18 @@ import numbers as _numbers
 
 _reactor_counts = _defaultdict(int)
 
+
+def _unique_name(name, class_type):
+    """Generate a unique name."""
+
+    if name is not None:
+        return name
+    else:
+        _reactor_counts[class_type] += 1
+        n = _reactor_counts[class_type]
+        return '{0}_{1}'.format(class_type, n)
+
+
 # Need a pure-python class to store weakrefs to
 class _WeakrefProxy:
     pass
@@ -28,12 +40,7 @@ cdef class ReactorBase:
         if isinstance(contents, ThermoPhase):
             self.insert(contents)
 
-        if name is not None:
-            self.name = name
-        else:
-            _reactor_counts[self.reactor_type] += 1
-            n = _reactor_counts[self.reactor_type]
-            self.name = '{0}_{1}'.format(self.reactor_type, n)
+        self.name = _unique_name(name, self.type)
 
         if volume is not None:
             self.volume = volume
@@ -419,12 +426,7 @@ cdef class ReactorSurface:
         if A is not None:
             self.area = A
 
-        if name is not None:
-            self.name = name
-        else:
-            _reactor_counts[self.__class__.__name__] += 1
-            n = _reactor_counts[self.__class__.__name__]
-            self.name = '{0}_{1}'.format(self.__class__.__name__, n)
+        self.name = _unique_name(name, self.type)
 
     property type:
         """The type of the reactor."""
@@ -537,12 +539,7 @@ cdef class WallBase:
 
         self._install(left, right)
 
-        if name is not None:
-            self.name = name
-        else:
-            _reactor_counts[self.__class__.__name__] += 1
-            n = _reactor_counts[self.__class__.__name__]
-            self.name = '{0}_{1}'.format(self.__class__.__name__, n)
+        self.name = _unique_name(name, self.type)
 
         if A is not None:
             self.area = A
@@ -720,12 +717,7 @@ cdef class FlowDevice:
         assert self.dev != NULL
         self._rate_func = None
 
-        if name is not None:
-            self.name = name
-        else:
-            _reactor_counts[self.__class__.__name__] += 1
-            n = _reactor_counts[self.__class__.__name__]
-            self.name = '{0}_{1}'.format(self.__class__.__name__, n)
+        self.name = _unique_name(name, self.type)
 
         self._install(upstream, downstream)
 
@@ -1062,9 +1054,19 @@ cdef class ReactorNet:
         self.net.addReactor(deref(r.reactor))
 
     def to_yaml(self):
-        """Return a YAML representation of the ReactorNet setup."""
+        """
+        Return a YAML representation of the ReactorNet structure. To
+        print the structure to the terminal, simply call the ReactorNet object.
+        The following two statements are equivalent for the sim object::
+
+        >>> sim()
+        >>> print(sim.to_yaml())
+        """
         return pystr(self.net.toYAML())
 
+    def __call__(self):
+        print(self.to_yaml())
+
     def advance(self, double t, pybool apply_limit=True):
         """
         Advance the state of the reactor network in time from the current time

interfaces/cython/cantera/test/test_reactor.py

@@ -5,6 +5,7 @@
 
 import numpy as np
 from .utilities import unittest
+from ruamel.yaml import YAML
 
 import cantera as ct
 from . import utilities
@@ -391,6 +392,43 @@ def v(t):
         self.assertNear(self.r1.volume, V1 + 1.0 * A, 1e-7)
         self.assertNear(self.r2.volume, V2 - 1.0 * A, 1e-7)
 
+    def test_yaml(self, **kwargs):
+        self.make_reactors()
+        self.add_wall()
+        reservoir = ct.Reservoir(self.gas1)
+        mfc = ct.MassFlowController(reservoir, self.r1)
+
+        self.assertTrue(isinstance(self.net.to_yaml(), str))
+        self.assertTrue(isinstance(self.r1.to_yaml(), str))
+        self.assertTrue(isinstance(self.r2.to_yaml(), str))
+        self.assertTrue(isinstance(self.w.to_yaml(), str))
+        self.assertTrue(isinstance(reservoir.to_yaml(), str))
+        self.assertTrue(isinstance(mfc.to_yaml(), str))
+
+        yaml = YAML()
+        yml = yaml.load(self.net.to_yaml())
+        self.assertTrue('ReactorNet' in yml)
+        net = yml['ReactorNet']
+
+        self.assertTrue('ReactorBase' in net)
+        reactors = [tuple(n)[0] for n in net['ReactorBase']]
+        self.assertTrue(self.r1.name in reactors)
+        self.assertTrue(self.r2.name in reactors)
+        self.assertTrue(reservoir.name in reactors)
+
+        self.assertTrue('WallBase' in net)
+        walls = [tuple(n)[0] for n in net['WallBase']]
+        self.assertTrue(self.w.name in walls)
+
+        self.assertTrue('FlowDevice' in net)
+        devices = [tuple(n)[0] for n in net['FlowDevice']]
+        self.assertTrue(mfc.name in devices)
+
+        self.r2.name = self.r1.name
+        with self.assertRaisesRegex(ct.CanteraError, 'names are not unique'):
+            # reactor names need to be unique
+            self.net.to_yaml()
+
     def test_disable_energy(self):
         self.make_reactors(T1=500)
         self.r1.energy_enabled = False

src/zeroD/ReactorNet.cpp

@@ -42,6 +42,7 @@ std::string ReactorNet::toYAML() const
 {
     YAML::Emitter yml;
     std::stringstream out;
+    std::map<std::string, std::string> names;
 
     // components: maps use generic pointers
     std::map<std::string, ReactorBase* > reactors;
@@ -109,39 +110,62 @@ std::string ReactorNet::toYAML() const
     yml << YAML::Key << "ReactorBase";
     yml << YAML::Value << YAML::BeginSeq;
     for (const auto& r : reactors) {
+        names.emplace(r.second->name(), r.first);
         yml << YAML::Load(r.second->toYAML());
     }
     yml << YAML::EndSeq;
+    if (names.size()!=reactors.size()) {
+        // this should raise a warning, but an applicable warning system is not in place
+        throw CanteraError("ReactorNet::toYAML", "ReactorBase names are not unique.");
+    }
 
     // emit list of walls
+    names.clear();
     if (walls.size()) {
         yml << YAML::Key << "WallBase";
         yml << YAML::Value << YAML::BeginSeq;
         for (const auto& w : walls) {
+            names.emplace(w.second->name(), w.first);
             yml << YAML::Load(w.second->toYAML());
         }
         yml << YAML::EndSeq;
     }
+    if (names.size()!=walls.size()) {
+        // this should raise a warning, but an applicable warning system is not in place
+        throw CanteraError("ReactorNet::toYAML", "Wall names are not unique.");
+    }
 
     // emit list of flow devices
+    names.clear();
     if (devices.size()) {
         yml << YAML::Key << "FlowDevice";
         yml << YAML::Value << YAML::BeginSeq;
         for (const auto& d : devices) {
+            names.emplace(d.second->name(), d.first);
             yml << YAML::Load(d.second->toYAML());
         }
         yml << YAML::EndSeq;
     }
+    if (names.size()!=devices.size()) {
+        // this should raise a warning, but an applicable warning system is not in place
+        throw CanteraError("ReactorNet::toYAML", "FlowDevice names are not unique.");
+    }
 
     // emit list of reactor surfaces
+    names.clear();
     if (surfaces.size()) {
         yml << YAML::Key << "ReactorSurface";
         yml << YAML::Value << YAML::BeginSeq;
         for (const auto& s : surfaces) {
+            names.emplace(s.second->name(), s.first);
             yml << YAML::Load(s.second->toYAML());
         }
         yml << YAML::EndSeq;
     }
+    if (names.size()!=surfaces.size()) {
+        // this should raise a warning, but an applicable warning system is not in place
+        throw CanteraError("ReactorNet::toYAML", "ReactorSurface names are not unique.");
+    }
 
     // close out
     yml << YAML::EndMap;