Esempio n. 1
0
// creates the NetCDF file following nc structure.
//func WriteNetcdf(any interface{}) error {
func WriteNetcdf(nc *lib.Nc, m *config.Map, cfg toml.Configtoml, ncType string, prefixAll string) {

	// build filename
	filename := fmt.Sprintf(cfg.Outputfile+"OS_%s%s_%s.nc",
		strings.ToUpper(nc.Attributes["cycle_mesure"]),
		strings.ToUpper(prefixAll),
		ncType)
	//fmt.Println(filename)

	// get roscop definition file for variables attributes
	var roscop = nc.Roscop
	fmt.Fprintf(echo, "writing netCDF: %s\n", filename)

	// get variables_1D size
	len_1D := nc.Dimensions["TIME"]
	len_2D := nc.Dimensions["DEPTH"]

	// Create a new NetCDF 3 file. The dataset is returned.
	ds, err := netcdf.CreateFile(filename, netcdf.CLOBBER)
	if err != nil {
		log.Fatal(err)
	}
	defer ds.Close()

	// Add the dimensions for our data to the dataset
	dim_1D := make([]netcdf.Dim, 1)
	dim_2D := make([]netcdf.Dim, 2)

	// dimensions for ROSCOP paremeters as DEPTH, PRES, TEMP, PSAL, etc
	dim_2D[0], err = ds.AddDim("TIME", uint64(len_1D))
	if err != nil {
		log.Fatal(err)
	}
	dim_2D[1], err = ds.AddDim("DEPTH", uint64(len_2D))
	if err != nil {
		log.Fatal(err)
	}
	// dimension for PROFILE, LATITUDE, LONGITUDE and BATH
	dim_1D[0] = dim_2D[0]

	// Add the variable to the dataset that will store our data
	map_1D := make(map[string]netcdf.Var)
	for key, _ := range nc.Variables_1D {
		// convert types from code_roscop structure to native netcdf types
		var netcdfType netcdf.Type

		/*//remove LATITUDE and LONGITUDE from the key list if thermo file
		if ncType=="THERMO"{
			if key == "LATITUDE" {
				continue
			}
			if key == "LONGITUDE" {
				continue
			}
		}*/

		pa := roscop.GetAttributesStringValue(key, "types")
		switch pa {
		case "int32":
			netcdfType = netcdf.INT
		case "float32":
			netcdfType = netcdf.FLOAT
		case "float64":
			netcdfType = netcdf.DOUBLE
		default:
			log.Fatal(fmt.Sprintf("Error: key: %s, Value: [%s], check roscop file\n", key, pa)) // wrong type, check code_roscop file
		}
		// add variables
		v, err := ds.AddVar(key, netcdfType, dim_1D)
		if err != nil {
			log.Fatal(err)
		}
		map_1D[key] = v

		// define variable attributes with the right type
		// for an physical parameter, get a slice of attributes name
		for _, name := range roscop.GetAttributes(key) {
			// for each attribute, get the value
			value := roscop.GetAttributesValue(key, name)
			// add new attribute to the variable v
			a := v.Attr(name)
			// value is an interface{}, need type assertion
			switch value.(type) {
			case string:
				err = a.WriteBytes([]byte(value.(string)))
			case int32:
				err = a.WriteInt32s([]int32{value.(int32)})
			case float32:
				err = a.WriteFloat32s([]float32{value.(float32)})
			case float64:
				err = a.WriteFloat64s([]float64{value.(float64)})
			default:
				log.Fatal(fmt.Sprintf("netcdf: create 1D attribute error, %v=%v:%v (%T)",
					key, name, value, value)) // wrong type, check code_roscop file
			}
			if err != nil {
				log.Fatal(fmt.Sprintf("%s, %v: %v (%T)", err, key, v, v))
			}
			fmt.Fprintf(debug, "%s: %s=%v (%T)\n", key, name, value, value)
		}
	}

	// Add the variable to the dataset that will store our data
	map_2D := make(map[string]netcdf.Var)

	// use the order list gave by split or splitAll (config file) because
	// the iteration order is not specified and is not guaranteed to be
	// the same from one iteration to the next in golang
	// for key, _ := range nc.Variables_2D {
	for _, key := range config.GetPhysicalParametersList(m) {
		// remove PRFL from the key list
		if key == "PRFL" {
			continue
		}

		/*if key == "SSJT" {
			continue
		}*/

		// convert types from code_roscop structure to native netcdf types
		var netcdfType netcdf.Type

		pa := roscop.GetAttributesStringValue(key, "types")
		switch pa {
		case "int32":
			netcdfType = netcdf.INT
		case "float32":
			netcdfType = netcdf.FLOAT
		case "float64":
			netcdfType = netcdf.DOUBLE
		default:
			log.Fatal(fmt.Sprintf("Error: key: %s, Value: [%s], check roscop file\n", key, pa)) // wrong type, check code_roscop file
		}
		v, err := ds.AddVar(key, netcdfType, dim_2D)
		if err != nil {
			log.Fatal(err)
		}
		map_2D[key] = v

		// define variable attributes with the right type
		// for an physical parameter, get a slice of attributes name
		for _, name := range roscop.GetAttributes(key) {
			// for each attribute, get the value
			value := roscop.GetAttributesValue(key, name)
			// add new attribute to the variable v
			a := v.Attr(name)
			// value is an interface{}, need type assertion
			switch value.(type) {
			case string:
				err = a.WriteBytes([]byte(value.(string)))
			case int32:
				err = a.WriteInt32s([]int32{value.(int32)})
			case float32:
				err = a.WriteFloat32s([]float32{value.(float32)})
			case float64:
				err = a.WriteFloat64s([]float64{value.(float64)})
			default:
				log.Fatal(fmt.Sprintf("netcdf: create 1D attribute error: key: %s, Value: [%s], \n", key, value))
			}
			if err != nil {
				log.Fatal(fmt.Sprintf("%s, %v: %v (%T)", err, key, v, v))
			}
			fmt.Fprintf(debug, "%s: %s=%v (%T)\n", key, name, value, value)
		}
	}

	// defines global attributes
	for key, value := range nc.Attributes {
		a := ds.Attr(key)
		err = a.WriteBytes([]byte(value))
		if err != nil {
			log.Fatal(fmt.Sprintf("%s, %v: %v (%T)", err, key, value, value))
		}
	}

	// leave define mode in NetCDF3
	ds.EndDef()

	// Create the data with the above dimensions and type,
	// write them to the file.
	for key, value := range nc.Variables_1D {
		// convert types from code_roscop structure to native netcdf types
		switch roscop.GetAttributesStringValue(key, "types") {
		case "int32":
			length := len(value.([]float64))
			v := make([]int32, length)
			fmt.Fprintf(echo, "writing %s: %d\n", key, len(v))
			fmt.Fprintf(debug, "writing %s: %d\n", key, len(v))
			for i := 0; i < length; i++ {
				v[i] = int32(value.([]float64)[i])
			}
			if err := map_1D[key].WriteInt32s(v); err != nil {
				log.Fatal(fmt.Sprintf("%s, %v: %v (%T)", err, key, v, v))
			}
		case "float32":
			length := len(value.([]float64))
			v := make([]float32, length)
			fmt.Fprintf(echo, "writing %s: %d\n", key, len(v))
			fmt.Fprintf(debug, "writing %s: %d\n", key, len(v))
			for i := 0; i < length; i++ {
				v[i] = float32(value.([]float64)[i])
			}
			if err := map_1D[key].WriteFloat32s(v); err != nil {
				log.Fatal(fmt.Sprintf("%s, %v: %v (%T)", err, key, v, v))
			}
		case "float64":
			length := len(value.([]float64))
			v := make([]float64, length)
			fmt.Fprintf(echo, "writing %s: %d\n", key, len(v))
			fmt.Fprintf(debug, "writing %s: %d\n", key, len(v))
			for i := 0; i < length; i++ {
				v[i] = float64(value.([]float64)[i])
			}
			if err := map_1D[key].WriteFloat64s(v); err != nil {
				log.Fatal(fmt.Sprintf("%s, %v: %v (%T)", err, key, v, v))
			}
		default:
			log.Fatal(fmt.Sprintf("%s, %v", err, key))
		}

	}

	// write data 2D (value.data) to netcdf variables
	// for key, value := range nc.Variables_2D {
	for _, key := range config.GetPhysicalParametersList(m) {
		// remove PRFL from the key list
		if key == "PRFL" {
			continue
		}
		value := nc.Variables_2D[key]
		i := 0
		ht := len(lib.GetData(value))
		wd := len(lib.GetData(value)[0])
		fmt.Fprintf(echo, "writing %s: %d x %d\n", key, ht, wd)
		fmt.Fprintf(debug, "writing %s: %d x %d\n", key, ht, wd)

		// Write<type> netcdf methods need []<type>, [][]data will be flatten
		gopher := make([]float64, ht*wd)
		for x := 0; x < ht; x++ {
			for y := 0; y < wd; y++ {
				gopher[i] = lib.GetData(value)[x][y]
				i++
			}
		}
		switch roscop.GetAttributesStringValue(key, "types") {
		case "int32":
			v := make([]int32, ht*wd)
			for i := 0; i < ht*wd; i++ {
				v[i] = int32(gopher[i])
			}
			if err := map_2D[key].WriteInt32s(v); err != nil {
				log.Fatal(fmt.Sprintf("%s, %v: (%T)", err, key, v))
			}
		case "float32":
			v := make([]float32, ht*wd)
			for i := 0; i < ht*wd; i++ {
				v[i] = float32(gopher[i])
			}
			if err := map_2D[key].WriteFloat32s(v); err != nil {
				log.Fatal(fmt.Sprintf("%s, %v: (%T)", err, key, v))
			}
		case "float64":
			if err := map_2D[key].WriteFloat64s(gopher); err != nil {
				log.Fatal(fmt.Sprintf("%s, %v: (%T)", err, key, gopher))
			}
		default:
			log.Fatal(fmt.Sprintf("%s, %v", err, key))
		}
	}
	fmt.Fprintf(echo, "writing %s done ...\n", filename)
}
func WriteAscii(nc *lib.Nc, cfg toml.Configtoml, map_format map[string]string, hdr []string, inst string, prefixAll string) {
	// define 2 files, profiles header and data
	var asciiFilename string

	// build filenames
	str := nc.Attributes["cycle_mesure"]
	str = strings.Replace(str, "\r", "", -1)
	headerFilename := fmt.Sprintf(cfg.Outputfile+"%s."+inst, strings.ToLower(str))
	asciiFilename = fmt.Sprintf(cfg.Outputfile+"%s%s_"+inst, strings.ToLower(str), prefixAll)
	//fmt.Println(headerFilename)
	//fmt.Println(asciiFilename)

	// open header file for writing result
	fid_hdr, err := os.Create(headerFilename)
	if err != nil {
		log.Fatal(err)
	}
	defer fid_hdr.Close()

	// use buffered mode for writing
	fbuf_hdr := bufio.NewWriter(fid_hdr)

	// open ASCII file for writing result
	fid_ascii, err := os.Create(asciiFilename)
	if err != nil {
		log.Fatal(err)
	}
	defer fid_ascii.Close()

	// use buffered mode for writing
	fbuf_ascii := bufio.NewWriter(fid_ascii)

	// write header to string
	str = fmt.Sprintf("%s  %s  %s  %s %s  %s\n",
		nc.Attributes["cycle_mesure"],
		nc.Attributes["plateforme"],
		nc.Attributes["institute"],
		nc.Attributes["type_instrument"],
		nc.Attributes["instrument_number"],
		nc.Attributes["pi"])

	// write first line header on header file and ascii file
	fmt.Fprintf(fbuf_hdr, str)
	fmt.Fprintf(fbuf_ascii, str)

	// display on screen
	fmt.Printf("%s", str)

	// write physical parameters in second line
	str = ""
	for _, key := range hdr {
		fmt.Fprintf(fbuf_ascii, "%s   ", key)
		fmt.Fprintf(lib.Debug, "%s   ", key)
	}
	// append new line
	fmt.Fprintln(fbuf_ascii, "\n")

	// write second line header on ascii file
	fmt.Fprintln(fbuf_ascii, str)

	// display on screen
	fmt.Printf("%s", str)

	// get data (slices) from nc struct
	len_1D := nc.Dimensions["TIME"]
	len_2D := nc.Dimensions["DEPTH"]
	time := nc.Variables_1D["TIME"].([]float64)
	lat := nc.Variables_1D["LATITUDE"].([]float64)
	lon := nc.Variables_1D["LONGITUDE"].([]float64)
	profile := nc.Variables_1D["PROFILE"].([]float64)

	// loop over each profile
	for x := 0; x < len_1D; x++ {
		str = ""
		t1 := lib.NewTimeFromJulian(time[x])
		// write profile informations to ASCII data file with DEPTH = -1
		// TODOS: adapt profile format to stationPrefixLength
		fmt.Fprintf(fbuf_ascii, "%05.0f %f %f %f %s",
			profile[x],
			t1.JulianDayOfYear(),
			lat[x],
			lon[x],
			t1.Format("20060102150405"))

		// write profile informations to header file
		str = fmt.Sprintf("%05.0f %s  %s %s %4.4g %4.4g %s %s\n",
			profile[x],
			t1.Format("02/01/2006 15:04:05"),
			lib.DecimalPosition2String(lat[x], 0),
			lib.DecimalPosition2String(lon[x], 0),
			nc.Extras_f[fmt.Sprintf("MINPRES:%d", int(profile[x]))],
			nc.Extras_f[fmt.Sprintf("PRES:%d", int(profile[x]))],
			nc.Extras_s[fmt.Sprintf("TYPECAST:%s", int(profile[x]))],
			cfg.Ladcp.CruisePrefix+nc.Extras_s[fmt.Sprintf("PRFL_NAME:%d", int(profile[x]))])

		// write profile information to header file
		fmt.Fprintf(fbuf_hdr, str)

		// display on screen
		fmt.Printf("%s", str)

		// fill last header columns with 1e36
		for i := 0; i < len(hdr)-6; i++ {
			fmt.Fprintf(fbuf_ascii, " %g", 1e36)
		}
		fmt.Fprintln(fbuf_ascii) // add newline

		// loop over each level
		for y := 0; y < len_2D; y++ {

			fmt.Fprintf(fbuf_ascii, "%05.0f ", profile[x])
			// loop over each physical parameter (key) in the rigth order
			for _, key := range hdr {
				// if key not in map, goto next key
				if _, ok := nc.Variables_2D[key]; ok {
					// fill 2D slice
					data := lib.GetData(nc.Variables_2D[key])[x][y]
					// print data with it's format, change format for FillValue
					if data == 1e36 {
						fmt.Fprintf(fbuf_ascii, "%g ", data)
					} else {
						if strings.ContainsAny(map_format[key], "lf") {
							res := strings.Split(map_format[key], "l")
							map_format[key] = strings.Join(res, "")
						}
						fmt.Fprintf(fbuf_ascii, map_format[key]+" ", data)
					}
				}
			}
			fmt.Fprintf(fbuf_ascii, "\n")

		}
		fbuf_ascii.Flush()
		fbuf_hdr.Flush()
	}
}