Fix snapshot

armi/bookkeeping/db/database3.py

@@ -119,7 +119,8 @@ class Database3:
     `doc/user/outputs/database` for more details.
     """
 
-    timeNodeGroupPattern = re.compile(r"^c(\d\d)n(\d\d)$")
+    # Allows matching for, e.g., c01n02EOL
+    timeNodeGroupPattern = re.compile(r"^c(\d\d)n(\d\d).*$")
 
     def __init__(self, fileName: os.PathLike, permission: str):
         """

armi/bookkeeping/db/databaseInterface.py

@@ -176,6 +176,10 @@ def interactEOL(self):
         # is necessary, too.
         self.r.core.p.minutesSinceStart = (time.time() - self.r.core.timeOfStart) / 60.0
         self._db.writeToDB(self.r, "EOL")
+        self.closeDB()
+
+    def closeDB(self):
+        """Close the DB, writing to file."""
         self._db.close(True)
 
     def interactError(self):

armi/operators/operator.py

@@ -654,7 +654,7 @@ def interactAllEOC(self, cycle, excludedInterfaceNames=()):
         activeInterfaces = self.getActiveInterfaces("EOC", excludedInterfaceNames)
         self._interactAll("EOC", activeInterfaces, cycle)
 
-    def interactAllEOL(self):
+    def interactAllEOL(self, excludedInterfaceNames=()):
         """
         Run interactEOL for all enabled interfaces.
 
@@ -665,7 +665,7 @@ def interactAllEOL(self):
         order. This allows, for example, an interface that must run
         first to also run last.
         """
-        activeInterfaces = self.getActiveInterfaces("EOL")
+        activeInterfaces = self.getActiveInterfaces("EOL", excludedInterfaceNames)
         self._interactAll("EOL", activeInterfaces)
 
     def interactAllCoupled(self, coupledIteration):
@@ -1024,7 +1024,7 @@ def getActiveInterfaces(
 
         # Ensure the name of the interface isn't in some exclusion list.
         nameCheck = lambda i: True
-        if interactState == "EveryNode" or interactState == "EOC":
+        if interactState in ("EveryNode", "EOC", "EOL"):
             nameCheck = lambda i: i.name not in excludedInterfaceNames
         elif interactState == "BOC" and cycle < self.cs[CONF_DEFERRED_INTERFACES_CYCLE]:
             nameCheck = lambda i: i.name not in self.cs[CONF_DEFERRED_INTERFACE_NAMES]

armi/operators/snapshots.py

@@ -62,8 +62,8 @@ def _mainOperate(self):
 
         # update the snapshot requests if the user chose to load from a specific cycle/node
         dbi = self.getInterface("database")
-
-        lastTimeStep = snapshots[-1]
+        # database is excluded since SS writes by itself
+        excludeDB = ("database",)
         for ssCycle, ssNode in snapshots:
             runLog.important(
                 "Beginning snapshot ({0:02d}, {1:02d})".format(ssCycle, ssNode)
@@ -79,18 +79,17 @@ def _mainOperate(self):
             if halt:
                 break
 
-            # database is excluded since it writes at EOC
-            self.interactAllEveryNode(
-                ssCycle, ssNode, excludedInterfaceNames=("database",)
-            )
+            # database is excluded since it writes after coupled
+            self.interactAllEveryNode(ssCycle, ssNode, excludedInterfaceNames=excludeDB)
             self._performTightCoupling(ssCycle, ssNode, writeDB=False)
+            # tight coupling is done, now write to DB
+            dbi.writeDBEveryNode()
 
-            # database is excluded at last snapshot since it writes at EOL
-            exclude = ("database",) if (ssCycle, ssNode) == lastTimeStep else ()
-            self.interactAllEOC(self.r.p.cycle, excludedInterfaceNames=exclude)
+            self.interactAllEOC(self.r.p.cycle)
 
         # run things that happen at EOL, like reports, plotters, etc.
-        self.interactAllEOL()
+        self.interactAllEOL(excludedInterfaceNames=excludeDB)
+        dbi.closeDB()  # dump the database to file
         runLog.important("Done with ARMI snapshots case.")
 
     @staticmethod

armi/operators/tests/test_operatorSnapshots.py

@@ -42,6 +42,8 @@ def setUp(self):
         # mock a Database Interface
         self.dbi = DatabaseInterface(self.r, o1.cs)
         self.dbi.loadState = lambda c, n: None
+        self.dbi.writeDBEveryNode = lambda: None
+        self.dbi.closeDB = lambda: None
 
     def test_atEOL(self):
         self.assertFalse(self.o.atEOL)