// @todo Make sure units are meters
 public Array getElevation(Range range) throws IOException, InvalidRangeException {
   List section = new ArrayList(1);
   section.add(range);
   Array a = elevVar.read(section);
   if (elevVarUnitsConversionFactor == 1.0) return (a);
   for (IndexIterator it = a.getIndexIterator(); it.hasNext(); ) {
     if (elevVar.getDataType() == DataType.DOUBLE) {
       double val = it.getDoubleNext();
       it.setDoubleCurrent(val * elevVarUnitsConversionFactor);
     } else if (elevVar.getDataType() == DataType.FLOAT) {
       float val = it.getFloatNext();
       it.setFloatCurrent((float) (val * elevVarUnitsConversionFactor));
     } else if (elevVar.getDataType() == DataType.INT) {
       int val = it.getIntNext();
       it.setIntCurrent((int) (val * elevVarUnitsConversionFactor));
     } else if (elevVar.getDataType() == DataType.LONG) {
       long val = it.getLongNext();
       it.setLongCurrent((long) (val * elevVarUnitsConversionFactor));
     } else {
       throw new IllegalStateException(
           "Elevation variable type <"
               + elevVar.getDataType().toString()
               + "> not double, float, int, or long.");
     }
   }
   return (a);
 }
Example #2
0
  public void testEnhanceDefer() throws IOException {
    NetcdfDataset ncd =
        NetcdfDataset.openDataset(
            filename, EnumSet.of(NetcdfDataset.Enhance.ScaleMissing), -1, null, null);
    VariableDS enhancedVar = (VariableDS) ncd.findVariable("t1");

    NetcdfDataset ncdefer =
        NetcdfDataset.openDataset(
            filename, EnumSet.of(NetcdfDataset.Enhance.ScaleMissingDefer), -1, null, null);
    VariableDS deferVar = (VariableDS) ncdefer.findVariable("t1");

    Array data = enhancedVar.read();
    Array dataDefer = deferVar.read();

    System.out.printf("Enhanced=");
    NCdumpW.printArray(data);
    System.out.printf("%nDeferred=");
    NCdumpW.printArray(dataDefer);
    System.out.printf("%nProcessed=");

    CompareNetcdf2 nc = new CompareNetcdf2(new Formatter(System.out), false, false, true);
    assert !nc.compareData(enhancedVar.getShortName(), data, dataDefer, false);

    IndexIterator ii = dataDefer.getIndexIterator();
    while (ii.hasNext()) {
      double val = deferVar.convertScaleOffsetMissing(ii.getDoubleNext());
      ii.setDoubleCurrent(val);
    }
    NCdumpW.printArray(dataDefer);

    assert nc.compareData(enhancedVar.getShortName(), data, dataDefer, false);

    ncd.close();
    ncdefer.close();
  }
  /**
   * Cast a dataset to this compound type. If repeat is set, the first element of each item in the
   * given dataset is repeated across all elements of an item. Otherwise, each item comprises a
   * truncated or zero-padded copy of elements from the given dataset.
   *
   * @param itemSize
   * @param repeat repeat first element
   * @param dataset
   */
  public CompoundIntegerDataset(
      final int itemSize, final boolean repeat, final AbstractDataset dataset) {
    isize = itemSize;
    size = dataset.size;
    shape = dataset.shape.clone();
    name = new String(dataset.name);

    odata = data = createArray(size);
    final int os = dataset.getElementsPerItem();

    IndexIterator iter = dataset.getIterator();
    if (repeat) {
      int i = 0;
      while (iter.hasNext()) {
        final int v =
            (int) dataset.getElementLongAbs(iter.index); // PRIM_TYPE // GET_ELEMENT_WITH_CAST
        for (int k = 0; k < isize; k++) data[i++] = v;
      }
    } else {
      final int kmax = Math.min(isize, os);
      int i = 0;
      while (iter.hasNext()) {
        for (int k = 0; k < kmax; k++)
          data[i + k] = (int) dataset.getElementLongAbs(iter.index + k); // GET_ELEMENT_WITH_CAST
        i += isize;
      }
    }
  }
  @Override
  public StringDatasetBase setByBoolean(final Object obj, Dataset selection) {
    if (obj instanceof Dataset) {
      final Dataset ds = (Dataset) obj;
      final int length = ((Number) selection.sum()).intValue();
      if (length != ds.getSize()) {
        throw new IllegalArgumentException(
            "Number of true items in selection does not match number of items in dataset");
      }

      final IndexIterator oiter = ds.getIterator();
      final BooleanIterator biter = getBooleanIterator(selection);

      while (biter.hasNext() && oiter.hasNext()) {
        data[biter.index] = ds.getStringAbs(oiter.index); // GET_ELEMENT_WITH_CAST
      }
    } else {
      final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT
      final BooleanIterator biter = getBooleanIterator(selection);

      while (biter.hasNext()) {
        data[biter.index] = dv;
      }
    }
    setDirty();
    return this;
  }
  @Override
  public StringDatasetBase setBy1DIndex(final Object obj, final Dataset index) {
    if (obj instanceof Dataset) {
      final Dataset ds = (Dataset) obj;
      if (index.getSize() != ds.getSize()) {
        throw new IllegalArgumentException(
            "Number of items in index dataset does not match number of items in dataset");
      }

      final IndexIterator oiter = ds.getIterator();
      final IntegerIterator iter = new IntegerIterator(index, size);

      while (iter.hasNext() && oiter.hasNext()) {
        data[iter.index] = ds.getStringAbs(oiter.index); // GET_ELEMENT_WITH_CAST
      }
    } else {
      final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT
      IntegerIterator iter = new IntegerIterator(index, size);

      while (iter.hasNext()) {
        data[iter.index] = dv;
      }
    }
    setDirty();
    return this;
  }
  @Override
  public StringDatasetBase setByIndexes(final Object obj, final Object... indexes) {
    final IntegersIterator iter = new IntegersIterator(shape, indexes);
    final int[] pos = iter.getPos();

    if (obj instanceof Dataset) {
      final Dataset ds = (Dataset) obj;
      if (calcSize(iter.getShape()) != ds.getSize()) {
        throw new IllegalArgumentException(
            "Number of items in index datasets does not match number of items in dataset");
      }

      final IndexIterator oiter = ds.getIterator();

      while (iter.hasNext() && oiter.hasNext()) {
        setItem(ds.getStringAbs(oiter.index), pos); // GET_ELEMENT_WITH_CAST
      }
    } else {
      final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT

      while (iter.hasNext()) {
        setItem(dv, pos);
      }
    }
    setDirty();
    return this;
  }
