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 run_finmag(demagsolver):
"""Run the finmag simulation and store data in (demagsolvertype)averages.txt."""
sim = Sim(mesh, Ms, unit_length=unit_length)
sim.alpha = 0.5
sim.set_m((1, 0, 1))
exchange = Exchange(13.0e-12)
sim.add(exchange)
demag = Demag(solver=demagsolver)
sim.add(demag)
fh = open(os.path.join(MODULE_DIR, demagsolver + "averages.txt"), "w")
fe = open(os.path.join(MODULE_DIR, demagsolver + "energies.txt"), "w")
# Progressbar
bar = pb.ProgressBar(maxval=60, \
widgets=[pb.ETA(), pb.Bar('=', '[', ']'), ' ', pb.Percentage()])
logger.info("Time integration")
times = np.linspace(0, 3.0e-10, 61)
#times = np.linspace(0, 3.0e-10, 100000)
for counter, t in enumerate(times):
bar.update(counter)
# Integrate
sim.run_until(t)
print counter
print("press return to continue")
_ = raw_input()
# Save averages to file
mx, my, mz = sim.m_average
fh.write(str(t) + " " + str(mx) + " " + str(my) + " " + str(mz) + "\n")
# Energies
E_e = exchange.compute_energy()
E_d = demag.compute_energy()
fe.write(str(E_e) + " " + str(E_d) + "\n")
# Energy densities
if counter == 10:
exch_energy = exchange.energy_density_function()
demag_energy = demag.demag.energy_density_function()
finmag_exch, finmag_demag = [], []
R = range(100)
for i in R:
finmag_exch.append(exch_energy([15, 15, i]))
finmag_demag.append(demag_energy([15, 15, i]))
# Store data
np.save(
os.path.join(MODULE_DIR,
"finmag%s_exch_density.npy" % demagsolver),
np.array(finmag_exch))
np.save(
os.path.join(MODULE_DIR,
"finmag%s_demag_density.npy" % demagsolver),
np.array(finmag_demag))
fh.close()
fe.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 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 run_finmag():
"""Run the finmag simulation and store data in averages.txt."""
sim = Sim(mesh, Ms, unit_length=unit_length)
sim.alpha = 0.5
sim.set_m((1, 0, 1))
exchange = Exchange(13.0e-12)
sim.add(exchange)
demag = Demag(solver="FK")
sim.add(demag)
fh = open(os.path.join(MODULE_DIR, "averages.txt"), "w")
fe = open(os.path.join(MODULE_DIR, "energies.txt"), "w")
logger.info("Time integration")
times = np.linspace(0, 3.0e-10, 61)
for counter, t in enumerate(times):
# Integrate
sim.run_until(t)
# Save averages to file
mx, my, mz = sim.m_average
fh.write(str(t) + " " + str(mx) + " " + str(my) + " " + str(mz) + "\n")
# Energies
E_e = exchange.compute_energy()
E_d = demag.compute_energy()
fe.write(str(E_e) + " " + str(E_d) + "\n")
# Energy densities
if counter == 10:
exch_energy = exchange.energy_density_function()
demag_energy = demag.energy_density_function()
finmag_exch, finmag_demag = [], []
R = range(100)
for i in R:
finmag_exch.append(exch_energy([15, 15, i]))
finmag_demag.append(demag_energy([15, 15, i]))
# Store data
np.save(os.path.join(MODULE_DIR, "finmag_exch_density.npy"),
np.array(finmag_exch))
np.save(os.path.join(MODULE_DIR, "finmag_demag_density.npy"),
np.array(finmag_demag))
fh.close()
fe.close()
def test_exchange_energy_analytical(fixt):
"""
Compare one Exchange energy with the corresponding analytical result.
"""
REL_TOLERANCE = 1e-7
A = 1
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(("x[0]", "x[2]", "-x[1]"), degree=1))
exch = Exchange(A)
exch.setup(m, Ms)
E = exch.compute_energy()
# integrating the vector laplacian, the latter gives 3 already
expected_E = 3
print "With m = (0, sqrt(1-x^2), x), " + \
"expecting E = {}. Got E = {}.".format(expected_E, E)
assert abs(E - expected_E) / expected_E < REL_TOLERANCE
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 test_exchange_energy_density():
"""
Compare solution with nmag for now. Should derive the
analytical solution here as well.
Our initial magnetisation looks like this:
^ ~
| / ---> \ | (Hahahaha! :-D)
~ v
"""
TOL = 1e-7 # Should be lower when comparing with analytical solution
MODULE_DIR = os.path.dirname(os.path.abspath(__file__))
# run nmag
cmd = "nsim %s --clean" % os.path.join(MODULE_DIR, "run_nmag_Eexch.py")
status, output = commands.getstatusoutput(cmd)
if status != 0:
print output
sys.exit("Error %d: Running %s failed." % (status, cmd))
nmag_data = np.loadtxt(
os.path.join(MODULE_DIR, "nmag_exchange_energy_density.txt"))
# run finmag
mesh = df.IntervalMesh(100, 0, 10e-9)
S3 = df.VectorFunctionSpace(mesh, "Lagrange", 1, dim=3)
Ms = 42
m = Field(S3,
value=df.Expression(
("cos(x[0]*pi/10e-9)", "sin(x[0]*pi/10e-9)", "0"), degree=1))
exch = Exchange(1.3e-11)
Ms_field = Field(df.FunctionSpace(mesh, 'DG', 0), Ms)
exch.setup(m, Ms_field)
finmag_data = exch.energy_density()
rel_err = np.abs(nmag_data - finmag_data) / np.linalg.norm(nmag_data)
print("Nmag data = %g" % nmag_data[0])
print("Finmag data = %g" % finmag_data[0])
print "Relative error from nmag data (expect array of 0):"
print rel_err
print "Max relative error:", np.max(rel_err)
assert np.max(rel_err) < TOL, \
"Max relative error is %g, should be zero." % np.max(rel_err)
print("Work out average energy density and energy")
S1 = df.VectorFunctionSpace(mesh, "Lagrange", 1, dim=1)
# only approximative -- using assemble would be better
average_energy_density = np.average(finmag_data)
w = df.TestFunction(S1)
vol = sum(df.assemble(df.dot(df.Constant([1]), w) * df.dx))
# finmag 'manually' computed, based on node values of energy density:
energy1 = average_energy_density * vol
# finmag computed by energy class
energy2 = exch.compute_energy()
# comparison with Nmag
energy3 = np.average(nmag_data) * vol
print energy1, energy2, energy3
assert abs(energy1 - energy2) < 1e-12 # actual value is 0, but
# that must be pure luck.
assert abs(energy1 - energy3) < 5e-8 # actual value
