def test_get_conversion(self): self.assertEqual(get_conversion('km', 'm'), (1000., 0.)) try: get_conversion('km', 1.0) except RuntimeError as err: self.assertEqual(str(err), "Cannot convert to new units: 1.0") else: self.fail("Expecting RuntimeError")
def test_get_conversion(self): msg = "'get_conversion' has been deprecated. Use 'unit_conversion' instead." with assert_warning(OMDeprecationWarning, msg): get_conversion('km', 'm'), (1000., 0.) self.assertEqual(get_conversion('km', 'm'), (1000., 0.)) try: get_conversion('km', 1.0) except ValueError as err: self.assertEqual(str(err), "The units '1.0' are invalid.") else: self.fail("Expecting ValueError")
def test_get_conversion(self): msg = "'get_conversion' has been deprecated. Use 'unit_conversion' instead." with assert_warning(DeprecationWarning, msg): get_conversion('km', 'm'), (1000., 0.) self.assertEqual(get_conversion('km', 'm'), (1000., 0.)) try: get_conversion('km', 1.0) except RuntimeError as err: self.assertEqual(str(err), "Cannot convert to new units: '1.0'.") else: self.fail("Expecting RuntimeError")
def get_val(self, name, units=None, indices=None): """ Get an output/input variable. Function is used if you want to specify display units. Parameters ---------- name : str Promoted or relative variable name in the root system's namespace. units : str, optional Units to convert to before upon return. indices : int or list of ints or tuple of ints or int ndarray or Iterable or None, optional Indices or slice to return. Returns ------- float or ndarray The requested output/input variable. """ val = self[name] if indices is not None: val = val[indices] if units is not None: base_units = self._get_units(name) if base_units is None: msg = "Can't express variable '{}' with units of 'None' in units of '{}'." raise TypeError(msg.format(name, units)) try: scale, offset = get_conversion(base_units, units) except TypeError: msg = "Can't express variable '{}' with units of '{}' in units of '{}'." raise TypeError(msg.format(name, base_units, units)) val = (val + offset) * scale return val
def _initialize(self): """ Allocate the global matrices. """ # var_indices are the *global* indices for variables on this proc system = self._system is_top = system.pathname == '' abs2meta = system._var_abs2meta self._int_mtx = int_mtx = self._matrix_class(system.comm) ext_mtx = self._matrix_class(system.comm) iproc = system.comm.rank abs2idx = system._var_allprocs_abs2idx['nonlinear'] sizes = system._var_sizes['nonlinear']['output'] out_ranges = self._out_ranges = {} for name in system._var_allprocs_abs_names['output']: start = np.sum(sizes[iproc, :abs2idx[name]]) out_ranges[name] = (start, start + sizes[iproc, abs2idx[name]]) sizes = system._var_sizes['nonlinear']['input'] in_ranges = self._in_ranges = {} for name in system._var_allprocs_abs_names['input']: start = np.sum(sizes[iproc, :abs2idx[name]]) in_ranges[name] = (start, start + sizes[iproc, abs2idx[name]]) abs2prom_out = system._var_abs2prom['output'] conns = {} if isinstance(system, Component) else system._conn_global_abs_in2out keymap = self._keymap abs_key2shape = self._abs_key2shape # create the matrix subjacs for abs_key, (info, shape) in iteritems(self._subjacs_info): res_abs_name, wrt_abs_name = abs_key # because self._subjacs_info is shared among all 'related' assembled jacs, # we use out_ranges (and later in_ranges) to weed out keys outside of this jac if res_abs_name not in out_ranges: continue res_offset, _ = out_ranges[res_abs_name] if wrt_abs_name in abs2prom_out: out_offset, _ = out_ranges[wrt_abs_name] int_mtx._add_submat(abs_key, info, res_offset, out_offset, None, shape) keymap[abs_key] = abs_key elif wrt_abs_name in in_ranges: if wrt_abs_name in conns: # connected input out_abs_name = conns[wrt_abs_name] # calculate unit conversion in_units = abs2meta[wrt_abs_name]['units'] out_units = abs2meta[out_abs_name]['units'] if in_units and out_units and in_units != out_units: factor, _ = get_conversion(out_units, in_units) if factor == 1.0: factor = None else: factor = None out_offset, _ = out_ranges[out_abs_name] src_indices = abs2meta[wrt_abs_name]['src_indices'] # need to add an entry for d(output)/d(source) # instead of d(output)/d(input) abs_key2 = (res_abs_name, out_abs_name) keymap[abs_key] = abs_key2 shape = abs_key2shape(abs_key2) int_mtx._add_submat(abs_key, info, res_offset, out_offset, src_indices, shape, factor) elif not is_top: # input is connected to something outside current system ext_mtx._add_submat(abs_key, info, res_offset, in_ranges[wrt_abs_name][0], None, shape) sizes = system._var_sizes iproc = system.comm.rank out_size = np.sum(sizes['nonlinear']['output'][iproc, :]) int_mtx._build(out_size, out_size) if ext_mtx._submats: in_size = np.sum(sizes['nonlinear']['input'][iproc, :]) ext_mtx._build(out_size, in_size) else: ext_mtx = None self._ext_mtx[system.pathname] = ext_mtx
def test_light_year(self): factor, offset = get_conversion('ly', 'au') self.assertAlmostEqual(factor, 63241, places=0)
def _initialize(self, system): """ Allocate the global matrices. Parameters ---------- system : System Parent system to this jacobian. """ # var_indices are the *global* indices for variables on this proc is_top = system.pathname == '' abs2meta = system._var_abs2meta all_meta = system._var_allprocs_abs2meta self._int_mtx = int_mtx = self._matrix_class(system.comm) ext_mtx = self._matrix_class(system.comm) iproc = system.comm.rank abs2idx = system._var_allprocs_abs2idx['nonlinear'] out_sizes = system._var_sizes['nonlinear']['output'] in_sizes = system._var_sizes['nonlinear']['input'] out_ranges = self._out_ranges in_ranges = self._in_ranges abs2prom_out = system._var_abs2prom['output'] conns = {} if isinstance(system, Component) else system._conn_global_abs_in2out abs_key2shape = self._abs_key2shape # create the matrix subjacs for abs_key, info in iteritems(self._subjacs_info): res_abs_name, wrt_abs_name = abs_key # because self._subjacs_info is shared among all 'related' assembled jacs, # we use out_ranges (and later in_ranges) to weed out keys outside of this jac if res_abs_name not in out_ranges: continue res_offset, res_end = out_ranges[res_abs_name] res_size = res_end - res_offset if wrt_abs_name in abs2prom_out: out_offset, out_end = out_ranges[wrt_abs_name] out_size = out_end - out_offset shape = (res_size, out_size) int_mtx._add_submat(abs_key, info, res_offset, out_offset, None, shape) elif wrt_abs_name in in_ranges: if wrt_abs_name in conns: # connected input out_abs_name = conns[wrt_abs_name] meta_in = abs2meta[wrt_abs_name] all_out_meta = all_meta[out_abs_name] # calculate unit conversion in_units = meta_in['units'] out_units = all_out_meta['units'] if in_units and out_units and in_units != out_units: factor, _ = get_conversion(out_units, in_units) if factor == 1.0: factor = None else: factor = None out_offset, out_end = out_ranges[out_abs_name] out_size = out_end - out_offset shape = (res_size, out_size) src_indices = abs2meta[wrt_abs_name]['src_indices'] # need to add an entry for d(output)/d(source) # instead of d(output)/d(input) abs_key2 = (res_abs_name, out_abs_name) if src_indices is not None: shape = abs_key2shape(abs_key2) if len(src_indices.shape) > 1: src_indices = _flatten_src_indices( src_indices, meta_in['shape'], all_out_meta['global_shape'], all_out_meta['global_size']) int_mtx._add_submat(abs_key, info, res_offset, out_offset, src_indices, shape, factor) elif not is_top: # input is connected to something outside current system in_offset, in_end = in_ranges[wrt_abs_name] shape = (res_size, in_end - in_offset) ext_mtx._add_submat(abs_key, info, res_offset, in_offset, None, shape) iproc = system.comm.rank out_size = np.sum(out_sizes[iproc, :]) int_mtx._build(out_size, out_size, in_ranges, out_ranges) if ext_mtx._submats: in_size = np.sum(in_sizes[iproc, :]) ext_mtx._build(out_size, in_size, in_ranges, out_ranges) else: ext_mtx = None self._ext_mtx[system.pathname] = ext_mtx
def _initialize(self): """ Allocate the global matrices. """ # var_indices are the *global* indices for variables on this proc system = self._system abs2meta_in = system._var_abs2meta['input'] abs2meta_out = system._var_abs2meta['output'] self._int_mtx = int_mtx = self.options['matrix_class'](system.comm) ext_mtx = self.options['matrix_class'](system.comm) out_ranges = {} for abs_name in system._var_allprocs_abs_names['output']: out_ranges[abs_name] = self._get_var_range(abs_name, 'output') in_ranges = {} src_indices_dict = {} for abs_name in system._var_allprocs_abs_names['input']: in_ranges[abs_name] = self._get_var_range(abs_name, 'input') src_indices_dict[abs_name] = \ system._var_abs2meta['input'][abs_name]['src_indices'] for s in self._system.system_iter(local=True, recurse=True, include_self=True): min_res_offset = sys.maxsize max_res_offset = 0 min_in_offset = sys.maxsize max_in_offset = 0 for in_abs_name in s._var_abs_names['input']: in_offset, in_end = in_ranges[in_abs_name] if in_end > max_in_offset: max_in_offset = in_end if in_offset < min_in_offset: min_in_offset = in_offset for res_abs_name in s._var_abs_names['output']: res_offset, res_end = out_ranges[res_abs_name] if res_end > max_res_offset: max_res_offset = res_end if res_offset < min_res_offset: min_res_offset = res_offset # only need to collect subjac info for components, not subgroups if not isinstance(s, Component): continue res_size = abs2meta_out[res_abs_name]['size'] for out_abs_name in s._var_abs_names['output']: out_offset, _ = out_ranges[out_abs_name] abs_key = (res_abs_name, out_abs_name) if abs_key in self._subjacs_info: info, shape = self._subjacs_info[abs_key] else: info = SUBJAC_META_DEFAULTS shape = (res_size, abs2meta_out[out_abs_name]['size']) int_mtx._add_submat( abs_key, info, res_offset, out_offset, None, shape) for in_abs_name in s._var_abs_names['input']: abs_key = (res_abs_name, in_abs_name) self._keymap[abs_key] = abs_key if abs_key in self._subjacs_info: info, shape = self._subjacs_info[abs_key] else: info = SUBJAC_META_DEFAULTS shape = (res_size, abs2meta_in[in_abs_name]['size']) self._keymap[abs_key] = abs_key if in_abs_name in system._conn_global_abs_in2out: out_abs_name = system._conn_global_abs_in2out[in_abs_name] out_offset, _ = out_ranges[out_abs_name] src_indices = src_indices_dict[in_abs_name] # calculate unit conversion in_units = abs2meta_in[in_abs_name]['units'] out_units = abs2meta_out[out_abs_name]['units'] if in_units and out_units: factor, _ = get_conversion(out_units, in_units) else: factor = None if src_indices is None: int_mtx._add_submat( abs_key, info, res_offset, out_offset, None, shape, factor) else: # need to add an entry for d(output)/d(source) # instead of d(output)/d(input) when we have # src_indices abs_key2 = (res_abs_name, out_abs_name) self._keymap[abs_key] = abs_key2 int_mtx._add_submat( abs_key2, info, res_offset, out_offset, src_indices, shape, factor) else: ext_mtx._add_submat( abs_key, info, res_offset, in_ranges[in_abs_name][0], None, shape) self._view_ranges[s.pathname] = ( min_res_offset, max_res_offset, min_in_offset, max_in_offset) sizes = system._var_sizes iproc = system.comm.rank out_size = np.sum(sizes['nonlinear']['output'][iproc, :]) int_mtx._build(out_size, out_size) if ext_mtx._submats: in_size = np.sum(sizes['nonlinear']['input'][iproc, :]) ext_mtx._build(out_size, in_size) else: ext_mtx = None self._ext_mtx[system.pathname] = ext_mtx
def _initialize(self, system): """ Allocate the global matrices. Parameters ---------- system : System Parent system to this jacobian. """ # var_indices are the *global* indices for variables on this proc is_top = system.pathname == '' abs2meta = system._var_abs2meta all_meta = system._var_allprocs_abs2meta self._int_mtx = int_mtx = self._matrix_class(system.comm, True) ext_mtx = self._matrix_class(system.comm, False) iproc = system.comm.rank abs2idx = system._var_allprocs_abs2idx['nonlinear'] in_sizes = system._var_sizes['nonlinear']['input'] out_ranges = self._out_ranges # for non-MPI case, global_out_ranges is out_ranges global_out_ranges = self._nodup_out_ranges in_ranges = self._in_ranges abs2prom_out = system._var_abs2prom['output'] owns = system._owning_rank conns = {} if isinstance(system, Component) else system._conn_global_abs_in2out abs_key2shape = self._abs_key2shape check_owns = system._use_owned_sizes() # create the matrix subjacs for abs_key, info in iteritems(self._subjacs_info): res_abs_name, wrt_abs_name = abs_key # because self._subjacs_info is shared among all 'related' assembled jacs, # we use global_out_ranges (and later in_ranges) to weed out keys outside of this jac if res_abs_name not in global_out_ranges: continue res_offset, res_end = global_out_ranges[res_abs_name] res_size = res_end - res_offset if wrt_abs_name in abs2prom_out: if check_owns and (owns[wrt_abs_name] != iproc and not all_meta[wrt_abs_name]['distributed']): continue out_offset, out_end = global_out_ranges[wrt_abs_name] out_size = out_end - out_offset shape = (res_size, out_size) int_mtx._add_submat(abs_key, info, res_offset, out_offset, None, shape) elif wrt_abs_name in in_ranges: if wrt_abs_name in conns: # connected input out_abs_name = conns[wrt_abs_name] if out_abs_name not in global_out_ranges: continue if check_owns and (owns[wrt_abs_name] != iproc and not (all_meta[wrt_abs_name]['distributed'] or all_meta[out_abs_name]['distributed'])): continue meta_in = abs2meta[wrt_abs_name] all_out_meta = all_meta[out_abs_name] # calculate unit conversion in_units = meta_in['units'] out_units = all_out_meta['units'] if in_units and out_units and in_units != out_units: factor, _ = get_conversion(out_units, in_units) if factor == 1.0: factor = None else: factor = None out_offset, out_end = global_out_ranges[out_abs_name] out_size = out_end - out_offset shape = (res_size, out_size) src_indices = abs2meta[wrt_abs_name]['src_indices'] if src_indices is not None: # need to add an entry for d(output)/d(source) # instead of d(output)/d(input). int_mtx is a square matrix whose # rows and columns map to output/resid vars only. abs_key2 = (res_abs_name, out_abs_name) shape = abs_key2shape(abs_key2) if len(src_indices.shape) > 1: src_indices = _flatten_src_indices(src_indices, meta_in['shape'], all_out_meta['global_shape'], all_out_meta['global_size']) int_mtx._add_submat(abs_key, info, res_offset, out_offset, src_indices, shape, factor) elif not is_top: # input is connected to something outside current system in_offset, in_end = in_ranges[wrt_abs_name] # don't use global offsets for ext_mtx res_offset, res_end = out_ranges[res_abs_name] res_size = res_end - res_offset shape = (res_size, in_end - in_offset) ext_mtx._add_submat(abs_key, info, res_offset, in_offset, None, shape) out_size = system._outputs._data.size if check_owns: total_non_dup_size = np.sum(system._owned_sizes) self._int_mtx._build(total_non_dup_size, total_non_dup_size, system) else: int_mtx._build(out_size, out_size, system) if ext_mtx._submats: in_size = np.sum(in_sizes[iproc, :]) ext_mtx._build(out_size, in_size) else: ext_mtx = None self._ext_mtx[system.pathname] = ext_mtx
def _initialize(self): """ Allocate the global matrices. """ # var_indices are the *global* indices for variables on this proc system = self._system abs2meta = system._var_abs2meta self._int_mtx = int_mtx = self.options['matrix_class'](system.comm) ext_mtx = self.options['matrix_class'](system.comm) out_ranges = { abs_name: self._get_var_range(abs_name, 'output') for abs_name in system._var_allprocs_abs_names['output'] } in_ranges = {} for abs_name in system._var_allprocs_abs_names['input']: in_ranges[abs_name] = self._get_var_range(abs_name, 'input') # set up view ranges for all subsystems for s in system.system_iter(recurse=True, include_self=True): min_res_offset = sys.maxsize max_res_offset = 0 min_in_offset = sys.maxsize max_in_offset = 0 for in_abs_name in s._var_abs_names['input']: in_offset, in_end = in_ranges[in_abs_name] if in_end > max_in_offset: max_in_offset = in_end if in_offset < min_in_offset: min_in_offset = in_offset for res_abs_name in s._var_abs_names['output']: res_offset, res_end = out_ranges[res_abs_name] if res_end > max_res_offset: max_res_offset = res_end if res_offset < min_res_offset: min_res_offset = res_offset self._view_ranges[s.pathname] = ( min_res_offset, max_res_offset, min_in_offset, max_in_offset) abs2prom_out = system._var_abs2prom['output'] conns = system._conn_global_abs_in2out # create the matrix subjacs for abs_key, (info, shape) in iteritems(self._subjacs_info): if not info['dependent']: continue res_abs_name, wrt_abs_name = abs_key res_offset, _ = out_ranges[res_abs_name] if wrt_abs_name in abs2prom_out: out_offset, _ = out_ranges[wrt_abs_name] int_mtx._add_submat( abs_key, info, res_offset, out_offset, None, shape) else: if wrt_abs_name in conns: # connected input out_abs_name = conns[wrt_abs_name] # calculate unit conversion in_units = abs2meta[wrt_abs_name]['units'] out_units = abs2meta[out_abs_name]['units'] if in_units and out_units and in_units != out_units: factor, _ = get_conversion(out_units, in_units) if factor == 1.0: factor = None else: factor = None out_offset, _ = out_ranges[out_abs_name] src_indices = abs2meta[wrt_abs_name]['src_indices'] if src_indices is None: int_mtx._add_submat( abs_key, info, res_offset, out_offset, None, shape, factor) else: # need to add an entry for d(output)/d(source) # instead of d(output)/d(input) when we have # src_indices abs_key2 = (res_abs_name, out_abs_name) self._keymap[abs_key] = abs_key2 int_mtx._add_submat( abs_key2, info, res_offset, out_offset, src_indices, shape, factor) else: # input connected to src outside current system ext_mtx._add_submat( abs_key, info, res_offset, in_ranges[wrt_abs_name][0], None, shape) if abs_key not in self._keymap: self._keymap[abs_key] = abs_key sizes = system._var_sizes iproc = system.comm.rank out_size = np.sum(sizes['nonlinear']['output'][iproc, :]) int_mtx._build(out_size, out_size) if ext_mtx._submats: in_size = np.sum(sizes['nonlinear']['input'][iproc, :]) ext_mtx._build(out_size, in_size) else: ext_mtx = None self._ext_mtx[system.pathname] = ext_mtx
def _initialize(self, system): """ Allocate the global matrices. Parameters ---------- system : System Parent system to this jacobian. """ # var_indices are the *global* indices for variables on this proc is_top = system.pathname == '' abs2meta = system._var_abs2meta all_meta = system._var_allprocs_abs2meta self._int_mtx = int_mtx = self._matrix_class(system.comm) ext_mtx = self._matrix_class(system.comm) iproc = system.comm.rank abs2idx = system._var_allprocs_abs2idx['nonlinear'] out_sizes = system._var_sizes['nonlinear']['output'] in_sizes = system._var_sizes['nonlinear']['input'] out_ranges = self._out_ranges in_ranges = self._in_ranges abs2prom_out = system._var_abs2prom['output'] conns = {} if isinstance(system, Component) else system._conn_global_abs_in2out keymap = self._keymap abs_key2shape = self._abs_key2shape # create the matrix subjacs for abs_key, info in iteritems(self._subjacs_info): res_abs_name, wrt_abs_name = abs_key # because self._subjacs_info is shared among all 'related' assembled jacs, # we use out_ranges (and later in_ranges) to weed out keys outside of this jac if res_abs_name not in out_ranges: continue res_offset, _ = out_ranges[res_abs_name] if wrt_abs_name in abs2prom_out: out_offset, _ = out_ranges[wrt_abs_name] int_mtx._add_submat(abs_key, info, res_offset, out_offset, None, info['shape']) keymap[abs_key] = abs_key elif wrt_abs_name in in_ranges: if wrt_abs_name in conns: # connected input out_abs_name = conns[wrt_abs_name] meta_in = abs2meta[wrt_abs_name] all_out_meta = all_meta[out_abs_name] # calculate unit conversion in_units = meta_in['units'] out_units = all_out_meta['units'] if in_units and out_units and in_units != out_units: factor, _ = get_conversion(out_units, in_units) if factor == 1.0: factor = None else: factor = None out_offset, _ = out_ranges[out_abs_name] src_indices = abs2meta[wrt_abs_name]['src_indices'] # need to add an entry for d(output)/d(source) # instead of d(output)/d(input) abs_key2 = (res_abs_name, out_abs_name) keymap[abs_key] = abs_key2 if src_indices is None: shape = info['shape'] else: shape = abs_key2shape(abs_key2) if len(src_indices.shape) > 1: src_indices = _flatten_src_indices(src_indices, meta_in['shape'], all_out_meta['global_shape'], all_out_meta['global_size']) int_mtx._add_submat(abs_key, info, res_offset, out_offset, src_indices, shape, factor) elif not is_top: # input is connected to something outside current system ext_mtx._add_submat(abs_key, info, res_offset, in_ranges[wrt_abs_name][0], None, info['shape']) iproc = system.comm.rank out_size = np.sum(out_sizes[iproc, :]) int_mtx._build(out_size, out_size, in_ranges, out_ranges) if ext_mtx._submats: in_size = np.sum(in_sizes[iproc, :]) ext_mtx._build(out_size, in_size, in_ranges, out_ranges) else: ext_mtx = None self._ext_mtx[system.pathname] = ext_mtx
def _initialize(self): """ Allocate the global matrices. """ # var_indices are the *global* indices for variables on this proc system = self._system abs2meta = system._var_abs2meta self._int_mtx = int_mtx = self.options['matrix_class'](system.comm) ext_mtx = self.options['matrix_class'](system.comm) out_ranges = { abs_name: self._get_var_range(abs_name, 'output') for abs_name in system._var_allprocs_abs_names['output'] } in_ranges = {} for abs_name in system._var_allprocs_abs_names['input']: in_ranges[abs_name] = self._get_var_range(abs_name, 'input') # set up view ranges for all subsystems for s in system.system_iter(recurse=True, include_self=True): min_res_offset = sys.maxsize max_res_offset = 0 min_in_offset = sys.maxsize max_in_offset = 0 for in_abs_name in s._var_abs_names['input']: in_offset, in_end = in_ranges[in_abs_name] if in_end > max_in_offset: max_in_offset = in_end if in_offset < min_in_offset: min_in_offset = in_offset for res_abs_name in s._var_abs_names['output']: res_offset, res_end = out_ranges[res_abs_name] if res_end > max_res_offset: max_res_offset = res_end if res_offset < min_res_offset: min_res_offset = res_offset self._view_ranges[s.pathname] = (min_res_offset, max_res_offset, min_in_offset, max_in_offset) abs2prom_out = system._var_abs2prom['output'] conns = system._conn_global_abs_in2out # create the matrix subjacs for abs_key, (info, shape) in iteritems(self._subjacs_info): if not info['dependent']: continue res_abs_name, wrt_abs_name = abs_key res_offset, _ = out_ranges[res_abs_name] if wrt_abs_name in abs2prom_out: out_offset, _ = out_ranges[wrt_abs_name] int_mtx._add_submat(abs_key, info, res_offset, out_offset, None, shape) else: if wrt_abs_name in conns: # connected input out_abs_name = conns[wrt_abs_name] # calculate unit conversion in_units = abs2meta[wrt_abs_name]['units'] out_units = abs2meta[out_abs_name]['units'] if in_units and out_units and in_units != out_units: factor, _ = get_conversion(out_units, in_units) if factor == 1.0: factor = None else: factor = None out_offset, _ = out_ranges[out_abs_name] src_indices = abs2meta[wrt_abs_name]['src_indices'] if src_indices is None: int_mtx._add_submat(abs_key, info, res_offset, out_offset, None, shape, factor) else: # need to add an entry for d(output)/d(source) # instead of d(output)/d(input) when we have # src_indices abs_key2 = (res_abs_name, out_abs_name) self._keymap[abs_key] = abs_key2 int_mtx._add_submat(abs_key2, info, res_offset, out_offset, src_indices, shape, factor) else: # input connected to src outside current system ext_mtx._add_submat(abs_key, info, res_offset, in_ranges[wrt_abs_name][0], None, shape) if abs_key not in self._keymap: self._keymap[abs_key] = abs_key sizes = system._var_sizes iproc = system.comm.rank out_size = np.sum(sizes['nonlinear']['output'][iproc, :]) int_mtx._build(out_size, out_size) if ext_mtx._submats: in_size = np.sum(sizes['nonlinear']['input'][iproc, :]) ext_mtx._build(out_size, in_size) else: ext_mtx = None self._ext_mtx[system.pathname] = ext_mtx
def _initialize(self): """ Allocate the global matrices. """ # var_indices are the *global* indices for variables on this proc system = self._system is_top = system.pathname == '' abs2meta = system._var_abs2meta self._int_mtx = int_mtx = self.options['matrix_class'](system.comm) ext_mtx = self.options['matrix_class'](system.comm) out_ranges = { abs_name: self._get_var_range(abs_name, 'output') for abs_name in system._var_allprocs_abs_names['output'] } in_ranges = { abs_name: self._get_var_range(abs_name, 'input') for abs_name in system._var_allprocs_abs_names['input'] } # set up view ranges for all subsystems for s in system.system_iter(recurse=True, include_self=True): input_names = s._var_abs_names['input'] if input_names: min_in_offset = in_ranges[input_names[0]][0] max_in_offset = in_ranges[input_names[-1]][1] else: min_in_offset = sys.maxsize max_in_offset = 0 output_names = s._var_abs_names['output'] if output_names: min_res_offset = out_ranges[output_names[0]][0] max_res_offset = out_ranges[output_names[-1]][1] else: min_res_offset = sys.maxsize max_res_offset = 0 self._view_ranges[s.pathname] = (min_res_offset, max_res_offset, min_in_offset, max_in_offset) # # keep track of mapped keys to check for corner case where one source connects to # # multiple inputs using src_indices on the same component. # mapped_keys = {} abs2prom_out = system._var_abs2prom['output'] conns = system._conn_global_abs_in2out keymap = self._keymap abs_key2shape = self._abs_key2shape # create the matrix subjacs for abs_key, (info, shape) in iteritems(self._subjacs_info): if not info['dependent']: continue res_abs_name, wrt_abs_name = abs_key # because self._subjacs_info is shared among all 'related' assembled jacs, # we use out_ranges (and later in_ranges) to weed out keys outside of this jac if res_abs_name not in out_ranges: continue res_offset, _ = out_ranges[res_abs_name] if wrt_abs_name in abs2prom_out: out_offset, _ = out_ranges[wrt_abs_name] int_mtx._add_submat(abs_key, info, res_offset, out_offset, None, shape) keymap[abs_key] = abs_key elif wrt_abs_name in in_ranges: if wrt_abs_name in conns: # connected input out_abs_name = conns[wrt_abs_name] # calculate unit conversion in_units = abs2meta[wrt_abs_name]['units'] out_units = abs2meta[out_abs_name]['units'] if in_units and out_units and in_units != out_units: factor, _ = get_conversion(out_units, in_units) if factor == 1.0: factor = None else: factor = None out_offset, _ = out_ranges[out_abs_name] src_indices = abs2meta[wrt_abs_name]['src_indices'] # need to add an entry for d(output)/d(source) # instead of d(output)/d(input) abs_key2 = (res_abs_name, out_abs_name) keymap[abs_key] = abs_key2 shape = abs_key2shape(abs_key2) int_mtx._add_submat(abs_key, info, res_offset, out_offset, src_indices, shape, factor) elif not is_top: # input is connected to something outside current system ext_mtx._add_submat(abs_key, info, res_offset, in_ranges[wrt_abs_name][0], None, shape) sizes = system._var_sizes iproc = system.comm.rank out_size = np.sum(sizes['nonlinear']['output'][iproc, :]) int_mtx._build(out_size, out_size) if ext_mtx._submats: in_size = np.sum(sizes['nonlinear']['input'][iproc, :]) ext_mtx._build(out_size, in_size) else: ext_mtx = None self._ext_mtx[system.pathname] = ext_mtx