Merge remote-tracking branch 'origin/master' into nebm_spherical

Author: davidcorteso

.travis.yml

@@ -18,7 +18,7 @@ before_install:
   - export PATH=/home/travis/miniconda/bin:$PATH
 
 install:
-  - conda create -q -y -n fidimag-test python=$TRAVIS_PYTHON_VERSION cython matplotlib pytest scipy pytest-cov
+  - conda create -q -y -n fidimag-test python=$TRAVIS_PYTHON_VERSION cython matplotlib pytest scipy pytest-cov gcc
   - source activate fidimag-test
   - pip install pyvtk six nbval
   # Download and compile FFTW & Sundials locally

bin/ubuntu_install_script.sh

@@ -1,7 +1,25 @@
+echo "Super user authentication required to add packages (you will be \
+prompted for confirmation)."
 sudo bash install-ubuntu-packages.sh
 bash install-fftw.sh
 bash install-sundials-2.5.sh
 sudo pip install cython --upgrade
-cd ..
+pushd .. > /dev/null
 make
-echo "export PYTHONPATH=$(dirname $PWD):$PYTHONPATH" >> /home/$USER/.bashrc
+
+# Adds Fidimag environment variables to profile.d, if they're not already
+# there.
+FIDIMAG_PROFILE_PATH=/etc/profile.d/fidimag.sh
+if [ ! -e "$FIDIMAG_PROFILE_PATH" ]; then
+    echo "Warning: Adding Fidimag to path at $FIDIMAG_PROFILE_PATH."
+    echo "Super user authentication required to add paths."
+    sudo mkdir --parents "$(dirname $FIDIMAG_PROFILE_PATH)"
+    sudo bash -c "echo \"export PYTHONPATH=$PWD/:\\\$PYTHONPATH\"\
+> $FIDIMAG_PROFILE_PATH"
+    sudo bash -c "echo \"export LD_LIBRARY_PATH=$PWD/local/lib:\
+\\\$LD_LIBRARY_PATH\" >> $FIDIMAG_PROFILE_PATH"
+    sudo chmod 0644 "$FIDIMAG_PROFILE_PATH"
+    echo "Path written to $FIDIMAG_PROFILE_PATH."
+else
+    echo "Path added previously. Skipping."
+fi

fidimag/atomistic/llg.py

@@ -8,6 +8,7 @@
 from fidimag.common.fileio import DataSaver
 from fidimag.common.save_vtk import SaveVTK
 import fidimag.common.constant as const
+import fidimag.common.skyrmion_number
 
 
 class LLG(object):
@@ -17,7 +18,7 @@ def __init__(self, mesh, name='unnamed', use_jac=False):
         *Arguments*
           name : the Simulation name (used for writing data files, for examples)
         """
-
+        self._micromagnetic = False
         self.t = 0
         self.name = name
         self.mesh = mesh
@@ -335,6 +336,9 @@ def skyrmion_number(self, method='FiniteSpinChirality'):
 
         return number
 
+    skyrmion_number_slice = fidimag.common.skyrmion_number.skyrmion_number_slice
+    skyrmion_number_lee = fidimag.common.skyrmion_number.skyrmion_number_lee
+
     def spin_at(self, i, j, k):
         """
         Returns the spin components of the spin at

fidimag/common/cuboid_mesh.py

