Ejemplo n.º 1
0
func dispersion(data [][][][]float32) {
	say("dispersion")
	out, err := os.OpenFile("dispersion", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	core.Fatal(err)
	defer out.Close()

	nx, ny, nz := len(data[0]), len(data[0][0]), len(data[0][0][0])

	for f := 1; f < len(data)/2; f++ {
		k := data[f]
		freq := float64(f) / totaltime
		power := make([]float64, nx+ny+nz)

		for x := range k {
			for y := range k[x] {
				for z := range k[x][y] {
					power[int(math.Sqrt(float64(x*x+y*y+z*z)))] += float64(k[x][y][z] * k[x][y][z])
				}
			}
		}

		for i := range power {
			wvec := float64(i) / meshsize[0] // !!!!!!! Assumes cubic cells.
			fmt.Fprintln(out, freq, wvec, power[i])
		}
		fmt.Fprintln(out)
	}
}
Ejemplo n.º 2
0
func writeVTKPoints(out io.Writer, q *dump.Frame, dataformat string) {
	fmt.Fprintln(out, "\t\t\t<Points>")
	fmt.Fprintf(out, "\t\t\t\t<DataArray type=\"Float32\" Name=\"points\" NumberOfComponents=\"3\" format=\"%s\">\n", dataformat)
	gridsize := q.Size()[1:]
	cellsize := q.MeshStep
	switch dataformat {
	case "ascii":
		for k := 0; k < gridsize[X]; k++ {
			for j := 0; j < gridsize[Y]; j++ {
				for i := 0; i < gridsize[Z]; i++ {
					x := (float32)(i) * (float32)(cellsize[Z])
					y := (float32)(j) * (float32)(cellsize[Y])
					z := (float32)(k) * (float32)(cellsize[X])
					_, err := fmt.Fprint(out, x, " ", y, " ", z, " ")
					core.Fatal(err)
				}
			}
		}
	case "binary":
		// Conversion form float32 [4]byte in big-endian
		// encoding/binary is too slow
		// Inlined for performance, terabytes of data will pass here...
		var bytes []byte
		for k := 0; k < gridsize[X]; k++ {
			for j := 0; j < gridsize[Y]; j++ {
				for i := 0; i < gridsize[Z]; i++ {
					x := (float32)(i) * (float32)(cellsize[Z])
					y := (float32)(j) * (float32)(cellsize[Y])
					z := (float32)(k) * (float32)(cellsize[X])
					bytes = (*[4]byte)(unsafe.Pointer(&x))[:]
					out.Write(bytes)
					bytes = (*[4]byte)(unsafe.Pointer(&y))[:]
					out.Write(bytes)
					bytes = (*[4]byte)(unsafe.Pointer(&z))[:]
					out.Write(bytes)
				}
			}
		}
	default:
		core.Fatal(fmt.Errorf("Illegal VTK data format: %v. Options are: ascii, binary", dataformat))
	}
	fmt.Fprintln(out, "</DataArray>")
	fmt.Fprintln(out, "\t\t\t</Points>")
}
Ejemplo n.º 3
0
func dumpOmf(file string, q *dump.Frame, dataformat string) {

	switch strings.ToLower(dataformat) {
	case "binary", "binary 4":
		dataformat = "Binary 4"
	case "text":
		dataformat = "Text"
	default:
		core.Fatal(fmt.Errorf("Illegal OMF data format: %v", dataformat))
	}

	out, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	core.Fatal(err)
	defer out.Close()

	writeOmfHeader(out, q)
	writeOmfData(out, q, dataformat)
	hdr(out, "End", "Segment")
}
Ejemplo n.º 4
0
func dumpVTK(file string, q *dump.Frame, dataformat string) {

	out, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	core.Fatal(err)
	defer out.Close()

	writeVTKHeader(out, q)
	writeVTKPoints(out, q, dataformat)
	writeVTKCellData(out, q, dataformat)
	writeVTKFooter(out)
}
Ejemplo n.º 5
0
// Writes data in OMF Text format
func writeOmfText(out io.Writer, tens *dump.Frame) {

	data := tens.Tensors()
	gridsize := tens.Size()[1:]

	// Here we loop over X,Y,Z, not Z,Y,X, because
	// internal in C-order == external in Fortran-order
	for i := 0; i < gridsize[X]; i++ {
		for j := 0; j < gridsize[Y]; j++ {
			for k := 0; k < gridsize[Z]; k++ {
				for c := 0; c < tens.Size()[0]; c++ {
					_, err := fmt.Fprint(out, data[core.SwapIndex(c, tens.Size()[0])][i][j][k], " ") // converts to user space.
					core.Fatal(err)
				}
				_, err := fmt.Fprint(out, "\n")
				core.Fatal(err)
			}
		}
	}
}
Ejemplo n.º 6
0
func main() {
	flag.Parse()

	if flag.NArg() == 0 {
		read(os.Stdin, "")
	}
	for _, arg := range flag.Args() {
		f, err := os.Open(arg)
		core.Fatal(err)
		read(f, arg)
		f.Close()
	}
}
Ejemplo n.º 7
0
func writeOmfData(out io.Writer, q *dump.Frame, dataformat string) {

	hdr(out, "Begin", "Data "+dataformat)
	switch strings.ToLower(dataformat) {
	case "text":
		writeOmfText(out, q)
	case "binary 4":
		writeOmfBinary4(out, q)
	default:
		core.Fatal(fmt.Errorf("Illegal OMF data format: %v. Options are: Text, Binary 4", dataformat))
	}
	hdr(out, "End", "Data "+dataformat)
}
Ejemplo n.º 8
0
func fSpectrum(data [][][][]float32) {
	say("frequencyspectrum")
	out, err := os.OpenFile("frequencyspectrum", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	core.Fatal(err)
	defer out.Close()

	for i := 1; i < len(data); i++ {
		k := data[i]
		power := 0.
		K := reshape.RtoC(reshape.ContiguousR3(k))
		for _, s := range K {
			power += float64(real(s)*real(s) + imag(s)*imag(s))
		}
		f := float64(i) / totaltime
		fmt.Fprintln(out, f, "\t", power)
	}
}
Ejemplo n.º 9
0
func read(in io.Reader, name string) {
	r := dump.NewReader(in, *flag_crc)
	err := r.Read()
	i := 0
	ext := path.Ext(name)
	woext := noExt(name)
	for err != io.EOF {
		core.Fatal(err)
		tname := name
		if !(*flag_onefile) {
			num := fmt.Sprintf("%06d", i)
			tname = woext + num + ext
		}
		process(&r.Frame, tname)
		err = r.Read()
		i = i + 1
	}
}
Ejemplo n.º 10
0
func dumpGnuplotGZip(f *dump.Frame, file string) {

	out, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	core.Fatal(err)

	out_gzip, err1 := gzip.NewWriterLevel(out, gzip.BestSpeed)
	core.Fatal(err1)

	out_buffered := bufio.NewWriter(out_gzip)

	defer func() {
		out_buffered.Flush()
		out_gzip.Close()
		out.Close()
	}()

	data := f.Tensors()
	gridsize := f.Size()[1:]
	cellsize := f.MeshStep
	ncomp := len(data)

	// Here we loop over X,Y,Z, not Z,Y,X, because
	// internal in C-order == external in Fortran-order
	for i := 0; i < gridsize[X]; i++ {
		x := float64(i) * cellsize[X]
		for j := 0; j < gridsize[Y]; j++ {
			y := float64(j) * cellsize[Y]
			for k := 0; k < gridsize[Z]; k++ {
				z := float64(k) * cellsize[Z]
				_, err := fmt.Fprint(out_buffered, z, " ", y, " ", x, "\t")
				core.Fatal(err)
				for c := 0; c < ncomp; c++ {
					_, err := fmt.Fprint(out_buffered, data[core.SwapIndex(c, ncomp)][i][j][k], " ") // converts to user space.
					core.Fatal(err)
				}
				_, err = fmt.Fprint(out_buffered, "\n")
				core.Fatal(err)
			}
			_, err := fmt.Fprint(out_buffered, "\n")
			core.Fatal(err)
		}
		core.Fatal(err)
	}
	out_buffered.Flush()
}
Ejemplo n.º 11
0
func dispersionZ(data [][][][]float32) {
	say("dispersionz")
	out, err := os.OpenFile("dispersionz", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	core.Fatal(err)
	defer out.Close()

	for f := 1; f < len(data)/2; f++ {
		k := data[f]
		freq := float64(f) / totaltime
		for z := range k[0][0] {
			wvec := float64(z) / meshsize[2]
			power := 0.
			for x := range k {
				for y := range k[0] {
					power += float64(k[x][y][z] * k[x][y][z])
				}
			}
			fmt.Fprintln(out, freq, wvec, power)
		}
		fmt.Fprintln(out)
	}
}
Ejemplo n.º 12
0
func dumpImage(f *dump.Frame, file string) {
	var img *image.NRGBA
	{
		dim := f.Size()[0]
		switch dim {
		default:
			core.Fatal(fmt.Errorf("unsupported number of components: %v", dim))
		case 3:
			img = DrawVectors(f.Vectors())
		case 1:
			min, max := extrema(f.Data)
			if *flag_min != "auto" {
				m, err := strconv.ParseFloat(*flag_min, 32)
				core.Fatal(err)
				min = float32(m)
			}
			if *flag_max != "auto" {
				m, err := strconv.ParseFloat(*flag_max, 32)
				core.Fatal(err)
				max = float32(m)
			}
			img = DrawFloats(f.Floats(), min, max)
		}
	}

	out, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	core.Fatal(err)
	defer out.Close()

	ext := path.Ext(file)
	switch ext {
	default:
		core.Fatal(fmt.Errorf("unsupported image type: %v", ext))
	case ".png":
		core.Fatal(png.Encode(out, img))
	case ".jpg":
		core.Fatal(jpeg.Encode(out, img, nil))
	}
}
Ejemplo n.º 13
0
func dumpGnuplot(f *dump.Frame, file string) {

	out_, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	core.Fatal(err)
	defer out_.Close()

	out_buffered := bufio.NewWriter(out_)
	defer out_buffered.Flush()

	data := f.Tensors()
	gridsize := f.Size()[1:]
	cellsize := f.MeshStep
	// 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.Components
	core.Assert(ncomp > 0)

	// Here we loop over X,Y,Z, not Z,Y,X, because
	// internal in C-order == external in Fortran-order
	for i := 0; i < gridsize[X]; i++ {
		x := float64(i) * cellsize[X]
		for j := 0; j < gridsize[Y]; j++ {
			y := float64(j) * cellsize[Y]
			for k := 0; k < gridsize[Z]; k++ {
				z := float64(k) * cellsize[Z]
				_, err := fmt.Fprint(out_buffered, z, " ", y, " ", x, "\t")
				core.Fatal(err)
				for c := 0; c < ncomp; c++ {
					_, err := fmt.Fprint(out_buffered, data[core.SwapIndex(c, ncomp)][i][j][k], " ") // converts to user space.
					core.Fatal(err)
				}
				_, err = fmt.Fprint(out_buffered, "\n")
				core.Fatal(err)
			}
			_, err := fmt.Fprint(out_buffered, "\n")
			core.Fatal(err)
		}
		core.Fatal(err)
	}
}
Ejemplo n.º 14
0
func writeVTKCellData(out io.Writer, q *dump.Frame, dataformat string) {
	N := q.Size()[0]
	data := q.Tensors()
	switch N {
	case 1:
		fmt.Fprintf(out, "\t\t\t<PointData Scalars=\"%s\">\n", q.DataLabel)
		fmt.Fprintf(out, "\t\t\t\t<DataArray type=\"Float32\" Name=\"%s\" NumberOfComponents=\"%d\" format=\"%s\">\n", q.DataLabel, N, dataformat)
	case 3:
		fmt.Fprintf(out, "\t\t\t<PointData Vectors=\"%s\">\n", q.DataLabel)
		fmt.Fprintf(out, "\t\t\t\t<DataArray type=\"Float32\" Name=\"%s\" NumberOfComponents=\"%d\" format=\"%s\">\n", q.DataLabel, N, dataformat)
	case 6, 9:
		fmt.Fprintf(out, "\t\t\t<PointData Tensors=\"%s\">\n", q.DataLabel)
		fmt.Fprintf(out, "\t\t\t\t<DataArray type=\"Float32\" Name=\"%s\" NumberOfComponents=\"%d\" format=\"%s\">\n", q.DataLabel, 9, dataformat) // must be 9!
	default:
		core.Fatal(fmt.Errorf("vtk: cannot handle %v components"))
	}
	gridsize := q.MeshSize
	switch dataformat {
	case "ascii":
		for i := 0; i < gridsize[X]; i++ {
			for j := 0; j < gridsize[Y]; j++ {
				for k := 0; k < gridsize[Z]; k++ {
					// if symmetric tensor manage it appart to write the full 9 components
					if N == 6 {
						fmt.Fprint(out, data[core.SwapIndex(0, 9)][i][j][k], " ")
						fmt.Fprint(out, data[core.SwapIndex(1, 9)][i][j][k], " ")
						fmt.Fprint(out, data[core.SwapIndex(2, 9)][i][j][k], " ")
						fmt.Fprint(out, data[core.SwapIndex(1, 9)][i][j][k], " ")
						fmt.Fprint(out, data[core.SwapIndex(3, 9)][i][j][k], " ")
						fmt.Fprint(out, data[core.SwapIndex(4, 9)][i][j][k], " ")
						fmt.Fprint(out, data[core.SwapIndex(2, 9)][i][j][k], " ")
						fmt.Fprint(out, data[core.SwapIndex(4, 9)][i][j][k], " ")
						fmt.Fprint(out, data[core.SwapIndex(5, 9)][i][j][k], " ")
					} else {
						for c := 0; c < N; c++ {
							fmt.Fprint(out, data[core.SwapIndex(c, N)][i][j][k], " ")
						}
					}
				}
			}
		}
	case "binary":
		// Inlined for performance, terabytes of data will pass here...
		var bytes []byte
		for i := 0; i < gridsize[X]; i++ {
			for j := 0; j < gridsize[Y]; j++ {
				for k := 0; k < gridsize[Z]; k++ {
					// if symmetric tensor manage it appart to write the full 9 components
					if N == 6 {
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(0, 9)][i][j][k]))[:]
						out.Write(bytes)
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(1, 9)][i][j][k]))[:]
						out.Write(bytes)
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(2, 9)][i][j][k]))[:]
						out.Write(bytes)
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(1, 9)][i][j][k]))[:]
						out.Write(bytes)
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(3, 9)][i][j][k]))[:]
						out.Write(bytes)
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(4, 9)][i][j][k]))[:]
						out.Write(bytes)
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(2, 9)][i][j][k]))[:]
						out.Write(bytes)
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(4, 9)][i][j][k]))[:]
						out.Write(bytes)
						bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(5, 9)][i][j][k]))[:]
						out.Write(bytes)
					} else {
						for c := 0; c < N; c++ {
							bytes = (*[4]byte)(unsafe.Pointer(&data[core.SwapIndex(c, N)][i][j][k]))[:]
							out.Write(bytes)
						}
					}
				}
			}
		}
	default:
		core.Fatal(fmt.Errorf("vtk: illegal data format " + dataformat + ". Options are: ascii, binary"))
	}
	fmt.Fprintln(out, "</DataArray>")
	fmt.Fprintln(out, "\t\t\t</PointData>")
}