def test_field_vector(self):
name = 'uniaxialanisotropy_field_vector'
def value_fun(pos):
x, y, z = pos
if x <= 0:
return 0
else:
return 1e5
mesh = df.Mesh(region=self.region, cell=self.cell)
K = df.Field(mesh, dim=1, value=value_fun)
u = (0, 0, 1)
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.UniaxialAnisotropy(K=K, u=u)
system.m = df.Field(mesh, dim=3, value=(0, 0.3, 1), norm=Ms)
md = self.calculator.MinDriver()
md.drive(system)
value = system.m((-2e-9, -2e-9, -2e-9))
assert np.linalg.norm(np.cross(value, (0, 0.3*Ms, Ms))) < 1e-3
value = system.m((2e-9, 2e-9, 2e-9))
assert np.linalg.norm(np.subtract(value, (0, 0, Ms))) < 1e-3
self.calculator.delete(system)
def test_scalar_field(self):
name = 'uniaxialanisotropy_scalar_field'
def value_fun(pos):
x, y, z = pos
if x <= 0:
return (1, 0, 0)
else:
return (0, 1, 0)
mesh = df.Mesh(region=self.region, cell=self.cell)
K = 1e5
u = df.Field(mesh, dim=3, value=value_fun)
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.UniaxialAnisotropy(K=K, u=u)
system.m = df.Field(mesh, dim=3, value=(1, 1, 0), norm=Ms)
md = self.calculator.MinDriver()
md.drive(system)
value = system.m((-2e-9, -2e-9, -2e-9))
assert np.linalg.norm(np.subtract(value, (Ms, 0, 0))) < 1e-3
value = system.m((2e-9, 2e-9, 2e-9))
assert np.linalg.norm(np.subtract(value, (0, Ms, 0))) < 1e-3
self.calculator.delete(system)
def test_field_scalar(self):
name = 'zhangli_field_scalar'
mesh = df.Mesh(region=self.region, cell=self.cell)
def u_fun(pos):
x, y, z = pos
if y <= 0:
return 0
else:
return 1
H = (0, 0, 1e6)
u = df.Field(mesh, dim=1, value=u_fun)
beta = 0.5
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.Zeeman(H=H)
system.dynamics = mm.ZhangLi(u=u, beta=beta)
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
td = self.calculator.TimeDriver()
td.drive(system, t=0.2e-9, n=50)
# u=0 region
value = system.m((1e-9, -4e-9, 3e-9))
assert np.linalg.norm(np.cross(value, (0, 0.1 * Ms, Ms))) < 1e-3
# u!=0 region
value = system.m((1e-9, 4e-9, 3e-9))
assert np.linalg.norm(np.subtract(value, (0, 0, Ms))) > 1
self.calculator.delete(system)
def test_field(self):
name = 'precession_field'
mesh = df.Mesh(region=self.region, n=self.n)
def value_fun(pos):
x, y, z = pos
if y <= 0:
return 0
else:
return 2.211e5
H = (0, 0, 1e6)
gamma0 = df.Field(mesh, dim=1, value=value_fun)
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.Zeeman(H=H)
system.dynamics = mm.Precession(gamma0=gamma0)
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
td = self.calculator.TimeDriver()
td.drive(system, t=0.2e-9, n=50)
# gamma=0 region
value = system.m((1e-9, -4e-9, 3e-9))
assert np.linalg.norm(np.cross(value, (0, 0.1*Ms, Ms))) < 1e-3
# gamma!=0 region
value = system.m((1e-9, 4e-9, 3e-9))
assert np.linalg.norm(np.cross(value, (0, 0.1*Ms, Ms))) > 1
self.calculator.delete(system)
def test_demag_pbc(self):
name = 'demag_pbc'
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.Demag()
md = self.calculator.MinDriver()
# 1D pbc
mesh = df.Mesh(region=self.region, cell=self.cell, bc='x')
system.m = df.Field(mesh, dim=3, value=(0, 0, 1), norm=Ms)
md.drive(system)
# 2D pbc
mesh = df.Mesh(region=self.region, cell=self.cell, bc='xy')
system.m = df.Field(mesh, dim=3, value=(0, 0, 1), norm=Ms)
with pytest.raises(ValueError):
md.drive(system)
# 3D pbc
mesh = df.Mesh(region=self.region, cell=self.cell, bc='xyz')
system.m = df.Field(mesh, dim=3, value=(0, 0, 1), norm=Ms)
with pytest.raises(ValueError):
md.drive(system)
self.calculator.delete(system)
def test_exchange_dmi_zeeman(self):
name = 'exchange_dmi_zeeman'
mesh = df.Mesh(region=self.region,
cell=self.cell,
subregions=self.subregions)
# Very weak DMI and strong Zeeman to make the final
# magnetisation uniform.
A = {'r1': 1e-12, 'r2': 3e-12, 'r1:r2': 2e-12}
D = {'r1': 1e-9, 'r2': 0, 'r1:r2': 5e-9}
H = df.Field(mesh, dim=3, value=(1e10, 0, 0))
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.Exchange(A=A) + \
mm.DMI(D=D, crystalclass='Cnv') + \
mm.Zeeman(H=H)
system.m = df.Field(mesh, dim=3, value=(1, 0.3, 0), norm=Ms)
md = self.calculator.MinDriver()
md.drive(system)
value = system.m(mesh.region.random_point())
assert np.linalg.norm(np.subtract(value, (Ms, 0, 0))) < 1
self.calculator.delete(system)
def test_norm(self):
mesh = df.Mesh(p1=(0, 0, 0), p2=(10, 10, 10), cell=(1, 1, 1))
f = df.Field(mesh, dim=3, value=(2, 2, 2))
assert np.all(f.norm.value == 2*np.sqrt(3))
assert np.all(f.norm.array == 2*np.sqrt(3))
assert np.all(f.array == 2)
f.norm = 1
assert np.all(f.norm.value == 1)
assert np.all(f.norm.array == 1)
assert np.all(f.array == 1/np.sqrt(3))
f.array[0, 0, 0, 0] = 3
assert isinstance(f.norm.value, np.ndarray)
assert not np.all(f.norm.value == 1)
for mesh in self.meshes:
for value in self.iters + self.vfuncs:
for norm_value in [1, 2.1, 50, 1e-3, np.pi]:
f = df.Field(mesh, dim=3, value=value, norm=norm_value)
# Compute norm.
norm = f.array[..., 0]**2
norm += f.array[..., 1]**2
norm += f.array[..., 2]**2
norm = np.sqrt(norm)
assert norm.shape == f.mesh.n
assert f.norm.array.shape == f.mesh.n + (1,)
assert np.all(abs(norm - norm_value) < 1e-12)
def test_field_vector_vector(self):
name = 'cubicanisotropy_field_vector_vector'
mesh = df.Mesh(region=self.region, cell=self.cell)
def K_fun(pos):
x, y, z = pos
if x <= 0:
return 0
else:
return 1e5
K = df.Field(mesh, dim=1, value=K_fun)
u1 = (0, 0, 1)
u2 = (0, 1, 0)
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.CubicAnisotropy(K=K, u1=u1, u2=u2)
system.m = df.Field(mesh, dim=3, value=(0, 0.3, 1), norm=Ms)
md = self.calculator.MinDriver()
md.drive(system)
value = system.m((-2e-9, 1e-9, 1e-9))
assert np.linalg.norm(np.cross(value, (0, 0.3 * Ms, Ms))) < 1e-3
value = system.m((2e-9, 2e-9, 2e-9))
assert np.linalg.norm(np.subtract(value, (0, 0, Ms))) < 1e-3
self.calculator.delete(system)
def test_field(self):
name = 'exchange_field'
def A_fun(pos):
x, y, z = pos
if x <= 0:
return 1e-10 # for 0, OOMMF gives nan
else:
return 1e-12
mesh = df.Mesh(region=self.region, n=self.n)
A = df.Field(mesh, dim=1, value=A_fun)
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.Exchange(A=A)
system.m = df.Field(mesh, dim=3, value=self.m_init, norm=Ms)
md = self.calculator.MinDriver()
md.drive(system)
assert abs(np.linalg.norm(system.m.average) - Ms) < 1
self.calculator.delete(system)
def test_field(self):
name = 'damping_field'
mesh = df.Mesh(region=self.region, n=self.n)
def value_fun(pos):
x, y, z = pos
if y <= 0:
return 0
else:
return 1
H = (0, 0, 1e6)
alpha = df.Field(mesh, dim=1, value=value_fun)
Ms = 1e6
system = mm.System(name=name)
system.energy = mm.Zeeman(H=H)
system.dynamics = mm.Damping(alpha=alpha)
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
td = self.calculator.TimeDriver()
td.drive(system, t=0.2e-9, n=50)
# alpha=0 region
value = system.m((1e-9, -4e-9, 3e-9))
assert np.linalg.norm(np.cross(value, (0, 0.1 * Ms, Ms))) < 1e-3
# alpha!=0 region
value = system.m((1e-9, 4e-9, 3e-9))
assert np.linalg.norm(np.subtract(value, (0, 0, Ms))) < 1e-3
self.calculator.delete(system)
def test_invalid_init(self):
with pytest.raises(TypeError):
mesh = 'wrong_mesh_string'
f = df.Field(mesh, dim=1)
for mesh in self.meshes:
with pytest.raises(TypeError):
f = df.Field(mesh, dim='wrong_dim')
def test_dir(self):
for mesh in self.meshes:
f = df.Field(mesh, value=(5, 6, -9))
assert 'x' in f.__dir__()
assert 'y' in f.__dir__()
assert 'z' in f.__dir__()
f = df.Field(mesh, dim=1, value=1)
assert 'x' not in f.__dir__()
assert 'y' not in f.__dir__()
assert 'z' not in f.__dir__()
def setup(self):
mesh = df.Mesh(p1=(0, 0, 0), p2=(5, 5, 5), cell=(1, 1, 1))
B1field = df.Field(mesh, dim=1, value=5e6)
B2field = df.Field(mesh, dim=1, value=7e6)
e_diagfield = df.Field(mesh, dim=3, value=(1, 0, 0))
e_offdiagfield = df.Field(mesh, dim=3, value=(1, 1, 0))
self.valid_args = [(1, 1, (0, 1, 0), (2, 3, 7)),
(2e6, 3e6, (1e6, 1, 0.1), (2, 3, 7)),
(7e6, -2e-6, (0, 1e-8, 0), (2, 3.14, 7)),
(B1field, B2field, e_diagfield, e_offdiagfield)]
self.invalid_args = [((0, 1), 1, (0, 1, 0), (2, 3, 7)),
(2e6, '5', (1e6, 1, 0.1), (2, 3, 7)),
(7e6, -2e-6, (0, 1e-8, 3.14), (1, 7)),
(7e6, -2e-6, 5, 2)]
def test_exchange_cubicanisotropy(self):
name = 'exchange_cubicanisotropy'
A = {'r1': 1e-12, 'r2': 0}
K = 1e5
u1 = (1, 0, 0)
u2 = (0, 1, 0)
Ms = 1e6
mesh = df.Mesh(region=self.region,
cell=self.cell,
subregions=self.subregions)
system = mm.System(name=name)
system.energy = mm.Exchange(A=A) + \
mm.CubicAnisotropy(K=K, u1=u1, u2=u2)
system.m = df.Field(mesh, dim=3, value=(1, 0.3, 0), norm=Ms)
md = self.calculator.MinDriver()
md.drive(system)
value = system.m(mesh.region.random_point())
assert np.linalg.norm(np.subtract(value, (Ms, 0, 0))) < 1e-3
self.calculator.delete(system)
def test_norm_scalar_field_exception(self):
for mesh in self.meshes:
for value in self.consts + self.sfuncs:
for norm in [1, 2.1, 50, 1e-3, np.pi]:
f = df.Field(mesh, dim=1, value=value)
with pytest.raises(ValueError):
f.norm = norm
def test_set_with_function(self):
for mesh in self.meshes:
for func in self.sfuncs:
f = df.Field(mesh, dim=1, value=func)
for j in range(10):
c = f.mesh.random_point()
c = f.mesh.index2point(f.mesh.point2index(c))
assert f(c) == func(c)
for mesh in self.meshes:
for func in self.vfuncs:
f = df.Field(mesh, dim=3, value=func)
for j in range(10):
c = f.mesh.random_point()
c = f.mesh.index2point(f.mesh.point2index(c))
assert np.all(f(c) == func(c))
def test_set_exception(self):
for mesh in self.meshes:
f = df.Field(mesh)
with pytest.raises(ValueError):
f.value = 'string'
with pytest.raises(ValueError):
f.value = 1+2j
def test_script(self):
system = mc.System(name="test_system")
system.hamiltonian += mc.Exchange(1e-12)
system.hamiltonian += mc.Demag()
system.hamiltonian += mc.UniaxialAnisotropy(1e3, (0, 1, 0))
system.hamiltonian += mc.Zeeman((0, 1e6, 0))
system.dynamics += mc.Precession(2.211e5)
system.dynamics += mc.Damping(0.1)
mesh = mc.Mesh((0, 0, 0), (5, 5, 5), (1, 1, 1))
system.m = df.Field(mesh, dim=3, value=(0, 1, 0), norm=1)
script = system._script
assert script[-1] == "\n"
assert "mu0mm" in script
assert "SetGridSize(5, 5, 5)" in script
assert "SetCellSize(1, 1, 1)" in script
assert "Aex=1e-12" in script
assert "enabledemag=true" in script
assert "B_ext=vector(0*mu0mm,1000000.0*mu0mm,0*mu0mm)" in script
assert "Ku1=1000.0" in script
assert "Ku2=0" in script
assert "anisu=vector(0,1,0)" in script
return None
def test_dict_scalar(self):
name = 'zhangli_dict_scalar'
H = (0, 0, 1e6)
u = {'r1': 0, 'r2': 1}
beta = 0.5
Ms = 1e6
mesh = df.Mesh(region=self.region,
cell=self.cell,
subregions=self.subregions)
system = mm.System(name=name)
system.energy = mm.Zeeman(H=H)
system.dynamics = mm.ZhangLi(u=u, beta=beta)
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
td = self.calculator.TimeDriver()
td.drive(system, t=0.2e-9, n=50)
# u=0 region
value = system.m((1e-9, -4e-9, 3e-9))
assert np.linalg.norm(np.cross(value, (0, 0.1 * Ms, Ms))) < 1e-3
# u!=0 region
value = system.m((1e-9, 4e-9, 3e-9))
assert np.linalg.norm(np.subtract(value, (0, 0, Ms))) > 1
self.calculator.delete(system)
def test_relax_with_cubicanisotropy():
name = "cubic_anisotropy"
L = 100e-9
d = 5e-9
Ms = 8e6
# Remove any previous simulation directories.
if os.path.exists(name):
shutil.rmtree(name)
system = oc.System(name=name)
system.hamiltonian = oc.CubicAnisotropy(K1=5e6, u1=(1, 0, 0), u2=(0, 1, 0))
mesh = oc.Mesh(p1=(0, 0, 0), p2=(L, L, L), cell=(d, d, d))
def m_init(pos):
x, y, z = pos
if x < 30e-9:
return (0.7, 0.1, 0.3)
elif x > 70e-9:
return (0.1, 0.7, 0.3)
else:
return (0.3, 0.1, 0.7)
system.m = df.Field(mesh, value=m_init, norm=Ms)
md = oc.MinDriver()
md.drive(system)
comp_value = 0.99 * Ms
assert system.m((10e-9, 0, 0))[0] > comp_value
assert system.m((50e-9, 0, 0))[2] > comp_value
assert system.m((80e-9, 0, 0))[1] > comp_value
shutil.rmtree(name)
def minimise_system_energy(L, m_init):
N = 16 # discretisation in one dimension
cubesize = 100e-9 # cube edge length (m)
cellsize = cubesize / N # discretisation in all three dimensions.
lex = cubesize / L # exchange length.
Km = 1e6 # magnetostatic energy density (J/m**3)
Ms = np.sqrt(2 * Km / oc.mu0) # magnetisation saturation (A/m)
A = 0.5 * oc.mu0 * Ms**2 * lex**2 # exchange energy constant
K = 0.1 * Km # Uniaxial anisotropy constant
u = (0, 0, 1) # Uniaxial anisotropy easy-axis
p1 = (0, 0, 0) # Minimum sample coordinate.
p2 = (cubesize, cubesize, cubesize) # Maximum sample coordinate.
cell = (cellsize, cellsize, cellsize) # Discretisation.
mesh = oc.Mesh(p1=(0, 0, 0),
p2=(cubesize, cubesize, cubesize),
cell=(cellsize, cellsize, cellsize))
system = oc.System(name=name)
system.hamiltonian = oc.Exchange(A) + oc.UniaxialAnisotropy(K, u) + \
oc.Demag()
system.m = df.Field(mesh, value=m_init, norm=Ms)
md = oc.MinDriver()
md.drive(system)
return system
def test_dict_values(self):
name = 'slonczewski_scalar_values'
J = {'r1': 1e12, 'r2': 5e12}
mp = {'r1': (0, 0, 1), 'r2': (0, 1, 0)}
P = {'r1': 0.4, 'r2': 0.35}
Lambda = {'r1': 2, 'r2': 1.5}
eps_prime = {'r1': 0, 'r2': 1}
H = (0, 0, 1e6)
Ms = 1e6
mesh = df.Mesh(region=self.region, n=self.n,
subregions=self.subregions)
system = mm.System(name=name)
system.energy = mm.Zeeman(H=H)
system.dynamics = mm.Slonczewski(J=J, mp=mp, P=P, Lambda=Lambda,
eps_prime=eps_prime)
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
td = self.calculator.TimeDriver()
td.drive(system, t=0.2e-9, n=20)
# Check if it runs.
self.calculator.delete(system)
def setup(self):
mesh = df.Mesh(p1=(0, 0, 0), p2=(5, 5, 5), cell=(1, 1, 1))
field = df.Field(mesh, dim=1, value=5e-12)
self.valid_args = [1, 2.0, 5e-11, 1e6, {'a': 1, 'b': 1e-12}, field]
self.invalid_args = [-1, -2.1, 'a', (1, 2), -3.6e-6, '0',
[1, 2, 3], {'a': -1, 'b': 3}]
def test_write_wrong_file(self):
wrongfilename = 'test_file.jpg'
mesh = df.Mesh(p1=(0, 0, 0), p2=(10, 12, 13), cell=(1, 1, 1))
f = df.Field(mesh, dim=3, value=(1, 2, -5))
with pytest.raises(ValueError) as excinfo:
f.write(wrongfilename)
assert 'Allowed extensions' in str(excinfo.value)
def test_wrong_dim_field(self):
ovffilename = 'test_file.ovf'
mesh = df.Mesh(p1=(0, 0, 0), p2=(10, 12, 13), cell=(1, 1, 1))
f = df.Field(mesh, dim=2, value=(1, 2))
with pytest.raises(TypeError) as excinfo:
f.write(ovffilename)
assert 'Cannot write' in str(excinfo.value)
def test_set_m(self):
system = mm.System(name="test_sim")
system.m = df.Field(self.mesh, dim=3, value=(0, 0, 1))
assert isinstance(system.m, df.Field)
assert len(system.m.average) == 3
def test_single_values(self):
name = 'slonczewski_scalar_values'
J = 1e12
mp = (1, 0, 0)
P = 0.4
Lambda = 2
eps_prime = 0
H = (0, 0, 1e6)
Ms = 1e6
mesh = df.Mesh(region=self.region, n=self.n)
system = mm.System(name=name)
system.energy = mm.Zeeman(H=H)
system.dynamics = mm.Slonczewski(J=J, mp=mp, P=P, Lambda=Lambda,
eps_prime=eps_prime)
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
td = self.calculator.TimeDriver()
td.drive(system, t=0.2e-9, n=20)
# Check if it runs.
self.calculator.delete(system)
def test_outputstep(calculator):
name = 'output_step'
p1 = (0, 0, 0)
p2 = (5e-9, 5e-9, 5e-9)
n = (2, 2, 2)
Ms = 1e6
A = 1e-12
H = (0, 0, 1e6)
region = df.Region(p1=p1, p2=p2)
mesh = df.Mesh(region=region, n=n)
system = mm.System(name=name)
system.energy = mm.Exchange(A=A) + mm.Zeeman(H=H)
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
md = calculator.MinDriver()
md.drive(system, output_step=True)
dirname = os.path.join(name, 'drive-0')
assert os.path.exists(dirname)
assert len(system.table.data.index) > 1
calculator.delete(system)
def test_scalar_dict(self):
name = 'dynamics_scalar_dict'
H = (0, 0, 1e6)
gamma0 = 2.211e5
alpha = {'r1': 0, 'r2': 1}
Ms = 1e6
mesh = df.Mesh(region=self.region,
n=self.n,
subregions=self.subregions)
system = mm.System(name=name)
system.energy = mm.Zeeman(H=H)
system.dynamics = (mm.Precession(gamma0=gamma0) +
mm.Damping(alpha=alpha))
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
td = self.calculator.TimeDriver()
td.drive(system, t=0.2e-9, n=50)
# alpha=0 region
value = system.m((1e-9, -4e-9, 3e-9))
assert np.linalg.norm(np.cross(value, (0, 0, Ms))) > 1
# alpha!=0 region
value = system.m((1e-9, 4e-9, 3e-9))
assert np.linalg.norm(np.subtract(value, (0, 0, Ms))) < 1e-3
self.calculator.delete(system)
def test_dict(self):
name = 'precession_dict'
H = (0, 0, 1e6)
gamma0 = {'r1': 0, 'r2': 2.211e5}
Ms = 1e6
mesh = df.Mesh(region=self.region, n=self.n,
subregions=self.subregions)
system = mm.System(name=name)
system.energy = mm.Zeeman(H=H)
system.dynamics = mm.Precession(gamma0=gamma0)
system.m = df.Field(mesh, dim=3, value=(0, 0.1, 1), norm=Ms)
td = self.calculator.TimeDriver()
td.drive(system, t=0.2e-9, n=50)
# gamma=0 region
value = system.m((1e-9, -4e-9, 3e-9))
assert np.linalg.norm(np.cross(value, (0, 0.1*Ms, Ms))) < 1e-3
# gamma!=0 region
value = system.m((1e-9, 4e-9, 3e-9))
assert np.linalg.norm(np.cross(value, (0, 0.1*Ms, Ms))) > 1
self.calculator.delete(system)
