def _write_table(self, var_type, var_data, hierarchical, print_arrays,
out_stream):
"""
Write table of variable names, values, residuals, and metadata to out_stream.
Parameters
----------
var_type : 'input', 'explicit' or 'implicit'
Indicates type of variables, input or explicit/implicit output.
var_data : list
List of (name, dict of vals and metadata) tuples.
hierarchical : bool
When True, human readable output shows variables in hierarchical format.
print_arrays : bool
When False, in the columnar display, just display norm of any ndarrays with size > 1.
The norm is surrounded by vertical bars to indicate that it is a norm.
When True, also display full values of the ndarray below the row. Format is affected
by the values set with numpy.set_printoptions
Default is False.
out_stream : file-like object
Where to send human readable output.
Set to None to suppress.
"""
if out_stream is None:
return
# Make a dict of variables. Makes it easier to work with in this method
var_dict = OrderedDict()
for name, vals in var_data:
var_dict[name] = vals
# determine pathname of the system
if self.source in ('root', 'driver', 'problem',
'root.nonlinear_solver'):
pathname = ''
elif '|' in self.source:
pathname = get_source_system(self.source)
else:
pathname = self.source.replace('root.', '')
if pathname.endswith('.nonlinear_solver'):
pathname = pathname[:-17] # len('.nonlinear_solver') == 17
# vars should be in execution order
if 'execution_order' in self._var_info:
var_order = self._var_info['execution_order']
var_list = [
var_name for var_name in var_order if var_name in var_dict
]
else:
# don't have execution order, just sort for determinism
var_list = sorted(var_dict.keys())
write_var_table(pathname,
var_list,
var_type,
var_dict,
hierarchical=hierarchical,
top_name='model',
print_arrays=print_arrays,
out_stream=out_stream)
def _get_source(self, iteration_coordinate):
"""
Get pathname of solver that is the source of the iteration.
Parameters
----------
iteration_coordinate : str
The full unique identifier for this iteration.
Returns
-------
str
The pathname of the solver that is the source of the iteration.
"""
source_system = get_source_system(iteration_coordinate)
system_solve = source_system.split('.')[-1] + '._solve_nonlinear'
system_coord_len = iteration_coordinate.index(system_solve) + len(
system_solve)
system_coord_nodes = len(
iteration_coordinate[:system_coord_len].split('|')) + 1
iter_coord_nodes = len(iteration_coordinate.split('|'))
if iter_coord_nodes == system_coord_nodes + 2:
return source_system + '.nonlinear_solver'
elif iter_coord_nodes == system_coord_nodes + 4:
return source_system + '.nonlinear_solver.linesearch'
else:
raise RuntimeError("Can't parse solver iteration coordinate: %s" %
iteration_coordinate)
def get_cases(self, source=None, recurse=False, flat=False):
"""
Get list of case names for cases in the table.
Parameters
----------
source : str, optional
If not None, only cases that have the specified source will be returned
recurse : bool, optional
If True, will enable iterating over all successors in case hierarchy
flat : bool, optional
If False and there are child cases, then a nested ordered dictionary
is returned rather than an iterator.
Returns
-------
list or dict
The cases from the table that have the specified source.
"""
if self._keys is None:
self.list_cases()
if not source:
# return all cases
return [self.get_case(key) for key in self._keys]
elif '|' in source:
# source is a coordinate
if recurse and not flat:
cases = OrderedDict()
for key in self._keys:
if len(key) > len(source) and key.startswith(source):
cases[key] = self.get_cases(key, recurse, flat)
return cases
else:
return list([
self.get_case(key) for key in self._keys
if key.startswith(source)
])
else:
# source is a system or solver
if recurse:
if flat:
# return all cases under the source system
source_sys = source.replace('.nonlinear_solver', '')
return list([
self.get_case(key) for key in self._keys
if get_source_system(key).startswith(source_sys)
])
else:
cases = OrderedDict()
for key in self._keys:
case_source = self._get_source(key)
if case_source == source:
cases[key] = self.get_cases(key, recurse, flat)
return cases
else:
return [
self.get_case(key) for key in self._keys
if self._get_source(key) == source
]
def _get_source(self, iteration_coordinate):
"""
Get the source of the iteration.
Parameters
----------
iteration_coordinate : str
The full unique identifier for this iteration.
Returns
-------
str
The source of the iteration.
"""
return get_source_system(iteration_coordinate)