コード例 #1
0
  /**
   * Retrieves velocities as a vector [u,v,w] based on given positions
   *
   * @param time - time coordinate in milliseconds
   * @param z - depth coordinate
   * @param lon - longitude (decimal degrees)
   * @param lat - latitude (decimal degrees)
   */
  @Override
  public synchronized double[] getVelocities(long time, double z, double lon, double lat) {

    if (Double.isNaN(lon) || Double.isNaN(lat)) {
      throw new IllegalArgumentException("Latitude or Longitude value is NaN");
    }

    // Completely outside the time bounds

    if (time < bounds[0][0] || time > bounds[0][1]) {
      this.notifyAll();
      return null;
    }

    // Completely outside the vertical bounds

    if (z < bounds[1][0] || z > bounds[1][1]) {
      this.notifyAll();
      return null;
    }

    // Completely outside the north-south bounds - return null as opposed
    // to NODATA

    if (lat < bounds[2][0] || lat > bounds[2][1]) {
      this.notifyAll();
      return null;
    }

    // Completely outside the east-west bounds

    if (lon < bounds[3][0] || lon > bounds[3][1]) {
      this.notifyAll();
      return null;
    }

    checkTime(time);

    try {
      int js, is, ks, ts;

      // Searching for the cell indices nearest to the given location

      is = yloc.lookup(lat);
      js = xloc.lookup(lon);
      ks = zloc.lookup(z);
      ts = tloc.lookup(TimeConvert.millisToHYCOM(time));

      // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
      // ATTENTION!!!! THE ORDER IS VERY IMPORTANT HERE!!!! Latitude (i/y)
      // and then Longitude (j/x). That's the way it is set up in the
      // NetCDF File. The best way would be to have automatic order
      // detection
      // somehow....
      // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

      // Handling data edges

      int i_lhs = halfKernel;
      int i_rhs = halfKernel;
      int j_lhs = halfKernel;
      int j_rhs = halfKernel;
      int k_lhs = zHalfKernel;
      int k_rhs = zHalfKernel;

      if (is < halfKernel) {
        i_lhs = is;
      }
      if (is + halfKernel >= yloc.arraySize()) {
        i_rhs = yloc.arraySize() - is - 1;
      }
      if (js < halfKernel) {
        j_lhs = js;
      }
      if (js + halfKernel >= xloc.arraySize()) {
        j_rhs = xloc.arraySize() - js - 1;
      }
      if (ks < zHalfKernel) {
        k_lhs = ks;
      }
      if (ks + zHalfKernel >= zloc.arraySize()) {
        k_rhs = zloc.arraySize() - ks - 1;
      }

      int istart = is - i_lhs;
      int jstart = js - j_lhs;
      int kstart = ks - k_lhs;

      // LHS + RHS + middle

      int idim = i_lhs + i_rhs + 1;
      int jdim = j_lhs + j_rhs + 1;
      int kdim = k_lhs + k_rhs + 1;

      // Splines cannot be used with only 2 points. If we are using a
      // kernel size of 3 and it is reduced due to edge effects, then
      // slide the window.

      if (kdim == 2) {
        if (kstart != 0) {
          kstart -= (k_rhs + 1);
        }
        kdim = zKernelSize;
      }

      int blocksize = idim * jdim * kdim;
      // int semiblock = (idim * (jdim + 1) * kdim) / 3;

      int[] origin = new int[] {ts, kstart, istart, jstart};
      int[] shape = new int[] {1, kdim, idim, jdim};

      try {
        uArr = uVar.read(origin, shape);
        uArr = uArr.reduce();
      } catch (InvalidRangeException e) {
        // Should not occur. Checking done above.
        e.printStackTrace();
      }

      try {
        vArr = vVar.read(origin, shape);
        vArr = vArr.reduce();
      } catch (InvalidRangeException e) {
        // Should not occur. Checking done above.
        e.printStackTrace();
      }

      if (zloc.isIn_Bounds() >= 0) {

        try {
          wArr = wVar.read(origin, shape);
          wArr = wArr.reduce();

        } catch (InvalidRangeException e) {
          // Should not occur. Checking done above.
          e.printStackTrace();
        }
      }

      float[][][] autmp = (float[][][]) uArr.copyToNDJavaArray();
      float[][][] avtmp = (float[][][]) vArr.copyToNDJavaArray();
      float[][][] awtmp = (float[][][]) wArr.copyToNDJavaArray();

      // Mitigate NODATA values

      int uct = 0;
      double usum = 0;
      double uavg = 0;
      double ussq = 0;
      double uvar = 0;

      int vct = 0;
      double vsum = 0;
      double vavg = 0;
      double vssq = 0;
      double vvar = 0;

      int wct = 0;
      double wsum = 0;
      double wavg = 0;
      double wssq = 0;
      double wvar = 0;

      for (int i = 0; i < idim; i++) {
        for (int j = 0; j < jdim; j++) {
          for (int k = 0; k < kdim; k++) {

            if (autmp[k][i][j] < cutoff && !Double.isNaN(autmp[k][i][j])) {
              uct++;
              usum += autmp[k][i][j];
              uavg = usum / uct;
              ussq += autmp[k][i][j] * autmp[k][i][j];
              uvar = ussq / uct - uavg * uavg;
              // } else {
              // if ((k > 0) && Double.isNaN(autmp[k - 1][i][j]))
              // {
              // autmp[k][i][j] = 0;
              // }
            }
          }
        }
      }

      for (int i = 0; i < idim; i++) {
        for (int j = 0; j < jdim; j++) {
          for (int k = 0; k < kdim; k++) {
            if (avtmp[k][i][j] < cutoff && !Double.isNaN(avtmp[k][i][j])) {
              vct++;
              vsum += avtmp[k][i][j];
              vavg = vsum / vct;
              vssq += avtmp[k][i][j] * avtmp[k][i][j];
              vvar = vssq / vct - vavg * vavg;
              // } else {
              // if ((k > 0)
              // && Double.isNaN(avtmp[k - 1][i][j])) {
              // avtmp[k][i][j] = 0;
              // }
            }
          }
        }
      }

      if (zloc.isIn_Bounds() >= 0) {

        for (int i = 0; i < idim; i++) {
          for (int j = 0; j < jdim; j++) {
            for (int k = 0; k < kdim; k++) {

              if (awtmp[k][i][j] < cutoff && !Double.isNaN(awtmp[k][i][j])) {
                wct++;
                wsum += awtmp[k][i][j];
                wavg = wsum / wct;
                wssq += awtmp[k][i][j] * awtmp[k][i][j];
                wvar = wssq / wct - wavg * wavg;
                // } else {
                // if ((k > 0)
                // && Double.isNaN(awtmp[k - 1][i][j])) {
                // awtmp[k][i][j] = 0;
                // }
              }
            }
          }
        }
      }

      nearNoData = false;

      // If there are null values...

      if (uct < blocksize) {

        nearNoData = true;

        // If there are more than (io-1)^2, return null

        /*
         * if (uct < semiblock) { velocities = NODATA; averages =
         * NODATA; variances = NODATA; return NODATA; }
         */

        // Otherwise mitigate by replacing using the average value.

        for (int i = 0; i < idim; i++) {
          for (int j = 0; j < jdim; j++) {
            for (int k = 0; k < kdim; k++) {

              if (autmp[k][i][j] > cutoff || Double.isNaN(autmp[k][i][j])) {

                if (ks == 0) {
                  autmp[k][i][j] = 0;
                }

                autmp[k][i][j] = (float) uavg;
              }
            }
          }
        }
      }

      if (vct < blocksize) {

        nearNoData = true;

        // If there are more than halfKernel/2, return null

        /*
         * if (vct < semiblock) { this.notifyAll(); velocities = NODATA;
         * averages = NODATA; variances = NODATA; return NODATA; }
         */

        // Otherwise mitigate by replacing using the average value.

        for (int i = 0; i < idim; i++) {
          for (int j = 0; j < jdim; j++) {
            for (int k = 0; k < kdim; k++) {

              if (avtmp[k][i][j] > cutoff || Double.isNaN(avtmp[k][i][j])) {

                avtmp[k][i][j] = (float) vavg;
              }
            }
          }
        }
      }
      if (zloc.isIn_Bounds() >= 0) {
        if (wct < blocksize) {

          nearNoData = true;

          // If there are more than (halfKernel-1)^2, return null

          /*
           * if (wct < semiblock) { this.notifyAll(); velocities =
           * NODATA; averages = NODATA; variances = NODATA; return
           * NODATA; }
           */

          // Otherwise mitigate by replacing using the average value.

          for (int i = 0; i < idim; i++) {
            for (int j = 0; j < jdim; j++) {
              for (int k = 0; k < kdim; k++) {

                if (awtmp[k][i][j] > cutoff || Double.isNaN(awtmp[k][i][j])) {

                  awtmp[k][i][j] = (float) wavg;
                }
              }
            }
          }
        }
      }

      /*
       * Convert the Arrays into Java arrays - because latitude and z
       * should be consistent among files, we subset from a constant
       * array.
       */

      double[] latja = Arrays.copyOfRange(yloc.getJavaArray(), istart, istart + idim);
      double[] lonja = Arrays.copyOfRange(xloc.getJavaArray(), jstart, jstart + jdim);
      double[] zja = Arrays.copyOfRange(zloc.getJavaArray(), kstart, kstart + kdim);

      // Obtain the interpolated values

      TricubicSplineInterpolator tci = new TricubicSplineInterpolator();
      TricubicSplineInterpolatingFunction tsf = tci.interpolate(zja, latja, lonja, autmp);

      // u = tcs.interpolate(z, lat, lon);
      u = tsf.value(z, lat, lon);
      // tcs.setValues(avtmp);
      // v = tcs.interpolate(z, lat, lon);
      tsf = tci.interpolate(zja, latja, lonja, avtmp);
      v = tsf.value(z, lat, lon);

      if (zloc.isIn_Bounds() >= 0) {
        // tcs.setValues(awtmp);
        // w = tcs.interpolate(z, lat, lon);
        tsf = tci.interpolate(zja, latja, lonja, awtmp);
        w = tsf.value(z, lat, lon);
      } else {
        w = 0;
      }

      // If there is something strange with the values, return NODATA.

      if (Math.abs(u) > cutoff) {
        u = 0.0f;
        v = 0.0f;
        w = 0.0f;
        this.notifyAll();
        velocities = NODATA;
        averages = NODATA;
        variances = NODATA;
        return NODATA;
      } else if (Math.abs(v) > cutoff) {
        u = 0.0f;
        v = 0.0f;
        w = 0.0f;
        this.notifyAll();
        velocities = NODATA;
        averages = NODATA;
        variances = NODATA;
        return NODATA;
      } else if (Math.abs(w) > cutoff) {
        u = 0.0f;
        v = 0.0f;
        w = 0.0f;
        this.notifyAll();
        velocities = NODATA;
        averages = NODATA;
        variances = NODATA;
        return NODATA;
      }

      if (Double.isNaN(u) || Double.isNaN(v) || Double.isNaN(w)) {
        u = 0.0f;
        v = 0.0f;
        w = 0.0f;
        this.notifyAll();
        velocities = NODATA;
        averages = NODATA;
        variances = NODATA;
        return NODATA;
      }

      // Otherwise return the interpolated values.

      this.notifyAll();
      velocities = new double[] {u, v, w};
      averages = new double[] {uavg, vavg, wavg};

      // Correct running population variance to be sample variance.
      double ucorr = (double) uct / (double) (uct - 1);
      double vcorr = (double) vct / (double) (vct - 1);
      double wcorr = (double) wct / (double) (wct - 1);
      variances = new double[] {uvar * ucorr, vvar * vcorr, wvar * wcorr};

      return velocities;

      // If for some reason there was an error reading from the file,
      // return null.

    } catch (IOException e) {
      System.out.println("WARNING:  Error reading from velocity files.\n\n");
      e.printStackTrace();
    }
    this.notifyAll();
    return null;
  }
