def test_exchange_field_supported_methods(fixt):
"""
Check that all supported methods give the same results
as the default method.
"""
A = 1
REL_TOLERANCE = 1e-12
mesh = df.UnitCubeMesh(10, 10, 10)
Ms = Field(df.FunctionSpace(mesh, 'DG', 0), 1)
functionspace = df.VectorFunctionSpace(mesh, "CG", 1, 3)
m = Field(functionspace)
m.set(df.Expression(("0", "sin(x[0])", "cos(x[0])"), degree=1))
exch = Exchange(A)
exch.setup(m, Ms)
H_default = exch.compute_field()
supported_methods = list(Exchange._supported_methods)
# no need to compare default method with itself
supported_methods.remove(exch.method)
# the project method for the exchange is too bad
supported_methods.remove("project")
for method in supported_methods:
exch = Exchange(A, method=method)
exch.setup(m, Ms)
H = exch.compute_field()
print "With method '{}', expecting H =\n{}\n, got H =\n{}.".format(
method,
H_default.reshape((3, -1)).mean(1),
H.reshape((3, -1)).mean(1))
rel_diff = np.abs((H - H_default) / H_default)
assert np.nanmax(rel_diff) < REL_TOLERANCE
def setup_module(module=None):
# define the mesh
x_max = 20e-9 # m
simplexes = 10
mesh = IntervalMesh(simplexes, 0, x_max)
def m_gen(coords):
x = coords[0]
mx = min(1.0, 2.0 * x / x_max - 1.0)
my = np.sqrt(1.0 - mx**2)
mz = 0.0
return np.array([mx, my, mz])
Ms = 0.86e6
A = 1.3e-11
global sim
sim = Sim(mesh, Ms)
sim.alpha = 0.2
sim.set_m(m_gen)
sim.pins = [0, 10]
exchange = Exchange(A)
sim.add(exchange)
# Save H_exc and m at t0 for comparison with nmag
global H_exc_t0, m_t0
H_exc_t0 = exchange.compute_field()
m_t0 = sim.m
t = 0
t1 = 5e-10
dt = 1e-11
# s
av_f = open(os.path.join(MODULE_DIR, "averages.txt"), "w")
tn_f = open(os.path.join(MODULE_DIR, "third_node.txt"), "w")
global averages
averages = []
global third_node
third_node = []
while t <= t1:
mx, my, mz = sim.m_average
averages.append([t, mx, my, mz])
av_f.write(
str(t) + " " + str(mx) + " " + str(my) + " " + str(mz) + "\n")
mx, my, mz = h.components(sim.m)
m2x, m2y, m2z = mx[2], my[2], mz[2]
third_node.append([t, m2x, m2y, m2z])
tn_f.write(
str(t) + " " + str(m2x) + " " + str(m2y) + " " + str(m2z) + "\n")
t += dt
sim.run_until(t)
av_f.close()
tn_f.close()
def test_exchange_periodic_boundary_conditions():
mesh1 = df.BoxMesh(df.Point(0, 0, 0), df.Point(1, 1, 0.1), 2, 2, 1)
mesh2 = df.UnitCubeMesh(10, 10, 10)
print("""
# for debugging, to make sense of output
# testrun 0, 1 : mesh1
# testrun 2,3 : mesh2
# testrun 0, 2 : normal
# testrun 1,3 : pbc
""")
testrun = 0
for mesh in [mesh1, mesh2]:
pbc = PeriodicBoundary2D(mesh)
S3_normal = df.VectorFunctionSpace(mesh, "Lagrange", 1)
S3_pbc = df.VectorFunctionSpace(mesh,
"Lagrange",
1,
constrained_domain=pbc)
for S3 in [S3_normal, S3_pbc]:
print("Running test {}".format(testrun))
testrun += 1
FIELD_TOLERANCE = 6e-7
ENERGY_TOLERANCE = 0.0
m_expr = df.Expression(("0", "0", "1"), degree=1)
m = Field(S3, m_expr, name='m')
exch = Exchange(1)
exch.setup(m, Field(df.FunctionSpace(mesh, 'DG', 0), 1))
field = exch.compute_field()
energy = exch.compute_energy()
print("m.shape={}".format(m.vector().array().shape))
print("m=")
print(m.vector().array())
print("energy=")
print(energy)
print("shape=")
print(field.shape)
print("field=")
print(field)
H = field
print "Asserted zero exchange field for uniform m = (1, 0, 0) " + \
"got H =\n{}.".format(H.reshape((3, -1)))
print "np.max(np.abs(H)) =", np.max(np.abs(H))
assert np.max(np.abs(H)) < FIELD_TOLERANCE
E = energy
print "Asserted zero exchange energy for uniform m = (1, 0, 0), " + \
"Got E = {:g}.".format(E)
assert abs(E) <= ENERGY_TOLERANCE
def H_eff(self):
"""Very temporary function to make things simple."""
H_app = project((Constant((0, 1e5, 0))), self.S3)
H_ex = Function(self.S3)
# Comment out these two lines if you don't want exchange.
exch = Exchange(1.3e-11)
print "About to call setup"
exch.setup(self._m_field, self.Ms)
H_ex.vector().array()[:] = exch.compute_field()
H_eff = H_ex + H_app
return H_eff
def compute_finmag_exc(dolfin_mesh, m_gen, Ms, A):
S3 = df.VectorFunctionSpace(dolfin_mesh, "Lagrange", 1, dim=3)
coords = np.array(zip(*dolfin_mesh.coordinates()))
m0 = m_gen(coords).flatten()
m = Field(S3)
m.set_with_numpy_array_debug(m0)
exchange = Exchange(A)
exchange.setup(m, Field(df.FunctionSpace(dolfin_mesh, 'DG', 0), Ms))
finmag_exc_field = df.Function(S3)
finmag_exc_field.vector()[:] = exchange.compute_field()
return finmag_exc_field
def exchange(mesh, unit_length):
S3 = df.VectorFunctionSpace(mesh, "Lagrange", 1)
m = Field(S3,
value=df.Expression(("x[1]*u", "0", "sqrt(1-pow(x[1]*u, 2))"),
u=unit_length,
degree=1))
exch = Exchange(A)
exch.setup(m,
Field(df.FunctionSpace(mesh, 'DG', 0), Ms),
unit_length=unit_length)
H = exch.compute_field()
E = exch.compute_energy()
return m.get_numpy_array_debug(), H, E
def three_dimensional_problem():
x_max = 10e-9
y_max = 1e-9
z_max = 1e-9
mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(x_max, y_max, z_max), 40, 2,
2)
V = df.VectorFunctionSpace(mesh, 'Lagrange', 1)
Ms = 8.6e5
m0_x = "pow(sin(0.2*x[0]*1e9), 2)"
m0_y = "0"
m0_z = "pow(cos(0.2*x[0]*1e9), 2)"
m = Field(V,
value=vector_valued_function((m0_x, m0_y, m0_z),
V,
normalise=True))
C = 1.3e-11
u_exch = Exchange(C)
u_exch.setup(m, Field(df.FunctionSpace(mesh, 'DG', 0), Ms))
finmag_exch = u_exch.compute_field()
magpar_result = os.path.join(MODULE_DIR, 'magpar_result', 'test_exch')
nodes, magpar_exch = magpar.get_field(magpar_result, 'exch')
## Uncomment the line below to invoke magpar to compute the results,
## rather than using our previously saved results.
# nodes, magpar_exch = magpar.compute_exch_magpar(m, A=C, Ms=Ms)
print magpar_exch
# Because magpar have changed the order of the nodes!!!
tmp = df.Function(V)
tmp_c = mesh.coordinates()
mesh.coordinates()[:] = tmp_c * 1e9
finmag_exch, magpar_exch, \
diff, rel_diff = magpar.compare_field(
mesh.coordinates(), finmag_exch,
nodes, magpar_exch)
return dict(m0=m.get_numpy_array_debug(),
mesh=mesh,
exch=finmag_exch,
magpar_exch=magpar_exch,
diff=diff,
rel_diff=rel_diff)
def test_exchange_field_should_change_when_M_changes():
sim = Sim(mesh, Ms)
sim.set_m(df.Expression(('(2*x[0]-L)/L',
'sqrt(1 - ((2*x[0]-L)/L)*((2*x[0]-L)/L))',
'0'), L=length, degree=1))
exchange = Exchange(A)
sim.add(exchange)
# save the beginning value of M and the exchange field for comparison
# purposes
old_m = sim.m
old_H_ex = exchange.compute_field()
sim.run_until(1e-11)
# Capture the current value of the exchange field and m.
m = sim.m
H_ex = exchange.compute_field()
# We assert that the magnetisation has indeed changed since the beginning.
assert not np.array_equal(old_m, m)
assert not np.array_equal(old_H_ex, H_ex), "H_ex hasn't changed."
def setup_finmag():
mesh = df.IntervalMesh(xn, x0, x1)
coords = np.array(zip(*mesh.coordinates()))
S3 = df.VectorFunctionSpace(mesh, "Lagrange", 1, dim=3)
m = Field(S3)
m.set_with_numpy_array_debug(m_gen(coords).flatten())
exchange = Exchange(A)
exchange.setup(m, Field(df.FunctionSpace(mesh, 'DG', 0), Ms))
H_exc = df.Function(S3)
H_exc.vector()[:] = exchange.compute_field()
return dict(m=m, H=H_exc, table=start_table())
mz = 0
if 8e-9 < x < 14e-9 and -3e-9 < y < 3e-9:
pass
else:
m_arr[i] = mx
m_arr[i + nb_nodes] = my
m_arr[i + 2 * nb_nodes] = mz
M.vector()[:] = m_arr
# LLG setup
exchange = Exchange(C)
exchange.setup(V, M, Ms)
H_eff = Function(V)
H_eff.vector()[:] = exchange.compute_field()
p = gamma / (1 + alpha * alpha)
q = alpha * p
u = TrialFunction(V)
v = TestFunction(V)
a = inner(u, v) * dx
L = inner(
-p * cross(M, H_eff) - q * cross(M, cross(M, H_eff)) - c *
(inner(M, M) - 1) * M, v) * dx
dm = Function(V)
problem = LinearVariationalProblem(a,
L,
"got H =\n{}.".format(H.reshape((3, -1)))
print "np.max(np.abs(H)) =", np.max(np.abs(H))
assert np.max(np.abs(H)) < FIELD_TOLERANCE
E = energy
print "Asserted zero exchange energy for uniform m = (1, 0, 0), " + \
"Got E = {:g}.".format(E)
assert abs(E) <= ENERGY_TOLERANCE
if __name__ == "__main__":
mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(2 * np.pi, 1, 1), 10, 1, 1)
S = df.FunctionSpace(mesh, "Lagrange", 1)
S3 = df.VectorFunctionSpace(mesh, "Lagrange", 1)
expr = df.Expression(("0", "cos(x[0])", "sin(x[0])"), degree=1)
m = df.interpolate(expr, S3)
exch = Exchange(1, pbc2d=True)
exch.setup(S3, m, 1)
print exch.compute_field()
field = df.Function(S3)
field.vector().set_local(exch.compute_field())
df.plot(m)
df.plot(field)
df.interactive()