// Writes data in OMF Binary 4 format
func writeOVF1Binary4(out io.Writer, array *data.Slice) (err error) {
data := array.Tensors()
gridsize := array.Size()
var bytes []byte
// OOMMF requires this number to be first to check the format
var controlnumber float32 = OVF_CONTROL_NUMBER_4
// Conversion form float32 [4]byte in big-endian
// Inlined for performance, terabytes of data will pass here...
bytes = (*[4]byte)(unsafe.Pointer(&controlnumber))[:]
bytes[0], bytes[1], bytes[2], bytes[3] = bytes[3], bytes[2], bytes[1], bytes[0] // swap endianess
_, err = out.Write(bytes)
ncomp := array.NComp()
for iz := 0; iz < gridsize[Z]; iz++ {
for iy := 0; iy < gridsize[Y]; iy++ {
for ix := 0; ix < gridsize[X]; ix++ {
for c := 0; c < ncomp; c++ {
// dirty conversion from float32 to [4]byte
bytes = (*[4]byte)(unsafe.Pointer(&data[c][iz][iy][ix]))[:]
bytes[0], bytes[1], bytes[2], bytes[3] = bytes[3], bytes[2], bytes[1], bytes[0]
out.Write(bytes)
}
}
}
}
return
}
// Render on existing image buffer. Resize it if needed
func On(img *image.RGBA, f *data.Slice, fmin, fmax string, arrowSize int, colormap ...color.RGBA) {
dim := f.NComp()
switch dim {
default:
log.Fatalf("unsupported number of components: %v", dim)
case 3:
drawVectors(img, f.Vectors(), arrowSize)
case 1:
min, max := extrema(f.Host()[0])
if fmin != "auto" {
m, err := strconv.ParseFloat(fmin, 32)
if err != nil {
util.Fatal("draw: scale:", err)
}
min = float32(m)
}
if fmax != "auto" {
m, err := strconv.ParseFloat(fmax, 32)
if err != nil {
util.Fatal("draw: scale:", err)
}
max = float32(m)
}
if min == max {
min -= 1
max += 1 // make it gray instead of black
}
drawFloats(img, f.Scalars(), min, max, colormap...)
}
}
func dumpGnuplot(f *data.Slice, m data.Meta, out io.Writer) {
buf := bufio.NewWriter(out)
defer buf.Flush()
data := f.Tensors()
cellsize := m.CellSize
// If no cell size is set, use generic cell index.
if cellsize == [3]float64{0, 0, 0} {
cellsize = [3]float64{1, 1, 1}
}
ncomp := f.NComp()
for iz := range data[0] {
z := float64(iz) * cellsize[Z]
for iy := range data[0][iz] {
y := float64(iy) * cellsize[Y]
for ix := range data[0][iz][iy] {
x := float64(ix) * cellsize[X]
fmt.Fprint(buf, x, DELIM, y, DELIM, z, DELIM)
for c := 0; c < ncomp-1; c++ {
fmt.Fprint(buf, data[c][iz][iy][ix], DELIM)
}
fmt.Fprint(buf, data[ncomp-1][iz][iy][ix])
fmt.Fprint(buf, "\n")
}
fmt.Fprint(buf, "\n")
}
}
}
func writeOVF2DataBinary4(out io.Writer, array *data.Slice) {
//w.count(w.out.Write((*(*[1<<31 - 1]byte)(unsafe.Pointer(&list[0])))[0 : 4*len(list)])) // (shortcut)
data := array.Tensors()
size := array.Size()
var bytes []byte
// OOMMF requires this number to be first to check the format
var controlnumber float32 = OVF_CONTROL_NUMBER_4
bytes = (*[4]byte)(unsafe.Pointer(&controlnumber))[:]
out.Write(bytes)
ncomp := array.NComp()
for iz := 0; iz < size[Z]; iz++ {
for iy := 0; iy < size[Y]; iy++ {
for ix := 0; ix < size[X]; ix++ {
for c := 0; c < ncomp; c++ {
bytes = (*[4]byte)(unsafe.Pointer(&data[c][iz][iy][ix]))[:]
out.Write(bytes)
}
}
}
}
}
// dst += LUT[region], for vectors. Used to add terms to excitation.
func RegionAddV(dst *data.Slice, lut LUTPtrs, regions *Bytes) {
util.Argument(dst.NComp() == 3)
N := dst.Len()
cfg := make1DConf(N)
k_regionaddv_async(dst.DevPtr(X), dst.DevPtr(Y), dst.DevPtr(Z),
lut[X], lut[Y], lut[Z], regions.Ptr, N, cfg)
}
// shift dst by shx cells (positive or negative) along X-axis.
// new edge value is clampL at left edge or clampR at right edge.
func ShiftX(dst, src *data.Slice, shiftX int, clampL, clampR float32) {
util.Argument(dst.NComp() == 1 && src.NComp() == 1)
util.Assert(dst.Len() == src.Len())
N := dst.Size()
cfg := make3DConf(N)
k_shiftx_async(dst.DevPtr(0), src.DevPtr(0), N[X], N[Y], N[Z], shiftX, clampL, clampR, cfg)
}
// Write the slice to out in binary format. Add time stamp.
func Write(out io.Writer, s *data.Slice, info data.Meta) error {
w := newWriter(out)
// Writes the header.
w.writeString(MAGIC)
w.writeUInt64(uint64(s.NComp()))
size := s.Size()
w.writeUInt64(uint64(size[2])) // backwards compatible coordinates!
w.writeUInt64(uint64(size[1]))
w.writeUInt64(uint64(size[0]))
cell := info.CellSize
w.writeFloat64(cell[2])
w.writeFloat64(cell[1])
w.writeFloat64(cell[0])
w.writeString(info.MeshUnit)
w.writeFloat64(info.Time)
w.writeString("s") // time unit
w.writeString(info.Name)
w.writeString(info.Unit)
w.writeUInt64(4) // precission
// return header write error before writing data
if w.err != nil {
return w.err
}
w.writeData(s)
w.writeHash()
return w.err
}
// Sets vector dst to zero where mask != 0.
func ZeroMask(dst *data.Slice, mask LUTPtr, regions *Bytes) {
N := dst.Len()
cfg := make1DConf(N)
for c := 0; c < dst.NComp(); c++ {
k_zeromask_async(dst.DevPtr(c), unsafe.Pointer(mask), regions.Ptr, N, cfg)
}
}
// kernel multiplication for 3D demag convolution, exploiting full kernel symmetry.
func kernMulRSymm3D_async(fftM [3]*data.Slice, Kxx, Kyy, Kzz, Kyz, Kxz, Kxy *data.Slice, Nx, Ny, Nz int) {
util.Argument(fftM[X].NComp() == 1 && Kxx.NComp() == 1)
cfg := make3DConf([3]int{Nx, Ny, Nz})
k_kernmulRSymm3D_async(fftM[X].DevPtr(0), fftM[Y].DevPtr(0), fftM[Z].DevPtr(0),
Kxx.DevPtr(0), Kyy.DevPtr(0), Kzz.DevPtr(0), Kyz.DevPtr(0), Kxz.DevPtr(0), Kxy.DevPtr(0),
Nx, Ny, Nz, cfg)
}
// kernel multiplication for 2D demag convolution on X and Y, exploiting full kernel symmetry.
func kernMulRSymm2Dxy_async(fftMx, fftMy, Kxx, Kyy, Kxy *data.Slice, Nx, Ny int) {
util.Argument(fftMy.NComp() == 1 && Kxx.NComp() == 1)
cfg := make3DConf([3]int{Nx, Ny, 1})
k_kernmulRSymm2Dxy_async(fftMx.DevPtr(0), fftMy.DevPtr(0),
Kxx.DevPtr(0), Kyy.DevPtr(0), Kxy.DevPtr(0),
Nx, Ny, cfg)
}
// Copies src (larger) into dst (smaller).
// Used to extract demag field after convolution on padded m.
func copyUnPad(dst, src *data.Slice, dstsize, srcsize [3]int) {
util.Argument(dst.NComp() == 1 && src.NComp() == 1)
util.Argument(dst.Len() == prod(dstsize) && src.Len() == prod(srcsize))
cfg := make3DConf(dstsize)
k_copyunpad_async(dst.DevPtr(0), dstsize[X], dstsize[Y], dstsize[Z],
src.DevPtr(0), srcsize[X], srcsize[Y], srcsize[Z], cfg)
}
// Set Bth to thermal noise (Brown).
// see temperature.cu
func SetTemperature(Bth, noise *data.Slice, temp_red LUTPtr, k2mu0_VgammaDt float64, regions *Bytes) {
util.Argument(Bth.NComp() == 1 && noise.NComp() == 1)
N := Bth.Len()
cfg := make1DConf(N)
k_settemperature_async(Bth.DevPtr(0), noise.DevPtr(0), float32(k2mu0_VgammaDt), unsafe.Pointer(temp_red),
regions.Ptr, N, cfg)
}
func shiftMag(m *data.Slice, dx int) {
m2 := cuda.Buffer(1, m.Size())
defer cuda.Recycle(m2)
for c := 0; c < m.NComp(); c++ {
comp := m.Comp(c)
cuda.ShiftX(m2, comp, dx, float32(ShiftMagL[c]), float32(ShiftMagR[c]))
data.Copy(comp, m2) // str0 ?
}
}
// average of slice over universe
func sAverageUniverse(s *data.Slice) []float64 {
nCell := float64(prod(s.Size()))
avg := make([]float64, s.NComp())
for i := range avg {
avg[i] = float64(cuda.Sum(s.Comp(i))) / nCell
checkNaN1(avg[i])
}
return avg
}
// Copies src into dst, which is larger, and multiplies by vol*Bsat.
// The remainder of dst is not filled with zeros.
// Used to zero-pad magnetization before convolution and in the meanwhile multiply m by its length.
func copyPadMul(dst, src, vol *data.Slice, dstsize, srcsize [3]int, Msat MSlice) {
util.Argument(dst.NComp() == 1 && src.NComp() == 1)
util.Assert(dst.Len() == prod(dstsize) && src.Len() == prod(srcsize))
cfg := make3DConf(srcsize)
k_copypadmul2_async(dst.DevPtr(0), dstsize[X], dstsize[Y], dstsize[Z],
src.DevPtr(0), srcsize[X], srcsize[Y], srcsize[Z],
Msat.DevPtr(0), Msat.Mul(0), vol.DevPtr(0), cfg)
}
// Copies src into dst, which is larger, and multiplies by vol*Bsat.
// The remainder of dst is not filled with zeros.
// Used to zero-pad magnetization before convolution and in the meanwhile multiply m by its length.
func copyPadMul(dst, src, vol *data.Slice, dstsize, srcsize [3]int, Bsat LUTPtr, regions *Bytes) {
util.Argument(dst.NComp() == 1 && src.NComp() == 1)
util.Assert(dst.Len() == prod(dstsize) && src.Len() == prod(srcsize))
cfg := make3DConf(srcsize)
k_copypadmul_async(dst.DevPtr(0), dstsize[X], dstsize[Y], dstsize[Z],
src.DevPtr(0), vol.DevPtr(0), srcsize[X], srcsize[Y], srcsize[Z],
unsafe.Pointer(Bsat), regions.Ptr, cfg)
}
// Dot product.
func Dot(a, b *data.Slice) float32 {
nComp := a.NComp()
util.Argument(nComp == b.NComp())
out := reduceBuf(0)
// not async over components
for c := 0; c < nComp; c++ {
k_reducedot_async(a.DevPtr(c), b.DevPtr(c), out, 0, a.Len(), reducecfg) // all components add to out
}
return copyback(out)
}
// Set Bth to thermal noise (Brown).
// see temperature.cu
func SetTemperature(Bth, noise *data.Slice, k2mu0_Mu0VgammaDt float64, Msat, Temp, Alpha MSlice) {
util.Argument(Bth.NComp() == 1 && noise.NComp() == 1)
N := Bth.Len()
cfg := make1DConf(N)
k_settemperature2_async(Bth.DevPtr(0), noise.DevPtr(0), float32(k2mu0_Mu0VgammaDt),
Msat.DevPtr(0), Msat.Mul(0),
Temp.DevPtr(0), Temp.Mul(0),
Alpha.DevPtr(0), Alpha.Mul(0),
N, cfg)
}
// average of slice over the magnet volume
func sAverageMagnet(s *data.Slice) []float64 {
if geometry.Gpu().IsNil() {
return sAverageUniverse(s)
} else {
avg := make([]float64, s.NComp())
for i := range avg {
avg[i] = float64(cuda.Dot(s.Comp(i), geometry.Gpu())) / magnetNCell()
checkNaN1(avg[i])
}
return avg
}
}
func divN1(dst, a, b *data.Slice) {
util.Assert(dst.NComp() == a.NComp())
util.Assert(b.NComp() == 1)
for c := 0; c < dst.NComp(); c++ {
cuda.Div(dst.Comp(c), a.Comp(c), b)
}
}
// mul1N pointwise multiplies a scalar (1-component) with an N-component vector,
// yielding an N-component vector stored in dst.
func mul1N(dst, a, b *data.Slice) {
util.Assert(a.NComp() == 1)
util.Assert(dst.NComp() == b.NComp())
for c := 0; c < dst.NComp(); c++ {
cuda.Mul(dst.Comp(c), a, b.Comp(c))
}
}
// Memset sets the Slice's components to the specified values.
// To be carefully used on unified slice (need sync)
func Memset(s *data.Slice, val ...float32) {
if Synchronous { // debug
Sync()
timer.Start("memset")
}
util.Argument(len(val) == s.NComp())
for c, v := range val {
cu.MemsetD32Async(cu.DevicePtr(uintptr(s.DevPtr(c))), math.Float32bits(v), int64(s.Len()), stream0)
}
if Synchronous { //debug
Sync()
timer.Stop("memset")
}
}
// Writes the data.
func (w *writer) writeData(array *data.Slice) {
data := array.Tensors()
size := array.Size()
ncomp := array.NComp()
for c := 0; c < ncomp; c++ {
for iz := 0; iz < size[2]; iz++ {
for iy := 0; iy < size[1]; iy++ {
for ix := 0; ix < size[0]; ix++ {
w.writeFloat32(data[c][iz][iy][ix])
}
}
}
}
}
// Select and resize one layer for interactive output
func Resize(dst, src *data.Slice, layer int) {
dstsize := dst.Size()
srcsize := src.Size()
util.Assert(dstsize[Z] == 1)
util.Assert(dst.NComp() == 1 && src.NComp() == 1)
scalex := srcsize[X] / dstsize[X]
scaley := srcsize[Y] / dstsize[Y]
util.Assert(scalex > 0 && scaley > 0)
cfg := make3DConf(dstsize)
k_resize_async(dst.DevPtr(0), dstsize[X], dstsize[Y], dstsize[Z],
src.DevPtr(0), srcsize[X], srcsize[Y], srcsize[Z], layer, scalex, scaley, cfg)
}
// read data block in text format, for OVF1 and OVF2
func readOVFDataText(in io.Reader, t *data.Slice) {
size := t.Size()
data := t.Tensors()
for iz := 0; iz < size[Z]; iz++ {
for iy := 0; iy < size[Y]; iy++ {
for ix := 0; ix < size[X]; ix++ {
for c := 0; c < t.NComp(); c++ {
_, err := fmt.Fscan(in, &data[c][iz][iy][ix])
if err != nil {
panic(err)
}
}
}
}
}
}
func writeOVF2Header(out io.Writer, q *data.Slice, meta data.Meta) {
gridsize := q.Size()
cellsize := meta.CellSize
fmt.Fprintln(out, "# OOMMF OVF 2.0")
hdr(out, "Segment count", "1")
hdr(out, "Begin", "Segment")
hdr(out, "Begin", "Header")
hdr(out, "Title", meta.Name)
hdr(out, "meshtype", "rectangular")
hdr(out, "meshunit", "m")
hdr(out, "xmin", 0)
hdr(out, "ymin", 0)
hdr(out, "zmin", 0)
hdr(out, "xmax", cellsize[X]*float64(gridsize[X]))
hdr(out, "ymax", cellsize[Y]*float64(gridsize[Y]))
hdr(out, "zmax", cellsize[Z]*float64(gridsize[Z]))
name := meta.Name
var labels []interface{}
if q.NComp() == 1 {
labels = []interface{}{name}
} else {
for i := 0; i < q.NComp(); i++ {
labels = append(labels, name+"_"+string('x'+i))
}
}
hdr(out, "valuedim", q.NComp())
hdr(out, "valuelabels", labels...) // TODO
unit := meta.Unit
if unit == "" {
unit = "1"
}
if q.NComp() == 1 {
hdr(out, "valueunits", unit)
} else {
hdr(out, "valueunits", unit, unit, unit)
}
// We don't really have stages
//fmt.Fprintln(out, "# Desc: Stage simulation time: ", meta.TimeStep, " s") // TODO
hdr(out, "Desc", "Total simulation time: ", meta.Time, " s")
hdr(out, "xbase", cellsize[X]/2)
hdr(out, "ybase", cellsize[Y]/2)
hdr(out, "zbase", cellsize[Z]/2)
hdr(out, "xnodes", gridsize[X])
hdr(out, "ynodes", gridsize[Y])
hdr(out, "znodes", gridsize[Z])
hdr(out, "xstepsize", cellsize[X])
hdr(out, "ystepsize", cellsize[Y])
hdr(out, "zstepsize", cellsize[Z])
hdr(out, "End", "Header")
}
// Returns a buffer obtained from GetBuffer to the pool.
func Recycle(s *data.Slice) {
if Synchronous {
Sync()
}
N := s.Len()
pool := buf_pool[N]
// put each component buffer back on the stack
for i := 0; i < s.NComp(); i++ {
ptr := s.DevPtr(i)
if _, ok := buf_check[ptr]; !ok {
log.Panic("recyle: was not obtained with getbuffer")
}
pool = append(pool, ptr)
}
s.Disable() // make it unusable, protect against accidental use after recycle
buf_pool[N] = pool
}
// multiply-add: dst[i] = src1[i] * factor1 + src2[i] * factor2 + src3 * factor3
func Madd3(dst, src1, src2, src3 *data.Slice, factor1, factor2, factor3 float32) {
N := dst.Len()
nComp := dst.NComp()
util.Assert(src1.Len() == N && src2.Len() == N && src3.Len() == N)
util.Assert(src1.NComp() == nComp && src2.NComp() == nComp && src3.NComp() == nComp)
cfg := make1DConf(N)
for c := 0; c < nComp; c++ {
k_madd3_async(dst.DevPtr(c), src1.DevPtr(c), factor1,
src2.DevPtr(c), factor2, src3.DevPtr(c), factor3, N, cfg)
}
}
// write data block in text format, for OVF1 and OVF2
func writeOVFText(out io.Writer, tens *data.Slice) (err error) {
data := tens.Tensors()
gridsize := tens.Size()
ncomp := tens.NComp()
// Here we loop over X,Y,Z, not Z,Y,X, because
// internal in C-order == external in Fortran-order
for iz := 0; iz < gridsize[Z]; iz++ {
for iy := 0; iy < gridsize[Y]; iy++ {
for ix := 0; ix < gridsize[X]; ix++ {
for c := 0; c < ncomp; c++ {
_, err = fmt.Fprint(out, data[c][iz][iy][ix], " ")
}
_, err = fmt.Fprint(out, "\n")
}
}
}
return
}
// Execute the FFT plan, asynchronous.
// src and dst are 3D arrays stored 1D arrays.
func (p *fft3DR2CPlan) ExecAsync(src, dst *data.Slice) {
if Synchronous {
Sync()
timer.Start("fft")
}
util.Argument(src.NComp() == 1 && dst.NComp() == 1)
oksrclen := p.InputLen()
if src.Len() != oksrclen {
log.Panicf("fft size mismatch: expecting src len %v, got %v", oksrclen, src.Len())
}
okdstlen := p.OutputLen()
if dst.Len() != okdstlen {
log.Panicf("fft size mismatch: expecting dst len %v, got %v", okdstlen, dst.Len())
}
p.handle.ExecR2C(cu.DevicePtr(uintptr(src.DevPtr(0))), cu.DevicePtr(uintptr(dst.DevPtr(0))))
if Synchronous {
Sync()
timer.Stop("fft")
}
}