コード例 #2
0
  public void initialize(String dir) throws IOException {
    // Set Time Zone to UTC
    formatUTC.setTimeZone(TimeZone.getTimeZone("UTC"));

    this.dir = dir;
    File f = new File(dir);

    // Ensure the path is a directory
    if (!f.isDirectory()) {
      throw new IllegalArgumentException(f.getName() + " is not a directory.");
    }

    // Filter the list of files

    File[] fa = f.listFiles(new FilenamePatternFilter(".*_[uvw].*\\.nc"));

    if (fa == null) {
      throw new IOException("File list is empty.");
    }

    for (File fil : fa) {

      String name = fil.getName();

      NetcdfFile ncf = NetcdfFile.open(fil.getPath());
      tVar = ncf.findVariable(tName);

      if (tVar == null) {
        System.out.println(
            "WARNING: Time variable "
                + tVar
                + " was not found in "
                + fil.getPath()
                + " when initializing the VelocityReader.  This file will be skipped.");
        continue;
      }

      Array arr = tVar.read();

      // Convert into a java array

      double[] ja = (double[]) arr.copyTo1DJavaArray();

      // Determine the minimum and maximum times

      long[] minmax = new long[2];

      minmax[0] = TimeConvert.HYCOMToMillis((long) ja[0]);
      minmax[1] = TimeConvert.HYCOMToMillis((long) ja[ja.length - 1]);

      // Put into an index linking start time with the associated file

      if (name.lastIndexOf("_u") > 0) {
        if (uFiles.containsKey(minmax[0])) {
          System.out.print(
              "WARNING:  Velocity files have duplicate time keys. "
                  + name
                  + "/"
                  + uFiles.get(minmax[0])
                  + " at "
                  + new Date(minmax[0]));
          System.out.println(" Skipping latter file.");
        } else {
          uFiles.put(minmax[0], ncf);
        }
      }

      if (name.lastIndexOf("_v") > 0) {
        if (vFiles.containsKey(minmax[0])) {
          System.out.print(
              "WARNING:  Velocity files have duplicate time keys. "
                  + name
                  + "/"
                  + vFiles.get(minmax[0])
                  + " at "
                  + new Date(minmax[0]));
          System.out.println(" Skipping latter file.");
        } else {
          vFiles.put(minmax[0], ncf);
        }
      }

      if (name.lastIndexOf("_w") > 0) {
        if (wFiles.containsKey(minmax[0])) {
          System.out.print(
              "WARNING:  Velocity files have duplicate time keys. "
                  + name
                  + "/"
                  + wFiles.get(minmax[0])
                  + " at "
                  + new Date(minmax[0]));
          System.out.println(" Skipping latter file.");
        } else {
          wFiles.put(minmax[0], ncf);
        }
      }
    }

    // If there are no files in one of the index collections, then exit.

    if (uFiles.size() == 0 || vFiles.size() == 0 || wFiles.size() == 0) {
      System.out.println(
          "Velocity directory is empty, or files/variables are not named properly."
              + "Files  must be named as *_u*, *_v*, and *_w*.");

      System.exit(0);
    }

    uKeys = new ArrayList<Long>(uFiles.keySet());
    vKeys = new ArrayList<Long>(vFiles.keySet());
    wKeys = new ArrayList<Long>(wFiles.keySet());

    // Populate uFile, vFile and wFile with the first entry so that they
    // are not null

    uFile = uFiles.get(uKeys.get(0));
    vFile = vFiles.get(vKeys.get(0));
    wFile = wFiles.get(wKeys.get(0));

    uVar = uFile.findVariable(uName);
    vVar = vFile.findVariable(vName);
    wVar = wFile.findVariable(wName);

    // Latitude and depth are read here because they should not change
    // and therefore can be input once only.

    latVar = uFile.findVariable(latName);
    lonVar = uFile.findVariable(lonName);
    zVar = uFile.findVariable(zName);

    setXLookup(lonName);
    setYLookup(latName);
    setZLookup(zName);

    if (positiveDown) {
      zloc.setNegate(true);
    }
    bounds[0][0] = uKeys.get(0);
    NetcdfFile lastfile = uFiles.get(uKeys.get(uKeys.size() - 1));
    Variable t = lastfile.findVariable(tName);
    double last;
    try {
      last = t.read(new int[] {t.getShape(0) - 1}, new int[] {1}).getDouble(0);
      bounds[0][1] = TimeConvert.HYCOMToMillis((long) last);
    } catch (InvalidRangeException e) {
      e.printStackTrace();
    }
  }