Fidimag

https://fidimag.readthedocs.io/en/latest/
Admin
Fidimag is an open-source micromagnetic and atomistic simulation package used to model and simulate...
Tokens:417,252
Snippets:2,207
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### DMI setup method

Source: https://fidimag.readthedocs.io/en/latest/_modules/fidimag/micro/dmi.html

The setup method configures the DMI vector based on the specified dmi_type (bulk, interfacial, or D_2d).

```python
def setup(self, mesh, spin, Ms, Ms_inv):
    super().setup(mesh, spin, Ms, Ms_inv)

    if self.dmi_type == 'bulk':
        self.dmi_vector = np.array([-1., 0, 0,
                                    1., 0, 0,
                                    0, -1., 0,
                                    0, 1., 0,
                                    0, 0, -1.,
                                    0, 0, 1.
                                    ])

    elif self.dmi_type == 'interfacial':
        self.dmi_vector = np.array([0, -1., 0,  # -x
                                    0, 1., 0,   # +x
                                    1., 0, 0,   # -y
                                    -1., 0, 0,  # +y
                                    0, 0, 0,    # -z
                                    0, 0, 0     # +z
                                    ])

    elif self.dmi_type == 'D_2d':
        self.dmi_vector = np.array([1., 0, 0,   # -x
                                    -1., 0, 0,  # +x
                                    0, -1., 0,  # -y
                                    0, 1., 0,   # +y
                                    0, 0, 0,    # -z
                                    0, 0, 0     # +z
                                    ])
```

--------------------------------

### Install all optional dependencies

Source: https://fidimag.readthedocs.io/en/latest/_sources/install.rst.txt

Installs the optional dev and docs dependencies for Fidimag.

```bash
uv sync --all-extras
```

--------------------------------

### Start IPython in container

Source: https://fidimag.readthedocs.io/en/latest/user_guide/ipynb/tutorial-docker-container.html

Launch an interactive IPython session within the container.

```bash
jovyan@4df962d27520:~/work$ ipython
Python 3.5.1 |Continuum Analytics, Inc.| (default, Jun 15 2016, 15:32:45)
Type "copyright", "credits" or "license" for more information.

IPython 4.2.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]:
```

--------------------------------

### Stop the last started Docker container

Source: https://fidimag.readthedocs.io/en/latest/_sources/user_guide/ipynb/tutorial-docker-container.ipynb.txt

Stops the most recently started container by combining docker ps -l -q to get the container ID and docker stop to stop it.

```bash
docker stop $(docker ps -l -q)
```

--------------------------------

### Energy.setup()

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.atomistic.energy.html

Sets up the energy computation with the given mesh, spin, and magnetic moment parameters.

```APIDOC
## Energy.setup()

### Description
Sets up the energy computation with the given mesh, spin, and magnetic moment parameters.

### Method
setup(_mesh_, _spin_, _mu_s_, _mu_s_inv_)

### Parameters
- **_mesh** - The mesh object.
- **_spin** - The spin configuration.
- **_mu_s** - The saturation magnetic moment.
- **_mu_s_inv** - The inverse of the saturation magnetic moment.

```

--------------------------------

### Get Docker machine IP address

Source: https://fidimag.readthedocs.io/en/latest/_sources/user_guide/ipynb/tutorial-docker-container.ipynb.txt

On a Mac, run this command to find the IP address to connect to the notebook. For example, if it returns 192.168.99.100, use http://192.168.99.100:30000.

```bash
docker-machine ip
```

--------------------------------

### DemagFull.setup()

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.atomistic.demag_full.html

Sets up the DemagFull object with the mesh, spin, and magnetic moment parameters.

```APIDOC
## DemagFull.setup()

### Description
Sets up the DemagFull object with the mesh, spin, and magnetic moment parameters.

### Method
setup

### Signature
setup(_mesh_, _spin_, _mu_s_, _mu_s_inv_)

### Parameters
- **mesh** (Mesh) - Required - The simulation mesh.
- **spin** (array-like) - Required - The spin configuration.
- **mu_s** (array-like) - Required - The saturation magnetic moment.
- **mu_s_inv** (array-like) - Required - The inverse of the saturation magnetic moment.
```

