def macrospin(Ms=0.86e6,
m_init=(1, 0, 0),
H_ext=(0, 0, 1e6),
alpha=0.1,
name='macrospin'):
"""
Minimal mesh with two vertices (1 nm apart). No anisotropy,
exchange coupling or demag is present so that magnetic moments at
the two vertices behave identical under the influence of the
external field. (Ideally, we would only have a single vertex but
Dolfin doesn't support this.)
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.UnitIntervalMesh(1)
sim = Simulation(mesh, Ms=Ms, unit_length=1e-9, name=name)
sim.alpha = alpha
sim.set_m(m_init)
sim.add(Zeeman(H_ext))
return sim
def setUp(self):
self.mesh = mesh = dolfin.UnitIntervalMesh(30)
self.element = element = dolfin.FiniteElement("CG", mesh.ufl_cell(), 3)
self.W = W = dolfin.FunctionSpace(mesh, element)
self.u = dolfin.Function(W, name='u')
self.v = dolfin.TestFunction(W)
self.x = dolfin.SpatialCoordinate(mesh)[0]
def __init__(self,
*,
time: df.Constant,
cell_model: CellModel,
parameters: df.Parameters = None) -> None:
"""Create solver from given cell model and optional parameters."""
# Define carefully chosen dummy mesh
mesh = df.UnitIntervalMesh(1)
_function_space = df.FunctionSpace(mesh, "CG", 1)
indicator_function = df.Function(_function_space)
indicator_function.vector()[:] = 1
extension_modules = import_extension_modules()
from extension_modules import load_module
ode_module = load_module(
"LatticeODESolver",
recompile=parameters["reload_extension_modules"],
verbose=parameters["reload_extension_modules"])
odemap = ode_module.ODEMap()
odemap.add_ode(1, ode_module.SimpleODE())
super().__init__(time=time,
mesh=mesh,
cell_model=cell_model,
parameter_map=odemap,
indicator_function=indicator_function,
parameters=parameters)
def __init__(self, t_end=None, func=None):
Problem_verification.__init__(self, t_end, func)
self.u0_expr = dol.Constant(1)
self.V = dol.FunctionSpace(dol.UnitIntervalMesh(1), 'DG', 0)
# rhs
self.f1 = dol.Expression('pow(t, 2)', t=0, degree=2)
self.f2 = dol.Expression('pow(t, 2)', t=0, degree=2)
Problem_FE.__init__(self)
# CN, higher order
F = (dol.inner(
self.v, self.utrial - self.uold + self.dt * 0.5 *
(self.uold + self.utrial)) * dol.dx -
0.5 * self.dt * dol.inner(self.f1 + self.f2, self.v) * dol.dx)
prob = dol.LinearVariationalProblem(dol.lhs(F), dol.rhs(F), self.unew)
self.solver = dol.LinearVariationalSolver(prob)
# IE, lower order
Flow = (dol.inner(
self.v, self.utrial - self.uold + self.dt * self.utrial) * dol.dx -
self.dt * dol.inner(self.f2, self.v) * dol.dx)
problow = dol.LinearVariationalProblem(dol.lhs(Flow), dol.rhs(Flow),
self.ulow)
self.solver_low = dol.LinearVariationalSolver(problow)
def test_plot_dolfin_function(tmpdir):
os.chdir(str(tmpdir))
interval_mesh = df.UnitIntervalMesh(2)
square_mesh = df.UnitSquareMesh(2, 2)
cube_mesh = df.UnitCubeMesh(2, 2, 2)
S = df.FunctionSpace(cube_mesh, 'CG', 1)
V2 = df.VectorFunctionSpace(square_mesh, 'CG', 1, dim=3)
V3 = df.VectorFunctionSpace(cube_mesh, 'CG', 1, dim=3)
s = df.Function(S)
v2 = df.Function(V2)
v3 = df.Function(V3)
v3.vector()[:] = 1.0
# Wrong function space dimension
with pytest.raises(TypeError):
plot_dolfin_function(s, outfile='buggy.png')
# Plotting a 3D function on a 3D mesh should work
plot_dolfin_function(v3, outfile='plot.png')
assert (os.path.exists('plot.png'))
# Try 2-dimensional mesh as well
plot_dolfin_function(v2, outfile='plot_2d_mesh.png')
assert (os.path.exists('plot_2d_mesh.png'))
def _fenics_vector_spaces(draw, np_data_list, compatible, count, dims):
ret = []
for d, ar in zip(dims, np_data_list):
assume(d > 1)
if d not in _FENICS_spaces:
_FENICS_spaces[d] = FenicsVectorSpace(df.FunctionSpace(df.UnitIntervalMesh(d - 1), 'Lagrange', 1))
ret.append((_FENICS_spaces[d], ar))
return ret
def _test_scipy_advance_time():
mesh = df.UnitIntervalMesh(10)
sim = Simulation(mesh, Ms=1, unit_length=1e-9, integrator_backend="scipy")
sim.set_m((1, 0, 0))
sim.advance_time(1e-12)
sim.advance_time(2e-12)
sim.advance_time(2e-12)
sim.advance_time(2e-12)
def __init__(self, problem_params, dtype_u=fenics_mesh, dtype_f=rhs_fenics_mesh):
"""
Initialization routine
Args:
problem_params (dict): custom parameters for the example
dtype_u: FEniCS mesh data type (will be passed to parent class)
dtype_f: FEniCS mesh data data type with implicit and explicit parts (will be passed to parent class)
"""
# define the Dirichlet boundary
# def Boundary(x, on_boundary):
# return on_boundary
# these parameters will be used later, so assert their existence
essential_keys = ['c_nvars', 't0', 'family', 'order', 'refinements', 'nu']
for key in essential_keys:
if key not in problem_params:
msg = 'need %s to instantiate problem, only got %s' % (key, str(problem_params.keys()))
raise ParameterError(msg)
# set logger level for FFC and dolfin
logging.getLogger('FFC').setLevel(logging.WARNING)
logging.getLogger('UFL').setLevel(logging.WARNING)
# set solver and form parameters
df.parameters["form_compiler"]["optimize"] = True
df.parameters["form_compiler"]["cpp_optimize"] = True
df.parameters['allow_extrapolation'] = True
# set mesh and refinement (for multilevel)
mesh = df.UnitIntervalMesh(problem_params['c_nvars'])
for i in range(problem_params['refinements']):
mesh = df.refine(mesh)
# define function space for future reference
self.V = df.FunctionSpace(mesh, problem_params['family'], problem_params['order'])
tmp = df.Function(self.V)
print('DoFs on this level:', len(tmp.vector()[:]))
# invoke super init, passing number of dofs, dtype_u and dtype_f
super(fenics_heat, self).__init__(self.V, dtype_u, dtype_f, problem_params)
# Stiffness term (Laplace)
u = df.TrialFunction(self.V)
v = df.TestFunction(self.V)
a_K = -1.0 * df.inner(df.nabla_grad(u), self.params.nu * df.nabla_grad(v)) * df.dx
# Mass term
a_M = u * v * df.dx
self.M = df.assemble(a_M)
self.K = df.assemble(a_K)
# set forcing term as expression
self.g = df.Expression('-cos(a*x[0]) * (sin(t) - b*a*a*cos(t))', a=np.pi, b=self.params.nu, t=self.params.t0,
degree=self.params.order)
def get_mesh(dimension: int, N: int) -> df.Mesh:
"""Create the mesh [0, 1]^d cm."""
if dimension == 1:
mesh = df.UnitIntervalMesh(N)
elif dimension == 2:
mesh = df.UnitSquareMesh(N, N) # 1cm time 1cm
elif dimension == 3:
mesh = df.UnitCubeMesh(N, N, N) # 1cm time 1cm
return mesh
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 test_cyclic_refs_in_simulation_object_barmini():
import finmag
import dolfin as df
mesh = df.UnitIntervalMesh(1)
s = finmag.example.barmini()
s.run_until(1e-12)
refcount = s.shutdown()
# The number 4 is emperical. If it increases, we
# have introduced an extra cyclic reference.
assert refcount <= 4
def condM(n, precond=lambda M: np.eye(M.shape[0])):
mesh = df.UnitIntervalMesh(n)
V = df.FunctionSpace(mesh, 'CG', 1)
u, v = df.TrialFunction(V), df.TestFunction(V)
M = df.assemble(df.inner(u, v)*df.dx).array()
B = precond(M)
eigw = eigvalsh(M, B)
lmin, lmax = np.sort(np.abs(eigw))[[0, -1]]
return lmin, lmax, lmax/lmin
def test_cyclic_refs_in_simulation_object_basic():
import finmag
import dolfin as df
mesh = df.UnitIntervalMesh(1)
s = finmag.Simulation(mesh, Ms=1, unit_length=1e-9, name='simple')
refcount = s.shutdown()
# The number 4 is emperical. If it increases, we
# have introduced an extra cyclic reference.
# Update: the cythonised code seems to have only 3 references at his point. Updated
# to smaller than 4 to allow binary build tests to pass.
assert refcount <= 4
def setup():
mesh = df.UnitIntervalMesh(3)
V = df.FunctionSpace(mesh, "CG", 1)
alpha = df.Function(V)
alpha.assign(df.Constant(1))
W = df.VectorFunctionSpace(mesh, "CG", 1, dim=3)
m = df.Function(W)
m.assign(df.Constant((0.6, 0.8, 0)))
H = df.Function(W)
H.assign(df.Constant((1, 2, 3)))
dmdt = df.Function(W)
return mesh, V, alpha, W, m, H, dmdt
def get_arguments(dim=2, th=False, nx=2):
if dim == 1:
mesh = dolfin.UnitIntervalMesh(nx)
elif dim == 2:
mesh = dolfin.UnitSquareMesh(nx, nx)
elif dim == 3:
mesh = dolfin.UnitCubeMesh(nx, nx, nx)
P1 = dolfin.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
P2 = dolfin.FiniteElement("Lagrange", mesh.ufl_cell(), 2)
args = [mesh, P1, P1, P2, P1]
if th:
args.append(P1)
return tuple(args)
def __init__(self, t_end = None, func = None, para_stiff = None, adjoint = False):
Problem_Basic.__init__(self, t_end = t_end, func = func, para_stiff = para_stiff)
self.k = dol.Constant(self.k)
self.u0_expr = dol.Constant(self.u0) # initial value
mesh = dol.UnitIntervalMesh(1)
R_elem = dol.FiniteElement("R", mesh.ufl_cell(), 0)
V_elem = dol.MixedElement([R_elem, R_elem])
self.V = dol.FunctionSpace(mesh, V_elem)
if adjoint:
self.z0_expr = dol.Constant(np.array([0., 0.])) # initial value adj
Problem_FE.__init__(self, adjoint)
(self.v1 , self.v2) = dol.split(self.v)
(self.u1trial, self.u2trial) = dol.split(self.utrial)
(self.u1old , self.u2old) = dol.split(self.uold)
(self.u1low , self.u2low) = dol.split(self.ulow)
## Crank nicolson weak formulation
F = (dol.inner(self.v1, self.u1trial - self.u1old + self.dt * (0.5 * (self.u1old + self.u1trial) - 0.5 * (self.u2old + self.u2trial)))*dol.dx
+ dol.inner(self.v2, self.u2trial - self.u2old - self.k * self.dt * 0.5 * (self.u2old + self.u2trial))*dol.dx)
prob = dol.LinearVariationalProblem(dol.lhs(F), dol.rhs(F), self.unew)
self.solver = dol.LinearVariationalSolver(prob)
## Implicit Euler weak formulation for error estimation
Flow = (dol.inner(self.v1, self.u1trial - self.u1old + self.dt * (self.u1trial - self.u2trial))*dol.dx
+ dol.inner(self.v2, self.u2trial - self.u2old - self.k * self.dt * self.u2trial)*dol.dx)
problow = dol.LinearVariationalProblem(dol.lhs(Flow), dol.rhs(Flow), self.ulow)
self.solver_low = dol.LinearVariationalSolver(problow)
if adjoint:
(self.z1old , self.z2old) = dol.split(self.zold)
(self.z1trial, self.z2trial) = dol.split(self.ztrial)
if self.func not in [1, 2]:
raise ValueError('DWR not (yet) implemented for this functional')
adj_src = dol.Function(self.V)
if self.func == 1: adj_src.interpolate(dol.Constant((1, 0)))
elif self.func == 2: adj_src.interpolate(dol.Constant((0, 1)))
src1, src2 = dol.split(adj_src)
Fadj = (dol.inner(self.z1trial - self.z1old + 0.5 * self.dt * (-self.z1trial - self.z1old + 2*src1), self.v1)*dol.dx +
dol.inner(self.z2trial - self.z2old + 0.5 * self.dt * ( self.z1trial + self.z1old + self.k*(self.z2trial + self.z2old) + 2*src2), self.v2)*dol.dx)
prob_adj = dol.LinearVariationalProblem(dol.lhs(Fadj), dol.rhs(Fadj), self.znew)
self.solver_adj = dol.LinearVariationalSolver(prob_adj)
def system0(n):
import dolfin as df
mesh = df.UnitIntervalMesh(n)
V = df.FunctionSpace(mesh, 'CG', 1)
u = df.TrialFunction(V)
v = df.TestFunction(V)
bc = df.DirichletBC(V, df.Constant(0), 'on_boundary')
a = df.inner(df.grad(u), df.grad(v)) * df.dx
m = df.inner(u, v) * df.dx
L = df.inner(df.Constant(0), v) * df.dx
A, _ = df.assemble_system(a, L, bc)
M, _ = df.assemble_system(m, L, bc)
return A, M
def generate_Mesh(shape):
ndim = len(shape)
Nd = tuple(shape)
if ndim == 1:
mesh = dl.UnitIntervalMesh(shape[0])
elif ndim == 2:
mesh = dl.UnitSquareMesh.create(shape[0], shape[1],
dl.CellType.Type.quadrilateral)
# mesh = dl.UnitSquareMesh(shape[0], shape[1])
elif ndim == 3:
mesh = dl.UnitCubeMesh.create(shape[0], shape[1], shape[2],
dl.CellType.Type.hexahedron)
else:
raise Exception(
"The case of Dimension={0:d} is not inplemented!".format(ndim))
return mesh
def __init__(self,
cell_model: CellModel,
time: df.Constant,
reload_ext_modules: bool = False,
parameters: df.Parameters = None) -> None:
"""Create solver from given cell model and optional parameters."""
# Store model
self.cell_model = cell_model
# Define carefully chosen dummy mesh
mesh = df.UnitIntervalMesh(1)
super().__init__(mesh,
time,
cell_model,
reload_ext_modules=reload_ext_modules,
parameters=parameters)
def buildMesh(self):
#-----------------------------------------------------------------------------------
""" Discretize the domain """
if self.tDim == 1:
self.mesh = df.UnitIntervalMesh(self.meshOpt['nXElem'])
if self.tDim == 2:
self.mesh = df.UnitSquareMesh(self.meshOpt['nXElem'],\
self.meshOpt['nYElem'])
if self.tDim == 3:
self.mesh = df.UnitCubeMesh(self.meshOpt['nXElem'],\
self.meshOpt['nYElem'],\
self.meshOpt['nXElem'])
self._buildMeshCompleted = True
return
def test1D(self):
n = 10
mesh = dl.UnitIntervalMesh(n)
true_sub = dl.CompiledSubDomain("x[0] <= .5")
true_marker = dl.MeshFunction('size_t', mesh, 1, value=0)
true_sub.mark(true_marker, 1)
np_sub = np.ones(n, dtype=np.uint)
np_sub[n // 2:] = 0
h = 1. / n
marker = dl.MeshFunction('size_t', mesh, 1)
numpy2MeshFunction(mesh, [h], np_sub, marker)
assert_allclose(marker.array(),
true_marker.array(),
rtol=1e-7,
atol=1e-9)
def test_1d(self):
prm = c.Parameters(c.Constraint.UNIAXIAL_STRAIN)
mesh = df.UnitIntervalMesh(10)
u_bc = 42.0
problem = c.MechanicsProblem(mesh, prm, law(prm))
bcs = []
bcs.append(df.DirichletBC(problem.Vd, [0], boundary.plane_at(0)))
bcs.append(df.DirichletBC(problem.Vd, [u_bc], boundary.plane_at(1)))
problem.set_bcs(bcs)
u = problem.solve()
xs = np.linspace(0, 1, 5)
for x in xs:
u_fem = u((x))
u_correct = x * u_bc
self.assertAlmostEqual(u_fem, u_correct)
def __init__(self, t_end=None, func=None):
Problem_verification.__init__(self, t_end, func)
self.u0_expr = dol.Constant(1)
self.V = dol.FunctionSpace(dol.UnitIntervalMesh(1), 'DG', 0)
Problem_FE.__init__(self)
# CN, higher order
F = dol.inner(
self.v, self.utrial - self.uold + self.dt * 0.5 *
(self.uold + self.utrial)) * dol.dx
prob = dol.LinearVariationalProblem(dol.lhs(F), dol.rhs(F), self.unew)
self.solver = dol.LinearVariationalSolver(prob)
# IE, lower order
Flow = dol.inner(
self.v, self.utrial - self.uold + self.dt * self.utrial) * dol.dx
problow = dol.LinearVariationalProblem(dol.lhs(Flow), dol.rhs(Flow),
self.ulow)
self.solver_low = dol.LinearVariationalSolver(problow)
def test1D(self):
n = 10
mesh = dl.UnitIntervalMesh(n)
Vh = dl.FunctionSpace(mesh, "CG", 2)
n_np = 2 * n
h = 1. / float(n_np)
f_np = np.linspace(0., 1., n_np + 1)
f_exp = NumpyScalarExpression1D()
f_exp.setData(f_np, h)
f_exp2 = dl.Expression("x[0]", degree=2)
fh_1 = dl.interpolate(f_exp, Vh).vector()
fh_2 = dl.interpolate(f_exp2, Vh).vector()
fh_1.axpy(-1., fh_2)
error = fh_1.norm("l2")
assert_allclose([error], [0.], rtol=1e-7, atol=1e-9)
def __init__(self,
*,
cell_model: CellModel,
time: df.Constant,
parameters: df.Parameters = None) -> None:
"""Create solver from given cell model and optional parameters."""
assert isinstance(cell_model, CellModel), \
"Expecting model to be a CellModel, not %r" % cell_model
assert (isinstance(time, df.Constant)), \
"Expecting time to be a Constant instance, not %r" % time
assert isinstance(parameters, df.Parameters) or parameters is None, \
"Expecting parameters to be a Parameters (or None), not %r" % parameters
# Define carefully chosen dummy mesh
mesh = df.UnitIntervalMesh(1)
super().__init__(mesh=mesh,
time=time,
model=cell_model,
I_s=cell_model.stimulus,
parameters=parameters)
def hyper_simplex(dim, n_refinements=0):
assert isinstance(dim, int)
assert dim <= 2, "This method is only implemented in 1D and 2D."
assert isinstance(n_refinements, int) and n_refinements >= 0
# mesh generation
if dim == 1:
mesh = dlfn.UnitIntervalMesh(n_refinements)
elif dim == 2:
mesh = dlfn.UnitTriangleMesh.create()
# mesh refinement
if dim != 1:
for i in range(n_refinements):
mesh = dlfn.refine(mesh)
# MeshFunction for boundaries ids
facet_marker = dlfn.MeshFunction("size_t", mesh, dim - 1)
facet_marker.set_all(0)
# mark boundaries
BoundaryMarkers = HyperSimplexBoundaryMarkers
if dim == 1:
gamma01 = dlfn.CompiledSubDomain("near(x[0], 0.0) && on_boundary")
gamma02 = dlfn.CompiledSubDomain("near(x[0], 1.0) && on_boundary")
gamma01.mark(facet_marker, BoundaryMarkers.left.value)
gamma02.mark(facet_marker, BoundaryMarkers.right.value)
elif dim == 2:
gamma00 = dlfn.CompiledSubDomain("on_boundary")
gamma01 = dlfn.CompiledSubDomain("near(x[0], 0.0) && on_boundary")
gamma02 = dlfn.CompiledSubDomain("near(x[1], 0.0) && on_boundary")
# first mark the entire boundary with the diagonal id
gamma00.mark(facet_marker, BoundaryMarkers.diagonal.value)
# then mark the other edges with the correct ids
gamma01.mark(facet_marker, BoundaryMarkers.left.value)
gamma02.mark(facet_marker, BoundaryMarkers.bottom.value)
return mesh, facet_marker
def test_uniaxial(self):
prm = c.Parameters(c.Constraint.UNIAXIAL_STRESS)
prm.deg_d = 1
prm.alpha = 0.999
prm.gf = 0.01
k0 = 2.0e-4
prm.ft = k0 * prm.E
law = law_from_prm(prm)
mesh = df.UnitIntervalMesh(1)
problem = c.MechanicsProblem(mesh, prm, law)
bc0 = df.DirichletBC(problem.Vd, [0], boundary.plane_at(0))
bc_expr = df.Expression(["u"], u=0, degree=0)
bc1 = df.DirichletBC(problem.Vd, bc_expr, boundary.plane_at(1))
problem.set_bcs([bc0, bc1])
ld = c.helper.LoadDisplacementCurve(bc1)
# ld.show()
solver = df.NewtonSolver()
solver.parameters["linear_solver"] = "mumps"
solver.parameters["maximum_iterations"] = 10
solver.parameters["error_on_nonconvergence"] = False
u_max = 100 * k0
for u in np.linspace(0, u_max, 101):
bc_expr.u = u
converged = solver.solve(problem, problem.u.vector())
assert converged
problem.update()
ld(u, df.assemble(problem.R))
GF = np.trapz(ld.load, ld.disp)
self.assertAlmostEqual(GF,
0.5 * k0**2 * prm.E + prm.gf,
delta=prm.gf / 100)
def test_embed3d():
# Create a 2D mesh which we want to embed in 3D space
mesh_2d = df.RectangleMesh(df.Point(0, 0), df.Point(20, 10), 10, 5)
coords_2d = mesh_2d.coordinates()
z_embed = 4.2
# Create array containing the expected 3D coordinates
coords_3d_expected = z_embed * np.ones((len(coords_2d), 3))
coords_3d_expected[:, :2] = coords_2d
# Create the embedded 3D mesh
mesh_3d = embed3d(mesh_2d, z_embed)
coords_3d = mesh_3d.coordinates()
# Check that the coordinates coincide
assert (np.allclose(coords_3d, coords_3d_expected))
# Check that we can't embed a 1D or 3D mesh (TODO: we could make these
# work, but currently they are not implemented)
with pytest.raises(NotImplementedError):
embed3d(df.UnitIntervalMesh(4))
with pytest.raises(NotImplementedError):
embed3d(df.UnitCubeMesh(4, 4, 4))
def test_verify_function_space_type():
N = 10
mesh1d = df.UnitIntervalMesh(N)
mesh2d = df.UnitSquareMesh(N, N)
mesh3d = df.UnitCubeMesh(N, N, N)
V1 = df.FunctionSpace(mesh3d, 'DG', 0)
V2 = df.VectorFunctionSpace(mesh1d, 'DG', 0, dim=1)
V3 = df.VectorFunctionSpace(mesh2d, 'CG', 1, dim=3)
# Check that verifying the known function space types works as expected
assert (verify_function_space_type(V1, 'DG', 0, dim=None))
assert (verify_function_space_type(V2, 'DG', 0, dim=1))
assert (verify_function_space_type(V3, 'CG', 1, dim=3))
# Check that the verification function returns 'False' if we pass in a
# non-matching function space type.
# wrong 'dim' (should be None)
assert (not verify_function_space_type(V1, 'DG', 0, dim=1))
# wrong degree
assert (not verify_function_space_type(V1, 'DG', 1, dim=None))
# wrong family
assert (not verify_function_space_type(V1, 'CG', 0, dim=None))
# wrong 'dim' (should be 1)
assert (not verify_function_space_type(V2, 'DG', 0, dim=None))
# wrong 'dim' (should be 1)
assert (not verify_function_space_type(V2, 'DG', 0, dim=42))
assert (not verify_function_space_type(V2, 'DG', 42, dim=1)
) # wrong degree
assert (not verify_function_space_type(V2, 'CG', 0, dim=1)) # wrong family
# wrong dimension
assert (not verify_function_space_type(V3, 'CG', 1, dim=42))
assert (not verify_function_space_type(V3, 'CG', 42, dim=1)
) # wrong degree
assert (not verify_function_space_type(V3, 'DG', 1, dim=3)) # wrong family
def macrospin_interval(Ms=0.86e6,
m_init=(1, 0, 0),
H_ext=(0, 0, 1e6),
alpha=0.1,
name='macrospin'):
"""
1d mesh (= interval) with two vertices which are 1 nm apart.
No anisotropy, exchange coupling or demag is present so that
magnetic moments at the vertices behave identical under the
influence of the external field. The damping constant has the
value alpha=0.1.
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.UnitIntervalMesh()
sim = sim_with(mesh,
Ms=1e6,
m_init=(1, 0, 0),
alpha=alpha,
unit_length=1e-9,
H_ext=H_ext,
A=None,
demag_solver=None,
name=name)
return sim