Example #7
0
  public void testAggCoordVar2(NetcdfFile ncfile) {

    Variable time = ncfile.findVariable("time");
    assert null != time;
    assert time.getShortName().equals("time");
    assert time.getRank() == 1 : time.getRank();
    assert time.getShape()[0] == 3;
    assert time.getDataType() == DataType.INT;

    assert time.getDimension(0) == ncfile.findDimension("time");

    try {
      Array data = time.read();

      assert (data instanceof ArrayInt);
      IndexIterator dataI = data.getIndexIterator();
      assert dataI.getIntNext() == 0 : dataI.getIntCurrent();
      assert dataI.getIntNext() == 1 : dataI.getIntCurrent();
      assert dataI.getIntNext() == 2 : dataI.getIntCurrent();

    } catch (IOException io) {
      io.printStackTrace();
      assert false;
    }
  }
  @Override
  public void setElements(AbstractDataset source, int element) {
    if (element < 0) element += isize;
    if (element < 0 || element > isize) {
      throw new IllegalArgumentException(
          String.format("Invalid choice of element: %d/%d", element, isize));
    }
    if (elementClass() != source.elementClass()) {
      throw new IllegalArgumentException(
          "Element class of destination does not match this dataset");
    }

    final IndexIterator it = getIterator(element);
    final int[] elements = ((IntegerDataset) source).data; // CLASS_TYPE // PRIM_TYPE

    if (source.isContiguous()) {
      int n = 0;
      while (it.hasNext()) {
        data[it.index] = elements[n];
        n++;
      }
    } else {
      final IndexIterator sit = source.getIterator();
      while (it.hasNext() && sit.hasNext()) {
        data[it.index] = elements[sit.index];
      }
    }
  }
  @Override
  public void fillDataset(Dataset result, IndexIterator iter) {
    IndexIterator riter = result.getIterator();

    String[] rdata = ((StringDatasetBase) result).data; // PRIM_TYPE

    while (riter.hasNext() && iter.hasNext()) rdata[riter.index] = data[iter.index];
  }
 private void convertScaleOffsetUnsignedInt(IndexIterator iterIn, IndexIterator iterOut) {
   boolean checkMissing = useNaNs && hasMissing();
   while (iterIn.hasNext()) {
     int valb = iterIn.getIntNext();
     double val = scale * DataType.unsignedIntToLong(valb) + offset;
     iterOut.setDoubleNext(checkMissing && isMissing_(val) ? Double.NaN : val);
   }
 }
  // get a list of station obs for this station
  public List getData(Station s, CancelTask cancel) throws IOException {
    ArrayStructure stationData = readData("ID " + s.getName(), cancel);

    ArrayList stationObs = new ArrayList();
    IndexIterator ii = stationData.getIndexIterator();
    while (ii.hasNext()) {
      stationObs.add(new StationObs((Station) s, (StructureData) ii.getObjectNext()));
    }
    return stationObs;
  }
  @Override
  public void fillDataset(AbstractDataset result, IndexIterator iter) {
    IndexIterator riter = result.getIterator();

    int[] rdata = ((CompoundIntegerDataset) result).data; // PRIM_TYPE

    while (riter.hasNext() && iter.hasNext()) {
      for (int i = 0; i < isize; i++) rdata[riter.index + i] = data[iter.index + i];
    }
  }
  /**
   * @param obj
   * @return dataset filled with given object
   */
  @Override
  public CompoundIntegerDataset fill(final Object obj) {
    IndexIterator iter = getIterator();
    int[] vr = toIntegerArray(obj, isize); // PRIM_TYPE // CLASS_TYPE

    while (iter.hasNext()) {
      for (int i = 0; i < isize; i++) data[iter.index + i] = vr[i]; // PRIM_TYPE
    }

    return this;
  }
  @Override
  public StringDatasetBase fill(final Object obj) {
    String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT
    IndexIterator iter = getIterator();
    while (iter.hasNext()) {
      data[iter.index] = dv;
    }

    setDirty();
    return this;
  }
  @Override
  public IntegerDataset real() { // CLASS_TYPE
    IntegerDataset rdataset = new IntegerDataset(shape); // CLASS_TYPE
    IndexIterator iter = getIterator();
    IndexIterator riter = rdataset.getIterator();

    int[] rdata = rdataset.data; // PRIM_TYPE
    while (iter.hasNext() && riter.hasNext()) rdata[riter.index] = data[iter.index];

    return rdataset;
  }