--------------------------------

### Demag.setup()

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.demag.html

Sets up the Demag energy term with the given mesh, spin, saturation magnetization, and inverse saturation magnetization. This method is part of the Demag class.

```APIDOC
## Demag.setup(mesh, spin, Ms, Ms_inv)

### Description
Sets up the Demag energy term with the given mesh, spin, saturation magnetization, and inverse saturation magnetization. This method is part of the Demag class.

### Method
setup

### Parameters
- **mesh** (Mesh) - Required - The mesh object for the simulation.
- **spin** (array) - Required - The spin configuration.
- **Ms** (float) - Required - Saturation magnetization.
- **Ms_inv** (float) - Required - Inverse saturation magnetization.

```

--------------------------------

### Energy.setup(_mesh_, _spin_, _Ms_, _Ms_inv_)

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.energy.html

Sets up the energy interaction with the given mesh, spin, saturation magnetization, and inverse saturation magnetization.

```APIDOC
## Energy.setup(_mesh_, _spin_, _Ms_, _Ms_inv_)

### Description
Sets up the energy interaction with the given mesh, spin, saturation magnetization, and inverse saturation magnetization.

### Method
setup(_mesh_, _spin_, _Ms_, _Ms_inv_)

### Parameters
- _mesh_ - The mesh object.
- _spin_ - The spin field.
- _Ms_ - Saturation magnetization.
- _Ms_inv_ - Inverse saturation magnetization.
```

--------------------------------

### Start IPython inside container

Source: https://fidimag.readthedocs.io/en/latest/_sources/user_guide/ipynb/tutorial-docker-container.ipynb.txt

Starts IPython inside the container. The output shows the IPython banner and prompt.

```bash
jovyan@4df962d27520:~/work$ ipython
Python 3.5.1 |Continuum Analytics, Inc.| (default, Jun 15 2016, 15:32:45) 
Type "copyright", "credits" or "license" for more information.

IPython 4.2.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: 
```

--------------------------------

### Install uv on Linux

Source: https://fidimag.readthedocs.io/en/latest/_sources/install.rst.txt

Command to install the uv package manager, required for managing the Python environment and building Fidimag.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Set up simulation with material parameters and energies

Source: https://fidimag.readthedocs.io/en/latest/user_guide/ipynb/isolated_skyrmion.html

Creates the simulation object, sets material parameters (Ms, A, D, alpha, gamma), adds exchange, DMI, and demagnetisation energies, and initialises the magnetisation.

```python
# FeGe material paremeters.
Ms = 3.84e5  # saturation magnetisation (A/m)
A = 8.78e-12  # exchange energy constant (J/m)
D = 1.58e-3  # Dzyaloshinkii-Moriya energy constant (J/m**2)
alpha = 1  # Gilbert damping
gamma = 2.211e5  # gyromagnetic ration (m/As)

# Create simulation object.
sim = Sim(mesh)
# sim = Sim(mesh, driver='steepest_descent')
sim.Ms = Ms_function(Ms)
sim.driver.alpha = alpha
sim.driver.gamma = gamma

# Add energies.
sim.add(UniformExchange(A=A))
sim.add(DMI(D=D))
sim.add(Demag())

# Since the magnetisation dynamics is not important in this stage,
# the precession term in LLG equation can be set to artificially zero.
# sim.driver.do_precession = False

# Initialise the system.
sim.set_m(init_m)
```

--------------------------------

### DemagHexagonal.setup(mesh, spin, mu_s, mu_s_inv)

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.atomistic.demag_hexagonal.html

Sets up the DemagHexagonal object with mesh, spin, and magnetic moment data.

