mumax3

https://mumax.github.io
Admin
mumax3 is a GPU-accelerated micromagnetic simulation program that enables 100x speedups over...
Tokens:73,927
Snippets:582
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Run Standard Problem 4 Example

Source: https://mumax.github.io/plus/install.html

Execute a standard example script to verify the installation. This helps confirm that MuMax+ can run basic simulations.

```shell
python examples/standardproblem4.py

```

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

### Check Git Installation

Source: https://mumax.github.io/plus/install.html

Verify that Git is installed and accessible by checking its version.

```bash
git --version
```

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

### Build and Install mumax+ using pip

Source: https://mumax.github.io/plus/install.html

Install mumax+ into the current environment using pip. Use verbose mode for debugging or editable mode for development.

```bash
pip install .

```

```bash
pip install -v .

```

```bash
pip install -ve .

```

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

### Get Help for Vortex Configuration

Source: https://mumax.github.io/plus/tutorial/magnetization.html

Displays the help documentation for the `config.vortex` function, showing its parameters and usage.

```python
help(config.vortex)

```

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

### Install PyVista and Trame

Source: https://mumax.github.io/plus/tutorial/shapes.html

Installs required packages for 3D plotting with PyVista.

```bash
pip install ipywidgets 'pyvista[all,trame]'
```

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

### Check C++ Compiler Installation on Windows

Source: https://mumax.github.io/plus/install.html

Verify the installation of the Microsoft Visual C++ compiler by checking its path.

```bash
where.exe cl.exe
```

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

### Check CUDA Installation

Source: https://mumax.github.io/plus/install.html

Verify that the CUDA Toolkit is correctly installed and accessible by checking its version.

```bash
nvcc --version
```

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

### Voronoi Tesselator Setup and Simulation

Source: https://mumax.github.io/plus/examples/voronoi.html

Sets up a simulation world and grid, initializes a Voronoi Tesselator, creates a Ferromagnet with Voronoi regions, applies random anisotropy and magnetization, and runs a time simulation.

```python
import matplotlib.pyplot as plt
import numpy as np

from mumaxplus import Ferromagnet, Grid, World
from mumaxplus.util import Circle, VoronoiTessellator, vortex, plot_field, show_regions

# Set up simulation parameters
N = 256
c = 4e-9
d = 40e-9

world = World(cellsize=(c, c, d))
grid = Grid((N, N, 1))

# Create a circle
diam = N*c
geo = Circle(diam).translate(diam/2, diam/2, 0)

# Initialize a Voronoi Tesselator using a grainsize of 40e-9 m
tessellator = VoronoiTessellator(40e-9)
regions = tessellator.generate(world, grid)

# Create Ferromagnet
magnet = Ferromagnet(world, grid, geometry=geo, regions=regions)
magnet.alpha = 3
magnet.aex = 13e-12
magnet.msat = 860e3

# Set vortex magnetization
magnet.magnetization = vortex(magnet.center, 2*c, 1, 1)
plot_field(magnet.magnetization)

for i in tessellator.indices:
    # Set random anisotropy axes in each region
    anisC1 = tuple(np.random.normal(size=3))
    anisC2 = tuple(np.random.normal(size=3))
    magnet.anisC1.set_in_region(i, anisC1)
    magnet.anisC2.set_in_region(i, anisC2)

    # Create a random 10% anisotropy variation
    K = 1e5
    magnet.kc1.set_in_region(i, K + np.random.normal() * 0.1 * K)

# Vary interregion aex
magnet.scale_exchange = 0.9

# Evolve the world in time
world.timesolver.run(0.1e-9)

plot_field(magnet.magnetization)
plot_field(magnet.kc1, imshow_kwargs={"cmap": "Greys"}, enable_colorbar=False)

show_regions(magnet, geometry=magnet.geometry, imshow_kwargs={"cmap":"Greys"})

```

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

### Check C++ Compiler Installation on Linux

Source: https://mumax.github.io/plus/install.html

Verify the installation and version of the GCC C++ compiler, which is required for building mumax+.

```bash
gcc --version
```

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

### Magnetoelastic Simulation Setup and Execution

Source: https://mumax.github.io/plus/examples/magnetoelastics.html

Initializes a ferromagnet, assigns elastic parameters, applies a sinusoidal external field, and runs a simulation to observe magnetization and displacement. Use this for simulating dynamic magnetoelastic phenomena.

