def record_metadata_system(self, recording_requester): """ Record system metadata. Parameters ---------- recording_requester : System The System that would like to record its metadata. """ if self.connection: # Cannot handle PETScVector yet from openmdao.api import PETScVector if PETScVector and isinstance(recording_requester._outputs, PETScVector): return # Cannot handle PETScVector yet # collect scaling arrays scaling_vecs = {} for kind, odict in iteritems(recording_requester._vectors): scaling_vecs[kind] = scaling = {} for vecname, vec in iteritems(odict): scaling[vecname] = vec._scaling scaling_factors = pickle.dumps(scaling_vecs, self._pickle_version) # create a copy of the system's metadata excluding what is in 'options_excludes' user_options = OptionsDictionary() excludes = recording_requester.recording_options[ 'options_excludes'] for key in recording_requester.options._dict: if check_path(key, [], excludes, True): user_options._dict[ key] = recording_requester.options._dict[key] user_options._read_only = recording_requester.options._read_only # try to pickle the metadata, report if it failed try: pickled_metadata = pickle.dumps(user_options, self._pickle_version) except Exception: pickled_metadata = pickle.dumps(OptionsDictionary(), self._pickle_version) warnings.warn( "Trying to record options which cannot be pickled " "on system with name: %s. Use the 'options_excludes' " "recording option on system objects to avoid attempting " "to record options which cannot be pickled. Skipping " "recording options for this system." % recording_requester.name, RuntimeWarning) path = recording_requester.pathname if not path: path = 'root' scaling_factors = sqlite3.Binary(scaling_factors) pickled_metadata = sqlite3.Binary(pickled_metadata) with self.connection as c: c.execute( "INSERT INTO system_metadata(id, scaling_factors, component_metadata) " "VALUES(?,?,?)", (path, scaling_factors, pickled_metadata))
def __init__(self, grid, values, interp, **kwargs): """ Initialize table and subtables. Parameters ---------- grid : tuple(ndarray) Tuple containing ndarray of x grid locations for each table dimension. values : ndarray Array containing the values at all points in grid. interp : class Interpolation class to be used for subsequent table dimensions. **kwargs : dict Interpolator-specific options to pass onward. """ self.options = OptionsDictionary(parent_name=type(self).__name__) self.initialize() self.options.update(kwargs) self.subtable = None self.grid = grid[0] self.values = values if len(grid) > 1: self.subtable = interp(grid[1:], values, interp, **kwargs) self.last_index = 0 self.k = None self._name = None self._vectorized = False self.training_data_gradients = False self._full_slice = None
def _get_metadata_system(self, system): # Cannot handle PETScVector yet from openmdao.api import PETScVector if PETScVector and isinstance(system._outputs, PETScVector): return None, None # Cannot handle PETScVector yet # collect scaling arrays scaling_vecs = {} for kind, odict in system._vectors.items(): scaling_vecs[kind] = scaling = {} for vecname, vec in odict.items(): scaling[vecname] = vec._scaling # create a copy of the system's metadata excluding what is in 'options_excludes' excludes = system.recording_options['options_excludes'] if excludes: user_options = OptionsDictionary() user_options._all_recordable = system.options._all_recordable for key in system.options._dict: if check_path(key, [], excludes, True): user_options._dict[key] = system.options._dict[key] user_options._read_only = system.options._read_only return scaling_vecs, user_options else: return scaling_vecs, system.options
def __init__(self, grid, values, interp=None, **kwargs): """ Initialize table and subtables. """ self.options = OptionsDictionary(parent_name=type(self).__name__) self.initialize() self.options.update(kwargs) self._vectorized = True interp_method = self.options['interp_method'] self._name = interp_method self._full_slice = None self.grid = grid self.values = values # InterpScipy supports automatic order reduction. self._ki = [] # Order is the number of required points minus one. k = SCIPY_ORDERS[interp_method] - 1 for p in grid: n_p = len(p) self._ki.append(k) if n_p <= k: self._ki[-1] = n_p - 1
def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict options dictionary. """ self._system = None self._depth = 0 self._vec_names = None self._mode = 'fwd' self._iter_count = 0 self.options = OptionsDictionary() self.recording_options = OptionsDictionary() self.options.declare('maxiter', types=int, default=10, desc='maximum number of iterations') self.options.declare('atol', default=1e-10, desc='absolute error tolerance') self.options.declare('rtol', default=1e-10, desc='relative error tolerance') self.options.declare('iprint', types=int, default=1, desc='whether to print output') self.options.declare('err_on_maxiter', types=bool, default=False, desc="When True, AnalysisError will be raised if we don't converge.") # Case recording options self.recording_options.declare('record_abs_error', types=bool, default=True, desc='Set to True to record absolute error at the \ solver level') self.recording_options.declare('record_rel_error', types=bool, default=True, desc='Set to True to record relative error at the \ solver level') self.recording_options.declare('record_solver_residuals', types=bool, default=False, desc='Set to True to record residuals at the solver level') self.recording_options.declare('record_metadata', types=bool, desc='Record metadata', default=True) self.recording_options.declare('includes', types=list, default=['*'], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') # Case recording related self._filtered_vars_to_record = {} self._norm0 = 0.0 # What the solver supports. self.supports = OptionsDictionary() self.supports.declare('gradients', types=bool, default=False) self._declare_options() self.options.update(kwargs) self.metadata = {} self._rec_mgr = RecordingManager() self.cite = ""
def __init__(self, **kwargs): """ Initialize all attributes. """ self.trained = False self.options = OptionsDictionary(parent_name=type(self).__name__) self._declare_options() self.options.update(kwargs)
def _declare_dynamic_parameter(self, name, targets, shape=None, units=None): """ Declare an input to the ODE. Parameters ---------- name : str The name of the dynamic parameter. targets : string_types or Iterable or None Paths to inputs in the ODE to which the incoming value of the dynamic parameter needs to be connected. shape : int or tuple or None Shape of the parameter. units : str or None Units of the parameter. """ if name in self._dynamic_parameters: raise ValueError( 'Dynamic parameter {0} has already been declared.'.format( name)) options = OptionsDictionary() options.declare('name', types=string_types) options.declare('targets', default=[], types=Iterable) options.declare('shape', default=(1, ), types=tuple) options.declare('units', default=None, types=string_types, allow_none=True) options['name'] = name if isinstance(targets, string_types): options['targets'] = [targets] elif isinstance(targets, Iterable): options['targets'] = targets elif targets is not None: raise ValueError( 'targets must be of type string_types or Iterable or None') if np.isscalar(shape): options['shape'] = (shape, ) elif isinstance(shape, Iterable): options['shape'] = tuple(shape) elif shape is not None: raise ValueError('shape must be of type int or Iterable or None') if units is not None: options['units'] = units self._dynamic_parameters[name] = options
def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict options dictionary. """ self.trained = False self.options = OptionsDictionary() self._declare_options() self.options.update(kwargs)
def record_metadata_system(self, recording_requester): """ Record system metadata. Parameters ---------- recording_requester : System The System that would like to record its metadata. """ if self.con: # Cannot handle PETScVector yet from openmdao.api import PETScVector if PETScVector and isinstance(recording_requester._outputs, PETScVector): return # Cannot handle PETScVector yet # collect scaling arrays scaling_vecs = {} for kind, odict in iteritems(recording_requester._vectors): scaling_vecs[kind] = scaling = {} for vecname, vec in iteritems(odict): scaling[vecname] = vec._scaling scaling_factors = pickle.dumps(scaling_vecs, self._pickle_version) # create a copy of the system's metadata excluding what is in 'metadata_excludes' user_metadata = OptionsDictionary() excludes = recording_requester.recording_options[ 'metadata_excludes'] for key in recording_requester.options._dict: if check_path(key, [], excludes, True): user_metadata._dict[ key] = recording_requester.options._dict[key] user_metadata._read_only = recording_requester.options._read_only pickled_metadata = pickle.dumps(user_metadata, self._pickle_version) path = recording_requester.pathname if not path: path = 'root' with self.con: self.con.execute( "INSERT INTO system_metadata(id, scaling_factors, component_metadata) \ VALUES(?,?, ?)", (path, sqlite3.Binary(scaling_factors), sqlite3.Binary(pickled_metadata)))
def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict options dictionary. """ self._system = None self._depth = 0 self._vec_names = None self._mode = 'fwd' self._iter_count = 0 self.options = OptionsDictionary() self.options.declare('maxiter', type_=int, default=10, desc='maximum number of iterations') self.options.declare('atol', default=1e-10, desc='absolute error tolerance') self.options.declare('rtol', default=1e-10, desc='relative error tolerance') self.options.declare('iprint', type_=int, default=1, desc='whether to print output') self.options.declare( 'err_on_maxiter', type_=bool, default=False, desc="When True, AnlysisError will be raised if we don't convege.") # What the solver supports. self.supports = OptionsDictionary() self.supports.declare('gradients', type_=bool, default=False) self._declare_options() self.options.update(kwargs) self.metadata = {} self._rec_mgr = RecordingManager()
def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict options dictionary. """ self._system = None self._subjacs = {} self._subjacs_info = {} self.options = OptionsDictionary() self.options.update(kwargs) self._override_checks = False
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: scaling_vecs, user_options = self._get_metadata_system( recording_requester) if scaling_vecs is None: return scaling_factors = pickle.dumps(scaling_vecs, self._pickle_version) # try to pickle the metadata, report if it failed try: pickled_metadata = pickle.dumps(user_options, self._pickle_version) except Exception: try: for key, values in user_options._dict.items(): pickle.dumps(values, self._pickle_version) except Exception: pickled_metadata = pickle.dumps(OptionsDictionary(), self._pickle_version) simple_warning( "Trying to record option '%s' which cannot be pickled on system " "%s. Set 'recordable' to False. Skipping recording options for " "this system." % (key, recording_requester.msginfo)) path = recording_requester.pathname if not path: path = 'root' scaling_factors = sqlite3.Binary(scaling_factors) pickled_metadata = sqlite3.Binary(pickled_metadata) # Need to use OR IGNORE in here because if the user does run_driver more than once # the current OpenMDAO code will call this function each time and there will be # SQL errors for "UNIQUE constraint failed: system_metadata.id" # Future versions of OpenMDAO will handle this better. if run_counter is None: name = path else: name = "{}_{}".format(path, str(run_counter)) with self.connection as c: c.execute( "INSERT OR IGNORE INTO system_metadata" "(id, scaling_factors, component_metadata) " "VALUES(?,?,?)", (name, scaling_factors, pickled_metadata))
def record_metadata_system(self, system, run_number=None): """ Record system metadata. Parameters ---------- system : System The System for which to record metadata. run_number : int or None Number indicating which run the metadata is associated with. None for the first run, 1 for the second, etc. """ if self._record_metadata and self.metadata_connection: scaling_vecs, user_options = self._get_metadata_system(system) if scaling_vecs is None: return scaling_factors = pickle.dumps(scaling_vecs, self._pickle_version) # try to pickle the metadata, report if it failed try: pickled_metadata = pickle.dumps(user_options, self._pickle_version) except Exception: try: for key, values in user_options._dict.items(): pickle.dumps(values, self._pickle_version) except Exception: pickled_metadata = pickle.dumps(OptionsDictionary(), self._pickle_version) msg = f"Trying to record option '{key}' which cannot be pickled on this " \ "system. Set option 'recordable' to False. Skipping recording options " \ "for this system." issue_warning(msg, prefix=system.msginfo, category=CaseRecorderWarning) path = system.pathname if not path: path = 'root' scaling_factors = sqlite3.Binary(zlib.compress(scaling_factors)) pickled_metadata = sqlite3.Binary(zlib.compress(pickled_metadata)) if run_number is None: name = path else: name = META_KEY_SEP.join([path, str(run_number)]) with self.metadata_connection as m: m.execute( "INSERT INTO system_metadata" "(id, scaling_factors, component_metadata) " "VALUES(?,?,?)", (name, scaling_factors, pickled_metadata))
def __init__(self, grid, values, interp, **kwargs): """ Initialize interp algorithm. """ self.options = OptionsDictionary(parent_name=type(self).__name__) self.initialize() self.options.update(kwargs) self.grid = grid self.values = values self.last_index = 0 self.k = None self.dim = None self._name = None self._vectorized = True self._compute_d_dvalues = False self._supports_d_dvalues = False self._compute_d_dx = True
def __init__(self, **kwargs): """ Initialize class attributes. Parameters ---------- kwargs : dict Keyword arguments that will be passed to the initialize method. """ self._system_class = None self._system_init_kwargs = {} time_options = OptionsDictionary() time_options.declare('targets', default=[], types=Iterable) time_options.declare('units', default=None, types=string_types, allow_none=True) self._time_options = time_options self._states = {} self._static_parameters = {} self._dynamic_parameters = {} self.initialize(**kwargs)
def _get_metadata_system(self, recording_requester): # Cannot handle PETScVector yet from openmdao.api import PETScVector if PETScVector and isinstance(recording_requester._outputs, PETScVector): return None, None # Cannot handle PETScVector yet # collect scaling arrays scaling_vecs = {} for kind, odict in iteritems(recording_requester._vectors): scaling_vecs[kind] = scaling = {} for vecname, vec in iteritems(odict): scaling[vecname] = vec._scaling # create a copy of the system's metadata excluding what is in 'options_excludes' user_options = OptionsDictionary() excludes = recording_requester.recording_options['options_excludes'] for key in recording_requester.options._dict: if check_path(key, [], excludes, True): user_options._dict[key] = recording_requester.options._dict[key] user_options._read_only = recording_requester.options._read_only return scaling_vecs, user_options
def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict options dictionary. """ self._system = None self._depth = 0 self._vec_names = None self._mode = 'fwd' self._iter_count = 0 self.options = OptionsDictionary() self.recording_options = OptionsDictionary() self.options.declare('maxiter', types=int, default=10, desc='maximum number of iterations') self.options.declare('atol', default=1e-10, desc='absolute error tolerance') self.options.declare('rtol', default=1e-10, desc='relative error tolerance') self.options.declare('iprint', types=int, default=1, desc='whether to print output') self.options.declare('err_on_maxiter', types=bool, default=False, desc="When True, AnalysisError will be raised if we don't converge.") # Case recording options self.recording_options.declare('record_abs_error', types=bool, default=True, desc='Set to True to record absolute error at the \ solver level') self.recording_options.declare('record_rel_error', types=bool, default=True, desc='Set to True to record relative error at the \ solver level') self.recording_options.declare('record_solver_residuals', types=bool, default=False, desc='Set to True to record residuals at the solver level') self.recording_options.declare('record_metadata', types=bool, desc='Record metadata', default=True) self.recording_options.declare('includes', types=list, default=['*'], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') # Case recording related self._filtered_vars_to_record = {} self._norm0 = 0.0 # What the solver supports. self.supports = OptionsDictionary() self.supports.declare('gradients', types=bool, default=False) self._declare_options() self.options.update(kwargs) self.metadata = {} self._rec_mgr = RecordingManager() self.cite = ""
def __init__(self): """ Initialize the driver. """ self._rec_mgr = RecordingManager() self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None self.options = OptionsDictionary() # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', type_=bool, default=False) self.supports.declare('equality_constraints', type_=bool, default=False) self.supports.declare('linear_constraints', type_=bool, default=False) self.supports.declare('two_sided_constraints', type_=bool, default=False) self.supports.declare('multiple_objectives', type_=bool, default=False) self.supports.declare('integer_design_vars', type_=bool, default=False) self.supports.declare('gradients', type_=bool, default=False) self.supports.declare('active_set', type_=bool, default=False) self.iter_count = 0 self.metadata = None self._model_viewer_data = None # TODO, support these in Openmdao blue self.supports.declare('integer_design_vars', type_=bool, default=False) self.fail = False
def __init__(self, grid, values, interp=None, **kwargs): """ Initialize table and subtables. Parameters ---------- grid : tuple(ndarray) Tuple containing x grid locations for this dimension and all subtable dimensions. values : ndarray Array containing the table values for all dimensions. interp : class Interpolation class to be used for subsequent table dimensions. **kwargs : dict Interpolator-specific options to pass onward. """ self.options = OptionsDictionary(parent_name=type(self).__name__) self.initialize() self.options.update(kwargs) self._vectorized = True interp_method = self.options['interp_method'] self._name = interp_method self._full_slice = None self.grid = grid self.values = values # InterpScipy supports automatic order reduction. self._ki = [] # Order is the number of required points minus one. k = SCIPY_ORDERS[interp_method] - 1 for p in grid: n_p = len(p) self._ki.append(k) if n_p <= k: self._ki[-1] = n_p - 1
def __init__(self, grid, values, interp, **kwargs): """ Initialize table and subtables. """ self.options = OptionsDictionary(parent_name=type(self).__name__) self.initialize() self.options.update(kwargs) self.subtable = None self.grid = grid[0] self.values = values if len(grid) > 1: self.subtable = interp(grid[1:], values, interp, **kwargs) self.last_index = 0 self.k = None self._name = None self._vectorized = False self._compute_d_dvalues = False self._compute_d_dx = True self._full_slice = None
def record_metadata_system(self, recording_requester): """ Record system metadata. Parameters ---------- recording_requester : System The System that would like to record its metadata. """ if self.connection: scaling_vecs, user_options = self._get_metadata_system( recording_requester) if scaling_vecs is None: return scaling_factors = pickle.dumps(scaling_vecs, self._pickle_version) # try to pickle the metadata, report if it failed try: pickled_metadata = pickle.dumps(user_options, self._pickle_version) except Exception: try: for key, values in user_options._dict.items(): pickle.dumps(values, self._pickle_version) except Exception: pickled_metadata = pickle.dumps(OptionsDictionary(), self._pickle_version) simple_warning( "Trying to record option '%s' which cannot be pickled on system " "%s. Set 'recordable' to False. Skipping recording options for " "this system." % (key, recording_requester.msginfo)) path = recording_requester.pathname if not path: path = 'root' scaling_factors = sqlite3.Binary(scaling_factors) pickled_metadata = sqlite3.Binary(pickled_metadata) with self.connection as c: # Because we can have a recorder attached to multiple Systems, # and because we are now recording System metadata recursively, # we can store System metadata multiple times. Need to ignore when that happens # so we don't get database errors. So use OR IGNORE c.execute( "INSERT OR IGNORE INTO system_metadata" "(id, scaling_factors, component_metadata) " "VALUES(?,?,?)", (path, scaling_factors, pickled_metadata))
def record_metadata_system(self, recording_requester): """ Record system metadata. Parameters ---------- recording_requester : System The System that would like to record its metadata. """ if self.connection: scaling_vecs, user_options = self._get_metadata_system( recording_requester) if scaling_vecs is None: return scaling_factors = pickle.dumps(scaling_vecs, self._pickle_version) # try to pickle the metadata, report if it failed try: pickled_metadata = pickle.dumps(user_options, self._pickle_version) except Exception: pickled_metadata = pickle.dumps(OptionsDictionary(), self._pickle_version) simple_warning( "Trying to record options which cannot be pickled " "on system with name: %s. Use the 'options_excludes' " "recording option on system objects to avoid attempting " "to record options which cannot be pickled. Skipping " "recording options for this system." % recording_requester.name, RuntimeWarning) path = recording_requester.pathname if not path: path = 'root' scaling_factors = sqlite3.Binary(scaling_factors) pickled_metadata = sqlite3.Binary(pickled_metadata) with self.connection as c: # Because we can have a recorder attached to multiple Systems, # and because we are now recording System metadata recursively, # we can store System metadata multiple times. Need to ignore when that happens # so we don't get database errors. So use OR IGNORE c.execute( "INSERT OR IGNORE INTO system_metadata" "(id, scaling_factors, component_metadata) " "VALUES(?,?,?)", (path, scaling_factors, pickled_metadata))
def _get_metadata_system(self, recording_requester): # Cannot handle PETScVector yet from openmdao.api import PETScVector if PETScVector and isinstance(recording_requester._outputs, PETScVector): return None, None # Cannot handle PETScVector yet # collect scaling arrays scaling_vecs = {} for kind, odict in iteritems(recording_requester._vectors): scaling_vecs[kind] = scaling = {} for vecname, vec in iteritems(odict): scaling[vecname] = vec._scaling # create a copy of the system's metadata excluding what is in 'options_excludes' user_options = OptionsDictionary() excludes = recording_requester.recording_options['options_excludes'] for key in recording_requester.options._dict: if check_path(key, [], excludes, True): user_options._dict[key] = recording_requester.options._dict[ key] user_options._read_only = recording_requester.options._read_only return scaling_vecs, user_options
class Solver(object): """ Base solver class. This class is subclassed by NonlinearSolver and LinearSolver, which are in turn subclassed by actual solver implementations. Attributes ---------- _system : <System> Pointer to the owning system. _depth : int How many subsolvers deep this solver is (0 means not a subsolver). _vec_names : [str, ...] List of right-hand-side (RHS) vector names. _mode : str 'fwd' or 'rev', applicable to linear solvers only. _iter_count : int Number of iterations for the current invocation of the solver. _rec_mgr : <RecordingManager> object that manages all recorders added to this solver cite : str Listing of relevant citations that should be referenced when publishing work that uses this class. options : <OptionsDictionary> Options dictionary. recording_options : <OptionsDictionary> Recording options dictionary. supports : <OptionsDictionary> Options dictionary describing what features are supported by this solver. _filtered_vars_to_record : Dict Dict of list of var names to record _norm0 : float Normalization factor _problem_meta : dict Problem level metadata. """ # Object to store some formatting for iprint that is shared across all solvers. SOLVER = 'base_solver' def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict of keyword arguments Keyword arguments that will be mapped into the Solver options. """ self._system = None self._depth = 0 self._vec_names = None self._mode = 'fwd' self._iter_count = 0 self._problem_meta = None # Solver options self.options = OptionsDictionary(parent_name=self.msginfo) self.options.declare('maxiter', types=int, default=10, desc='maximum number of iterations') self.options.declare('atol', default=1e-10, desc='absolute error tolerance') self.options.declare('rtol', default=1e-10, desc='relative error tolerance') self.options.declare('iprint', types=int, default=1, desc='whether to print output') self.options.declare( 'err_on_non_converge', types=bool, default=False, desc="When True, AnalysisError will be raised if we don't converge." ) # Case recording options self.recording_options = OptionsDictionary(parent_name=self.msginfo) self.recording_options.declare( 'record_abs_error', types=bool, default=True, desc='Set to True to record absolute error at the \ solver level') self.recording_options.declare( 'record_rel_error', types=bool, default=True, desc='Set to True to record relative error at the \ solver level') self.recording_options.declare( 'record_inputs', types=bool, default=True, desc='Set to True to record inputs at the solver level') self.recording_options.declare( 'record_outputs', types=bool, default=True, desc='Set to True to record outputs at the solver level') self.recording_options.declare( 'record_solver_residuals', types=bool, default=False, desc='Set to True to record residuals at the solver level') self.recording_options.declare( 'record_metadata', types=bool, desc='Deprecated. Recording ' 'of metadata will always be done', deprecation="The recording option, record_metadata, on " "Solver is " "deprecated. Recording of metadata will always be done", default=True) self.recording_options.declare( 'includes', types=list, default=['*'], desc="Patterns for variables to include in recording. \ Paths are relative to solver's Group. \ Uses fnmatch wildcards") self.recording_options.declare( 'excludes', types=list, default=[], desc="Patterns for vars to exclude in recording. \ (processed post-includes) \ Paths are relative to solver's Group. \ Uses fnmatch wildcards") # Case recording related self._filtered_vars_to_record = {} self._norm0 = 0.0 # What the solver supports. self.supports = OptionsDictionary(parent_name=self.msginfo) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('implicit_components', types=bool, default=False) self._declare_options() self.options.update(kwargs) self._rec_mgr = RecordingManager() self.cite = "" @property def msginfo(self): """ Return info to prepend to messages. Returns ------- str Info to prepend to messages. """ if self._system is None: return type(self).__name__ return '{} in {}'.format(type(self).__name__, self._system().msginfo) @property def _recording_iter(self): if self._problem_meta is None: raise RuntimeError( f"{self.msginfo}: Can't access recording_iter because " "_setup_solvers has not been called.") return self._problem_meta['recording_iter'] @property def _solver_info(self): if self._problem_meta is None: raise RuntimeError( f"{self.msginfo}: Can't access solver_info because _setup_solvers " "has not been called.") return self._problem_meta['solver_info'] def _assembled_jac_solver_iter(self): """ Return an empty generator of lin solvers using assembled jacs. """ for i in (): yield def add_recorder(self, recorder): """ Add a recorder to the solver's RecordingManager. Parameters ---------- recorder : <CaseRecorder> A recorder instance to be added to RecManager. """ if MPI: raise RuntimeError( "Recording of Solvers when running parallel code is not supported yet" ) self._rec_mgr.append(recorder) def _declare_options(self): """ Declare options before kwargs are processed in the init method. This is optionally implemented by subclasses of Solver. """ pass def _setup_solvers(self, system, depth): """ Assign system instance, set depth, and optionally perform setup. Parameters ---------- system : <System> pointer to the owning system. depth : int depth of the current system (already incremented). """ self._system = weakref.ref(system) self._depth = depth self._problem_meta = system._problem_meta if system.pathname: parent_name = self.msginfo self.options._parent_name = parent_name self.recording_options._parent_name = parent_name self.supports._parent_name = parent_name if isinstance(self, LinearSolver) and not system._use_derivatives: return self._rec_mgr.startup(self) myoutputs = myresiduals = myinputs = [] incl = self.recording_options['includes'] excl = self.recording_options['excludes'] # doesn't matter if we're a linear or nonlinear solver. The names for # inputs, outputs, and residuals are the same for both the 'linear' and 'nonlinear' # vectors. if system.pathname: incl = ['.'.join((system.pathname, i)) for i in incl] excl = ['.'.join((system.pathname, i)) for i in excl] if self.recording_options['record_solver_residuals']: myresiduals = [ n for n in system._residuals._abs_iter() if check_path(n, incl, excl) ] if self.recording_options['record_outputs']: myoutputs = [ n for n in system._outputs._abs_iter() if check_path(n, incl, excl) ] if self.recording_options['record_inputs']: myinputs = [ n for n in system._inputs._abs_iter() if check_path(n, incl, excl) ] self._filtered_vars_to_record = { 'input': myinputs, 'output': myoutputs, 'residual': myresiduals } def _set_solver_print(self, level=2, type_='all'): """ Control printing for solvers and subsolvers in the model. Parameters ---------- level : int iprint level. Set to 2 to print residuals each iteration; set to 1 to print just the iteration totals; set to 0 to disable all printing except for failures, and set to -1 to disable all printing including failures. type_ : str Type of solver to set: 'LN' for linear, 'NL' for nonlinear, or 'all' for all. """ self.options['iprint'] = level def _mpi_print(self, iteration, abs_res, rel_res): """ Print residuals from an iteration. Parameters ---------- iteration : int iteration counter, 0-based. abs_res : float current absolute residual norm. rel_res : float current relative residual norm. """ if (self.options['iprint'] == 2 and (self._system().comm.rank == 0 or os.environ.get('USE_PROC_FILES'))): prefix = self._solver_info.prefix solver_name = self.SOLVER if prefix.endswith('precon:'): solver_name = solver_name[3:] print_str = prefix + solver_name print_str += ' %d ; %.9g %.9g' % (iteration, abs_res, rel_res) print(print_str) def _mpi_print_header(self): """ Print header text before solving. """ if (self.options['iprint'] > 0 and (self._system().comm.rank == 0 or os.environ.get('USE_PROC_FILES'))): pathname = self._system().pathname if pathname: nchar = len(pathname) prefix = self._solver_info.prefix header = prefix + "\n" header += prefix + nchar * "=" + "\n" header += prefix + pathname + "\n" header += prefix + nchar * "=" print(header) def _iter_initialize(self): """ Perform any necessary pre-processing operations. Returns ------- float initial error. float error at the first iteration. """ pass def _run_apply(self): """ Run the appropriate apply method on the system. """ pass def _linearize(self): """ Perform any required linearization operations such as matrix factorization. """ pass def _linearize_children(self): """ Return a flag that is True when we need to call linearize on our subsystems' solvers. Returns ------- boolean Flag for indicating child linerization """ return True def __str__(self): """ Return a string representation of the solver. Returns ------- str String representation of the solver. """ return self.SOLVER def record_iteration(self, **kwargs): """ Record an iteration of the current Solver. Parameters ---------- **kwargs : dict Keyword arguments (used for abs and rel error). """ if not self._rec_mgr._recorders: return metadata = create_local_meta(self.SOLVER) # Get the data data = { 'abs': kwargs.get('abs') if self.recording_options['record_abs_error'] else None, 'rel': kwargs.get('rel') if self.recording_options['record_rel_error'] else None, 'input': {}, 'output': {}, 'residual': {} } system = self._system() vec_name = 'nonlinear' if isinstance(self, NonlinearSolver) else 'linear' filt = self._filtered_vars_to_record parallel = self._rec_mgr._check_parallel( ) if system.comm.size > 1 else False if self.recording_options['record_outputs']: data['output'] = system._retrieve_data_of_kind( filt, 'output', vec_name, parallel) if self.recording_options['record_inputs']: data['input'] = system._retrieve_data_of_kind( filt, 'input', vec_name, parallel) if self.recording_options['record_solver_residuals']: data['residual'] = system._retrieve_data_of_kind( filt, 'residual', vec_name, parallel) self._rec_mgr.record_iteration(self, data, metadata) def cleanup(self): """ Clean up resources prior to exit. """ # shut down all recorders self._rec_mgr.shutdown() def _set_complex_step_mode(self, active): """ Turn on or off complex stepping mode. Recurses to turn on or off complex stepping mode in all subsystems and their vectors. Parameters ---------- active : bool Complex mode flag; set to True prior to commencing complex step. """ pass def _disallow_distrib_solve(self): """ Raise an exception if our system or any subsystems are distributed or non-local. """ s = self._system() if s.comm.size == 1: return from openmdao.core.group import Group if s._has_distrib_vars or (isinstance(s, Group) and s._contains_parallel_group): msg = "{} linear solver in {} cannot be used in or above a ParallelGroup or a " + \ "distributed component." raise RuntimeError(msg.format(type(self).__name__, s.msginfo))
def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict of keyword arguments Keyword arguments that will be mapped into the Solver options. """ self._system = None self._depth = 0 self._vec_names = None self._mode = 'fwd' self._iter_count = 0 self._problem_meta = None # Solver options self.options = OptionsDictionary(parent_name=self.msginfo) self.options.declare('maxiter', types=int, default=10, desc='maximum number of iterations') self.options.declare('atol', default=1e-10, desc='absolute error tolerance') self.options.declare('rtol', default=1e-10, desc='relative error tolerance') self.options.declare('iprint', types=int, default=1, desc='whether to print output') self.options.declare( 'err_on_non_converge', types=bool, default=False, desc="When True, AnalysisError will be raised if we don't converge." ) # Case recording options self.recording_options = OptionsDictionary(parent_name=self.msginfo) self.recording_options.declare( 'record_abs_error', types=bool, default=True, desc='Set to True to record absolute error at the \ solver level') self.recording_options.declare( 'record_rel_error', types=bool, default=True, desc='Set to True to record relative error at the \ solver level') self.recording_options.declare( 'record_inputs', types=bool, default=True, desc='Set to True to record inputs at the solver level') self.recording_options.declare( 'record_outputs', types=bool, default=True, desc='Set to True to record outputs at the solver level') self.recording_options.declare( 'record_solver_residuals', types=bool, default=False, desc='Set to True to record residuals at the solver level') self.recording_options.declare( 'record_metadata', types=bool, desc='Deprecated. Recording ' 'of metadata will always be done', deprecation="The recording option, record_metadata, on " "Solver is " "deprecated. Recording of metadata will always be done", default=True) self.recording_options.declare( 'includes', types=list, default=['*'], desc="Patterns for variables to include in recording. \ Paths are relative to solver's Group. \ Uses fnmatch wildcards") self.recording_options.declare( 'excludes', types=list, default=[], desc="Patterns for vars to exclude in recording. \ (processed post-includes) \ Paths are relative to solver's Group. \ Uses fnmatch wildcards") # Case recording related self._filtered_vars_to_record = {} self._norm0 = 0.0 # What the solver supports. self.supports = OptionsDictionary(parent_name=self.msginfo) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('implicit_components', types=bool, default=False) self._declare_options() self.options.update(kwargs) self._rec_mgr = RecordingManager() self.cite = ""
class Driver(object): """ Top-level container for the systems and drivers. Attributes ---------- fail : bool Reports whether the driver ran successfully. iter_count : int Keep track of iterations for case recording. options : <OptionsDictionary> Dictionary with general pyoptsparse options. recording_options : <OptionsDictionary> Dictionary with driver recording options. debug_print : <OptionsDictionary> Dictionary with debugging printing options. cite : str Listing of relevant citataions that should be referenced when publishing work that uses this class. _problem : <Problem> Pointer to the containing problem. supports : <OptionsDictionary> Provides a consistant way for drivers to declare what features they support. _designvars : dict Contains all design variable info. _cons : dict Contains all constraint info. _objs : dict Contains all objective info. _responses : dict Contains all response info. _rec_mgr : <RecordingManager> Object that manages all recorders added to this driver. _vars_to_record: dict Dict of lists of var names indicating what to record _model_viewer_data : dict Structure of model, used to make n2 diagram. _remote_dvs : dict Dict of design variables that are remote on at least one proc. Values are (owning rank, size). _remote_cons : dict Dict of constraints that are remote on at least one proc. Values are (owning rank, size). _remote_objs : dict Dict of objectives that are remote on at least one proc. Values are (owning rank, size). _remote_responses : dict A combined dict containing entries from _remote_cons and _remote_objs. _simul_coloring_info : tuple of dicts A data structure describing coloring for simultaneous derivs. _total_jac_sparsity : dict, str, or None Specifies sparsity of sub-jacobians of the total jacobian. Only used by pyOptSparseDriver. _res_jacs : dict Dict of sparse subjacobians for use with certain optimizers, e.g. pyOptSparseDriver. _total_jac : _TotalJacInfo or None Cached total jacobian handling object. """ def __init__(self, **kwargs): """ Initialize the driver. Parameters ---------- **kwargs : dict of keyword arguments Keyword arguments that will be mapped into the Driver options. """ self._rec_mgr = RecordingManager() self._vars_to_record = { 'desvarnames': set(), 'responsenames': set(), 'objectivenames': set(), 'constraintnames': set(), 'sysinclnames': set(), } self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None # Driver options self.options = OptionsDictionary() self.options.declare( 'debug_print', types=list, is_valid=_is_debug_print_opts_valid, desc="List of what type of Driver variables to print at each " "iteration. Valid items in list are 'desvars', 'ln_cons', " "'nl_cons', 'objs'", default=[]) # Case recording options self.recording_options = OptionsDictionary() self.recording_options.declare('record_metadata', types=bool, default=True, desc='Record metadata') self.recording_options.declare( 'record_desvars', types=bool, default=True, desc='Set to True to record design variables at the ' 'driver level') self.recording_options.declare( 'record_responses', types=bool, default=False, desc='Set to True to record responses at the driver level') self.recording_options.declare( 'record_objectives', types=bool, default=True, desc='Set to True to record objectives at the driver level') self.recording_options.declare( 'record_constraints', types=bool, default=True, desc='Set to True to record constraints at the ' 'driver level') self.recording_options.declare( 'includes', types=list, default=['*'], desc='Patterns for variables to include in recording') self.recording_options.declare( 'excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') self.recording_options.declare( 'record_derivatives', types=bool, default=False, desc='Set to True to record derivatives at the driver ' 'level') self.recording_options.declare( 'record_inputs', types=bool, default=True, desc='Set to True to record inputs at the driver level') # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', types=bool, default=False) self.supports.declare('equality_constraints', types=bool, default=False) self.supports.declare('linear_constraints', types=bool, default=False) self.supports.declare('two_sided_constraints', types=bool, default=False) self.supports.declare('multiple_objectives', types=bool, default=False) self.supports.declare('integer_design_vars', types=bool, default=False) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('active_set', types=bool, default=False) self.supports.declare('simultaneous_derivatives', types=bool, default=False) self.supports.declare('total_jac_sparsity', types=bool, default=False) # TODO, support these in OpenMDAO self.supports.declare('integer_design_vars', types=bool, default=False) self.iter_count = 0 self._model_viewer_data = None self.cite = "" self._simul_coloring_info = None self._total_jac_sparsity = None self._res_jacs = {} self._total_jac = None self.fail = False self._declare_options() self.options.update(kwargs) def add_recorder(self, recorder): """ Add a recorder to the driver. Parameters ---------- recorder : BaseRecorder A recorder instance. """ self._rec_mgr.append(recorder) def cleanup(self): """ Clean up resources prior to exit. """ self._rec_mgr.close() def _declare_options(self): """ Declare options before kwargs are processed in the init method. This is optionally implemented by subclasses of Driver. """ pass def _setup_comm(self, comm): """ Perform any driver-specific setup of communicators for the model. Parameters ---------- comm : MPI.Comm or <FakeComm> or None The communicator for the Problem. Returns ------- MPI.Comm or <FakeComm> or None The communicator for the Problem model. """ return comm def _setup_driver(self, problem): """ Prepare the driver for execution. This is the final thing to run during setup. Parameters ---------- problem : <Problem> Pointer to the containing problem. """ self._problem = problem model = problem.model self._total_jac = None self._objs = objs = OrderedDict() self._cons = cons = OrderedDict() self._responses = model.get_responses(recurse=True) response_size = 0 for name, data in iteritems(self._responses): if data['type'] == 'con': cons[name] = data else: objs[name] = data response_size += data['size'] # Gather up the information for design vars. self._designvars = model.get_design_vars(recurse=True) self._has_scaling = ( np.any([r['scaler'] is not None for r in self._responses.values()]) or np.any( [dv['scaler'] is not None for dv in self._designvars.values()])) con_set = set() obj_set = set() dv_set = set() self._remote_dvs = dv_dict = {} self._remote_cons = con_dict = {} self._remote_objs = obj_dict = {} # Now determine if later we'll need to allgather cons, objs, or desvars. if model.comm.size > 1 and model._subsystems_allprocs: local_out_vars = set(model._outputs._views) remote_dvs = set(self._designvars) - local_out_vars remote_cons = set(self._cons) - local_out_vars remote_objs = set(self._objs) - local_out_vars all_remote_vois = model.comm.allgather( (remote_dvs, remote_cons, remote_objs)) for rem_dvs, rem_cons, rem_objs in all_remote_vois: con_set.update(rem_cons) obj_set.update(rem_objs) dv_set.update(rem_dvs) # If we have remote VOIs, pick an owning rank for each and use that # to bcast to others later owning_ranks = model._owning_rank sizes = model._var_sizes['nonlinear']['output'] for i, vname in enumerate(model._var_allprocs_abs_names['output']): owner = owning_ranks[vname] if vname in dv_set: dv_dict[vname] = (owner, sizes[owner, i]) if vname in con_set: con_dict[vname] = (owner, sizes[owner, i]) if vname in obj_set: obj_dict[vname] = (owner, sizes[owner, i]) self._remote_responses = self._remote_cons.copy() self._remote_responses.update(self._remote_objs) # set up case recording self._setup_recording() desvar_size = np.sum(data['size'] for data in itervalues(self._designvars)) # set up simultaneous deriv coloring if (coloring_mod._use_sparsity and self._simul_coloring_info and self.supports['simultaneous_derivatives']): if problem._mode == 'fwd': self._setup_simul_coloring(problem._mode) else: raise RuntimeError( "simultaneous derivs are currently not supported in rev mode." ) # if we're using simultaneous derivatives then our effective design var size is less # than the full design var size if self._simul_coloring_info: col_lists = self._simul_coloring_info[0] if col_lists: desvar_size = len(col_lists[0]) desvar_size += len(col_lists) - 1 if ((problem._mode == 'fwd' and desvar_size > response_size) or (problem._mode == 'rev' and response_size > desvar_size)): warnings.warn( "Inefficient choice of derivative mode. You chose '%s' for a " "problem with %d design variables and %d response variables " "(objectives and constraints)." % (problem._mode, desvar_size, response_size), RuntimeWarning) def _setup_recording(self): """ Set up case recording. """ problem = self._problem model = problem.model mydesvars = myobjectives = myconstraints = myresponses = set() myinputs = set() mysystem_outputs = set() incl = self.recording_options['includes'] excl = self.recording_options['excludes'] rec_desvars = self.recording_options['record_desvars'] rec_objectives = self.recording_options['record_objectives'] rec_constraints = self.recording_options['record_constraints'] rec_responses = self.recording_options['record_responses'] rec_inputs = self.recording_options['record_inputs'] all_desvars = { n for n in self._designvars if check_path(n, incl, excl, True) } all_objectives = { n for n in self._objs if check_path(n, incl, excl, True) } all_constraints = { n for n in self._cons if check_path(n, incl, excl, True) } if rec_desvars: mydesvars = all_desvars if rec_objectives: myobjectives = all_objectives if rec_constraints: myconstraints = all_constraints if rec_responses: myresponses = { n for n in self._responses if check_path(n, incl, excl, True) } # get the includes that were requested for this Driver recording if incl: # The my* variables are sets # First gather all of the desired outputs # The following might only be the local vars if MPI mysystem_outputs = { n for n in model._outputs if check_path(n, incl, excl) } # If MPI, and on rank 0, need to gather up all the variables # even those not local to rank 0 if MPI: all_vars = model.comm.gather(mysystem_outputs, root=0) if MPI.COMM_WORLD.rank == 0: mysystem_outputs = all_vars[-1] for d in all_vars[:-1]: mysystem_outputs.update(d) # de-duplicate mysystem_outputs mysystem_outputs = mysystem_outputs.difference( all_desvars, all_objectives, all_constraints) if rec_inputs: prob = self._problem root = prob.model myinputs = {n for n in root._inputs if check_path(n, incl, excl)} if MPI: all_vars = root.comm.gather(myinputs, root=0) if MPI.COMM_WORLD.rank == 0: myinputs = all_vars[-1] for d in all_vars[:-1]: myinputs.update(d) if MPI: # filter based on who owns the variables # TODO Eventually, we think we can get rid of this next check. But to be safe, # we are leaving it in there. if not model.is_active(): raise RuntimeError( "RecordingManager.startup should never be called when " "running in parallel on an inactive System") rrank = problem.comm.rank rowned = model._owning_rank mydesvars = [n for n in mydesvars if rrank == rowned[n]] myresponses = [n for n in myresponses if rrank == rowned[n]] myobjectives = [n for n in myobjectives if rrank == rowned[n]] myconstraints = [n for n in myconstraints if rrank == rowned[n]] mysystem_outputs = [ n for n in mysystem_outputs if rrank == rowned[n] ] myinputs = [n for n in myinputs if rrank == rowned[n]] self._filtered_vars_to_record = { 'des': mydesvars, 'obj': myobjectives, 'con': myconstraints, 'res': myresponses, 'sys': mysystem_outputs, 'in': myinputs } self._rec_mgr.startup(self) if self._rec_mgr._recorders: from openmdao.devtools.problem_viewer.problem_viewer import _get_viewer_data self._model_viewer_data = _get_viewer_data(problem) if self.recording_options['record_metadata']: self._rec_mgr.record_metadata(self) def _get_voi_val(self, name, meta, remote_vois, unscaled=False, ignore_indices=False): """ Get the value of a variable of interest (objective, constraint, or design var). This will retrieve the value if the VOI is remote. Parameters ---------- name : str Name of the variable of interest. meta : dict Metadata for the variable of interest. remote_vois : dict Dict containing (owning_rank, size) for all remote vois of a particular type (design var, constraint, or objective). unscaled : bool Set to True if unscaled (physical) design variables are desired. ignore_indices : bool Set to True if the full array is desired, not just those indicated by indices. Returns ------- float or ndarray The value of the named variable of interest. """ model = self._problem.model comm = model.comm vec = model._outputs._views_flat indices = meta['indices'] if name in remote_vois: owner, size = remote_vois[name] if owner == comm.rank: if indices is None or ignore_indices: val = vec[name].copy() else: val = vec[name][indices] else: if indices is not None: size = len(indices) val = np.empty(size) comm.Bcast(val, root=owner) else: if indices is None or ignore_indices: val = vec[name].copy() else: val = vec[name][indices] if self._has_scaling and not unscaled: # Scale design variable values adder = meta['adder'] if adder is not None: val += adder scaler = meta['scaler'] if scaler is not None: val *= scaler return val def get_design_var_values(self, filter=None, unscaled=False, ignore_indices=False): """ Return the design variable values. This is called to gather the initial design variable state. Parameters ---------- filter : list List of desvar names used by recorders. unscaled : bool Set to True if unscaled (physical) design variables are desired. ignore_indices : bool Set to True if the full array is desired, not just those indicated by indices. Returns ------- dict Dictionary containing values of each design variable. """ if filter: dvs = filter else: # use all the designvars dvs = self._designvars return { n: self._get_voi_val(n, self._designvars[n], self._remote_dvs, unscaled=unscaled, ignore_indices=ignore_indices) for n in dvs } def set_design_var(self, name, value): """ Set the value of a design variable. Parameters ---------- name : str Global pathname of the design variable. value : float or ndarray Value for the design variable. """ if (name in self._remote_dvs and self._problem.model._owning_rank[name] != self._problem.comm.rank): return meta = self._designvars[name] indices = meta['indices'] if indices is None: indices = slice(None) desvar = self._problem.model._outputs._views_flat[name] desvar[indices] = value if self._has_scaling: # Scale design variable values scaler = meta['scaler'] if scaler is not None: desvar[indices] *= 1.0 / scaler adder = meta['adder'] if adder is not None: desvar[indices] -= adder def get_response_values(self, filter=None): """ Return response values. Parameters ---------- filter : list List of response names used by recorders. Returns ------- dict Dictionary containing values of each response. """ if filter: resps = filter else: resps = self._responses return { n: self._get_voi_val(n, self._responses[n], self._remote_objs) for n in resps } def get_objective_values(self, unscaled=False, filter=None): """ Return objective values. Parameters ---------- unscaled : bool Set to True if unscaled (physical) design variables are desired. filter : list List of objective names used by recorders. Returns ------- dict Dictionary containing values of each objective. """ if filter: objs = filter else: objs = self._objs return { n: self._get_voi_val(n, self._objs[n], self._remote_objs, unscaled=unscaled) for n in objs } def get_constraint_values(self, ctype='all', lintype='all', unscaled=False, filter=None): """ Return constraint values. Parameters ---------- ctype : string Default is 'all'. Optionally return just the inequality constraints with 'ineq' or the equality constraints with 'eq'. lintype : string Default is 'all'. Optionally return just the linear constraints with 'linear' or the nonlinear constraints with 'nonlinear'. unscaled : bool Set to True if unscaled (physical) design variables are desired. filter : list List of constraint names used by recorders. Returns ------- dict Dictionary containing values of each constraint. """ if filter is not None: cons = filter else: cons = self._cons con_dict = {} for name in cons: meta = self._cons[name] if lintype == 'linear' and not meta['linear']: continue if lintype == 'nonlinear' and meta['linear']: continue if ctype == 'eq' and meta['equals'] is None: continue if ctype == 'ineq' and meta['equals'] is not None: continue con_dict[name] = self._get_voi_val(name, meta, self._remote_cons, unscaled=unscaled) return con_dict def _get_ordered_nl_responses(self): """ Return the names of nonlinear responses in the order used by the driver. Default order is objectives followed by nonlinear constraints. This is used for simultaneous derivative coloring and sparsity determination. Returns ------- list of str The nonlinear response names in order. """ order = list(self._objs) order.extend(n for n, meta in iteritems(self._cons) if not ('linear' in meta and meta['linear'])) return order def run(self): """ Execute this driver. The base `Driver` just runs the model. All other drivers overload this method. Returns ------- boolean Failure flag; True if failed to converge, False is successful. """ with RecordingDebugging(self._get_name(), self.iter_count, self) as rec: failure_flag, _, _ = self._problem.model._solve_nonlinear() self.iter_count += 1 return failure_flag def _compute_totals(self, of=None, wrt=None, return_format='flat_dict', global_names=True): """ Compute derivatives of desired quantities with respect to desired inputs. All derivatives are returned using driver scaling. Parameters ---------- of : list of variable name strings or None Variables whose derivatives will be computed. Default is None, which uses the driver's objectives and constraints. wrt : list of variable name strings or None Variables with respect to which the derivatives will be computed. Default is None, which uses the driver's desvars. return_format : string Format to return the derivatives. Default is a 'flat_dict', which returns them in a dictionary whose keys are tuples of form (of, wrt). For the scipy optimizer, 'array' is also supported. global_names : bool Set to True when passing in global names to skip some translation steps. Returns ------- derivs : object Derivatives in form requested by 'return_format'. """ total_jac = self._total_jac debug_print = 'totals' in self.options['debug_print'] and ( not MPI or MPI.COMM_WORLD.rank == 0) if debug_print: header = 'Driver total derivatives for iteration: ' + str( self.iter_count) print(header) print(len(header) * '-' + '\n') if self._problem.model._owns_approx_jac: if total_jac is None: self._total_jac = total_jac = _TotalJacInfo( self._problem, of, wrt, global_names, return_format, approx=True, debug_print=debug_print) return total_jac.compute_totals_approx() else: if total_jac is None: total_jac = _TotalJacInfo(self._problem, of, wrt, global_names, return_format, debug_print=debug_print) # don't cache linear constraint jacobian if not total_jac.has_lin_cons: self._total_jac = total_jac return total_jac.compute_totals() def record_iteration(self): """ Record an iteration of the current Driver. """ if not self._rec_mgr._recorders: return # Get the data to record (collective calls that get across all ranks) opts = self.recording_options filt = self._filtered_vars_to_record if opts['record_desvars']: des_vars = self.get_design_var_values() else: des_vars = {} if opts['record_objectives']: obj_vars = self.get_objective_values() else: obj_vars = {} if opts['record_constraints']: con_vars = self.get_constraint_values() else: con_vars = {} if opts['record_responses']: # res_vars = self.get_response_values() # not really working yet res_vars = {} else: res_vars = {} des_vars = {name: des_vars[name] for name in filt['des']} obj_vars = {name: obj_vars[name] for name in filt['obj']} con_vars = {name: con_vars[name] for name in filt['con']} # res_vars = {name: res_vars[name] for name in filt['res']} model = self._problem.model sys_vars = {} in_vars = {} outputs = model._outputs inputs = model._inputs views = outputs._views views_in = inputs._views sys_vars = { name: views[name] for name in outputs._names if name in filt['sys'] } if self.recording_options['record_inputs']: in_vars = { name: views_in[name] for name in inputs._names if name in filt['in'] } if MPI: des_vars = self._gather_vars(model, des_vars) res_vars = self._gather_vars(model, res_vars) obj_vars = self._gather_vars(model, obj_vars) con_vars = self._gather_vars(model, con_vars) sys_vars = self._gather_vars(model, sys_vars) in_vars = self._gather_vars(model, in_vars) outs = {} if not MPI or model.comm.rank == 0: outs.update(des_vars) outs.update(res_vars) outs.update(obj_vars) outs.update(con_vars) outs.update(sys_vars) data = {'out': outs, 'in': in_vars} metadata = create_local_meta(self._get_name()) self._rec_mgr.record_iteration(self, data, metadata) def _gather_vars(self, root, local_vars): """ Gather and return only variables listed in `local_vars` from the `root` System. Parameters ---------- root : <System> the root System for the Problem local_vars : dict local variable names and values Returns ------- dct : dict variable names and values. """ # if trace: # debug("gathering vars for recording in %s" % root.pathname) all_vars = root.comm.gather(local_vars, root=0) # if trace: # debug("DONE gathering rec vars for %s" % root.pathname) if root.comm.rank == 0: dct = all_vars[-1] for d in all_vars[:-1]: dct.update(d) return dct def _get_name(self): """ Get name of current Driver. Returns ------- str Name of current Driver. """ return "Driver" def set_simul_deriv_color(self, simul_info): """ Set the coloring (and possibly the sub-jac sparsity) for simultaneous total derivatives. Parameters ---------- simul_info : str or tuple :: # Information about simultaneous coloring for design vars and responses. If a # string, then simul_info is assumed to be the name of a file that contains the # coloring information in JSON format. If a tuple, the structure looks like this: ( # First, a list of column index lists, each index list representing columns # having the same color, except for the very first index list, which contains # indices of all columns that are not colored. [ [i1, i2, i3, ...] # list of non-colored columns [ia, ib, ...] # list of columns in first color [ic, id, ...] # list of columns in second color ... # remaining color lists, one list of columns per color ], # Next is a list of lists, one for each column, containing the nonzero rows for # that column. If a column is not colored, then it will have a None entry # instead of a list. [ [r1, rn, ...] # list of nonzero rows for column 0 None, # column 1 is not colored [ra, rb, ...] # list of nonzero rows for column 2 ... ], # The last tuple entry can be None, indicating that no sparsity structure is # specified, or it can be a nested dictionary where the outer keys are response # names, the inner keys are design variable names, and the value is a tuple of # the form (row_list, col_list, shape). { resp1_name: { dv1_name: (rows, cols, shape), # for sub-jac d_resp1/d_dv1 dv2_name: (rows, cols, shape), ... }, resp2_name: { ... } ... } ) """ if self.supports['simultaneous_derivatives']: self._simul_coloring_info = simul_info else: raise RuntimeError( "Driver '%s' does not support simultaneous derivatives." % self._get_name()) def set_total_jac_sparsity(self, sparsity): """ Set the sparsity of sub-jacobians of the total jacobian. Note: This currently will have no effect if you are not using the pyOptSparseDriver. Parameters ---------- sparsity : str or dict :: # Sparsity is a nested dictionary where the outer keys are response # names, the inner keys are design variable names, and the value is a tuple of # the form (row_list, col_list, shape). { resp1: { dv1: (rows, cols, shape), # for sub-jac d_resp1/d_dv1 dv2: (rows, cols, shape), ... }, resp2: { ... } ... } """ if self.supports['total_jac_sparsity']: self._total_jac_sparsity = sparsity else: raise RuntimeError( "Driver '%s' does not support setting of total jacobian sparsity." % self._get_name()) def _setup_simul_coloring(self, mode='fwd'): """ Set up metadata for simultaneous derivative solution. Parameters ---------- mode : str Derivative direction, either 'fwd' or 'rev'. """ if mode == 'rev': raise NotImplementedError( "Simultaneous derivatives are currently not supported " "in 'rev' mode") # command line simul_coloring uses this env var to turn pre-existing coloring off if not coloring_mod._use_sparsity: return if isinstance(self._simul_coloring_info, string_types): with open(self._simul_coloring_info, 'r') as f: self._simul_coloring_info = json.load(f) tup = self._simul_coloring_info column_lists, row_map = tup[:2] if len(tup) > 2: sparsity = tup[2] if self._total_jac_sparsity is not None: raise RuntimeError( "Total jac sparsity was set in both _simul_coloring_info" " and _total_jac_sparsity.") self._total_jac_sparsity = sparsity self._simul_coloring_info = column_lists, row_map def _pre_run_model_debug_print(self): """ Optionally print some debugging information before the model runs. """ debug_opt = self.options['debug_print'] if not debug_opt or debug_opt == ['totals']: return if not MPI or MPI.COMM_WORLD.rank == 0: header = 'Driver debug print for iter coord: {}'.format( get_formatted_iteration_coordinate()) print(header) print(len(header) * '-') if 'desvars' in debug_opt: desvar_vals = self.get_design_var_values(unscaled=True, ignore_indices=True) if not MPI or MPI.COMM_WORLD.rank == 0: print("Design Vars") if desvar_vals: pprint.pprint(desvar_vals) else: print("None") print() sys.stdout.flush() def _post_run_model_debug_print(self): """ Optionally print some debugging information after the model runs. """ if 'nl_cons' in self.options['debug_print']: cons = self.get_constraint_values(lintype='nonlinear', unscaled=True) if not MPI or MPI.COMM_WORLD.rank == 0: print("Nonlinear constraints") if cons: pprint.pprint(cons) else: print("None") print() if 'ln_cons' in self.options['debug_print']: cons = self.get_constraint_values(lintype='linear', unscaled=True) if not MPI or MPI.COMM_WORLD.rank == 0: print("Linear constraints") if cons: pprint.pprint(cons) else: print("None") print() if 'objs' in self.options['debug_print']: objs = self.get_objective_values(unscaled=True) if not MPI or MPI.COMM_WORLD.rank == 0: print("Objectives") if objs: pprint.pprint(objs) else: print("None") print() sys.stdout.flush()
def __init__(self): """ Initialize the driver. """ self._rec_mgr = RecordingManager() self._vars_to_record = { 'desvarnames': set(), 'responsenames': set(), 'objectivenames': set(), 'constraintnames': set(), 'sysinclnames': set(), } self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None self.options = OptionsDictionary() self.recording_options = OptionsDictionary() ########################### self.recording_options.declare('record_metadata', types=bool, desc='Record metadata', default=True) self.recording_options.declare('record_desvars', types=bool, default=True, desc='Set to True to record design variables at the \ driver level') self.recording_options.declare('record_responses', types=bool, default=False, desc='Set to True to record responses at the driver level') self.recording_options.declare('record_objectives', types=bool, default=True, desc='Set to True to record objectives at the \ driver level') self.recording_options.declare('record_constraints', types=bool, default=True, desc='Set to True to record constraints at the \ driver level') self.recording_options.declare('includes', types=list, default=[], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') self.recording_options.declare('record_derivatives', types=bool, default=False, desc='Set to True to record derivatives at the driver \ level') ########################### # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', types=bool, default=False) self.supports.declare('equality_constraints', types=bool, default=False) self.supports.declare('linear_constraints', types=bool, default=False) self.supports.declare('two_sided_constraints', types=bool, default=False) self.supports.declare('multiple_objectives', types=bool, default=False) self.supports.declare('integer_design_vars', types=bool, default=False) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('active_set', types=bool, default=False) self.supports.declare('simultaneous_derivatives', types=bool, default=False) self.iter_count = 0 self.options = None self._model_viewer_data = None self.cite = "" # TODO, support these in OpenMDAO self.supports.declare('integer_design_vars', types=bool, default=False) self._simul_coloring_info = None self._res_jacs = {} self.fail = False
class SurrogateModel(object): """ Base class for surrogate models. Parameters ---------- **kwargs : dict Options dictionary. Attributes ---------- options : <OptionsDictionary> Dictionary with general pyoptsparse options. trained : bool True when surrogate has been trained. """ def __init__(self, **kwargs): """ Initialize all attributes. """ self.trained = False self.options = OptionsDictionary(parent_name=type(self).__name__) self._declare_options() self.options.update(kwargs) def train(self, x, y): """ Train the surrogate model with the given set of inputs and outputs. Parameters ---------- x : array-like Training input locations.. y : array-like Model responses at given inputs. """ self.trained = True def predict(self, x): """ Calculate a predicted value of the response based on the current trained model. Parameters ---------- x : array-like Point(s) at which the surrogate is evaluated. """ if not self.trained: msg = "{0} has not been trained, so no prediction can be made."\ .format(type(self).__name__) raise RuntimeError(msg) def vectorized_predict(self, x): """ Calculate predicted values of the response based on the current trained model. Parameters ---------- x : array-like Vectorized point(s) at which the surrogate is evaluated. """ pass def linearize(self, x): """ Calculate the jacobian of the interpolant at the requested point. Parameters ---------- x : array-like Point at which the surrogate Jacobian is evaluated. """ pass def _declare_options(self): """ Declare options before kwargs are processed in the init method. """ pass
def __init__(self, **kwargs): """ Initialize the driver. Parameters ---------- **kwargs : dict of keyword arguments Keyword arguments that will be mapped into the Driver options. """ self._rec_mgr = RecordingManager() self._vars_to_record = { 'desvarnames': set(), 'responsenames': set(), 'objectivenames': set(), 'constraintnames': set(), 'sysinclnames': set(), } self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None # Driver options self.options = OptionsDictionary() self.options.declare( 'debug_print', types=list, is_valid=_is_debug_print_opts_valid, desc="List of what type of Driver variables to print at each " "iteration. Valid items in list are 'desvars', 'ln_cons', " "'nl_cons', 'objs'", default=[]) # Case recording options self.recording_options = OptionsDictionary() self.recording_options.declare('record_metadata', types=bool, default=True, desc='Record metadata') self.recording_options.declare( 'record_desvars', types=bool, default=True, desc='Set to True to record design variables at the ' 'driver level') self.recording_options.declare( 'record_responses', types=bool, default=False, desc='Set to True to record responses at the driver level') self.recording_options.declare( 'record_objectives', types=bool, default=True, desc='Set to True to record objectives at the driver level') self.recording_options.declare( 'record_constraints', types=bool, default=True, desc='Set to True to record constraints at the ' 'driver level') self.recording_options.declare( 'includes', types=list, default=['*'], desc='Patterns for variables to include in recording') self.recording_options.declare( 'excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') self.recording_options.declare( 'record_derivatives', types=bool, default=False, desc='Set to True to record derivatives at the driver ' 'level') self.recording_options.declare( 'record_inputs', types=bool, default=True, desc='Set to True to record inputs at the driver level') # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', types=bool, default=False) self.supports.declare('equality_constraints', types=bool, default=False) self.supports.declare('linear_constraints', types=bool, default=False) self.supports.declare('two_sided_constraints', types=bool, default=False) self.supports.declare('multiple_objectives', types=bool, default=False) self.supports.declare('integer_design_vars', types=bool, default=False) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('active_set', types=bool, default=False) self.supports.declare('simultaneous_derivatives', types=bool, default=False) self.supports.declare('total_jac_sparsity', types=bool, default=False) # TODO, support these in OpenMDAO self.supports.declare('integer_design_vars', types=bool, default=False) self.iter_count = 0 self._model_viewer_data = None self.cite = "" self._simul_coloring_info = None self._total_jac_sparsity = None self._res_jacs = {} self._total_jac = None self.fail = False self._declare_options() self.options.update(kwargs)
class InterpAlgorithm(object): """ Base class for interpolation over data in an n-dimensional table. Attributes ---------- grid : tuple(ndarray) Tuple containing x grid locations for this dimension. k : int Minimum number of points required for this algorithm. last_index : integer Index of previous evaluation, used to start search for current index. options : <OptionsDictionary> Dictionary with general pyoptsparse options. subtable : <InterpAlgorithm> Table interpolation that handles child dimensions. training_data_gradients : bool Flag that tells interpolation objects wether to compute gradients with respect to the grid values. values : ndarray Array containing the table values for all dimensions. _name : str Algorithm name for error messages. _full_slice : tuple of <Slice> Used to cache the full slice if training derivatives are computed. _vectorized :bool If True, this method is vectorized and can simultaneously solve multiple interpolations. """ def __init__(self, grid, values, interp, **kwargs): """ Initialize table and subtables. Parameters ---------- grid : tuple(ndarray) Tuple containing ndarray of x grid locations for each table dimension. values : ndarray Array containing the values at all points in grid. interp : class Interpolation class to be used for subsequent table dimensions. **kwargs : dict Interpolator-specific options to pass onward. """ self.options = OptionsDictionary(parent_name=type(self).__name__) self.initialize() self.options.update(kwargs) self.subtable = None self.grid = grid[0] self.values = values if len(grid) > 1: self.subtable = interp(grid[1:], values, interp, **kwargs) self.last_index = 0 self.k = None self._name = None self._vectorized = False self.training_data_gradients = False self._full_slice = None def initialize(self): """ Declare options. Override to add options. """ pass def check_config(self): """ Verify that we have enough points for this interpolation algorithm. """ if self.subtable: self.subtable.check_config() k = self.k n_p = len(self.grid) if n_p < k: raise ValueError("There are %d points in a data dimension," " but method %s requires at least %d " "points per dimension." "" % (n_p, self._name, k + 1)) def bracket(self, x): """ Locate the interval of the new independent. Uses the following algorithm: 1. Determine if the value is above or below the value at last_index 2. Bracket the value between last_index and last_index +- inc, where inc has an increasing value of 1,2,4,8, etc. 3. Once the value is bracketed, use bisection method within that bracket. The grid is assumed to increase in a monotonic fashion. Parameters ---------- x : float Value of new independent to interpolate. Returns ------- integer Grid interval index that contains x. integer Extrapolation flag, -1 if the bracket is below the first table element, 1 if the bracket is above the last table element, 0 for normal interpolation. """ grid = self.grid last_index = self.last_index high = last_index + 1 highbound = len(grid) - 1 inc = 1 while x < grid[last_index]: high = last_index last_index -= inc if last_index < 0: last_index = 0 # Check if we're off of the bottom end. if x < grid[0]: return last_index, -1 break inc += inc if high > highbound: high = highbound while x > grid[high]: last_index = high high += inc if high >= highbound: # Check if we're off of the top end if x > grid[highbound]: last_index = highbound return last_index, 1 high = highbound break inc += inc # Bisection while high - last_index > 1: low = (high + last_index) // 2 if x < grid[low]: high = low else: last_index = low return last_index, 0 def evaluate(self, x, slice_idx=None): """ Interpolate across this and subsequent table dimensions. Parameters ---------- x : ndarray The coordinates to sample the gridded data at. First array element is the point to interpolate here. Remaining elements are interpolated on sub tables. slice_idx : List of <slice> Slice object containing indices of data points requested by parent interpolating tables. Returns ------- ndarray Interpolated values. ndarray Derivative of interpolated values with respect to this independent and child independents. ndarray Derivative of interpolated values with respect to values for this and subsequent table dimensions. ndarray Derivative of interpolated values with respect to grid for this and subsequent table dimensions. """ idx, _ = self.bracket(x[0]) self.last_index = idx if slice_idx is None: slice_idx = [] if self.subtable is not None: self.subtable.training_data_gradients = self.training_data_gradients result, d_dx, d_values, d_grid = self.interpolate(x, idx, slice_idx) return result, d_dx, d_values, d_grid def interpolate(self, x, idx, slice_idx): """ Compute the interpolated value over this grid dimension. This method must be defined by child classes. Parameters ---------- x : ndarray The coordinates to sample the gridded data at. First array element is the point to interpolate here. Remaining elements are interpolated on sub tables. idx : integer Interval index for x. slice_idx : List of <slice> Slice object containing indices of data points requested by parent interpolating tables. Returns ------- ndarray Interpolated values. ndarray Derivative of interpolated values with respect to this independent and child independents. ndarray Derivative of interpolated values with respect to values for this and subsequent table dimensions. ndarray Derivative of interpolated values with respect to grid for this and subsequent table dimensions. """ pass
class Driver(object): """ Top-level container for the systems and drivers. Attributes ---------- fail : bool Reports whether the driver ran successfully. iter_count : int Keep track of iterations for case recording. options : <OptionsDictionary> Dictionary with general pyoptsparse options. recording_options : <OptionsDictionary> Dictionary with driver recording options. cite : str Listing of relevant citations that should be referenced when publishing work that uses this class. _problem : <Problem> Pointer to the containing problem. supports : <OptionsDictionary> Provides a consistent way for drivers to declare what features they support. _designvars : dict Contains all design variable info. _cons : dict Contains all constraint info. _objs : dict Contains all objective info. _responses : dict Contains all response info. _rec_mgr : <RecordingManager> Object that manages all recorders added to this driver. _vars_to_record: dict Dict of lists of var names indicating what to record _model_viewer_data : dict Structure of model, used to make n2 diagram. _simul_coloring_info : tuple of dicts A data structure describing coloring for simultaneous derivs. _total_jac_sparsity : dict, str, or None Specifies sparsity of sub-jacobians of the total jacobian. Only used by pyOptSparseDriver. _res_jacs : dict Dict of sparse subjacobians for use with certain optimizers, e.g. pyOptSparseDriver. _total_jac : _TotalJacInfo or None Cached total jacobian handling object. """ def __init__(self, **kwargs): """ Initialize the driver. Parameters ---------- **kwargs : dict of keyword arguments Keyword arguments that will be mapped into the Driver options. """ self._rec_mgr = RecordingManager() self._vars_to_record = { 'desvarnames': set(), 'responsenames': set(), 'objectivenames': set(), 'constraintnames': set(), 'sysinclnames': set(), } self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None # Driver options self.options = OptionsDictionary() self.options.declare('debug_print', types=list, check_valid=_check_debug_print_opts_valid, desc="List of what type of Driver variables to print at each " "iteration. Valid items in list are 'desvars', 'ln_cons', " "'nl_cons', 'objs', 'totals'", default=[]) # Case recording options self.recording_options = OptionsDictionary() self.recording_options.declare('record_model_metadata', types=bool, default=True, desc='Record metadata for all Systems in the model') self.recording_options.declare('record_desvars', types=bool, default=True, desc='Set to True to record design variables at the ' 'driver level') self.recording_options.declare('record_responses', types=bool, default=False, desc='Set to True to record responses at the driver level') self.recording_options.declare('record_objectives', types=bool, default=True, desc='Set to True to record objectives at the driver level') self.recording_options.declare('record_constraints', types=bool, default=True, desc='Set to True to record constraints at the ' 'driver level') self.recording_options.declare('includes', types=list, default=[], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') self.recording_options.declare('record_derivatives', types=bool, default=False, desc='Set to True to record derivatives at the driver ' 'level') self.recording_options.declare('record_inputs', types=bool, default=True, desc='Set to True to record inputs at the driver level') # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', types=bool, default=False) self.supports.declare('equality_constraints', types=bool, default=False) self.supports.declare('linear_constraints', types=bool, default=False) self.supports.declare('two_sided_constraints', types=bool, default=False) self.supports.declare('multiple_objectives', types=bool, default=False) self.supports.declare('integer_design_vars', types=bool, default=False) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('active_set', types=bool, default=False) self.supports.declare('simultaneous_derivatives', types=bool, default=False) self.supports.declare('total_jac_sparsity', types=bool, default=False) self.iter_count = 0 self._model_viewer_data = None self.cite = "" self._simul_coloring_info = None self._total_jac_sparsity = None self._res_jacs = {} self._total_jac = None self.fail = False self._declare_options() self.options.update(kwargs) def add_recorder(self, recorder): """ Add a recorder to the driver. Parameters ---------- recorder : CaseRecorder A recorder instance. """ self._rec_mgr.append(recorder) def cleanup(self): """ Clean up resources prior to exit. """ # shut down all recorders self._rec_mgr.shutdown() def _declare_options(self): """ Declare options before kwargs are processed in the init method. This is optionally implemented by subclasses of Driver. """ pass def _setup_comm(self, comm): """ Perform any driver-specific setup of communicators for the model. Parameters ---------- comm : MPI.Comm or <FakeComm> or None The communicator for the Problem. Returns ------- MPI.Comm or <FakeComm> or None The communicator for the Problem model. """ return comm def _setup_driver(self, problem): """ Prepare the driver for execution. This is the final thing to run during setup. Parameters ---------- problem : <Problem> Pointer to the containing problem. """ self._problem = problem self._recording_iter = problem._recording_iter model = problem.model self._total_jac = None self._has_scaling = ( np.any([r['scaler'] is not None for r in itervalues(self._responses)]) or np.any([dv['scaler'] is not None for dv in itervalues(self._designvars)]) ) con_set = set() obj_set = set() dv_set = set() self._remote_dvs = dv_dict = {} self._remote_cons = con_dict = {} self._remote_objs = obj_dict = {} # Now determine if later we'll need to allgather cons, objs, or desvars. if model.comm.size > 1 and model._subsystems_allprocs: local_out_vars = set(model._outputs._views) remote_dvs = set(self._designvars) - local_out_vars remote_cons = set(self._cons) - local_out_vars remote_objs = set(self._objs) - local_out_vars all_remote_vois = model.comm.allgather( (remote_dvs, remote_cons, remote_objs)) for rem_dvs, rem_cons, rem_objs in all_remote_vois: con_set.update(rem_cons) obj_set.update(rem_objs) dv_set.update(rem_dvs) # If we have remote VOIs, pick an owning rank for each and use that # to bcast to others later owning_ranks = model._owning_rank sizes = model._var_sizes['nonlinear']['output'] for i, vname in enumerate(model._var_allprocs_abs_names['output']): owner = owning_ranks[vname] if vname in dv_set: dv_dict[vname] = (owner, sizes[owner, i]) if vname in con_set: con_dict[vname] = (owner, sizes[owner, i]) if vname in obj_set: obj_dict[vname] = (owner, sizes[owner, i]) self._remote_responses = self._remote_cons.copy() self._remote_responses.update(self._remote_objs) # set up simultaneous deriv coloring if (coloring_mod._use_sparsity and self._simul_coloring_info and self.supports['simultaneous_derivatives']): self._setup_simul_coloring() def _get_vars_to_record(self, recording_options): """ Get variables to record based on recording options. Parameters ---------- recording_options : <OptionsDictionary> Dictionary with recording options. Returns ------- dict Dictionary containing lists of variables to record. """ problem = self._problem model = problem.model if MPI: # TODO: Eventually, we think we can get rid of this next check. # But to be safe, we are leaving it in there. if not model.is_active(): raise RuntimeError("RecordingManager.startup should never be called when " "running in parallel on an inactive System") rrank = problem.comm.rank rowned = model._owning_rank incl = recording_options['includes'] excl = recording_options['excludes'] # includes and excludes for outputs are specified using promoted names # NOTE: only local var names are in abs2prom, all will be gathered later abs2prom = model._var_abs2prom['output'] all_desvars = {n for n in self._designvars if n in abs2prom and check_path(abs2prom[n], incl, excl, True)} all_objectives = {n for n in self._objs if n in abs2prom and check_path(abs2prom[n], incl, excl, True)} all_constraints = {n for n in self._cons if n in abs2prom and check_path(abs2prom[n], incl, excl, True)} # design variables, objectives and constraints are always in the options mydesvars = myobjectives = myconstraints = set() if recording_options['record_desvars']: if MPI: mydesvars = [n for n in all_desvars if rrank == rowned[n]] else: mydesvars = list(all_desvars) if recording_options['record_objectives']: if MPI: myobjectives = [n for n in all_objectives if rrank == rowned[n]] else: myobjectives = list(all_objectives) if recording_options['record_constraints']: if MPI: myconstraints = [n for n in all_constraints if rrank == rowned[n]] else: myconstraints = list(all_constraints) filtered_vars_to_record = { 'des': mydesvars, 'obj': myobjectives, 'con': myconstraints } # responses (if in options) if 'record_responses' in recording_options: myresponses = set() if recording_options['record_responses']: myresponses = {n for n in self._responses if n in abs2prom and check_path(abs2prom[n], incl, excl, True)} if MPI: myresponses = [n for n in myresponses if rrank == rowned[n]] filtered_vars_to_record['res'] = list(myresponses) # inputs (if in options) if 'record_inputs' in recording_options: myinputs = set() if recording_options['record_inputs']: myinputs = {n for n in model._inputs if check_path(n, incl, excl)} if MPI: # gather the variables from all ranks to rank 0 all_vars = model.comm.gather(myinputs, root=0) if MPI.COMM_WORLD.rank == 0: myinputs = all_vars[-1] for d in all_vars[:-1]: myinputs.update(d) myinputs = [n for n in myinputs if rrank == rowned[n]] filtered_vars_to_record['in'] = list(myinputs) # system outputs (if the options being processed are for the driver itself) if recording_options is self.recording_options: myoutputs = set() if incl: myoutputs = {n for n in model._outputs if n in abs2prom and check_path(abs2prom[n], incl, excl)} if MPI: # gather the variables from all ranks to rank 0 all_vars = model.comm.gather(myoutputs, root=0) if MPI.COMM_WORLD.rank == 0: myoutputs = all_vars[-1] for d in all_vars[:-1]: myoutputs.update(d) # de-duplicate myoutputs = myoutputs.difference(all_desvars, all_objectives, all_constraints) if MPI: myoutputs = [n for n in myoutputs if rrank == rowned[n]] filtered_vars_to_record['sys'] = list(myoutputs) return filtered_vars_to_record def _setup_recording(self): """ Set up case recording. """ self._filtered_vars_to_record = self._get_vars_to_record(self.recording_options) self._rec_mgr.startup(self) # record the system metadata to the recorders attached to this Driver if self.recording_options['record_model_metadata']: for sub in self._problem.model.system_iter(recurse=True, include_self=True): self._rec_mgr.record_metadata(sub) def _get_voi_val(self, name, meta, remote_vois, unscaled=False, ignore_indices=False): """ Get the value of a variable of interest (objective, constraint, or design var). This will retrieve the value if the VOI is remote. Parameters ---------- name : str Name of the variable of interest. meta : dict Metadata for the variable of interest. remote_vois : dict Dict containing (owning_rank, size) for all remote vois of a particular type (design var, constraint, or objective). unscaled : bool Set to True if unscaled (physical) design variables are desired. ignore_indices : bool Set to True if the full array is desired, not just those indicated by indices. Returns ------- float or ndarray The value of the named variable of interest. """ model = self._problem.model comm = model.comm vec = model._outputs._views_flat indices = meta['indices'] if name in remote_vois: owner, size = remote_vois[name] if owner == comm.rank: if indices is None or ignore_indices: val = vec[name].copy() else: val = vec[name][indices] else: if not (indices is None or ignore_indices): size = len(indices) val = np.empty(size) comm.Bcast(val, root=owner) else: if indices is None or ignore_indices: val = vec[name].copy() else: val = vec[name][indices] if self._has_scaling and not unscaled: # Scale design variable values adder = meta['adder'] if adder is not None: val += adder scaler = meta['scaler'] if scaler is not None: val *= scaler return val def get_design_var_values(self, filter=None, unscaled=False, ignore_indices=False): """ Return the design variable values. This is called to gather the initial design variable state. Parameters ---------- filter : list List of desvar names used by recorders. unscaled : bool Set to True if unscaled (physical) design variables are desired. ignore_indices : bool Set to True if the full array is desired, not just those indicated by indices. Returns ------- dict Dictionary containing values of each design variable. """ if filter: dvs = filter else: # use all the designvars dvs = self._designvars return {n: self._get_voi_val(n, self._designvars[n], self._remote_dvs, unscaled=unscaled, ignore_indices=ignore_indices) for n in dvs} def set_design_var(self, name, value): """ Set the value of a design variable. Parameters ---------- name : str Global pathname of the design variable. value : float or ndarray Value for the design variable. """ problem = self._problem if (name in self._remote_dvs and problem.model._owning_rank[name] != problem.comm.rank): return meta = self._designvars[name] indices = meta['indices'] if indices is None: indices = slice(None) desvar = problem.model._outputs._views_flat[name] desvar[indices] = value if self._has_scaling: # Scale design variable values scaler = meta['scaler'] if scaler is not None: desvar[indices] *= 1.0 / scaler adder = meta['adder'] if adder is not None: desvar[indices] -= adder def get_response_values(self, filter=None): """ Return response values. Parameters ---------- filter : list List of response names used by recorders. Returns ------- dict Dictionary containing values of each response. """ if filter: resps = filter else: resps = self._responses return {n: self._get_voi_val(n, self._responses[n], self._remote_objs) for n in resps} def get_objective_values(self, unscaled=False, filter=None, ignore_indices=False): """ Return objective values. Parameters ---------- unscaled : bool Set to True if unscaled (physical) design variables are desired. filter : list List of objective names used by recorders. ignore_indices : bool Set to True if the full array is desired, not just those indicated by indices. Returns ------- dict Dictionary containing values of each objective. """ if filter: objs = filter else: objs = self._objs return {n: self._get_voi_val(n, self._objs[n], self._remote_objs, unscaled=unscaled, ignore_indices=ignore_indices) for n in objs} def get_constraint_values(self, ctype='all', lintype='all', unscaled=False, filter=None, ignore_indices=False): """ Return constraint values. Parameters ---------- ctype : string Default is 'all'. Optionally return just the inequality constraints with 'ineq' or the equality constraints with 'eq'. lintype : string Default is 'all'. Optionally return just the linear constraints with 'linear' or the nonlinear constraints with 'nonlinear'. unscaled : bool Set to True if unscaled (physical) design variables are desired. filter : list List of constraint names used by recorders. ignore_indices : bool Set to True if the full array is desired, not just those indicated by indices. Returns ------- dict Dictionary containing values of each constraint. """ if filter is not None: cons = filter else: cons = self._cons con_dict = {} for name in cons: meta = self._cons[name] if lintype == 'linear' and not meta['linear']: continue if lintype == 'nonlinear' and meta['linear']: continue if ctype == 'eq' and meta['equals'] is None: continue if ctype == 'ineq' and meta['equals'] is not None: continue con_dict[name] = self._get_voi_val(name, meta, self._remote_cons, unscaled=unscaled, ignore_indices=ignore_indices) return con_dict def _get_ordered_nl_responses(self): """ Return the names of nonlinear responses in the order used by the driver. Default order is objectives followed by nonlinear constraints. This is used for simultaneous derivative coloring and sparsity determination. Returns ------- list of str The nonlinear response names in order. """ order = list(self._objs) order.extend(n for n, meta in iteritems(self._cons) if not ('linear' in meta and meta['linear'])) return order def _update_voi_meta(self, model): """ Collect response and design var metadata from the model and size desvars and responses. Parameters ---------- model : System The System that represents the entire model. Returns ------- int Total size of responses, with linear constraints excluded. int Total size of design vars. """ self._objs = objs = OrderedDict() self._cons = cons = OrderedDict() self._responses = resps = model.get_responses(recurse=True) for name, data in iteritems(resps): if data['type'] == 'con': cons[name] = data else: objs[name] = data response_size = sum(resps[n]['size'] for n in self._get_ordered_nl_responses()) # Gather up the information for design vars. self._designvars = designvars = model.get_design_vars(recurse=True) desvar_size = sum(data['size'] for data in itervalues(designvars)) return response_size, desvar_size def run(self): """ Execute this driver. The base `Driver` just runs the model. All other drivers overload this method. Returns ------- boolean Failure flag; True if failed to converge, False is successful. """ with RecordingDebugging(self._get_name(), self.iter_count, self): self._problem.model._solve_nonlinear() self.iter_count += 1 return False def _compute_totals(self, of=None, wrt=None, return_format='flat_dict', global_names=True): """ Compute derivatives of desired quantities with respect to desired inputs. All derivatives are returned using driver scaling. Parameters ---------- of : list of variable name strings or None Variables whose derivatives will be computed. Default is None, which uses the driver's objectives and constraints. wrt : list of variable name strings or None Variables with respect to which the derivatives will be computed. Default is None, which uses the driver's desvars. return_format : string Format to return the derivatives. Default is a 'flat_dict', which returns them in a dictionary whose keys are tuples of form (of, wrt). For the scipy optimizer, 'array' is also supported. global_names : bool Set to True when passing in global names to skip some translation steps. Returns ------- derivs : object Derivatives in form requested by 'return_format'. """ problem = self._problem total_jac = self._total_jac debug_print = 'totals' in self.options['debug_print'] and (not MPI or MPI.COMM_WORLD.rank == 0) if debug_print: header = 'Driver total derivatives for iteration: ' + str(self.iter_count) print(header) print(len(header) * '-' + '\n') if problem.model._owns_approx_jac: self._recording_iter.stack.append(('_compute_totals_approx', 0)) try: if total_jac is None: total_jac = _TotalJacInfo(problem, of, wrt, global_names, return_format, approx=True, debug_print=debug_print) self._total_jac = total_jac totals = total_jac.compute_totals_approx(initialize=True) else: totals = total_jac.compute_totals_approx() finally: self._recording_iter.stack.pop() else: if total_jac is None: total_jac = _TotalJacInfo(problem, of, wrt, global_names, return_format, debug_print=debug_print) # don't cache linear constraint jacobian if not total_jac.has_lin_cons: self._total_jac = total_jac self._recording_iter.stack.append(('_compute_totals', 0)) try: totals = total_jac.compute_totals() finally: self._recording_iter.stack.pop() if self._rec_mgr._recorders and self.recording_options['record_derivatives']: metadata = create_local_meta(self._get_name()) total_jac.record_derivatives(self, metadata) return totals def record_iteration(self): """ Record an iteration of the current Driver. """ if not self._rec_mgr._recorders: return # Get the data to record (collective calls that get across all ranks) opts = self.recording_options filt = self._filtered_vars_to_record if opts['record_desvars']: des_vars = self.get_design_var_values(unscaled=True, ignore_indices=True) else: des_vars = {} if opts['record_objectives']: obj_vars = self.get_objective_values(unscaled=True, ignore_indices=True) else: obj_vars = {} if opts['record_constraints']: con_vars = self.get_constraint_values(unscaled=True, ignore_indices=True) else: con_vars = {} if opts['record_responses']: # res_vars = self.get_response_values() # not really working yet res_vars = {} else: res_vars = {} des_vars = {name: des_vars[name] for name in filt['des']} obj_vars = {name: obj_vars[name] for name in filt['obj']} con_vars = {name: con_vars[name] for name in filt['con']} # res_vars = {name: res_vars[name] for name in filt['res']} model = self._problem.model names = model._outputs._names views = model._outputs._views sys_vars = {name: views[name] for name in names if name in filt['sys']} if self.recording_options['record_inputs']: names = model._inputs._names views = model._inputs._views in_vars = {name: views[name] for name in names if name in filt['in']} else: in_vars = {} if MPI: des_vars = self._gather_vars(model, des_vars) res_vars = self._gather_vars(model, res_vars) obj_vars = self._gather_vars(model, obj_vars) con_vars = self._gather_vars(model, con_vars) sys_vars = self._gather_vars(model, sys_vars) in_vars = self._gather_vars(model, in_vars) outs = {} if not MPI or model.comm.rank == 0: outs.update(des_vars) outs.update(res_vars) outs.update(obj_vars) outs.update(con_vars) outs.update(sys_vars) data = { 'out': outs, 'in': in_vars } metadata = create_local_meta(self._get_name()) self._rec_mgr.record_iteration(self, data, metadata) def _gather_vars(self, root, local_vars): """ Gather and return only variables listed in `local_vars` from the `root` System. Parameters ---------- root : <System> the root System for the Problem local_vars : dict local variable names and values Returns ------- dct : dict variable names and values. """ # if trace: # debug("gathering vars for recording in %s" % root.pathname) all_vars = root.comm.gather(local_vars, root=0) # if trace: # debug("DONE gathering rec vars for %s" % root.pathname) if root.comm.rank == 0: dct = all_vars[-1] for d in all_vars[:-1]: dct.update(d) return dct def _get_name(self): """ Get name of current Driver. Returns ------- str Name of current Driver. """ return "Driver" def set_simul_deriv_color(self, simul_info): """ Set the coloring (and possibly the sub-jac sparsity) for simultaneous total derivatives. Parameters ---------- simul_info : str or dict :: # Information about simultaneous coloring for design vars and responses. If a # string, then simul_info is assumed to be the name of a file that contains the # coloring information in JSON format. If a dict, the structure looks like this: { "fwd": [ # First, a list of column index lists, each index list representing columns # having the same color, except for the very first index list, which contains # indices of all columns that are not colored. [ [i1, i2, i3, ...] # list of non-colored columns [ia, ib, ...] # list of columns in first color [ic, id, ...] # list of columns in second color ... # remaining color lists, one list of columns per color ], # Next is a list of lists, one for each column, containing the nonzero rows for # that column. If a column is not colored, then it will have a None entry # instead of a list. [ [r1, rn, ...] # list of nonzero rows for column 0 None, # column 1 is not colored [ra, rb, ...] # list of nonzero rows for column 2 ... ], ], # This example is not a bidirectional coloring, so the opposite direction, "rev" # in this case, has an empty row index list. It could also be removed entirely. "rev": [[[]], []], "sparsity": # The sparsity entry can be absent, indicating that no sparsity structure is # specified, or it can be a nested dictionary where the outer keys are response # names, the inner keys are design variable names, and the value is a tuple of # the form (row_list, col_list, shape). { resp1_name: { dv1_name: (rows, cols, shape), # for sub-jac d_resp1/d_dv1 dv2_name: (rows, cols, shape), ... }, resp2_name: { ... } ... } } """ if self.supports['simultaneous_derivatives']: self._simul_coloring_info = simul_info else: raise RuntimeError("Driver '%s' does not support simultaneous derivatives." % self._get_name()) def set_total_jac_sparsity(self, sparsity): """ Set the sparsity of sub-jacobians of the total jacobian. Note: This currently will have no effect if you are not using the pyOptSparseDriver. Parameters ---------- sparsity : str or dict :: # Sparsity is a nested dictionary where the outer keys are response # names, the inner keys are design variable names, and the value is a tuple of # the form (row_list, col_list, shape). { resp1: { dv1: (rows, cols, shape), # for sub-jac d_resp1/d_dv1 dv2: (rows, cols, shape), ... }, resp2: { ... } ... } """ if self.supports['total_jac_sparsity']: self._total_jac_sparsity = sparsity else: raise RuntimeError("Driver '%s' does not support setting of total jacobian sparsity." % self._get_name()) def _setup_simul_coloring(self): """ Set up metadata for simultaneous derivative solution. """ # command line simul_coloring uses this env var to turn pre-existing coloring off if not coloring_mod._use_sparsity: return problem = self._problem if not problem.model._use_derivatives: simple_warning("Derivatives are turned off. Skipping simul deriv coloring.") return if isinstance(self._simul_coloring_info, string_types): with open(self._simul_coloring_info, 'r') as f: self._simul_coloring_info = coloring_mod._json2coloring(json.load(f)) if 'rev' in self._simul_coloring_info and problem._orig_mode not in ('rev', 'auto'): revcol = self._simul_coloring_info['rev'][0][0] if revcol: raise RuntimeError("Simultaneous coloring does reverse solves but mode has " "been set to '%s'" % problem._orig_mode) if 'fwd' in self._simul_coloring_info and problem._orig_mode not in ('fwd', 'auto'): fwdcol = self._simul_coloring_info['fwd'][0][0] if fwdcol: raise RuntimeError("Simultaneous coloring does forward solves but mode has " "been set to '%s'" % problem._orig_mode) # simul_coloring_info can contain data for either fwd, rev, or both, along with optional # sparsity patterns if 'sparsity' in self._simul_coloring_info: sparsity = self._simul_coloring_info['sparsity'] del self._simul_coloring_info['sparsity'] else: sparsity = None if sparsity is not None and self._total_jac_sparsity is not None: raise RuntimeError("Total jac sparsity was set in both _simul_coloring_info" " and _total_jac_sparsity.") self._total_jac_sparsity = sparsity def _pre_run_model_debug_print(self): """ Optionally print some debugging information before the model runs. """ debug_opt = self.options['debug_print'] if not debug_opt or debug_opt == ['totals']: return if not MPI or MPI.COMM_WORLD.rank == 0: header = 'Driver debug print for iter coord: {}'.format( self._recording_iter.get_formatted_iteration_coordinate()) print(header) print(len(header) * '-') if 'desvars' in debug_opt: desvar_vals = self.get_design_var_values(unscaled=True, ignore_indices=True) if not MPI or MPI.COMM_WORLD.rank == 0: print("Design Vars") if desvar_vals: pprint.pprint(desvar_vals) else: print("None") print() sys.stdout.flush() def _post_run_model_debug_print(self): """ Optionally print some debugging information after the model runs. """ if 'nl_cons' in self.options['debug_print']: cons = self.get_constraint_values(lintype='nonlinear', unscaled=True) if not MPI or MPI.COMM_WORLD.rank == 0: print("Nonlinear constraints") if cons: pprint.pprint(cons) else: print("None") print() if 'ln_cons' in self.options['debug_print']: cons = self.get_constraint_values(lintype='linear', unscaled=True) if not MPI or MPI.COMM_WORLD.rank == 0: print("Linear constraints") if cons: pprint.pprint(cons) else: print("None") print() if 'objs' in self.options['debug_print']: objs = self.get_objective_values(unscaled=True) if not MPI or MPI.COMM_WORLD.rank == 0: print("Objectives") if objs: pprint.pprint(objs) else: print("None") print() sys.stdout.flush()
def __init__(self): """ Initialize the driver. """ self._rec_mgr = RecordingManager() self._vars_to_record = { 'desvarnames': set(), 'responsenames': set(), 'objectivenames': set(), 'constraintnames': set(), 'sysinclnames': set(), } self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None self.options = OptionsDictionary() self.recording_options = OptionsDictionary() ########################### self.options.declare('debug_print', types=list, is_valid=_is_debug_print_opts_valid, desc="List of what type of Driver variables to print at each " "iteration. Valid items in list are 'desvars','ln_cons'," "'nl_cons','objs'", default=[]) ########################### self.recording_options.declare('record_metadata', types=bool, desc='Record metadata', default=True) self.recording_options.declare('record_desvars', types=bool, default=True, desc='Set to True to record design variables at the \ driver level') self.recording_options.declare('record_responses', types=bool, default=False, desc='Set to True to record responses at the driver level') self.recording_options.declare('record_objectives', types=bool, default=True, desc='Set to True to record objectives at the \ driver level') self.recording_options.declare('record_constraints', types=bool, default=True, desc='Set to True to record constraints at the \ driver level') self.recording_options.declare('includes', types=list, default=['*'], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') self.recording_options.declare('record_derivatives', types=bool, default=False, desc='Set to True to record derivatives at the driver \ level') ########################### # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', types=bool, default=False) self.supports.declare('equality_constraints', types=bool, default=False) self.supports.declare('linear_constraints', types=bool, default=False) self.supports.declare('two_sided_constraints', types=bool, default=False) self.supports.declare('multiple_objectives', types=bool, default=False) self.supports.declare('integer_design_vars', types=bool, default=False) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('active_set', types=bool, default=False) self.supports.declare('simultaneous_derivatives', types=bool, default=False) # Debug printing. self.debug_print = OptionsDictionary() self.debug_print.declare('debug_print', types=bool, default=False, desc='Overall option to turn on Driver debug printing') self.debug_print.declare('debug_print_desvars', types=bool, default=False, desc='Print design variables') self.debug_print.declare('debug_print_nl_con', types=bool, default=False, desc='Print nonlinear constraints') self.debug_print.declare('debug_print_ln_con', types=bool, default=False, desc='Print linear constraints') self.debug_print.declare('debug_print_objective', types=bool, default=False, desc='Print objectives') self.iter_count = 0 self.metadata = None self._model_viewer_data = None self.cite = "" # TODO, support these in OpenMDAO self.supports.declare('integer_design_vars', types=bool, default=False) self._simul_coloring_info = None self._res_jacs = {} self.fail = False
def __init__(self, **kwargs): """ Initialize the driver. Parameters ---------- **kwargs : dict of keyword arguments Keyword arguments that will be mapped into the Driver options. """ self._rec_mgr = RecordingManager() self._vars_to_record = { 'desvarnames': set(), 'responsenames': set(), 'objectivenames': set(), 'constraintnames': set(), 'sysinclnames': set(), } self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None # Driver options self.options = OptionsDictionary() self.options.declare('debug_print', types=list, check_valid=_check_debug_print_opts_valid, desc="List of what type of Driver variables to print at each " "iteration. Valid items in list are 'desvars', 'ln_cons', " "'nl_cons', 'objs', 'totals'", default=[]) # Case recording options self.recording_options = OptionsDictionary() self.recording_options.declare('record_model_metadata', types=bool, default=True, desc='Record metadata for all Systems in the model') self.recording_options.declare('record_desvars', types=bool, default=True, desc='Set to True to record design variables at the ' 'driver level') self.recording_options.declare('record_responses', types=bool, default=False, desc='Set to True to record responses at the driver level') self.recording_options.declare('record_objectives', types=bool, default=True, desc='Set to True to record objectives at the driver level') self.recording_options.declare('record_constraints', types=bool, default=True, desc='Set to True to record constraints at the ' 'driver level') self.recording_options.declare('includes', types=list, default=[], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') self.recording_options.declare('record_derivatives', types=bool, default=False, desc='Set to True to record derivatives at the driver ' 'level') self.recording_options.declare('record_inputs', types=bool, default=True, desc='Set to True to record inputs at the driver level') # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', types=bool, default=False) self.supports.declare('equality_constraints', types=bool, default=False) self.supports.declare('linear_constraints', types=bool, default=False) self.supports.declare('two_sided_constraints', types=bool, default=False) self.supports.declare('multiple_objectives', types=bool, default=False) self.supports.declare('integer_design_vars', types=bool, default=False) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('active_set', types=bool, default=False) self.supports.declare('simultaneous_derivatives', types=bool, default=False) self.supports.declare('total_jac_sparsity', types=bool, default=False) self.iter_count = 0 self._model_viewer_data = None self.cite = "" self._simul_coloring_info = None self._total_jac_sparsity = None self._res_jacs = {} self._total_jac = None self.fail = False self._declare_options() self.options.update(kwargs)
class Jacobian(object): """ Base Jacobian class. This class provides a dictionary interface for sub-Jacobians and performs matrix-vector products when apply_linear is called. Attributes ---------- _system : <System> Pointer to the system that is currently operating on this Jacobian. _subjacs : dict Dictionary of the user-supplied sub-Jacobians keyed by absolute names. _subjacs_info : dict Dictionary of the sub-Jacobian metadata keyed by absolute names. options : <OptionsDictionary> Options dictionary. _override_checks : bool If we are approximating a jacobian at the top level and we have specified indices on the functions or designvars, then we need to disable the size checking temporarily so that we can assign a jacobian with less rows or columns than the variable sizes. """ def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict options dictionary. """ self._system = None self._subjacs = {} self._subjacs_info = {} self.options = OptionsDictionary() self.options.update(kwargs) self._override_checks = False def _abs_key2shape(self, abs_key): """ Return shape of sub-jacobian for variables making up the key tuple. Parameters ---------- abs_key : (str, str) Absolute name pair of sub-Jacobian. Returns ------- out_size : int local size of the output variable. in_size : int local size of the input variable. """ abs2meta = self._system._var_allprocs_abs2meta return (abs2meta[abs_key[0]]['size'], abs2meta[abs_key[1]]['size']) def _multiply_subjac(self, abs_key, val): """ Multiply this sub-Jacobian by val. Parameters ---------- abs_key : (str, str) Absolute name pair of sub-Jacobian. val : float value to multiply by. """ jac = self._subjacs[abs_key] if isinstance(jac, np.ndarray): self._subjacs[abs_key] *= val elif isinstance(jac, sparse_types): self._subjacs[abs_key].data *= val # DOK not supported elif len(jac) == 3: self._subjacs[abs_key][0] *= val else: self._subjacs[abs_key] *= val def __contains__(self, key): """ Return whether there is a subjac for the given promoted or relative name pair. Parameters ---------- key : (str, str) Promoted or relative name pair of sub-Jacobian. Returns ------- boolean return whether sub-Jacobian has been defined. """ return key2abs_key(self._system, key) in self._subjacs def __getitem__(self, key): """ Get sub-Jacobian. Parameters ---------- key : (str, str) Promoted or relative name pair of sub-Jacobian. Returns ------- ndarray or spmatrix or list[3] sub-Jacobian as an array, sparse mtx, or AIJ/IJ list or tuple. """ abs_key = key2abs_key(self._system, key) if abs_key in self._subjacs: subjac = self._subjacs[abs_key] if isinstance(subjac, list): # Sparse AIJ format return subjac[0] return subjac else: msg = 'Variable name pair ("{}", "{}") not found.' raise KeyError(msg.format(key[0], key[1])) def __setitem__(self, key, subjac): """ Set sub-Jacobian. Parameters ---------- key : (str, str) Promoted or relative name pair of sub-Jacobian. subjac : int or float or ndarray or sparse matrix sub-Jacobian as a scalar, vector, array, or AIJ list or tuple. """ abs_key = key2abs_key(self._system, key) if abs_key is not None: # You can only set declared subjacobians. if abs_key not in self._subjacs_info: msg = 'Variable name pair ("{}", "{}") must first be declared.' raise KeyError(msg.format(key[0], key[1])) self._set_abs(abs_key, subjac) else: msg = 'Variable name pair ("{}", "{}") not found.' raise KeyError(msg.format(key[0], key[1])) def _set_abs(self, abs_key, subjac): """ Set sub-Jacobian. Parameters ---------- abs_key : (str, str) Absolute name pair of sub-Jacobian. subjac : int or float or ndarray or sparse matrix sub-Jacobian as a scalar, vector, array, or AIJ list or tuple. """ if not issparse(subjac): # np.promote_types will choose the smallest dtype that can contain both arguments subjac = np.atleast_1d(subjac) safe_dtype = np.promote_types(subjac.dtype, float) subjac = subjac.astype(safe_dtype, copy=False) # Bail here so that we allow top level jacobians to be of reduced size when indices are # specified on driver vars. if self._override_checks: self._subjacs[abs_key] = subjac return if abs_key in self._subjacs_info: subjac_info = self._subjacs_info[abs_key][0] rows = subjac_info['rows'] else: rows = None if rows is None: # Dense subjac shape = self._abs_key2shape(abs_key) subjac = np.atleast_2d(subjac) if subjac.shape == (1, 1): subjac = subjac[0, 0] * np.ones(shape, dtype=safe_dtype) else: subjac = subjac.reshape(shape) if abs_key in self._subjacs and self._subjacs[abs_key].shape == shape: np.copyto(self._subjacs[abs_key], subjac) else: self._subjacs[abs_key] = subjac.copy() else: # Sparse subjac if subjac.shape == (1,): subjac = subjac[0] * np.ones(rows.shape, dtype=safe_dtype) if subjac.shape != rows.shape: raise ValueError("Sub-jacobian for key %s has " "the wrong shape (%s), expected (%s)." % (abs_key, subjac.shape, rows.shape)) if abs_key in self._subjacs and subjac.shape == self._subjacs[abs_key][0].shape: np.copyto(self._subjacs[abs_key][0], subjac) else: self._subjacs[abs_key] = [subjac.copy(), rows, subjac_info['cols']] else: self._subjacs[abs_key] = subjac def _initialize(self): """ Allocate the global matrices. """ pass def _update(self): """ Read the user's sub-Jacobians and set into the global matrix. """ pass def _apply(self, d_inputs, d_outputs, d_residuals, mode): """ Compute matrix-vector product. Parameters ---------- d_inputs : Vector inputs linear vector. d_outputs : Vector outputs linear vector. d_residuals : Vector residuals linear vector. mode : str 'fwd' or 'rev'. """ pass def _set_partials_meta(self, abs_key, meta, negate=False): """ Store subjacobian metadata. Parameters ---------- abs_key : (str, str) Absolute name pair of sub-Jacobian. meta : dict Metadata dictionary for the subjacobian. negate : bool If True negate the given value, if any. """ shape = self._abs_key2shape(abs_key) self._subjacs_info[abs_key] = (meta, shape) val = meta['value'] if val is not None: self._set_abs(abs_key, val) if negate: self._multiply_subjac(abs_key, -1.0)
class Solver(object): """ Base solver class. This class is subclassed by NonlinearSolver and LinearSolver, which are in turn subclassed by actual solver implementations. Attributes ---------- _system : <System> Pointer to the owning system. _depth : int How many subsolvers deep this solver is (0 means not a subsolver). _vec_names : [str, ...] List of right-hand-side (RHS) vector names. _mode : str 'fwd' or 'rev', applicable to linear solvers only. _iter_count : int Number of iterations for the current invocation of the solver. _rec_mgr : <RecordingManager> object that manages all recorders added to this solver cite : str Listing of relevant citations that should be referenced when publishing work that uses this class. options : <OptionsDictionary> Options dictionary. recording_options : <OptionsDictionary> Recording options dictionary. supports : <OptionsDictionary> Options dictionary describing what features are supported by this solver. _filtered_vars_to_record: Dict Dict of list of var names to record _norm0: float Normalization factor _solver_info : SolverInfo A stack-like object shared by all Solvers in the model. """ # Object to store some formatting for iprint that is shared across all solvers. SOLVER = 'base_solver' def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict of keyword arguments Keyword arguments that will be mapped into the Solver options. """ self._system = None self._depth = 0 self._vec_names = None self._mode = 'fwd' self._iter_count = 0 self._solver_info = None # Solver options self.options = OptionsDictionary(parent_name=self.msginfo) self.options.declare('maxiter', types=int, default=10, desc='maximum number of iterations') self.options.declare('atol', default=1e-10, desc='absolute error tolerance') self.options.declare('rtol', default=1e-10, desc='relative error tolerance') self.options.declare('iprint', types=int, default=1, desc='whether to print output') self.options.declare('err_on_maxiter', types=bool, default=None, allow_none=True, desc="Deprecated. Use 'err_on_non_converge'.") self.options.declare('err_on_non_converge', types=bool, default=False, desc="When True, AnalysisError will be raised if we don't converge.") # Case recording options self.recording_options = OptionsDictionary(parent_name=self.msginfo) self.recording_options.declare('record_abs_error', types=bool, default=True, desc='Set to True to record absolute error at the \ solver level') self.recording_options.declare('record_rel_error', types=bool, default=True, desc='Set to True to record relative error at the \ solver level') self.recording_options.declare('record_inputs', types=bool, default=True, desc='Set to True to record inputs at the solver level') self.recording_options.declare('record_outputs', types=bool, default=True, desc='Set to True to record outputs at the solver level') self.recording_options.declare('record_solver_residuals', types=bool, default=False, desc='Set to True to record residuals at the solver level') self.recording_options.declare('record_metadata', types=bool, desc='Record metadata', default=True) self.recording_options.declare('includes', types=list, default=['*'], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') # Case recording related self._filtered_vars_to_record = {} self._norm0 = 0.0 # What the solver supports. self.supports = OptionsDictionary(parent_name=self.msginfo) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('implicit_components', types=bool, default=False) self._declare_options() self.options.update(kwargs) self._rec_mgr = RecordingManager() self.cite = "" @property def msginfo(self): """ Return info to prepend to messages. Returns ------- str Info to prepend to messages. """ if self._system is None: return type(self).__name__ return '{} in {}'.format(type(self).__name__, self._system().msginfo) def _assembled_jac_solver_iter(self): """ Return an empty generator of lin solvers using assembled jacs. """ for i in (): yield def add_recorder(self, recorder): """ Add a recorder to the solver's RecordingManager. Parameters ---------- recorder : <CaseRecorder> A recorder instance to be added to RecManager. """ if MPI: raise RuntimeError( "Recording of Solvers when running parallel code is not supported yet") self._rec_mgr.append(recorder) def _declare_options(self): """ Declare options before kwargs are processed in the init method. This is optionally implemented by subclasses of Solver. """ pass def _setup_solvers(self, system, depth): """ Assign system instance, set depth, and optionally perform setup. Parameters ---------- system : <System> pointer to the owning system. depth : int depth of the current system (already incremented). """ self._system = weakref.ref(system) self._depth = depth self._solver_info = system._solver_info self._recording_iter = system._recording_iter if system.pathname: parent_name = self.msginfo self.options._parent_name = parent_name self.recording_options._parent_name = parent_name self.supports._parent_name = parent_name if isinstance(self, LinearSolver) and not system._use_derivatives: return self._rec_mgr.startup(self) self._rec_mgr.record_metadata(self) myoutputs = myresiduals = myinputs = set() incl = self.recording_options['includes'] excl = self.recording_options['excludes'] if self.recording_options['record_solver_residuals']: if isinstance(self, NonlinearSolver): residuals = system._residuals else: # it's a LinearSolver residuals = system._vectors['residual']['linear'] myresiduals = {n for n in residuals._names if check_path(n, incl, excl)} if self.recording_options['record_outputs']: if isinstance(self, NonlinearSolver): outputs = system._outputs else: # it's a LinearSolver outputs = system._vectors['output']['linear'] myoutputs = {n for n in outputs._names if check_path(n, incl, excl)} if self.recording_options['record_inputs']: if isinstance(self, NonlinearSolver): inputs = system._inputs else: inputs = system._vectors['input']['linear'] myinputs = {n for n in inputs._names if check_path(n, incl, excl)} self._filtered_vars_to_record = { 'in': myinputs, 'out': myoutputs, 'res': myresiduals } # Raise a deprecation warning for changed option. if 'err_on_maxiter' in self.options and self.options['err_on_maxiter'] is not None: self.options['err_on_non_converge'] = self.options['err_on_maxiter'] warn_deprecation("The 'err_on_maxiter' option provides backwards compatibility " "with earlier version of OpenMDAO; use options['err_on_non_converge'] " "instead.") def _set_solver_print(self, level=2, type_='all'): """ Control printing for solvers and subsolvers in the model. Parameters ---------- level : int iprint level. Set to 2 to print residuals each iteration; set to 1 to print just the iteration totals; set to 0 to disable all printing except for failures, and set to -1 to disable all printing including failures. type_ : str Type of solver to set: 'LN' for linear, 'NL' for nonlinear, or 'all' for all. """ self.options['iprint'] = level def _mpi_print(self, iteration, abs_res, rel_res): """ Print residuals from an iteration. Parameters ---------- iteration : int iteration counter, 0-based. abs_res : float current absolute residual norm. rel_res : float current relative residual norm. """ if (self.options['iprint'] == 2 and self._system().comm.rank == 0): prefix = self._solver_info.prefix solver_name = self.SOLVER if prefix.endswith('precon:'): solver_name = solver_name[3:] print_str = prefix + solver_name print_str += ' %d ; %.9g %.9g' % (iteration, abs_res, rel_res) print(print_str) def _mpi_print_header(self): """ Print header text before solving. """ pass def _solve(self): """ Run the iterative solver. """ maxiter = self.options['maxiter'] atol = self.options['atol'] rtol = self.options['rtol'] iprint = self.options['iprint'] self._mpi_print_header() self._iter_count = 0 norm0, norm = self._iter_initialize() self._norm0 = norm0 self._mpi_print(self._iter_count, norm, norm / norm0) while self._iter_count < maxiter and norm > atol and norm / norm0 > rtol: with Recording(type(self).__name__, self._iter_count, self) as rec: self._single_iteration() self._iter_count += 1 self._run_apply() norm = self._iter_get_norm() # With solvers, we want to record the norm AFTER the call, but the call needs to # be wrapped in the with for stack purposes, so we locally assign norm & norm0 # into the class. rec.abs = norm rec.rel = norm / norm0 if norm0 == 0: norm0 = 1 self._mpi_print(self._iter_count, norm, norm / norm0) system = self._system() if system.comm.rank == 0 or os.environ.get('USE_PROC_FILES'): prefix = self._solver_info.prefix + self.SOLVER # Solver terminated early because a Nan in the norm doesn't satisfy the while-loop # conditionals. if np.isinf(norm) or np.isnan(norm): msg = "Solver '{}' on system '{}': residuals contain 'inf' or 'NaN' after {} " + \ "iterations." if iprint > -1: print(prefix + msg.format(self.SOLVER, system.pathname, self._iter_count)) # Raise AnalysisError if requested. if self.options['err_on_non_converge']: raise AnalysisError(msg.format(self.SOLVER, system.pathname, self._iter_count)) # Solver hit maxiter without meeting desired tolerances. elif (norm > atol and norm / norm0 > rtol): msg = "Solver '{}' on system '{}' failed to converge in {} iterations." if iprint > -1: print(prefix + msg.format(self.SOLVER, system.pathname, self._iter_count)) # Raise AnalysisError if requested. if self.options['err_on_non_converge']: raise AnalysisError(msg.format(self.SOLVER, system.pathname, self._iter_count)) # Solver converged elif iprint == 1: print(prefix + ' Converged in {} iterations'.format(self._iter_count)) elif iprint == 2: print(prefix + ' Converged') def _iter_initialize(self): """ Perform any necessary pre-processing operations. Returns ------- float initial error. float error at the first iteration. """ pass def _run_apply(self): """ Run the appropriate apply method on the system. """ pass def _linearize(self): """ Perform any required linearization operations such as matrix factorization. """ pass def _linearize_children(self): """ Return a flag that is True when we need to call linearize on our subsystems' solvers. Returns ------- boolean Flag for indicating child linerization """ return True def __str__(self): """ Return a string representation of the solver. Returns ------- str String representation of the solver. """ return self.SOLVER def record_iteration(self, **kwargs): """ Record an iteration of the current Solver. Parameters ---------- **kwargs : dict Keyword arguments (used for abs and rel error). """ if not self._rec_mgr._recorders: return metadata = create_local_meta(self.SOLVER) # Get the data data = {} if self.recording_options['record_abs_error']: data['abs'] = kwargs.get('abs') else: data['abs'] = None if self.recording_options['record_rel_error']: data['rel'] = kwargs.get('rel') else: data['rel'] = None system = self._system() if isinstance(self, NonlinearSolver): outputs = system._outputs inputs = system._inputs residuals = system._residuals else: # it's a LinearSolver outputs = system._vectors['output']['linear'] inputs = system._vectors['input']['linear'] residuals = system._vectors['residual']['linear'] if self.recording_options['record_outputs']: data['o'] = {} if 'out' in self._filtered_vars_to_record: for out in self._filtered_vars_to_record['out']: if out in outputs._names: data['o'][out] = outputs._views[out] else: data['o'] = outputs else: data['o'] = None if self.recording_options['record_inputs']: data['i'] = {} if 'in' in self._filtered_vars_to_record: for inp in self._filtered_vars_to_record['in']: if inp in inputs._names: data['i'][inp] = inputs._views[inp] else: data['i'] = inputs else: data['i'] = None if self.recording_options['record_solver_residuals']: data['r'] = {} if 'res' in self._filtered_vars_to_record: for res in self._filtered_vars_to_record['res']: if res in residuals._names: data['r'][res] = residuals._views[res] else: data['r'] = residuals else: data['r'] = None self._rec_mgr.record_iteration(self, data, metadata) def cleanup(self): """ Clean up resources prior to exit. """ # shut down all recorders self._rec_mgr.shutdown() def _set_complex_step_mode(self, active): """ Turn on or off complex stepping mode. Recurses to turn on or off complex stepping mode in all subsystems and their vectors. Parameters ---------- active : bool Complex mode flag; set to True prior to commencing complex step. """ pass
def __init__(self): """ Initialize the driver. """ self._rec_mgr = RecordingManager() self._vars_to_record = { 'desvarnames': set(), 'responsenames': set(), 'objectivenames': set(), 'constraintnames': set(), 'sysinclnames': set(), } self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None self.options = OptionsDictionary() self.recording_options = OptionsDictionary() ########################### self.recording_options.declare('record_desvars', types=bool, default=True, desc='Set to True to record design variables at the \ driver level') self.recording_options.declare('record_responses', types=bool, default=False, desc='Set to True to record responses at the driver level') self.recording_options.declare('record_objectives', types=bool, default=True, desc='Set to True to record objectives at the \ driver level') self.recording_options.declare('record_constraints', types=bool, default=True, desc='Set to True to record constraints at the \ driver level') self.recording_options.declare('includes', types=list, default=[], desc='Patterns for variables to include in recording. \ Uses fnmatch wildcards') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes). Uses fnmatch wildcards') self.recording_options.declare('record_derivatives', types=bool, default=False, desc='Set to True to record derivatives at the driver \ level') ########################### # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', types=bool, default=False) self.supports.declare('equality_constraints', types=bool, default=False) self.supports.declare('linear_constraints', types=bool, default=False) self.supports.declare('two_sided_constraints', types=bool, default=False) self.supports.declare('multiple_objectives', types=bool, default=False) self.supports.declare('integer_design_vars', types=bool, default=False) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('active_set', types=bool, default=False) self.supports.declare('simultaneous_derivatives', types=bool, default=False) self.supports.declare('distributed_design_vars', types=bool, default=False) self.iter_count = 0 self.options = None self._model_viewer_data = None self.cite = "" # TODO, support these in OpenMDAO self.supports.declare('integer_design_vars', types=bool, default=False) self._res_jacs = {} self.fail = False
class Solver(object): """ Base solver class. This class is subclassed by NonlinearSolver and LinearSolver, which are in turn subclassed by actual solver implementations. Attributes ---------- _system : <System> Pointer to the owning system. _depth : int How many subsolvers deep this solver is (0 means not a subsolver). _vec_names : [str, ...] List of right-hand-side (RHS) vector names. _mode : str 'fwd' or 'rev', applicable to linear solvers only. _iter_count : int Number of iterations for the current invocation of the solver. _rec_mgr : <RecordingManager> object that manages all recorders added to this solver cite : str Listing of relevant citations that should be referenced when publishing work that uses this class. options : <OptionsDictionary> Options dictionary. recording_options : <OptionsDictionary> Recording options dictionary. supports : <OptionsDictionary> Options dictionary describing what features are supported by this solver. _filtered_vars_to_record: Dict Dict of list of var names to record _norm0: float Normalization factor _solver_info : SolverInfo A stack-like object shared by all Solvers in the model. """ # Object to store some formatting for iprint that is shared across all solvers. SOLVER = 'base_solver' def __init__(self, **kwargs): """ Initialize all attributes. Parameters ---------- **kwargs : dict of keyword arguments Keyword arguments that will be mapped into the Solver options. """ self._system = None self._depth = 0 self._vec_names = None self._mode = 'fwd' self._iter_count = 0 self._solver_info = None # Solver options self.options = OptionsDictionary() self.options.declare('maxiter', types=int, default=10, desc='maximum number of iterations') self.options.declare('atol', default=1e-10, desc='absolute error tolerance') self.options.declare('rtol', default=1e-10, desc='relative error tolerance') self.options.declare('iprint', types=int, default=1, desc='whether to print output') self.options.declare('err_on_maxiter', types=bool, default=False, desc="When True, AnalysisError will be raised if we don't converge.") # Case recording options self.recording_options = OptionsDictionary() self.recording_options.declare('record_abs_error', types=bool, default=True, desc='Set to True to record absolute error at the \ solver level') self.recording_options.declare('record_rel_error', types=bool, default=True, desc='Set to True to record relative error at the \ solver level') self.recording_options.declare('record_inputs', types=bool, default=True, desc='Set to True to record inputs at the solver level') self.recording_options.declare('record_outputs', types=bool, default=True, desc='Set to True to record outputs at the solver level') self.recording_options.declare('record_solver_residuals', types=bool, default=False, desc='Set to True to record residuals at the solver level') self.recording_options.declare('record_metadata', types=bool, desc='Record metadata', default=True) self.recording_options.declare('includes', types=list, default=['*'], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') # Case recording related self._filtered_vars_to_record = {} self._norm0 = 0.0 # What the solver supports. self.supports = OptionsDictionary() self.supports.declare('gradients', types=bool, default=False) self.supports.declare('implicit_components', types=bool, default=False) self._declare_options() self.options.update(kwargs) self._rec_mgr = RecordingManager() self.cite = "" def _assembled_jac_solver_iter(self): """ Return an empty generator of lin solvers using assembled jacs. """ for i in (): yield def add_recorder(self, recorder): """ Add a recorder to the solver's RecordingManager. Parameters ---------- recorder : <CaseRecorder> A recorder instance to be added to RecManager. """ if MPI: raise RuntimeError( "Recording of Solvers when running parallel code is not supported yet") self._rec_mgr.append(recorder) def _declare_options(self): """ Declare options before kwargs are processed in the init method. This is optionally implemented by subclasses of Solver. """ pass def _setup_solvers(self, system, depth): """ Assign system instance, set depth, and optionally perform setup. Parameters ---------- system : <System> pointer to the owning system. depth : int depth of the current system (already incremented). """ self._system = system self._depth = depth self._solver_info = system._solver_info self._recording_iter = system._recording_iter if isinstance(self, LinearSolver) and not system._use_derivatives: return self._rec_mgr.startup(self) self._rec_mgr.record_metadata(self) myoutputs = myresiduals = myinputs = set() incl = self.recording_options['includes'] excl = self.recording_options['excludes'] if self.recording_options['record_solver_residuals']: if isinstance(self, NonlinearSolver): residuals = system._residuals else: # it's a LinearSolver residuals = system._vectors['residual']['linear'] myresiduals = {n for n in residuals._names if check_path(n, incl, excl)} if self.recording_options['record_outputs']: if isinstance(self, NonlinearSolver): outputs = system._outputs else: # it's a LinearSolver outputs = system._vectors['output']['linear'] myoutputs = {n for n in outputs._names if check_path(n, incl, excl)} if self.recording_options['record_inputs']: if isinstance(self, NonlinearSolver): inputs = system._inputs else: inputs = system._vectors['input']['linear'] myinputs = {n for n in inputs._names if check_path(n, incl, excl)} self._filtered_vars_to_record = { 'in': myinputs, 'out': myoutputs, 'res': myresiduals } def _set_solver_print(self, level=2, type_='all'): """ Control printing for solvers and subsolvers in the model. Parameters ---------- level : int iprint level. Set to 2 to print residuals each iteration; set to 1 to print just the iteration totals; set to 0 to disable all printing except for failures, and set to -1 to disable all printing including failures. type_ : str Type of solver to set: 'LN' for linear, 'NL' for nonlinear, or 'all' for all. """ self.options['iprint'] = level def _mpi_print(self, iteration, abs_res, rel_res): """ Print residuals from an iteration. Parameters ---------- iteration : int iteration counter, 0-based. abs_res : float current absolute residual norm. rel_res : float current relative residual norm. """ if (self.options['iprint'] == 2 and self._system.comm.rank == 0): prefix = self._solver_info.prefix solver_name = self.SOLVER if prefix.endswith('precon:'): solver_name = solver_name[3:] print_str = prefix + solver_name print_str += ' %d ; %.9g %.9g' % (iteration, abs_res, rel_res) print(print_str) def _mpi_print_header(self): """ Print header text before solving. """ pass def _solve(self): """ Run the iterative solver. """ maxiter = self.options['maxiter'] atol = self.options['atol'] rtol = self.options['rtol'] iprint = self.options['iprint'] self._mpi_print_header() self._iter_count = 0 norm0, norm = self._iter_initialize() self._norm0 = norm0 self._mpi_print(self._iter_count, norm, norm / norm0) while self._iter_count < maxiter and norm > atol and norm / norm0 > rtol: with Recording(type(self).__name__, self._iter_count, self) as rec: self._single_iteration() self._iter_count += 1 self._run_apply() norm = self._iter_get_norm() # With solvers, we want to record the norm AFTER the call, but the call needs to # be wrapped in the with for stack purposes, so we locally assign norm & norm0 # into the class. rec.abs = norm rec.rel = norm / norm0 if norm0 == 0: norm0 = 1 self._mpi_print(self._iter_count, norm, norm / norm0) if self._system.comm.rank == 0 or os.environ.get('USE_PROC_FILES'): prefix = self._solver_info.prefix + self.SOLVER if np.isinf(norm) or np.isnan(norm) or (norm > atol and norm / norm0 > rtol): if iprint > -1: msg = ' Failed to Converge in {} iterations'.format(self._iter_count) print(prefix + msg) # Raise AnalysisError if requested. if self.options['err_on_maxiter']: msg = "Solver '{}' on system '{}' failed to converge." raise AnalysisError(msg.format(self.SOLVER, self._system.pathname)) elif iprint == 1: print(prefix + ' Converged in {} iterations'.format(self._iter_count)) elif iprint == 2: print(prefix + ' Converged') def _iter_initialize(self): """ Perform any necessary pre-processing operations. Returns ------- float initial error. float error at the first iteration. """ pass def _run_apply(self): """ Run the appropriate apply method on the system. """ pass def _linearize(self): """ Perform any required linearization operations such as matrix factorization. """ pass def _linearize_children(self): """ Return a flag that is True when we need to call linearize on our subsystems' solvers. Returns ------- boolean Flag for indicating child linerization """ return True def __str__(self): """ Return a string representation of the solver. Returns ------- str String representation of the solver. """ return self.SOLVER def record_iteration(self, **kwargs): """ Record an iteration of the current Solver. Parameters ---------- **kwargs : dict Keyword arguments (used for abs and rel error). """ if not self._rec_mgr._recorders: return metadata = create_local_meta(self.SOLVER) # Get the data data = {} if self.recording_options['record_abs_error']: data['abs'] = kwargs.get('abs') else: data['abs'] = None if self.recording_options['record_rel_error']: data['rel'] = kwargs.get('rel') else: data['rel'] = None system = self._system if isinstance(self, NonlinearSolver): outputs = system._outputs inputs = system._inputs residuals = system._residuals else: # it's a LinearSolver outputs = system._vectors['output']['linear'] inputs = system._vectors['input']['linear'] residuals = system._vectors['residual']['linear'] if self.recording_options['record_outputs']: data['o'] = {} if 'out' in self._filtered_vars_to_record: for out in self._filtered_vars_to_record['out']: if out in outputs._names: data['o'][out] = outputs._views[out] else: data['o'] = outputs else: data['o'] = None if self.recording_options['record_inputs']: data['i'] = {} if 'in' in self._filtered_vars_to_record: for inp in self._filtered_vars_to_record['in']: if inp in inputs._names: data['i'][inp] = inputs._views[inp] else: data['i'] = inputs else: data['i'] = None if self.recording_options['record_solver_residuals']: data['r'] = {} if 'res' in self._filtered_vars_to_record: for res in self._filtered_vars_to_record['res']: if res in residuals._names: data['r'][res] = residuals._views[res] else: data['r'] = residuals else: data['r'] = None self._rec_mgr.record_iteration(self, data, metadata) def cleanup(self): """ Clean up resources prior to exit. """ # shut down all recorders self._rec_mgr.shutdown() def _set_complex_step_mode(self, active): """ Turn on or off complex stepping mode. Recurses to turn on or off complex stepping mode in all subsystems and their vectors. Parameters ---------- active : bool Complex mode flag; set to True prior to commencing complex step. """ pass
class Driver(object): """ Top-level container for the systems and drivers. Options ------- options['debug_print'] : list of strings([]) Indicates what variables to print at each iteration. The valid options are: 'desvars','ln_cons','nl_cons',and 'objs'. recording_options['record_metadata'] : bool(True) Tells recorder whether to record variable attribute metadata. recording_options['record_desvars'] : bool(True) Tells recorder whether to record the desvars of the Driver. recording_options['record_responses'] : bool(False) Tells recorder whether to record the responses of the Driver. recording_options['record_objectives'] : bool(False) Tells recorder whether to record the objectives of the Driver. recording_options['record_constraints'] : bool(False) Tells recorder whether to record the constraints of the Driver. recording_options['includes'] : list of strings("*") Patterns for variables to include in recording. recording_options['excludes'] : list of strings('') Patterns for variables to exclude in recording (processed after includes). Attributes ---------- fail : bool Reports whether the driver ran successfully. iter_count : int Keep track of iterations for case recording. metadata : list List of metadata options : <OptionsDictionary> Dictionary with general pyoptsparse options. recording_options : <OptionsDictionary> Dictionary with driver recording options. debug_print : <OptionsDictionary> Dictionary with debugging printing options. cite : str Listing of relevant citataions that should be referenced when publishing work that uses this class. _problem : <Problem> Pointer to the containing problem. supports : <OptionsDictionary> Provides a consistant way for drivers to declare what features they support. _designvars : dict Contains all design variable info. _cons : dict Contains all constraint info. _objs : dict Contains all objective info. _responses : dict Contains all response info. _rec_mgr : <RecordingManager> Object that manages all recorders added to this driver. _vars_to_record: dict Dict of lists of var names indicating what to record _model_viewer_data : dict Structure of model, used to make n2 diagram. _remote_dvs : dict Dict of design variables that are remote on at least one proc. Values are (owning rank, size). _remote_cons : dict Dict of constraints that are remote on at least one proc. Values are (owning rank, size). _remote_objs : dict Dict of objectives that are remote on at least one proc. Values are (owning rank, size). _remote_responses : dict A combined dict containing entries from _remote_cons and _remote_objs. _simul_coloring_info : tuple of dicts A data structure describing coloring for simultaneous derivs. _res_jacs : dict Dict of sparse subjacobians for use with certain optimizers, e.g. pyOptSparseDriver. """ def __init__(self): """ Initialize the driver. """ self._rec_mgr = RecordingManager() self._vars_to_record = { 'desvarnames': set(), 'responsenames': set(), 'objectivenames': set(), 'constraintnames': set(), 'sysinclnames': set(), } self._problem = None self._designvars = None self._cons = None self._objs = None self._responses = None self.options = OptionsDictionary() self.recording_options = OptionsDictionary() ########################### self.options.declare('debug_print', types=list, is_valid=_is_debug_print_opts_valid, desc="List of what type of Driver variables to print at each " "iteration. Valid items in list are 'desvars','ln_cons'," "'nl_cons','objs'", default=[]) ########################### self.recording_options.declare('record_metadata', types=bool, desc='Record metadata', default=True) self.recording_options.declare('record_desvars', types=bool, default=True, desc='Set to True to record design variables at the \ driver level') self.recording_options.declare('record_responses', types=bool, default=False, desc='Set to True to record responses at the driver level') self.recording_options.declare('record_objectives', types=bool, default=True, desc='Set to True to record objectives at the \ driver level') self.recording_options.declare('record_constraints', types=bool, default=True, desc='Set to True to record constraints at the \ driver level') self.recording_options.declare('includes', types=list, default=['*'], desc='Patterns for variables to include in recording') self.recording_options.declare('excludes', types=list, default=[], desc='Patterns for vars to exclude in recording ' '(processed post-includes)') self.recording_options.declare('record_derivatives', types=bool, default=False, desc='Set to True to record derivatives at the driver \ level') ########################### # What the driver supports. self.supports = OptionsDictionary() self.supports.declare('inequality_constraints', types=bool, default=False) self.supports.declare('equality_constraints', types=bool, default=False) self.supports.declare('linear_constraints', types=bool, default=False) self.supports.declare('two_sided_constraints', types=bool, default=False) self.supports.declare('multiple_objectives', types=bool, default=False) self.supports.declare('integer_design_vars', types=bool, default=False) self.supports.declare('gradients', types=bool, default=False) self.supports.declare('active_set', types=bool, default=False) self.supports.declare('simultaneous_derivatives', types=bool, default=False) # Debug printing. self.debug_print = OptionsDictionary() self.debug_print.declare('debug_print', types=bool, default=False, desc='Overall option to turn on Driver debug printing') self.debug_print.declare('debug_print_desvars', types=bool, default=False, desc='Print design variables') self.debug_print.declare('debug_print_nl_con', types=bool, default=False, desc='Print nonlinear constraints') self.debug_print.declare('debug_print_ln_con', types=bool, default=False, desc='Print linear constraints') self.debug_print.declare('debug_print_objective', types=bool, default=False, desc='Print objectives') self.iter_count = 0 self.metadata = None self._model_viewer_data = None self.cite = "" # TODO, support these in OpenMDAO self.supports.declare('integer_design_vars', types=bool, default=False) self._simul_coloring_info = None self._res_jacs = {} self.fail = False def add_recorder(self, recorder): """ Add a recorder to the driver. Parameters ---------- recorder : BaseRecorder A recorder instance. """ self._rec_mgr.append(recorder) def cleanup(self): """ Clean up resources prior to exit. """ self._rec_mgr.close() def _setup_driver(self, problem): """ Prepare the driver for execution. This is the final thing to run during setup. Parameters ---------- problem : <Problem> Pointer to the containing problem. """ self._problem = problem model = problem.model self._objs = objs = OrderedDict() self._cons = cons = OrderedDict() self._responses = model.get_responses(recurse=True) response_size = 0 for name, data in iteritems(self._responses): if data['type'] == 'con': cons[name] = data else: objs[name] = data response_size += data['size'] # Gather up the information for design vars. self._designvars = model.get_design_vars(recurse=True) desvar_size = np.sum(data['size'] for data in itervalues(self._designvars)) if ((problem._mode == 'fwd' and desvar_size > response_size) or (problem._mode == 'rev' and response_size > desvar_size)): warnings.warn("Inefficient choice of derivative mode. You chose '%s' for a " "problem with %d design variables and %d response variables " "(objectives and constraints)." % (problem._mode, desvar_size, response_size), RuntimeWarning) self._has_scaling = ( np.any([r['scaler'] is not None for r in self._responses.values()]) or np.any([dv['scaler'] is not None for dv in self._designvars.values()]) ) con_set = set() obj_set = set() dv_set = set() self._remote_dvs = dv_dict = {} self._remote_cons = con_dict = {} self._remote_objs = obj_dict = {} # Now determine if later we'll need to allgather cons, objs, or desvars. if model.comm.size > 1 and model._subsystems_allprocs: local_out_vars = set(model._outputs._views) remote_dvs = set(self._designvars) - local_out_vars remote_cons = set(self._cons) - local_out_vars remote_objs = set(self._objs) - local_out_vars all_remote_vois = model.comm.allgather( (remote_dvs, remote_cons, remote_objs)) for rem_dvs, rem_cons, rem_objs in all_remote_vois: con_set.update(rem_cons) obj_set.update(rem_objs) dv_set.update(rem_dvs) # If we have remote VOIs, pick an owning rank for each and use that # to bcast to others later owning_ranks = model._owning_rank['output'] sizes = model._var_sizes['nonlinear']['output'] for i, vname in enumerate(model._var_allprocs_abs_names['output']): owner = owning_ranks[vname] if vname in dv_set: dv_dict[vname] = (owner, sizes[owner, i]) if vname in con_set: con_dict[vname] = (owner, sizes[owner, i]) if vname in obj_set: obj_dict[vname] = (owner, sizes[owner, i]) self._remote_responses = self._remote_cons.copy() self._remote_responses.update(self._remote_objs) # Case recording setup mydesvars = myobjectives = myconstraints = myresponses = set() mysystem_outputs = set() incl = self.recording_options['includes'] excl = self.recording_options['excludes'] rec_desvars = self.recording_options['record_desvars'] rec_objectives = self.recording_options['record_objectives'] rec_constraints = self.recording_options['record_constraints'] rec_responses = self.recording_options['record_responses'] all_desvars = {n for n in self._designvars if check_path(n, incl, excl, True)} all_objectives = {n for n in self._objs if check_path(n, incl, excl, True)} all_constraints = {n for n in self._cons if check_path(n, incl, excl, True)} if rec_desvars: mydesvars = all_desvars if rec_objectives: myobjectives = all_objectives if rec_constraints: myconstraints = all_constraints if rec_responses: myresponses = {n for n in self._responses if check_path(n, incl, excl, True)} # get the includes that were requested for this Driver recording if incl: prob = self._problem root = prob.model # The my* variables are sets # First gather all of the desired outputs # The following might only be the local vars if MPI mysystem_outputs = {n for n in root._outputs if check_path(n, incl, excl)} # If MPI, and on rank 0, need to gather up all the variables # even those not local to rank 0 if MPI: all_vars = root.comm.gather(mysystem_outputs, root=0) if MPI.COMM_WORLD.rank == 0: mysystem_outputs = all_vars[-1] for d in all_vars[:-1]: mysystem_outputs.update(d) # de-duplicate mysystem_outputs mysystem_outputs = mysystem_outputs.difference(all_desvars, all_objectives, all_constraints) if MPI: # filter based on who owns the variables # TODO Eventually, we think we can get rid of this next check. But to be safe, # we are leaving it in there. if not model.is_active(): raise RuntimeError( "RecordingManager.startup should never be called when " "running in parallel on an inactive System") rrank = self._problem.comm.rank # root ( aka model ) rank. rowned = model._owning_rank['output'] mydesvars = [n for n in mydesvars if rrank == rowned[n]] myresponses = [n for n in myresponses if rrank == rowned[n]] myobjectives = [n for n in myobjectives if rrank == rowned[n]] myconstraints = [n for n in myconstraints if rrank == rowned[n]] mysystem_outputs = [n for n in mysystem_outputs if rrank == rowned[n]] self._filtered_vars_to_record = { 'des': mydesvars, 'obj': myobjectives, 'con': myconstraints, 'res': myresponses, 'sys': mysystem_outputs, } self._rec_mgr.startup(self) if self._rec_mgr._recorders: from openmdao.devtools.problem_viewer.problem_viewer import _get_viewer_data self._model_viewer_data = _get_viewer_data(problem) if self.recording_options['record_metadata']: self._rec_mgr.record_metadata(self) # set up simultaneous deriv coloring if self._simul_coloring_info and self.supports['simultaneous_derivatives']: if problem._mode == 'fwd': self._setup_simul_coloring(problem._mode) else: raise RuntimeError("simultaneous derivs are currently not supported in rev mode.") def _get_voi_val(self, name, meta, remote_vois): """ Get the value of a variable of interest (objective, constraint, or design var). This will retrieve the value if the VOI is remote. Parameters ---------- name : str Name of the variable of interest. meta : dict Metadata for the variable of interest. remote_vois : dict Dict containing (owning_rank, size) for all remote vois of a particular type (design var, constraint, or objective). Returns ------- float or ndarray The value of the named variable of interest. """ model = self._problem.model comm = model.comm vec = model._outputs._views_flat indices = meta['indices'] if name in remote_vois: owner, size = remote_vois[name] if owner == comm.rank: if indices is None: val = vec[name].copy() else: val = vec[name][indices] else: if indices is not None: size = len(indices) val = np.empty(size) comm.Bcast(val, root=owner) else: if indices is None: val = vec[name].copy() else: val = vec[name][indices] if self._has_scaling: # Scale design variable values adder = meta['adder'] if adder is not None: val += adder scaler = meta['scaler'] if scaler is not None: val *= scaler return val def get_design_var_values(self, filter=None): """ Return the design variable values. This is called to gather the initial design variable state. Parameters ---------- filter : list List of desvar names used by recorders. Returns ------- dict Dictionary containing values of each design variable. """ if filter: dvs = filter else: # use all the designvars dvs = self._designvars return {n: self._get_voi_val(n, self._designvars[n], self._remote_dvs) for n in dvs} def set_design_var(self, name, value): """ Set the value of a design variable. Parameters ---------- name : str Global pathname of the design variable. value : float or ndarray Value for the design variable. """ if (name in self._remote_dvs and self._problem.model._owning_rank['output'][name] != self._problem.comm.rank): return meta = self._designvars[name] indices = meta['indices'] if indices is None: indices = slice(None) desvar = self._problem.model._outputs._views_flat[name] desvar[indices] = value if self._has_scaling: # Scale design variable values scaler = meta['scaler'] if scaler is not None: desvar[indices] *= 1.0 / scaler adder = meta['adder'] if adder is not None: desvar[indices] -= adder def get_response_values(self, filter=None): """ Return response values. Parameters ---------- filter : list List of response names used by recorders. Returns ------- dict Dictionary containing values of each response. """ if filter: resps = filter else: resps = self._responses return {n: self._get_voi_val(n, self._responses[n], self._remote_objs) for n in resps} def get_objective_values(self, filter=None): """ Return objective values. Parameters ---------- filter : list List of objective names used by recorders. Returns ------- dict Dictionary containing values of each objective. """ if filter: objs = filter else: objs = self._objs return {n: self._get_voi_val(n, self._objs[n], self._remote_objs) for n in objs} def get_constraint_values(self, ctype='all', lintype='all', filter=None): """ Return constraint values. Parameters ---------- ctype : string Default is 'all'. Optionally return just the inequality constraints with 'ineq' or the equality constraints with 'eq'. lintype : string Default is 'all'. Optionally return just the linear constraints with 'linear' or the nonlinear constraints with 'nonlinear'. filter : list List of constraint names used by recorders. Returns ------- dict Dictionary containing values of each constraint. """ if filter is not None: cons = filter else: cons = self._cons con_dict = {} for name in cons: meta = self._cons[name] if lintype == 'linear' and not meta['linear']: continue if lintype == 'nonlinear' and meta['linear']: continue if ctype == 'eq' and meta['equals'] is None: continue if ctype == 'ineq' and meta['equals'] is not None: continue con_dict[name] = self._get_voi_val(name, meta, self._remote_cons) return con_dict def run(self): """ Execute this driver. The base `Driver` just runs the model. All other drivers overload this method. Returns ------- boolean Failure flag; True if failed to converge, False is successful. """ with RecordingDebugging(self._get_name(), self.iter_count, self) as rec: failure_flag, _, _ = self._problem.model._solve_nonlinear() self.iter_count += 1 return failure_flag def _dict2array_jac(self, derivs): osize = 0 isize = 0 do_wrt = True islices = {} oslices = {} for okey, oval in iteritems(derivs): if do_wrt: for ikey, val in iteritems(oval): istart = isize isize += val.shape[1] islices[ikey] = slice(istart, isize) do_wrt = False ostart = osize osize += oval[ikey].shape[0] oslices[okey] = slice(ostart, osize) new_derivs = np.zeros((osize, isize)) relevant = self._problem.model._relevant for okey, odict in iteritems(derivs): for ikey, val in iteritems(odict): if okey in relevant[ikey] or ikey in relevant[okey]: new_derivs[oslices[okey], islices[ikey]] = val return new_derivs def _compute_totals(self, of=None, wrt=None, return_format='flat_dict', global_names=True): """ Compute derivatives of desired quantities with respect to desired inputs. All derivatives are returned using driver scaling. Parameters ---------- of : list of variable name strings or None Variables whose derivatives will be computed. Default is None, which uses the driver's objectives and constraints. wrt : list of variable name strings or None Variables with respect to which the derivatives will be computed. Default is None, which uses the driver's desvars. return_format : string Format to return the derivatives. Default is a 'flat_dict', which returns them in a dictionary whose keys are tuples of form (of, wrt). For the scipy optimizer, 'array' is also supported. global_names : bool Set to True when passing in global names to skip some translation steps. Returns ------- derivs : object Derivatives in form requested by 'return_format'. """ prob = self._problem # Compute the derivatives in dict format... if prob.model._owns_approx_jac: derivs = prob._compute_totals_approx(of=of, wrt=wrt, return_format='dict', global_names=global_names) else: derivs = prob._compute_totals(of=of, wrt=wrt, return_format='dict', global_names=global_names) # ... then convert to whatever the driver needs. if return_format in ('dict', 'array'): if self._has_scaling: for okey, odict in iteritems(derivs): for ikey, val in iteritems(odict): iscaler = self._designvars[ikey]['scaler'] oscaler = self._responses[okey]['scaler'] # Scale response side if oscaler is not None: val[:] = (oscaler * val.T).T # Scale design var side if iscaler is not None: val *= 1.0 / iscaler else: raise RuntimeError("Derivative scaling by the driver only supports the 'dict' and " "'array' formats at present.") if return_format == 'array': derivs = self._dict2array_jac(derivs) return derivs def record_iteration(self): """ Record an iteration of the current Driver. """ if not self._rec_mgr._recorders: return metadata = create_local_meta(self._get_name()) # Get the data to record data = {} if self.recording_options['record_desvars']: # collective call that gets across all ranks desvars = self.get_design_var_values() else: desvars = {} if self.recording_options['record_responses']: # responses = self.get_response_values() # not really working yet responses = {} else: responses = {} if self.recording_options['record_objectives']: objectives = self.get_objective_values() else: objectives = {} if self.recording_options['record_constraints']: constraints = self.get_constraint_values() else: constraints = {} desvars = {name: desvars[name] for name in self._filtered_vars_to_record['des']} # responses not working yet # responses = {name: responses[name] for name in self._filtered_vars_to_record['res']} objectives = {name: objectives[name] for name in self._filtered_vars_to_record['obj']} constraints = {name: constraints[name] for name in self._filtered_vars_to_record['con']} if self.recording_options['includes']: root = self._problem.model outputs = root._outputs # outputsinputs, outputs, residuals = root.get_nonlinear_vectors() sysvars = {} for name, value in iteritems(outputs._names): if name in self._filtered_vars_to_record['sys']: sysvars[name] = value else: sysvars = {} if MPI: root = self._problem.model desvars = self._gather_vars(root, desvars) responses = self._gather_vars(root, responses) objectives = self._gather_vars(root, objectives) constraints = self._gather_vars(root, constraints) sysvars = self._gather_vars(root, sysvars) data['des'] = desvars data['res'] = responses data['obj'] = objectives data['con'] = constraints data['sys'] = sysvars self._rec_mgr.record_iteration(self, data, metadata) def _gather_vars(self, root, local_vars): """ Gather and return only variables listed in `local_vars` from the `root` System. Parameters ---------- root : <System> the root System for the Problem local_vars : dict local variable names and values Returns ------- dct : dict variable names and values. """ # if trace: # debug("gathering vars for recording in %s" % root.pathname) all_vars = root.comm.gather(local_vars, root=0) # if trace: # debug("DONE gathering rec vars for %s" % root.pathname) if root.comm.rank == 0: dct = all_vars[-1] for d in all_vars[:-1]: dct.update(d) return dct def _get_name(self): """ Get name of current Driver. Returns ------- str Name of current Driver. """ return "Driver" def set_simul_deriv_color(self, simul_info): """ Set the coloring for simultaneous derivatives. Parameters ---------- simul_info : str or ({dv1: colors, ...}, {resp1: {dv1: {0: [res_idxs, dv_idxs]} ...} ...}) Information about simultaneous coloring for design vars and responses. If a string, then simul_info is assumed to be the name of a file that contains the coloring information in JSON format. """ if self.supports['simultaneous_derivatives']: self._simul_coloring_info = simul_info else: raise RuntimeError("Driver '%s' does not support simultaneous derivatives." % self._get_name()) def _setup_simul_coloring(self, mode='fwd'): """ Set up metadata for simultaneous derivative solution. Parameters ---------- mode : str Derivative direction, either 'fwd' or 'rev'. """ if mode == 'rev': raise NotImplementedError("Simultaneous derivatives are currently not supported " "in 'rev' mode") # command line simul_coloring uses this env var to turn pre-existing coloring off if not _use_simul_coloring: return prom2abs = self._problem.model._var_allprocs_prom2abs_list['output'] if isinstance(self._simul_coloring_info, string_types): with open(self._simul_coloring_info, 'r') as f: self._simul_coloring_info = json.load(f) coloring, maps = self._simul_coloring_info for dv, colors in iteritems(coloring): if dv not in self._designvars: # convert name from promoted to absolute dv = prom2abs[dv][0] self._designvars[dv]['simul_deriv_color'] = colors for res, dvdict in iteritems(maps): if res not in self._responses: # convert name from promoted to absolute res = prom2abs[res][0] self._responses[res]['simul_map'] = dvdict for dv, col_dict in dvdict.items(): col_dict = {int(k): v for k, v in iteritems(col_dict)} if dv not in self._designvars: # convert name from promoted to absolute and replace dictionary key del dvdict[dv] dv = prom2abs[dv][0] dvdict[dv] = col_dict def _pre_run_model_debug_print(self): """ Optionally print some debugging information before the model runs. """ if not self.options['debug_print']: return if not MPI or MPI.COMM_WORLD.rank == 0: header = 'Driver debug print for iter coord: {}'.format( get_formatted_iteration_coordinate()) print(header) print(len(header) * '-') if 'desvars' in self.options['debug_print']: desvar_vals = self.get_design_var_values() if not MPI or MPI.COMM_WORLD.rank == 0: print("Design Vars") if desvar_vals: for name, value in iteritems(desvar_vals): print("{}: {}".format(name, repr(value))) else: print("None") print() def _post_run_model_debug_print(self): """ Optionally print some debugging information after the model runs. """ if 'nl_cons' in self.options['debug_print']: cons = self.get_constraint_values(lintype='nonlinear') if not MPI or MPI.COMM_WORLD.rank == 0: print("Nonlinear constraints") if cons: for name, value in iteritems(cons): print("{}: {}".format(name, repr(value))) else: print("None") print() if 'ln_cons' in self.options['debug_print']: cons = self.get_constraint_values(lintype='linear') if not MPI or MPI.COMM_WORLD.rank == 0: print("Linear constraints") if cons: for name, value in iteritems(cons): print("{}: {}".format(name, repr(value))) else: print("None") print() if 'objs' in self.options['debug_print']: objs = self.get_objective_values() if not MPI or MPI.COMM_WORLD.rank == 0: print("Objectives") if objs: for name, value in iteritems(objs): print("{}: {}".format(name, repr(value))) else: print("None") print()