```APIDOC
## DemagHexagonal.setup(mesh, spin, mu_s, mu_s_inv)

### Description
Sets up the DemagHexagonal object with the given mesh, spin configuration, and magnetic moment arrays.

### Parameters
- `mesh` - The mesh object.
- `spin` - The spin configuration.
- `mu_s` - The magnetic moment array.
- `mu_s_inv` - The inverse magnetic moment array.
```

--------------------------------

### Relaxation.setup(mesh, m, Ms)

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.relax.html

Sets up the relaxation computation with the given mesh, magnetization, and saturation magnetization.

```APIDOC
## Relaxation.setup(mesh, m, Ms)

### Description
Sets up the relaxation computation with the given mesh, magnetization, and saturation magnetization.

### Method
setup

### Parameters
- **mesh** (Mesh) - Required - The mesh on which the computation is performed.
- **m** (field) - Required - The magnetization field.
- **Ms** (float) - Required - Saturation magnetization.

### Returns
None
```

--------------------------------

### Install cmake and GCC on OS X

Source: https://fidimag.readthedocs.io/en/latest/_sources/install.rst.txt

Installs cmake and a GCC version compatible with OpenMP on OS X via brew.

```bash
brew install cmake gcc@15
```

--------------------------------

### Initialize Periodic System

Source: https://fidimag.readthedocs.io/en/latest/_sources/user_guide/ipynb/spin-waves-in-periodic-system.ipynb.txt

Sets up a periodic mesh and initializes the magnetic system for spin wave calculations.

```python
import numpy as np
from fidimag.atomistic import Sim
from fidimag.atomistic.hamiltonian import Exchange, DMI, Zeeman
from fidimag.common.mesh import PeriodicMesh

# Define mesh and system
mesh = PeriodicMesh(nx=100, ny=1, nz=1, dx=1e-9)
sim = Sim(mesh, name='spin_wave_periodic')

# Add interactions
sim.hamiltonian.add(Exchange(1e-12))

# Set initial state
sim.set_m((0, 0, 1))
```

--------------------------------

### Example spatial_Ms TCL function

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.oommf.html

Example of a spatial_Ms function that returns 2e4 inside a circular region and 0 elsewhere. This is passed as a string to the spatial_Ms parameter.

```tcl
spatial_Ms = """
if { $x * $x + $y * $y < 5e-9 * 5e-9 } {
    return 2e4
} else {
    return 0
}
"""

```

--------------------------------

### Energy class definition and setup method

Source: https://fidimag.readthedocs.io/en/latest/_modules/fidimag/atomistic/energy.html

Defines the Energy abstract class with a setup method that initializes mesh properties, spin, and material constants. It also allocates arrays for field and energy.

```python
import numpy as np

#from constant import mu_0




[docs]
class Energy:

    """

    An abstract class to implement the basic functions such as setup for atomic
    dynamics.

    """



[docs]
    def setup(self, mesh, spin, mu_s, mu_s_inv):
        self.mesh = mesh
        self.dx = mesh.dx * mesh.unit_length
        self.dy = mesh.dy * mesh.unit_length
        self.dz = mesh.dz * mesh.unit_length
        self.nx = mesh.nx
        self.ny = mesh.ny
        self.nz = mesh.nz
        self.spin = spin
        self.n = mesh.n
        self.n_ngbs = mesh.n_ngbs
        self.mesh_type = mesh.mesh_type

        self.total_energy = 0
        self.mu_s = mu_s

        self.field = np.zeros(3 * self.n, dtype=np.float64)
        self.energy = np.zeros(mesh.n, dtype=np.float64)
        self.total_energy = 0.0

        self.mu_s_inv = mu_s_inv

        self.xperiodic, self.yperiodic = (mesh.periodicity[0],
                                          mesh.periodicity[1])
        self.neighbours = mesh.neighbours

        try:
            self.coordinates = self.mesh.coordinates
        except:
            self.coordinates = np.array(self.mesh.pos)
```