```python
import numpy as np
import math
from tqdm import tqdm
import matplotlib.pyplot as plt
import matplotlib.animation as animation

from mumaxplus import World, Grid, Ferromagnet
import mumaxplus.util.shape as shapes


length, width, thickness = 1e-6, 1e-6, 20e-9
nx, ny, nz = 256, 256, 1
cx, cy, cz = length/nx, width/ny, thickness/nz
cellsize = (cx, cy, cz)

grid = Grid((nx, ny, nz))
world = World(cellsize, mastergrid=Grid((nx, ny, 0)), pbc_repetitions=(2, 2, 0))
magnet = Ferromagnet(world, grid)

magnet.msat = 1.2e6
magnet.aex = 18e-12
magnet.alpha = 0.004
Bdc = 5e-3
magnet.bias_magnetic_field = (Bdc, 0, 0)  # uniform term
magnet.magnetization = (1, 0, 0)

magnet.minimize()

magnet.enable_elastodynamics = True
magnet.rho = 8e3
magnet.B1 = -8.8e6
magnet.B2 = -8.8e6
magnet.C11 = 283e9
magnet.C44 = 58e9
magnet.C12 = 166e9

magnet.elastic_displacement = (0, 0, 0)

# add magnetic field excitation
f_B = 9.8e9
Bac = 1e-3
Bdiam = 200e-9  # excitation diameter

# circular magnetic field excitation at the center
Bshape = shapes.Circle(Bdiam).translate(*magnet.center)
Bmask = magnet._get_mask_array(Bshape, grid, world, "mask")
magnet.bias_magnetic_field.add_time_term(
            lambda t: (0, Bac * math.sin(2*math.pi*f_B * t), 0), mask=Bmask)

magnet.alpha = 0.004
magnet.eta = 1e10  # elastic force damping

# plotting
fig, ax = plt.subplots()


u_scale = 1e5  # amplification of displacement
u_skip  = 10  # don't show every displacement

world.timesolver.adaptive_timestep = False
world.timesolver.timestep = 1e-12

frames = 400
steps_per_frame = 2

# save magnetization and displacement
m = np.zeros(shape=(frames, ny, nx))
u = np.zeros(shape=(frames, *magnet.elastic_displacement.shape))
t = np.zeros(shape=(frames))

# run a simulation
print("Simulating...")
for i in tqdm(range(frames)):
    world.timesolver.steps(steps_per_frame)
    m[i,...] = magnet.magnetization.eval()[1,0,:,:]
    u[i,...] = magnet.elastic_displacement.eval()
    t[i] = world.timesolver.time


# Draw horizontal and vertical lines to connect neighbors
mgrid = magnet.meshgrid
horizontal = []
vertical = []
uxyz = magnet.elastic_displacement.eval()[:,...] # This line seems to be missing a frame index, assuming it should be uxyz = magnet.elastic_displacement.eval()[i,...] or similar if it's meant to be for a specific frame.
coord = mgrid + uxyz*u_scale
x, y = coord[:2,0,...]

lw = 0.8

for i in range(0, ny, u_skip):  # Iterate over rows
    line = ax.plot(x[i,:], y[i,:], 'k-', lw=lw)  # Horizontal lines
    horizontal.append(line[0])
line = ax.plot(x[-1,:], y[-1,:], 'k-', lw=lw)  # Horizontal lines
horizontal.append(line[0])  # include the last cell to encompass whole grid

for i in range(0, nx, u_skip):  # Iterate over cols
    line = ax.plot(x[:,i], y[:,i], 'k-', lw=lw)  # Vertical lines
    vertical.append(line[0])
line = ax.plot(x[:,-1], y[:,-1], 'k-', lw=lw)  # Vertical lines
vertical.append(line[0])


# imshow setup
im_extent = (-0.5*cx, length - 0.5*cx, -0.5*cy, width - 0.5*cy)
vmax, vmin = np.max(m), np.min(m)
vmax = max(abs(vmax), abs(vmin))
vmin = -vmax
m_im = ax.imshow(m[0,...], origin="lower", extent=im_extent, vmin=vmin, vmax=vmax, cmap="seismic")

# colorbar setup
cbar = plt.colorbar(m_im)
cbar.ax.set_ylabel(r"$<m_y>$", rotation=270)

```

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

### Basic mumax 3 Scripting Example

Source: http://mumax.github.io

This script demonstrates applying a time-dependent external field to a uniform magnet, simulating an FMR experiment. It sets up the simulation grid, cell size, material properties, initial magnetization, and defines a time-dependent magnetic field before running the simulation.

```mumax3
SetGridSize(128, 32, 4)
SetCellSize(5e-9, 5e-9, 5e-9)
Msat  = 860e3
Aex   = 13e-12
alpha = 0.2
m = Uniform(1, 1, 0)

f := 1e9  // 1GHz
A := 0.01 // 10mT
B_ext = Vector(0.1, A*sin(2*pi*f*t), 0)

run(10e-9)

```

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

### Create and Activate Conda Environment

Source: https://mumax.github.io/plus/install.html

Create a new conda environment using the provided 'environment.yml' file and activate it. This installs necessary build tools and dependencies.

```bash
conda env create -f environment.yml
conda activate mumaxplus

```

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

### Set Magnetization using Meshgrid

Source: https://mumax.github.io/plus/tutorial/magnetization.html

Applies magnetization based on spatial coordinates using the magnetization's meshgrid. This example sets 'mx' and 'my' components using cosine and sine functions of the x-coordinate.

```python
m = np.zeros(magnet.magnetization.shape)

x, y, z = magnet.magnetization.meshgrid

m[0] = np.cos(1e8*x)
m[1] = np.sin(1e8*x)
m[2] = 0

magnet.magnetization = m

plot_field(magnet.magnetization, arrow_size=4)
```

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

### Set Magnetization with Numpy Array

Source: https://mumax.github.io/plus/tutorial/magnetization.html

Sets a custom magnetization configuration using a numpy array. This example creates a two-domain state with opposite 'my' components in the left and right halves.

