Add more documentation, a test and timing code in the test_time_zeeman.py file.

Author: rpep

fidimag/common/lib/common_clib.pyx

@@ -212,7 +212,7 @@ def init_vector_func_fast(m0, mesh, double[:] field, norm=False, *args):
     must handle evaluating the function at different
     coordinate points. It needs to be able to handle
     the spatial dependence itself, and write the
-    field valuse into the field array. This can 
+    field valuse into the field array. This can
     be written with Cython which will give much
     better performance. For example:
 
@@ -225,8 +225,7 @@ def init_vector_func_fast(m0, mesh, double[:] field, norm=False, *args):
             field[3*i+1] = Bmax * axis[1] * sin(fc*t)
             field[3*i+2] = Bmax * axis[2] * sin(fc*t)
 
-    """
-    # field = np.zeros(mesh.n * 3)
+    """  
     m0(mesh, field, *args)
     if norm:
         normalise(field)

fidimag/micro/__init__.py

@@ -2,7 +2,7 @@
 from .demag import Demag
 from .exchange import UniformExchange
 from .exchange_rkky import ExchangeRKKY
-from .zeeman import Zeeman, TimeZeeman, SimpleTimeZeeman, TimeZeemanFast
+from .zeeman import Zeeman, TimeZeeman, TimeZeemanSimple, TimeZeemanFast
 from .anisotropy import UniaxialAnisotropy
 from .dmi import DMI
 from .baryakhtar import LLBar, LLBarFull

fidimag/micro/zeeman.py

@@ -1,5 +1,4 @@
 import numpy as np
-
 from fidimag.common.constant import mu_0
 import fidimag.common.helper as helper
 import inspect
@@ -113,7 +112,6 @@ def compute_energy(self):
 
 
 class TimeZeeman(Zeeman):
-
     """
     The time dependent external field, also can vary with space
 
@@ -127,13 +125,31 @@ def time_fun(pos, t):
         Bz = ...
         return (Bx, By, Bz)
 
+    Extra arguments can be passed to the function to allow more
+    general code. These must be set when initialising the TimeZeeman class. For
+    example:
+
+    freq = 10e9
+
+    def time_fun(pos, t, frequency):
+        x, y, z = pos
+        if x < 50:
+            return (0.0, 0.0, np.sin(frequency*t))
+        else:
+            return (0.0, 0.0, 0.0)
+
+    zee = TimeZeeman(time_fun, extra_args=[freq])
+
+    These arguments are then passed into the time_fun code function in
+    order.
 
     """
 
-    def __init__(self, time_fun, name='TimeZeeman'):
+    def __init__(self, time_fun, extra_args=[], name='TimeZeeman'):
         self.time_fun = time_fun
         self.name = name
         self.jac = True
+        self.extra_args = extra_args
 
     def setup(self, mesh, spin, Ms):
         self.mesh = mesh
@@ -154,19 +170,19 @@ def setup(self, mesh, spin, Ms):
         self.field = np.zeros(3 * self.n)
 
     def compute_field(self, t=0, spin=None):
-        self.field[:] = helper.init_vector_func_fast(self.time_fun,
-                                                     self.mesh,
-                                                     False,
-                                                     t)
+        self.field[:] = helper.init_vector(self.time_fun,
+                                           self.mesh,
+                                           False,
+                                           t, *self.extra_args)
         return self.field
 
 
-class SimpleTimeZeeman(Zeeman):
+class TimeZeemanSimple(Zeeman):
 
     """
-    The time dependent external field, also can vary with space
+    Time Dependent Zeeman Interaction with no spatial dependence.
 
-    The function time_fun must be a function which takes two arguments:
+    The function time_fun must be a function which takes one argument:
 
     def time_fun(t):
         x, y, z = pos
@@ -177,13 +193,29 @@ def time_fun(t):
         return (Bx, By, Bz)
 
 
+    Extra arguments can be passed to the function to allow more
+    general code. These must be set when initialising the TimeZeeman class. For
+    example:
+
+    freq = 10e9
+
+    def time_fun(t, frequency):
+        return (0.0, 0.0, np.sin(frequency*t))
+
+    zee = SimpleTimeZeeman(time_fun, extra_args=[freq])
+
+    These arguments are then passed into the time_fun code function in
+    order.
+
+
     """
 
