/** * Clones the attributes of one NetCDF file into another. * * @param infile - The source NetCDF file * @param inVarName - The variable name to be copied * @param outfile - The destination NetCDF file * @param outVarName - The output variable name */ private void cloneAttributes( NetcdfFile infile, String inVarName, NetcdfFileWriteable outfile, String outVarName) { // Find the variable Variable vi = infile.findVariable(inVarName); // Grab all of its attributes - unchecked, but should be OK. List<Attribute> l = vi.getAttributes(); for (Attribute a : l) { if (a.getName().equalsIgnoreCase("units") && inVarName.equalsIgnoreCase("time")) { Attribute aa = new Attribute("units", "days since 1900-12-31 00:00:00"); outfile.addVariableAttribute(outVarName, aa); } else if (a.getName().equalsIgnoreCase("time_origin") && inVarName.equalsIgnoreCase("time")) { Attribute aa = new Attribute("time_origin", "1900-12-31 00:00:00"); outfile.addVariableAttribute(outVarName, aa); } else if (a.getName().equalsIgnoreCase("calendar")) { Attribute aa = new Attribute("calendar", "standard"); outfile.addVariableAttribute(outVarName, aa); } else { outfile.addVariableAttribute(outVarName, a); } } }
private void createDataVariables(List<VariableSimpleIF> dataVars) throws IOException { /* height variable Variable heightVar = ncfile.addStringVariable(altName, recordDims, 20); ncfile.addVariableAttribute(heightVar, new Attribute("long_name", "height of observation")); ncfile.addVariableAttribute(heightVar, new Attribute("units", altUnits)); */ Variable v = ncfile.addVariable(parentProfileIndex, DataType.INT, recordDimName); ncfile.addVariableAttribute(v, new Attribute("long_name", "index of parent profile")); v = ncfile.addVariable(nextObsName, DataType.INT, recordDimName); ncfile.addVariableAttribute( v, new Attribute("long_name", "record number of next obs in linked list for this profile")); // find all dimensions needed by the data variables for (VariableSimpleIF var : dataVars) { List<Dimension> dims = var.getDimensions(); dimSet.addAll(dims); } // add them for (Dimension d : dimSet) { if (!d.isUnlimited()) ncfile.addDimension(d.getName(), d.getLength(), d.isShared(), false, d.isVariableLength()); } // add the data variables all using the record dimension for (VariableSimpleIF oldVar : dataVars) { List<Dimension> dims = oldVar.getDimensions(); StringBuffer dimNames = new StringBuffer(recordDimName); for (Dimension d : dims) { if (!d.isUnlimited()) dimNames.append(" ").append(d.getName()); } Variable newVar = ncfile.addVariable(oldVar.getName(), oldVar.getDataType(), dimNames.toString()); List<Attribute> atts = oldVar.getAttributes(); for (Attribute att : atts) { ncfile.addVariableAttribute(newVar, att); } } }
private void createProfiles(int nprofiles) throws IOException { this.nprofiles = nprofiles; // add the dimensions Dimension profileDim = ncfile.addDimension(profileDimName, nprofiles); profileDims.add(profileDim); Variable v = ncfile.addVariable(numObsName, DataType.INT, profileDimName); ncfile.addVariableAttribute( v, new Attribute("long_name", "number of children in linked list for this profile")); v = ncfile.addVariable(numProfilesTotalName, DataType.INT, ""); ncfile.addVariableAttribute(v, new Attribute("long_name", "number of valid profiles")); v = ncfile.addVariable(firstObsName, DataType.INT, profileDimName); ncfile.addVariableAttribute( v, new Attribute("long_name", "record number of first obs in linked list for this profile")); // time variable Variable timeVar = ncfile.addStringVariable(timeName, profileDims, 20); ncfile.addVariableAttribute( timeVar, new Attribute("long_name", "ISO-8601 Date - time of observation")); v = ncfile.addVariable(parentStationIndex, DataType.INT, profileDimName); ncfile.addVariableAttribute(v, new Attribute("long_name", "index of parent station")); v = ncfile.addVariable(nextProfileName, DataType.INT, profileDimName); ncfile.addVariableAttribute( v, new Attribute("long_name", "index of next profile in linked list for this station")); }
/** * Clones the attributes of the input file(s) to the output file * * @param infile * @param inVarName * @param outfile * @param outVarName */ private void cloneAttributes( NetcdfDataset infile, String inVarName, NetcdfFileWriteable outfile, String outVarName) { // Find the variable Variable vi = infile.findVariable(inVarName); List<Attribute> l = vi.getAttributes(); for (Attribute a : l) { outfile.addVariableAttribute(outVarName, a); } }
private void createStations(List<ucar.unidata.geoloc.Station> stnList) throws IOException { int nstns = stnList.size(); // see if there's altitude, wmoId for any stations for (int i = 0; i < nstns; i++) { ucar.unidata.geoloc.Station stn = stnList.get(i); // if (!Double.isNaN(stn.getAltitude())) // useAlt = true; if ((stn.getWmoId() != null) && (stn.getWmoId().trim().length() > 0)) useWmoId = true; } /* if (useAlt) ncfile.addGlobalAttribute("altitude_coordinate", altName); */ // find string lengths for (int i = 0; i < nstns; i++) { ucar.unidata.geoloc.Station station = stnList.get(i); name_strlen = Math.max(name_strlen, station.getName().length()); desc_strlen = Math.max(desc_strlen, station.getDescription().length()); if (useWmoId) wmo_strlen = Math.max(wmo_strlen, station.getName().length()); } LatLonRect llbb = getBoundingBox(stnList); ncfile.addGlobalAttribute( "geospatial_lat_min", Double.toString(llbb.getLowerLeftPoint().getLatitude())); ncfile.addGlobalAttribute( "geospatial_lat_max", Double.toString(llbb.getUpperRightPoint().getLatitude())); ncfile.addGlobalAttribute( "geospatial_lon_min", Double.toString(llbb.getLowerLeftPoint().getLongitude())); ncfile.addGlobalAttribute( "geospatial_lon_max", Double.toString(llbb.getUpperRightPoint().getLongitude())); // add the dimensions Dimension recordDim = ncfile.addUnlimitedDimension(recordDimName); recordDims.add(recordDim); Dimension stationDim = ncfile.addDimension(stationDimName, nstns); stationDims.add(stationDim); // add the station Variables using the station dimension Variable v = ncfile.addVariable(latName, DataType.DOUBLE, stationDimName); ncfile.addVariableAttribute(v, new Attribute("units", "degrees_north")); ncfile.addVariableAttribute(v, new Attribute("long_name", "station latitude")); v = ncfile.addVariable(lonName, DataType.DOUBLE, stationDimName); ncfile.addVariableAttribute(v, new Attribute("units", "degrees_east")); ncfile.addVariableAttribute(v, new Attribute("long_name", "station longitude")); if (useAlt) { v = ncfile.addVariable(altName, DataType.DOUBLE, stationDimName); ncfile.addVariableAttribute(v, new Attribute("units", "meters")); ncfile.addVariableAttribute(v, new Attribute("long_name", "station altitude")); } v = ncfile.addStringVariable(idName, stationDims, name_strlen); ncfile.addVariableAttribute(v, new Attribute("long_name", "station identifier")); v = ncfile.addStringVariable(descName, stationDims, desc_strlen); ncfile.addVariableAttribute(v, new Attribute("long_name", "station description")); if (useWmoId) { v = ncfile.addStringVariable(wmoName, stationDims, wmo_strlen); ncfile.addVariableAttribute(v, new Attribute("long_name", "station WMO id")); } v = ncfile.addVariable(numProfilesName, DataType.INT, stationDimName); ncfile.addVariableAttribute( v, new Attribute("long_name", "number of profiles in linked list for this station")); v = ncfile.addVariable(firstProfileName, DataType.INT, stationDimName); ncfile.addVariableAttribute( v, new Attribute("long_name", "index of first profile in linked list for this station")); }
public void testWritePermute() throws Exception { NetcdfFileWriteable ncfile = new NetcdfFileWriteable(); ncfile.setName(TestLocal.cdmTestDataDir + "permuteTest.nc"); // define dimensions Dimension xDim = ncfile.addDimension("x", 3); Dimension yDim = ncfile.addDimension("y", 5); Dimension zDim = ncfile.addDimension("z", 4); Dimension tDim = ncfile.addDimension("time", 2); // define Variables ncfile.addVariable("time", double.class, new Dimension[] {tDim}); ncfile.addVariableAttribute("time", "units", "secs since 1-1-1 00:00"); ncfile.addVariable("z", double.class, new Dimension[] {zDim}); ncfile.addVariableAttribute("z", "units", "meters"); ncfile.addVariableAttribute("z", "positive", "up"); ncfile.addVariable("y", double.class, new Dimension[] {yDim}); ncfile.addVariableAttribute("y", "units", "degrees_north"); ncfile.addVariable("x", double.class, new Dimension[] {xDim}); ncfile.addVariableAttribute("x", "units", "degrees_east"); ncfile.addVariable("tzyx", double.class, new Dimension[] {tDim, zDim, yDim, xDim}); ncfile.addVariableAttribute("tzyx", "units", "K"); ncfile.addVariable("tzxy", double.class, new Dimension[] {tDim, zDim, xDim, yDim}); ncfile.addVariableAttribute("tzxy", "units", "K"); ncfile.addVariable("tyxz", double.class, new Dimension[] {tDim, yDim, xDim, zDim}); ncfile.addVariableAttribute("tyxz", "units", "K"); ncfile.addVariable("txyz", double.class, new Dimension[] {tDim, xDim, yDim, zDim}); ncfile.addVariableAttribute("txyz", "units", "K"); ncfile.addVariable("zyxt", double.class, new Dimension[] {zDim, yDim, xDim, tDim}); ncfile.addVariableAttribute("zyxt", "units", "K"); ncfile.addVariable("zxyt", double.class, new Dimension[] {zDim, xDim, yDim, tDim}); ncfile.addVariableAttribute("zxyt", "units", "K"); ncfile.addVariable("yxzt", double.class, new Dimension[] {yDim, xDim, zDim, tDim}); ncfile.addVariableAttribute("yxzt", "units", "K"); ncfile.addVariable("xyzt", double.class, new Dimension[] {xDim, yDim, zDim, tDim}); ncfile.addVariableAttribute("xyzt", "units", "K"); // missing one dimension ncfile.addVariable("zyx", double.class, new Dimension[] {zDim, yDim, xDim}); ncfile.addVariable("txy", double.class, new Dimension[] {tDim, xDim, yDim}); ncfile.addVariable("yxz", double.class, new Dimension[] {yDim, xDim, zDim}); ncfile.addVariable("xzy", double.class, new Dimension[] {xDim, zDim, yDim}); ncfile.addVariable("yxt", double.class, new Dimension[] {yDim, xDim, tDim}); ncfile.addVariable("xyt", double.class, new Dimension[] {xDim, yDim, tDim}); ncfile.addVariable("xyz", double.class, new Dimension[] {xDim, yDim, zDim}); // missing two dimension ncfile.addVariable("yx", double.class, new Dimension[] {yDim, xDim}); ncfile.addVariable("xy", double.class, new Dimension[] {xDim, yDim}); ncfile.addVariable("yz", double.class, new Dimension[] {yDim, zDim}); ncfile.addVariable("xz", double.class, new Dimension[] {xDim, zDim}); ncfile.addVariable("yt", double.class, new Dimension[] {yDim, tDim}); ncfile.addVariable("xt", double.class, new Dimension[] {xDim, tDim}); ncfile.addVariable("ty", double.class, new Dimension[] {tDim, yDim}); ncfile.addVariable("tx", double.class, new Dimension[] {tDim, xDim}); // add global attributes ncfile.addGlobalAttribute("Convention", "COARDS"); // create the file try { ncfile.create(); } catch (IOException e) { System.err.println("ERROR creating file"); assert (false); } // write time data int len = tDim.getLength(); ArrayDouble A = new ArrayDouble.D1(len); Index ima = A.getIndex(); for (int i = 0; i < len; i++) A.setDouble(ima.set(i), (double) (i * 3600)); int[] origin = new int[1]; try { ncfile.write("time", origin, A); } catch (IOException e) { System.err.println("ERROR writing time"); assert (false); } // write z data len = zDim.getLength(); A = new ArrayDouble.D1(len); ima = A.getIndex(); for (int i = 0; i < len; i++) A.setDouble(ima.set(i), (double) (i * 10)); try { ncfile.write("z", origin, A); } catch (IOException e) { System.err.println("ERROR writing z"); assert (false); } // write y data len = yDim.getLength(); A = new ArrayDouble.D1(len); ima = A.getIndex(); for (int i = 0; i < len; i++) A.setDouble(ima.set(i), (double) (i * 3)); try { ncfile.write("y", origin, A); } catch (IOException e) { System.err.println("ERROR writing y"); assert (false); } // write x data len = xDim.getLength(); A = new ArrayDouble.D1(len); ima = A.getIndex(); for (int i = 0; i < len; i++) A.setDouble(ima.set(i), (double) (i * 5)); try { ncfile.write("x", origin, A); } catch (IOException e) { System.err.println("ERROR writing x"); assert (false); } // write tzyx data doWrite4(ncfile, "tzyx"); doWrite4(ncfile, "tzxy"); doWrite4(ncfile, "txyz"); doWrite4(ncfile, "tyxz"); doWrite4(ncfile, "zyxt"); doWrite4(ncfile, "zxyt"); doWrite4(ncfile, "xyzt"); doWrite4(ncfile, "yxzt"); doWrite3(ncfile, "zyx"); doWrite3(ncfile, "txy"); doWrite3(ncfile, "yxz"); doWrite3(ncfile, "xzy"); doWrite3(ncfile, "yxt"); doWrite3(ncfile, "xyt"); doWrite3(ncfile, "yxt"); doWrite3(ncfile, "xyz"); doWrite2(ncfile, "yx"); doWrite2(ncfile, "xy"); doWrite2(ncfile, "yz"); doWrite2(ncfile, "xz"); doWrite2(ncfile, "yt"); doWrite2(ncfile, "xt"); doWrite2(ncfile, "ty"); doWrite2(ncfile, "tx"); if (show) System.out.println("ncfile = " + ncfile); // all done try { ncfile.close(); } catch (IOException e) { System.err.println("ERROR writing file"); assert (false); } System.out.println("*****************Test Write done"); }
public void testWriteStandardVar() throws Exception { NetcdfFileWriteable ncfile = new NetcdfFileWriteable(filename, false); // define dimensions Dimension latDim = ncfile.addDimension("lat", 2); Dimension lonDim = ncfile.addDimension("lon", 3); ArrayList dims = new ArrayList(); dims.add(latDim); dims.add(lonDim); // case 1 ncfile.addVariable("t1", DataType.DOUBLE, dims); ncfile.addVariableAttribute("t1", CDM.SCALE_FACTOR, new Double(2.0)); ncfile.addVariableAttribute("t1", "add_offset", new Double(77.0)); // case 2 ncfile.addVariable("t2", DataType.BYTE, dims); ncfile.addVariableAttribute("t2", CDM.SCALE_FACTOR, new Short((short) 2)); ncfile.addVariableAttribute("t2", "add_offset", new Short((short) 77)); // case 3 ncfile.addVariable("t3", DataType.BYTE, dims); ncfile.addVariableAttribute("t3", "_FillValue", new Byte((byte) 255)); // case 4 ncfile.addVariable("t4", DataType.SHORT, dims); ncfile.addVariableAttribute("t4", CDM.MISSING_VALUE, new Short((short) -9999)); // case 5 ncfile.addVariable("t5", DataType.SHORT, dims); ncfile.addVariableAttribute("t5", CDM.MISSING_VALUE, new Short((short) -9999)); ncfile.addVariableAttribute("t5", CDM.SCALE_FACTOR, new Short((short) 2)); ncfile.addVariableAttribute("t5", "add_offset", new Short((short) 77)); // case 1 ncfile.addVariable("m1", DataType.DOUBLE, dims); ncfile.addVariableAttribute("m1", CDM.MISSING_VALUE, -999.99); // create the file ncfile.create(); // write t1 ArrayDouble A = new ArrayDouble.D2(latDim.getLength(), lonDim.getLength()); int i, j; Index ima = A.getIndex(); // write for (i = 0; i < latDim.getLength(); i++) for (j = 0; j < lonDim.getLength(); j++) A.setDouble(ima.set(i, j), (double) (i * 10.0 + j)); int[] origin = new int[2]; ncfile.write("t1", origin, A); // write t2 ArrayByte Ab = new ArrayByte.D2(latDim.getLength(), lonDim.getLength()); ima = Ab.getIndex(); for (i = 0; i < latDim.getLength(); i++) for (j = 0; j < lonDim.getLength(); j++) Ab.setByte(ima.set(i, j), (byte) (i * 10 + j)); ncfile.write("t2", origin, Ab); // write t3 ncfile.write("t3", origin, Ab); // write t4 Array As = new ArrayShort.D2(latDim.getLength(), lonDim.getLength()); ima = As.getIndex(); for (i = 0; i < latDim.getLength(); i++) for (j = 0; j < lonDim.getLength(); j++) As.setShort(ima.set(i, j), (short) (i * 10 + j)); ncfile.write("t4", origin, As); As.setShort(ima.set(0, 0), (short) -9999); ncfile.write("t5", origin, As); // write m1 ArrayDouble.D2 Ad = new ArrayDouble.D2(latDim.getLength(), lonDim.getLength()); for (i = 0; i < latDim.getLength(); i++) for (j = 0; j < lonDim.getLength(); j++) Ad.setDouble(ima.set(i, j), (double) (i * 10.0 + j)); Ad.set(1, 1, -999.99); ncfile.write("m1", new int[2], Ad); // all done ncfile.close(); System.out.println("**************TestStandardVar Write done"); }
Write2ncRect(NetcdfFile bufr, String fileOutName, boolean fill) throws IOException, InvalidRangeException { NetcdfFileWriteable ncfile = NetcdfFileWriteable.createNew(fileOutName, fill); if (debug) { System.out.println("FileWriter write " + bufr.getLocation() + " to " + fileOutName); } // global attributes List<Attribute> glist = bufr.getGlobalAttributes(); for (Attribute att : glist) { String useName = N3iosp.makeValidNetcdfObjectName(att.getName()); Attribute useAtt; if (att.isArray()) useAtt = ncfile.addGlobalAttribute(useName, att.getValues()); else if (att.isString()) useAtt = ncfile.addGlobalAttribute(useName, att.getStringValue()); else useAtt = ncfile.addGlobalAttribute(useName, att.getNumericValue()); if (debug) System.out.println("add gatt= " + useAtt); } // global dimensions Dimension recordDim = null; Map<String, Dimension> dimHash = new HashMap<String, Dimension>(); for (Dimension oldD : bufr.getDimensions()) { String useName = N3iosp.makeValidNetcdfObjectName(oldD.getName()); boolean isRecord = useName.equals("record"); Dimension newD = ncfile.addDimension(useName, oldD.getLength(), true, false, false); dimHash.put(newD.getName(), newD); if (isRecord) recordDim = newD; if (debug) System.out.println("add dim= " + newD); } // Variables Structure recordStruct = (Structure) bufr.findVariable(BufrIosp.obsRecord); for (Variable oldVar : recordStruct.getVariables()) { if (oldVar.getDataType() == DataType.STRUCTURE) continue; String varName = N3iosp.makeValidNetcdfObjectName(oldVar.getShortName()); DataType newType = oldVar.getDataType(); List<Dimension> newDims = new ArrayList<Dimension>(); newDims.add(recordDim); for (Dimension dim : oldVar.getDimensions()) { newDims.add(ncfile.addDimension(oldVar.getShortName() + "_strlen", dim.getLength())); } Variable newVar = ncfile.addVariable(varName, newType, newDims); if (debug) System.out.println("add var= " + newVar); // attributes List<Attribute> attList = oldVar.getAttributes(); for (Attribute att : attList) { String useName = N3iosp.makeValidNetcdfObjectName(att.getName()); if (att.isArray()) ncfile.addVariableAttribute(varName, useName, att.getValues()); else if (att.isString()) ncfile.addVariableAttribute(varName, useName, att.getStringValue()); else ncfile.addVariableAttribute(varName, useName, att.getNumericValue()); } } // int max_seq = countSeq(recordStruct); // Dimension seqD = ncfile.addDimension("level", max_seq); for (Variable v : recordStruct.getVariables()) { if (v.getDataType() != DataType.STRUCTURE) continue; String structName = N3iosp.makeValidNetcdfObjectName(v.getShortName()); int shape[] = v.getShape(); Dimension structDim = ncfile.addDimension(structName, shape[0]); Structure struct = (Structure) v; for (Variable seqVar : struct.getVariables()) { String varName = N3iosp.makeValidNetcdfObjectName(seqVar.getShortName() + "-" + structName); DataType newType = seqVar.getDataType(); List<Dimension> newDims = new ArrayList<Dimension>(); newDims.add(recordDim); newDims.add(structDim); for (Dimension dim : seqVar.getDimensions()) { newDims.add(ncfile.addDimension(seqVar.getShortName() + "_strlen", dim.getLength())); } Variable newVar = ncfile.addVariable(varName, newType, newDims); if (debug) System.out.println("add var= " + newVar); // attributes List<Attribute> attList = seqVar.getAttributes(); for (Attribute att : attList) { String useName = N3iosp.makeValidNetcdfObjectName(att.getName()); if (att.isArray()) ncfile.addVariableAttribute(varName, useName, att.getValues()); else if (att.isString()) ncfile.addVariableAttribute(varName, useName, att.getStringValue()); else ncfile.addVariableAttribute(varName, useName, att.getNumericValue()); } } } // create the file ncfile.create(); if (debug) System.out.println("File Out= " + ncfile.toString()); // boolean ok = (Boolean) ncfile.sendIospMessage(NetcdfFile.IOSP_MESSAGE_ADD_RECORD_STRUCTURE); double total = copyVarData(ncfile, recordStruct); ncfile.flush(); System.out.println("FileWriter done total bytes = " + total); ncfile.close(); }
public static void main2(String args[]) throws Exception { final int NLVL = 2; final int NLAT = 6; final int NLON = 12; final int NumberOfRecords = 2; final float SAMPLE_PRESSURE = 900.0f; final float SAMPLE_TEMP = 9.0f; final float START_LAT = 25.0f; final float START_LON = -125.0f; // Create the file. String filename = "pres_temp_4D.nc"; NetcdfFileWriteable dataFile = null; try { // Create new netcdf-3 file with the given filename dataFile = NetcdfFileWriteable.createNew(filename, false); // add dimensions where time dimension is unlimit Dimension lvlDim = dataFile.addDimension("level", NLVL); Dimension latDim = dataFile.addDimension("latitude", NLAT); Dimension lonDim = dataFile.addDimension("longitude", NLON); Dimension timeDim = dataFile.addDimension("time", 1000); // should // not be // need // second // argument ArrayList dims = null; // Define the coordinate variables. dataFile.addVariable("latitude", DataType.FLOAT, new Dimension[] {latDim}); dataFile.addVariable("longitude", DataType.FLOAT, new Dimension[] {lonDim}); // Define units attributes for data variables. dataFile.addVariableAttribute("latitude", "units", "degrees_north"); dataFile.addVariableAttribute("longitude", "units", "degrees_east"); // Define the netCDF variables for the pressure and temperature // data. dims = new ArrayList(); dims.add(timeDim); dims.add(lvlDim); dims.add(latDim); dims.add(lonDim); dataFile.addVariable("pressure", DataType.FLOAT, dims); dataFile.addVariable("temperature", DataType.FLOAT, dims); // Define units attributes for data variables. dataFile.addVariableAttribute("pressure", "units", "hPa"); dataFile.addVariableAttribute("temperature", "units", "celsius"); // Create some pretend data. If this wasn't an example program, we // would have some real data to write for example, model output. ArrayFloat.D1 lats = new ArrayFloat.D1(latDim.getLength()); ArrayFloat.D1 lons = new ArrayFloat.D1(lonDim.getLength()); int i, j; for (i = 0; i < latDim.getLength(); i++) { lats.set(i, START_LAT + 5.f * i); } for (j = 0; j < lonDim.getLength(); j++) { lons.set(j, START_LON + 5.f * j); } // Create the pretend data. This will write our surface pressure and // surface temperature data. ArrayFloat.D4 dataTemp = new ArrayFloat.D4( NumberOfRecords, lvlDim.getLength(), latDim.getLength(), lonDim.getLength()); ArrayFloat.D4 dataPres = new ArrayFloat.D4( NumberOfRecords, lvlDim.getLength(), latDim.getLength(), lonDim.getLength()); for (int record = 0; record < NumberOfRecords; record++) { i = 0; for (int lvl = 0; lvl < NLVL; lvl++) for (int lat = 0; lat < NLAT; lat++) for (int lon = 0; lon < NLON; lon++) { dataPres.set(record, lvl, lat, lon, SAMPLE_PRESSURE + i); dataTemp.set(record, lvl, lat, lon, SAMPLE_TEMP + i++); } } // Create the file. At this point the (empty) file will be written // to disk dataFile.create(); // A newly created Java integer array to be initialized to zeros. int[] origin = new int[4]; dataFile.write("latitude", lats); dataFile.write("longitude", lons); dataFile.write("pressure", origin, dataPres); dataFile.write("temperature", origin, dataTemp); dataFile.close(); } catch (IOException e) { e.printStackTrace(System.err); } catch (InvalidRangeException e) { e.printStackTrace(System.err); } finally { // if (dataFile != null) { // try { // dataFile.close(); // } catch (IOException ioe) { // ioe.printStackTrace(); // } // } } System.out.println("*** SUCCESS writing example file " + filename); }
private NetcdfFileWriteable writeNetcdfMetadata( NetcdfFileWriteable ncFile, String variableName, ArrayList<ArrayList<VariableEntry>> variableListList) throws IOException { int suffixInt = 1; for (ArrayList<VariableEntry> variableList : variableListList) { ArrayList<Dimension> dims = new ArrayList<Dimension>(); // add coordinate variables for each dimension for (int i = 0; i < variableList.size(); i++) { VariableEntry temp = variableList.get(i); Dimension tempDim; System.out.println("writing metadata for dim " + temp.getVariableName()); if (temp.isUnlimited()) { // see if there is already an unlimited dimension in this filea, // if so, use it. If not, add it // if ( ncFile.hasUnlimitedDimension() ) { if (this._unlimitedDim == null) { tempDim = ncFile.addUnlimitedDimension(temp.getVariableName()); this._unlimitedDim = tempDim; } else { // tempDim = this._unlimitedDim; dims.add(this._unlimitedDim); continue; } } else { tempDim = ncFile.addDimension(temp.getVariableName(), temp.getSize()); } // add a coordinate variable Dimension[] tempDimArray = {tempDim}; ncFile.addVariable(temp.getVariableName(), temp.getType(), tempDimArray); ncFile.addVariableAttribute(temp.getVariableName(), "units", temp.getUnits()); ncFile.addVariableAttribute(temp.getVariableName(), "long_name", temp.getLongName()); dims.add(tempDim); } // add the main variable System.out.println("adding variable " + (variableName + Integer.toString(suffixInt))); ncFile.addVariable(variableName + Integer.toString(suffixInt), DataType.INT, dims); suffixInt++; } /* ArrayList<Dimension> dims = new ArrayList<Dimension>(); Dimension tempDim; String localName = "dim"; for( int i = 0; i < dimensions.length; i++){ if ( (0 == i) && variableDim) { tempDim = ncFile.addUnlimitedDimension("dim" + Integer.toString(i)); } else { tempDim = ncFile.addDimension("dim" + Integer.toString(i), dimensions[i]); } dims.add( tempDim); } ncFile.addVariable(varName, dataType, dims); */ return ncFile; }