```python
import numpy as np

m = np.zeros(magnet.magnetization.shape)
m[1,:,:,0:100] = 1 # set my=1 in the left half
m[1,:,:,100:] = -1 # set my=-1 in the right half

magnet.magnetization = m

plot_field(magnet.magnetization)
```

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

### Initialize World and Grid with Regions

Source: https://mumax.github.io/plus/tutorial/regions.html

Sets up the simulation environment and defines a 3D grid with three distinct regions represented by integer indices. This is a prerequisite for defining region-specific parameters.

```python
from mumaxplus import Ferromagnet, Grid, World
from mumaxplus.util import plot_field

world = World(cellsize=(1e-9, 1e-9, 1e-9))
grid = Grid((5, 5, 1))
regions = np.zeros(grid.shape)
regions[:, :, :1] = 1
regions[:, :, 1:2] = 2
regions[:, :, 2:] = 3
print(regions)

magnet = Ferromagnet(world, grid, regions=regions)
```

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

### Grid

Source: https://mumax.github.io/plus/api.html

Create a Grid instance.

```APIDOC
## Grid

### Description
Create a Grid instance.

### Endpoint
`/Grid`

### Parameters
#### Query Parameters
- **grid_instance** (object) - Required - Description of the grid instance parameter.
```

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

### Getting Variable Value

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Variable.html

Retrieves the current value of the variable field.

```python
get()
```

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

### dmi_tensor

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Altermagnet.html

Get the DMI tensor of this Altermagnet, describing intersublattice DMI exchange.

```APIDOC
## dmi_tensor

### Description
Get the DMI tensor of this Altermagnet. This tensor describes intersublattice DMI exchange. Note that individual sublattices can have their own tensor to describe intrasublattice DMI exchange.

### Returns
The DMI tensor of this Altermagnet.

### Return type
DmiTensor

### See also
`DmiTensor`, `dmi_tensors`, `dmi_vector`
```

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

### Initialize Ferromagnet and World

Source: https://mumax.github.io/plus/tutorial/plot_field.html

Sets up the simulation environment and a ferromagnetic material with specified properties. This includes defining saturation magnetization, exchange stiffness, anisotropy, and grid dimensions. Use this for setting up basic micromagnetic simulations.

```python
import numpy as np
import matplotlib.pyplot as plt

from mumaxplus import Ferromagnet, Grid, World
from mumaxplus.util.config import vortex
from mumaxplus.util.formulary import exchange_length, magnetostatic_energy_density

msat = 800e3
aex = 13e-12
alpha = 0.02
ku1 = 0.1 * magnetostatic_energy_density(msat)
anisU = (1, 0, 0)

# close to cube size where vortex and flower states have equal energy
length_in_lex = 8.46  # in unit of exchange length
lex = exchange_length(aex, msat)
length = length_in_lex * lex
N = 32

world = World(cellsize=(length / N, length / N, length / N))
magnet = Ferromagnet(world, Grid((N, N, N)))

magnet.msat = msat
magnet.aex = aex
magnet.ku1 = ku1
magnet.anisU = anisU

magnet.magnetization = (1, 0, 0.01)  # flower
# magnet.magnetization = vortex(magnet.center, length / 12, -1, 1)  # vortex
magnet.minimize()

# make magnetization a shorter variable
mag = magnet.magnetization

```

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

### Import Configuration Utilities

Source: https://mumax.github.io/plus/tutorial/magnetization.html

Imports the configuration utility module which contains predefined magnetization configurations.

```python
import mumaxplus.util.config as config

```

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

### Color Conversion Functions

Source: https://mumax.github.io/plus/_api/util/mumaxplus.util.show.html

Provides functions to convert between HSL and RGB color spaces, and to get RGB or RGBA color values.

```APIDOC
## util.show.hsl_to_rgb()

### Description
Converts HSL color values to RGB.

### Method
N/A (Function)

### Parameters
None explicitly documented.

### Response
Returns RGB color values.

## util.show.vector_to_rgb()

### Description
Converts a vector to an RGB color representation.

### Method
N/A (Function)

### Parameters
None explicitly documented.

### Response
Returns RGB color values.

## util.show.get_rgb()

### Description
Retrieves RGB color values.

### Method
N/A (Function)

### Parameters
None explicitly documented.

### Response
Returns RGB color values.

## util.show.get_rgba()

### Description
Retrieves RGBA color values.

### Method
N/A (Function)

### Parameters
None explicitly documented.

### Response
Returns RGBA color values.
```

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

### Initialize Ferromagnet and Plot

Source: https://mumax.github.io/plus/tutorial/magnetization.html

Initializes a Ferromagnet object and plots its initial random magnetization. This sets up the simulation environment.

```python
from mumaxplus import Ferromagnet, Grid, World
from mumaxplus.util import plot_field

world = World(cellsize=(1e-9,1e-9,1e-9))
magnet = Ferromagnet(world, Grid((200,100,1)))

plot_field(magnet.magnetization, enable_quiver=False)

```

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

### Get Magnetization Shape

Source: https://mumax.github.io/plus/tutorial/magnetization.html

Prints the current shape of the magnetization array. This is useful for understanding the dimensions before setting a custom numpy array.

```python
print(magnet.magnetization.shape)
```

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

### Setting up a Vortex State

