Merge 6a794f1 into a4a0eea

openmdao/core/problem.py

@@ -116,6 +116,8 @@ class Problem(object):
         A flag to indicate whether the system options for all the systems have been recorded
     _metadata : dict
         Problem level metadata.
+    _run_counter : int
+        The number of times run_driver or run_model has been called.
     """
 
     def __init__(self, model=None, driver=None, comm=None, name=None, **options):
@@ -169,6 +171,7 @@ def __init__(self, model=None, driver=None, comm=None, name=None, **options):
         self._initial_condition_cache = {}
 
         self._metadata = None
+        self._run_counter = 0
         self._system_options_recorded = False
         self._rec_mgr = RecordingManager()
 
@@ -597,6 +600,9 @@ def run_model(self, case_prefix=None, reset_iter_counts=True):
             self.driver.iter_count = 0
             self.model._reset_iter_counts()
 
+        if self._setup_already_called:
+            self._run_counter += 1
+
         self.final_setup()
         self.model._clear_iprint()
         self.model.run_solve_nonlinear()
@@ -633,6 +639,9 @@ def run_driver(self, case_prefix=None, reset_iter_counts=True):
             self.driver.iter_count = 0
             self.model._reset_iter_counts()
 
+        if self._setup_already_called:
+            self._run_counter += 1
+
         self.final_setup()
         self.model._clear_iprint()
         return self.driver.run()
@@ -831,6 +840,12 @@ def setup(self, check=False, logger=None, mode='auto', force_alloc_complex=False
         model = self.model
         comm = self.comm
 
+        self._setup_already_called = False
+
+        if hasattr(self, '_metadata') and self._metadata is not None:
+            if self._metadata['setup_status'] == _SetupStatus.POST_FINAL_SETUP:
+                self._setup_already_called = True
+
         # PETScVector is required for MPI
         if comm.size > 1:
             if PETScVector is None:

openmdao/recorders/base_case_reader.py

@@ -17,7 +17,7 @@ class BaseCaseReader(object):
         Metadata about the problem, including the system hierachy and connections.
     solver_metadata : dict
         The solver options for each solver in the recorded model.
-    system_options : dict
+    _system_options : dict
         Metadata about each system in the recorded model, including options and scaling factors.
     """
 
@@ -35,7 +35,7 @@ def __init__(self, filename, pre_load=False):
         self._format_version = None
         self.problem_metadata = {}
         self.solver_metadata = {}
-        self.system_options = {}
+        self._system_options = {}
 
     @property
     def system_metadata(self):
@@ -45,11 +45,11 @@ def system_metadata(self):
         Returns
         -------
         dict
-            reference to the 'system_options' attribute.
+            reference to the '_system_options' attribute.
         """
         warn_deprecation("The BaseCaseReader.system_metadata attribute is deprecated. "
                          "Use the BaseCaseReader.system_option attribute instead.")
-        return self.system_options
+        return self._system_options
 
     def get_cases(self, source, recurse=True, flat=False):
         """

openmdao/recorders/recording_manager.py

@@ -270,4 +270,7 @@ def record_system_options(problem):
 
         for recorder in recorders:
             for sub in problem.model.system_iter(recurse=True, include_self=True):
-                recorder.record_metadata_system(sub)
+                if hasattr(problem, "_run_counter"):
+                    recorder.record_metadata_system(sub, problem._run_counter)
+                else:
+                    recorder.record_metadata_system(sub)

openmdao/recorders/sqlite_reader.py

@@ -262,10 +262,10 @@ def _collect_system_metadata(self, cur):
         cur.execute("SELECT id, scaling_factors, component_metadata FROM system_metadata")
         for row in cur:
             id = row[0]
-            self.system_options[id] = {}
+            self._system_options[id] = {}
 
