ucar.nc2.NetcdfFileWriter java code examples

Common ways to obtain NetcdfFileWriter

private void myMethod () {
 NetcdfFileWriter n =NetcdfFileWriter.Version version;String location;NetcdfFileWriter.createNew(version, location)
NetcdfFileWriter.Version version;String location;Nc4Chunking chunker;NetcdfFileWriter.createNew(version, location, chunker)
NetcdfFileWriter.Version version;File file;NetcdfFileWriter.createNew(version, file.getAbsolutePath())
Smart code suggestions by Codota
}

public void alterExistingFile(String url) throws IOException {
 NetcdfFileWriter file = null;
 try {
  file = NetcdfFileWriter.openExisting(url);
  file.setRedefineMode(true);
  //Group rootGroup = file.getRootGroup();
  //Group headerDataGroup = new Group(file, rootGroup, "header_data");
  //file.addGroup(rootGroup, headerDataGroup);
  file.addVariable(null, newVarName, DataType.FLOAT, "z y x");
 } finally {
  if (file != null) {
   file.setRedefineMode(false);
   file.flush();
   file.close();
  }
 }
}

private void open() throws KlabIOException {
  try {
    if (_file.exists()) {
      _ncfile = NetcdfFileWriter.openExisting(_file.toString());
    } else {
      _ncfile = NetcdfFileWriter.createNew(Version.netcdf3, _file.toString());
      _ncfile.create();
    }
  } catch (IOException e) {
    throw new KlabIOException(e);
  }
  _open = true;
}

public void write(String varname, Array values) throws java.io.IOException, InvalidRangeException {
 write(findVariable(varname), values);
}
/**

public boolean addVariableAttribute(String varName, Attribute att) {
 return addVariableAttribute(findVariable(varName), att);
}
/**

private void createWriter(String fileOut, NetcdfFileWriter.Version version) throws IOException {
 writer = NetcdfFileWriter.createNew(version, fileOut, null);
 writer.setFill(false);
}

@Test
public void testRedefine3() throws IOException, InvalidRangeException {
 String filename = tempFolder.newFile().getAbsolutePath();
 NetcdfFileWriter ncFile = NetcdfFileWriter.createNew (filename, false);
 ncFile.setExtraHeaderBytes (64*1000);
 Dimension dim = ncFile.addDimension ("time", 100);
 for (int i = 0; i < 100; i++) jillData[i] = 2*i;
 ncFile.addVariable ("jack", DataType.DOUBLE, "time");
 ncFile.addVariableAttribute ("jack", "where", "up the hill");
 ncFile.create();
 ncFile.write ("jack", start, Array.factory (DataType.DOUBLE, count, jackData));
 ncFile.setRedefineMode (true);
 ncFile.addVariable ("jill", DataType.DOUBLE, "time");
 ncFile.addVariableAttribute ("jill", "where", "up the hill");
 ncFile.setRedefineMode (false);
 ncFile.write ("jill", start, jillArray);
 ncFile.flush();
 ncFile.close();

try (NetcdfFileWriter ncfile = NetcdfFileWriter.createNew(fileOutName, fill)) {
 if (debug) {
  System.out.println("FileWriter write " + bufr.getLocation() + " to " + fileOutName);
  Attribute useAtt;
  if (att.isArray())
   useAtt = ncfile.addGlobalAttribute(new Attribute(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);
  String useName = N3iosp.makeValidNetcdfObjectName(oldD.getShortName());
  boolean isRecord = useName.equals("record");
  Dimension newD = ncfile.addDimension(useName, isRecord ? 0 : oldD.getLength(),
      isRecord, oldD.isVariableLength());
  if (isRecord) recordDim = newD;
  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);
    newVar.addAttribute(new Attribute(useName, att.getValues()));
   else if (att.isString())
    ncfile.addVariableAttribute(varName, useName, att.getStringValue());

private NetcdfFileWriter createTimeLatLonDataCube(String filename, double[] latitudes, double[] longitudes) throws IOException {
 NetcdfFileWriter writeableFile = NetcdfFileWriter.createNew(filename, true);
 // define dimensions, including unlimited
 Dimension latDim = writeableFile.addDimension(latVar, latitudes.length);
 Dimension lonDim = writeableFile.addDimension(lonVar, longitudes.length);
 Dimension timeDim = writeableFile.addUnlimitedDimension(timeVar);
 // define Variables
 defineHeader(writeableFile, timeVar, latVar, lonVar, timeVar+" "+latVar+" "+lonVar);
 // create the file
 writeableFile.create();
 writeableFile.close();
 return writeableFile;
}

NetcdfFileWriter writer = NetcdfFileWriter.createNew(version, fileName);
writer.setExtraHeaderBytes(64 * 1024);
Variable coordVar = writer.addVariable(root, "coord_ref", DataType.INT, "");
writer.create();
writer.flush();
writer.close();
logger.debug("File written {}", fileName);

@Before
public void setUp() throws IOException {
 filePath = tempFolder.newFile().getAbsolutePath();
 try (NetcdfFileWriter file = NetcdfFileWriter.createNew(NetcdfFileWriter.Version.netcdf3, filePath)) {
  file.addDimension(null, "t", DIM_T);
  file.addDimension(null, "alt", DIM_ALT);
  file.addDimension(null, "lat", DIM_LAT);
  file.addDimension(null, "lon", DIM_LON);
  file.addVariable(DATA_VARIABLE, DataType.FLOAT, "t alt lat lon");
  file.create();
 }
}

/**
 * Write the NetCDF file
 * @throws IOException
 * @throws InvalidRangeException
 */
