Merge branch 'master' of github.com:computationalmodelling/fidimag

Author: fangohr

bin/install-scikit-odes.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -e
+
+# This script installs the python bindings to SUNDIALS called scikit ODES.
+# It requires SUNDIALS 2.6.2 to be installed.
+
+echo "Installing dependencies."
+sudo apt-get install python-dev
+sudo pip install scipy numpy cython enum34
+
+HERE_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+FIDIMAG_DIR="$(dirname "$HERE_DIR")"
+LIBS_DIR=${FIDIMAG_DIR}/local
+
+echo "Downloading ODES to "${LIBS_DIR}"."
+mkdir -p ${LIBS_DIR}
+cd ${LIBS_DIR}
+
+git clone git://github.com/bmcage/odes.git odes
+cd odes
+
+# Paths to SUNDIALS are hardcoded in odes/scikits/odes/sundials/setup.py.
+# The README recommends to edit that file if you want to change the paths...
+
+sed -i \
+    "s|LIB_DIRS_SUNDIALS  = \[base_path\,|LIB_DIRS_SUNDIALS = [base_path, '${LIBS_DIR}\/lib',|g" \
+    scikits/odes/sundials/setup.py
+
+python setup.py build
+sudo python setup.py install
+
+cd ${HERE_DIR}

bin/install-sundials.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+set -e
+
+# This script installs any SUNDIALS version starting with version 2.6.0
+# when SUNDIALS moved to a CMake-based installation. Will install locally.
+# It may need environment variables to work, like `export CC=gcc` in ARCHER.
+
+SUNDIALS=sundials-2.6.2
+
+# Make sure CMake is installed, since SUNDIALS requires it.
+which cmake > /dev/null
+if [ $? -eq 0 ]
+then
+    echo "Found CMake."
+else
+    echo "CMake required to build SUNDIALS. Installing."
+    sudo apt-get install cmake
+fi
+
+HERE_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+FIDIMAG_DIR="$(dirname "$HERE_DIR")"
+LIBS_DIR=${FIDIMAG_DIR}/local
+
+echo "Will install SUNDIALS to "${LIBS_DIR}" using CC="${CC}"."
+mkdir -p ${LIBS_DIR}
+cd ${LIBS_DIR}
+
+download_and_cmake_install() {
+    # $1 name of the package
+    # $2 URL where ${1}.tar.gz can be obtained
+    # $3 configure options
+    if [ ! -e ${1}.tar.gz ]; then
+        echo "Downloading "${1}"."
+        wget -q ${2}/${1}.tar.gz
+    fi;
+
+    if [ ! -e ${1} ]; then
+        tar -xzf ${1}.tar.gz
+
+        echo "Configuring "${1}"."
+        mkdir ${1}_build
+        cd ${1}_build
+        cmake ${3} ../${1}
+
+        echo "Compiling and installing "${1}"."
+        {
+            make
+            make install
+        } > /dev/null
+
+        echo "Cleaning up."
+        cd ..
+        rm -rf ${1}
+        rm -rf ${1}_build
+
+        cd ${HERE_DIR}
+        echo "Done."
+    fi;
+}
+
+download_and_cmake_install \
+    ${SUNDIALS} \
+    http://computation.llnl.gov/projects/sundials-suite-nonlinear-differential-algebraic-equation-solvers/download \
+    "-DBUILD_STATIC_LIBS=OFF -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX="${LIBS_DIR}" -DEXAMPLES_ENABLE=OFF -DLAPACK_ENABLE=ON -DOPENMP_ENABLE=ON"

doc/ipynb/1d_domain_wall.ipynb

@@ -79,41 +79,10 @@ void compute_guiding_center(double *spin, int nx, int ny, int nz, double *res);
 void compute_px_py_c(double *spin, int nx, int ny, int nz,
                      double *px, double *py);
 
+//======================================================================
 
