Is it possible to define more than only one K1/anisU pair?
In OOMMF it's possible to add several anisotropies just by naming them separately, so you can define several uniaxial anisotropy axis with different values (ej. K1(001)=1E5J/m3 AND K1(100)=1E3J/m3).
Is there any way to add more than only one anisotropy direction/magnitude?

Recently I discovered that mumax3-server memory usage bloats after a large number of simulations. My colleague had around 700~ mx3 files in his folder.

From the head of the output of is pprof/heap:

heap profile: 184: 3070230816 [9190: 3247059856] @ heap/1048576
183: 3070230528 [183: 3070230528] @ 0x42874c 0x49357e 0x40215d 0x40bbbc 0x437561
#   0x49357e    github.com/mumax/3/httpfs.Create+0x2ce  /home/syukri/gopath/src/github.com/mumax/3/httpfs/reader.go:21
#   0x40215d    main.NewProcess+0x8ed           /home/syukri/gopath/src/github.com/mumax/3/cmd/mumax3-server/compute.go:164
#   0x40bbbc    main.func·003+0x14c            /home/syukri/gopath/src/github.com/mumax/3/cmd/mumax3-server/compute.go:70

where line 21 of httpfs/reader.go is

        return &bufWriter{bufio.NewWriterSize(&appendWriter{URL, 0}, BUFSIZE)}, nil

To dissect the problem, I modified reader.go to the following

        mywriter := &appendWriter{URL, 0}
        mybufio := bufio.NewWriterSize(mywriter, BUFSIZE)
        return &bufWriter{mybufio}, nil

and recompiled, and ran the server on another folder with 10 simulation files. This time, the head of pprof/heap read:

heap profile: 13: 167862608 [24: 167937288] @ heap/1048576
10: 167772160 [10: 167772160] @ 0x4289dc 0x493811 0x40215d 0x40be40 0x4377f1
#   0x493811    github.com/mumax/3/httpfs.Create+0x2d1  /home/syukri/gopath/src/github.com/mumax/3/httpfs/reader.go:22
#   0x40215d    main.NewProcess+0x8ed           /home/syukri/gopath/src/github.com/mumax/3/cmd/mumax3-server/compute.go:166
#   0x40be40    main.func·003+0x2a0            /home/syukri/gopath/src/github.com/mumax/3/cmd/mumax3-server/compute.go:72

Line 22 refers to

        mybufio := bufio.NewWriterSize(mywriter, BUFSIZE)

It puzzles me why this one escapes the GC; it seems this one is alive even after reference to the parent Process is deleted (line 65 of cmd/mumax3-server/compute.go).

P/S: Compiled on Linux kernel 3.2.0-4-amd64 using golang 1.4.2

I've trying to define the bilayer film with different DMI in each layer. For this goal two regions were defined as top and bottom layers. Then magnetic parameters were set for this two regions. The values of magnetisatoin saturation (Msat) and exchange stiffness (Aex) were identical for top and bottom layers, but the Interfacial Dzyaloshinskii-Moriya strength (Dind) was different for each layer. After the compilation I get the error message "DMI: Msat, Aex, Dex must be uniform". Why DMI should be uniform for all regions? The function Dind has method "SetRegion( int ScalarFunction )" as written in syntax. How I can solve this problem and define special DMI for each region?

It would be very helpful if we could zoom into the sample as in OOMMF.
Right now, unless the number of cells is large enough, we can't see much of the sample. I think it is 1 pixel per cell at scale=1, and for a sample 256x16, we can only see a single line of "arrows".

What's the first parameter in NewSlice(?,x,y,z)?

I'm trying to define a spatially dependent B_ext but I'm having a hard time following what's going on in http://mumax.github.io/examples.html#example14 . Thanks, Alex

Hi everybody!
I'm interested in changing of default value of gyromagnetic value. Is there any way to do it, except recompilation with a new gamma value?

I've installed mumax3 from github, and from downloading the binaries. I was getting this error:

$ mumax3
mumax3: error while loading shared libraries: libcufft.so.6.5: cannot open shared object file: No such file or directory

After some googling, I found that I needed to add a directory containing libcufft.so.6.5, libcudart.so.6.5, and libcurand.so.6.5 to my $LD_LIBRARY_PATH. This was not obvious from the install instructions.

Could someone please update the install instructions to make this clear? Thanks!

I'm currently using mumax3.6 with CUDA 6.5 under Debian Wheezy amd64.

After running mumax3-server in a folder containing subfolders with simulation scripts, I get to access GUI from the web interface, very handy! But the plot doesnt appear:

line 0: warning: Skipping unreadable file "http://192.168.0.122:35360/afmdots/afmdots_05_10.out/table.txt" line 0: No data in plot

Shouldn't it be reading from http://192.168.0.122:35360/fs/afmdots/afmdots_05_10.out/table.txt instead?

This is on mumax3.7a commit e7c58ad

Sometimes my servers have their clocks not in sync, one being late by more than half a minute.
The last seen alive time is written by the server running the job, but watchdog on the server hosting the job compares the time with its own server clock, so it will kill the job prematurely.

For now I'll work around it by ensuring the time is sync'ed correctly (might be due to ntpd not functioning in order)

As reported by Teng Sun and @syockit , one cannot use simultaneously autosave and autosnaphot of the same quantity. This is because they share the same output que (output) and quantity (q), i.e.

output[q] = &autosave{period, Time, -1, save}.

It would be nice to have a switch to enable/disable calculation of torque in specific cells in mumax3.

I'm facing an error while running mumax3 code. I'm pretty new to mumax3 and not sure how to troubleshoot the issue. Appreciate any help regarding this issue.

The content of mx3 file is:
setgridsize(256, 128, 1)
setcellsize(5e-9, 5e-9, 5e-9)

m = NeelSkyrmion(1,-1).scale(3,3,1)
saveas(m, "Néel_skyrmion")

The command executed is below
$ mumax3 mx3test.mx3
//mumax 3.9.1c linux_amd64 go1.6.2 (gc)
//CUDA 7050 Tesla K40t(11519MB) cc3.5, using CC35 PTX
//(c) Arne Vansteenkiste, Dynamat LAB, Ghent University, Belgium
//This is free software without any warranty. See license.txt
//output directory: /home/users/astar/dsi/anibal-g/scratch/neelSK.out/
//starting GUI at http://127.0.0.1:35367
setgridsize(256, 128, 1)
setcellsize(5e-9, 5e-9, 5e-9)
panic: runtime error: cgo argument has Go pointer to Go pointer
panic: runtime error: cgo argument has Go pointer to Go pointer