--------------------------------

### ExchangeRKKY.setup(mesh, spin, Ms, Ms_inv)

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.exchange_rkky.html

Sets up the energy term with the mesh, spin, and saturation magnetization data. This method is called during initialization to prepare the term for computation.

```APIDOC
## ExchangeRKKY.setup(mesh, spin, Ms, Ms_inv)

### Description
Sets up the energy term with the mesh, spin, and saturation magnetization data. This method is called during initialization to prepare the term for computation.

### Parameters
- **mesh** (Mesh) - The mesh object defining the simulation geometry.
- **spin** (array-like) - The initial spin configuration.
- **Ms** (array-like) - Saturation magnetization values.
- **Ms_inv** (array-like) - Inverse saturation magnetization values.

### Returns
- None
```

--------------------------------

### LLG_STT_CPP.get_p()

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.atomistic.llg_stt_cpp.html

Method to get the polarization p.

```APIDOC
## LLG_STT_CPP.get_p()

### Description
Returns the polarization p.

### Returns
- The value of p.
```

--------------------------------

### LLG_STT_CPP.get_a_J()

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.llg_stt_cpp.html

Method to get the current density a_J.

```APIDOC
## LLG_STT_CPP.get_a_J()

### Description
Method to get the current density a_J.

### Method
Getter

### Signature
get_a_J()

### Returns
The current density a_J.
```

--------------------------------

### Set up simulation with LLG driver for comparison

Source: https://fidimag.readthedocs.io/en/latest/user_guide/ipynb/hubert_minimiser_atomistic.html

Creates an atomistic simulation with the 'llg' driver, sets the magnetic moment, adds the same interactions as the Hubert example, and defines the same initial magnetisation function.

```python
sim = fidimag.atomistic.Sim(mesh, name='one_dim', driver='llg')

# Define the magnetisation
sim.set_mu_s(mus)

# Add the magnetic interactions
sim.add(fidimag.atomistic.Exchange(J))
sim.add(fidimag.atomistic.Anisotropy(Ku, axis=(0, 0, 1)))
sim.add(fidimag.atomistic.DMI(D, dmi_type='interfacial'))
sim.add(fidimag.atomistic.Zeeman((0, 0, B)))

xs = mesh.coordinates[:, 0]
centre_x = (xs.max() + xs.min()) * 0.5 + xs.min()

def m_initial(r):
    x, y, z = r[0], r[1], r[2]
    if np.abs(x - centre_x) < 2:
        return (0, 0.1, -.9)
    else:
        return (0, 0.1, .9)

# sim.set_m((0.1, 0, 0.9))
sim.set_m(m_initial)

```

--------------------------------

### SimBase.get_alpha(alpha)

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.common.sim_base.html

Gets the damping parameter alpha.

```APIDOC
## SimBase.get_alpha(alpha)

### Description
Gets the damping parameter alpha.

### Parameters
- **alpha** - Required - The alpha value to get.

### Returns
The alpha value.
```

--------------------------------

### DMI.setup(mesh, spin, mu_s, mu_s_inv)

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.atomistic.dmi.html

Sets up the DMI interaction with the given mesh, spin, and magnetic moment parameters.

```APIDOC
## DMI.setup(mesh, spin, mu_s, mu_s_inv)

### Description
Initializes the DMI interaction with the simulation mesh and spin configuration.

### Parameters
- **mesh** (Mesh) - Required - The simulation mesh.
- **spin** (array) - Required - Spin configuration.
- **mu_s** (array) - Required - Saturation magnetic moments.
- **mu_s_inv** (array) - Required - Inverse saturation magnetic moments.

### Returns
None.
```

--------------------------------

### LLG_STT_CPP.p

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.llg_stt_cpp.html

Property to get or set the spin polarization p.