-//=========================================================
-//=========================================================
-//used for sode
-typedef struct {
-	int n;
+void llg_rhs_dw_c(double *m, double *h, double *dm, double *T, double *alpha, 
+                  double *mu_s_inv, int *pins, double *eta, int n, double gamma, double dt);
 
-	double dt;
-	double T;
-	double gamma;
-	double *mu_s;
-	double coeff;
-	double Q;
-
-	double theta;
-	double theta1;
-	double theta2;
-
-	double *dm1;
-	double *dm2;
-	double *eta;
-
-} ode_solver;
-
-void init_solver(ode_solver *s, double k_B, double theta,
-                 int n, double dt, double gamma);
-
-ode_solver *create_ode_plan(void);
-
-void finalize_ode_plan(ode_solver *plan);
-
-void run_step1(ode_solver *s, double *m, double *h, double *m_pred, double *T,
-		double *alpha, double *mu_s_inv, int *pins);
-
-void run_step2(ode_solver *s, double *m_pred, double *h, double *m, double *T,
-		double *alpha, double *mu_s_inv, int *pins);
 
 #endif

doc/ipynb/tutorial-basics.ipynb

@@ -4,8 +4,8 @@ np.import_array()
 
 
 cdef extern from "clib.h":
-
-    void gauss_random_vec_with_init(double *x, int n)
+    void initial_random(int seed)
+    void gauss_random_vec(double *x, int n)
 
     double skyrmion_number(double *spin, double *charge,
                            int nx, int ny, int nz, int *ngbs)
@@ -70,32 +70,7 @@ cdef extern from "clib.h":
 			      double *alpha, int *pins, double *a_J, double beta, double gamma, int n)
 
     # used for sllg