Example #16
0
 private Array convertToChar(Variable newVar, Array oldData) {
   ArrayChar newData = (ArrayChar) Array.factory(DataType.CHAR, newVar.getShape());
   Index ima = newData.getIndex();
   IndexIterator ii = oldData.getIndexIterator();
   while (ii.hasNext()) {
     String s = (String) ii.getObjectNext();
     int[] c = ii.getCurrentCounter();
     for (int i = 0; i < c.length; i++) ima.setDim(i, c[i]);
     newData.setString(ima, s);
   }
   return newData;
 }
  @Override
  public CompoundIntegerDataset getSlice(final SliceIterator siter) {
    CompoundIntegerDataset result = new CompoundIntegerDataset(isize, siter.getSliceShape());
    int[] rdata = result.data; // PRIM_TYPE
    IndexIterator riter = result.getIterator();

    while (siter.hasNext() && riter.hasNext()) {
      for (int i = 0; i < isize; i++) rdata[riter.index + i] = data[siter.index + i];
    }

    result.setName(name + ".slice");
    return result;
  }
  protected Array convertEnums(Array values) {
    DataType dt = DataType.getType(values.getElementType());
    if (!dt.isNumeric()) System.out.println("HEY");

    Array result = Array.factory(DataType.STRING, values.getShape());
    IndexIterator ii = result.getIndexIterator();
    values.resetLocalIterator();
    while (values.hasNext()) {
      String sval = lookupEnumString(values.nextInt());
      ii.setObjectNext(sval);
    }
    return result;
  }
  private List<int[]> findPositions(final String value) { // PRIM_TYPE
    IndexIterator iter = getIterator(true);
    List<int[]> posns = new ArrayList<int[]>();
    int[] pos = iter.getPos();

    {
      while (iter.hasNext()) {
        if (data[iter.index] == value) {
          posns.add(pos.clone());
        }
      }
    }
    return posns;
  }
Example #20
0
  /**
   * Get the minimum and the maximum data value of the previously read Array, skipping missing
   * values as defined by isMissingData(double val).
   *
   * @param a Array to get min/max values
   * @return both min and max value.
   */
  public MAMath.MinMax getMinMaxSkipMissingData(Array a) {
    if (!hasMissingData()) return MAMath.getMinMax(a);

    IndexIterator iter = a.getIndexIterator();
    double max = -Double.MAX_VALUE;
    double min = Double.MAX_VALUE;
    while (iter.hasNext()) {
      double val = iter.getDoubleNext();
      if (isMissingData(val)) continue;
      if (val > max) max = val;
      if (val < min) min = val;
    }
    return new MAMath.MinMax(min, max);
  }
