def setup_logging(level, logfile=None, logfile_level=None, verbatim_filename=False): # log level and format configuration log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s" logging.basicConfig(level=level, format=log_format) # FEniCS logging dolfin.set_log_active(True) dolfin.set_log_level(logging.WARNING) fenics_logger = logging.getLogger("FFC") fenics_logger.setLevel(logging.WARNING) fenics_logger = logging.getLogger("UFL") fenics_logger.setLevel(logging.WARNING) # explicitly set levels for certain loggers logging.getLogger("spuq").setLevel(level) logging.getLogger("spuq.application.egsz.multi_operator").setLevel(logging.WARNING) #logging.getLogger("spuq.application.egsz.marking").setLevel(logging.INFO) # output to logfile, if set if logfile: # replace .py or .conf with .log, if not prohibited if not verbatim_filename: logfile = basename(logfile, ".conf") logfile = basename(logfile, ".py") logfile = logfile + ".log" # create a new file handler (obsolete: specify mode "w" for overwriting, instead of the default "a") ch = logging.FileHandler(logfile, mode="a") ch.setLevel(logfile_level if logfile_level else level) ch.setFormatter(logging.Formatter(log_format)) # add to root logger root = logging.getLogger() root.addHandler(ch)
def make_logger(name, level=parameters["log_level"]): def log_if_process0(record): if dolfin.MPI.rank(mpi_comm_world()) == 0: return 1 else: return 0 mpi_filt = Object() mpi_filt.filter = log_if_process0 logger = logging.getLogger(name) logger.setLevel(level) ch = logging.StreamHandler() ch.setLevel(0) # formatter = logging.Formatter('%(message)s') formatter = logging.Formatter( ("%(asctime)s - " "%(name)s - " "%(levelname)s - " "%(message)s") ) ch.setFormatter(formatter) logger.addHandler(ch) logger.addFilter(mpi_filt) dolfin.set_log_level(logging.WARNING) ffc_logger = logging.getLogger("FFC") ffc_logger.setLevel(logging.WARNING) ffc_logger.addFilter(mpi_filt) ufl_logger = logging.getLogger("UFL") ufl_logger.setLevel(logging.WARNING) ufl_logger.addFilter(mpi_filt) return logger
def make_logger(name, level=logging.INFO): import logging import dolfin mpi_filt = lambda: None def log_if_proc0(record): if dolfin.mpi_comm_world().rank == 0: return 1 else: return 0 mpi_filt.filter = log_if_proc0 logger = logging.getLogger(name) logger.setLevel(log_level) ch = logging.StreamHandler() ch.setLevel(0) formatter = logging.Formatter("%(message)s") ch.setFormatter(formatter) logger.addHandler(ch) logger.addFilter(mpi_filt) dolfin.set_log_active(False) dolfin.set_log_level(dolfin.WARNING) return logger
def setup_logging(level): # log level and format configuration log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s" logging.basicConfig(filename=__file__[:-2] + 'log', level=level, format=log_format) # FEniCS logging from dolfin import (set_log_level, set_log_active, INFO, DEBUG, WARNING) set_log_active(True) set_log_level(WARNING) fenics_logger = logging.getLogger("FFC") fenics_logger.setLevel(logging.WARNING) fenics_logger = logging.getLogger("UFL") fenics_logger.setLevel(logging.WARNING) # module logger logger = logging.getLogger(__name__) logging.getLogger("spuq.application.egsz.multi_operator").disabled = True #logging.getLogger("spuq.application.egsz.marking").setLevel(logging.INFO) # add console logging output ch = logging.StreamHandler() ch.setLevel(level) ch.setFormatter(logging.Formatter(log_format)) logger.addHandler(ch) logging.getLogger("spuq").addHandler(ch) return logger
def main(): "Generates the mesh" import mshr as m import dolfin as d import matplotlib.pyplot as plt d.set_log_level(13) # PROGRESS r_1 = 0.5 # inner r_2 = 2.0 # outer res = 10 # resolution circle_inner = m.Circle(d.Point(0.0, 0.0), r_1) circle_outer = m.Circle(d.Point(0.0, 0.0), r_2) domain = circle_outer - circle_inner domain.set_subdomain(1, circle_inner) domain.set_subdomain(2, circle_outer) mesh = m.generate_mesh(domain, res) print("max edge length:", mesh.hmax()) mesh_file_pvd = d.File("mesh.pvd") mesh_file_pvd.write(mesh) plt.figure() d.plot(mesh, title="Mesh") plt.show()
def __init__(self, cparams, dtype_u, dtype_f): """ Initialization routine Args: cparams: custom parameters for the example dtype_u: particle data type (will be passed parent class) dtype_f: acceleration data type (will be passed parent class) """ # define the Dirichlet boundary def Boundary(x, on_boundary): return on_boundary # these parameters will be used later, so assert their existence assert 'c_nvars' in cparams assert 'nu' in cparams assert 't0' in cparams assert 'family' in cparams assert 'order' in cparams assert 'refinements' in cparams # add parameters as attributes for further reference for k,v in cparams.items(): setattr(self,k,v) df.set_log_level(df.WARNING) df.parameters["form_compiler"]["optimize"] = True df.parameters["form_compiler"]["cpp_optimize"] = True # set mesh and refinement (for multilevel) mesh = df.UnitIntervalMesh(self.c_nvars) # mesh = df.UnitSquareMesh(self.c_nvars[0],self.c_nvars[1]) for i in range(self.refinements): mesh = df.refine(mesh) # self.mesh = mesh # define function space for future reference self.V = df.FunctionSpace(mesh, self.family, self.order) tmp = df.Function(self.V) print('DoFs on this level:',len(tmp.vector().array())) # invoke super init, passing number of dofs, dtype_u and dtype_f super(fenics_heat,self).__init__(self.V,dtype_u,dtype_f) self.g = df.Expression('-sin(a*x[0]) * (sin(t) - b*a*a*cos(t))',a=np.pi,b=self.nu,t=self.t0,degree=self.order) # rhs in weak form self.w = df.Function(self.V) v = df.TestFunction(self.V) self.a_K = -self.nu*df.inner(df.nabla_grad(self.w), df.nabla_grad(v))*df.dx + self.g*v*df.dx # mass matrix u = df.TrialFunction(self.V) a_M = u*v*df.dx self.M = df.assemble(a_M) self.bc = df.DirichletBC(self.V, df.Constant(0.0), Boundary)
def setup(self): """ Setup logging to file if requested in the simulation input """ # Ensure that the output directory exist tmp = self.simulation.input.get_output_file_path('BOGUS', 'xxxxx') output_dir = os.path.split(tmp)[0] if output_dir and not os.path.exists(output_dir): os.makedirs(output_dir) log_name = self.simulation.input.get_output_file_path('output/log_name', '.log') log_on_all_ranks = self.simulation.input.get_value( 'output/log_on_all_ranks', False, 'bool' ) log_enabled = self.simulation.input.get_value( 'output/log_enabled', True, 'bool' ) log_append_existing = self.simulation.input.get_value( 'output/log_append_to_existing_file', True, 'bool' ) stdout_on_all_ranks = self.simulation.input.get_value( 'output/stdout_on_all_ranks', False, 'bool' ) stdout_enabled = self.simulation.input.get_value( 'output/stdout_enabled', True, 'bool' ) self.show_memory_usage = self.simulation.input.get_value( 'output/show_memory_usage', False, 'bool' ) rank = self.simulation.rank self.write_stdout = (rank == 0 or stdout_on_all_ranks) and stdout_enabled self.write_log = False if log_enabled: if log_on_all_ranks and rank > 0: log_name = '%s.%d' % (log_name, self.simulation.rank) if rank == 0 or log_on_all_ranks: self.write_log = True self.log_file_name = log_name if log_append_existing: self.log_file = open(self.log_file_name, 'at') self.log_file.write('\n\n') else: self.log_file = open(self.log_file_name, 'wt') # Set the Ocellaris log level log_level = self.simulation.input.get_value( 'output/ocellaris_log_level', 'info' ) self.simulation.log.set_log_level(self.AVAILABLE_LOG_LEVELS[log_level]) # Set the Dolfin log level df_log_level = self.simulation.input.get_value( 'output/dolfin_log_level', 'warning' ) dolfin.set_log_level(self.AVAILABLE_LOG_LEVELS[df_log_level])
def init_ffc(): import dolfin as _dolfin flags = ["-O3", "-ffast-math"] # , "-march=native"] _dolfin.parameters["form_compiler"]["quadrature_degree"] = 4 _dolfin.parameters["form_compiler"]["representation"] = "uflacs" _dolfin.parameters["form_compiler"]["cpp_optimize"] = True _dolfin.parameters["form_compiler"]["cpp_optimize_flags"] = " ".join(flags) _dolfin.set_log_level(_logging.WARNING)
def __init__(self, domain, **kwargs): dolf.set_log_level(LOG_LEVEL) self.domain = domain self._visualization_files = None experiment_id = kwargs.get("experiment_id", "") if experiment_id: experiment_id = "_" + experiment_id self.vis_dir = "Visualization" + experiment_id + "/" if not os.path.exists(self.vis_dir): os.makedirs(self.vis_dir)
def setUp(self): d.set_log_level(d.LogLevel.WARNING) N = 50 order = 2 tF = 0.10 # Dirichlet boundary characteristic time tau = tF / 10.0 # time step h = 0.001 self.num_steps = round(tF / h) # Mesh and Function space mesh = d.UnitIntervalMesh(N) V = d.FunctionSpace(mesh, "P", order) w = d.TestFunction(V) v = d.TrialFunction(V) # Initial conditions chosen such that the wave travels to the right uInit = d.Expression( "((1./3 < x[0]) && (x[0] < 2./3)) ? 0.5*(1-cos(2*pi*3*(x[0]-1./3))) : 0.", degree=2, ) u = d.interpolate(uInit, V) # values # Dirichlet boundary on the right with its derivatives g = d.Expression( "(t < total) ? 0.4*(1.-cos(2*pi*t/total))/2. : 0.", degree=2, t=0.0, total=tau, ) dg = d.Expression( "(t < total) ? 0.4*(pi/total) * sin(2*pi*t/total) : 0.", degree=2, t=0.0, total=tau, ) def updateBC(t): g.t = t dg.t = t def right(x, on_boundary): return on_boundary and d.near(x[0], 1.0) bc0 = d.DirichletBC(V, g, right) bc1 = d.DirichletBC(V, dg, right) self.bc = [bc0, bc1] L1 = -d.inner(d.grad(w), d.grad(u)) * d.dx L2 = w * v * d.dx self.parameters = (L1, L2, u, h, updateBC)
def set_log_level(level): """Sets the log level. Parameters ---------- level : int Log level that should be set. """ df.set_log_level(level) m3h3.parameters.update({"log_level": df.get_log_level()}) log(LogLevel.INFO, "Log level updated to {}".format(level))
def set_solver(): # "hypre_amg") #"hypre_euclid") # "hypre_amg") # "petsc_amg" "petsc_amg" solver = d.KrylovSolver("cg", "hypre_amg") solver.parameters["maximum_iterations"] = 1000 solver.parameters["absolute_tolerance"] = 1E-8 solver.parameters["error_on_nonconvergence"] = True solver.parameters["monitor_convergence"] = True # solver.parameters["divergence_limit"] = 1E+6 # solver.parameters["nonzero_initial_guess"] = True d.info(solver.parameters, verbose=True) d.set_log_level(d.PROGRESS) return solver
def test_save_load(): """Solve a problem, save the data, load it back and compare.""" df.set_log_level(100) # supress dolfin logger # Setup solver solver = SubdomainSolver(N=32) with tempfile.TemporaryDirectory() as tmpdirname: tmpdirname = "foo" casedir = Path(tmpdirname) / "test_pp_casedir" # Setup saver field_spec = FieldSpec(stride_timestep=1, save_as=("checkpoint", "hdf5")) saver_spec = SaverSpec(casedir=str(casedir)) saver = Saver(saver_spec) saver.store_mesh( solver.mesh, cell_domains=solver.cell_function, facet_domains=solver.facet_function ) saver.add_field(Field("u", field_spec)) # Solver loop time_func_dict = {} for timestep, (t, u) in enumerate(solver.solve(0, 100, 1.0)): saver.update(t, timestep, {"u": u}) time_func_dict[timestep] = u.copy(True) saver.close() # Define loader loader_spec = LoaderSpec(casedir=str(casedir)) loader = Loader(loader_spec) loaded_mesh = loader.load_mesh() loaded_cell_function = loader.load_mesh_function("cell_function") loaded_facet_function = loader.load_mesh_function("facet_function") # Compare mesh and meshfunctions assert np.sum(solver.mesh.coordinates() - loaded_mesh.coordinates()) == 0 assert np.sum(solver.mesh.cells() - loaded_mesh.cells()) == 0 assert np.sum(solver.cell_function.array() - loaded_cell_function.array()) == 0 assert np.sum(solver.facet_function.array() - loaded_facet_function.array()) == 0 # Compare functions and time checkpoint for timestep, (loaded_t, loaded_u) in enumerate(loader.load_checkpoint("u")): diff = np.sum(time_func_dict[timestep].vector().get_local() - loaded_u.vector().get_local()) assert diff == 0, diff # Compare functions and time hdf5 for timestep, (loaded_t, loaded_u) in enumerate(loader.load_field("u")): diff = np.sum(time_func_dict[timestep].vector().get_local() - loaded_u.vector().get_local()) assert diff == 0, diff
def test_mpset(): #set_log_level(DEBUG) # Print parameters and their values #mpset.show() # Check that assignment out of range raises # FIXME: dolfin/parameter/Parameter.cpp is broken. # It doesn't raise when assigning a value out of range; # see 921c56cee4f50f016a07f49a5e90f6627c7317a6 # with pytest.raises(RuntimeError): # mpset["discretization"]["N"] = 1 # with pytest.raises(RuntimeError): # mpset["model"]["mobility"]["beta"] = 2.0 with pytest.raises(RuntimeError): mpset["model"]["mobility"]["m"] = 0.0 # Try to add parameter mpset.add("foo", "bar") assert mpset["foo"] == "bar" # Try direct access to a parameter mpset["foo"] = "bar_" assert mpset["foo"] == "bar_" # Try to write parameters to a file comm = mpi_comm_world() tempdir = "/tmp/pytest-of-fenics" fname = tempdir + "/foo.xml" mpset.write(comm, fname) if MPI.rank(comm) == 0: assert os.path.isfile(fname) MPI.barrier(comm) # wait until the file is written # Change back value of parameter 'foo' mpset["foo"] = "bar" assert mpset["foo"] == "bar" # Try to read parameters back mpset.read(fname) assert mpset["foo"] == "bar_" MPI.barrier(comm) # wait until each process finishes reading if MPI.rank(comm) == 0: os.remove(fname) del fname # Check that every other call points to the same object assert id(MuflonParameterSet()) == id(mpset) # Cleanup set_log_level(INFO) mpset.refresh()
def setup_general_parameters(): """ Parameters to speed up the compiler """ # Parameter for the compiler flags = ["-O3", "-ffast-math", "-march=native"] dolfin.parameters["form_compiler"]["quadrature_degree"] = 4 dolfin.parameters["form_compiler"]["representation"] = "uflacs" dolfin.parameters["form_compiler"]["cpp_optimize"] = True dolfin.parameters["form_compiler"]["cpp_optimize_flags"] = " ".join(flags) # dolfin.set_log_active(False) dolfin.set_log_level(logging.INFO)
def run_mms0(): df.set_log_level(20) N = [2, 4, 8, 16, 32, 40, 50, 60, 70, 80] errors = [] dxs = [] rho = 0.7 # load mms p_code, m_code, q_code = manufactured_solution(rho) for nx in N: mesh = df.UnitCubeMesh(nx, nx, nx) p_D = df.Expression(p_code, degree=2) m_D = df.Expression(m_code, degree=2) q_D = df.Expression(q_code, degree=2) # load perspect solution m = run_perspect(mesh, q_D, p_D, m_D, rho) e = df.errornorm(m_D, m, degree_rise=0) F = df.FunctionSpace(mesh, 'P', 2) n = df.interpolate(m_D, F) f = df.File("test.pvd") f << m errors.append(e) dxs.append(mesh.hmin()) errors = np.array(errors) dxs = np.array(dxs) conv_rates = np.log(errors[1:] / errors[0:-1]) / np.log( dxs[1:] / dxs[0:-1]) print(errors) print(dxs) print(conv_rates) import matplotlib.pyplot as plt plt.loglog(dxs, errors) plt.loglog(dxs, errors, marker='o') plt.xlabel("dx") plt.ylabel("L2 errornorm") plt.grid(True, which="both") plt.savefig("mms0_convergence.png")
def make_logger(name, level=logging.INFO): import logging mpi_filt = lambda: None def log_if_proc0(record): if dolfin.MPI.rank(dolfin.mpi_comm_world()) == 0: return 1 else: return 0 mpi_filt.filter = log_if_proc0 logger = logging.getLogger(name) logger.setLevel(level) ch = logging.StreamHandler() ch.setLevel(0) formatter = logging.Formatter( "%(message)s") #'\n%(name)s - %(levelname)s - %(message)s\n' ch.setFormatter(formatter) logger.addHandler(ch) logger.addFilter(mpi_filt) dolfin.set_log_active(False) dolfin.set_log_level(dolfin.WARNING) # ffc_logger = logging.getLogger('FFC') # ffc_logger.setLevel(DEBUG) # ffc_logger.addFilter(mpi_filt) # ufl_logger = logging.getLogger('UFL') # ufl_logger.setLevel(DEBUG) # ufl_logger.addFilter(mpi_filt) # from haosolver import logger as hao_logger # hao_logger.setLevel(DEBUG) return logger
def make_logger(name, level=logging.INFO): def log_if_process0(record): if dolfin.MPI.rank(dolfin.mpi_comm_world()) == 0: return 1 else: return 0 mpi_filt = Object() mpi_filt.filter = log_if_process0 logger = logging.getLogger(name) logger.setLevel(level) ch = logging.StreamHandler() ch.setLevel(0) # formatter = logging.Formatter('%(message)s') formatter = logging.Formatter(('%(asctime)s - ' '%(name)s - ' '%(levelname)s - ' '%(message)s')) ch.setFormatter(formatter) logger.addHandler(ch) logger.addFilter(mpi_filt) dolfin.set_log_active(False) dolfin.set_log_level(dolfin.WARNING) ffc_logger = logging.getLogger('FFC') ffc_logger.setLevel(dolfin.WARNING) ffc_logger.addFilter(mpi_filt) ufl_logger = logging.getLogger('UFL') ufl_logger.setLevel(dolfin.WARNING) ufl_logger.addFilter(mpi_filt) return logger
from dolfin import set_log_level, WARNING, Expression, FunctionSpace, \ DirichletBC, Function, errornorm, project, plot, interactive, triangle, \ norm, UnitIntervalMesh, pi, inner, grad, dx, ds, dot, UnitSquareMesh, \ FacetNormal, interval, RectangleMesh, TrialFunction, TestFunction, \ assemble, lhs, rhs, MPI import maelstrom.time_steppers as ts import sympy as smp import numpy import itertools import helpers # Turn down the log level to only error messages. set_log_level(WARNING) #set_log_level(ERROR) #set_log_level(0) def test_generator(): '''Test order of time discretization. ''' # TODO add test for spatial order problems = [ #problem_sinsin1d, #problem_sinsin, problem_coscos_cartesian, #problem_coscos_cylindrical, #problem_stefanboltzmann ]
def custom_apply(self_, *args, **kwargs): set_log_level(ERROR) original_apply(*args, **kwargs) set_log_level(PROGRESS)
def project(*args, **kwargs): set_log_level(ERROR) output = dolfin_project(*args, **kwargs) set_log_level(PROGRESS) return output
def wrapped_f(*args, **kwargs): old_level = get_log_level() set_log_level(log_level) f(*args, **kwargs) set_log_level(old_level)
def test_stokes_noflow(gamma, Re, nu_interp, postprocessor): #set_log_level(WARNING) basename = postprocessor.basename label = "{}_{}_gamma_{}_Re_{:.0e}".format(basename, nu_interp, gamma, Re) c = postprocessor.get_coefficients() c[r"\nu_1"] = c[r"\rho_1"] / Re c[r"\nu_2"] = c[r"r_visc"] * c[r"\nu_1"] c[r"\nu_1"] /= c[r"\rho_0"] * c[r"V_0"] * c[r"L_0"] c[r"\nu_2"] /= c[r"\rho_0"] * c[r"V_0"] * c[r"L_0"] cc = wrap_coeffs_as_constants(c) nu = eval("nu_" + nu_interp) # choose viscosity interpolation for level in range(1, 4): mesh, boundary_markers, pinpoint, periodic_bnd = create_domain(level) periodic_bnd = None W = create_mixed_space(mesh, periodic_boundary=periodic_bnd) bcs = create_bcs(W, boundary_markers, periodic_boundary=periodic_bnd, pinpoint=pinpoint) phi = create_fixed_vfract(mesh, c) # Create forms a, L = create_forms(W, rho(phi, cc), nu(phi, cc), c[r"g_a"], boundary_markers, gamma) # Solve problem w = df.Function(W) A, b = df.assemble_system(a, L, bcs) solver = df.LUSolver("mumps") df.PETScOptions.set("fieldsplit_u_mat_mumps_icntl_14", 500) solver.set_operator(A) try: solver.solve(w.vector(), b) except: df.warning("Ooops! Something went wrong: {}".format( sys.exc_info()[0])) continue # Pre-process results v, p = w.split(True) v.rename("v", "velocity") p.rename("p", "pressure") V_dv = df.FunctionSpace(mesh, "DG", W.sub(0).ufl_element().degree() - 1) div_v = df.project(df.div(v), V_dv) div_v.rename("div_v", "velocity-divergence") D_22 = df.project(v.sub(1).dx(1), V_dv) p_h = create_hydrostatic_pressure(mesh, cc) #p_ref = df.project(p_h, W.sub(1).ufl_element()) p_ref = df.project( p_h, df.FunctionSpace(mesh, df.FiniteElement("CG", mesh.ufl_cell(), 4))) v_errL2, v_errH10, div_errL2, p_errL2 = compute_errornorms( v, div_v, p, p_ref) if nu_interp[:2] == "PW": V_nu = df.FunctionSpace(mesh, "DG", phi.ufl_element().degree()) else: V_nu = phi.function_space() nu_0 = df.project(nu(phi, cc), V_nu) T_22 = df.project(2.0 * nu(phi, cc) * v.sub(1).dx(1), V_nu) # Save results make_cut = postprocessor._make_cut rs = dict(ndofs=W.dim(), level=level, h=mesh.hmin(), r_dens=c[r"r_dens"], r_visc=c[r"r_visc"], gamma=gamma, Re=Re, nu_interp=nu_interp) rs[r"$v_2$"] = make_cut(v.sub(1)) rs[r"$p$"] = make_cut(p) rs[r"$\phi$"] = make_cut(phi) rs[r"$D_{22}$"] = make_cut(D_22) rs[r"$T_{22}$"] = make_cut(T_22) rs[r"$\nu$"] = make_cut(nu_0) rs[r"$||\mathbf{v} - \mathbf{v}_h||_{L^2}$"] = v_errL2 rs[r"$||\nabla (\mathbf{v} - \mathbf{v}_h)||_{L^2}$"] = v_errH10 rs[r"$||\mathrm{div} \mathbf{v}_h||_{L^2}$"] = div_errL2 rs[r"$||\mathbf{p} - \mathbf{p}_h||_{L^2}$"] = p_errL2 print(label, level) # Send to posprocessor comm = mesh.mpi_comm() rank = df.MPI.rank(comm) postprocessor.add_result(rank, rs) # Plot results obtained in the last round outdir = os.path.join(postprocessor.outdir, "XDMFoutput") with df.XDMFFile(os.path.join(outdir, "v.xdmf")) as file: file.write(v, 0.0) with df.XDMFFile(os.path.join(outdir, "p.xdmf")) as file: file.write(p, 0.0) with df.XDMFFile(os.path.join(outdir, "phi.xdmf")) as file: file.write(phi, 0.0) with df.XDMFFile(os.path.join(outdir, "div_v.xdmf")) as file: file.write(div_v, 0.0) # Save results into a binary file filename = "results_{}.pickle".format(label) postprocessor.save_results(filename) # Flush plots as we now have data for all level values postprocessor.pop_items(["level", "h"]) postprocessor.flush_plots() # Cleanup df.set_log_level(df.INFO) gc.collect()
import dolfin as df import numpy as np import perspect import pulse import sys import time from geometry import Geometry, MarkerFunctions, Microstructure comm = df.MPI.comm_world df.set_log_level(40) mesh = df.BoxMesh(comm, df.Point(0, 0, 0), df.Point(3, 1, 0.1), 30, 10, 1) class Base(df.SubDomain): def inside(self, x, on_boundary): return on_boundary and df.near(x[1], 0) class Endo(df.SubDomain): def inside(self, x, on_boundary): return on_boundary and df.near(x[0], 0) class Epi(df.SubDomain): def inside(self, x, on_boundary): return on_boundary and df.near(x[0], 1.0) markers = {'BASE': (10, 1), 'ENDO': (30, 1), 'EPI': (40, 1), 'NONE': (0, 2)} ffun = df.MeshFunction("size_t", mesh, mesh.topology().dim() - 1)
import sys; sys.path.append('../') import numpy as np import matplotlib; matplotlib.use('agg') import matplotlib.pyplot as plt import os import warnings warnings.filterwarnings('ignore',category=FutureWarning) from dolfin import set_log_level; set_log_level(40) from tensorflow.keras import Sequential, Model, Input from tensorflow.keras.optimizers import Adam from tensorflow.keras.layers import * from tensorflow.keras.regularizers import l1_l2, l2, l1 from tensorflow.keras.callbacks import LearningRateScheduler from deep_learning.generate_fin_dataset import gen_affine_avg_rom_dataset def load_dataset_avg_rom(load_prev=True, tr_size=6000, v_size=500, genrand=False): ''' Load dataset where the conductivity is parametrized as a FEniCS function and the QoI is the averaged temperature per subfin ''' if os.path.isfile('../data/z_aff_avg_tr.npy') and load_prev: z_train = np.load('../data/z_aff_avg_tr.npy') errors_train = np.load('../data/errors_aff_avg_tr.npy') else: (z_train, errors_train) = gen_affine_avg_rom_dataset(tr_size, genrand=genrand) if os.path.isfile('../data/z_aff_avg_eval.npy') and load_prev: z_val = np.load('../data/z_aff_avg_eval.npy')
args, remaining = parser.parse_known_args() # additional output PETScOptions.set('ksp_view') # shows info about used PETSc Solver and preconditioner # if args.solver == 'ipcs1': # PETScOptions.set('log_summary') # Paralell run initialization comm = mpi_comm_world() rank = MPI.rank(comm) # parameters["std_out_all_processes"] = False # print only rank==0 process output # parameters["ghost_mode"] = "shared_facet" # may be needed for operating DG elements in parallel # allows output using info() for the main process only if rank == 0 or args.out == 'all': set_log_level(INFO) else: set_log_level(INFO + 1) info('Running on %d processor(s).' % MPI.size(comm)) if MPI.size(comm) > 1 and args.problem == 'womersley_cylinder': info('Womersley cylinder problem is not runnable in parallel due to method of construction of analytic solution,' ' which is used to describe boundary conditions.') # the change of mesh format would be also needed exit() # dynamically import selected solver and problem files exec('from solvers.%s import Solver' % args.solver) exec('from problems.%s import Problem' % args.problem) # setup and parse problem- and solver-specific command-line arguments
import dolfin import numpy as np import scipy.sparse.linalg as spsla from time_int_schemes import expand_vp_dolfunc, get_dtstr import dolfin_navier_scipy.problem_setups as dnsps import dolfin_navier_scipy.stokes_navier_utils as snu from prob_defs import FempToProbParams import matlibplots.conv_plot_utils as cpu dolfin.set_log_level(60) samplerate = 1 N, Re, scheme, tE = 3, 60, 'CR', .2 # Ntslist = [2**x for x in range(6, 11)] Ntslist = [2**x for x in range(8, 10)] Ntsref = 2048 tol = 2**(-16) tolcor = True method = 1 svdatapathref = 'data/' svdatapath = 'data/' # svdatapath = 'edithadata/' # svdatapath = 'edithadata_scm/' # with the scaled momentum eqn femp, stokesmatsc, rhsd_vfrc, rhsd_stbc \ = dnsps.get_sysmats(problem='cylinderwake', N=N, Re=Re,
def __init__(self, cparams, dtype_u, dtype_f): """ Initialization routine Args: cparams: custom parameters for the example dtype_u: particle data type (will be passed parent class) dtype_f: acceleration data type (will be passed parent class) """ # define the Dirichlet boundary def Boundary(x, on_boundary): return on_boundary # these parameters will be used later, so assert their existence assert 'c_nvars' in cparams assert 't0' in cparams assert 'family' in cparams assert 'order' in cparams assert 'refinements' in cparams # add parameters as attributes for further reference for k,v in cparams.items(): setattr(self,k,v) df.set_log_level(df.WARNING) df.parameters["form_compiler"]["optimize"] = True df.parameters["form_compiler"]["cpp_optimize"] = True # set mesh and refinement (for multilevel) # mesh = df.UnitIntervalMesh(self.c_nvars) # mesh = df.UnitSquareMesh(self.c_nvars[0],self.c_nvars[1]) mesh = df.IntervalMesh(self.c_nvars,0,100) # mesh = df.RectangleMesh(0.0,0.0,2.0,2.0,self.c_nvars[0],self.c_nvars[1]) for i in range(self.refinements): mesh = df.refine(mesh) # self.mesh = mesh # define function space for future reference V = df.FunctionSpace(mesh, self.family, self.order) self.V = V*V # invoke super init, passing number of dofs, dtype_u and dtype_f super(fenics_grayscott,self).__init__(self.V,dtype_u,dtype_f) # rhs in weak form self.w = df.Function(self.V) q1,q2 = df.TestFunctions(self.V) self.w1,self.w2 = df.split(self.w) self.F1 = (-self.Du*df.inner(df.nabla_grad(self.w1), df.nabla_grad(q1)) - self.w1*(self.w2**2)*q1 + self.A*(1-self.w1)*q1)*df.dx self.F2 = (-self.Dv*df.inner(df.nabla_grad(self.w2), df.nabla_grad(q2)) + self.w1*(self.w2**2)*q2 - self.B* self.w2*q2)*df.dx self.F = self.F1+self.F2 # mass matrix u1,u2 = df.TrialFunctions(self.V) a_M = u1*q1*df.dx M1 = df.assemble(a_M) a_M = u2*q2*df.dx M2 = df.assemble(a_M) self.M = M1+M2
def __init__(self, cparams, dtype_u, dtype_f): """ Initialization routine Args: cparams: custom parameters for the example dtype_u: particle data type (will be passed parent class) dtype_f: acceleration data type (will be passed parent class) """ # define the Dirichlet boundary # def Boundary(x, on_boundary): # return on_boundary # Sub domain for Periodic boundary condition class PeriodicBoundary(df.SubDomain): # Left boundary is "target domain" G def inside(self, x, on_boundary): return bool(x[0] < df.DOLFIN_EPS and x[0] > -df.DOLFIN_EPS and on_boundary) # Map right boundary (H) to left boundary (G) def map(self, x, y): y[0] = x[0] - 1.0 # these parameters will be used later, so assert their existence assert 'c_nvars' in cparams assert 'nu' in cparams assert 't0' in cparams assert 'family' in cparams assert 'order' in cparams assert 'refinements' in cparams # add parameters as attributes for further reference for k,v in cparams.items(): setattr(self,k,v) df.set_log_level(df.WARNING) # set mesh and refinement (for multilevel) mesh = df.UnitIntervalMesh(self.c_nvars) # mesh = df.UnitSquareMesh(self.c_nvars[0],self.c_nvars[1]) for i in range(self.refinements): mesh = df.refine(mesh) # define function space for future reference self.V = df.FunctionSpace(mesh, self.family, self.order, constrained_domain=PeriodicBoundary()) tmp = df.Function(self.V) print('DoFs on this level:',len(tmp.vector().array())) # invoke super init, passing number of dofs, dtype_u and dtype_f super(fenics_adv_diff_1d,self).__init__(self.V,dtype_u,dtype_f) u = df.TrialFunction(self.V) v = df.TestFunction(self.V) # Stiffness term (diffusion) a_K = -1.0*df.inner(df.nabla_grad(u), self.nu*df.nabla_grad(v))*df.dx # Stiffness term (advection) a_G = df.inner(self.mu*df.nabla_grad(u)[0], v)*df.dx # Mass term a_M = u*v*df.dx self.M = df.assemble(a_M) self.K = df.assemble(a_K) self.G = df.assemble(a_G)
def wrapped(*args, **kwargs): old_level = get_log_level() set_log_level(log_level) function(*args, **kwargs) set_log_level(old_level)
__author__ = "Jan Blechta" __version__ = "2017.1.0.dev0" __license__ = 'LGPL v3' # Avoid PETSc being initialized by DOLFIN, which sets some performance # degrading parameters since e91b4100. This assumes that this module # is imported before DOLFIN; otherwise the assertion may fail. # TODO: Test whether it works! from petsc4py import PETSc from dolfin import SubSystemsManager assert not SubSystemsManager.responsible_petsc() del PETSc, SubSystemsManager # Reduce DOLFIN logging bloat in parallel from dolfin import set_log_level, get_log_level, MPI, mpi_comm_world set_log_level(get_log_level()+(0 if MPI.rank(mpi_comm_world())==0 else 1)) del set_log_level, get_log_level # Parse command-line options # FIXME: Automatic parsing temporarily commented out as it disallows parsing # our own application specific parameters. Do we need it somewhere? #from dolfin import parameters #parameters.parse() # Enable info_{green,red,blue} on rank 0 import ufl ufl.set_level(ufl.INFO if MPI.rank(mpi_comm_world())==0 else ufl.INFO+1) del ufl, MPI, mpi_comm_world from dolfintape.flux_reconstructor import FluxReconstructor
def __init__(self, cparams, dtype_u, dtype_f): """ Initialization routine Args: cparams: custom parameters for the example dtype_u: particle data type (will be passed parent class) dtype_f: acceleration data type (will be passed parent class) """ # define the Dirichlet boundary # def Boundary(x, on_boundary): # return on_boundary # Sub domain for Periodic boundary condition class PeriodicBoundary(df.SubDomain): # Left boundary is "target domain" G def inside(self, x, on_boundary): # return True if on left or bottom boundary AND NOT on one of the two corners (0, 1) and (1, 0) return bool((df.near(x[0], 0) or df.near(x[1], 0)) and (not ((df.near(x[0], 0) and df.near(x[1], 1)) or (df.near(x[0], 1) and df.near(x[1], 0)))) and on_boundary) def map(self, x, y): if df.near(x[0], 1) and df.near(x[1], 1): y[0] = x[0] - 1. y[1] = x[1] - 1. elif df.near(x[0], 1): y[0] = x[0] - 1. y[1] = x[1] else: # near(x[1], 1) y[0] = x[0] y[1] = x[1] - 1. # these parameters will be used later, so assert their existence assert 'c_nvars' in cparams assert 'nu' in cparams assert 't0' in cparams assert 'family' in cparams assert 'order' in cparams assert 'refinements' in cparams # add parameters as attributes for further reference for k,v in cparams.items(): setattr(self,k,v) df.set_log_level(df.WARNING) # set mesh and refinement (for multilevel) # mesh = df.UnitIntervalMesh(self.c_nvars) mesh = df.UnitSquareMesh(self.c_nvars[0],self.c_nvars[1]) for i in range(self.refinements): mesh = df.refine(mesh) self.mesh = df.Mesh(mesh) self.bc = PeriodicBoundary() # define function space for future reference self.V = df.FunctionSpace(mesh, self.family, self.order, constrained_domain=self.bc) tmp = df.Function(self.V) print('DoFs on this level:',len(tmp.vector().array())) # invoke super init, passing number of dofs, dtype_u and dtype_f super(fenics_vortex_2d,self).__init__(self.V,dtype_u,dtype_f) w = df.TrialFunction(self.V) v = df.TestFunction(self.V) # Stiffness term (diffusion) a_K = df.inner(df.nabla_grad(w), df.nabla_grad(v))*df.dx # Mass term a_M = w*v*df.dx self.M = df.assemble(a_M) self.K = df.assemble(a_K)
def test_shear(scheme, nu_interp, postprocessor): #set_log_level(WARNING) assert scheme == "SemiDecoupled" dt = 0.0 # solve as the stationary problem # Read parameters scriptdir = os.path.dirname(os.path.realpath(__file__)) prm_file = os.path.join(scriptdir, "interface-parameters.xml") mpset.read(prm_file) # Adjust parameters c = postprocessor.get_coefficients() mpset["model"]["eps"] = c[r"\eps"] mpset["model"]["rho"]["1"] = c[r"\rho_1"] mpset["model"]["rho"]["2"] = c[r"\rho_2"] mpset["model"]["nu"]["1"] = c[r"\nu_1"] mpset["model"]["nu"]["2"] = c[r"\nu_2"] mpset["model"]["chq"]["L"] = c[r"L_0"] mpset["model"]["chq"]["V"] = c[r"V_0"] mpset["model"]["chq"]["rho"] = c[r"\rho_0"] mpset["model"]["mobility"]["M0"] = 1.0e+0 mpset["model"]["sigma"]["12"] = 1.0e-0 #mpset.show() cc = wrap_coeffs_as_constants(c) # Names and directories basename = postprocessor.basename label = "{}_{}".format(basename, nu_interp) outdir = postprocessor.outdir for level in range(2, 3): # Prepare domain and discretization mesh, boundary_markers, pinpoint, periodic_bnd = create_domain( level, "crossed") del periodic_bnd DS, div_v = create_discretization(scheme, mesh, div_projection=True) DS.parameters["PTL"] = 1 DS.setup() # Prepare initial and boundary conditions load_initial_conditions(DS, c) bcs = create_bcs(DS, boundary_markers, pinpoint) # for Dirichlet p_h = create_hydrostatic_pressure(mesh, cc) # for Neumann # Force applied on the top plate B = 0.0 if dt == 0.0 else 1.0 applied_force = df.Expression( ("A*(1.0 - B*exp(-alpha*t))", "0.0"), degree=DS.subspace("v", 0).ufl_element().degree(), t=0.0, alpha=1.0, A=1.0, B=B) # Prepare model model = ModelFactory.create("Incompressible", DS, bcs) model.parameters["THETA2"] = 0.0 #model.parameters["rho"]["itype"] = "lin" #model.parameters["rho"]["trunc"] = "minmax" model.parameters["nu"]["itype"] = nu_interp model.parameters["nu"]["trunc"] = "minmax" #model.parameters["nu"]["trunc"] = "clamp_hard" #model.parameters["mobility"]["cut"] = True # Prepare external source term g_a = c[r"g_a"] g_a /= mpset["model"]["chq"]["V"]**2.0 * mpset["model"]["chq"]["L"] f_src = df.Constant((0.0, -g_a), cell=mesh.ufl_cell(), name="f_src") model.load_sources(f_src) # Create forms forms = model.create_forms() # Add boundary integrals n = DS.facet_normal() ds = df.Measure("ds", subdomain_data=boundary_markers) test = DS.test_functions() forms["lin"]["rhs"] +=\ df.inner(applied_force, test["v"]) * ds(3) # driving force forms["lin"]["rhs"] -=\ p_h * df.inner(n, test["v"]) * (ds(2) + ds(4)) # hydrostatic balance # Prepare solver solver = SolverFactory.create(model, forms, fix_p=False) # Prepare time-stepping algorithm comm = mesh.mpi_comm() pv = DS.primitive_vars_ctl() modulo_factor = 1 xfields = list(zip(pv["phi"].split(), ("phi", ))) xfields.append((pv["p"].dolfin_repr(), "p")) if scheme == "FullyDecoupled": xfields += list(zip(pv["v"].split(), ("v1", "v2"))) else: xfields.append((pv["v"].dolfin_repr(), "v")) if div_v is not None: xfields.append((div_v, "div_v")) functionals = {"t": [], "E_kin": [], "Psi": [], "mean_p": []} hook = prepare_hook(model, applied_force, functionals, modulo_factor, div_v) logfile = "log_{}.dat".format(label) TS = TimeSteppingFactory.create("ConstantTimeStep", comm, solver, hook=hook, logfile=logfile, xfields=xfields, outdir=outdir) TS.parameters["xdmf"]["folder"] = "XDMF_{}".format(label) TS.parameters["xdmf"]["modulo"] = modulo_factor TS.parameters["xdmf"]["flush"] = True TS.parameters["xdmf"]["iconds"] = True # Time-stepping with Timer("Time stepping") as tmr_tstepping: result = TS.run(0.0, 2.0, dt, OTD=1) # Pre-process results v = pv["v"].dolfin_repr() p = pv["p"].dolfin_repr() phi = pv["phi"].split()[0] w_diff = DS.solution_ctl()[0].copy(True) w0 = DS.solution_ptl(0)[0] w_diff.vector().axpy(-1.0, w0.vector()) phi_diff = w_diff.split(True)[0] phi_diff.rename("phi_diff", "phi_tstep_difference") xdmfdir = \ os.path.join(outdir, TS.parameters["xdmf"]["folder"], "phi_diff.xdmf") with df.XDMFFile(xdmfdir) as file: file.write(phi_diff, 0.0) D_12 = df.project(0.5 * v.sub(0).dx(1), div_v.function_space()) if nu_interp in [ "har", ]: deg = DS.subspace("phi", 0).ufl_element().degree() V_nu = df.FunctionSpace(mesh, "DG", deg) else: V_nu = DS.subspace("phi", 0, deepcopy=True) nu_0 = df.project(model.coeffs["nu"], V_nu) T_12 = df.project(model.coeffs["nu"] * v.sub(0).dx(1), V_nu) #p_ref = df.project(p_h, df.FunctionSpace(mesh, W.sub(1).ufl_element())) # Save results make_cut = postprocessor._make_cut rs = dict(level=level, r_dens=c[r"r_dens"], r_visc=c[r"r_visc"], nu_interp=nu_interp) rs[r"$v_1$"] = make_cut(v.sub(0)) rs[r"$p$"] = make_cut(p) rs[r"$\phi$"] = make_cut(phi) rs[r"$D_{12}$"] = make_cut(D_12) rs[r"$T_{12}$"] = make_cut(T_12) rs[r"$\nu$"] = make_cut(nu_0) print(label, level) # Send to posprocessor comm = mesh.mpi_comm() rank = df.MPI.rank(comm) postprocessor.add_result(rank, rs) # Save results into a binary file filename = "results_{}.pickle".format(label) postprocessor.save_results(filename) # Flush plots as we now have data for all level values postprocessor.flush_plots() # Cleanup df.set_log_level(df.INFO) gc.collect()
def write_file(f, u, label, t): df.set_log_level(40) f.write_checkpoint(u, label, t) df.set_log_level(30)
# mshr is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # 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 mshr. If not, see <http://www.gnu.org/licenses/>. # import dolfin import pygmsh # from mshr import Sphere, Cylinder, CSGCGALDomain3D, generate_mesh # dolfin.set_log_level(dolfin.TRACE) dolfin.set_log_active(True) dolfin.set_log_level(4) # Define 3D geometry # sphere = Sphere(dolfin.Point(0, 0, 0), 0.5) # cone = Cylinder(dolfin.Point(0, 0, 0), dolfin.Point(0, 0, -1), .35, .1) # geometry = cone + sphere geom = pygmsh.opencascade.Geometry(characteristic_length_min=0.1, characteristic_length_max=0.1) sphere_a = geom.add_ball([0., 0., 0.], 0.5) cone = geom.add_cylinder([0., 0., 0.], [0., 0., 1.], .1) figure = geom.boolean_union([sphere_a, cone]) mesh = pygmsh.generate_mesh(geom, verbose=True) # Geometry surfaces can be saved to off files
else: dx = Measure("dx", domain=mesh) # Optimization options for the form compiler parameters["krylov_solver"]["maximum_iterations"] = 300 parameters["krylov_solver"]["relative_tolerance"] = 1.0e-10 parameters["krylov_solver"]["absolute_tolerance"] = 1.0e-10 # ================= MPI PARAMETERS ================= # # MPI Parameters comm = MPI.comm_world rank = MPI.rank(comm) # Set log level for parallel set_log_level(LogLevel.ERROR) if rank == 0: set_log_level(LogLevel.PROGRESS) ff = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1) Dirichlet(Lx, Ly, Lpml).mark(ff, 1) # Create function spaces VE = VectorElement("CG", mesh.ufl_cell(), 1, dim=2) TE = TensorElement("DG", mesh.ufl_cell(), 0, shape=(2, 2), symmetry=True) W = FunctionSpace(mesh, MixedElement([VE, TE])) F = FunctionSpace(mesh, "CG", 2) V = W.sub(0).collapse() M = W.sub(1).collapse()
import dolfin as df import numpy as np import scipy as sp import scipy.sparse as sps # self defined modules import sys sys.path.append( "../" ) from util.dolfin_gadget import get_dof_coords,vec2fun from util.sparse_geeklet import * from util.Eigen import * # set to warn only once for the same warnings import warnings warnings.simplefilter('once') df.set_log_level(df.ERROR) def _get_sqrtm(A,m_name='K',output_petsc=True,SAVE=True): """ Get the root of matrix A. """ if output_petsc and df.has_petsc4py(): from petsc4py import PETSc rtA_f=os.path.join(os.getcwd(),'rt'+m_name+'_petsc.dat') try: viewer = PETSc.Viewer().createBinary(rtA_f, 'r') rtA_petsc=df.PETScMatrix(PETSc.Mat().load(viewer)) print('Read the root of '+{'K':'kernel','C':'covariance'}[m_name]+' successfully!') except: import scipy.linalg as spla rtA_sps = sps.csr_matrix(spla.sqrtm(A.array()).real)
import math # from dolfin import * from dolfin import ERROR, set_log_level, exp, near, File, Expression, tanh, \ Constant, SubDomain, VectorFunctionSpace, FunctionSpace, \ DirichletBC, Function, split, \ MixedFunctionSpace, TestFunctions, inner, sym, grad, div, dx, \ RectangleMesh, Point, solve, project, assign, interpolate ''' This version of the code runs a swarm of simulations of various viscosities and temperatures per viscosity. Since 5-29, it also includes an adiabatic temperature variance at the LAB. ''' set_log_level(ERROR) rho_0 = 3300. rhomelt = 2900. darcy = 1e-13 # k over (mu*phi) in darcy alpha = 2.5e-5 g = 9.81 # not actually used.. (in cian's notes he is using the non dimensional # kappa in the equations, which here i have defined as 1 (as # kappa/kappa_0) so i think i can get away with this) kappa = 1.E-6 b = 12.7 cc = math.log(128) #Ep = 0.014057 theta = 0.5
import sys sys.path.append('../') import matplotlib matplotlib.use('macosx') import time import numpy as np import matplotlib.pyplot as plt import dolfin as dl dl.set_log_level(40) from utils import nb # Tensorflow related imports from tensorflow.keras.optimizers import Adam # Scipy imports from scipy.optimize import minimize, Bounds # ROMML imports from fom.forward_solve_exp import Fin from fom.thermal_fin import get_space from rom.averaged_affine_ROM import AffineROMFin from deep_learning.dl_model import load_parametric_model_avg, load_bn_model from gaussian_field import make_cov_chol randobs = True resolution = 40 V = get_space(resolution) chol = make_cov_chol(V, length=1.2)
# import numbers import types import pytest from numpy import allclose as float_array_equal, array_equal as integer_array_equal, bmat, hstack as bvec, sort, unique, vstack from dolfin import assemble, Constant, DOLFIN_EPS, dx, Expression, FiniteElement, Function, FunctionSpace, has_pybind11, inner, MixedElement, project as dolfin_project, set_log_level, SubDomain, TensorElement, TensorFunctionSpace, VectorElement, VectorFunctionSpace if has_pybind11(): from dolfin.cpp.la import GenericMatrix, GenericVector from dolfin.cpp.log import LogLevel ERROR = LogLevel.ERROR PROGRESS = LogLevel.PROGRESS else: from dolfin import ERROR, GenericMatrix, GenericVector, PROGRESS from multiphenics import assign, block_assemble, block_assign, BlockDirichletBC, BlockFunction, block_split, BlockTestFunction, BlockTrialFunction, DirichletBC set_log_level(PROGRESS) # ================ PYTEST HELPER ================ # def pytest_mark_slow_for_cartesian_product(generator_1, generator_2): for i in generator_1(): for j in generator_2(): slow = False if hasattr(i, "mark"): assert i.name == "slow" assert len(i.args) is 1 i = i.args[0] slow = True if hasattr(j, "mark"): assert j.name == "slow" assert len(j.args) is 1 j = j.args[0]
def read_file(f, u, label, i): df.set_log_level(40) f.read_checkpoint(u, label, i) df.set_log_level(30) return u
# the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # mshr is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with mshr. If not, see <http://www.gnu.org/licenses/>. from __future__ import print_function import dolfin from mshr import * dolfin.set_log_level(dolfin.TRACE) # Define 2D geometry domain = Rectangle(dolfin.Point(0., 0.), dolfin.Point(5., 5.)) \ - Rectangle(dolfin.Point(2., 1.25), dolfin.Point(3., 1.75)) \ - Circle(dolfin.Point(1, 4), .25) \ - Circle(dolfin.Point(4, 4), .25) domain.set_subdomain(1, Rectangle(dolfin.Point(1., 1.), dolfin.Point(4., 3.))) domain.set_subdomain(2, Rectangle(dolfin.Point(2., 2.), dolfin.Point(3., 4.))) dolfin.info("\nVerbose output of 2D geometry:") dolfin.info(domain, True) # Generate and plot mesh mesh2d = generate_mesh(domain, 45) print(mesh2d)
from time import clock from os import makedirs import math # from dolfin import * from dolfin import ERROR, set_log_level, exp, near, File, Expression, tanh, \ Constant, SubDomain, VectorFunctionSpace, FunctionSpace, \ DirichletBC, Function, split, \ MixedFunctionSpace, TestFunctions, inner, sym, grad, div, dx, \ RectangleMesh, Point, solve, project, assign, interpolate ''' This version of the code runs a swarm of simulations of various viscosities and temperatures per viscosity. Since 5-29, it also includes an adiabatic temperature variance at the LAB. ''' set_log_level(ERROR) rho_0 = 3300. rhomelt = 2900. darcy = 1e-13 # k over (mu*phi) in darcy alpha = 2.5e-5 g = 9.81 # not actually used.. (in cian's notes he is using the non dimensional # kappa in the equations, which here i have defined as 1 (as # kappa/kappa_0) so i think i can get away with this) kappa = 1.E-6 b = 12.7 cc = math.log(128) #Ep = 0.014057 theta = 0.5