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)