```APIDOC
## LLG_STT_CPP.p

### Description
Property to get or set the spin polarization p.

### Method
Property getter and setter

### Getter
Returns the spin polarization p.

### Setter
Sets the spin polarization p.

### Parameters (Setter)
- **value** - Required - The new value for p.
```

--------------------------------

### LLG_STT_CPP.a_J

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.llg_stt_cpp.html

Property to get or set the current density a_J.

```APIDOC
## LLG_STT_CPP.a_J

### Description
Property to get or set the current density a_J.

### Method
Property getter and setter

### Getter
Returns the current density a_J.

### Setter
Sets the current density a_J.

### Parameters (Setter)
- **value** - Required - The new value for a_J.
- **args** - Optional - Additional arguments.
```

--------------------------------

### Exchange.setup(mesh, spin, mu_s, mu_s_inv)

Source: https://fidimag.readthedocs.io/en/latest/_modules/fidimag/atomistic/exchange.html

Sets up the exchange interaction for a given mesh, spin, and magnetic moments. It determines the appropriate computation method based on the type of J provided: uniform, spatial, or full exchange calculation.

```APIDOC
## Exchange.setup(mesh, spin, mu_s, mu_s_inv)

### Description
Sets up the exchange interaction energy term for the given mesh and spin configuration. Based on the type of J provided, it selects the appropriate computation method: uniform exchange for scalar J, spatial exchange for callable J, or full exchange for a list of shell constants.

### Parameters
- **mesh** (Mesh) - Required - The mesh object defining the lattice structure.
- **spin** (array) - Required - The spin configuration.
- **mu_s** (array) - Required - The magnetic moment magnitudes.
- **mu_s_inv** (array) - Required - The inverse magnetic moment magnitudes.

### Behavior
- If J is a float or int, it sets Jx, Jy, Jz to the same value and uses `compute_field_uniform`.
- If J is callable, it evaluates the function at each lattice site to build a spatial exchange tensor and uses `compute_field_spatial`.
- If J is a list or numpy array with length equal to the number of neighbour shells, it stores the shell constants and uses `compute_field_full`.

### Notes
- The spatial function must return either a float/int or a list/array/tuple of length 6. Otherwise, an exception is raised.
- The number of shells should not be larger than 8 (checked in the mesh class).
```

--------------------------------

### LLG_STT_CPP.get_a_J()

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.atomistic.llg_stt_cpp.html

Method to get the spin torque coefficient a_J.

```APIDOC
## LLG_STT_CPP.get_a_J()

### Description
Returns the spin torque coefficient a_J.

### Returns
- The value of a_J.
```

--------------------------------

### DMI.setup(mesh, spin, Ms, Ms_inv)

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.micro.dmi.html

Sets up the DMI interaction with the given mesh, spin, and saturation magnetization values. This method initializes necessary internal data.

```APIDOC
## DMI.setup(mesh, spin, Ms, Ms_inv)

### Description
Sets up the DMI interaction with the provided mesh and spin configuration.

### Parameters
- **mesh** (Mesh) - Required - The mesh object.
- **spin** (array) - Required - The spin configuration.
- **Ms** (float) - Required - Saturation magnetization.
- **Ms_inv** (float) - Required - Inverse saturation magnetization.
```

--------------------------------

### Create environment and build C/C++ modules

Source: https://fidimag.readthedocs.io/en/latest/_sources/install.rst.txt

Creates the Python environment and builds the C/C++ modules in editable mode.

```bash
uv sync
```

--------------------------------

### LLG_STT.get_jz()

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.atomistic.llg_stt.html

Method to get the jz component of the LLG_STT driver.

```APIDOC
## LLG_STT.get_jz()

### Description
Method to get the jz component of the LLG_STT driver.

### Signature
LLG_STT.get_jz()
```

--------------------------------

### LLG_STT.get_jy()

Source: https://fidimag.readthedocs.io/en/latest/api/generated/fidimag.atomistic.llg_stt.html

Method to get the jy component of the LLG_STT driver.