Source: https://mumax.github.io/plus/tutorial/plot_field.html

Prepare the simulation by setting the magnetization to a vortex state and minimizing it. This is often done to create an interesting initial condition for further analysis or visualization.

```python
# Change the state to a vortex state to make it more interesting
magnet.magnetization = vortex(magnet.center, length / 12, -1, 1)
magnet.minimize()
```

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

### Get Number of Unique Regions

Source: https://mumax.github.io/plus/_api/util/mumaxplus.util.voronoi.html

Returns the total count of unique region indices in the tessellation. This property is available after `generate()` has been called.

```python
num_regions = t.number_of_regions
```

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

### Minimize Antiferromagnet Energy

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Antiferromagnet.html

Performs a fast energy minimization for the antiferromagnet. Use this for quick convergence when starting from a low energy state.

```python
afm.minimize()
```

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

### Relax Antiferromagnet State

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Antiferromagnet.html

Relaxes the antiferromagnet state to an energy minimum. This method is more robust than minimize() for high energy starting states but takes longer.

```python
afm.relax()
```

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

### Initialize Magnetic Wire Simulation

Source: https://mumax.github.io/plus/tutorial/langevin.html

Sets up a 1D magnetic wire simulation with specified cell volume, number of cells, and magnetic properties. Demagnetization is disabled, and exchange stiffness is set to zero.

```python
cellvolume = 100e-27  # volume of a cubic cell
N = 1024 # number of cells

world = World(cellsize=3*[np.power(cellvolume, 1./3.)])
magnet = Ferromagnet(world, Grid((N, 1, 1)))
magnet.enable_demag = False
magnet.aex = 0.0
magnet.alpha = 0.1
magnet.msat = 800e3
magnet.magnetization = (0,0,1) # groundstate
```

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

### Minimize Energy of NcAfm

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.NcAfm.html

Perform a fast energy minimization for the non-collinear antiferromagnet. Use this for quick convergence when starting from a relatively low energy state.

```python
my_ncafm.minimize(tol=1e-6, nsamples=30)
```

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

### Basic Field Plotting

Source: https://mumax.github.io/plus/tutorial/plot_field.html

A basic example of plotting a magnetization difference field. This function can take a field array and optional arguments for arrow size and layer.

```python
m_diff = m_minimized - m_initial

plot_field(m_diff, arrow_size=2, layer=N//2)
```

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

### Variable Class Methods

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Variable.html

This section details the methods available for the Variable class, which represents physical variable fields. Users can initialize, set, and get the values of these fields.

```APIDOC
## Variable Class

### Description
Represents a physical variable field, e.g. magnetization. Inherits from `FieldQuantity`.

### Methods

#### `__init__(_impl_)`
Initializes the Variable object.

#### `set(_value_)`
Sets the variable value uniformly, cell by cell, or with a function.

**Parameters:**
* **value** (tuple of floats, ndarray, or callable) - The new value for the variable field. Can be set uniformly with a tuple of floats (matching the number of components), cell by cell with an ndarray (same shape as this variable), or with a function that returns the cell value as a function of position.

#### `set_in_region(_region_idx_, _value_)`
Sets a static value in a specified region.

**Parameters:**
* **region_idx** (int) - The index of the region the variable must be set in.
* **value** (float, tuple of floats, or callable) - Value to assign within the specified region. Can be a uniform scalar or vector matching the number of variable components, or a callable that takes grid coordinates and returns a compatible value.

#### `get()`
Gets the current variable value.

**Returns:**
The current value of the variable field.
```

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

### Ferromagnet

Source: https://mumax.github.io/plus/api.html

Create a ferromagnet instance.

```APIDOC
## Ferromagnet

### Description
Create a ferromagnet instance.

### Endpoint
`/Ferromagnet`

### Parameters
#### Request Body
- **ferromagnet_instance** (object) - Required - Description of the ferromagnet instance parameter.
```

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

### Initialize NcAfm Instance

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.NcAfm.html

Create a non-collinear antiferromagnet instance. Specify the world, grid, and optionally name, geometry, and regions.

```python
world.MakeNcAfm(name='my_ncafm', grid=10, geometry=None, regions=None)
```

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

### Get Region Index by Coordinate

Source: https://mumax.github.io/plus/_api/util/mumaxplus.util.voronoi.html

Retrieves the region index for a specific (x, y, z) coordinate. Note that this method does not consider world boundaries or periodic conditions unless `generate()` has been called previously.

```python
region_index = t.coo_to_idx(x=10, y=20, z=5)
```

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

### Ferromagnet Initialization

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Ferromagnet.html

Creates a ferromagnet instance with specified world, grid, name, geometry, and regions.