Example #21
0
  // for jon blower
  private Array getEnhancedArray(VariableDS vds) throws IOException {
    Array data = vds.read();
    EnumSet<NetcdfDataset.Enhance> mode = vds.getEnhanceMode();
    if (mode.contains(NetcdfDataset.Enhance.ScaleMissing)) return data;
    if (!mode.contains(NetcdfDataset.Enhance.ScaleMissingDefer))
      throw new IllegalStateException("Must include " + NetcdfDataset.Enhance.ScaleMissingDefer);

    IndexIterator ii = data.getIndexIterator();
    while (ii.hasNext()) {
      double val = vds.convertScaleOffsetMissing(ii.getDoubleNext());
      ii.setDoubleCurrent(val);
    }
    return data;
  }
  private void allocateArray(final int... nshape) {
    if (data == null) {
      throw new IllegalStateException("Data buffer in dataset is null");
    }

    if (dataShape != null) {
      // see if reserved space is sufficient
      if (isShapeInDataShape(nshape)) {
        shape = nshape;
        size = calcSize(shape);
        if (Arrays.equals(shape, dataShape)) {
          dataShape = null; // no reserved space
        }
        return;
      }
    }

    final IndexIterator iter = getIterator();

    // not enough room so need to expand the allocated memory
    if (dataShape == null) dataShape = shape.clone();
    expandDataShape(nshape);
    dataSize = calcSize(dataShape);

    final int[] ndata = createArray(dataSize); // PRIM_TYPE
    final int[] oshape = shape;

    // now this object has the new dimensions so specify them correctly
    shape = nshape;
    size = calcSize(nshape);

    // make sure that all the data is set to NaN, minimum value or false
    Arrays.fill(ndata, Integer.MIN_VALUE); // CLASS_TYPE // DEFAULT_VAL

    // now copy the data back to the correct positions
    final IndexIterator niter = getSliceIterator(null, oshape, null);

    while (niter.hasNext() && iter.hasNext())
      for (int j = 0; j < isize; j++) {
        ndata[niter.index + j] = data[iter.index + j];
      }

    odata = data = ndata;

    // if fully expanded then reset the reserved space dimensions
    if (dataSize == size) {
      dataShape = null;
    }
  }
  @Override
  public void copyItemsFromAxes(final int[] pos, final boolean[] axes, final Dataset dest) {
    String[] ddata = (String[]) dest.getBuffer(); // PRIM_TYPE

    SliceIterator siter = getSliceIteratorFromAxes(pos, axes);
    int[] sshape = squeezeShape(siter.getShape(), false);

    IndexIterator diter = dest.getSliceIterator(null, sshape, null);

    if (ddata.length < calcSize(sshape)) {
      throw new IllegalArgumentException("destination array is not large enough");
    }

    while (siter.hasNext() && diter.hasNext()) ddata[diter.index] = data[siter.index];
  }
  @Override
  public StringDatasetBase getUniqueItems() {
    Set<String> set = new TreeSet<String>(); // CLASS_TYPE
    IndexIterator it = getIterator();
    while (it.hasNext()) {
      set.add(data[it.index]);
    }

    StringDataset u = new StringDataset(set.size()); // CLASS_TYPE
    int i = 0;
    String[] udata = u.getData(); // PRIM_TYPE
    for (String v : set) { // CLASS_TYPE
      udata[i++] = v;
    }
    return u;
  }
 /**
  * Cast a dataset to this class type
  *
  * @param dataset
  */
 public StringDatasetBase(final Dataset dataset) {
   copyToView(dataset, this, true, false);
   offset = 0;
   stride = null;
   base = null;
   try {
     odata = data = createArray(size);
   } catch (Throwable t) {
     logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t);
     throw t;
   }
   IndexIterator iter = dataset.getIterator();
   for (int i = 0; iter.hasNext(); i++) {
     data[i] = dataset.getStringAbs(iter.index); // GET_ELEMENT_WITH_CAST
   }
 }
  @Override
  public CompoundIntegerDataset ipower(final Object b) {
    if (b instanceof AbstractDataset) {
      final AbstractDataset bds = (AbstractDataset) b;
      checkCompatibility(bds);

      final IndexIterator it1 = getIterator();
      final IndexIterator it2 = bds.getIterator();
      final int bis = bds.getElementsPerItem();

      if (bis == 1) {
        while (it1.hasNext() && it2.hasNext()) {
          final int db =
              (int) bds.getElementLongAbs(it2.index); // PRIM_TYPE // GET_ELEMENT_WITH_CAST
          for (int i = 0; i < isize; i++) {
            final double v = Math.pow(data[it1.index + i], db);
            if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST
              data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE
            } else { // INT_ZEROTEST
              data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST
            } // INT_ZEROTEST
          }
        }
      } else if (bis == isize) {
        while (it1.hasNext() && it2.hasNext()) {
          for (int i = 0; i < isize; i++) {
            final double v = Math.pow(data[it1.index + i], bds.getElementDoubleAbs(it2.index + i));
            if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST
              data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE
            } else { // INT_ZEROTEST
              data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST
            } // INT_ZEROTEST
          }
        }
      } else {
        throw new IllegalArgumentException(
            "Argument does not have same number of elements per item or is not a non-compound dataset");
      }
    } else {
      final int[] vr = toIntegerArray(b, isize); // PRIM_TYPE // CLASS_TYPE
      final IndexIterator it1 = getIterator();

      while (it1.hasNext()) {
        for (int i = 0; i < isize; i++) {
          final double v = Math.pow(data[it1.index + i], vr[i]);
          if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST
            data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE
          } else { // INT_ZEROTEST
            data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST
          } // INT_ZEROTEST
        }
      }
    }
    setDirty();
    return this;
  }
  @Override
  public double residual(final Object b) {
    double sum = 0;
    if (b instanceof AbstractDataset) {
      final AbstractDataset bds = (AbstractDataset) b;
      checkCompatibility(bds);

      final IndexIterator it1 = getIterator();
      final IndexIterator it2 = bds.getIterator();
      final int bis = bds.getElementsPerItem();

      if (bis == 1) {
        double comp = 0;
        while (it1.hasNext() && it2.hasNext()) {
          final double db = bds.getElementDoubleAbs(it2.index);
          for (int i = 0; i < isize; i++) {
            final double diff = data[it1.index + i] - db;
            final double err = diff * diff - comp;
            final double temp = sum + err;
            comp = (temp - sum) - err;
            sum = temp;
          }
        }
      } else if (bis == isize) {
        double comp = 0;
        while (it1.hasNext() && it2.hasNext()) {
          for (int i = 0; i < isize; i++) {
            final double diff = data[it1.index + i] - bds.getElementDoubleAbs(it2.index + i);
            final double err = diff * diff - comp;
            final double temp = sum + err;
            comp = (temp - sum) - err;
            sum = temp;
          }
        }
      } else {
        throw new IllegalArgumentException(
            "Argument does not have same number of elements per item or is not a non-compound dataset");
      }
    } else {
      final double[] vr = toDoubleArray(b, isize);
      final IndexIterator it1 = getIterator();

      double comp = 0;
      while (it1.hasNext()) {
        for (int i = 0; i < isize; i++) {
          final double diff = data[it1.index + i] - vr[i];
          final double err = diff * diff - comp;
          final double temp = sum + err;
          comp = (temp - sum) - err;
          sum = temp;
        }
      }
    }
    return sum;
  }
  @Override
  public boolean equals(Object obj) {
    if (!super.equals(obj)) {
      return false;
    }

    if (getRank() == 0) // already true for scalar dataset
    return true;

    CompoundIntegerDataset other = (CompoundIntegerDataset) obj;
    IndexIterator it = getIterator();
    while (it.hasNext()) {
      for (int j = 0; j < isize; j++) {
        if (data[it.index + j] != other.data[it.index + j]) return false;
      }
    }
    return true;
  }
  @Override
  public boolean equals(Object obj) {
    if (!super.equals(obj)) {
      return false;
    }

    if (getRank() == 0) // already true for zero-rank dataset
    return true;

    StringDatasetBase other = (StringDatasetBase) obj;
    IndexIterator iter = getIterator();
    IndexIterator oiter = other.getIterator();
    while (iter.hasNext() && oiter.hasNext()) {
      if (!data[iter.index].equals(other.data[oiter.index])) // OBJECT_UNEQUAL
      return false;
    }
    return true;
  }
 private void readOneRadial(Cinrad2Record r, int datatype, Range gateRange, IndexIterator ii)
     throws IOException {
   if (r == null) {
     for (int i = gateRange.first(); i <= gateRange.last(); i += gateRange.stride())
       ii.setByteNext(Cinrad2Record.MISSING_DATA);
     return;
   }
   r.readData(volScan.raf, datatype, gateRange, ii);
 }