-            self.system_options[id]['scaling_factors'] = pickle.loads(row[1])
-            self.system_options[id]['component_options'] = pickle.loads(row[2])
+            self._system_options[id]['scaling_factors'] = pickle.loads(row[1])
+            self._system_options[id]['component_options'] = pickle.loads(row[2])
 
     def _collect_solver_metadata(self, cur):
         """
@@ -409,6 +409,48 @@ def list_source_vars(self, source, out_stream=_DEFAULT_OUT_STREAM):
 
         return dct
 
+    def list_model_options(self, run_counter=None, out_stream=_DEFAULT_OUT_STREAM):
+        """
+        List of all model options.
+
+        Parameters
+        ----------
+        run_counter : int or None
+            Run_driver or run_model iteration to inspect
+        out_stream : file-like object
+            Where to send human readable output. Default is sys.stdout.
+            Set to None to suppress.
+
+        Returns
+        -------
+        dict
+            {'root':{key val}}
+        """
+        if out_stream:
+            if out_stream is _DEFAULT_OUT_STREAM:
+                out_stream = sys.stdout
+
+            dct = {}
+
+            for i in self._system_options:
+                subsys, num = i.rsplit('_', 1)
+
+                if (run_counter is not None and run_counter == int(num) and subsys == 'root') or \
+                        (subsys == 'root' and run_counter is None):
+
+                    out_stream.write(
+                        'Run Number: {}\n    Subsystem: {}'.format(num, subsys))
+
+                    for j in self._system_options[i]['component_options']:
+                        option = "{0} : {1}".format(
+                            j, self._system_options[i]['component_options'][j])
+                        out_stream.write('\n        {}\n'.format(option))
+
+                        dct[subsys] = {}
+                        dct[subsys][j] = self._system_options[i]['component_options'][j]
+
+        return dct
+
     def list_cases(self, source=None, recurse=True, flat=True, out_stream=_DEFAULT_OUT_STREAM):
         """
         Iterate over Driver, Solver and System cases in order.

openmdao/recorders/sqlite_recorder.py

@@ -622,16 +622,21 @@ def record_viewer_data(self, model_viewer_data, key='Driver'):
             except sqlite3.IntegrityError:
                 print("Model viewer data has already has already been recorded for %s." % key)
 
-    def record_metadata_system(self, recording_requester):
+    def record_metadata_system(self, recording_requester, run_counter=None):
         """
         Record system metadata.
 
         Parameters
         ----------
         recording_requester : System
             The System that would like to record its metadata.
+        run_counter : int or None
+            The number of times run_driver or run_model has been called.
         """
         if self.connection:
+            if run_counter is None:
+                run_counter = self._counter
+
             scaling_vecs, user_options = self._get_metadata_system(recording_requester)
 
             if scaling_vecs is None:
@@ -666,7 +671,8 @@ def record_metadata_system(self, recording_requester):
             with self.connection as c:
                 c.execute("INSERT OR IGNORE INTO system_metadata"
                           "(id, scaling_factors, component_metadata) "
-                          "VALUES(?,?,?)", (path, scaling_factors, pickled_metadata))
+                          "VALUES(?,?,?)", ("{}_{}".format(path, str(run_counter)), scaling_factors,
+                                            pickled_metadata))
 
     def record_metadata_solver(self, recording_requester):
         """

openmdao/recorders/tests/test_sqlite_reader.py

@@ -2005,7 +2005,7 @@ def test_system_options_pickle_fail(self):
 
         prob.cleanup()
         cr = om.CaseReader(self.filename)
-        subs_options = cr.system_options['subs']['component_options']
+        subs_options = cr._system_options['subs_0']['component_options']
 
         # no options should have been recorded for d1
         self.assertEqual(len(subs_options._dict), 0)
@@ -2041,8 +2041,8 @@ def test_pre_load(self):
 
         self.assertEqual(cr._format_version, format_version)
 
-        self.assertEqual(set(cr.system_options.keys()),
-                         set(['root'] + [sys.name for sys in prob.model._subsystems_allprocs]))
+        self.assertEqual(set(cr._system_options.keys()),
+                         set(['root_0'] + [sys.name + '_0' for sys in prob.model._subsystems_allprocs]))
 
         self.assertEqual(set(cr.problem_metadata.keys()), {
             'tree', 'sys_pathnames_list', 'connections_list', 'variables', 'abs2prom',
@@ -2069,8 +2069,8 @@ def test_pre_load(self):
 
         self.assertEqual(cr._format_version, format_version)
 
-        self.assertEqual(set(cr.system_options.keys()),
-                         set(['root'] + [sys.name for sys in prob.model._subsystems_allprocs]))
+        self.assertEqual(set(cr._system_options.keys()),
+                         set(['root_0'] + [sys.name + '_0' for sys in prob.model._subsystems_allprocs]))
 
         self.assertEqual(set(cr.problem_metadata.keys()), {
             'tree', 'sys_pathnames_list', 'connections_list', 'variables', 'abs2prom',