def _simul_coloring(prob):
if options.outfile is None:
outfile = sys.stdout
else:
outfile = open(options.outfile, 'w')
if prob.model._use_derivatives:
Problem._post_setup_func = None # avoid recursive loop
with profiling('coloring_profile.out'
) if options.profile else do_nothing_context():
color_info = get_simul_meta(
prob,
repeats=options.num_jacs,
tol=options.tolerance,
show_jac=options.show_jac,
include_sparsity=not options.no_sparsity,
setup=False,
run_model=True,
stream=outfile)
if sys.stdout.isatty():
simul_coloring_summary(color_info, stream=sys.stdout)
else:
print(
"Derivatives are turned off. Cannot compute simul coloring.")
exit()
def _simul_coloring(prob):
if options.outfile is None:
outfile = sys.stdout
else:
outfile = open(options.outfile, 'w')
if prob.model._use_derivatives:
Problem._post_setup_func = None # avoid recursive loop
with profiling('coloring_profile.out') if options.profile else do_nothing_context():
color_info = get_simul_meta(prob,
repeats=options.num_jacs, tol=options.tolerance,
show_jac=options.show_jac,
include_sparsity=not options.no_sparsity,
setup=False, run_model=True,
stream=outfile)
if sys.stdout.isatty():
simul_coloring_summary(color_info, stream=sys.stdout)
else:
print("Derivatives are turned off. Cannot compute simul coloring.")
exit()
def _inverse(self):
"""
Return the inverse Jacobian.
This is only used by the Broyden solver when calculating a full model Jacobian. Since it
is only done for a single RHS, no need for LU.
Returns
-------
ndarray
Inverse Jacobian.
"""
system = self._system
iproc = system.comm.rank
nproc = system.comm.size
if self._assembled_jac is not None:
with multi_proc_exception_check(
system.comm) if nproc > 1 else do_nothing_context():
if nproc == 1:
matrix = self._assembled_jac._int_mtx._matrix
else:
matrix = self._assembled_jac._int_mtx._get_assembled_matrix(
system)
if self._owned_size_totals is None:
self._owned_size_totals = np.sum(system._owned_sizes,
axis=1)
if matrix is None:
# This happens if we're not rank 0
sz = np.sum(system._owned_sizes)
inv_jac = np.zeros((sz, sz))
# Dense and Sparse matrices have their own inverse method.
elif isinstance(matrix, np.ndarray):
# Detect singularities and warn user.
with warnings.catch_warnings():
if self.options['err_on_singular']:
warnings.simplefilter('error', RuntimeWarning)
try:
inv_jac = scipy.linalg.inv(matrix)
except RuntimeWarning as err:
raise RuntimeError(
format_singular_error(err, system, matrix))
# NaN in matrix.
except ValueError as err:
raise RuntimeError(format_nan_error(
system, matrix))
elif isinstance(matrix, csc_matrix):
try:
inv_jac = scipy.sparse.linalg.inv(matrix)
except RuntimeError as err:
if 'exactly singular' in str(err):
raise RuntimeError(
format_singular_csc_error(system, matrix))
else:
reraise(*sys.exc_info())
else:
raise RuntimeError(
"Direct solver not implemented for matrix type %s"
" in %s." % (type(matrix), system.msginfo))
else:
mtx = self._build_mtx()
# During inversion detect singularities and warn user.
with warnings.catch_warnings():
if self.options['err_on_singular']:
warnings.simplefilter('error', RuntimeWarning)
try:
inv_jac = scipy.linalg.inv(mtx)
except RuntimeWarning as err:
raise RuntimeError(format_singular_error(err, system, mtx))
# NaN in matrix.
except ValueError as err:
raise RuntimeError(format_nan_error(system, mtx))
return inv_jac
def _linearize(self):
"""
Perform factorization.
"""
system = self._system
nproc = system.comm.size
if self._assembled_jac is not None:
with multi_proc_exception_check(
system.comm) if nproc > 1 else do_nothing_context():
if nproc == 1:
matrix = self._assembled_jac._int_mtx._matrix
else:
matrix = self._assembled_jac._int_mtx._get_assembled_matrix(
system)
if self._owned_size_totals is None:
self._owned_size_totals = np.sum(system._owned_sizes,
axis=1)
if matrix is None:
# this happens if we're not rank 0
self._lu = self._lup = None
self._nodup_size = np.sum(system._owned_sizes)
# Perform dense or sparse lu factorization.
elif isinstance(matrix, csc_matrix):
try:
self._lu = scipy.sparse.linalg.splu(matrix)
self._nodup_size = matrix.shape[1]
except RuntimeError as err:
if 'exactly singular' in str(err):
raise RuntimeError(
format_singular_csc_error(system, matrix))
else:
reraise(*sys.exc_info())
elif isinstance(matrix, np.ndarray): # dense
# During LU decomposition, detect singularities and warn user.
with warnings.catch_warnings():
if self.options['err_on_singular']:
warnings.simplefilter('error', RuntimeWarning)
try:
self._lup = scipy.linalg.lu_factor(matrix)
self._nodup_size = matrix.shape[1]
except RuntimeWarning as err:
raise RuntimeError(
format_singular_error(err, system, matrix))
# NaN in matrix.
except ValueError as err:
raise RuntimeError(format_nan_error(
system, matrix))
# Note: calling scipy.sparse.linalg.splu on a COO actually transposes
# the matrix during conversion to csc prior to LU decomp, so we can't use COO.
else:
raise RuntimeError(
"Direct solver not implemented for matrix type %s"
" in %s." %
(type(self._assembled_jac._int_mtx), system.msginfo))
else:
if nproc > 1:
raise RuntimeError(
"DirectSolvers without an assembled jacobian are not supported "
"when running under MPI if comm.size > 1.")
mtx = self._build_mtx()
self._nodup_size = mtx.shape[1]
# During LU decomposition, detect singularities and warn user.
with warnings.catch_warnings():
if self.options['err_on_singular']:
warnings.simplefilter('error', RuntimeWarning)
try:
self._lup = scipy.linalg.lu_factor(mtx)
except RuntimeWarning as err:
raise RuntimeError(format_singular_error(err, system, mtx))
# NaN in matrix.
except ValueError as err:
raise RuntimeError(format_nan_error(system, mtx))