def import_solution(self,
folder=None,
filename=None,
solution=None,
component=None,
suffix=None):
"""
Import solution from file.
"""
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "solution"
if solution is None:
solution = self._solution
assert component is None or isinstance(component, (str, list))
if component is None and len(self.components) > 1:
component = self.components
if component is None:
return import_(solution, folder, filename, suffix)
elif isinstance(component, str):
return import_(solution, folder, filename + "_" + component,
suffix, component)
elif isinstance(component, list):
for c in component:
assert isinstance(c, str)
if not import_(solution, folder, filename + "_" + c, suffix,
c):
return False
return True
else:
raise TypeError("Invalid component in import_solution()")
def import_supremizer(self, folder=None, filename=None, supremizer=None, component=None, suffix=None):
assert folder is not None
assert filename is not None
assert component is not None
assert isinstance(component, str)
if supremizer is None:
supremizer = self._supremizer[component]
import_(supremizer, folder, filename + "_" + component, suffix, component)
def import_solution(self, folder=None, filename=None, solution=None):
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "snapshot"
if solution is None:
solution = self.snapshot
import_(solution, folder, filename)
def import_solution(self, folder, filename):
eigenvalue_storage = [0.]
import_successful = import_(eigenvalue_storage, folder, filename + "_eigenvalue")
if import_successful:
assert len(eigenvalue_storage) == 1
self._eigenvalue = eigenvalue_storage[0]
import_successful = import_(self._eigenvector, folder, filename + "_eigenvector")
return import_successful
def _compute_yd(self):
"""
The desired state is (a component of) the solution of a nonlinear geostrophic problem for fixed parameters
"""
# State space
state_element = MixedElement(scalar_element, scalar_element)
W = FunctionSpace(mesh, state_element, components=["psi", "q"])
# Solution
psiq = Function(W)
# Import solution from file, if possible
try:
import_(psiq, self.name(), "yd")
except OSError:
# Fixed problem coefficients (mu[0] is (delta_M/L)**3, mu[1] is C)
delta_M = 7e4
L = 1e6
C = 0
# Fixed problem coefficients related to the nonlinear term
delta_I = 7e4
# Test and trial functions for variational forms definition
phip = TestFunction(W)
(phi, p) = split(phip)
delta_psiq = TrialFunction(W)
(delta_psi, delta_q) = split(delta_psiq)
(psi, q) = split(psiq)
# Variational forms
F = (inner(q, phi) * dx + inner(grad(psi), grad(phi)) * dx +
Constant(-(delta_I / L)**2) *
inner(psi,
q.dx(1) * p.dx(0) - q.dx(0) * p.dx(1)) * dx +
inner(psi.dx(0), p) * dx + Constant(
(delta_M / L)**3) * inner(grad(q), grad(p)) * dx +
Constant(C) * inner(q, p) * dx - inner(self.f, p) * dx)
J = derivative(F, psiq, delta_psiq)
# Boundary conditions
bc = [
DirichletBC(W, Constant((0., 0.)), boundaries, idx)
for idx in [1, 2, 3, 4]
]
# Solve nonlinear problem
snes_solver_parameters = {
"nonlinear_solver": "snes",
"snes_solver": {
"linear_solver": "mumps",
"maximum_iterations": 20,
"report": True
}
}
problem = NonlinearVariationalProblem(F, psiq, bc, J)
solver = NonlinearVariationalSolver(problem)
solver.parameters.update(snes_solver_parameters)
solver.solve()
# Export solution to file
export(psiq, self.name(), "yd")
# Tracking is on the psi component
(psi, q) = psiq.split(deepcopy=True)
return psi
def import_stability_factor_upper_bound(self, folder=None, filename=None):
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "stability_factor"
alpha_UB_storage = [0.]
import_(alpha_UB_storage, folder, filename + "_UB")
assert len(alpha_UB_storage) == 1
self._alpha_UB = alpha_UB_storage[0]
def import_eigenvalue(self, folder=None, filename=None):
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "stability_factor"
eigenvalue_storage = [0.]
import_(eigenvalue_storage, folder, filename + "_eigenvalue")
assert len(eigenvalue_storage) == 1
self._eigenvalue = eigenvalue_storage[0]
def import_stability_factor_upper_bound(self, folder=None, filename=None):
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "stability_factor"
stability_factor_upper_bound_storage = [0.]
import_(stability_factor_upper_bound_storage, folder,
filename + "_upper_bound")
assert len(stability_factor_upper_bound_storage) == 1
self._stability_factor_upper_bound = stability_factor_upper_bound_storage[
0]
def import_solution(self, folder, filename, solution=None):
if solution is None:
if self.snapshot is None:
self.snapshot = self.parametrized_expression.create_empty_snapshot(
)
solution = self.snapshot
return import_(solution, folder, filename)
def import_stability_factor_upper_bound(self, folder, filename):
eigenvalue_storage = [0.]
import_successful = import_(eigenvalue_storage, folder,
filename + "_UB")
if import_successful:
assert len(eigenvalue_storage) == 1
self._alpha_UB = eigenvalue_storage[0]
return import_successful
def import_supremizer(self,
folder=None,
filename=None,
supremizer=None,
component=None,
suffix=None):
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "supremizer"
if supremizer is None:
supremizer = self._supremizer
assert component is None or isinstance(component, str)
if component is None:
component = "s"
import_(supremizer, folder, filename + "_" + component, suffix,
component)
def import_output(self, folder=None, filename=None, output=None, suffix=None):
"""
Import solution from file.
"""
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "solution"
if output is None:
output = [0.]
import_(output, folder, filename + "_output", suffix)
assert len(output) == 1
assert isinstance(output[0], Number)
self._output = output[0]
else:
assert isinstance(output, list)
assert len(output) == 1
assert isinstance(output[0], Number)
import_(output, folder, filename + "_output", suffix)
def import_eigenvector(self, folder=None, filename=None):
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "coercivity_constant"
import_(self._eigenvector, folder, filename + "_eigenvector")
def import_eigenvector(self, folder, filename):
import_(self._eigenvector, folder, filename + "_eigenvector")
def import_solution(self, folder, filename, solution=None):
if solution is None:
solution = self.snapshot
import_(solution, folder, filename)
def import_stability_factor_lower_bound(self, folder, filename):
eigenvalue_storage = [0.]
import_(eigenvalue_storage, folder, filename + "_LB")
assert len(eigenvalue_storage) == 1
self._alpha_LB = eigenvalue_storage[0]
def import_eigenvector(self, folder=None, filename=None):
if folder is None:
folder = self.folder_prefix
if filename is None:
filename = "stability_factor"
import_(self._eigenvector, folder, filename + "_eigenvector")
def import_eigenvalue(self, folder, filename):
eigenvalue_storage = [0.]
import_(eigenvalue_storage, folder, filename + "_eigenvalue")
assert len(eigenvalue_storage) == 1
self._eigenvalue = eigenvalue_storage[0]
