def compute_approximations(self, system, jac, total=False):
"""
Execute the system to compute the approximate sub-Jacobians.
Parameters
----------
system : System
System on which the execution is run.
jac : dict-like
Approximations are stored in the given dict-like object.
total : bool
If True total derivatives are being approximated, else partials.
"""
if system.under_complex_step:
# If we are nested under another complex step, then warn and swap to FD.
if not self._fd:
from openmdao.approximation_schemes.finite_difference import FiniteDifference
msg = "Nested complex step detected. Finite difference will be used for '%s'."
simple_warning(msg % system.pathname)
fd = self._fd = FiniteDifference()
for item in self._exec_list:
fd.add_approximation(item[0:2], {})
self._fd.compute_approximations(system, jac, total=total)
return
if len(self._exec_list) == 0:
return
if total:
current_vec = system._outputs
else:
current_vec = system._residuals
# Clean vector for results
results_clone = current_vec._clone(True)
# Turn on complex step.
system._set_complex_step_mode(True)
results_clone.set_complex_step_mode(True)
# To support driver src_indices, we need to override some checks in Jacobian, but do it
# selectively.
uses_src_indices = (system._owns_approx_of_idx or system._owns_approx_wrt_idx) and \
not isinstance(jac, dict)
use_parallel_fd = system._num_par_fd > 1 and (
system._full_comm is not None and system._full_comm.size > 1)
num_par_fd = system._num_par_fd if use_parallel_fd else 1
is_parallel = use_parallel_fd or system.comm.size > 1
results = defaultdict(list)
iproc = system.comm.rank
owns = system._owning_rank
mycomm = system._full_comm if use_parallel_fd else system.comm
fd_count = 0
approx_groups = self._get_approx_groups(system)
for tup in approx_groups:
wrt, delta, fact, in_idx, in_size, outputs = tup
for i_count, idx in enumerate(in_idx):
if fd_count % num_par_fd == system._par_fd_id:
# Run the Finite Difference
result = self._run_point_complex(system, wrt, idx, delta,
results_clone, total)
if is_parallel:
for of, _, out_idx in outputs:
if owns[of] == iproc:
results[(of, wrt)].append(
(i_count, result._views_flat[of]
[out_idx].imag.copy()))
else:
for of, subjac, out_idx in outputs:
subjac[:, i_count] = result._views_flat[of][
out_idx].imag
fd_count += 1
if is_parallel:
results = _gather_jac_results(mycomm, results)
for wrt, _, fact, _, _, outputs in approx_groups:
for of, subjac, _ in outputs:
key = (of, wrt)
if is_parallel:
for i, result in results[key]:
subjac[:, i] = result
subjac *= fact
if uses_src_indices:
jac._override_checks = True
jac[key] = subjac
jac._override_checks = False
else:
jac[key] = subjac
# Turn off complex step.
system._set_complex_step_mode(False)
def compute_approximations(self, system, jac=None, total=False):
"""
Execute the system to compute the approximate sub-Jacobians.
Parameters
----------
system : System
System on which the execution is run.
jac : None or dict-like
If None, update system with the approximated sub-Jacobians. Otherwise, store the
approximations in the given dict-like object.
total : bool
If True total derivatives are being approximated, else partials.
"""
if len(self._exec_list) == 0:
return
if jac is None:
jac = system._jacobian
if total:
current_vec = system._outputs
else:
current_vec = system._residuals
result = system._outputs._clone(True)
cs_active = system._outputs._under_complex_step
if cs_active:
result.set_complex_step_mode(cs_active)
result_array = result._data.copy()
out_tmp = current_vec._data.copy()
in_tmp = system._inputs._data.copy()
# To support driver src_indices, we need to override some checks in Jacobian, but do it
# selectively.
uses_src_indices = (system._owns_approx_of_idx or system._owns_approx_wrt_idx) and \
not isinstance(jac, dict)
use_parallel_fd = system._num_par_fd > 1 and (system._full_comm is not None and
system._full_comm.size > 1)
num_par_fd = system._num_par_fd if use_parallel_fd else 1
is_parallel = use_parallel_fd or system.comm.size > 1
results = defaultdict(list)
iproc = system.comm.rank
owns = system._owning_rank
mycomm = system._full_comm if use_parallel_fd else system.comm
fd_count = 0
approx_groups = self._get_approx_groups(system, under_cs=cs_active)
for wrt, deltas, coeffs, current_coeff, in_idx, in_size, outputs in approx_groups:
for i_count, idx in enumerate(in_idx):
if fd_count % num_par_fd == system._par_fd_id:
if current_coeff:
result._data[:] = current_vec._data
result._data *= current_coeff
else:
result._data[:] = 0.
# Run the Finite Difference
for delta, coeff in zip(deltas, coeffs):
self._run_point(system, wrt, idx, delta, out_tmp, in_tmp, result_array,
total)
result_array *= coeff
result._data += result_array
if is_parallel:
for of, _, out_idx in outputs:
if owns[of] == iproc:
results[(of, wrt)].append(
(i_count, result._views_flat[of][out_idx].copy()))
else:
for of, subjac, out_idx in outputs:
subjac[:, i_count] = result._views_flat[of][out_idx]
fd_count += 1
if is_parallel:
results = _gather_jac_results(mycomm, results)
for wrt, _, _, _, _, _, outputs in approx_groups:
for of, subjac, _ in outputs:
key = (of, wrt)
if is_parallel:
for i, result in results[key]:
subjac[:, i] = result
if uses_src_indices:
jac._override_checks = True
jac[key] = subjac
jac._override_checks = False
else:
jac[key] = subjac
def compute_approximations(self, system, jac, total=False):
"""
Execute the system to compute the approximate sub-Jacobians.
Parameters
----------
system : System
System on which the execution is run.
jac : dict-like
Approximations are stored in the given dict-like object.
total : bool
If True total derivatives are being approximated, else partials.
"""
if len(self._exec_list) == 0:
return
if system.under_complex_step:
# If we are nested under another complex step, then warn and swap to FD.
if not self._fd:
from openmdao.approximation_schemes.finite_difference import FiniteDifference
msg = "Nested complex step detected. Finite difference will be used for '%s'."
simple_warning(msg % system.pathname)
fd = self._fd = FiniteDifference()
for item in self._exec_list:
fd.add_approximation(item[0:2], {})
self._fd.compute_approximations(system, jac, total=total)
return
if total:
current_vec = system._outputs
else:
current_vec = system._residuals
# Clean vector for results
results_clone = current_vec._clone(True)
# Turn on complex step.
system._set_complex_step_mode(True)
results_clone.set_complex_step_mode(True)
# To support driver src_indices, we need to override some checks in Jacobian, but do it
# selectively.
uses_src_indices = (system._owns_approx_of_idx or system._owns_approx_wrt_idx) and \
not isinstance(jac, dict)
use_parallel_fd = system._num_par_fd > 1 and (system._full_comm is not None and
system._full_comm.size > 1)
num_par_fd = system._num_par_fd if use_parallel_fd else 1
is_parallel = use_parallel_fd or system.comm.size > 1
results = defaultdict(list)
iproc = system.comm.rank
owns = system._owning_rank
mycomm = system._full_comm if use_parallel_fd else system.comm
fd_count = 0
approx_groups = self._get_approx_groups(system)
for tup in approx_groups:
wrt, delta, fact, in_idx, in_size, outputs = tup
for i_count, idx in enumerate(in_idx):
if fd_count % num_par_fd == system._par_fd_id:
# Run the Finite Difference
result = self._run_point_complex(system, wrt, idx, delta, results_clone, total)
if is_parallel:
for of, _, out_idx in outputs:
if owns[of] == iproc:
results[(of, wrt)].append(
(i_count, result._views_flat[of][out_idx].imag.copy()))
else:
for of, subjac, out_idx in outputs:
subjac[:, i_count] = result._views_flat[of][out_idx].imag
fd_count += 1
if is_parallel:
results = _gather_jac_results(mycomm, results)
for wrt, _, fact, _, _, outputs in approx_groups:
for of, subjac, _ in outputs:
key = (of, wrt)
if is_parallel:
for i, result in results[key]:
subjac[:, i] = result
subjac *= fact
if uses_src_indices:
jac._override_checks = True
jac[key] = subjac
jac._override_checks = False
else:
jac[key] = subjac
# Turn off complex step.
system._set_complex_step_mode(False)