goroutine 1 [running, locked to thread]:
panic(0x9d14a0, 0xc82119a460)
/app/go/1.6.3/src/runtime/panic.go:481 +0x3e6
github.com/mumax/3/cuda/cu._cgoCheckPointer0(0x8b40e0, 0x10d77a0, 0x0, 0x0, 0x0, 0x8a5440)
??:0 +0x4d
github.com/mumax/3/cuda/cu.LaunchKernel(0x156ab60, 0x8, 0x1, 0x1, 0x200, 0x1, 0x1, 0x0, 0x0, 0x10d77a0, ...)
/app/go/apps/src/github.com/mumax/3/cuda/cu/execution.go:22 +0x107
github.com/mumax/3/cuda.k_reducesum_async(0x2006200000, 0x2006300000, 0x2000000000, 0x8000, 0x10c1a80)
/app/go/apps/src/github.com/mumax/3/cuda/reducesum_wrapper.go:59 +0x1c4
github.com/mumax/3/cuda.Sum(0xc8211e6050, 0xc8211e6050)
/app/go/apps/src/github.com/mumax/3/cuda/reduce.go:22 +0xc4
github.com/mumax/3/engine.sAverageUniverse(0xc8212230e0, 0x0, 0x0, 0x0)
/app/go/apps/src/github.com/mumax/3/engine/average.go:24 +0x247
github.com/mumax/3/engine.sAverageMagnet(0xc8212230e0, 0x0, 0x0, 0x0)
/app/go/apps/src/github.com/mumax/3/engine/average.go:33 +0x75
github.com/mumax/3/engine.(_magnetization).average(0x10d5820, 0x0, 0x0, 0x0)
/app/go/apps/src/github.com/mumax/3/engine/magnetization.go:31 +0x37
github.com/mumax/3/engine.(_comp).average(0xc8211bc020, 0x0, 0x0, 0x0)
/app/go/apps/src/github.com/mumax/3/engine/comp.go:27 +0x52
github.com/mumax/3/engine.(_comp).Average(0xc8211bc020, 0x0)
/app/go/apps/src/github.com/mumax/3/engine/comp.go:28 +0x24
github.com/mumax/3/engine.Close()
/app/go/apps/src/github.com/mumax/3/engine/engine.go:42 +0x74
panic(0x9d14a0, 0xc82119a030)
/app/go/1.6.3/src/runtime/panic.go:443 +0x4e9
github.com/mumax/3/cuda/cu._cgoCheckPointer0(0x8b40e0, 0x10d7988, 0x0, 0x0, 0x0, 0x8a5440)
??:0 +0x4d
github.com/mumax/3/cuda/cu.LaunchKernel(0x1619e70, 0x1, 0x40, 0x1, 0x200, 0x1, 0x1, 0x0, 0x0, 0x10d7988, ...)
/app/go/apps/src/github.com/mumax/3/cuda/cu/execution.go:22 +0x107
github.com/mumax/3/cuda.k_normalize_async(0x2006200000, 0x2006220000, 0x2006240000, 0x0, 0x8000, 0xc8211f6030)
/app/go/apps/src/github.com/mumax/3/cuda/normalize_wrapper.go:62 +0x20b
github.com/mumax/3/cuda.Normalize(0xc8212230e0, 0xc8211e6000)
/app/go/apps/src/github.com/mumax/3/cuda/normalize.go:13 +0x145
github.com/mumax/3/engine.(_magnetization).normalize(0x10d5820)
/app/go/apps/src/github.com/mumax/3/engine/magnetization.go:33 +0x4a
github.com/mumax/3/engine.(_magnetization).SetArray(0x10d5820, 0xc8212a4000)
/app/go/apps/src/github.com/mumax/3/engine/magnetization.go:46 +0x154
github.com/mumax/3/engine.(_magnetization).SetInShape(0x10d5820, 0xb967b8, 0xc820145e30)
/app/go/apps/src/github.com/mumax/3/engine/magnetization.go:108 +0x428
github.com/mumax/3/engine.(_magnetization).Set(0x10d5820, 0xc820145e30)
/app/go/apps/src/github.com/mumax/3/engine/magnetization.go:51 +0x39
github.com/mumax/3/engine.(_magnetization).alloc(0x10d5820)
/app/go/apps/src/github.com/mumax/3/engine/magnetization.go:38 +0xb1
github.com/mumax/3/engine.SetMesh(0x100, 0x80, 0x1, 0x3e35798ee2308c3a, 0x3e35798ee2308c3a, 0x3e35798ee2308c3a, 0x0, 0x0, 0x0)
/app/go/apps/src/github.com/mumax/3/engine/mesh.go:46 +0x382
github.com/mumax/3/engine.SetCellSize(0x3e35798ee2308c3a, 0x3e35798ee2308c3a, 0x3e35798ee2308c3a)
/app/go/apps/src/github.com/mumax/3/engine/mesh.go:105 +0x186
reflect.Value.call(0x96f040, 0xb965d8, 0x13, 0xa8c180, 0x4, 0xc821223090, 0x3, 0x3, 0x0, 0x0, ...)
/app/go/1.6.3/src/reflect/value.go:435 +0x120d
reflect.Value.Call(0x96f040, 0xb965d8, 0x13, 0xc821223090, 0x3, 0x3, 0x0, 0x0, 0x0)
/app/go/1.6.3/src/reflect/value.go:303 +0xb1
github.com/mumax/3/script.(*call).Eval(0xc8200241e0, 0x0, 0x0)
/app/go/apps/src/github.com/mumax/3/script/call.go:61 +0x267
github.com/mumax/3/engine.EvalFile(0xc820024120)
/app/go/apps/src/github.com/mumax/3/engine/script.go:95 +0x21b
main.runFileAndServe(0x7fffffffdeba, 0x31)
/app/go/apps/src/github.com/mumax/3/cmd/mumax3/main.go:144 +0x1e5
main.main()
/app/go/apps/src/github.com/mumax/3/cmd/mumax3/main.go:89 +0x35d

I tired to use a binary from an older release, but it simply cannot start jobs.