```APIDOC
## LLG_STT.get_jy()

### Description
Method to get the jy component of the LLG_STT driver.

### Signature
LLG_STT.get_jy()
```

--------------------------------

### Configure Simulation and Initial State

Source: https://fidimag.readthedocs.io/en/latest/user_guide/ipynb/hubert_minimiser_atomistic.html

Initialize the simulation with the Hubert minimiser, set physical parameters, and define the initial magnetisation state.

```python
sim = fidimag.micro.Sim(mesh, name='1Dmicro', driver='hubert_minimiser')

Ms = 0.86e6
A = 13e-12
Ku = 0.4e6

# Define the magnetisation
sim.set_Ms(Ms)

# Add the magnetic interactions
sim.add(fidimag.micro.UniformExchange(A))
sim.add(fidimag.micro.UniaxialAnisotropy(Ku, axis=(0, 0, 1)))
# sim.add(fidimag.atomistic.DMI(D, dmi_type='interfacial'))
# sim.add(fidimag.micro.Zeeman((0, 0, B)))

xs = mesh.coordinates[:, 0]
centre_x = (xs.max() + xs.min()) * 0.5 + xs.min()

def m_initial(r):
    x, y, z = r[0], r[1], r[2]
    if x < centre_x:
        return (0, 0.1, -.9)
    else:
        return (0, 0.1, .9)

# sim.set_m((0.1, 0, 0.9))
sim.set_m(m_initial)

mesh_vol = mesh.n * mesh.dx * mesh.dy * mesh.dz * 1e-27
Kd = C.mu_0 * (Ms ** 2) * 0.5 * mesh_vol
sim.driver.energyScale = Kd
```

--------------------------------

### DemagHexagonal setup method

Source: https://fidimag.readthedocs.io/en/latest/_modules/fidimag/atomistic/demag_hexagonal.html

Configures the hexagonal mesh parameters and initializes the equivalent cuboid mesh for demagnetization calculations.

```python
[docs]
    def setup(self, mesh, spin, mu_s, mu_s_inv):

        if mesh.mesh_type != 'hexagonal':
            raise Exception('This interaction is only defined'
                            'for hexagonal meshes'
                            )

        # `mesh`, `spin`, `n`, `field`, `energy` and `total_energy` come from
        # the base class, so that this reports an energy the same way as every
        # other interaction
        super().setup(mesh, spin, mu_s, mu_s_inv)

        # The equivalent cuboid mesh is built in mesh units rather than in
        # metres, the unit length being carried by `scale` below, so the
        # spacings the base class stores in metres are replaced here
        self.dx = mesh.dx
        self.dx_c = 0.5 * mesh.dx

        self.dy = mesh.dy
        self.dz = mesh.dz

        self.nx_c = 2 * mesh.nx

        self.spin_c = np.zeros(2 * len(spin))

        self.n_c = mesh.n * 2
        # self.n_c = self.mesh_c.n

        self.field_c = np.zeros(3 * self.n_c, dtype=np.float64)

        self.energy_c = np.zeros(self.n_c, dtype=np.float64)

        unit_length = mesh.unit_length
        self.mu_s_scale_c = np.zeros(2 * self.n, dtype=np.float64)

        # note that the 1e-7 comes from \frac{\mu_0}{4\pi}
        self.scale = 1e-7 / unit_length ** 3

        # could be wrong, needs carefully tests!!!
        # David Tue 19 Jun 2018: this variable is upated in the sim class
        # in case mu_s changes
        self.mu_s_scale = mu_s * self.scale

        # This seems not to be necessary
        # self.create_cuboid_mesh()

        self.scalar2cuboid(self.mu_s_scale, self.mu_s_scale_c)

        # Compute demag using the cuboid mesh with the double
        # number of x finite differences
        self.demag = clib.FFTDemag(self.dx_c, self.dy, self.dz,
                                   self.nx_c, self.ny, self.nz,
                                   tensor_type='dipolar')
```
Tokens:
Raw