Welcome to fidimag’s documentation!¶

Install prerequisites¶

On Ubuntu systems, we need to run the following commands:

# required to compile fidimag
apt-get install cython python-numpy
# required for tests and running it
apt-get install python-pytest python-pyvtk ipython python-matplotlib mayavi2

These are available in the script bin/install-ubuntu-packages.sh for convenience.

Install external libraries (FFTW and Sundials)¶

Run the install.sh by using

bash install.sh

in the fidimag/bin folder.

Install fidimag¶

In the fidimag folder type

make

to build fidimag.

Add the fidimag to python path¶

Add the following to your .bashrc file:

export PYTHONPATH=/path/to/fidimag:$PYTHONPATH

for example, suppose fidimag is in the directory of ~/work, then:

export PYTHONPATH=~/work/fidimag:$PYTHONPATH

Add the library path to LD_LIBRARY_PATH¶

By default, the libraries are installed in fidimag/local, so in order to run fidimag we need to include the libs path in LD_LIBRARY_PATH, so please add the following to your .bashrc file:

export LD_LIBRARY_PATH=/path/to/fidimag/local/lib:$LD_LIBRARY_PATH

for instance:

export LD_LIBRARY_PATH=~/work/fidimag/local/lib:$LD_LIBRARY_PATH

Adding OOMMF path to the system¶

For the tests that call OOMMF (in micro/tests), we need to tell the system where to find it. The way it is currently set up (in util/oommf.py), we need to find our oommf.tcl file, and add the path to it to .bashrc in this way:

export OOMMF_PATH=/opt/oommf/oommf-1.2a5bis

Loading Modules¶

Need to load the hg and numpy modules. This can be done by

module load hg numpy

These modules will only be loaded for your current session on iridis. To have the modules automatically loaded at login, you can add them to the module initlist by

module initadd hg numpy

Installing PyTest and PyVTK¶

py.test and PyVTK need to be installed locally (at /home/$USER/.local/bin/) by

pip install --user pytest pyvtk

The following path needs to be added to the .bashrc file

export PATH=~/.local/bin:$PATH

Cloning Repository¶

Can only be done with ssh keys.

How to set up a virtual machine via vagrant¶

• install vagrant on your host machine

• run:

  vagrant init ubuntu/trusty64
  

  to set up a basic linux machine.

• run:

  vagrant up
  

  to start the machine.

• ssh into the machine with X-forwarding:

  vagrant ssh -- -X
  

Then within the virtual machine:

aptitude install git
git clone https://github.com/fangohr/fidimag.git
cd fidimag/bin
sudo sh install-ubuntu-packages.sh
sh install.sh
cd ..
make

To run the tests:

cd /home/vagrant/fidimag/tests
py.test

Notes:

• some tests will fail as OOMMF is not installed
• it seems that we need an active X server, on OS X, one may need to install XQuartz before the tests can pass (even ‘import fidimag’ failed without a working X server).

Landau-Lifshitz-Gilbert (LLG) equation¶

The dynamic of magnetic moment \(\vec{\mu}_i\) is governed by LLG equation,

where \(\vec{S}_i\) is the unit vector of magnetic moment,

and \(\vec{\mu}_s = |\vec{\mu}_i|\), the effective field \(\vec{H}_i\) is defined as

Interactions¶

In the level of atomic moments, \(\vec{\mu}_s\), originated from the angular momentum of electrons in atoms, could be employed as the base unit in simulations. There are several typical interactions between magnetic moments. The total Hamiltonian is the summation of them.

Stochastic LLG equation¶

The implemented equation including the thermal fluctuation effects is

where \(\vec{\xi}\) is the thermal fluctuation field and is assumed to have the following properties,

and

Spin transfer torque (Zhang-Li model)¶

The extended equation with current is,

Where

and \(\mu_B=|e|\hbar/(2m)\) is the Bohr magneton. Notice that \(\partial_x \vec{m} \cdot \vec{m}=0\) so \(u_0 (\vec{j}_s \cdot \nabla) \vec{m}= - u_0 \vec{m}\times[\vec{m}\times (\vec{j}_s \cdot \nabla)\vec{m}]\). Besides, we can change the equation to atomistic one by introducing \(\vec{s}=-\vec{S}\) where \(\vec{S}\) is the local spin such that