If just start a single instance of mumax3 it works

XXX.XXX.XXX.XXX:60001

Uptime: 26s 
Peer nodes

scan 192.168.0.1-128: 35360-35361
ports 35360-35361
Rescan 
Compute service

mumax: //mumax 3.9.3 linux_amd64 go1.7.1 (gc) 
GPU0: //mumax 3.9.3 linux_amd64 go1.7.1 (gc) //CUDA 8000 GeForce GTX 780 Ti(3017MB) cc3.5, using CC35 PTX //(c) Arne Vansteenkiste, Dynamat LAB, Ghent University, Belgium //This is free software without any warranty. See license.txt CUDA 8000 GeForce GTX 780 Ti(3017MB) cc3.5
Running jobs

Queue service

Users

.nv 0 GPU-seconds   no queued jobs
test    0 GPU-seconds   no queued jobs
Next job for: test

Jobs

Reload all (consider reloading just your own files). 
Wake-up Watchdog (re-queue dead simulations right now).
.nv

test

Jobs  Reload (only needed when you changed your files on disk) 
[test/test.mx3] []  []  []  []  []

At line 68 of script/stdlib.go the normal distribution in fact returns an exponential distribution.

i.e.
w.Func("randExp", rand.ExpFloat64, "Exponentially distributed random number between 0 and +inf, mean=1")
w.Func("randNorm", rand.ExpFloat64, "Standard normal random number")

Best, and thanks as always,
Graham

After recent renovation, mumax3 folder is no longer in root folder, so please update the instructions on github page.

CUFFT_COMPATIBILITY_NATIVE mode is broken since cuda7.0+. Since CUFFT_COMPATIBILITY_NATIVE has been marked as DEPRECATED since cuda6.0, Nvidia developers are not willing to fix it. Therefore mumax3 should switch to the default CUFFT_COMPATIBILITY_FFTW_PADDING mode. This is rather big change.

Since Nvidia now suggests to use out-of-place r2c and c2r transforms, i.e. see page 20 of the "CUFFT LIBRARY USER'S GUIDE DU-06707-001_v7.5", then I would prefer to take this route. This will marginally increase mumax3 memory consumption, but is way less harmful, then say touching mighty demag kernel code.

@barnex any thoughts?

In OOMMF's thetaevolve, user is advised to first run the simulation at 0 K, enabling adaptive-step evaluation. And then, the lower boundary is used as the fixed dt value in finite temperature simulation.

Having an option to save the smallest step over all time steps (as done with peakErr) would be nice.

By the way, would it expensive to add another comparison check in adaptDt? It'd be nice if golang supported metaprogramming…

Not sure what causes this, but it happened repeatedly when running similar simulations. MuMax3 just exits unexpectedly after a long run, however sometimes finishes without error.

System file limits:
$ ulimit -Sn
1024
$ ulimit -Hn
4096
$ cat /proc/sys/fs/file-max
2436315