-    ctypedef struct ode_solver:
-        pass
-
-    ode_solver *create_ode_plan()
-
-    void init_solver(ode_solver *s, double k_B, double theta,
-                     int n, double dt, double gamma)
-
-    void finalize_ode_plan(ode_solver *plan)
-
-    void run_step1(ode_solver *s, double *m, double *h,
-                   double *m_pred, double *T, double *alpha,
-                   double *mu_s_inv, int *pins)
-
-    void run_step2(ode_solver *s, double *m_pred,
-                   double *h, double *m, double *T,
-                   double *alpha, double *mu_s_inv, int *pins)
-
-def random_number(np.ndarray[double, ndim=1, mode="c"] v):
-    cdef int n = len(v)
-
-
-    print n
-
-    gauss_random_vec_with_init(&v[0], n)
-
+    void llg_rhs_dw_c(double *m, double *h, double *dm, double *T, double *alpha, double *mu_s_inv, int *pins, double *eta, int n, double gamma, double dt)
 
 
 def compute_skyrmion_number(np.ndarray[double, ndim=1, mode="c"] spin,
@@ -273,87 +248,22 @@ def normalise_spin(np.ndarray[double, ndim=1, mode="c"] spin, n):
     normalise(&spin[0], n)
 
 
+def init_random(seed):
+    initial_random(seed);
 
-cdef class RK2S(object):
-    cdef ode_solver * _c_plan
-    cdef double dt
-    cdef update_fun
-    cdef np.ndarray pred_m
-    cdef np.ndarray field
-    cdef np.ndarray mu_s_inv
-    cdef np.ndarray T
-    cdef np.ndarray alpha
-    cdef np.ndarray pins
+def random_number_array(np.ndarray[double, ndim=1, mode="c"] v):
+    
+    cdef int n = len(v)
 
-    cdef public double t
-    cdef public int step
-    cdef public np.ndarray y
+    gauss_random_vec(&v[0], n)
 
-    def __cinit__(self,dt,n,gamma,k_B,theta,
-                            np.ndarray[double, ndim=1, mode="c"] mu_s_inv,
-                            np.ndarray[double, ndim=1, mode="c"] alpha,
-                            np.ndarray[double, ndim=1, mode="c"] spin,
-                            np.ndarray[double, ndim=1, mode="c"] field,
-                            np.ndarray[double, ndim=1, mode="c"] T,
-                            np.ndarray[int, ndim=1, mode="c"] pins,
-                            update_fun):
-
-        self.t = 0
-        self.step = 0
-        self.dt = dt
-
-        self.update_fun = update_fun
-        self.mu_s_inv = mu_s_inv
-        self.field = field
-        self.T = T
-        self.alpha = alpha
-        self.pins = pins
-        self.pred_m = numpy.zeros(3*n,dtype=numpy.float)
-        self.y = numpy.zeros(3*n,dtype=numpy.float)
-
-
-        self._c_plan = create_ode_plan()
-        if self._c_plan is NULL:
-            raise MemoryError()
-
-        init_solver(self._c_plan,k_B,theta,n,dt,gamma)
-
-    def __dealloc__(self):
-        if self._c_plan is not NULL:
-            finalize_ode_plan(self._c_plan)
-            self._c_plan = NULL
-    
-    def set_initial_value(self,np.ndarray[double, ndim=1, mode="c"] spin, t):
-        self.t = t
-        self.y[:] = spin[:]
-
-    def successful(self):
-        #print self.spin
-        return True
-
-    def run_step(self):
-        cdef np.ndarray[double, ndim=1, mode="c"] y=self.y
-        cdef np.ndarray[double, ndim=1, mode="c"] field=self.field
-        cdef np.ndarray[double, ndim=1, mode="c"] pred_m=self.pred_m
-        cdef np.ndarray[double, ndim=1, mode="c"] T=self.T
-        cdef np.ndarray[double, ndim=1, mode="c"] alpha=self.alpha
-        cdef np.ndarray[double, ndim=1, mode="c"] mu_s_inv=self.mu_s_inv
-        cdef np.ndarray[int, ndim=1, mode="c"] pins = self.pins
-
-        #print "from cython1", self.spin,self.field,self.pred_m
-        self.update_fun(self.y, self.t)
-        run_step1(self._c_plan, &y[0], &field[0], &pred_m[0],
-                  &T[0], &alpha[0], &mu_s_inv[0], &pins[0])
-
-        self.step += 1
-        self.t = self.step * self.dt
-
-        self.update_fun(self.pred_m, self.t)
-        run_step2(self._c_plan, &pred_m[0], &field[0],
-                  &y[0], &T[0], &alpha[0], &mu_s_inv[0], &pins[0])
-
-
-    def run_until(self, t):
-        while (self.t<t):
-            self.run_step()
-        return 0
+
+def compute_llg_rhs_dw(np.ndarray[double, ndim=1, mode="c"] dm,
+                np.ndarray[double, ndim=1, mode="c"] spin,
+                np.ndarray[double, ndim=1, mode="c"] field,
+                np.ndarray[double, ndim=1, mode="c"] T,
+                np.ndarray[double, ndim=1, mode="c"] alpha,
+                np.ndarray[double, ndim=1, mode="c"] mu_s_inv,
+                np.ndarray[double, ndim=1, mode="c"] eta,
+                np.ndarray[int, ndim=1, mode="c"] pin, n, gamma, dt):
+    llg_rhs_dw_c(&spin[0], &field[0], &dm[0], &T[0], &alpha[0],  &mu_s_inv[0], &pin[0], &eta[0], n, gamma, dt)

fidimag/atomistic/lib/clib.h

@@ -43,8 +43,8 @@ static inline unsigned int int_rand(void) {
 }
 
 //temporary random generator
-void initial_random(void) {
-	unsigned int seed = (unsigned int) time(NULL);
+void initial_random(int seed) {
+	//unsigned int seed = (unsigned int) time(NULL);
 
 	int i;
 	MT[0] = seed & 0xFFFFFFFFU;
@@ -136,12 +136,4 @@ void gauss_random_vec(double *x, int n) {
 
 }
 
-void gauss_random_vec_with_init(double *x, int n) {
-
-	initial_random();
-
-	gauss_random_vec(x,n);
-
-}
-
 #endif