def write(self, function, name, index): time = float(index) # Write visualization file (no append available, will overwrite) self._update_function_container(function) self._visualization_file.write(self._function_container, time) # Write restart file. It might be possible that the solution was written to file in a previous run # and the execution was interrupted before last written index was updated. In this corner case # there would be two functions corresponding to the same time, with two consecutive indices. # For now the inelegant way is to try to read: if that works, assume that we are in the corner case; # otherwise, we are in the standard case and we should write to file. try: self._restart_file.read_checkpoint(self._function_container, name, index) except RuntimeError: self._update_function_container(function) bak_log_level = get_log_level() set_log_level(int(WARNING) + 1) # disable xdmf logs if self.append_attribute: self._restart_file.write_checkpoint( self._function_container, name, time, append=True) else: self._restart_file.write_checkpoint( self._function_container, name, time) set_log_level(bak_log_level) # Once solutions have been written to file, update last written index self._write_last_index(index)
def write(self, function, name, index): assert index in (self._last_index, self._last_index + 1) if index == self._last_index + 1: # writing out solutions after time stepping self._update_function_container(function) time = float(index) self._visualization_file.write(self._function_container, time) bak_log_level = get_log_level() set_log_level(int(WARNING) + 1) # disable xdmf logs) if self.append_attribute: self._restart_file.write_checkpoint( self._function_container, name, time, append=True) else: self._restart_file.write_checkpoint( self._function_container, name, time) set_log_level(bak_log_level) # Once solutions have been written to file, update last written index self._write_last_index(index) elif index == self._last_index: # corner case for problems with two (or more) unknowns which are written separately to file; # one unknown was written to file, while the other was not: since the problem might be coupled, # a recomputation of both is required, but there is no need to update storage pass else: raise ValueError("Invalid index")
from dolfin.cpp.log import log, LogLevel, set_log_level dolfin.parameters["std_out_all_processes"] = False from solvers import EquilibriumAM from solver_stability import StabilitySolver from linsearch import LineSearch from dolfin import * import yaml import mshr from lib import create_output, compile_continuation_data, getDefaultParameters from utils import get_versions code_parameters = get_versions() set_log_level(LogLevel.INFO) def perturbState(state, perturb): """ Perturbs current state with perturbation Arguments --------- state: dict like {'u': Coefficient, 'alpha': Coefficient} perturb: dict like {'v': Coefficient, 'beta': Coefficient, 'h': Float} """ u = state['u'] alpha = state['alpha'] perturbation_v = perturb['v']
from solvers import EquilibriumSolver from solver_stability import StabilitySolver from linsearch import LineSearch # from dolfin import NonlinearProblem, derivative, \ # TrialFunction, TestFunction, inner, assemble, sqrt, \ # Constant, interpolate, RectangleMesh, Point from dolfin import * import yaml from utils import get_versions code_parameters = get_versions() set_log_level(LogLevel.DEBUG) def compile_continuation_data(state, energy): continuation_data_i = {} continuation_data_i["energy"] = assemble(energy) return continuation_data_i def numerical_test( user_parameters, ell=0.05, nu=0., ): time_data = [] time_data_pd = [] spacetime = []
def _write_to_xdmf_file(fun, directory, filename, suffix, components=None): if components is not None: filename = filename + "_component_" + "".join(components) function_name = "function_" + "".join(components) else: function_name = "function" fun_rank = fun.value_rank() fun_dim = product(fun.value_shape()) assert fun_rank <= 2 if ((fun_rank is 1 and fun_dim not in (2, 3)) or (fun_rank is 2 and fun_dim not in (4, 9))): funs = fun.split(deepcopy=True) for (i, fun_i) in enumerate(funs): if components is not None: filename_i = filename + "_subcomponent_" + str(i) else: filename_i = filename + "_component_" + str(i) _write_to_xdmf_file(fun_i, directory, filename_i, suffix, None) else: full_filename_visualization = os.path.join(str(directory), filename + ".xdmf") full_filename_checkpoint = os.path.join(str(directory), filename + "_checkpoint.xdmf") if suffix is not None: if full_filename_checkpoint in _all_xdmf_files: assert _all_xdmf_latest_suffix[ full_filename_checkpoint] == suffix - 1 _all_xdmf_latest_suffix[full_filename_checkpoint] = suffix else: assert suffix == 0 # Remove existing files if any, as new functions should not be appended, # but rather overwrite existing functions if is_io_process() and os.path.exists( full_filename_checkpoint): os.remove(full_filename_checkpoint) os.remove(full_filename_checkpoint.replace(".xdmf", ".h5")) _all_xdmf_files[full_filename_visualization] = XDMFFile( full_filename_visualization) _all_xdmf_files[full_filename_checkpoint] = XDMFFile( full_filename_checkpoint) _all_xdmf_latest_suffix[ full_filename_checkpoint] = 0 # don't store these twice for both visualization _all_xdmf_functions[full_filename_checkpoint] = fun.copy( deepcopy=True) # and checkpoint, as they are the same! # Make sure to always use the same function, otherwise dolfin # changes the numbering and visualization is difficult in ParaView assign(_all_xdmf_functions[full_filename_checkpoint], fun) _all_xdmf_files[full_filename_visualization].write( _all_xdmf_functions[full_filename_checkpoint], float(suffix)) bak_log_level = get_log_level() set_log_level(int(WARNING) + 1) # disable xdmf logs _all_xdmf_files[full_filename_checkpoint].write_checkpoint( _all_xdmf_functions[full_filename_checkpoint], function_name, float(suffix)) set_log_level(bak_log_level) # Write out current suffix as well SuffixIO.save_file(suffix, directory, filename + "_suffix") else: # Remove existing files if any, as new functions should not be appended, # but rather overwrite existing functions if is_io_process() and os.path.exists(full_filename_checkpoint): os.remove(full_filename_checkpoint) os.remove(full_filename_checkpoint.replace(".xdmf", ".h5")) with XDMFFile(full_filename_visualization) as file_visualization: file_visualization.write(fun, 0.) with XDMFFile(full_filename_checkpoint) as file_checkpoint: file_checkpoint.write_checkpoint(fun, function_name, 0.)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with RBniCS. If not, see <http://www.gnu.org/licenses/>. # import pytest from mpi4py import MPI from dolfin import CellDiameter, Constant, det, dx, Expression, Function, FunctionSpace, grad, has_pybind11, inner, TensorFunctionSpace, TestFunction, TrialFunction, UnitSquareMesh, VectorFunctionSpace if has_pybind11(): from dolfin.cpp.log import log, LogLevel, set_log_level PROGRESS = LogLevel.PROGRESS else: from dolfin import log, PROGRESS, set_log_level set_log_level(PROGRESS) from rbnics.backends.dolfin import SeparatedParametrizedForm from rbnics.eim.utils.decorators.store_map_from_solution_to_problem import _solution_to_problem_map # Common variables mesh = UnitSquareMesh(10, 10) V = VectorFunctionSpace(mesh, "Lagrange", 2) expr1 = Expression("x[0]", mu_0=0., degree=1, cell=mesh.ufl_cell()) # f_5 expr2 = Expression(("x[0]", "x[1]"), mu_0=0., degree=1, cell=mesh.ufl_cell()) # f_6 expr3 = Expression((("1*x[0]", "2*x[1]"), ("3*x[0]", "4*x[1]")), mu_0=0., degree=1, cell=mesh.ufl_cell()) # f_7 expr4 = Expression((("4*x[0]", "3*x[1]"), ("2*x[0]", "1*x[1]")), mu_0=0., degree=1, cell=mesh.ufl_cell()) # f_8 expr5 = Expression("x[0]", degree=1, cell=mesh.ufl_cell()) # f_9 expr6 = Expression(("x[0]", "x[1]"), degree=1, cell=mesh.ufl_cell()) # f_10 expr7 = Expression((("1*x[0]", "2*x[1]"), ("3*x[0]", "4*x[1]")), degree=1, cell=mesh.ufl_cell()) # f_11