Here is the full log:
running ~/Desktop/mumax3.6.2_linux_x64/mumax3-cuda6.0
//output directory: run/hyst.out/
starting GUI at http://127.0.0.1:35367
setGridSize(512, 512, 2)
setCellSize(20e-9, 20e-9, 20e-9)
DefRegion(0, Layer(0))
DefRegion(1, Layer(1))
Aex.SetRegion(0, 4E-12)
Msat.SetRegion(0, 1.6E+5)
Aex.SetRegion(1, 1.3E-11)
Msat.SetRegion(1, 8.6E+5)
ext_ScaleExchange(0, 1, 0)
Bmax := 20e-3
dB := 0.1e-3
tableadd(B_ext)
m = Uniform(1, 0, 0)
for B := Bmax; B >= -Bmax; B -= dB {
B_ext = vector(B, 0, 0)
relax()
tableSave()
}
//Not using kernel cache (-cache="")
Calculating demag kernel 33 %
Calculating demag kernel 100 %
skipping convolution self-test
for B := -Bmax; B <= Bmax; B += dB {
B_ext = vector(B, 0, 0)
relax()
tableSave()
}
http: panic serving 10.31.4.185:62097: runtime error: invalid memory address or nil pointer dereference
goroutine 16023 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
io/ioutil.func·002()
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:30 +0x11f
bytes.(_Buffer).ReadFrom(0xc20f3c8e00, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/bytes/buffer.go:169 +0x25a
io/ioutil.readAll(0x0, 0x0, 0x200, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:33 +0x1b7
io/ioutil.ReadAll(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:42 +0x68
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20eb66790, 0xc2091cd450)
/home/arne/src/github.com/mumax/3/engine/plot.go:28 +0x543
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20eb66790, 0xc2091cd450)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20eb66790, 0xc2091cd450)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20eb66790, 0xc2091cd450)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20eb66790, 0xc2091cd450)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20e9e7c20)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: panic serving 10.31.4.185:62099: runtime error: invalid memory address or nil pointer dereference
goroutine 16024 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
io/ioutil.func·002()
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:30 +0x11f
bytes.(_Buffer).ReadFrom(0xc209cf6c40, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/bytes/buffer.go:169 +0x25a
io/ioutil.readAll(0x0, 0x0, 0x200, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:33 +0x1b7
io/ioutil.ReadAll(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:42 +0x68
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20eaa49a0, 0xc2091cd6c0)
/home/arne/src/github.com/mumax/3/engine/plot.go:28 +0x543
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20eaa49a0, 0xc2091cd6c0)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20eaa49a0, 0xc2091cd6c0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20eaa49a0, 0xc2091cd6c0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20eaa49a0, 0xc2091cd6c0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20e9e7cc0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: panic serving 10.31.4.185:62101: runtime error: invalid memory address or nil pointer dereference
goroutine 16025 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20ea44210, 0xc20e89d040)
/home/arne/src/github.com/mumax/3/engine/plot.go:26 +0x4ed
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20ea44210, 0xc20e89d040)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20ea44210, 0xc20e89d040)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20ea44210, 0xc20e89d040)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20ea44210, 0xc20e89d040)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20e9e7d60)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 5ms
http: panic serving 10.31.4.185:62103: runtime error: invalid memory address or nil pointer dereference
goroutine 16015 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20eb66dc0, 0xc2091cdba0)
/home/arne/src/github.com/mumax/3/engine/plot.go:26 +0x4ed
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20eb66dc0, 0xc2091cdba0)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20eb66dc0, 0xc2091cdba0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20eb66dc0, 0xc2091cdba0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20eb66dc0, 0xc2091cdba0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20971f900)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 5ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 10ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 20ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 40ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 80ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 160ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 320ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 640ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: panic serving 10.31.4.185:62105: runtime error: invalid memory address or nil pointer dereference
goroutine 15965 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc209bce4d0, 0xc2093c4680)
/home/arne/src/github.com/mumax/3/engine/plot.go:26 +0x4ed
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc209bce4d0, 0xc2093c4680)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc209bce4d0, 0xc2093c4680)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc209bce4d0, 0xc2093c4680)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc209bce4d0, 0xc2093c4680)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20913fd60)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: panic serving 10.31.4.185:62107: runtime error: invalid memory address or nil pointer dereference
goroutine 15910 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20911e210, 0xc209ef6d00)
/home/arne/src/github.com/mumax/3/engine/plot.go:26 +0x4ed
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20911e210, 0xc209ef6d00)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20911e210, 0xc209ef6d00)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20911e210, 0xc209ef6d00)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20911e210, 0xc209ef6d00)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20971f5e0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: panic serving 10.31.4.185:62108: runtime error: invalid memory address or nil pointer dereference
goroutine 16026 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc209ad7ef0, 0xc20803e5b0)
/home/arne/src/github.com/mumax/3/engine/plot.go:26 +0x4ed
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc209ad7ef0, 0xc20803e5b0)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc209ad7ef0, 0xc20803e5b0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc209ad7ef0, 0xc20803e5b0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc209ad7ef0, 0xc20803e5b0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20971f5e0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: panic serving 10.31.4.185:63116: runtime error: invalid memory address or nil pointer dereference
goroutine 16987 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
io/ioutil.func·002()
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:30 +0x11f
bytes.(_Buffer).ReadFrom(0xc2097a6e00, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/bytes/buffer.go:169 +0x25a
io/ioutil.readAll(0x0, 0x0, 0x200, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:33 +0x1b7
io/ioutil.ReadAll(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:42 +0x68
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20955a000, 0xc209e7fe10)
/home/arne/src/github.com/mumax/3/engine/plot.go:28 +0x543
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20955a000, 0xc209e7fe10)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20955a000, 0xc209e7fe10)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20955a000, 0xc209e7fe10)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20955a000, 0xc209e7fe10)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20ebea960)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: panic serving 10.31.4.185:63118: runtime error: invalid memory address or nil pointer dereference
goroutine 16937 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
io/ioutil.func·002()
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:30 +0x11f
bytes.(_Buffer).ReadFrom(0xc209d86d90, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/bytes/buffer.go:169 +0x25a
io/ioutil.readAll(0x0, 0x0, 0x200, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:33 +0x1b7
io/ioutil.ReadAll(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/arne/src/github.com/golang/go/src/io/ioutil/ioutil.go:42 +0x68
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20ebd89a0, 0xc20f8c4b60)
/home/arne/src/github.com/mumax/3/engine/plot.go:28 +0x543
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20ebd89a0, 0xc20f8c4b60)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20ebd89a0, 0xc20f8c4b60)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20ebd89a0, 0xc20f8c4b60)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20ebd89a0, 0xc20f8c4b60)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc209e84280)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: panic serving 10.31.4.185:63120: runtime error: invalid memory address or nil pointer dereference
goroutine 16938 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20955a210, 0xc20ecc81a0)
/home/arne/src/github.com/mumax/3/engine/plot.go:26 +0x4ed
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20955a210, 0xc20ecc81a0)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20955a210, 0xc20ecc81a0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20955a210, 0xc20ecc81a0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20955a210, 0xc20ecc81a0)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc209e84320)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(_Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 5ms
http: panic serving 10.31.4.185:63122: runtime error: invalid memory address or nil pointer dereference
goroutine 16990 [running]:
net/http.func·012()
/home/arne/src/github.com/golang/go/src/net/http/server.go:1187 +0xbb
github.com/mumax/3/engine.(_guistate).servePlot(0xeadcc0, 0x7fa5740612d0, 0xc20955a2c0, 0xc20ecc8340)
/home/arne/src/github.com/mumax/3/engine/plot.go:26 +0x4ed
github.com/mumax/3/engine._guistate.(github.com/mumax/3/engine.servePlot)·fm(0x7fa5740612d0, 0xc20955a2c0, 0xc20ecc8340)
/home/arne/src/github.com/mumax/3/engine/gui.go:107 +0x45
net/http.HandlerFunc.ServeHTTP(0xc2091d4e20, 0x7fa5740612d0, 0xc20955a2c0, 0xc20ecc8340)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1322 +0x41
net/http.(_ServeMux).ServeHTTP(0xc20800a750, 0x7fa5740612d0, 0xc20955a2c0, 0xc20ecc8340)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1598 +0x17d
net/http.serverHandler.ServeHTTP(0xc208064600, 0x7fa5740612d0, 0xc20955a2c0, 0xc20ecc8340)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1760 +0x19a
net/http.(_conn).serve(0xc20ebeab40)
/home/arne/src/github.com/golang/go/src/net/http/server.go:1261 +0xba9
created by net/http.(*Server).Serve
/home/arne/src/github.com/golang/go/src/net/http/server.go:1808 +0x39f
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 5ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 10ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 20ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 40ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 80ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 160ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 320ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 640ms
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
http: Accept error: accept tcp [::]:35367: too many open files; retrying in 1s
/home/arne/src/github.com/mumax/3/engine/table.go:56 open run/hyst.out/table.txt: too many open files
exit status 1

Hello,

We are currently dealing with some crashes, and hard quits for the client and server. Would it be possible to have an "parameter file" that one could upload or export that would set all the parameters in the web client, this way using the web client could be more user friendly.

Would this be hard to add? Because I could take a look at it.

Thanks

I've been trying to define material parameters as a function with little success. I'm not sure what they do, but in the API I see two methods:

SetRegionFuncGo( int func() float64 )
SetRegionValueGo( int float64 )

When I try to call them on the MSat parameter, I get an error as follows:

//script line 1: MSat.SetRegionFuncGo(): *engine.ScalarParam has no method SetRegionFuncGo
//script line 1: MSat.SetRegionValueGo(): *engine.ScalarParam has no method SetRegionValueGo

Any ideas what they do and why they don't work in the example above? Any suggestions as to how I might vary my material parameters without using regions? The motivation is to simulate the effects of reduced magnetisation length from a temperature distribution.

Note, something similar is discussed in issue #15, the loading of parameters is not implemented.

I'm using mumax3.4 on an Ubuntu12.04 amd64 PC with:

• Intel(R) Core(TM)2 Extreme CPU X9650 @ 3.00GHz
• GeForce GTX 550 Ti

I run small scale simulations of 3D objects, with gridsize 10x10x20 of 1nm cubic cells (which is actually better simulated using FEM, but mumax gives good approximation anyway).
Since one simulation doesn't use that much memory, and a mumax3 process uses only one cpu process, I thought I could maximize my resource usage by running 4 at a time.

Effectively, I get reduced amount of total simulation time, running separate simulations require roughly 60 min. to complete per simulation i.e. 240 min. per batch, while running 4 simulateneously will require 160 min.

But I wonder if there's a way to further increase the speedup. My intuition is that the a sync call to GPU for one process will cause other processes to pause their simulation as well, and with many processes calling each other, the pauses build up, causing the effective slowdown per process mentioned above (60 min.→160min.)

Are there better methods to efficiently parallelize the simulations? Like a way for all processes to sync at the same time? (Assuming the number of steps between syncs are roughly similar for all process, this should be faster, right?)

The default output directory for interactive sessions has a format which generates things like mumax-2014-04-01_18:21.out/, but this generates an error under windows since colons is disallowed in folder or file names.

(I hope I'm doing this right!)

I couldn't find any mention anywhere, but I've noticed mumax uses 100% of a single core of the CPU regardless of the simulation size or power of the CPU. I was wondering what it's being used for? If the CPU is being used by other software, will this effect mumax performance?

Hello I'm Aurelio Hierro from University of Porto.

I'm using the mumax3.5 Beta2 and I'm defining the regions by mean of ImageShape function. I observed when the image is loaded and the regions are created, that there is a 1pixel shift up and left so, at the end, the last row and column of the region's out .ovf file are equal to 0 with this region index. Can you fix this?

Thank you for this wonderful micromag. code :).

Best regards.

It looks like the cuFFT bug addressed in issue #52 also affects MFM image generation. At least MFM looks broken on my Ubuntu 15.10, nvidia 352.63, cuda 6.5.12 system.

a9cae13 changes the MFM test so that it panics on my system. It was not really testing anything else than the existence of the MFM quantity. Can someone run the test file on a non-affected system and report the expected value for the average MFM image so I can update the test?

Hi,
I'm trying to follow the instructions in readme.md.

When I run go get -u -v github.com/mumax/3/... I get these errors:

# github.com/mumax/3/cuda/curand
/home/deparkes/gocode/src/github.com/mumax/3/cuda/curand/generator.go:3:20: fatal error: curand.h: No such file or directory
 //#include <curand.h>
                    ^
compilation terminated.
# github.com/barnex/cuda5/cufft
/home/deparkes/gocode/src/github.com/barnex/cuda5/cufft/mode.go:3:19: fatal error: cufft.h: No such file or directory
 //#include <cufft.h>
                   ^
compilation terminated.
# github.com/mumax/3/cuda/cufft
/home/deparkes/gocode/src/github.com/mumax/3/cuda/cufft/mode.go:3:19: fatal error: cufft.h: No such file or directory
 //#include <cufft.h>
                   ^
compilation terminated.

I was wondering if you had any suggestions for what I could do to solve this?

When running multiple simulations in a row through a bash script, I found the title of the web interface (both top of the page, and HTML title) does not change to show the current simulation name. (mumax 3.5)

When trying to randomize exchange between grains I get different results for the following loops:

    for j:=i+i; j<maxRegions; j++{
        arg := 0.5 + 0.0
        ext_ScaleExchange(i, j, arg) 
    }   

and

    for j:=i+i; j<maxRegions; j++{
        arg := 0.5 + 0.0*rand()
        ext_ScaleExchange(i, j, arg) 
    }   

(same goes for arg := rand()*0.0) This suggests that the RHS of the expression is not being properly evaluated within the ext_ScaleExchange call. It seems to print just fine if I run this separately in a text loop using print(arg). The latter loop appears to give the same results as if arg := rand() were being set instead.

In engine/ext_rmsurfacecharge.go, the function compensateLRSurfaceCharges has bsat as a parameter, but is unused.

Shouldn't line 42 be multiplied with bsat?

q := cell[Z] * cell[Y] * bsat

I am trying to simulate voltage-controlled magnetic anisotropy and was wondering is MuMax3 supports time-dependent anisotropy constants. If not, could that be easily integrated into MuMax3?

Thanks,
Kelvin

In a 3D simulation with Slow. and ZhangLi spin torques that considers all layers (free, spacer and polarizer) it will be great to be able to define the spin current polarization to be dinamically equal to the magnetization of the polarizer even in the case of a non-uniformely magnetized polarizer.

mumax3-server complains that the port is already in use. This happens for any port

[ivlis@ou-dell2 mumax3_scripts]$ /opt/mumax3/mumax3.7_linux/mumax3-server -exec /opt/mumax3/mumax3.7_linux/mumax3-cuda7.0 -l :60000
2015/05/05 07:56:01 have //mumax 3.7 linux_amd64 go1.4.2 (gc)
2015/05/05 07:56:02 gpu 0 : //mumax 3.7 linux_amd64 go1.4.2 (gc)
//CUDA 7000 GeForce GTX 780 Ti(3071MB) cc3.5, using CC35 PTX 
//(c) Arne Vansteenkiste, Dynamat LAB, Ghent University, Belgium
//This is free software without any warranty. See license.txt
CUDA 7000 GeForce GTX 780 Ti(3071MB) cc3.5
2015/05/05 07:56:02 LoadUserJobs 1
2015/05/05 07:56:02 serving at ou-dell2:60000
2015/05/05 07:56:02 listen tcp 141.210.115.253:60000: bind: address already in use

It happens with any port, even if mumax3 is run under root. There is no other servers on this PC:

[ivlis@ou-dell2 mumax3_scripts]$ netstat -lnpt 
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:5355            0.0.0.0:*               LISTEN      -                   
tcp6       0      0 :::5355                 :::*                    LISTEN      -       

The most interesting thing is that, in a very rear case (maybe 1:20) the server does start! I cannot figure out the conditions on that.

Hi,

While running simulations, I constantly get Cuda error message. It is something like "CUDA illegal instructions", "Unknwon CU result: 700". It happens not only at the beginning of the simulation, but also at the middle or towards the end. How do I resolve this issue? Thank you.

I wanna know, if there're a function to have a radial anisotropy, for example for a cylinder geometry

Thanks :)