```APIDOC
## Ferromagnet

### Description
Creates a ferromagnet instance.

### Parameters
* **world** (World) – World in which the ferromagnet lives.
* **grid** (Grid) – The number of cells in x, y, z the ferromagnet should be divided into.
* **name** (str, default='') – The ferromagnet’s identifier. If the name is empty (the default), a name for the ferromagnet will be created.
* **geometry** (None, ndarray, or callable, default=None) – The geometry of the ferromagnet can be set in three ways: 
1. If the geometry contains all cells in the grid, then use None (the default)
2. Use an ndarray which specifies for each cell whether or not it is in the geometry.
3. Use a function which takes x, y, and z coordinates as arguments and returns true if this position is inside the geometry and false otherwise.
* **regions** (None, ndarray, or callable, default=None) – The regional structure of a ferromagnet can be set in the same three ways as the geometry. This parameter indexes each grid cell to a certain region.

### Note
The values of InterParameters which act between different regions are stored in an array with a size that scales with the square of the maximal index value. Therefore, if possible, it’s good practice to keep each region index as close to zero as possible. E.g. defining two regions with indices 1 and 500 will work, but occupies more memory and will pay in performance than giving them the values 0 and 1.
```

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

### Relax NcAfm to Energy Minimum

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.NcAfm.html

Relax the non-collinear antiferromagnet state to an energy minimum using pure damping. This method is more robust for high energy starting states but takes longer than minimize.

```python
my_ncafm.relax(tol=1e-9)
```

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

### Clone mumax+ Repository

Source: https://mumax.github.io/plus/install.html

Clone the mumax+ Git repository, including its submodules, and navigate into the created directory.

```bash
git clone --recursive https://github.com/mumax/plus.git mumaxplus
cd mumaxplus

```

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

### Set Magnetization and Parameters in Regions

Source: https://mumax.github.io/plus/tutorial/regions.html

Configures the magnetization and material parameters like alpha, msat, and aex for a ferromagnet. It demonstrates setting a global parameter, changing a parameter in a specific region, and setting region-specific exchange constants.

```python
# consistent random configuration
np.random.seed(1234567)
magnet.magnetization = np.random.normal(size=magnet.magnetization.shape)

# Set parameter values for all regions
magnet.alpha = 0.1
magnet.msat = 800e3
magnet.enable_demag = False

magnet.msat.set_in_region(2, 1e6) # Change msat in middle strip

# Set exchange constant in regions seperately
magnet.aex.set_in_region(1, 5e-12)
magnet.aex.set_in_region(2, 13e-12)
magnet.aex.set_in_region(3, 20e-12)

# Set exchange constant between different regions
magnet.scale_exchange.set_between(1, 2, 0) # No exchange between first two "strips" of the magnet
magnet.inter_exchange.set_between(2, 3, 15e-12)

plot_field(magnet.magnetization, arrow_size=1)

world.timesolver.run(.1e-9)

plot_field(magnet.magnetization, arrow_size=1)
```

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

### Initialize VoronoiTessellator

Source: https://mumax.github.io/plus/_api/util/mumaxplus.util.voronoi.html

Creates an instance of the VoronoiTessellator. The grain size is a required parameter. An optional seed can be provided for reproducibility, and a maximum index can be set. A custom function can also be provided to map Voronoi centers to region indices.

```python
t = VoronoiTessellator(_grainsize_=0.5, _seed_=12345, _max_idx_=100)
```

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

### Advanced Plotting with Customization and Integration

Source: https://mumax.github.io/plus/tutorial/plot_field.html

This example demonstrates advanced customization of plot_field, including setting figure size, labels, title, and integrating with Matplotlib's Axes object. It also shows how to add custom annotations to the plot and control figure display.

```python
from mumaxplus.util.constants import MU0

# make a magnet with exchange length and magnetostatic energy set to 1
# as specified in the original problem statement
cs = length_in_lex / N
rescaled_world = World((cs, cs, cs))
rescaled_magnet = Ferromagnet(rescaled_world, Grid((N, N, N)))

rescaled_magnet.msat = np.sqrt(2/MU0)  # so Km = 1/2 µ0 Msat² = 1
rescaled_magnet.aex = 1.0  # so l_ex = sqrt(aex / Km) = 1
rescaled_magnet.ku1 = 0.1  # 0.1 * Km as specified
rescaled_magnet.anisU = (1, 0, 0)

rescaled_magnet.magnetization = vortex(rescaled_magnet.center, length_in_lex / 12, -1, 1)  # vortex
rescaled_magnet.minimize()


ax = plot_field(rescaled_magnet.magnetization, layer=N//2, arrow_size=4,
                xlabel=r"$x$ ($l_{\rm ex}$)", ylabel=r"$y$ ($l_{\rm ex}$)",
                figsize=(3,3), title="Magnetization in\nrescaled magnet", show=False)

center = rescaled_magnet.center[0:2]
ax.scatter(*center)
ax.annotate("Center", center, np.array(center) + np.array([-2 * cs, 7 * cs]), arrowprops=dict(facecolor='black', shrink=0.05))

plt.show()
```

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

### Altermagnet

Source: https://mumax.github.io/plus/api.html

Create an altermagnet instance.

```APIDOC
## Altermagnet

### Description
Create an altermagnet instance.

### Endpoint
`/Altermagnet`

### Parameters
#### Request Body
- **altermagnet_instance** (object) - Required - Description of the altermagnet instance parameter.
```

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

### Altermagnetic Domain Wall Simulation and Plotting

Source: https://mumax.github.io/plus/examples/Bloch_wall_altermagnet.html

This Python script simulates an altermagnetic domain wall using mumaxplus. It sets up material and simulation parameters, creates an Altermagnet object, defines an initial two-domain state, minimizes it to the ground state, and then plots the Néel and net magnetization profiles, comparing them against theoretical models. Requires mumaxplus, matplotlib, and numpy.

