/**
* Get a 1DArray for the type and length
*
* @param type DataType
* @param len length
* @return the array
*/
private Array get1DArray(DataType type, int len) {
Array varArray = null;
if (type.equals(DataType.FLOAT)) {
varArray = new ArrayFloat.D1(len);
} else if (type.equals(DataType.DOUBLE)) {
varArray = new ArrayDouble.D1(len);
} else if (type.equals(DataType.INT)) {
varArray = new ArrayInt.D1(len);
}
return varArray;
}
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 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);
}
}
public double convertScaleOffsetMissing(int vali) {
if (!hasScaleOffset) return useNaNs && isMissing((double) vali) ? Double.NaN : (double) vali;
double convertedValue;
if (isUnsigned) convertedValue = scale * DataType.unsignedIntToLong(vali) + offset;
else convertedValue = scale * vali + offset;
return useNaNs && isMissing(convertedValue) ? Double.NaN : convertedValue;
}
public double convertScaleOffsetMissing(short vals) {
if (!hasScaleOffset) return useNaNs && isMissing((double) vals) ? Double.NaN : (double) vals;
double convertedValue;
if (isUnsigned) convertedValue = scale * DataType.unsignedShortToInt(vals) + offset;
else convertedValue = scale * vals + offset;
return useNaNs && isMissing(convertedValue) ? Double.NaN : convertedValue;
}
public double convertScaleOffsetMissing(byte valb) {
if (!hasScaleOffset) return useNaNs && isMissing((double) valb) ? Double.NaN : (double) valb;
double convertedValue;
if (isUnsigned) convertedValue = scale * DataType.unsignedByteToShort(valb) + offset;
else convertedValue = scale * valb + offset;
return useNaNs && isMissing(convertedValue) ? Double.NaN : convertedValue;
}
/**
* Convert Data with scale and offset. Also translate missing data to NaNs if useNaNs = true.
*
* @param in data to convert
* @return converted data.
*/
private Array convertScaleOffset(Array in) {
if (!hasScaleOffset) return in;
if (debugRead) System.out.println("convertScaleOffset ");
Array out = Array.factory(convertedDataType.getPrimitiveClassType(), in.getShape());
IndexIterator iterIn = in.getIndexIterator();
IndexIterator iterOut = out.getIndexIterator();
if (isUnsigned && in.getElementType() == byte.class)
convertScaleOffsetUnsignedByte(iterIn, iterOut);
else if (isUnsigned && in.getElementType() == short.class)
convertScaleOffsetUnsignedShort(iterIn, iterOut);
else if (isUnsigned && in.getElementType() == int.class)
convertScaleOffsetUnsignedInt(iterIn, iterOut);
else {
boolean checkMissing = useNaNs && hasMissing();
while (iterIn.hasNext()) {
double val = scale * iterIn.getDoubleNext() + offset;
iterOut.setDoubleNext(checkMissing && isMissing_(val) ? Double.NaN : val);
}
}
return out;
}
/**
* Make a station variable
*
* @param varname variable name
* @param firstDim station dimension
* @return corresponding variable
*/
protected Variable makeStationVariable(String varname, Dimension firstDim) {
String longName = varname;
String unit = null;
DataType type = DataType.CHAR;
List<Dimension> dims = new ArrayList<Dimension>();
List<Attribute> attrs = new ArrayList<Attribute>();
if (firstDim != null) {
dims.add(firstDim);
}
if (varname.equals(GempakStation.STID)) {
longName = "Station identifier";
dims.add(DIM_LEN8);
} else if (varname.equals(GempakStation.STNM)) {
longName = "WMO station id";
type = DataType.INT;
} else if (varname.equals(GempakStation.SLAT)) {
longName = "latitude";
unit = "degrees_north";
type = DataType.FLOAT;
attrs.add(new Attribute("standard_name", "latitude"));
} else if (varname.equals(GempakStation.SLON)) {
longName = "longitude";
unit = "degrees_east";
type = DataType.FLOAT;
attrs.add(new Attribute("standard_name", "longitude"));
} else if (varname.equals(GempakStation.SELV)) {
longName = "altitude";
unit = "meter";
type = DataType.FLOAT;
attrs.add(new Attribute(CF.POSITIVE, CF.POSITIVE_UP));
attrs.add(new Attribute("standard_name", "station_altitude"));
} else if (varname.equals(GempakStation.STAT)) {
longName = "state or province";
dims.add(DIM_LEN2);
} else if (varname.equals(GempakStation.COUN)) {
longName = "country code";
dims.add(DIM_LEN2);
} else if (varname.equals(GempakStation.STD2)) {
longName = "Extended station id";
dims.add(DIM_LEN4);
} else if (varname.equals(GempakStation.SPRI)) {
longName = "Station priority";
type = DataType.INT;
} else if (varname.equals(GempakStation.SWFO)) {
longName = "WFO code";
dims.add(DIM_LEN4);
} else if (varname.equals(GempakStation.WFO2)) {
longName = "Second WFO code";
dims.add(DIM_LEN4);
}
Variable v = new Variable(ncfile, null, null, varname);
v.setDataType(type);
v.addAttribute(new Attribute("long_name", longName));
if (unit != null) {
v.addAttribute(new Attribute(CDM.UNITS, unit));
}
if (type.equals(DataType.FLOAT)) {
v.addAttribute(new Attribute("missing_value", RMISS));
} else if (type.equals(DataType.INT)) {
v.addAttribute(new Attribute("missing_value", IMISS));
}
if (!attrs.isEmpty()) {
for (Attribute attr : attrs) {
v.addAttribute(attr);
}
}
if (!dims.isEmpty()) {
v.setDimensions(dims);
} else {
v.setDimensions((String) null);
}
return v;
}
private boolean compareData(String name, Array data1, Array data2, double tol, boolean justOne) {
boolean ok = true;
if (data1.getSize() != data2.getSize()) {
f.format(" DIFF %s: size %d !== %d%n", name, data1.getSize(), data2.getSize());
ok = false;
}
if (data1.getElementType() != data2.getElementType()) {
f.format(
" DIFF %s: element type %s !== %s%n",
name, data1.getElementType(), data2.getElementType());
ok = false;
}
if (!ok) return false;
DataType dt = DataType.getType(data1.getElementType());
IndexIterator iter1 = data1.getIndexIterator();
IndexIterator iter2 = data2.getIndexIterator();
if (dt == DataType.DOUBLE) {
while (iter1.hasNext() && iter2.hasNext()) {
double v1 = iter1.getDoubleNext();
double v2 = iter2.getDoubleNext();
if (!Double.isNaN(v1) || !Double.isNaN(v2))
if (!closeEnough(v1, v2, tol)) {
f.format(
" DIFF %s: %f != %f count=%s diff = %f pdiff = %f %n",
name, v1, v2, iter1, diff(v1, v2), pdiff(v1, v2));
ok = false;
if (justOne) break;
}
}
} else if (dt == DataType.FLOAT) {
while (iter1.hasNext() && iter2.hasNext()) {
float v1 = iter1.getFloatNext();
float v2 = iter2.getFloatNext();
if (!Float.isNaN(v1) || !Float.isNaN(v2))
if (!closeEnough(v1, v2, (float) tol)) {
f.format(
" DIFF %s: %f != %f count=%s diff = %f pdiff = %f %n",
name, v1, v2, iter1, diff(v1, v2), pdiff(v1, v2));
ok = false;
if (justOne) break;
}
}
} else if (dt == DataType.INT) {
while (iter1.hasNext() && iter2.hasNext()) {
int v1 = iter1.getIntNext();
int v2 = iter2.getIntNext();
if (v1 != v2) {
f.format(
" DIFF %s: %d != %d count=%s diff = %f pdiff = %f %n",
name, v1, v2, iter1, diff(v1, v2), pdiff(v1, v2));
ok = false;
if (justOne) break;
}
}
} else if (dt == DataType.SHORT) {
while (iter1.hasNext() && iter2.hasNext()) {
short v1 = iter1.getShortNext();
short v2 = iter2.getShortNext();
if (v1 != v2) {
f.format(
" DIFF %s: %d != %d count=%s diff = %f pdiff = %f %n",
name, v1, v2, iter1, diff(v1, v2), pdiff(v1, v2));
ok = false;
if (justOne) break;
}
}
} else if (dt == DataType.BYTE) {
while (iter1.hasNext() && iter2.hasNext()) {
byte v1 = iter1.getByteNext();
byte v2 = iter2.getByteNext();
if (v1 != v2) {
f.format(
" DIFF %s: %d != %d count=%s diff = %f pdiff = %f %n",
name, v1, v2, iter1, diff(v1, v2), pdiff(v1, v2));
ok = false;
if (justOne) break;
}
}
} else if (dt == DataType.STRUCTURE) {
while (iter1.hasNext() && iter2.hasNext()) {
compareStructureData(
(StructureData) iter1.next(), (StructureData) iter2.next(), tol, justOne);
}
}
return ok;
}