public void write() throws IOException, InvalidRangeException {
  // end of define mode
  writer.create();
  // Setting values
  for (NetCDFDimensionMapping mapper : dimensionsManager.getDimensions()) {
    crsWriter.setCoordinateVariable(mapper);
  }
  writeDataValues();
  // Close the writer
  writer.close();
}

/**
 * Write the input file to the output file.
 * @param cancel  allow user to cancel; may be null.
 * @return the open output file.
 * @throws IOException
 */
public NetcdfFile write(CancelTask cancel) throws IOException {
 try {
  if (version.isNetdf4format())
   addGroup4(null, fileIn.getRootGroup());
  else
   addNetcdf3();
  if (cancel != null && cancel.isCancel()) return null;
  if (debugWrite)
   System.out.printf("About to write = %n%s%n", writer.getNetcdfFile());
  // create the file
  writer.create();
  if (debug)
   System.out.printf("File Out= %n%s%n", writer.getNetcdfFile());
  if (cancel != null && cancel.isCancel()) return null;
  double total = copyVarData(varList, null, cancel);
  if (cancel != null && cancel.isCancel()) return null;
  writer.flush();
  if (debug) System.out.println("FileWriter done total bytes = " + total);
 } catch (IOException ioe) {
  writer.abort();  // clean up
  throw ioe;
 }
 return writer.getNetcdfFile();
}

private static Dimension setDimension(NetcdfFileWriter ncFile, String name, String units, int length) {
 Dimension dimension = ncFile.addDimension(null, name, length);
 Variable v = ncFile.addVariable(null, name, DataType.FLOAT, name);
 ncFile.addVariableAttribute(v, new Attribute("units", units));
 return dimension;
}

@Test
public void testRewriteHeader3() throws IOException, InvalidRangeException {
 String filename = tempFolder.newFile().getAbsolutePath();
 try (NetcdfFileWriter file = NetcdfFileWriter.createNew(NetcdfFileWriter.Version.netcdf3, filename)) {
  file.addGlobalAttribute("att8", "1234567890");
  file.setExtraHeaderBytes(10);
  file.create();
  file.setRedefineMode(true);
  file.addGlobalAttribute("att8", "123456789012345");
  boolean rewriteAll = file.setRedefineMode(false);
  assert !rewriteAll;
  Attribute att = file.findGlobalAttribute("att8");
  assert att != null;
  assert att.getStringValue().equals("123456789012345") : att.getStringValue();
 }
}

private void addAtts(List<Attribute> atts) {
 if (writer == null) throw new IllegalStateException("NetcdfFileWriter must be created");
 writer.addGroupAttribute(null, new Attribute(CDM.CONVENTIONS, "CF-1.6"));
 writer.addGroupAttribute(null, new Attribute(CDM.HISTORY, "Written by CFPointWriter"));
 for (Attribute att : atts) {
  if (!reservedAttsList.contains(att.getShortName()))
   writer.addGroupAttribute(null, att);
 }
}

private void createObsVariables(DateUnit timeUnit) throws IOException {
 // time variable LOOK could also be time(profile)
 time = writer.addVariable(null, timeName, DataType.DOUBLE, recordDimName);
 writer.addVariableAttribute(time, new Attribute(CDM.UNITS, timeUnit.getUnitsString()));
 writer.addVariableAttribute(time, new Attribute(CDM.LONG_NAME, "time of measurement"));
 
 /*Variable zVar = ncfile.addVariable(zName, DataType.DOUBLE, recordDimName);
 ncfile.addVariableAttribute(timeVar, new Attribute(CDM.UNITS, zUnit));
 ncfile.addVariableAttribute(timeVar, new Attribute(CDM.LONG_NAME, "time of measurement")); */
 index = writer.addVariable(null, profileIndexName, DataType.INT, recordDimName);
 writer.addVariableAttribute(index, new Attribute(CDM.LONG_NAME, "profile index for this observation record"));
 writer.addVariableAttribute(index, new Attribute(CF.INSTANCE_DIMENSION, profileDimName));
}

private void addCoordTransforms(CoverageCollection subsetDataset, NetcdfFileWriter writer) {
 for (CoverageTransform ct : subsetDataset.getCoordTransforms()) {
  // scalar coordinate transform variable - container for transform info
  Variable ctv = writer.addVariable(null, ct.getName(), DataType.INT, "");
  for (Attribute att : ct.getAttributes())
   ctv.addAttribute(att);
 }
}

private void writeToFile(NetcdfFileWriter writer, Map<Variable, Array> variableArrayMap) throws EncodingException, IOException {
  writer.create();
  // fill the netCDF file with data
  try {
    for (Entry<Variable, Array> varEntry : variableArrayMap.entrySet()) {
      writer.write(varEntry.getKey(), varEntry.getValue());
    }
  } catch (InvalidRangeException e) {
    throw new EncodingException("Error writing netCDF variable data");
  }
}

/**
 * Add single unlimited dimension (classic model)
 * @param dimName name of dimension
 * @return Dimension object that was added
 */
public Dimension addUnlimitedDimension(String dimName) {
 return addDimension(null, dimName, 0, true, true, false);
}

/**
 * Specify which variable will get written
 *
 * @param oldVar add this variable, and all parent groups
 * @return new Variable.
 */
public Variable addVariable(Variable oldVar) {
 List<Dimension> newDims = getNewDimensions(oldVar);
 Variable newVar;
 if ((oldVar.getDataType().equals(DataType.STRING)) && (!version.isNetdf4format())) {
  newVar = writer.addStringVariable(null, oldVar, newDims);
 } else {
  newVar = writer.addVariable(null, oldVar.getShortName(), oldVar.getDataType(), newDims);
 }
 varMap.put(oldVar, newVar);
 varList.add(oldVar);
 for (Attribute att : oldVar.getAttributes())
  writer.addVariableAttribute(newVar, att); // atts are immutable
 return newVar;
}

Javadoc

Writes Netcdf 3 or 4 formatted files to disk. To write new files:

createNew()
Add objects with addXXX() deleteXXX() renameXXX() calls
create file and write metadata with create()
write data with writeXXX()
close()

To write data to existing files:

openExisting()
write data with writeXXX()
close()

NetcdfFileWriter is a low level wrap of IOServiceProviderWriter, if possible better to use:

ucar.nc2.FileWriter2()
ucar.nc2.dt.grid.CFGridWriter
ucar.nc2.ft.point.writer.CFPointWriter
ucar.nc2.ft2.coverage.grid.CFGridCoverageWriter

Most used methods

close
close the file.
createNew
Create a new Netcdf file, with fill mode true.
addVariable
Add a variable to the file. Must be in define mode.
create
After you have added all of the Dimensions, Variables, and Attributes, call create() to actually cre
write
Write data to the named variable. Must not be in define mode.
addDimension
Add a Dimension to the file. Must be in define mode.
addGroupAttribute
Add a Global attribute to the file. Must be in define mode.
addVariableAttribute
Add an attribute to the named Variable. Must be in define mode.
findVariable
flush
Flush anything written to disk.
addUnlimitedDimension
Add single unlimited dimension (classic model)
getVersion

Popular in Java

Reading from database using SQL prepared statement
setContentView (Activity)
compareTo (BigDecimal)
Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
scheduleAtFixedRate (ScheduledExecutorService)
Creates and executes a periodic action that becomes enabled first after the given initial delay, and
BufferedReader (java.io)
Reads text from a character-input stream, buffering characters so as to provide for the efficient re
Socket (java.net)
Provides a client-side TCP socket.
Dictionary (java.util)
The Dictionary class is the abstract parent of any class, such as Hashtable, which maps keys to valu
HashMap (java.util)
HashMap is an implementation of Map. All optional operations are supported.All elements are permitte
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
BoxLayout (javax.swing)

How to useNetcdfFileWriter in ucar.nc2

Best Java code snippets using ucar.nc2.NetcdfFileWriter (Showing top 20 results out of 315)

How to use
NetcdfFileWriter
in
ucar.nc2