```python
from mumaxplus import World, Grid, Altermagnet

import matplotlib.pyplot as plt
import numpy as np


# ----------- Material and simulation parameters -----------

cs = 0.5e-9
a  = 0.35e-9

Ms  = 2.9e5
K   = 2e5
A1  = 25e-12
A2  = 15e-12
A0  = -5e-13
A12 = A0/2

length = 256e-9
width = 64e-9

# ----------- Create altermagnet -----------

Nx = int(length / cs)
Ny = int(width / cs)

world  = World((cs, cs, cs))
grid   = Grid((Nx, 1, 1))
magnet = Altermagnet(world, grid)

# ----------- Set parameters -----------

magnet.msat  = Ms
magnet.alpha = 0.01

magnet.ku1   = K
magnet.anisU = (0, 0, 1)

magnet.afmex_nn   = A12
magnet.afmex_cell = A0
magnet.latcon     = a

magnet.alterex_1 = A1 # first exchange matrix eigenvalue
magnet.alterex_2 = A2 # second exchange matrix eigenvalue
magnet.alterex_angle = 0 # exchange frame of reference aligns with the simulation grid

# ----------- Create a two-domain state -----------

dw_idx = 10 # initial guess of DW width (in cells)
m = np.zeros(magnet.sub1.magnetization.shape)
m[2, :, :,              0:Nx//2 - dw_idx] = 1   # Left domain
m[1, :, :, Nx//2 - dw_idx:Nx//2 + dw_idx] = -1  # Domain wall
m[2, :, :, Nx//2 + dw_idx:] = -1                # Right domain

magnet.sub1.magnetization =  m
magnet.sub2.magnetization = -m

# minimize to ground state
magnet.minimize()

# ----------- Plot Néel and net magnetization profiles -----------
fig, axs = plt.subplots(2, 1, sharex=True)
scale_net = 1e4
# Theoretical profiles
dw = np.sqrt((0.5*(A1+A2) - A12) / (2*K)) # Theoretical DW width
t = np.linspace(-Nx*cs/2, Nx*cs/2, Nx) / dw

# --- NEEL ---
theta = 2*np.arctan(np.exp(t))
axs[0].plot(t, np.cos(theta),  'k--', label="Model")
axs[0].plot(t, np.sin(-theta), 'k--')

# --- NET ---
Han = 2 * K / Ms
Hex = -8 * A0 / ( Ms * (a**2))
prefactor = 0.5 * (Han/Hex) * (A1-A2) / (0.5*(A1+A2) - A12)

theory_y = -prefactor * np.sinh(t)**2 / np.cosh(t)**3
theory_z =  prefactor * np.sinh(t)   /  np.cosh(t)**3
axs[1].plot(t, scale_net * theory_y, 'k--', label="Model")
axs[1].plot(t, scale_net * theory_z, 'k--')

# Simulated profiles
ms = 3

# --- NEEL ---
neel = magnet.neel_vector()[:, 0, 0, :]
axs[0].plot(t, neel[1], '.', label=r"$n_y$", markersize=ms)
axs[0].plot(t, neel[2], '.', label=r"$n_z$", markersize=ms)

# --- NET ---
net = 0.5 * (magnet.sub1.magnetization() + magnet.sub2.magnetization())[:, 0, 0, :]
axs[1].plot(t, scale_net * net[1], '.', label=r"$m_y$", markersize=ms)
axs[1].plot(t, scale_net * net[2], '.', label=r"$m_z$", markersize=ms)

# --- Plotter stuff ---
axs[1].set_xlabel(r"$x/\Delta$")
axs[1].set_ylabel(r"Net magnetization $m$ ($\\times 10^{-4}$)")
axs[0].set_ylabel(r"Néel vector $n$")
axs[0].set_xlim(-10, 10)
axs[0].legend()
axs[1].legend()
plt.tight_layout(h_pad=0.2)
plt.show()
```

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

### Antiferromagnet

Source: https://mumax.github.io/plus/api.html

Create an antiferromagnet instance.

```APIDOC
## Antiferromagnet

### Description
Create an antiferromagnet instance.

### Endpoint
`/Antiferromagnet`

### Parameters
#### Request Body
- **antiferromagnet_instance** (object) - Required - Description of the antiferromagnet instance parameter.
```

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

### Initialize Ferromagnet

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Ferromagnet.html

Create a ferromagnet instance with specified grid, geometry, and regions. The geometry and regions can be defined using None, ndarray, or a callable function.

```python
world.add(mumaxplus.Ferromagnet(grid=(10,10,10), geometry=None, regions=None, name='my_ferromagnet'))
```

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

### Simulate Domain Wall Motion with SAW

Source: https://mumax.github.io/plus/examples/DW_SAW.html

This snippet sets up and runs a micromagnetic simulation to observe domain wall movement induced by surface acoustic waves. It requires numpy, matplotlib, and mumaxplus libraries. The simulation involves defining grid parameters, magnetic properties, DMI, and applying time-varying strain terms.