When running with 2,2,2 pbcs, for example, the following output is given. Also the simulation typically pauses for a while before beginning — the GUI reports the demag tensor is still being calculated after the command line input has indicated that the calculation is complete.

This is from github source I pulled earlier today.

[Did not use cached kernel: open ../cache/mumax3kernel_[128 128 1][2 2 2][5e-09 5e-09 6e-10]_6_0 0.ovf: no such file or directory]
Calculating demag kernel 0 %
Calculating demag kernel 25 %
Calculating demag kernel 26 %
Calculating demag kernel 76 %
Calculating demag kernel 77 %
Calculating demag kernel 100 %
Calculating demag kernel 126 %
Calculating demag kernel 127 %

Is there any way to reload a previous state in order to re-launch a new simulation with new parameters from a previously saved starting point?

I'm trying to set a granular system, generated by ext_makegrains and I want to modify several aspects of the simulation: In order to compare results I would need to use the same starting point but, as far as I see in the API, you can only feed mumax with regions and m (besides excitation), but there is no "loadfile" method for A, Msat or K1 (magnitude nor vector). Could it be easily possible to add the load method in order to load these parameters?

When you define a grain-dependent material it's important to be able to fully save the initial material configuration (Msat, anisotropy, exchange... not only the magnetization state). In the same way, it would be useful in order to restart/repeat a simulation in the same way that OOMMF does, by adding a lot of parameters in the same OVF file (instead of saving only one magnitude) or by adding parameters to the simulation by loading several OVF files.

