Merge pull request #126 from computationalmodelling/dmi-nn-working

Dmi nn working

Author: davidcortesortuno

.gitignore

@@ -6,8 +6,11 @@
 *.pdf
 *.tmp
 *.so
-/local/
-
+local/
+*~
+*.bak
+.DS_Store
+.pytest_cache/
 # ignore automatically generated cython files
 fidimag/atomistic/lib/clib.c
 fidimag/common/lib/common_clib.c

examples/micromagnetic/box_real_time/box_sim_fidimag.py

@@ -161,10 +161,10 @@ def run_from_ipython():
 if args.preview:
     if run_from_ipython():
         matplotlib.use('nbagg')
-        print 'Using Backend: NBAgg'
+        print('Using Backend: NBAgg')
     else:
         matplotlib.use('TkAgg')
-        print 'Using Backend: TkAgg'
+        print('Using Backend: TkAgg')
 
 import matplotlib.pyplot as plt
 from mpl_toolkits.axes_grid1 import make_axes_locatable
@@ -266,7 +266,7 @@ def irregular_state(pos):
                   unit_length=1e-9,
                   )
 else:
-    print 'Using Periodic Boundary Conditions!'
+    print('Using Periodic Boundary Conditions!')
     mesh = CuboidMesh(nx=nx,
                   ny=ny,
                   nz=nz,
@@ -307,7 +307,7 @@ def irregular_state(pos):
     sim.add(UniaxialAnisotropy(args.k_u, axis=(0, 0, 1)))
 
 if args.Demag:
-    print 'Using Demag!'
+    print('Using Demag!')
     sim.add(Demag())
 
 # -------------------------------------------------------------------------
@@ -344,20 +344,20 @@ def irregular_state(pos):
 
 
 # Debug Information -------------------------------------------------------
-print 'Simulating a {} x {} x {} box'.format(args.box_length,
+print(('Simulating a {} x {} x {} box'.format(args.box_length,
                                              args.box_width,
-                                             args.box_thickness)
-print 'Number of elements in x-y-z directions: ', nx, ny, nz
-print 'Finite differences size in x-y-z directions: ', dx, dy, dz
+                                             args.box_thickness)))
+print(('Number of elements in x-y-z directions: ', nx, ny, nz))
+print(('Finite differences size in x-y-z directions: ', dx, dy, dz))
 
-print 'Saturation Magnetisation: {} A / m'.format(args.Ms)
-print 'Exchange constant: {}  J m**-1'.format(args.A)
-print 'DMI constant: {} * 1e-3  J m**-2'.format(args.D)
+print(('Saturation Magnetisation: {} A / m'.format(args.Ms)))
+print(('Exchange constant: {}  J m**-1'.format(args.A)))
+print(('DMI constant: {} * 1e-3  J m**-2'.format(args.D)))
 if args.k_u:
-    print 'Anisotropy constant: {}  J m**-3'.format(args.k_u)
+    print(('Anisotropy constant: {}  J m**-3'.format(args.k_u)))
 if args.B:
-    print 'Zeeman field: (0, 0, {})  A / m'.format(args.B / mu0)
-print '--------------------------------------'
+    print(('Zeeman field: (0, 0, {})  A / m'.format(args.B / mu0)))
+print('--------------------------------------')
 
 # -------------------------------------------------------------------------
 
@@ -439,9 +439,9 @@ def irregular_state(pos):
     # Now run the simulation printing the energy
     for time in times:
         if not run_from_ipython():
-            print 'Time: ', time, ' s'
-            print 'Total energy: ', sim.compute_energy(), ' J'
-            print '\n'
+            print('Time: ', time, ' s')
+            print('Total energy: ', sim.compute_energy(), ' J')
+            print('\n')
         sim.run_until(time)
 
         # Update the vector data for the plot (the spins do not move

examples/micromagnetic/domain_wall_simple_demag/dw.py

@@ -89,7 +89,7 @@ def excite_system_K(mesh, Hx=2000):
 
     ts = np.linspace(0, 5e-9, 501)
     for t in ts:
-        print 'time', t
+        print('time', t)
         sim.run_until(t)
 
 def excite_system_D(mesh, Hx=2000):
@@ -123,7 +123,7 @@ def excite_system_D(mesh, Hx=2000):
 
     ts = np.linspace(0, 5e-9, 101)
     for t in ts:
-        print 'time', t
+        print('time', t)
         sim.run_until(t)
         #sim.save_vtk()
 

examples/micromagnetic/dw_stt/main.py

@@ -170,7 +170,7 @@ def excite_system(mesh):
     ts = np.linspace(0, 5e-9, 501)
 
     for t in ts:
-        print 'time', t
+        print('time', t)
         sim.driver.run_until(t)
         sim.save_vtk()
         sim.save_m()

examples/micromagnetic/skyrmion_stt/main.py

@@ -64,7 +64,7 @@ def excite_system(mesh):
 
     ts = np.linspace(0, 0.5e-9, 101)
     for t in ts:
-        print 'time', t
+        print('time', t)
         sim.run_until(t)
         sim.save_vtk()
         #sim.save_m()

examples/micromagnetic/vortex/main.py

@@ -101,8 +101,8 @@ def gaussian_fun(t):
     ts = np.linspace(0, 1e-9, 501)
 
     for t in ts:
-        print 'time', t
-        print 'length:', sim.spin_length()[0:200]
+        print('time', t)
+        print('length:', sim.spin_length()[0:200])
         sim.run_until(t)
         sim.save_vtk()
 

fidimag/atomistic/anisotropy.py

@@ -54,7 +54,7 @@ def setup(self, mesh, spin, mu_s, mu_s_inv):
         super(Anisotropy, self).setup(mesh, spin, mu_s, mu_s_inv)
 
         self._Ku = helper.init_scalar(self.Ku, self.mesh)
-        self._axis = helper.init_vector(self.axis, self.mesh, True)
+        self._axis = helper.init_vector(self.axis, self.mesh, norm=True)
 
     def compute_field(self, t=0, spin=None):
 

fidimag/atomistic/monte_carlo.py

@@ -81,7 +81,7 @@ def create_tablewriter(self):
         self.saver.update_entity_order()
 
     def set_m(self, m0=(1, 0, 0), normalise=True):
-        self.spin[:] = helper.init_vector(m0, self.mesh, normalise)
+        self.spin[:] = helper.init_vector(m0, self.mesh, norm=normalise)
 
         # TODO: carefully checking and requires to call set_mu first
 

fidimag/common/driver_base.py

@@ -193,8 +193,8 @@ def run_until(self, t):
         self.data_saver.save()
 
     def relax(self, dt=10e-12, stopping_dmdt=0.01, max_steps=1000,
-              save_m_steps=100, save_vtk_steps=100
-              ):
+              save_m_steps=100, save_vtk_steps=100,
+              printing=True):
         """
         Evolve the system until meeting the `dmdt` < `stopping_dmdt` criteria.
 
@@ -221,11 +221,12 @@ def relax(self, dt=10e-12, stopping_dmdt=0.01, max_steps=1000,
                 self.save_m()
 
             dmdt = self.compute_dmdt(_dt)
-            print("#{:<4} t={:<8.3g} dt={:.3g} max_dmdt={:.3g}".format(
-                self.step,  # incremented in self.run_until (called above)
-                self.t,
-                _dt,
-                dmdt / self._dmdt_factor))
+            if printing:
+                print("#{:<4} t={:<8.3g} dt={:.3g} max_dmdt={:.3g}".format(
+                    self.step,  # incremented in self.run_until (called above)
+                    self.t,
+                    _dt,
+                    dmdt / self._dmdt_factor))
             if dmdt < stopping_dmdt * self._dmdt_factor:
                 break
 

fidimag/common/gradient_descent.py

@@ -0,0 +1,121 @@
+from __future__ import division
+import numpy as np
+import fidimag.extensions.clib as clib
+# import fidimag.common.constant as const
+
+from .minimiser_base import MinimiserBase
+
+
+class GradientDescentMinimiser(MinimiserBase):
+    """
+    A simple minimisation algorithm, where the evolution of the magnetisation
+    follows the system's torque
+
+        CHECK:
+
+        h = (m_i + H) / || (m_i + H) ||
+        m_i+1 = m_i + alpha * (h_i - m_i)
+    """
+
+    def __init__(self, mesh, spin,
+                 magnetisation, magnetisation_inv, field, pins,
+                 interactions,
+                 name,
+                 data_saver,
+                 use_jac=False,
+                 integrator=None
+                 ):
+
+        # Inherit from the base minimiser class
+        super(SimpleMinimiser, self).__init__(mesh, spin,
+                                              magnetisation, magnetisation_inv,
+                                              field,
+                                              pins,
+                                              interactions,
+                                              name,
+                                              data_saver
+                                              )
+
+        self.t = 1e-4
+        self._alpha = 0.1
+        self._alpha_field = self._alpha * np.ones_like(self.spin)
+        self.spin_last = np.zeros_like(spin)
+        self._new_spin = np.zeros_like(spin)
+
+    @property
+    def alpha(self):
+        """
+        Returns the array with the spatially dependent Gilbert damping
+        per mesh/lattice site
+        """
+        return self._alpha
+
+    @alpha.setter
+    def set_alpha(self, value):
+        """
+        """
+        self._alpha = value
+        self._alpha_field =  value * np.ones_like(self.spin)
+
+    def run_step(self):
+
+        self.spin_last[:] = self.spin[:]
+        self.update_effective_field()
+
+        self._new_spin[self._material] = (self.spin + self.field)[self._material]
+        clib.normalise_spin(self._new_spin, self._pins, self.n)
+
+        self._new_spin[self._material] = (self.spin_last +
+                                          self._alpha_field * (self._new_spin - self.spin_last))[self._material]
+        self.spin[:] = self._new_spin[:]
+        clib.normalise_spin(self.spin, self._pins, self.n)
+
+    def minimise(self, stopping_dm=1e-2, max_steps=2000,
+                 save_data_steps=10, save_m_steps=None, save_vtk_steps=None,
+                 log_steps=1000
+                 ):
+        """
+
+        """
+
+        self.step = 0
+
+        # Only update site with magnetisation > 0 which are not pinned
+        self._material = np.logical_and(np.repeat(self._magnetisation, 3) > 0.0,
+                                        np.repeat(1 - self._pins, 3).astype(np.bool))
+
+        self.spin_last[:] = self.spin[:]
+        self.compute_effective_field()
+        while self.step < max_steps:
+
+            self.run_step()
+
+            max_dm = (self.spin - self.spin_last).reshape(-1, 3) ** 2
+            max_dm = np.max(np.sqrt(np.sum(max_dm, axis=1)))
+
+            if self.step % log_steps == 0:
+                print("#max_tau={:<8.3g} max_dm={:<10.3g} counter={}".format(
+                    np.max(np.abs(self.tau)),
+                    max_dm, self.step))
+
+            if max_dm < stopping_dm and self.step > 0:
+                print("FINISHED AT: max_tau={:<8.3g} max_dm={:<10.3g} counter={}".format(
+                      np.max(np.abs(self.tau)),
+                      max_dm, self.step))
+
+                self.compute_effective_field()
+                self.data_saver.save()
+
+                break
+
+            if self.step % save_data_steps == 0:
+                # update field before saving data
+                self.compute_effective_field()
+                self.data_saver.save()
+
+            if (save_vtk_steps is not None) and (self.step % save_vtk_steps == 0):
+                self.save_vtk()
+            if (save_m_steps is not None) and (self.step % save_m_steps == 0):
+                self.save_m()
+
+            self.step += 1