```python
import numpy as np
import matplotlib.pyplot as plt

from mumaxplus import World, Grid, Ferromagnet
from mumaxplus.util import twodomain, plot_field

# simulation time
run = 10e-9
steps = 1000
dt = run/steps

# simulation grid parameters
# Use a very large y cell size and periodic boundary conditions to replicate a
# wider track while only simulating a thin strip
nx, ny, nz = 256, 8, 1
cx, cy, cz = 2.4e-9, 4 * 2.4e-9, 1e-9
mastergrid, pbc_repetitions = Grid((0, ny, 0)), (0, 4, 0)

# create a world and a magnet
cellsize = (cx, cy, cz)
world = World(cellsize, mastergrid=mastergrid, pbc_repetitions=pbc_repetitions)
magnet = Ferromagnet(world, Grid((nx, ny, nz)))

# setting magnet parameters
magnet.msat = 6e5
magnet.aex = 1e-11
magnet.alpha = 0.01
magnet.ku1 = 8e5
magnet.anisU = (0,0,1)

# setting DMI to stabilize the DW
magnet.dmi_tensor.set_interfacial_dmi(1e-3)

# Create a DW
magnet.magnetization = twodomain((0,0,1), (-1,0,0), (0,0,-1), nx*cx/3, 5*cx)

print("minimizing...")
magnet.minimize()  # minimize

# magnetoelastic coupling constants
magnet.B1 = -1.5e7
magnet.B2 = 0

# amplitude, angular frequency and wave vector of the strain
E = 6e-3
w = 200e6 * 2*np.pi
k = 4000 / w

# normal stain, given by exx = E [sin(wt)*cos(kx) - cos(wt)*sin(kx)]
# Create the first time term
magnet.rigid_norm_strain.add_time_term(lambda t: (np.sin(w*t), 0., 0.),
                                       lambda x,y,z: (E*np.cos(k*x), 0., 0.))
# Add the second time term
magnet.rigid_norm_strain.add_time_term(lambda t: (np.cos(w*t), 0., 0.),
                                       lambda x,y,z: (-E*np.sin(k*x), 0., 0.))

# plot the initial and final magnetization
fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, sharex="all", sharey="all")
plot_field(magnet.magnetization, ax=ax1, title="Initial magnetization",
           xlabel="", show=False, enable_quiver=False)

# function to estimate the position of the DW
def DW_position(magnet):
    m_av = magnet.magnetization.average()[2]
    return m_av*nx*cx / 2 + nx*cx/2

# run the simulation and save the DW postion
print("running...")
quantity_dict = {"DW_pos": lambda: DW_position(magnet)}
output = world.timesolver.solve(np.linspace(0, run, steps+1), quantity_dict, tqdm=True)
print("done!")

# final magnetization
plot_field(magnet.magnetization, ax=ax2, title="Final magnetization", show=True,
           enable_quiver=False)

# plot DW position as a function of time
plt.plot(np.array(output["time"])*1e9, np.array(output["DW_pos"])*1e6)
plt.xlabel("Time (ns)")
plt.ylabel("Domain wall position (µm)")
plt.title("Domain wall position in time")
plt.show()

```

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

### Setting Individual DMI Parameters

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.DmiTensor.html

Demonstrates how to set specific DMI parameters (xxz and yyz) for a ferromagnet. This is useful for fine-tuning DMI strengths.

```python
world = World(cellsize=(1e-9,1e-9,1e-9))
magnet = Ferromagnet(world, Grid((64,64,1)))
magnet.dmi_tensor.xxz = 3e-3
magnet.dmi_tensor.yyz = 3e-3
```

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

### Initialize Altermagnet

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Altermagnet.html

Creates an Altermagnet instance. Specify the world, grid dimensions, and optionally name, geometry, and regions.

```python
Altermagnet(_world_, _grid_, _name='', _geometry=None, _regions=None)
```

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

### Initialize Antiferromagnet

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Antiferromagnet.html

Creates an instance of the Antiferromagnet class. It can be used for both antiferromagnetic and ferrimagnetic simulations.

```python
world.add(mumaxplus.Antiferromagnet(world, grid, name='my_afm'))
```

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

### Antiferromagnet Initialization

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Antiferromagnet.html

Creates an Antiferromagnet instance. This class can also be used to create a Ferrimagnet instance as both sublattices are independently modifiable.

```APIDOC
## __init__

### Description
Create an antiferromagnet instance.

### Parameters
* **world** (World) – World in which the antiferromagnet lives.
* **grid** (Grid) – The number of cells in x, y, z the antiferromagnet should be divided into.
* **name** (str, optional) – The antiferromagnet’s identifier. Defaults to "".
* **geometry** (None, ndarray, or callable, optional) – The geometry of the antiferromagnet. Can be None (uses all cells), an ndarray specifying cell inclusion, or a function taking x, y, z coordinates.
* **regions** (None, ndarray, or callable, optional) – The regional structure of an antiferromagnet. Can be None, an ndarray indexing cells to regions, or a function taking x, y, z coordinates.
```

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

### NcAfm Constructor

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.NcAfm.html

Initializes a NcAfm instance. It requires a World and Grid, and optionally accepts geometry, regions, and a name.