@barnex as of go 1.6 "Briefly, Go and C may share memory allocated by Go when a pointer to that memory is passed to C as part of a cgo call, provided that the memory itself contains no pointers to Go-allocated memory, and provided that C does not retain the pointer after the call returns."

Not really sure why mumax is affected, but it now needs some love)

Forcing GODEBUG=cgocheck=0 does not show any further incompatibilities.

The ext_rmSurfaceCharge function works only for in-plane magnetized systems. Is there a function to remove magnetic surface charge to simulate infinitely long wire with perpendicular anisotropy?

We have a GTX Titan X running on windows 8.1 with CUDA 7.5 and updated drivers. We are unable to use the energy minimizer solver present in the 3.9c version of Mumax3. All the other modules work properly but when the minimizer starts to work the error:

CUDA_ERROR_INVALID_IMAGE appears and the simulation stops showing some panic messages.

Should be it because of the version of cuda libraries used in the windows compilation of Mumax3 (version 6.5) and the fact that the graphic board is very recent?

Thank you.

Hi all,

I've encountered the following error after setting up a system with the configuration details as below, using the precompiled version of mumax3:

mumax 3.9.1c windows_amd64 go1.3.3 (gc)
CUDA 8000 GeForce GTX 1080(8192MB) cc6.1, using CC53 PTX

During the simulation, the generation of the mesh and even the relax() phase works properly. However at the end of relax(), before the simulation runs it gives:

panic: CURAND_STATUS_LAUNCH_FAILURE

goroutine 16 [running]:
runtime.panic(0x8af1a0, 0xc9)
        c:/go/src/pkg/runtime/panic.c:279 +0x11f
github.com/mumax/3/cuda/curand.Generator.GenerateNormal(0x14d61f0, 0x70b000000, 0x80000, 0x3f80000000000000)
        C:/Users/Arne/src/github.com/mumax/3/cuda/curand/generator.go:41 +0x7a

If I set the temperature to 0K it works fine. It seems that the error with CURAND comes from compatibility with the GTX1080 architecture and may need update to CUDA8.0?

BVLC/caffe#4324

Would building Mumax3 with CUDA8.0 solve this issue? I've tried, however I could not build. I got an error related to the CUDA header files, exactly as in issue #18, despite I changed the //windows lines in the different cgoflags.go to be

//#cgo windows LDFLAGS:-LC:/cuda/v5.0/lib/x64 -LC:/cuda/v5.5/lib/x64 -LC:/cuda/v6.0/lib/x64 -LC:/cuda/v6.5/lib/x64 -LC:/cuda/v7.0/lib/x64 -LC:/cuda/v8.0/lib/x64
//#cgo windows CFLAGS: -IC:/cuda/v5.0/include -IC:/cuda/v5.5/include -IC:/cuda/v6.0/include -IC:/cuda/v6.5/include -IC:/cuda/v7.0/include -IC:/cuda/v8.0/include

Actually I also tried different ways and paths to include the headers but only manually adding the full path of a header file seems to work, not any path in the //#cgo commands. What could cause this?

Thank you for your help and comments!

It'd be nice if I could load magnetizations as Config to be put into regions/shapes.

(The main reason I need this is because I need to pad my shapes to see demags, but it could be useful for purposes such as putting configs of two different files on different coordinates.)

I get the following error when trying to run a temperature simulation (temp = ...) with any solver

Finite temperature requires fixed time step. Set FixDt != 0.

Reading the rk45 source, I see that the 437e026 commit tried to get adaptive time step to work with temperature simulations.

Is this error simply because the temperature.go hasn't been updated to reflect the changes? Can this be updated and an adaptive time step now be used?

2014/11/12 15:51:19 makeProcess do http://157.193.57.146:35360/append/goed/local_bias_12mT_uniform_distr.out/stdout.txt:500 Internal Server Error:open goed/local_bias_12mT_uniform_distr.out/stdout.txt: no such file or directory

2014/11/12 15:51:19 => exec /home/mumax/bin/mumax3 [/home/mumax/bin/mumax3 -gpu=0 -http=157.193.57.146:35367 -cache= -f=0 http://157.193.57.146:35360/goed/lo
cal_bias_12mT_uniform_distr.mx3]
panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xb code=0x1 addr=0x0 pc=0x403baa]

