Live-info channel like mumax3's web UI

[borisgross]

Hi there,
I am very much impressed by and happy with the new possibilities offered by mumax+. As a heavy user of mumax3 I found the live display of any field (most important the magnetization of course) during the computation very useful. It allows to get some feeling of what is actually going on in the simulation. Starting to use mumax+ I do miss this feature. Is it possible to get similar live info from mumax+ as with mumax3?

[ilateur]

Hi,

I agree with your sentiment and find this very useful myself, but a live GUI is not supported out of the box. It would be quite a lot of work throughout the whole code to make this feature robust, efficient and compatible with all types of output, especially on remote machines. We are not planning to spend time on this right now.

However, if you are a bit proficient with Python, matplotlib and mumax+, you can probably make something to suit your specific needs. For example, let's say we are looking at standard problem 4.

from mumaxplus import World, Grid, Ferromagnet
import numpy as np
import matplotlib.pyplot as plt

length, width, thickness = 500e-9, 125e-9, 3e-9
nx, ny, nz = 128, 32, 1
world = World(cellsize=(length / nx, width / ny, thickness / nz))

magnet = Ferromagnet(world, Grid((nx, ny, nz)))
magnet.msat = 800e3
magnet.aex = 13e-12
magnet.alpha = 0.02

magnet.magnetization = (1, 0.1, 0)
magnet.minimize()

B1 = (-24.6e-3, 4.3e-3, 0)
B2 = (-35.5e-3, -6.3e-3, 0)
world.bias_magnetic_field = B1  # choose B1 or B2 here

We are then able to set up some plotting code and update that live. Here I will look at the magnetization as a vector field and the exchange_energy_density as a scalar field. Each get their own axes and image.

# example quantities to look at
vec_qty = magnet.magnetization
sca_qty = magnet.exchange_energy_density

# Initialize figure and axes
fig, (vec_ax, sca_ax) = plt.subplots(nrows=2)
fig.suptitle(f"t = {world.timesolver.time * 1e9:.6f} ns")

# --- Initialize images ---
# vector image
def qty_to_rgb(qty, layer=0):
    return np.transpose(qty.get_rgb()[:,layer,:,:], axes=[1,2,0])
vec_im = vec_ax.imshow(qty_to_rgb(vec_qty), origin="lower")

# scalar image
layer, comp = 0, 0
field = sca_qty.eval()[comp,layer,:,:]
vmax = np.abs(field).max()
vmin = -vmax
sca_im = sca_ax.imshow(field)
sca_im = sca_ax.imshow(field, origin="lower", cmap="seismic", vmin=vmin, vmax=vmax)
# -------------------------

plt.show(block=False)

Now we can run the timesolver in small steps, and after each step we update all our images with new data and redraw the canvas.

def update_images():
    # vector
    vec_im.set_data(qty_to_rgb(vec_qty))
    # scalar
    field = sca_qty.eval()[comp,layer,:,:]
    sca_im.set_data(field)
    vmax = np.abs(field).max()
    vmin = -vmax
    sca_im.set_clim(vmin=vmin, vmax=vmax)

# run while updating images
total_runtime = 1e-9
runtime_per_frame = 1e-11
pause = 0.01  # allow time to draw
timepoints = np.arange(0, total_runtime + runtime_per_frame, runtime_per_frame)
for t in timepoints:
    dt = t - world.timesolver.time
    world.timesolver._impl.run(dt)  # avoid resetting sensible timestep

    fig.suptitle(f"t = {world.timesolver.time * 1e9:.3f} ns")
    update_images()
    fig.canvas.draw()
    plt.pause(pause)

You could for example also use world.timesolver.run_while() and make a conditional statement to take into account the passage of real time, to get some type of stable frame rate.

A few months ago, I made a slightly more general version of the idea above and made it as a Viewer class (see the attached file live_viewer.py). It takes a timesolver and a list of FieldQuantities to inspect and can then run forever. Feel free to plunder this code, but I don't guarantee that it works anymore.

[borisgross]

Hi Ian
thank you for your script and code example, that is very useful. Do you think a similar approach is possible in case of minimize or relax to get a glimpse on the current state during computation?

[ilateur]

That's an excellent question, but sadly no. Those are single monolithic functions as far as the Python wrapper is concerned.