```APIDOC
## __init__

### Description
Creates a non-collinear antiferromagnet instance.

### Parameters
* **world** (_World_) – World in which the non-collinear antiferromagnet lives.
* **grid** (_Grid_) – The number of cells in x, y, z the non-collinear antiferromagnet should be divided into.
* **name** (_str_ _(__default=""__)_) – The non-collinear antiferromagnet’s identifier. If the name is empty (the default), a name for the non-collinear antiferromagnet will be created.
* **geometry** (_None_ _,__ndarray_ _, or_ _callable_ _(__default=None_ _)_) – The geometry of the non-collinear antiferromagnet can be set in three ways: 1. If the geometry contains all cells in the grid, then use None (the default). 2. Use an ndarray which specifies for each cell whether or not it is in the geometry. 3. Use a function which takes x, y, and z coordinates as arguments and returns true if this position is inside the geometry and false otherwise.
* **regions** (_None_ _,__ndarray_ _, or_ _callable_ _(__default=None_ _)_) – The regional structure of a non-collinear antiferromagnet can be set in the same three ways as the geometry. This parameter indexes each grid cell to a certain region.
```

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

### Altermagnet Initialization

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.Altermagnet.html

Creates an Altermagnet instance. It can be initialized with world, grid, and optional geometry, regions, and name.

```APIDOC
## Altermagnet

### Description
Create an altermagnet instance.

### Parameters
* **world** (World) – World in which the altermagnet lives.
* **grid** (Grid) – The number of cells in x, y, z the altermagnet should be divided into.
* **name** (str, default='') – The altermagnet’s identifier. If the name is empty (the default), a name for the altermagnet will be created.
* **geometry** (None, ndarray, or callable, default=None) – The geometry of the altermagnet can be set in three ways: 
1. If the geometry contains all cells in the grid, then use None (the default)
2. Use an ndarray which specifies for each cell whether or not it is in the geometry.
3. Use a function which takes x, y, and z coordinates as arguments and returns true if this position is inside the geometry and false otherwise.
* **regions** (None, ndarray, or callable, default=None) – The regional structure of an altermagnet can be set in the same three ways as the geometry. This parameter indexes each grid cell to a certain region.
```

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

### Schedule Output Quantities

Source: https://mumax.github.io/plus/tutorial/stdp4.html

Defines the time points for simulation and the quantities to be recorded during the simulation.

```python
timepoints = np.linspace(0, 1e-9, 200)
outputquantities = {
    "mx": lambda: magnet.magnetization.average()[0],
    "my": lambda: magnet.magnetization.average()[1],
    "mz": lambda: magnet.magnetization.average()[2],
    "e_total": magnet.total_energy,
    "e_exchange": magnet.exchange_energy,
    "e_zeeman": magnet.zeeman_energy,
    "e_demag": magnet.demag_energy
}

```

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

### Import Libraries

Source: https://mumax.github.io/plus/tutorial/langevin.html

Imports necessary libraries for MuMax3, NumPy, and Matplotlib.

```python
from mumaxplus import *
import numpy as np
import matplotlib.pyplot as plt
```

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

### World Constructor

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.World.html

Constructs a new World object, defining the simulation space and boundary conditions.

```APIDOC
## World Constructor

### Description
Constructs a world with a given cell size, periodic boundary conditions, and master grid.

### Parameters
* **cellsize** (tuple[float] of size 3) - Required - A tuple of three floating-point numbers representing the dimensions of the cells in the x, y, and z directions.
* **pbc_repetitions** (tuple[int] of size 3, default=(0, 0, 0)) - Optional - The number of repetitions for periodic boundary conditions in x, y, and z directions.
* **mastergrid** (Grid, default=Grid(size=(0, 0, 0), origin=(0, 0, 0))) - Optional - Defines the periodic simulation box. If a dimension is zero, it's considered infinitely large in that direction.
```

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

### TimeSolver Methods

Source: https://mumax.github.io/plus/_api/mumaxplus/mumaxplus.TimeSolver.html

This section details the methods available for the TimeSolver, allowing users to control simulation time, integration methods, and execution.

```APIDOC
## TimeSolver

### Description
Provides methods for controlling and executing time-dependent simulations.

### Methods

*   `__init__()`: Initializes the TimeSolver.
*   `set_method(method_name)`: Sets the numerical integration method.
*   `steps(num_steps)`: Executes a specified number of simulation steps.
*   `run_while(condition)`: Runs the simulation as long as the given condition is true.
*   `run()`: Runs the simulation until completion or a stopping condition is met.
*   `solve()`: Solves the micromagnetic problem over time.

### Properties

*   `timestep`: The current simulation timestep.
*   `adaptive_timestep`: Enables or disables adaptive timestep calculation.
*   `time`: The current simulation time.
*   `max_error`: The maximum allowed error for adaptive timestepping.
*   `headroom`: Headroom factor for adaptive timestepping.
*   `lower_bound`: Lower bound for adaptive timestep.
*   `upper_bound`: Upper bound for adaptive timestep.
*   `sensible_factor`: Factor for calculating a sensible timestep.
*   `sensible_timestep_default`: Default sensible timestep value.
```

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

### Import Libraries

Source: https://mumax.github.io/plus/tutorial/stdp4.html

Imports necessary libraries for mumaxplus and plotting.

```python
from mumaxplus import *
from mumaxplus.util import plot_field

import matplotlib.pyplot as plt
import numpy as np

```
Tokens:
Raw