goroutine 106 [running]:
main.(*Process).Run(0xc208176c40)
/home/arne/src/github.com/mumax/3/cmd/mumax3-server/compute.go:189 +0x150a
main.func·003()
/home/arne/src/github.com/mumax/3/cmd/mumax3-server/compute.go:73 +0x185
created by main.RunComputeService
/home/arne/src/github.com/mumax/3/cmd/mumax3-server/compute.go:86 +0x3ff

When "m" is set as an output, only the normalized sum of magnetization UNITARY vectors is shown instead the normalized magnetization.
If you are only working with 1 magnetic material the result is exactly the same, but in multilayers, with several M_{s} for each material, m.Comp(0), m..Comp(1) and m..Comp(2) shows only:

m.Comp(i)=1/(Sum(i=1:n)(i))*Sum(i=1:n)(vector_{n}.Comp(i))

instead of

m.Comp(i){corrected}=1/(Sum(i=1:n)(msat{n})) * Sum(i=1:n)( msat_{n}*vector_{n}.Comp(i) )

thus, contribution to the total (normalized) magnetization of several materials results to be exactly the same and mfull and m hysteresis loops are different (besides normalization term).
Could it be a mislocated parenthesis? Note that:

1/(Sum(i=1:n) (msat_{n})) * Sum(i=1:n) ( msat_{n}vector{n} ) != ...
Sum(i=1:n) ( 1/(msat_{n})msat{n}*vector_{n} ) = Sum(i=1:n) ( vector_{n} )

P.S. Great work anyway.

Anders Eklund:
"Since our devices present inhomogeneous fields and hence polarizer magnetizations (for the fixed layer magnetization at 30 mA, theta has a spatial deviation +/- 5 deg and phi +/- 15 deg) it would obviously be an advantage to be able to account for this in the most realistic way."

I have the following error when I use an odd number for the Nx cell and I use periodic boundary conditions. I think there is a small error in some integer division.

Below there is a typical example. There is a mismatch in the fft length.

If it the example I exchange x by y does not happen because 182 is an even number. Whenever Nx is odd and PBC are on in that direction I get the error.

//mumax 3.9.1c linux_amd64 go1.3.3 (gc)
//CUDA 8000 GeForce GT 640(2047MB) cc3.0, using CC30 PTX
//(c) Arne Vansteenkiste, Dynamat LAB, Ghent University, Belgium
//This is free software without any warranty. See license.txt
//output directory: array_red.out/
//starting GUI at http://127.0.0.1:35367
Nx := 105
Ny := 182
Nz := 32
lx := 105e-9
ly := 182e-9
lz := 32e-9
dx := lx / Nx
dy := ly / Ny
dz := lz / Nz
SetPBC(3, 3, 0)
SetGridSize(Nx, Ny, Nz)
SetCellSize(dx, dy, dz)
m = uniform(0, 0.1, 1)
Msat = 1.4e6
Aex = 1.3e-11
Ku1 = 4.5e5
Ku2 = 1.5e5
anisU = vector(0, 0, 1)
save(B_demag)
//Not using kernel cache (-cache="")
// Calculating demag kernel 49 %
// Calculating demag kernel 73 %
// Calculating demag kernel 99 %
// Calculating demag kernel 100 %
fft size mismatch: expecting dst len 1246336, got 1234688
panic: fft size mismatch: expecting dst len 1246336, got 1234688

goroutine 16 [running]:
runtime.panic(0x7ebd60, 0xc2096a7690)
/usr/lib/go/src/pkg/runtime/panic.c:279 +0xf5
log.Panicf(0x9fefd0, 0x2f, 0xc209121128, 0x2, 0x2)
/usr/lib/go/src/pkg/log/log.go:314 +0xcd
github.com/mumax/3/cuda.(_fft3DR2CPlan).ExecAsync(0xc20911c2c0, 0xc2090cc910, 0xc2090cc820)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/cuda/fft3dr2c.go:41 +0x254
github.com/mumax/3/cuda.(_DemagConvolution).init(0xc20911c200, 0xc209180050, 0xc2091805a0, 0xc209180a00, 0xc2091805a0, 0xc209181720, 0xc2090cc280, 0xc209180a00, 0xc2090cc280, 0xc2090cd180)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/cuda/conv_demag.go:159 +0x65e
github.com/mumax/3/cuda.NewDemag(0x69, 0xb6, 0x20, 0x3, 0x3, 0x0, 0xc209180050, 0xc2091805a0, 0xc209180a00, 0xc2091805a0, ...)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/cuda/conv_demag.go:28 +0xf0
github.com/mumax/3/engine.demagConv(0x0)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/demag.go:116 +0x308
github.com/mumax/3/engine.SetDemagField(0xc209181e00)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/demag.go:52 +0x4c
github.com/mumax/3/engine.(__setter).Set(0xf80400, 0xc209181e00)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/setter.go:27 +0x30
github.com/mumax/3/engine.(__setter).Slice(0xf80400, 0x0, 0xc20918bc00)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/setter.go:22 +0xc1
github.com/mumax/3/engine.SaveAs(0x7ffbf31fae60, 0xf80400, 0xc20918bc20, 0x1f)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/save.go:69 +0x238
github.com/mumax/3/engine.Save(0x7ffbf31fae60, 0xf80400)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/save.go:55 +0xf9
reflect.Value.call(0x7fad60, 0xa5d738, 0x0, 0x130, 0x95d9b0, 0x4, 0xc20918bbc0, 0x1, 0x1, 0x0, ...)
/usr/lib/go/src/pkg/reflect/value.go:563 +0x1210
reflect.Value.Call(0x7fad60, 0xa5d738, 0x0, 0x130, 0xc20918bbc0, 0x1, 0x1, 0x0, 0x0, 0x0)
/usr/lib/go/src/pkg/reflect/value.go:411 +0xd7
github.com/mumax/3/script.(*call).Eval(0xc2080b4330, 0x0, 0x0)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/script/call.go:61 +0x256
github.com/mumax/3/engine.EvalFile(0xc2080b4120)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/script.go:99 +0x1e0
main.runFileAndServe(0x7ffcf079a54c, 0xd)
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/cmd/mumax3/main.go:144 +0x1da
main.main()
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/cmd/mumax3/main.go:89 +0x2bf