-    def __init__(self, time_fun, name='TimeZeeman'):
+    def __init__(self, time_fun, extra_args=[], name='TimeZeemanFast'):
         self.time_fun = time_fun
         self.name = name
         self.jac = True
         self._v = np.zeros(3)
+        self.extra_args = extra_args
 
     def setup(self, mesh, spin, Ms):
         self.mesh = mesh
@@ -204,7 +236,7 @@ def setup(self, mesh, spin, Ms):
         self.field = np.zeros(3 * self.n)
 
     def compute_field(self, t=0, spin=None):
-        v = self.time_fun(t)
+        v = self.time_fun(t, *self.extra_args)
         self.field[0::3] = v[0]
         self.field[1::3] = v[1]
         self.field[2::3] = v[2]
@@ -215,24 +247,32 @@ def compute_field(self, t=0, spin=None):
 class TimeZeemanFast(Zeeman):
 
     """
-    The time dependent external field, also can vary with space
+    The time dependent external field, also can vary with space. This uses
+    an unsafe setting function. Should not be used except by advanced users.
 
-    The function time_fun must be a function which takes two arguments:
+    The function must handle coordinates
 
-    def time_fun(mesh, t):
-        x, y, z = pos
-        # compute Bx, By, Bz as a function of x y, z and t.
-        Bx = ...
-        By = ...
-        Bz = ...
-        return (Bx, By, Bz)
+    The function time_fun must be a function which takes three or more arguments. The time variable is always passed in as the first argument
+    in params.
 
-    Add the function to the user modules and recompile.
+    e.g.
+
+    from libc.math cimport sin
+
+    def fast_sin_init(mesh, double[:] field, *params):
+        t, axis, Bmax, fc = params
+        for i in range(mesh.n):
+            x, y, z = mesh.coordinates[i]
+            if x < 10:
+                field[3*i+0] = Bmax * axis[0] * sin(fc*t)
+                field[3*i+1] = Bmax * axis[1] * sin(fc*t)
+                field[3*i+2] = Bmax * axis[2] * sin(fc*t)
 
+    Add the function to a user Cython module in fidimag/user/ and recompile.
 
     """
 
-    def __init__(self, time_fun, extra_args, name='TimeZeeman'):
+    def __init__(self, time_fun, extra_args=[], name='TimeZeemanFast'):
         self.time_fun = time_fun
         self.name = name
         self.jac = True

fidimag/user/example/__init__.py

@@ -0,0 +1 @@
+from fidimag.extensions.user.example import *

fidimag/user/example/example.pyx

@@ -0,0 +1,16 @@
+from libc.math cimport cos, sin
+
+def fast_sin_init(mesh, double[:] field, *params):
+    t, axis, Bmax, fc = params
+    for i in range(mesh.n):
+        field[3*i+0] = Bmax * axis[0] * sin(fc*t)
+        field[3*i+1] = Bmax * axis[1] * sin(fc*t)
+        field[3*i+2] = Bmax * axis[2] * sin(fc*t)
+
+def TimeZeemanFast_test_time_fun(mesh, double[:] field, *params):
+    cdef int i
+    t, frequency = params
+    for i in range(mesh.n):
+        field[3*i+0] = 0
+        field[3*i+1] = 0
+        field[3*i+2] = 10 * cos(frequency * t)

tests/test_time_zeeman.py