@@ -26,6 +26,8 @@
 in the innermost loop, and the z-axis in the outermost loop!
 
 """
+from __future__ import print_function
+import os
 import numpy as np
 from textwrap import dedent
 from six.moves import range
@@ -69,6 +71,7 @@ def __init__(self, dx=1, dy=1, dz=1, nx=1, ny=1, nz=1, x0=0, y0=0, z0=0,
         self.n = nx * ny * nz  # total number of cells
         self.nxy = nx * ny  # number of cells in the x-y plane
         self.size = (nx, ny, nz)
+        self.check_size()
 
         self.mesh_type = "cuboid"
         self.unit_length = unit_length
@@ -258,3 +261,25 @@ def vertices(self, origin=(0, 0, 0)):
                     grid[i] = (x, y, z)
                     i += 1
         return grid
+
+    def check_size(self, system_memory_fake_for_testing=None):
+        """
+        Provide an estimate of how much system memory is needed and warn accordingly.
+
+        """
+        bytes_per_float_numpy = 8
+        size_coordinates_bytes = self.nx * self.ny * self.nz * 3 * bytes_per_float_numpy
+        size_coordinates_GiB = size_coordinates_bytes / (1024. ** 3)
+
+        if system_memory_fake_for_testing is None:
+            mem_bytes = os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES')
+            mem_GiB = mem_bytes / (1024. ** 3)
+        else:
+            mem_GiB = system_memory_fake_for_testing
+
+        if 2 * size_coordinates_GiB > mem_GiB:
+            # print because no logging yet
+            print("Warning! Size of mesh coordinates i {} GiB.".format(size_coordinates_GiB))
+            print("You have {} GiB system memory. Possible halt.".format(mem_GiB))
+            return 1
+        return 0

fidimag/common/cuboid_mesh_test.py

@@ -242,3 +242,8 @@ def test_vector_field_shape():
     expected_shape_for_vector_field = (expected_nb_cells, 3)
     assert mesh.vector_shape() == expected_shape_for_vector_field
     m = np.zeros(mesh.vector_shape())  # usage example
+
+
+def test_check_size():
+    mesh = CuboidMesh(1, 1, 1, 2, 3, 4)
+    assert 1 == mesh.check_size(system_memory_fake_for_testing=0)

fidimag/common/skyrmion_number.py

@@ -0,0 +1,113 @@
+import fidimag.extensions.clib
+import fidimag.extensions.micro_clib
+import numpy as np
+
+
+def skyrmion_number_slice(sim, at=None, zIndex=None):
+    """
+    Returns the skyrmion number calculated on the x-y plane at a specific z
+    co-ordinate.
+
+    The current fidimag skyrmion number function finds the skyrmion number for
+    the first z co-ordinate in index order (unintentionally?). So the approach
+    this function uses is to slice the spin array in the simulation object to
+    only include the x-y plane as previously described.
+
+    Arguments:
+      sim: LLG object with cuboidal mesh.
+
+    Optional Arguments:
+      If neither of these arguments are specified, this function raises a
+      ValueError.
+
+      at: None, "top", "centre", or "bottom" denoting where to slice in
+          British English. https://en.wikipedia.org/wiki/Strike_It_Lucky
+      zIndex: Integer (not a float), or None denoting the index at which to
+          slice. Overrides "at" if not None. Bound by zIndex~[0, sim.mesh.nz-1]
+
+    Returns:
+      skyrmionNumber (a float)
+    """
+
+    # Deal with inputs.
+    if zIndex is None:
+        if at is "bottom":
+            zIndex = 0
+
+        elif at is "centre":
+            # Find the layer number that corresponds to the centre of the mesh,
+            # preferring the lower layer in a tie.
+            zIndex = sim.mesh.nz / 2.
+            if sim.mesh.nz % 2 == 0:
+                zIndex -= 0.5
+            zIndex -= 0.5
+
+        elif at is "top":
+            zIndex = sim.mesh.nz - 1  # Indeces start at 0.
+
+        else:
+            raise ValueError("[skyrmion_number_slice]: Either "
+                             "'at=bottom|centre|top' or 'zIndex'=[integer] "
+                             "must be passed as arguments.")
+
+    elif zIndex > sim.mesh.nz - 1 or zIndex < 0:
+        raise ValueError("[skyrmion_number_slice]: 'zIndex={}' must be an "
+                         "integer between 0 and sim.mesh.nz - 1, which is "
+                         "'{}' for this simulation object."
+                         .format(zIndex, sim.mesh.nz - 1))
+
+    # Find the "length" of a slice in terms of the spin array.
+    xyLength = sim.mesh.nx * sim.mesh.ny * 3  # The 3 represents (x,y,z).
+
+    # Obtain slice of spins cleverly. This also works if the domain is flat
+    # (i.e. nz=1, zIndex=0)
+    spinSlice = sim.spin[int(xyLength * zIndex):int(xyLength * (zIndex + 1))]
+
+    # Compute the skyrmion number for our spin slice.
+    if sim._micromagnetic is True:
+        return fidimag.extensions.micro_clib.compute_skyrmion_number(\
+               spinSlice, sim._skx_number, sim.mesh.nx, sim.mesh.ny,
+               sim.mesh.nz, sim.mesh.neighbours)
+    else:
+        return fidimag.extensions.clib.compute_skyrmion_number(\
+               spinSlice, sim._skx_number, sim.mesh.nx, sim.mesh.ny,
+               sim.mesh.nz, sim.mesh.neighbours)
+
+
+def skyrmion_number_lee(sim):
+    """
+    Returns the skyrmion number calculated from a 3D sample, as defined in:
+
+    Lee, M, Kang, W, Onose, Y, et. al (2009) "Unusual Hall effect anomaly in
+    MnSi under pressure". PRL.
+
+    Arguments:
+      sim: LLG object with cuboidal mesh.
+
+    Returns:
+      skyrmionNumber (a float)
+    """
+
+    # Find the "length" of a slice in terms of the spin array.
+    xyLength = sim.mesh.nx * sim.mesh.ny * 3  # The 3 represents (x, y, z).
+
+    # Create an array to store skyrmion number values for each z slice.
+    skyrmionNumbers = np.ndarray(sim.mesh.nz)
+
+    # For each slice, compute the skyrmion number.
+    for zI in range(len(skyrmionNumbers)):
+        spinSlice = sim.spin[xyLength * zI:xyLength * (zI + 1)]
+
+        if sim._micromagnetic is True:
+            skyrmionNumbers[zI] = fidimag.extensions.micro_clib.compute_skyrmion_number(\
+                                  spinSlice, sim._skx_number, sim.mesh.nx,
+                                  sim.mesh.ny, sim.mesh.nz,
+                                  sim.mesh.neighbours)
+        else:
+            skyrmionNumbers[zI] = fidimag.extensions.clib.compute_skyrmion_number(\
+                                  spinSlice, sim._skx_number, sim.mesh.nx,
+                                  sim.mesh.ny, sim.mesh.nz,
+                                  sim.mesh.neighbours)
+
+    # Return the average. This is equivalent to the integral in the equation.
+    return skyrmionNumbers.mean()