goroutine 19 [finalizer wait]:
runtime.park(0x41b8e0, 0xf7deb0, 0xf68a69)
/usr/lib/go/src/pkg/runtime/proc.c:1369 +0x89
runtime.parkunlock(0xf7deb0, 0xf68a69)
/usr/lib/go/src/pkg/runtime/proc.c:1385 +0x3b
runfinq()
/usr/lib/go/src/pkg/runtime/mgc0.c:2644 +0xcf
runtime.goexit()
/usr/lib/go/src/pkg/runtime/proc.c:1445

goroutine 20 [chan receive]:
github.com/mumax/3/engine.runSaver()
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/asyncio.go:40 +0x50
created by github.com/mumax/3/engine.init·2
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/asyncio.go:24 +0x9c

goroutine 17 [syscall]:
runtime.goexit()
/usr/lib/go/src/pkg/runtime/proc.c:1445

goroutine 33 [IO wait]:
net.runtime_pollWait(0x7ffbf3205788, 0x72, 0x0)
/usr/lib/go/src/pkg/runtime/netpoll.goc:146 +0x66
net.(_pollDesc).Wait(0xc2091080d0, 0x72, 0x0, 0x0)
/usr/lib/go/src/pkg/net/fd_poll_runtime.go:84 +0x46
net.(_pollDesc).WaitRead(0xc2091080d0, 0x0, 0x0)
/usr/lib/go/src/pkg/net/fd_poll_runtime.go:89 +0x42
net.(_netFD).accept(0xc209108070, 0xa5e290, 0x0, 0x7ffbf31fa418, 0xb)
/usr/lib/go/src/pkg/net/fd_unix.go:419 +0x343
net.(_TCPListener).AcceptTCP(0xc2090d4160, 0xc2090dc6a8, 0x0, 0x0)
/usr/lib/go/src/pkg/net/tcpsock_posix.go:234 +0x5d
net.(_TCPListener).Accept(0xc2090d4160, 0x0, 0x0, 0x0, 0x0)
/usr/lib/go/src/pkg/net/tcpsock_posix.go:244 +0x4b
net/http.(_Server).Serve(0xc2090f2060, 0x7ffbf32047e0, 0xc2090d4160, 0x0, 0x0)
/usr/lib/go/src/pkg/net/http/server.go:1698 +0x91
net/http.Serve(0x7ffbf32047e0, 0xc2090d4160, 0x0, 0x0, 0x0, 0x0)
/usr/lib/go/src/pkg/net/http/server.go:1576 +0x7c
github.com/mumax/3/engine.func·085()
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/gui.go:537 +0x38
created by github.com/mumax/3/engine.GoServe
/home/felipe/mumax_versions/mumax_3.9.1/src/github.com/mumax/3/engine/gui.go:537 +0x2e3

When i try to use minimize() function, mumax has crashed and showed me a this error:

(Only when i'm using mimize(), relax() works fine)

Win 7 64-bit GTX 980 TI MSI Lightening

//mumax 3.9c windows_amd64 go1.3.3 (gc)
//CUDA 7050 GeForce GTX 980 Ti(6144MB) cc5.2, using CC52 PTX
//(c) Arne Vansteenkiste, Dynamat LAB, Ghent University, Belgium
//This is free software without any warranty. See license.txt
//output directory: .\test.out/
//starting GUI at http://127.0.0.1:35367
SetGridsize(128, 32, 1)
SetCellsize(4e-9, 4e-9, 30e-9)
Msat = 800e3
Aex = 13e-12
m = randomMag()
B_ext = vector(0, 1, 0)
relax()
//Not using kernel cache (-cache="")
// Calculating demag kernel 1 %
// Calculating demag kernel 100 %
Bmax := 100.0e-3
Bstep := 1.0e-3
MinimizerStop = 1e-6
TableAdd(B_ext)
for B := 0.0; B <= Bmax; B += Bstep {
B_ext = vector(B, 0, 0)
minimize()
tablesave()
}
panic: CUDA_ERROR_INVALID_IMAGE
goroutine 16 [running]:
runtime.panic(0x8ae900, 0xc8)
c:/go/src/pkg/runtime/panic.c:279 +0x11f
github.com/mumax/3/cuda/cu.ModuleLoadData(0x0, 0x0, 0x34)
C:/Users/Arne/src/github.com/mumax/3/cuda/cu/module.go:31 +0x87
github.com/mumax/3/cuda.fatbinLoad(0xc08205cb10, 0x9a46b0, 0x8, 0x8e4de0)
C:/Users/Arne/src/github.com/mumax/3/cuda/fatbin.go:12 +0x6f
github.com/mumax/3/cuda.k_minimize_async(0x23062c0000, 0x23062c4000, 0x23062c8000, 0x23062ec000, 0x23062e8000, 0x23062e4
000, 0x23062e0000, 0x23062dc000, 0x23062d8000, 0x38d1b717, ...)
C:/Users/Arne/src/github.com/mumax/3/cuda/minimize_wrapper.go:64 +0xd7
github.com/mumax/3/cuda.Minimize(0xc08317eaa0, 0xc08385a4b0, 0xc08385a230, 0x38d1b717)
C:/Users/Arne/src/github.com/mumax/3/cuda/minimize.go:16 +0x235
github.com/mumax/3/engine.(*Minimizer).Step(0xc0837de700)
C:/Users/Arne/src/github.com/mumax/3/engine/minimizer.go:69 +0x13b
github.com/mumax/3/engine.step(0x7ec401)
C:/Users/Arne/src/github.com/mumax/3/engine/run.go:196 +0x3a
github.com/mumax/3/engine.runWhile(0xc0820576e8, 0xc08385a201)
C:/Users/Arne/src/github.com/mumax/3/engine/run.go:181 +0x95
github.com/mumax/3/engine.RunWhile(0xc0820576e8)
C:/Users/Arne/src/github.com/mumax/3/engine/run.go:172 +0x40
github.com/mumax/3/engine.Minimize()
C:/Users/Arne/src/github.com/mumax/3/engine/minimizer.go:157 +0x2fe
reflect.Value.call(0x7ffda0, 0xa75a90, 0x0, 0x130, 0x971130, 0x4, 0xd66698, 0x0, 0x0, 0x0, ...)
c:/go/src/pkg/reflect/value.go:563 +0x1217

how do I implement an exchange bias in mumax?
I can get through the DMI?

The 3.9.1c release does not have a binary linked with cuda 7.0 libraries.