@@ -0,0 +1,101 @@
+import numpy as np
+from fidimag.common import CuboidMesh
+from fidimag.micro import TimeZeeman, TimeZeemanSimple, TimeZeemanFast
+from fidimag.user.example import TimeZeemanFast_test_time_fun
+
+
+def time_fun_spatial(pos, t, frequency):
+   return (0.0, 0.0, 10*np.cos(frequency*t))
+
+def time_fun(t, frequency):
+   return (0.0, 0.0, 10*np.cos(frequency*t))
+
+
+
+def fixture_setup(nx, ny, nz):
+    """
+    Fixtures for the tests
+    """
+    dx = 10.0/nx
+    spin = np.zeros(3*nx*ny*nz)
+    Ms = np.zeros(nx*ny*nz)
+    mesh = CuboidMesh(nx=nx, ny=ny, nz=nz, dx=dx, dy=1, dz=1, unit_length=1e-9)
+    frequency = 10e9
+    return mesh, frequency, spin, Ms
+
+
+def test_TimeZeeman():
+    mesh, frequency, spin, Ms = fixture_setup(10, 10, 10)
+    zee = TimeZeeman(time_fun_spatial, extra_args=[frequency])
+    zee.setup(mesh, spin, Ms)
+    field1 = zee.compute_field(t=0)
+    assert field1[0] == 0
+    assert field1[1] == 0
+    assert field1[2] == 10
+
+    field2 = zee.compute_field(t=1)
+    assert field2[0] == 0
+    assert field2[1] == 0
+    assert field2[2] == 10*np.cos(frequency)
+
+def test_TimeZeemanSimple():
+    mesh, frequency, spin, Ms = fixture_setup(10, 10, 10)
+    zee = TimeZeemanSimple(time_fun, extra_args=[frequency])
+    zee.setup(mesh, spin, Ms)
+    field1 = zee.compute_field(t=0)
+    assert field1[0] == 0
+    assert field1[1] == 0
+    assert field1[2] == 10
+
+    field2 = zee.compute_field(t=1)
+    assert field2[0] == 0
+    assert field2[1] == 0
+    assert field2[2] == 10*np.cos(frequency)
+
+def test_TimeZeemanFast():
+    mesh, frequency, spin, Ms = fixture_setup(10, 10, 10)
+    zee = TimeZeemanFast(TimeZeemanFast_test_time_fun, extra_args=[frequency])
+    zee.setup(mesh, spin, Ms)
+    field1 = zee.compute_field(t=0)
+    assert field1[0] == 0
+    assert field1[1] == 0
+    assert field1[2] == 10
+
+    field2 = zee.compute_field(t=1)
+    assert field2[0] == 0
+    assert field2[1] == 0
+    assert field2[2] == 10*np.cos(frequency)
+
+if __name__ == "__main__":
+    import time
+    # Run the speed tests...
+    for i in range(1, 5):
+        nx = 10**i
+        ny = nz = 10
+        print('\nN = {} * {} * {} = '.format(nx, ny, nz,  nx*ny*nz))
+        mesh, frequency, spin, Ms = setup(nx, ny, nz)
+
+        zee = TimeZeeman(time_fun_spatial, extra_args=[frequency])
+        zee.setup(mesh, spin, Ms)
+        t1 = time.time()
+        field1 = zee.compute_field(t=0)
+        field2 = zee.compute_field(t=1)
+        t2 = time.time()
+        print('  Timing results for TimeZeeman = {}'.format(t2 - t1))
+
+        zee = TimeZeemanSimple(time_fun, extra_args=[frequency])
+        zee.setup(mesh, spin, Ms)
+        t3 = time.time()
+        field1 = zee.compute_field(t=0)
+        field2 = zee.compute_field(t=1)
+        t4 = time.time()
+        print('  Timing results for TimeZeemanSimple = {}'.format(t4 - t3))
+
+        zee = TimeZeemanFast(TimeZeemanFast_test_time_fun, extra_args=[frequency])
+        zee.setup(mesh, spin, Ms)
+        t5 = time.time()
+        field1 = zee.compute_field(t=0)
+        field2 = zee.compute_field(t=1)
+        t6 = time.time()
+        print('  Timing results for TimeZeemanFast = {}'.format(t6 - t5))
+        print('\n  Normalised: TimeZeeman = 1, TimeZeemanSimple = {}, TimeZeemanFast = {}'.format((t4-t3)/(t2-t1), (t6-t5)/(t2-t1)))