def test_anisotropy_energy_analytical(fixt):
"""
Compare one UniaxialAnisotropy energy with the corresponding analytical result.
The magnetisation is m = (0, sqrt(1 - x^2), x) and the easy axis still
a = (0, 0, 1). The squared dot product in the energy integral thus gives
dot(a, m)^2 = x^2. Integrating x^2 gives (x^3)/3 and the analytical
result with the constants we have chosen is 1 - 1/3 = 2/3.
"""
mesh = df.UnitCubeMesh(1, 1, 1)
functionspace = df.VectorFunctionSpace(mesh, "Lagrange", 1)
K1 = 1
Ms = Field(df.FunctionSpace(mesh, 'DG', 0), 1)
a = df.Constant((0, 0, 1))
m = Field(functionspace)
m.set(df.Expression(("0", "sqrt(1 - pow(x[0], 2))", "x[0]"), degree=1))
anis = UniaxialAnisotropy(K1, a)
anis.setup(m, Ms)
E = anis.compute_energy()
expected_E = float(2) / 3
print "With m = (0, sqrt(1-x^2), x), expecting E = {}. Got E = {}.".format(
expected_E, E)
#assert abs(E - expected_E) < TOLERANCE
assert np.allclose(E, expected_E, atol=1e-14, rtol=TOLERANCE)
def test_anisotropy_field_supported_methods(fixt):
"""
Check that all supported methods give the same results as the default method.
"""
TOLERANCE = 1e-13
fixt["m"].set(df.Constant((1 / np.sqrt(2), 0, 1 / np.sqrt(2))))
H_default = fixt["anis"].compute_field()
supported_methods = list(UniaxialAnisotropy._supported_methods)
# No need to compare default method with itself.
supported_methods.remove(fixt["anis"].method)
for method in supported_methods:
anis = UniaxialAnisotropy(fixt["K1"], fixt["a"], method=method)
anis.setup(fixt["m"], fixt["Ms"])
H = anis.compute_field()
print(
textwrap.dedent("""
With method '{}',
expecting: H = {},
got: H = {}.
""".format(method,
H_default.reshape((3, -1)).mean(axis=1),
H.reshape((3, -1)).mean(axis=1))))
assert np.allclose(H, H_default, atol=0, rtol=TOLERANCE)
def create_simulation(mesh):
sim = Sim(mesh, Ms=8.6e5, unit_length=1e-9)
sim.set_m((1, 0, 0))
sim.add(UniaxialAnisotropy(-1e5, (0, 0, 1), name='Kp'))
sim.add(UniaxialAnisotropy(1e4, (1, 0, 0), name='Kx'))
return sim
def compute_finmag_anis(m_gen, Ms, K1, axis, dolfin_mesh):
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)
anis = UniaxialAnisotropy(K1, axis)
anis.setup(m, Field(df.FunctionSpace(dolfin_mesh, 'DG', 0), Ms))
anis_field = df.Function(S3)
anis_field.vector()[:] = anis.compute_field()
return anis_field
def setup_module(module=None):
x_max = 100e-9 # m
simplexes = 50
mesh = dolfin.IntervalMesh(simplexes, 0, x_max)
def m_gen(coords):
x = coords[0]
mx = min(1.0, x / x_max)
mz = 0.1
my = np.sqrt(1.0 - (0.99 * mx**2 + mz**2))
return np.array([mx, my, mz])
K1 = 520e3 # J/m^3
Ms = 0.86e6
sim = Sim(mesh, Ms)
sim.alpha = 0.2
sim.set_m(m_gen)
anis = UniaxialAnisotropy(K1, (0, 0, 1))
sim.add(anis)
# Save H_anis and m at t0 for comparison with nmag
global H_anis_t0, m_t0
H_anis_t0 = anis.compute_field()
m_t0 = sim.m
av_f = open(os.path.join(MODULE_DIR, "averages.txt"), "w")
tn_f = open(os.path.join(MODULE_DIR, "third_node.txt"), "w")
t = 0
t_max = 3e-10
dt = 5e-12
# s
while t <= t_max:
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 fixt():
"""
Create an UniaxialAnisotropy object that will be re-used during testing.
"""
mesh = df.UnitCubeMesh(1, 1, 1)
functionspace = df.VectorFunctionSpace(mesh, "Lagrange", 1)
K1 = 1
Ms = Field(df.FunctionSpace(mesh, 'DG', 0), 1)
a = df.Constant((0, 0, 1))
m = Field(functionspace)
anis = UniaxialAnisotropy(K1, a)
anis.setup(m, Ms)
return {"anis": anis, "m": m, "a": a, "Ms": Ms, "K1": K1}
def create_simulation():
from finmag.util.meshes import ellipsoid
#mesh = df.IntervalMesh(10,0,30)
#mesh = df.RectangleMesh(0,0,10,2,5,1)
mesh = ellipsoid(30, 10, 10, maxh=3.0)
sim = Sim(mesh, Ms=8.6e5, unit_length=1e-9)
sim.set_m((1, 1, 1))
sim.add(Exchange(1.3e-11))
sim.add(UniaxialAnisotropy(-1e5, (0, 0, 1), name='Kp'))
sim.add(UniaxialAnisotropy(1e4, (1, 0, 0), name='Kx'))
return sim
def test_zhangli():
#mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(100, 1, 1), 50, 1, 1)
mesh = df.IntervalMesh(50, 0, 100)
sim = Sim(mesh, Ms=8.6e5, unit_length=1e-9, kernel='llg_stt')
sim.set_m(init_m)
sim.add(UniaxialAnisotropy(K1=520e3, axis=[1, 0, 0]))
sim.add(Exchange(A=13e-12))
sim.alpha = 0.01
sim.llg.set_parameters(J_profile=init_J, speedup=50)
p0 = sim.m_average
sim.run_until(5e-12)
p1 = sim.m_average
print sim.integrator.stats()
print p0, p1
sim.run_until(1e-11)
p1 = sim.m_average
print sim.integrator.stats()
print p0, p1
assert p1[0] < p0[0]
assert abs(p0[0]) < 1e-15
assert abs(p1[0]) > 1e-3
def run_sim_with_stt():
sim = Sim(mesh, Ms=8.6e5)
sim.set_m((1, 0.01, 0.01))
sim.alpha = 0.014
sim.gamma = 221017
H_app_mT = np.array([0.2, 0.2, 10.0])
H_app_SI = H_app_mT / (1000 * mu0)
sim.add(Zeeman(tuple(H_app_SI)))
sim.add(Exchange(1.3e-11))
sim.add(UniaxialAnisotropy(1e5, (0, 0, 1)))
I = 5e-5 # current in A
J = I / (L * W) # current density in A/m^2
theta = 40.0 * pi / 180
phi = pi / 2 # polarisation direction
p = (sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta))
sim.llg.use_slonczewski(J=J, P=0.4, d=5e-9, p=(0, 1, 0))
with open(averages_with, "w") as f:
dt = 5e-12
t_max = 10e-9
for t in np.arange(0, t_max, dt):
sim.run_until(t)
f.write("{} {} {} {}\n".format(t, *sim.m_average))
def test_interaction_accepts_name(fixt):
"""
Check that the interaction accepts a 'name' argument and has a 'name' attribute.
"""
K1 = 1
a = df.Constant((0, 0, 1))
anis = UniaxialAnisotropy(K1, a, name='MyAnisotropy')
assert hasattr(anis, 'name')
def setup(K2=K2):
print "Running finmag..."
mesh = from_geofile(os.path.join(MODULE_DIR, "bar.geo"))
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())
S1 = df.FunctionSpace(mesh, "Lagrange", 1)
Ms_cg = Field(df.FunctionSpace(mesh, 'CG', 1), Ms)
anisotropy = UniaxialAnisotropy(K1, u1, K2=K2)
anisotropy.setup(m, Ms_cg, unit_length=1e-9)
H_anis = df.Function(S3)
H_anis.vector()[:] = anisotropy.compute_field()
return dict(m=m, H=H_anis, S3=S3, table=start_table())
def test_anisotropy():
mesh = df.IntervalMesh(1, 0, 1)
sim = Simulation(mesh, Ms, unit_length=1e-9)
sim.set_m((mx, my, mz))
sim.add(UniaxialAnisotropy(K1, axis=[1, 0, 0]))
expected = 2 * K1 / (mu0 * Ms) * mx
field = sim.effective_field()
assert abs(field[0] - expected) / Ms < 1e-15
def test_spatially_varying_anisotropy_axis(tmpdir, debug=False):
Ms = 1e6
A = 1.3e-11
K1 = 6e5
lb = bloch_parameter(A, K1)
unit_length = 1e-9
nx = 20
Lx = nx * lb / unit_length
mesh = df.IntervalMesh(nx, 0, Lx)
# anisotropy axis goes from (0, 1, 0) at x=0 to (1, 0, 0) at x=Lx
expr_a = df.Expression(("x[0] / sqrt(pow(x[0], 2) + pow(Lx-x[0], 2))",
"(Lx-x[0]) / sqrt(pow(x[0], 2) + pow(Lx-x[0], 2))",
"0"), Lx=Lx, degree=1)
# in theory, a discontinuous Galerkin (constant over the cell) is a good
# choice to represent material parameters. In this case though, the
# parameter varies linearly, so we use the usual CG.
V = df.VectorFunctionSpace(mesh, "CG", 1, dim=3)
a = Field(V, expr_a)
sim = Simulation(mesh, Ms, unit_length)
sim.set_m((1, 1, 0))
sim.add(UniaxialAnisotropy(K1, a))
sim.relax()
# probe the easy axis and the magnetisation along the interval
points = 100
xs = np.linspace(0, Lx, points)
axis_xs = np.zeros((points, 3))
m_xs = np.zeros((points, 3))
for i, x in enumerate(xs):
axis_xs[i] = a(x)
m_xs[i] = sim.m_field(x)
# we want to the magnetisation to follow the easy axis
# it does so, except at x=0, what is happening there?
diff = np.abs(m_xs - axis_xs)
assert diff.max() < 0.02
if debug:
old = os.getcwd()
os.chdir(tmpdir)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(xs, axis_xs[:, 0], "b+", label="a_x")
ax.plot(xs, m_xs[:, 0], "r--", label="m_x")
ax.legend(loc="upper left")
ax.set_ylim((0, 1.05))
ax.set_xlabel("x (nm)")
plt.savefig('spatially_varying_easy_axis.png')
plt.close()
sim.m_field.save_pvd('spatially_varying_easy_axis.pvd')
os.chdir(old)
def run_simulation(plot=False):
mu0 = 4.0 * np.pi * 10**-7 # vacuum permeability N/A^2
Ms = 1.0e6 # saturation magnetisation A/m
A = 13.0e-12 # exchange coupling strength J/m
Km = 0.5 * mu0 * Ms**2 # magnetostatic energy density scale kg/ms^2
lexch = (A / Km)**0.5 # exchange length m
unit_length = 1e-9
K1 = Km
L = lexch / unit_length
nx = 10
Lx = nx * L
ny = 1
Ly = ny * L
nz = 30
Lz = nz * L
mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(Lx, Ly, Lz), nx, ny, nz)
# Anisotropy easy axis is (0, 0, 1) in the lower half of the film and
# (1, 0, 0) in the upper half. This is a toy model of the exchange spring
# systems that Bob Stamps is working on.
boundary = Lz / 2.0
expr_a = df.Expression(("x[2] <= b ? 0 : 1", "0", "x[2] <= b ? 1 : 0"),
b=boundary,
degree=1)
V = df.VectorFunctionSpace(mesh, "DG", 0, dim=3)
a = Field(V, expr_a)
sim = Simulation(mesh, Ms, unit_length)
sim.set_m((1, 0, 1))
sim.add(UniaxialAnisotropy(K1, a))
sim.add(Exchange(A))
sim.relax()
if plot:
points = 200
zs = np.linspace(0, Lz, points)
axis_zs = np.zeros((points, 3)) # easy axis probed along z-axis
m_zs = np.zeros((points, 3)) # magnetisation probed along z-axis
for i, z in enumerate(zs):
axis_zs[i] = a((Lx / 2.0, Ly / 2.0, z))
m_zs[i] = sim.m_field((Lx / 2.0, Ly / 2.0, z))
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(zs, axis_zs[:, 0], "-o", label="a_x")
ax.plot(zs, axis_zs[:, 2], "-x", label="a_z")
ax.plot(zs, m_zs[:, 0], "-", label="m_x")
ax.plot(zs, m_zs[:, 2], "-", label="m_z")
ax.set_xlabel("z (nm)")
ax.legend(loc="upper left")
plt.savefig(os.path.join(MODULE_DIR, "profile.png"))
sim.m_field.save_pvd(os.path.join(MODULE_DIR, 'exchangespring.pvd'))
def test_anisotropy_energy_simple_configurations(fixt, m, expected_E):
"""
Test some parallel and orthogonal configurations of m and a.
"""
mesh = df.UnitCubeMesh(1, 1, 1)
functionspace = df.VectorFunctionSpace(mesh, "Lagrange", 1)
K1 = 1
Ms = Field(df.FunctionSpace(mesh, 'DG', 0), 1)
a = df.Constant((0, 0, 1))
m_field = Field(functionspace)
m_field.set(df.Constant(m))
anis = UniaxialAnisotropy(K1, a)
anis.setup(m_field, Ms)
E = anis.compute_energy()
print "With m = {}, expecting E = {}. Got E = {}.".format(m, expected_E, E)
#assert abs(E - expected_E) < TOLERANCE
assert np.allclose(E, expected_E, atol=1e-14, rtol=TOLERANCE)
def test_anisotropy_energy_density():
"""
Written in sperical coordinates, the equation for the
anisotropy energy density reads
E/V = K*sin^2(theta),
where theta is the angle between the magnetisation and
the easy axis. With a magnetisation pointing 45 degrees
between the x- and z-axis, and using the z-axis as the
easy axis, theta becomes pi/4. sin^2(pi/4) evaluates
to 1/2, and with K set to 1 in this simple test case,
we expect the energy density to be 1/2 at every node.
"""
# 5 simplices between 0 and 1 nm.
mesh = df.IntervalMesh(5, 0, 1e-9)
V = df.VectorFunctionSpace(mesh, "CG", 1, dim=3)
# Initial magnetisation 45 degress between x- and z-axis.
m_vec = df.Constant((1 / np.sqrt(2), 0, 1 / np.sqrt(2)))
m = Field(V, value=m_vec)
# Easy axis in z-direction.
a = df.Constant((0, 0, 1))
# These are 1 just to simplify the analytical solution.
K = 1
Ms = 1
anis = UniaxialAnisotropy(K, a)
anis.setup(m, Field(df.FunctionSpace(mesh, 'DG', 0), Ms))
density = anis.energy_density()
deviation = np.abs(density - 0.5)
print "Anisotropy energy density (expect array of 0.5):"
print density
print "Max deviation: %g" % np.max(deviation)
assert np.all(deviation < TOL), \
"Max deviation %g, should be zero." % np.max(deviation)
def run_simulation(lfactor, m_init, m_init_name=""):
L = lfactor * lexch
divisions = int(round(lfactor * 2)) # that magic number influences L
mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(L, L, L), divisions,
divisions, divisions)
exchange = Exchange(A)
anisotropy = UniaxialAnisotropy(K1, [0, 0, 1])
demag = Demag()
sim = Simulation(mesh, Ms)
sim.set_m(m_init)
sim.add(exchange)
sim.add(anisotropy)
sim.add(demag)
sim.relax()
# Save average magnetisation.
mx, my, mz = sim.m_average
with open(os.path.join(MODULE_DIR, "data_m.txt"), "a") as f:
t = time.asctime()
f.write("{} {} {} {} {} {}\n".format(m_init_name, lfactor, mx, my, mz,
t))
# Save energies.
# We could call sim.total_energy, but we want the individual contributions.
e_exc = exchange.compute_energy() / (sim.Volume * Km)
e_anis = anisotropy.compute_energy() / (sim.Volume * Km)
e_demag = demag.compute_energy() / (sim.Volume * Km)
e_total = e_exc + e_anis + e_demag # relative total energy density
with open(os.path.join(MODULE_DIR, "data_energies.txt"), "a") as f:
t = time.asctime()
f.write("{} {} {} {} {} {} {}\n".format(m_init_name, lfactor, e_total,
e_exc, e_anis, e_demag, t))
return e_total
def run_sim_without_stt():
sim = Sim(mesh, Ms=8.6e5)
sim.set_m((1, 0.01, 0.01))
sim.alpha = 0.014
sim.gamma = 221017
H_app_mT = np.array([0.2, 0.2, 10.0])
H_app_SI = H_app_mT / (1000 * mu0)
sim.add(Zeeman(tuple(H_app_SI)))
sim.add(Exchange(1.3e-11))
sim.add(UniaxialAnisotropy(1e5, (0, 0, 1)))
with open(averages_without, "w") as f:
dt = 5e-12
t_max = 10e-9
for t in np.arange(0, t_max, dt):
sim.run_until(t)
f.write("{} {} {} {}\n".format(t, *sim.m_average))
def setup_domain_wall_cobalt(node_count=NODE_COUNT,
A=A_Co,
Ms=Ms_Co,
K1=K1_Co,
length=LENGTH,
do_precession=True):
mesh = df.IntervalMesh(node_count - 1, 0, length)
S1 = df.FunctionSpace(mesh, "Lagrange", 1)
S3 = df.VectorFunctionSpace(mesh, "Lagrange", 1, dim=3)
llg = LLG(S1, S3)
llg.set_m(
np.array([initial_m(xi, node_count)
for xi in xrange(node_count)]).T.reshape((-1, )))
exchange = Exchange(A)
llg.effective_field.add(exchange)
anis = UniaxialAnisotropy(K1, (0, 0, 1))
llg.effective_field.add(anis)
llg.pins = [0, node_count - 1]
return llg
def run_simulation():
L = W = 12.5e-9
H = 5e-9
mesh = df.BoxMesh(df.Point(0, 0, 0), df.Point(L, W, H), 5, 5, 2)
sim = Sim(mesh, Ms=860e3, name="finmag_validation")
sim.set_m((1, 0.01, 0.01))
sim.alpha = 0.014
sim.gamma = 221017
H_app_mT = np.array([0.2, 0.2, 10.0])
H_app_SI = H_app_mT / (1000 * mu0)
sim.add(Zeeman(tuple(H_app_SI)))
sim.add(Exchange(1.3e-11))
sim.add(UniaxialAnisotropy(-1e5, (0, 0, 1)))
I = 5e-5 # current in A
J = I / (L * W) # current density in A/m^2
theta = 40.0 * pi / 180 # polarisation direction
phi = pi / 2
p = (sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta))
sim.set_stt(current_density=J, polarisation=0.4, thickness=H, direction=p)
sim.schedule("save_averages", every=5e-12)
sim.run_until(10e-9)
D = 3e-3
Ms = 0.86e6
Ku = 0.4e6
initial_sk_diam = 10
sim = Sim(mesh, Ms=Ms, unit_length=1e-9, name="1d_Cnv")
sim.set_m((0, 0.1, 0.9))
# -----------------------------------------------------------------------------
# Exchange Energy
sim.add(Exchange(A))
# DMI
sim.add(DMI(D, dmi_type='interfacial'))
# Uniaxial Anisotropy
sim.add(UniaxialAnisotropy(Ku, (0, 0, 1), name='Ku'))
# -----------------------------------------------------------------------------
sim.do_precession = False
sim.alpha = 0.9
if not os.path.exists('vtks'):
# shutil.rmtree('vtks')
os.mkdir('vtks')
sim.relax()
sim.save_vtk(filename='vtks/1d_Cnv.pvd', overwrite=True)
sim.save_field('m', '1d_Cnv.npy', overwrite=True)
xs = sim.mesh.coordinates()
else:
sim = Sim(mesh, args.Ms, unit_length=1e-9, pbc='2d', name=args.sim_name)
# Add energies
sim.add(Exchange(args.A))
if args.D != 0:
sim.add(DMI(args.D * 1e-3, dmi_type='interfacial'))
# Zeeman field in the z direction (in Tesla)
# if it is not zero
if args.B != 0:
sim.add(Zeeman((0, 0, args.B / finmag.util.consts.mu0)))
if args.k_u:
sim.add(UniaxialAnisotropy(args.k_u, (0, 0, 1), name='Ku'))
# No Demag in 2D
# sim.add(Demag())
# sim.llg.presession = False
if args.alpha:
sim.alpha = args.alpha
# Pin the magnetisation vectors at the borders if specified
if args.pin_borders:
def borders_pinning(pos):
x, y = pos[0], pos[1]
def test_domain_wall_profile(do_plot=False):
simplices = 500
L = 504e-9
dim = 3
mesh = df.IntervalMesh(simplices, 0, L)
V = df.VectorFunctionSpace(mesh, "CG", 1, dim=dim)
m0 = df.Function(V)
coor = mesh.coordinates()
n = len(m0.vector().array())
print "Double check that the length of the vectors are equal: %g and %g" \
% (n, len(coor) * dim)
assert n == len(coor) * dim
# Setup LLG
sim = Sim(mesh, Ms)
exchange = Exchange(A)
sim.add(exchange)
anisotropy = UniaxialAnisotropy(K1, (0, 0, 1))
sim.add(anisotropy)
# TODO: Find out how one are supposed to pin.
# llg.pins = [0,1,-2,-1] # This is not so good
# MA: because you pin by index -2 and -1 won't work like you'd expect.
sim.alpha = 1.0
# set initial magnetization
x, y, z = M0(coor)
m0.vector()[:] = np.array([x, y, z]).reshape(n)
sim.set_m(np.array([x, y, z]).reshape(n))
# Time integration
# f=open('data.txt','w')
for t in np.arange(0.0, 2e-10, 1e-11):
sim.run_until(t)
#Eani = anisotropy.compute_energy()/L
#Eex = exchange.compute_energy()/L
#f.write('%g\t%g\t%g\n' % (r.t,Eani,Eex))
print "Integrating time: %g" % t
# f.close()
print timer
mz = []
x = np.linspace(0, L, simplices + 1)
for xpos in x:
mz.append(sim.m_field.probe(xpos)[2])
mz = np.array(mz) * Ms
if do_plot:
# Plot magnetisation in z-direction
pylab.plot(x, mz, 'o', label='finmag')
pylab.plot(x, Mz_exact(x), '-', label='analytic')
pylab.legend(("Finmag", "Analytical"))
pylab.title("Domain wall example - Finmag vs analytical solution")
pylab.xlabel("Length")
pylab.ylabel("M.z")
pylab.savefig('1d-domain-wall-profile.png')
try:
import scipy.optimize
except ImportError:
pass
else:
popt, pcov = scipy.optimize.curve_fit(
Mz_exact, x, mz, p0=(x0 * 1.1, A * 1.1, Ms * 1.1))
print "popt=", popt
fittedx0, fittedA, fittedMs = popt
print "Error in fitted x0: %9.7f%%" % ((fittedx0 - x0) / x0 * 100)
print "Error in fitted Ms: %9.7f%%" % ((fittedMs - Ms) / Ms * 100)
print "Error in fitted A : %9.7f%%" % ((fittedA - A) / A * 100)
print "fitted A : %9g" % (fittedA)
print "correct A : %9g" % (A)
print "difference A : %9g" % (fittedA - A)
print "rel difference A : %9g" % ((fittedA - A) / A)
print "quotient A/fittedA and fittedA/A : %9g %g" % (A / fittedA, fittedA / A)
assert abs(fittedA - A) / A < 0.004, "Fitted A too inaccurate"
# Maximum deviation:
maxdiff = max(abs(mz - Mz_exact(x)))
print "Absolute deviation in Mz", maxdiff
assert maxdiff < 1200
maxreldiff = maxdiff / max(Mz_exact(x))
print "Relative deviation in Mz", maxreldiff
assert maxreldiff < 0.0009
A = 1e-11
K1 = 3e5
K1_axis = (0, 0, 1)
H_baseline = 2 * K1 / Ms_Tesla
H_mult = [0.95, 1.2, 2.8]
H_axis = -spherical_to_cartesian((1.0, 1.0 * np.pi / 180, 0))
mesh = cylinder(6, 20, 2.0)
start_clock = time.clock()
for H in H_mult:
sim = Simulation(mesh, Ms, unit_length=1e-9)
sim.alpha = 0.02
sim.set_m(K1_axis)
sim.add(Exchange(A))
sim.add(UniaxialAnisotropy(K1, K1_axis))
sim.add(Demag())
sim.add(Zeeman(H * H_baseline * H_axis))
print "Running simulation for H = {} T.".format(H)
print sim.mesh_info()
t = 0
dt = 1e-12
t_failsafe = 2e-9
dt_output = 100e-12
ts = []
mzs = []
while True:
sim.run_until(t)
from finmag import NormalModeSimulation as Sim
from finmag.energies import Exchange, DMI, UniaxialAnisotropy, Zeeman
from finmag.util.dmi_helper import find_skyrmion_center_2d
from finmag.util.helpers import set_logging_level
from finmag.util import meshes
import finmag
rdir = '../results/relax'
os.chdir(rdir)
h5_file = df.HDF5File(df.mpi_comm_world(), 'relaxed-nanotrack-1e-7.h5', 'r')
mesh = df.Mesh()
h5_file.read(mesh, 'mesh', False)
sim = Sim(mesh=mesh, Ms=5.8e5, unit_length=1e-9, pbc=None)
sim.add(UniaxialAnisotropy(K1=6e5, axis=[0, 0, 1]))
sim.add(Exchange(A=1.5e-11))
sim.add(DMI(D=3e-3))
sim.add(Zeeman((0, 0, 1e5)))
sim.alpha = 0.5
print('Trying to load relaxed state')
m = hlp.load_h5_field(sim, 'relaxed-nanotrack-1e-7.h5')
sim.set_m(m)
sim.do_precession = False
print('Computing eigenmodes!\n\n\n')
n_eigenmodes = 50 # Calculate the first 50 eigenmodes.
complex_freqs = sim.compute_normal_modes(n_values=n_eigenmodes)
f_array = np.real(complex_freqs[0])
