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]