so \(u_0=p a^3/(2|e|s)\), furthermore,

However, we perfer the normalised equaiton here, after changing it to LL form, we obtain,

although in principle \(\partial_x \vec{m}\) is always perpendicular to \(\vec{m}\), it’s better to take an extra step to remove its longitudinal component, therefore, the real equation written in codes is,

where \(\vec{\tau}=(\vec{j}_s \cdot \nabla)\vec{m}\) is the effective torque generated by current.

Nonlocal spin transfer torque (full version of Zhang-li model)¶

The LLG equation with STT is given by,

where \(\vec{T}\) is the spin transfer torque. In the local form the STT is given by,

And in general case, the spin transfer torque could be computed by,

where \(\tau_{sd}\) is the s-d exchange time and \(\delta \vec{m}\) is the nonequilibrium spin density governed by

By changing the LLG equation to LL form, we obtain,

i.e.,

Data structure¶

The first thing we may want to know is that how we label each spin in space, which can be peered from the index method in Mesh class

def index(self, i, j, k):
    idx = i*self.nyz + j*self.nz + k
    return idx

So we label the cells along z axis first then along y axis and the last is x, therefore we using the following code to loop all cells

for (i = 0; i < nx; i++) {
        for (j = 0; j < ny; j++) {
                for (k = 0; k < nz; k++) {
                        index = nyz * i + nz * j + k;
                        //do something ...
                }
        }
}

Units¶

We try to follow the SI units in the whole development, for example the gyromagnetic ratio \(\gamma\) is 1.76e11 rad/(s T). Because we use the sampe code to compute the exchange field and DMI field for both the atomic moments and the continuum case, so we need to take care of the relation between the two. For example, the saturated magnetization \(M_s\) can be computed by

Exchange and DMI energy¶

Although we can compute the total energy according to the direct definitions, however, we also can compute them using the corresponding effective fields, the energy density is

where

and thus the total energy is

\[\mathcal{H} = \frac{1}{2}\sum_i \mathcal{H}_i\]

Anisotropy and external field energy¶

We compute them directly from the direct definitions.

Meshes¶

                       Mesh                                              Cell
                                                                    +------------+
      +-----+-----+-----+-----+-----+-----+                        /            /|
     /     /     /     /     /     /     /|                       /            / |
    +-----+-----+-----+-----+-----+-----+ |                      /            /  | dz
   /     /     /     /     /     /     /| +                     +------------+   |
  +-----+-----+-----+-----+-----+-----+ |/          ----->      |            |   |
 /     /     /     /     /     /     /| +                       |            |   +
+-----+-----+-----+-----+-----+-----+ |/                        |            |  /
|     |     |     |     |     |     | +                         |            | /  dy
|     |     |     |     |     |     |/                          |            |/
+-----+-----+-----+-----+-----+-----+                           +------------+
                                                                     dx

We need to create a mesh. Meshes are created by specifying the dimensions of the finite difference cells, (dx, dy, dz) and the number of cells in each direction, (nx, ny, nz).

The cell dimensions are defined by dimensionless units. The dimensions of the mesh/cells are integrated by the parameter, unit_length.

In the the following example, the (cuboid) mesh consists of 6x3x1 cells (nx=6, ny=3 and nz=1), with each cell comprising of the dimensions, dx=3, dy=3 and dz=4. The unit_length = 1e-9 (nm).

Thus, the total size of the mesh is 18nm x 9nm x 4nm.

In [2]:

nx, ny, nz = 6, 3, 1
dx, dy, dz = 3, 3, 4 #nm
unit_length = 1e-9 # define the unit length of the dx units to nm.

mesh = CuboidMesh(nx=nx, ny=ny, nz=nz, dx=dx, dy=dy, dz=dz, unit_length=unit_length)

In [3]:

nx

Out[3]:

6

In [ ]: