private boolean addAxisType(NetcdfDataset ds, String vname, AxisType a) { if (vname == null) return false; Variable v = ds.findVariable(vname); if (v == null) return false; addAxisType(v, a); return true; }
private JoinArray readJoinArray(NetcdfDataset ds, Element joinElement) { JoinArray.Type type = JoinArray.Type.valueOf(joinElement.getAttributeValue("type")); Element paramElem = joinElement.getChild("param"); String paramS = paramElem.getText(); Integer param = Integer.parseInt(paramS); Element varElem = joinElement.getChild("variable"); String varName = varElem.getText(); VariableDS v = (VariableDS) ds.findVariable(varName); return new JoinArray(v, type, param); }
/** * Set extra information used by station obs datasets. Use stnIdVName or stnIndexVName. * * @param stnIdVName the obs variable that is used to find the station in the stnHash; may be type * int or a String (char). * @param stnDescVName optional station var containing station description */ public void setStationInfo( String stnIdVName, String stnDescVName, String stnIndexVName, StationHelper stationHelper) { this.stnIdVName = stnIdVName; this.stnDescVName = stnDescVName; this.stnIndexVName = stnIndexVName; this.stationHelper = stationHelper; if (stnIdVName != null) { Variable stationVar = ncfile.findVariable(stnIdVName); stationIdType = stationVar.getDataType(); } }
/** * Constructor. * * @param ncfile the netccdf file * @param typedDataVariables list of data variables; all record variables will be added to this * list, except . You can remove extra * @param obsTimeVName observation time variable name (required) * @param nomTimeVName nominal time variable name (may be null) * @throws IllegalArgumentException if ncfile has no unlimited dimension and recDimName is null. */ public RecordDatasetHelper( NetcdfDataset ncfile, String obsTimeVName, String nomTimeVName, List<VariableSimpleIF> typedDataVariables, String recDimName, Formatter errBuffer) { this.ncfile = ncfile; this.obsTimeVName = obsTimeVName; this.nomTimeVName = nomTimeVName; this.errs = errBuffer; // check if we already have a structure vs if we have to add it. if (this.ncfile.hasUnlimitedDimension()) { this.ncfile.sendIospMessage(NetcdfFile.IOSP_MESSAGE_ADD_RECORD_STRUCTURE); this.recordVar = (StructureDS) this.ncfile.getRootGroup().findVariable("record"); this.obsDim = ncfile.getUnlimitedDimension(); } else { if (recDimName == null) throw new IllegalArgumentException( "File <" + this.ncfile.getLocation() + "> has no unlimited dimension, specify psuedo record dimension with observationDimension global attribute."); this.obsDim = this.ncfile.getRootGroup().findDimension(recDimName); this.recordVar = new StructurePseudoDS(this.ncfile, null, "record", null, obsDim); } // create member variables List<Variable> recordMembers = ncfile.getVariables(); for (Variable v : recordMembers) { if (v == recordVar) continue; if (v.isScalar()) continue; if (v.getDimension(0) == this.obsDim) typedDataVariables.add(v); } // need the time units Variable timeVar = ncfile.findVariable(obsTimeVName); String timeUnitString = ncfile.findAttValueIgnoreCase(timeVar, CDM.UNITS, "seconds since 1970-01-01"); try { timeUnit = new DateUnit(timeUnitString); } catch (Exception e) { if (null != errs) errs.format("Error on string = %s == %s%n", timeUnitString, e.getMessage()); try { timeUnit = new DateUnit("seconds since 1970-01-01"); } catch (Exception e1) { // cant happen } } }
/** * 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); } }
@Test public void testH5StructureDS() throws java.io.IOException { int a_name = 0; String[] b_name = new String[] { "A fight is a contract that takes two people to honor.", "A combative stance means that you've accepted the contract.", "In which case, you deserve what you get.", " -- Professor Cheng Man-ch'ing" }; String c_name = "Hello!"; // H5header.setDebugFlags(new ucar.nc2.util.DebugFlagsImpl("H5header/header")); try (NetcdfDataset ncfile = NetcdfDataset.openDataset(TestH5.testDir + "complex/compound_complex.h5")) { Variable dset = ncfile.findVariable("CompoundComplex"); assert (null != dset); assert (dset.getDataType() == DataType.STRUCTURE); assert (dset.getRank() == 1); assert (dset.getSize() == 6); Dimension d = dset.getDimension(0); assert (d.getLength() == 6); Structure s = (Structure) dset; // read all with the iterator StructureDataIterator iter = s.getStructureIterator(); while (iter.hasNext()) { StructureData sd = iter.next(); assert sd.getScalarInt("a_name") == a_name; a_name++; assert sd.getScalarString("c_name").equals(c_name); String[] results = sd.getJavaArrayString(sd.findMember("b_name")); assert results.length == b_name.length; int count = 0; for (String r : results) assert r.equals(b_name[count++]); for (StructureMembers.Member m : sd.getMembers()) { Array data = sd.getArray(m); NCdumpW.printArray(data, m.getName(), out, null); } } } System.out.println("*** testH5StructureDS ok"); }
public void setLocationInfo(String latVName, String lonVName, String zcoordVName) { this.latVName = latVName; this.lonVName = lonVName; this.zcoordVName = zcoordVName; // check for meter conversion if (zcoordVName != null) { Variable v = ncfile.findVariable(zcoordVName); zcoordUnits = ncfile.findAttValueIgnoreCase(v, CDM.UNITS, null); if (zcoordUnits != null) try { altScaleFactor = getMetersConversionFactor(zcoordUnits); } catch (Exception e) { if (errs != null) errs.format("%s", e.getMessage()); } } }
public static void doVar(NetcdfDataset netcdfdataset, String varS, String limits) { System.out.println("\r---------\r\r"); ucar.nc2.Variable var = netcdfdataset.findVariable(varS); System.out.println(var.getName() + " " + var.getSize()); Array arr; try { arr = var.read(limits); NCdump.printArray(arr, "array", System.out, null); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvalidRangeException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
public String getReadOk() { if (!getComplete().equals("true")) return "false"; if (!getBitsOk().equals("true")) return "false"; if (!doRead) return "N/A"; if (readOk == 0) try { NetcdfDataset ncd = getBufrMessageAsDataset(m); SequenceDS v = (SequenceDS) ncd.findVariable(BufrIosp.obsRecord); StructureDataIterator iter = v.getStructureIterator(-1); while (iter.hasNext()) { iter.next(); } readOk = 1; } catch (Exception e) { readOk = 2; } return readOk == 1 ? "true" : "false"; }
private void setObs(Message m) { java.util.List<ObsBean> beanList = new ArrayList<ObsBean>(); try { NetcdfDataset ncd = getBufrMessageAsDataset(m); Variable v = ncd.findVariable(BufrIosp.obsRecord); if ((v != null) && (v instanceof Structure)) { Structure obs = (Structure) v; StructureDataIterator iter = obs.getStructureIterator(); while (iter.hasNext()) { beanList.add(new ObsBean(obs, iter.next())); } } } catch (Exception ex) { JOptionPane.showMessageDialog(BufrMessageViewer.this, ex.getMessage()); ex.printStackTrace(); } obsTable.setBeans(beanList); }
public static void main(String args[]) throws Exception { long start = System.currentTimeMillis(); Map<String, ucar.unidata.geoloc.Station> staHash = new HashMap<String, ucar.unidata.geoloc.Station>(); String location = "R:/testdata/sounding/netcdf/Upperair_20070401_0000.nc"; NetcdfDataset ncfile = NetcdfDataset.openDataset(location); ncfile.sendIospMessage(NetcdfFile.IOSP_MESSAGE_ADD_RECORD_STRUCTURE); // look through record varibles, for those that have "manLevel" dimension // make a StructureData object for those StructureMembers sm = new StructureMembers("manLevel"); Dimension manDim = ncfile.findDimension("manLevel"); Structure record = (Structure) ncfile.findVariable("record"); List<Variable> allList = record.getVariables(); List<VariableSimpleIF> varList = new ArrayList<VariableSimpleIF>(); for (Variable v : allList) { if ((v.getRank() == 1) && v.getDimension(0).equals(manDim)) { // public VariableDS(NetcdfDataset ds, Group group, Structure parentStructure, String // shortName, DataType dataType, // String dims, String units, String desc) { varList.add( new VariableDS( ncfile, null, null, v.getShortName(), v.getDataType(), "", v.getUnitsString(), v.getDescription())); // (String name, String desc, String units, DataType dtype, int []shape) sm.addMember( v.getShortName(), v.getDescription(), v.getUnitsString(), v.getDataType(), new int[0]); // scalar } } ArrayStructureMA manAS = new ArrayStructureMA(sm, new int[] {manDim.getLength()}); // need the date units Variable time = ncfile.findVariable("synTime"); String timeUnits = ncfile.findAttValueIgnoreCase(time, "units", null); timeUnits = StringUtil.remove(timeUnits, '('); // crappy fsl'ism timeUnits = StringUtil.remove(timeUnits, ')'); DateUnit timeUnit = new DateUnit(timeUnits); // extract stations int nrecs = 0; StructureDataIterator iter = record.getStructureIterator(); while (iter.hasNext()) { StructureData sdata = iter.next(); String name = sdata.getScalarString("staName"); ucar.unidata.geoloc.Station s = staHash.get(name); if (s == null) { float lat = sdata.convertScalarFloat("staLat"); float lon = sdata.convertScalarFloat("staLon"); float elev = sdata.convertScalarFloat("staElev"); s = new StationImpl(name, "", lat, lon, elev); staHash.put(name, s); } nrecs++; } List<ucar.unidata.geoloc.Station> stnList = Arrays.asList(staHash.values().toArray(new ucar.unidata.geoloc.Station[staHash.size()])); Collections.sort(stnList); // create the writer WriterProfileObsDataset writer = new WriterProfileObsDataset(location + ".out", "rewrite " + location); writer.writeHeader(stnList, varList, nrecs, "prMan"); // extract records iter = record.getStructureIterator(); while (iter.hasNext()) { StructureData sdata = iter.next(); String name = sdata.getScalarString("staName"); double timeValue = sdata.convertScalarDouble("synTime"); Date date = timeUnit.makeDate(timeValue); // transfer to the ArrayStructure List<String> names = sm.getMemberNames(); for (String mname : names) { manAS.setMemberArray(mname, sdata.getArray(mname)); } // each level is weritten as a seperate structure int numMand = sdata.getScalarInt("numMand"); if (numMand >= manDim.getLength()) continue; for (int i = 0; i < numMand; i++) { StructureData useData = manAS.getStructureData(i); writer.writeRecord(name, date, useData); } } writer.finish(); long took = System.currentTimeMillis() - start; System.out.println("That took = " + took); }
public static void generateObs(NetcdfDataset netcdfdataset) { try { ucar.nc2.Variable lon = netcdfdataset.findVariable("lon"); ucar.nc2.Variable lat = netcdfdataset.findVariable("lat"); ucar.nc2.Variable time = netcdfdataset.findVariable("time"); ucar.nc2.Variable BAssta = netcdfdataset.findVariable("BAssta"); Array dataLat = lat.read(); int[] shapeLat = lat.getShape(); Index indexLat = dataLat.getIndex(); Array dataLon = lon.read(); int[] shapeLon = lon.getShape(); Index indexLon = dataLon.getIndex(); Array dataTime = time.read(); Index indexTime = dataTime.getIndex(); // mbari double minLat = 34.955; double maxLat = 38.260; double minLon = -124.780; double maxLon = -121.809; int minIndexLat = -Integer.MAX_VALUE; int minIndexLon = Integer.MAX_VALUE; int maxIndexlat = Integer.MIN_VALUE; int maxIndexLon = Integer.MIN_VALUE; // lon is ginve as + // int[][] indexLatLon = new int[shapeLat[0]][shapeLon[0]]; List lats = new ArrayList<Integer>(); List lons = new ArrayList<Integer>(); // get lats for (int i = 0; i < shapeLat[0]; i++) { Double lat_d = dataLat.getDouble(indexLat.set(i)); if (lat_d >= minLat && lat_d <= maxLat) { minIndexLat = i; lats.add(i); } } for (int j = 0; j < shapeLon[0]; j++) { Double lon_d = dataLon.getDouble(indexLon.set(j)); if (lon_d > 180) { lon_d = -360 + lon_d; } if (lon_d >= minLon && lon_d <= maxLon) { lons.add(j); } } // get values: ucar.nc2.Variable bassta = netcdfdataset.findVariable("BAssta"); int indMinLat = (Integer) lats.get(0); int indMaxLat = (Integer) lats.get(lats.size() - 1); int indMinLon = (Integer) lons.get(0); int indMaxLon = (Integer) lons.get(lons.size() - 1); int indMinTime = 0; int indMaxTime = time.getShape()[0] - 1; String s = createString(indMinLat, indMaxLat, indMinLon, indMaxLon, indMinTime, indMaxTime); // doVar(netcdfdataset, "BAssta", s); // Array dataVar= bassta.read(); // bassta.getShape() // System.out.println("lats size: " + lats.size()+" "+"lons size: // "+lons.size()); // for a given lat lon get time series // 1st lat lon s = createString(indMinLat, indMinLat, indMinLon, indMinLon, indMinTime, indMaxTime); Array arr = BAssta.read(s); int[] shapeArr = arr.getShape(); Index index = arr.getIndex(); System.out.println(shapeArr); // [74, 1, 1, 1] for (int i = 0; i < shapeArr[0]; i++) { Double d = arr.getDouble(index.set(i, 0, 0, 0)); Double t = dataTime.getDouble(indexTime.set(i)); String timeS = TimeUtil.getISOFromMillisec(t * 1000); System.out.println(t + " " + timeS + " " + d); } // lat lon are fixed, only varying time // basta[time,alt,lat,lon] // NCdump.printArray(arr, "array", System.out, null); // doVar(netcdfdataset, "BAssta", s); // doVar(netcdfdataset, "time", indMinTime + ":" + indMaxTime); // while (i < lon.getSize()) { // System.out.println("obs" + i + " " + lat + " " + lon); // i++; // } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvalidRangeException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
public static NetcdfDataset buildStation(IObservationGroup obsGroup) { if (obsGroup.getDepths().length > 1) { return buildStationProfile(obsGroup); } NetcdfDataset ncds = null; File temp = null; try { /* Instantiate an empty NetcdfDataset object from the template ncml */ temp = File.createTempFile("ooi", ".ncml"); ncds = getNcdsFromTemplate(temp, "station.ncml"); Map<String, String> allAttributes = new HashMap<String, String>(); allAttributes.putAll(obsGroup.getAttributes()); /* Do the station Id */ ArrayInt.D0 aid = new ArrayInt.D0(); aid.set(obsGroup.getId()); ncds.findVariable("stnId").setCachedData(aid); /* Do the times */ Number[] times = obsGroup.getTimes(); IObservationGroup.DataType tdt = obsGroup.getTimeDataType(); ncds.findDimension("time").setLength(times.length); Variable tvar = ncds.findVariable("time"); tvar.setDataType(getNcDataType(tdt)); tvar.setCachedData(getNcArray(times, tdt)); /* Do the lat & lon */ IObservationGroup.DataType lldt = obsGroup.getLatLonDataType(); DataType ncdtLl = getNcDataType(lldt); Variable laVar = ncds.findVariable("lat"); laVar.setDataType(ncdtLl); laVar.setCachedData(getNcScalar(obsGroup.getLat(), lldt)); Variable loVar = ncds.findVariable("lon"); loVar.setDataType(ncdtLl); loVar.setCachedData(getNcScalar(obsGroup.getLon(), lldt)); /* Do the depth */ IObservationGroup.DataType ddt = obsGroup.getDepthDataType(); VariableDS zVar = new VariableDS( ncds, null, null, "stnDepth", getNcDataType(ddt), "", "m", "station depth"); zVar.addAttribute(new Attribute("positive", "down")); ncds.addVariable(null, zVar); Number depth = obsGroup.getDepths()[0]; zVar.setCachedData(getNcScalar(obsGroup.getDepths()[0], ddt)); /* Do the data variables */ for (VariableParams dn : obsGroup.getDataNames()) { DataType ncdtData = getNcDataType(dn.getDataType()); VariableDS dvar = new VariableDS( ncds, null, null, dn.getShortName(), ncdtData, "time", dn.getUnits(), dn.getDescription()); dvar.addAttribute(new Attribute(CF.COORDINATES, "time lon lat")); dvar.addAttribute(new Attribute(CF.STANDARD_NAME, dn.getStandardName())); Array adata = Array.factory(ncdtData, new int[] {times.length}); IndexIterator aii = adata.getIndexIterator(); dvar.setCachedData(adata); ncds.addVariable(null, dvar); for (int ti = 0; ti < times.length; ti++) { putArrayData(aii, ncdtData, obsGroup.getData(dn, times[ti], depth)); } } /* Add global attributes */ for (String key : allAttributes.keySet()) { ncds.addAttribute(null, new Attribute(key, allAttributes.get(key))); } } catch (FileNotFoundException ex) { Logger.getLogger(NcdsFactory.class.getName()).log(Level.SEVERE, null, ex); } catch (IOException ex) { Logger.getLogger(NcdsFactory.class.getName()).log(Level.SEVERE, null, ex); } finally { if (temp != null) { if (!temp.delete()) { temp.deleteOnExit(); } } if (ncds != null) { ncds.finish(); } } return ncds; }
public static NetcdfDataset buildTrajectory(List<IObservationGroup> obsGroups) { // IObservationGroup.DataType tdt = IObservationGroup.DataType.values()[0]; // IObservationGroup.DataType lldt = IObservationGroup.DataType.values()[0]; // IObservationGroup.DataType ddt = IObservationGroup.DataType.values()[0]; // for(IObservationGroup og : obsGroups) { // tdt = (og.getTimeDataType().compareTo(tdt) > 0) ? og.getTimeDataType() : tdt; // lldt = (og.getLatLonDataType().compareTo(lldt) > 0) ? og.getLatLonDataType() : // lldt; // ddt = (og.getDepthDataType().compareTo(ddt) > 0) ? og.getDepthDataType() : ddt; // } NetcdfDataset ncds = null; File temp = null; try { /* Instantiate an empty NetcdfDataset object from the template ncml */ temp = File.createTempFile("ooi", ".ncml"); ncds = getNcdsFromTemplate(temp, "trajectory.ncml"); int nobs = obsGroups.size(); List<Number> allDepths = new ArrayList<Number>(); List<VariableParams> allDn = new ArrayList<VariableParams>(); int nt = nobs; int nd = 0; for (IObservationGroup og : obsGroups) { nd = Math.max(nd, og.getDepths().length); for (Number d : og.getDepths()) { if (!allDepths.contains(d)) { allDepths.add(d); } } for (VariableParams dn : og.getDataNames()) { if (!allDn.contains(dn)) { allDn.add(dn); } } } /* Do the trajectory ID */ /* Do the times */ Number[] times = obsGroups.get(0).getTimes(); IObservationGroup.DataType tdt = obsGroups.get(0).getTimeDataType(); DataType ncdtTime = getNcDataType(tdt); ncds.findDimension("time").setLength(nt); Array tarr = Array.factory(ncdtTime, new int[] {nt}); IndexIterator tii = tarr.getIndexIterator(); Variable tvar = ncds.findVariable("time"); tvar.setDataType(getNcDataType(tdt)); tvar.setCachedData(tarr); /* Do the lats */ IObservationGroup.DataType lldt = obsGroups.get(0).getLatLonDataType(); DataType ncdtLl = getNcDataType(lldt); Array laarr = Array.factory(ncdtLl, new int[] {nt}); IndexIterator laii = laarr.getIndexIterator(); Variable lavar = ncds.findVariable("lat"); lavar.setDataType(ncdtLl); lavar.setCachedData(laarr); /* Do the lons */ Array loarr = Array.factory(ncdtLl, new int[] {nt}); IndexIterator loii = loarr.getIndexIterator(); Variable lovar = ncds.findVariable("lon"); lovar.setDataType(ncdtLl); lovar.setCachedData(loarr); /* Iterate over the observation groups and fill the data */ Map<String, String> allAttributes = new HashMap<String, String>(); IObservationGroup og; HashMap<String, IndexIterator> darrs = new HashMap<String, IndexIterator>(); Number time; Number depth = allDepths.get(0); for (int obs = 0; obs < nobs; obs++) { og = obsGroups.get(obs); time = og.getTimes()[0]; putArrayData(tii, ncdtTime, time); putArrayData(loii, ncdtLl, og.getLon()); putArrayData(laii, ncdtLl, og.getLat()); for (VariableParams dn : allDn) { if (og.getDataNames().contains(dn)) { DataType ncdtData = getNcDataType(dn.getDataType()); VariableDS dvar = (VariableDS) ncds.findVariable(dn.getShortName()); if (dvar == null) { dvar = new VariableDS( ncds, null, null, dn.getShortName(), ncdtData, "time", dn.getUnits(), dn.getDescription()); dvar.addAttribute(new Attribute(CF.COORDINATES, "time lon lat")); // dvar.addAttribute(new Attribute("missing_value", // missingData)); dvar.addAttribute(new Attribute(CF.STANDARD_NAME, dn.getStandardName())); Array darr = Array.factory(ncdtData, new int[] {nt}); dvar.setCachedData(darr); darrs.put(dn.getStandardName(), darr.getIndexIterator()); ncds.addVariable(null, dvar); } putArrayData(darrs.get(dn.getStandardName()), ncdtData, og.getData(dn, time, depth)); } else { /* * station doesn't have this variable - don't believe * this can even happen... * * NOTE: This would indicate a problem with the above processing where the data-name list * has been modified prior to contains-checking */ } } } /* Add global attributes */ for (String key : allAttributes.keySet()) { ncds.addAttribute(null, new Attribute(key, allAttributes.get(key))); } } catch (FileNotFoundException ex) { Logger.getLogger(NcdsFactory.class.getName()).log(Level.SEVERE, null, ex); } catch (IOException ex) { Logger.getLogger(NcdsFactory.class.getName()).log(Level.SEVERE, null, ex); } finally { if (temp != null) { if (!temp.delete()) { temp.deleteOnExit(); } } if (ncds != null) { ncds.finish(); } } return ncds; }
/** * Creates the w file * * @param uFile - the input east-west velocity file * @param vFile - the input north-south velocity file * @throws InvalidRangeException * @throws IOException */ private void generate(NetcdfDataset uFile, NetcdfDataset vFile) throws InvalidRangeException, IOException { // Set up empty arrays for ranges and dimensions. dims = new ArrayList<Dimension>(); // Create the output file outfile = NetcdfFileWriteable.createNew(outputWFile, false); // Construct the data set dimensions - Time, Depth, Latitude and // Longitude (in order) int uTimeLength = uFile.findDimension(inTimeName).getLength(); int uLayerLength = uFile.findDimension(inLayerName).getLength(); int uXLength = uFile.findDimension(inXName).getLength(); int uYLength = uFile.findDimension(inYName).getLength(); int vTimeLength = vFile.findDimension(inTimeName).getLength(); int vLayerLength = vFile.findDimension(inLayerName).getLength(); int vXLength = vFile.findDimension(inXName).getLength(); int vYLength = vFile.findDimension(inYName).getLength(); Dimension timeDim = outfile.addDimension(outTimeName, Math.min(uTimeLength, vTimeLength)); Dimension layerDim = outfile.addDimension(outLayerName, Math.min(uLayerLength, vLayerLength)); Dimension yDim = outfile.addDimension(outYName, Math.min(uYLength, vYLength)); Dimension xDim = outfile.addDimension(outXName, Math.min(uXLength, vXLength)); // Add to a list - this becomes the coordinate system for the output // variable. The order is *very* important! dims.add(timeDim); dims.add(layerDim); dims.add(yDim); dims.add(xDim); // Create variables in the output file outfile.addVariable(outTimeName, DataType.DOUBLE, new Dimension[] {timeDim}); outfile.addVariable(outLayerName, DataType.DOUBLE, new Dimension[] {layerDim}); outfile.addVariable(outLatName, DataType.DOUBLE, new Dimension[] {yDim, xDim}); outfile.addVariable(outLonName, DataType.DOUBLE, new Dimension[] {yDim, xDim}); // outfile.setLargeFile(true); outfile.addVariable(outVarName, DataType.FLOAT, dims); // Add attribute information (cloned from source) cloneAttributes(uFile, inTimeName, outfile, outTimeName); cloneAttributes(uFile, inLayerName, outfile, outLayerName); cloneAttributes(uFile, inLatName, outfile, outLatName); cloneAttributes(uFile, inLonName, outfile, outLonName); // Finalizes the structure of the output file, making the changes real. outfile.create(); // Write the static information for 1D axes. outfile.write(outTimeName, uFile.findVariable(inTimeName).read()); outfile.write(outLayerName, uFile.findVariable(inLayerName).read()); outfile.write(outLatName, uFile.findVariable(inLatName).read()); outfile.write(outLonName, uFile.findVariable(inLonName).read()); Variable u = uFile.findVariable(inUName); Variable v = vFile.findVariable(inVName); Variable latdim = uFile.findVariable(inLatName); Variable londim = uFile.findVariable(inLonName); Variable zdim = uFile.findVariable(inLayerName); // Read the depth array Array depth_array = zdim.read(new int[] {0}, new int[] {uLayerLength}); double[] depths; if (depth_array.getClass().getName().contains("Float")) { float[] tmp = (float[]) depth_array.copyTo1DJavaArray(); depths = new double[tmp.length]; for (int i = 0; i < tmp.length; i++) { depths[i] = tmp[i]; } } else { depths = (double[]) depth_array.copyTo1DJavaArray(); } // Determine the size and midpoint of the depth bins double[] binz = new double[depths.length - 1]; float[] mpz = new float[depths.length - 1]; for (int i = 0; i < depths.length - 1; i++) { binz[i] = depths[i + 1] - depths[i]; mpz[i] = (float) (depths[i + 1] + depths[i]) / 2; } float[] nan = new float[uLayerLength]; for (int n = 0; n < uLayerLength; n++) { nan[n] = Float.NaN; } // Write the collar as NaNs. Array nana = Array.factory(java.lang.Float.class, new int[] {1, uLayerLength, 1, 1}, nan); for (int t = 0; t < u.getShape(0); t++) { for (int j = 0; j < u.getShape(3); j++) { outfile.write(outVarName, new int[] {t, 0, 0, j}, nana); outfile.write(outVarName, new int[] {t, 0, u.getShape(2) - 1, j}, nana); } for (int i = 1; i < u.getShape(2) - 1; i++) { outfile.write(outVarName, new int[] {t, 0, i, 0}, nana); outfile.write(outVarName, new int[] {t, 0, i, u.getShape(3) - 1}, nana); } } // Calculate w values for each time, depth, lat and lon // using 3x3 (horizontal) vertical pencils for (int t = 0; t < u.getShape(0); t++) { for (int i = 1; i < u.getShape(2) - 1; i++) { Array lta = latdim .read( new int[] {i - 1, 0}, // move for // speed new int[] {3, 1}) .reduce(); double currentLat = lta.getDouble(1); for (int j = 1; j < u.getShape(3) - 1; j++) { float[] w_arr = new float[uLayerLength]; if (i == 0 || j == 0 || i == u.getShape(2) - 1 || j == u.getShape(3) - 1) { for (int n = 0; n < w_arr.length; n++) { w_arr[n] = Float.NaN; } continue; } Array lna = londim.read(new int[] {0, j - 1}, new int[] {1, 3}).reduce(); double currentLon = lna.getDouble(1); float maxZ = bathy.value_at_lonlat((float) currentLon, (float) currentLat); boolean alwaysNaN = true; for (int k = u.getShape(1) - 1; k >= 0; k--) { // If the bathymetry says we're on land, then all values // will be NaN. This type of check is required because // the value does not equal java.Float.NaN, but // 1.2676506E30. if (maxZ > bathy_cutoff) { w_arr[k] = Float.NaN; continue; } if (k == 0) { if (!alwaysNaN) { w_arr[k] = 0; } else { w_arr[k] = Float.NaN; } continue; } if (maxZ < mpz[k - 1]) { w_arr[k] = Float.NaN; continue; } Array ua = u.read(new int[] {t, k, i - 1, j - 1}, new int[] {1, 1, 3, 3}).reduce(); Array va = v.read(new int[] {t, k, i - 1, j - 1}, new int[] {1, 1, 3, 3}).reduce(); float dz = calcdz(k, mpz, maxZ); if (Float.isNaN(dz)) { w_arr[k] = dz; continue; } float dwdz = calcdwdz(lta, lna, ua, va); if (Float.isNaN(dwdz)) { continue; } if (alwaysNaN) { w_arr[k] = dwdz; alwaysNaN = false; } else { w_arr[k] = w_arr[k + 1] + dwdz; } } Array warra = Array.factory(java.lang.Float.class, new int[] {1, uLayerLength, 1, 1}, w_arr); outfile.write(outVarName, new int[] {t, 0, i, j}, warra); } System.out.println("\tRow " + i + " complete."); } System.out.printf("Time %d of " + (u.getShape(0)) + " is complete.\n", t + 1); } }