def run_simulation(): L = 3e-8 W = 1e-8 H = 1e-8 mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(L, W, H), 10, 4, 4) Ms = 0.86e6 # A/m A = 1.3e-11 # J/m sim = Sim(mesh, Ms) sim.set_m(("2*x[0]/L - 1", "2*x[1]/W - 1", "1"), L=3e-8, H=1e-8, W=1e-8) sim.alpha = 0.1 sim.add(Zeeman((Ms / 2, 0, 0))) sim.add(Exchange(A)) t = 0 dt = 1e-11 tmax = 1e-9 # s fh = open(os.path.join(MODULE_DIR, "averages.txt"), "w") while t <= tmax: mx, my, mz = sim.m_average fh.write(str(t) + " " + str(mx) + " " + str(my) + " " + str(mz) + "\n") t += dt sim.run_until(t) fh.close()
def test_cosine_solution_robin_boundary_conditions(self): dt = 0.05 t = 0 final_time = 1 nx, ny = 31, 31 degree = 2 kappa = dla.Constant(3) mesh = dla.RectangleMesh(dl.Point(0, 0), dl.Point(1, 1), nx, ny) function_space = dl.FunctionSpace(mesh, "Lagrange", degree) # bc : kappa * grad u.dot(n)+alpha*u=beta alpha = 1 from functools import partial expression = partial(get_gradu_dot_n, kappa, alpha, mesh, degree) boundary_conditions = get_robin_boundary_conditions_from_expression( expression, dla.Constant(alpha)) sol = run_model(function_space, kappa, get_forcing(kappa, mesh, degree), get_exact_solution(mesh, degree), dt, final_time, boundary_conditions=boundary_conditions, second_order_timestepping=True, exact_sol=None) exact_sol = get_exact_solution(mesh, degree) exact_sol.t = final_time error = dl.errornorm(exact_sol, sol, mesh=mesh) print('Error', error) assert error <= 1e-4
def setUp(self): np.random.seed(1) #self.dim = np.random.randint(1, high=5) self.dim = 1 self.means = np.random.uniform(-10, high=10., size=self.dim) self.chol = np.tril( np.random.uniform(1, high=10, size=(self.dim, self.dim))) self.cov = np.dot(self.chol, self.chol.T) self.precision = np.linalg.inv(self.cov) mesh = dl.RectangleMesh(dl.mpi_comm_world(), dl.Point(0.0, 0.0), dl.Point(3, 2), 6, 4) if self.dim > 1: self.Rn = dl.VectorFunctionSpace(mesh, "R", 0, dim=self.dim) else: self.Rn = dl.FunctionSpace(mesh, "R", 0) self.test_prior = GaussianRealPrior(self.Rn, self.cov) m = dl.Function(self.Rn) m.vector().zero() m.vector().set_local(self.means) self.test_prior.mean.axpy(1., m.vector())
def test_dirichlet_boundary(self): frequency=50 omega = 2.*np.pi*frequency c1,c2 = [343.4,6320] gamma=8.4e-4 kappa = omega/c1 Nx, Ny = [21,21] Lx,Ly=[1,1] # create function space mesh = dl.RectangleMesh(dl.Point(0., 0.), dl.Point(Lx, Ly), Nx, Ny) degree=1 P1=dl.FiniteElement('Lagrange',mesh.ufl_cell(),degree) element=dl.MixedElement([P1,P1]) function_space=dl.FunctionSpace(mesh,element) boundary_conditions=None kappa=dl.Constant(kappa) # do not pass element=function_space.ufl_element() # as want forcing to be a scalar pass degree instead forcing=[ Forcing(kappa,'real',degree=function_space.ufl_element().degree()), Forcing(kappa,'imag',degree=function_space.ufl_element().degree())] p=run_model(kappa,forcing,function_space,boundary_conditions) error = dl.errornorm( ExactSolution(kappa,element=function_space.ufl_element()),p) print('Error',error) assert error<=3e-2
def test_quadratic_solution(self): dt = 0.01 t = 0 final_time = 2 nx, ny = 2, 2 degree = 2 alpha, beta = 3, 1.2 kappa = dla.Constant(1) mesh = dla.RectangleMesh(dl.Point(0, 0), dl.Point(1, 1), nx, ny) function_space = dl.FunctionSpace(mesh, "Lagrange", degree) boundary_conditions = get_dirichlet_boundary_conditions_from_expression( get_quadratic_exact_solution(alpha, beta, mesh, degree), 0, 1, 0, 1) sol = run_model(function_space, kappa, get_quadratic_solution_forcing(alpha, beta, mesh, degree), get_quadratic_exact_solution(alpha, beta, mesh, degree), dt, final_time, boundary_conditions=boundary_conditions) # , # exact_sol=get_quadratic_exact_solution(alpha,beta,mesh,degree)) exact_sol = get_quadratic_exact_solution(alpha, beta, mesh, degree) exact_sol.t = final_time error = dl.errornorm(exact_sol, sol, mesh=mesh) print('Error', error) assert error <= 3e-14
def test_2D_particle_source_region(self): """Set up a two-dimensional source region and display it. Incomplete """ fncName = '(' + __file__ + ') ' + sys._getframe().f_code.co_name + '():\n' print('\ntest: ', fncName, '(' + __file__ + ')') # from UserMesh_y_Fields_FE_XYZ_Module import UserMeshInput_C umi2D = UserMeshInput_C() # TODO: Change these to TUPLES instead of Points? (to avoid df_m at toplevel) umi2D.pmin = df_m.Point(-10.0, -10.0) umi2D.pmax = df_m.Point(10.0, 10.0) umi2D.cells_on_side = (4, 2) ## Boundary conditions for the particles on this mesh # Create a 2D particle mesh # pmesh2D = UserMesh_C(umi2D, computeDictionaries=True, computeTree=True, plotFlag=plotFlag) return
def mesh(Lx=1., Ly=1., Lz=2., grid_spacing=1./16, **namespace): m = df.BoxMesh(df.Point(0., 0., 0.), df.Point(Lx, Ly, Lz), int(Lx/(2*grid_spacing)), int(Ly/(2*grid_spacing)), int(Lz/(2*grid_spacing))) m = df.refine(m) return m
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 test_quadratic_diffusion_dirichlet_boundary_conditions(self): """ du/dt = div((1+u**2)*grad(u))+f in the unit square. u = u_D on the boundary. """ nx, ny, degree = 21, 21, 2 mesh = dla.RectangleMesh(dl.Point(0, 0), dl.Point(1, 1), nx, ny) function_space = dl.FunctionSpace(mesh, "Lagrange", degree) bndry_obj = get_2d_unit_square_mesh_boundaries() boundary_conditions = get_dirichlet_boundary_conditions_from_expression( get_quadratic_diffusion_exact_solution(mesh, degree), 0, 1, 0, 1) forcing = get_diffusion_forcing( quadratic_diffusion, get_quadratic_diffusion_exact_solution_sympy, mesh, degree) options = {'time_step': 0.05, 'final_time': 1, 'forcing': forcing, 'boundary_conditions': boundary_conditions, 'second_order_timestepping': True, 'init_condition': get_quadratic_diffusion_exact_solution( mesh, degree), 'nonlinear_diffusion': quadratic_diffusion} sol = run_model(function_space, **options) exact_sol = get_quadratic_diffusion_exact_solution(mesh, degree) exact_sol.t = options['final_time'] error = dl.errornorm(exact_sol, sol, mesh=mesh) print('Abs. Error', error) assert error <= 8e-5
def test_dmi_pbc2d_1D(plot=False): def m_init_fun(p): if p[0] < 10: return [0.5, 0, 1] else: return [-0.5, 0, -1] mesh = df.RectangleMesh(df.Point(0, 0), df.Point(20, 2), 10, 1) m_init = vector_valued_function(m_init_fun, mesh) Ms = 8.6e5 sim = Simulation(mesh, Ms, pbc='2d', unit_length=1e-9) sim.set_m(m_init_fun) A = 1.3e-11 D = 5e-3 sim.add(Exchange(A)) sim.add(DMI(D)) sim.relax(stopping_dmdt=0.0001) if plot: sim.m_field.plot_with_dolfin() mx = [sim.m_field.probe([x + 0.5, 1])[0] for x in range(20)] assert np.max(np.abs(mx)) < 1e-6
def test_hysteresis(tmpdir): os.chdir(str(tmpdir)) sim = barmini() mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(1, 1, 1), 1, 1, 1) H_ext_list = [(1, 0, 0), (2, 0, 0), (3, 0, 0), (4, 0, 0)] N = len(H_ext_list) # Run a relaxation and save a vtk snapshot at the end of each stage; # this should result in three .vtu files (one for each stage). sim1 = sim_with(mesh, Ms=1e6, m_init=(0.8, 0.2, 0), alpha=1.0, unit_length=1e-9, A=None, demag_solver=None) sim1.schedule('save_vtk', at_end=True, filename='barmini_hysteresis.pvd') res1 = sim1.hysteresis(H_ext_list=H_ext_list) assert (len(glob('barmini_hysteresis*.vtu')) == N) assert (res1 == None) # Run a relaxation with a non-trivial `fun` argument and check # that we get a list of return values. sim2 = sim_with(mesh, Ms=1e6, m_init=(0.8, 0.2, 0), alpha=1.0, unit_length=1e-9, A=None, demag_solver=None) res2 = sim2.hysteresis(H_ext_list=H_ext_list, fun=lambda sim: sim.m_average[0]) assert (len(res2) == N)
def macrospin_box(Ms=0.86e6, m_init=(1, 0, 0), H_ext=(0, 0, 1e6), alpha=0.1, name='macrospin'): """ Cubic mesh of length 1 nm along each edge, with eight vertices located in the corners of the cube. No anisotropy, exchange coupling or demag is present so that magnetic moments at the vertices behave identical under the influence of the external field. Default values for the arguments: Ms = 0.86e6 (saturation magnetisation in A/m) m_init = (1, 0, 0) (initial magnetisation pointing along the x-axis) H_ext = (0, 0, 1e6) (external field in A/m) alpha = 0.1 (Gilbert damping coefficient) """ mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(1, 1, 1), 1, 1, 1) sim = sim_with(mesh, Ms=0.86e6, alpha=alpha, unit_length=1e-9, A=None, H_ext=H_ext, m_init=(1, 0, 0), name=name) return sim
def test_crossprod(): """ Compute the cross product of two functions f and g numerically using `helpers.crossprod` and compare with the analytical expression. """ xmin = ymin = zmin = -2 xmax = ymax = zmax = 3 nx = ny = nz = 10 mesh = df.BoxMesh(df.Point(xmin, ymin, zmin), df.Point(xmax, ymax, zmax), nx, ny, nz) V = df.VectorFunctionSpace(mesh, 'CG', 1, dim=3) u = df.interpolate(df.Expression(['x[0]', 'x[1]', '0'], degree=1), V) v = df.interpolate(df.Expression(['-x[1]', 'x[0]', 'x[2]'], degree=1), V) w = df.interpolate( df.Expression(['x[1]*x[2]', '-x[0]*x[2]', 'x[0]*x[0]+x[1]*x[1]'], degree=1), V) a = u.vector().array() b = v.vector().array() c = w.vector().array() axb = crossprod(a, b) assert (np.allclose(axb, c))
def test_energy_density_function(): """ Compute the Zeeman energy density over the entire mesh, integrate it, and compare it to the expected result. """ mesh = df.RectangleMesh(df.Point(-50, -50), df.Point(50, 50), 10, 10) unit_length = 1e-9 H = 1e6 # Create simulation object. sim = finmag.Simulation(mesh, 1e5, unit_length=unit_length) # Set uniform magnetisation. def m_ferromagnetic(pos): return np.array([0., 0., 1.]) sim.set_m(m_ferromagnetic) # Assign zeeman object to simulation sim.add(Zeeman(H * np.array([0., 0., 1.]))) # Get energy density function edf = sim.get_interaction('Zeeman').energy_density_function() # Integrate it over the mesh and compare to expected result. total_energy = df.assemble(edf * df.dx) * unit_length expected_energy = -mu0 * H assert (total_energy + expected_energy) < 1e-6
def __init__(self, Cg, m0, B0, R_E, c_squared): self.Cg = Cg self.m0 = m0 self.B0 = B0 self.R_E = R_E self.c_squared = c_squared self.nv = 40 self.nk = 45 # NB: keep odd to avoid blowups with y = 0! self.nl = 8 self.lmin = 1.1 self.lmax = 7.0 self.logvmin = np.log(1e11) self.logvmax = np.log(1e17) # recall: k{hat}_min => theta_max and vice versa! Y/y = 33 => alpha ~= 4 degr. self.khatmax = (33. * R_E * (B0 / self.lmin)**0.5)**0.2 self.khatmin = -self.khatmax self.vk_mesh = d.RectangleMesh( d.Point(self.logvmin, self.khatmin), d.Point(self.logvmax, self.khatmax), self.nv, self.nk ) self.l_mesh = d.IntervalMesh(self.nl, self.lmin, self.lmax) self.l_boundary = OneDWallExpression(degree=0).configure(0., self.lmax)
def test_constant_diffusion_dirichlet_boundary_conditions(self): kappa = 3 nx, ny, degree = 31, 31, 2 mesh = dla.RectangleMesh(dl.Point(0, 0), dl.Point(1, 1), nx, ny) function_space = dl.FunctionSpace(mesh, "Lagrange", degree) def constant_diffusion(u): return dla.Constant(kappa) boundary_conditions = get_dirichlet_boundary_conditions_from_expression( get_advec_exact_solution(mesh, degree), 0, 1, 0, 1) nlsparam = dict() options = {'time_step': 0.05, 'final_time': 1, 'forcing': get_advec_forcing(kappa, mesh, degree), 'boundary_conditions': boundary_conditions, 'second_order_timestepping': True, 'init_condition': get_advec_exact_solution(mesh, degree), 'nlsparam': nlsparam, 'nonlinear_diffusion': constant_diffusion} sol = run_model(function_space, **options) exact_sol = get_advec_exact_solution(mesh, degree) exact_sol.t = options['final_time'] error = dl.errornorm(exact_sol, sol, mesh=mesh) print('Abs. Error', error) assert error <= 1e-4
def three_dimensional_problem(): x_max = 100e-9 y_max = z_max = 1e-9 x_n = 20 y_n = z_n = 1 dolfin_mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(x_max, y_max, z_max), x_n, y_n, z_n) print dolfin_mesh.num_vertices() oommf_mesh = mesh.Mesh((x_n, y_n, z_n), size=(x_max, y_max, z_max)) def m_gen(rs): xs = rs[0] return np.array([ xs / x_max, np.sqrt(1 - (0.9 * xs / x_max)**2 - 0.01), 0.1 * np.ones(len(xs)) ]) from finmag.util.oommf.comparison import compare_anisotropy return compare_anisotropy(m_gen, Ms, K1, (0, 0, 1), dolfin_mesh, oommf_mesh, dims=3, name="3D")
def test_exchange_energy_analytical_2(): """ Compare one Exchange energy with the corresponding analytical result. """ REL_TOLERANCE = 5e-5 lx = 6 ly = 3 lz = 2 nx = 300 ny = nz = 1 mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(lx, ly, lz), nx, ny, nz) unit_length = 1e-9 functionspace = df.VectorFunctionSpace(mesh, "CG", 1, 3) Ms = Ms = Field(df.FunctionSpace(mesh, 'DG', 0), 8e5) A = 13e-12 m = Field(functionspace) m.set( df.Expression(['0', 'sin(2*pi*x[0]/l_x)', 'cos(2*pi*x[0]/l_x)'], l_x=lx, degree=1)) exch = Exchange(A) exch.setup(m, Ms, unit_length=unit_length) E_expected = A * 4 * pi ** 2 * \ (ly * unit_length) * (lz * unit_length) / (lx * unit_length) E = exch.compute_energy() print "expected energy: {}".format(E) print "computed energy: {}".format(E_expected) assert abs((E - E_expected) / E_expected) < REL_TOLERANCE
def demo1(): # create example simulation import finmag import dolfin as df xmin, ymin, zmin = 0, 0, 0 # one corner of cuboid xmax, ymax, zmax = 6, 6, 11 # other corner of cuboid nx, ny, nz = 3, 3, 6 # number of subdivisions (use ~2nm edgelength) mesh = df.BoxMesh(df.Point(xmin, ymin, zmin), df.Point(xmax, ymax, zmax), nx, ny, nz) # standard Py parameters sim = finmag.sim_with(mesh, Ms=0.86e6, alpha=0.5, unit_length=1e-9, A=13e-12, m_init=(1, 0, 1)) filename = 'data.txt' ndt = Tablewriter(filename, sim, override=True) times = np.linspace(0, 3.0e-11, 6 + 1) for i, time in enumerate(times): print("In iteration {}, computing up to time {}".format(i, time)) sim.run_until(time) ndt.save() # now open file for reading f = Tablereader(filename) print f.timesteps() print f['m_x']
def create_simple_mesh(Rint, Rout, resolution): # Create circles as Circle(Center, Radius) outer_circle = mshr.Circle(df.Point(0, 0), Rout) inner_circle = mshr.Circle(df.Point(0, 0), Rint) domain = outer_circle - inner_circle mesh = mshr.generate_mesh(domain, resolution) return mesh
def test_current_time(): size = 20e-9 simplices = 4 mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(size, size, size), simplices, simplices, simplices) Ms = 860e3 A = 13.0e-12 sim = Sim(mesh, Ms) sim.set_m((1, 0, 0)) sim.add(Exchange(A)) sim.add(Demag()) t = 0.0 t_max = 1e-10 dt = 1e-12 while t <= t_max: t += dt sim.run_until(t) # cur_t is equal to whatever time the integrator decided to probe last assert not sim.integrator.cur_t == 0.0 # t is equal to our current simulation time assert abs(sim.t - t) < epsilon
def test_mat_without_dictionnary(): """FenicsPart instance initialized with only one instance of Material""" L_x, L_y = 1, 1 mesh = fe.RectangleMesh(fe.Point(0.0, 0.0), fe.Point(L_x, L_y), 10, 10) dimensions = np.array(((L_x, 0.0), (0.0, L_y))) E, nu = 1, 0.3 material = mat.Material(E, nu, "cp") rect_part = part.FenicsPart( mesh, materials=material, subdomains=None, global_dimensions=dimensions, facet_regions=None, ) elem_type = "CG" degree = 2 strain_fspace = fe.FunctionSpace( mesh, fe.VectorElement(elem_type, mesh.ufl_cell(), degree, dim=3), ) strain = fe.project(fe.Expression(("1.0+x[0]*x[0]", "0", "1.0"), degree=2), strain_fspace) stress = mat.sigma(rect_part.elasticity_tensor, strain) energy = fe.assemble(fe.inner(stress, strain) * fe.dx(rect_part.mesh)) energy_theo = E / (1 + nu) * (1 + 28 / (15 * (1 - nu))) assert energy == approx(energy_theo, rel=1e-13)
def test_robin_boundary(self): frequency=50 omega = 2.*np.pi*frequency c1,c2 = [343.4,6320] gamma=8.4e-4 kappa = omega/c1 alpha=kappa*gamma Nx, Ny = 21,21; Lx, Ly = 1,1 mesh = dl.RectangleMesh(dl.Point(0., 0.), dl.Point(Lx, Ly), Nx, Ny) degree=1 P1=dl.FiniteElement('Lagrange',mesh.ufl_cell(),degree) element=dl.MixedElement([P1,P1]) function_space=dl.FunctionSpace(mesh,element) boundary_conditions=get_robin_bndry_conditions( kappa,alpha,function_space) kappa=dl.Constant(kappa) forcing=[ Forcing(kappa,'real',degree=function_space.ufl_element().degree()), Forcing(kappa,'imag',degree=function_space.ufl_element().degree())] p=run_model(kappa,forcing,function_space,boundary_conditions) error = dl.errornorm( ExactSolution(kappa,element=function_space.ufl_element()),p,) print('Error',error) assert error<=3e-2
def test_2_materials(): """FenicsPart instance initialized with only one instance of Material in the materials dictionnary""" L_x, L_y = 1, 1 mesh = fe.RectangleMesh(fe.Point(-L_x, -L_y), fe.Point(L_x, L_y), 20, 20) dimensions = np.array(((2 * L_x, 0.0), (0.0, 2 * L_y))) subdomains = fe.MeshFunction("size_t", mesh, 2) class Right_part(fe.SubDomain): def inside(self, x, on_boundary): return x[0] >= 0 - fe.DOLFIN_EPS subdomain_right = Right_part() subdomains.set_all(0) subdomain_right.mark(subdomains, 1) E_1, E_2, nu = 1, 3, 0.3 materials = {0: mat.Material(1, 0.3, "cp"), 1: mat.Material(3, 0.3, "cp")} rect_part = part.FenicsPart(mesh, materials, subdomains, dimensions) elem_type = "CG" degree = 2 strain_fspace = fe.FunctionSpace( mesh, fe.VectorElement(elem_type, mesh.ufl_cell(), degree, dim=3), ) strain = fe.project(fe.Expression(("1.0+x[0]*x[0]", "0", "1.0"), degree=2), strain_fspace) stress = mat.sigma(rect_part.elasticity_tensor, strain) energy = fe.assemble(fe.inner(stress, strain) * fe.dx(rect_part.mesh)) energy_theo = 2 * ((E_1 + E_2) / (1 + nu) * (1 + 28 / (15 * (1 - nu)))) assert energy == approx(energy_theo, rel=1e-13)
def test_cosine_solution_dirichlet_boundary_conditions(self): dt = 0.05 t = 0 final_time = 1 nx, ny = 31, 31 degree = 2 kappa = dla.Constant(3) mesh = dla.RectangleMesh(dl.Point(0, 0), dl.Point(1, 1), nx, ny) function_space = dl.FunctionSpace(mesh, "Lagrange", degree) boundary_conditions = get_dirichlet_boundary_conditions_from_expression( get_exact_solution(mesh, degree), 0, 1, 0, 1) sol = run_model(function_space, kappa, get_forcing(kappa, mesh, degree), get_exact_solution(mesh, degree), dt, final_time, boundary_conditions=boundary_conditions, second_order_timestepping=True, exact_sol=None) exact_sol = get_exact_solution(mesh, degree) exact_sol.t = final_time error = dl.errornorm(exact_sol, sol, mesh=mesh) print('Error', error) assert error <= 1e-4
def test_compute_skyrmion_number_2d_pbc(): mesh = df.RectangleMesh(df.Point(0, 0), df.Point(100, 100), 40, 40) Ms = 8.6e5 sim = Simulation(mesh, Ms, pbc='2d', unit_length=1e-9) sim.set_m(init_skx_down) sim.add(Exchange(1.3e-11)) sim.add(DMI(D=4e-3)) sim.add(Zeeman((0, 0, 0.45 * Ms))) sim.do_precession = False sim.relax(stopping_dmdt=1, dt_limit=1e-9) #df.plot(sim.m_field.f) #df.interactive() print np.max(sim.m_field.as_array()) sky_num = compute_skyrmion_number_2d(sim.m_field.f) print 'sky_num = %g' % sky_num assert sky_num < -0.95 and sky_num > -1.0
def FunctionFromSamples(g_samples, grid, offset=0.0): """ Given an array of function samples at the points of a grid, construct a callable dolfin function by interpolation. Inputs: g_samples (np.array): 2D or 3D array of function samples grid (Grid): grid of Points at which function was sampled Returns: Callable dolfin function of 2D or 3D coordinate array p """ n, nd = np.shape(g_samples), len(np.shape(g_samples)) x, y, z = grid.xtics, grid.ytics, grid.ztics vmin, vmax = [x[0], y[0], z[0]], [x[-1], y[-1], z[-1]] pmin, pmax = df.Point(vmin[0:nd]), df.Point(vmax[0:nd]) if nd == 2: mesh = df.RectangleMesh(pmin, pmax, n[0], n[1]) else: mesh = df.BoxMesh(pmin, pmax, n[0], n[1], n[2]) grid_space = df.FunctionSpace(mesh, 'Lagrange', 1) g = df.Function(grid_space) v = g.vector() delta = [t[2] - t[1] if len(t) > 1 else 1.0 for t in [x, y, z]] for i, p in enumerate(grid_space.tabulate_dof_coordinates()): n = [int(round((p[d] - pmin[d]) / delta[d])) for d in range(nd)] v[i] = g_samples[tuple(n)] + offset g.set_allow_extrapolation(True) return g
def bar(name='bar', demag_solver_type=None): """Py bar with dimensions 30x30x100nm, initial field pointing in (1,0,1) direction. Same as example 2 in Nmag manual. This function returns a simulation object that is 'ready to go'. Useful commands to run this for a minute:: times = numpy.linspace(0, 3.0e-11, 6 + 1) for t in times: # Integrate sim.run_until(t) """ xmin, ymin, zmin = 0, 0, 0 # one corner of cuboid xmax, ymax, zmax = 30, 30, 100 # other corner of cuboid # number of subdivisions (use ~2nm edgelength) nx, ny, nz = 15, 15, 50 mesh = df.BoxMesh(df.Point(xmin, ymin, zmin), df.Point(xmax, ymax, zmax), nx, ny, nz) sim = finmag.sim_with(mesh, Ms=0.86e6, alpha=0.5, unit_length=1e-9, A=13e-12, m_init=(1, 0, 1), name=name, demag_solver_type=demag_solver_type) return sim
def extract_mesh_slice(mesh, slice_z): coords = mesh.coordinates() xmin = min(coords[:, 0]) xmax = max(coords[:, 0]) ymin = min(coords[:, 1]) ymax = max(coords[:, 1]) nx = int(1 * (xmax - xmin)) ny = int(1 * (ymax - ymin)) slice_mesh = embed3d(df.RectangleMesh(df.Point(xmin, ymin), df.Point(xmax, ymax), nx, ny), z_embed=slice_z) V = df.FunctionSpace(mesh, 'CG', 1) f = df.Function(V) V_slice = df.FunctionSpace(slice_mesh, 'CG', 1) f_slice = df.Function(V_slice) lg = df.LagrangeInterpolator() def restrict_to_slice_mesh(a): f.vector().set_local(a) lg.interpolate(f_slice, f) return f_slice.vector().array() return slice_mesh, restrict_to_slice_mesh
def test_compare_exchange_for_two_dolfin_meshes(): """ Check that a mesh expressed in nanometers gives the same results as a mesh expressed in meters for the exchange interaction. """ mesh_nm = df.BoxMesh(df.Point(0, 0, 0), df.Point(1, 1, 1), n, n, n) # in nm m_nm, H_nm, E_nm = exchange(mesh_nm, unit_length=1e-9) mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(1e-9, 1e-9, 1e-9), n, n, n) m, H, E = exchange(mesh, unit_length=1) rel_diff_m = np.max(np.abs(m_nm - m)) # norm m = 1 print "Difference of magnetisation is {:.2f}%.".format(100 * rel_diff_m) assert rel_diff_m < REL_TOL rel_diff_E = abs((E_nm - E) / E) print "Relative difference between E_nm = {:.5g} and E_m = {:.5g} is d = {:.2f}%.".format( E_nm, E, 100 * rel_diff_E) assert rel_diff_E < REL_TOL max_diff_H = np.max(np.abs(H_nm - H) / np.max(H)) print "Maximum of relative difference between the two fields is d = {:.2f}%.".format( 100 * max_diff_H) assert np.max(np.abs(H)) > 0 assert max_diff_H < REL_TOL