private void showValuesAsDates(CoordinateAxis axis) {
String units = axis.getUnitsString();
String cal = getCalendarAttribute(axis);
CalendarDateUnit cdu = CalendarDateUnit.of(cal, units);
try {
infoTA.appendLine(units);
infoTA.appendLine(NCdumpW.printVariableData(axis, null));
if (axis.getDataType().isNumeric()) {
if (axis instanceof CoordinateAxis2D) {
showDates2D((CoordinateAxis2D) axis, cdu);
} else if (axis instanceof CoordinateAxis1D) { // 1D
showDates1D((CoordinateAxis1D) axis, cdu);
} else { // > 2D
Array data = axis.read();
IndexIterator ii = data.getIndexIterator();
while (ii.hasNext()) {
double val = ii.getDoubleNext();
infoTA.appendLine(makeCalendarDateStringOrMissing(cdu, val));
}
}
} else { // must be iso dates
Array data = axis.read();
Formatter f = new Formatter();
if (data instanceof ArrayChar) {
ArrayChar dataS = (ArrayChar) data;
ArrayChar.StringIterator iter = dataS.getStringIterator();
while (iter.hasNext()) f.format(" %s%n", iter.next());
infoTA.appendLine(f.toString());
} else if (data instanceof ArrayObject) {
IndexIterator iter = data.getIndexIterator();
while (iter.hasNext()) f.format(" %s%n", iter.next());
infoTA.appendLine(f.toString());
}
}
} catch (Exception ex) {
ex.printStackTrace();
infoTA.appendLine(ex.getMessage());
}
}
private void showValueDiffs(CoordinateAxis axis) {
if (!axis.isNumeric()) return;
try {
if (axis instanceof CoordinateAxis1D) {
CoordinateAxis1D axis1D = (CoordinateAxis1D) axis;
double[] mids = axis1D.getCoordValues();
double[] diffs = new double[mids.length];
for (int i = 0; i < mids.length - 1; i++) diffs[i] = mids[i + 1] - mids[i];
printArrays("midpoint differences", mids, diffs);
} else if (axis instanceof CoordinateAxis2D) {
CoordinateAxis2D axis2D = (CoordinateAxis2D) axis;
ArrayDouble.D2 mids = axis2D.getCoordValuesArray();
int[] shape = mids.getShape();
ArrayDouble.D2 diffx =
(ArrayDouble.D2) Array.factory(DataType.DOUBLE, new int[] {shape[0], shape[1] - 1});
for (int j = 0; j < shape[0]; j++) {
for (int i = 0; i < shape[1] - 1; i++) {
double diff = mids.get(j, i + 1) - mids.get(j, i);
diffx.set(j, i, diff);
}
}
infoTA.appendLine(NCdumpW.toString(diffx, "diff in x", null));
ArrayDouble.D2 diffy =
(ArrayDouble.D2) Array.factory(DataType.DOUBLE, new int[] {shape[0] - 1, shape[1]});
for (int j = 0; j < shape[0] - 1; j++) {
for (int i = 0; i < shape[1]; i++) {
double diff = mids.get(j + 1, i) - mids.get(j, i);
diffy.set(j, i, diff);
}
}
infoTA.appendLine("\n\n\n");
infoTA.appendLine(NCdumpW.toString(diffy, "diff in y", null));
}
} catch (Exception e1) {
e1.printStackTrace();
infoTA.appendLine(e1.getMessage());
}
}
/**
* This reads an arbitrary data slice, returning the data in canonical order (rt-e-t-z-y-x). If
* any dimension does not exist, ignore it.
*
* @param rt if < 0, get all of runtime dim; if valid index, fix slice to that value.
* @param e if < 0, get all of ensemble dim; if valid index, fix slice to that value.
* @param t if < 0, get all of time dim; if valid index, fix slice to that value.
* @param z if < 0, get all of z dim; if valid index, fix slice to that value.
* @param y if < 0, get all of y dim; if valid index, fix slice to that value.
* @param x if < 0, get all of x dim; if valid index, fix slice to that value.
* @return data[rt,e,t,z,y,x], eliminating missing or fixed dimension.
*/
public Array readDataSlice(int rt, int e, int t, int z, int y, int x) throws java.io.IOException {
int rank = vs.getRank();
int[] start = new int[rank];
int[] shape = new int[rank];
for (int i = 0; i < rank; i++) {
start[i] = 0;
shape[i] = 1;
}
Dimension xdim = getXDimension();
Dimension ydim = getYDimension();
Dimension zdim = getZDimension();
Dimension tdim = getTimeDimension();
Dimension edim = getEnsembleDimension();
Dimension rtdim = getRunTimeDimension();
// construct the shape of the data volume to be read
if (rtdim != null) {
if ((rt >= 0) && (rt < rtdim.getLength())) start[rtDimOrgIndex] = rt; // fix rt
else {
shape[rtDimOrgIndex] = rtdim.getLength(); // all of rt
}
}
if (edim != null) {
if ((e >= 0) && (e < edim.getLength())) start[eDimOrgIndex] = e; // fix e
else {
shape[eDimOrgIndex] = edim.getLength(); // all of e
}
}
if (tdim != null) {
if ((t >= 0) && (t < tdim.getLength())) start[tDimOrgIndex] = t; // fix t
else {
shape[tDimOrgIndex] = tdim.getLength(); // all of t
}
}
if (zdim != null) {
if ((z >= 0) && (z < zdim.getLength())) start[zDimOrgIndex] = z; // fix z
else {
shape[zDimOrgIndex] = zdim.getLength(); // all of z
}
}
if (ydim != null) {
if ((y >= 0) && (y < ydim.getLength())) start[yDimOrgIndex] = y; // fix y
else {
shape[yDimOrgIndex] = ydim.getLength(); // all of y
}
}
if (xdim != null) {
if ((x >= 0) && (x < xdim.getLength())) // all of x
start[xDimOrgIndex] = x; // fix x
else {
shape[xDimOrgIndex] = xdim.getLength(); // all of x
}
}
if (debugArrayShape) {
System.out.println("read shape from org variable = ");
for (int i = 0; i < rank; i++)
System.out.println(
" start = "
+ start[i]
+ " shape = "
+ shape[i]
+ " name = "
+ vs.getDimension(i).getName());
}
// read it
Array dataVolume;
try {
dataVolume = vs.read(start, shape);
} catch (Exception ex) {
log.error(
"GeoGrid.getdataSlice() on dataset " + getFullName() + " " + dataset.getLocation(), ex);
throw new java.io.IOException(ex.getMessage());
}
// LOOK: the real problem is the lack of named dimensions in the Array object
// figure out correct permutation for canonical ordering for permute
List<Dimension> oldDims = new ArrayList<Dimension>(vs.getDimensions());
int[] permuteIndex = new int[dataVolume.getRank()];
int count = 0;
if (oldDims.contains(rtdim)) permuteIndex[count++] = oldDims.indexOf(rtdim);
if (oldDims.contains(edim)) permuteIndex[count++] = oldDims.indexOf(edim);
if (oldDims.contains(tdim)) permuteIndex[count++] = oldDims.indexOf(tdim);
if (oldDims.contains(zdim)) permuteIndex[count++] = oldDims.indexOf(zdim);
if (oldDims.contains(ydim)) permuteIndex[count++] = oldDims.indexOf(ydim);
if (oldDims.contains(xdim)) permuteIndex[count] = oldDims.indexOf(xdim);
if (debugArrayShape) {
System.out.println("oldDims = ");
for (Dimension oldDim : oldDims) System.out.println(" oldDim = " + oldDim.getName());
System.out.println("permute dims = ");
for (int aPermuteIndex : permuteIndex)
System.out.println(" oldDim index = " + aPermuteIndex);
}
// check to see if we need to permute
boolean needPermute = false;
for (int i = 0; i < permuteIndex.length; i++) {
if (i != permuteIndex[i]) needPermute = true;
}
// permute to the order rt,e,t,z,y,x
if (needPermute) dataVolume = dataVolume.permute(permuteIndex);
// eliminate fixed dimensions, but not all dimensions of length 1.
count = 0;
if (rtdim != null) {
if (rt >= 0) dataVolume = dataVolume.reduce(count);
else count++;
}
if (edim != null) {
if (e >= 0) dataVolume = dataVolume.reduce(count);
else count++;
}
if (tdim != null) {
if (t >= 0) dataVolume = dataVolume.reduce(count);
else count++;
}
if (zdim != null) {
if (z >= 0) dataVolume = dataVolume.reduce(count);
else count++;
}
if (ydim != null) {
if (y >= 0) dataVolume = dataVolume.reduce(count);
else count++;
}
if (xdim != null) {
if (x >= 0) dataVolume = dataVolume.reduce(count);
}
return dataVolume;
}