import ucar.ma2.ArrayDouble; //导入依赖的package包/类
private static void addConcatenatedValueArraysToMaps(Map<Variable, Array> variableArraysMap, Map<Variable, Array> timeVariableArraysMap, Variable targetVariable, Variable timeVariableTarget, boolean concatenateTimeVariable, int targetLocationDimensionLength, double[][] targetValues, double[][] addedValues, double[] timesTarget, double[] convertedTimesToBeAdded, int totalTimesCombined, boolean firstAddedTimeOverlapping) {
	if (firstAddedTimeOverlapping) totalTimesCombined--;
	ArrayDouble.D1 timeArrayDouble = new ArrayDouble.D1(totalTimesCombined);
	ArrayDouble.D2 valueArrayDouble = new ArrayDouble.D2(totalTimesCombined, targetLocationDimensionLength);

	int targetTimes = firstAddedTimeOverlapping ? timesTarget.length - 1 : timesTarget.length;
	for (int i = 0; i < targetTimes; i++) {
		if (concatenateTimeVariable) timeArrayDouble.set(i, timesTarget[i]);
		for (int j = 0; j < targetLocationDimensionLength; j++) {
			valueArrayDouble.set(i, j, targetValues[i][j]);
		}
	}
	for (int i = 0; i < convertedTimesToBeAdded.length; i++) {
		if (concatenateTimeVariable) timeArrayDouble.set(i + targetTimes, convertedTimesToBeAdded[i]);
		for (int j = 0; j < targetLocationDimensionLength; j++) {
			valueArrayDouble.set(i + targetTimes, j, addedValues[i][j]);
		}
	}
	if (concatenateTimeVariable) timeVariableArraysMap.put(timeVariableTarget, timeArrayDouble);
	variableArraysMap.put(targetVariable, valueArrayDouble);
}
 

import ucar.ma2.ArrayDouble; //导入依赖的package包/类
public void writeEmpty (String netcdfFilename) throws Exception {
    ArrayList<Dimension> dimList = new ArrayList<Dimension>();
    IntermediateNetcdfFile nfile;
    try {
        nfile = new IntermediateNetcdfFile(netcdfFilename, false);
    } catch (LASException e) {
        throw new Exception("Cannot create empty file.");
    }
    NetcdfFileWriteable netcdfFile = nfile.getNetcdfFile();
    Dimension index = netcdfFile.addDimension("index", 1);
    dimList.add(index);
    netcdfFile.addVariable(time, DataType.DOUBLE, dimList);
    ArrayDouble.D1 data = new ArrayDouble.D1(1);
    Double d = new Double("-9999.");
    data.set(0, d);
    netcdfFile.addGlobalAttribute("query_result", "No data found to match this request.");
    netcdfFile.create();
    netcdfFile.write(time, data);
}
 

import ucar.ma2.ArrayDouble; //导入依赖的package包/类
/**
 * Puts longitude into the range [center +/- 180] deg. Center correspond to the class attribute
 *
 * @param data data to normalize
 * @param variable the variable
 * @throws MotuNotImplementedException the motu not implemented exception {@link #longitudeCenter}
 */
protected void normalizeLongitudeData(Array data, Variable variable) throws MotuNotImplementedException {
    if (data instanceof ArrayDouble) {
        normalizeLongitudeData((ArrayDouble) data, variable);
    } else if (data instanceof ArrayFloat) {
        normalizeLongitudeData((ArrayFloat) data, variable);
    } else if (data instanceof ArrayShort) {
        normalizeLongitudeData((ArrayShort) data, variable);
    } else if (data instanceof ArrayInt) {
        normalizeLongitudeData((ArrayInt) data, variable);
    } else if (data instanceof ArrayLong) {
        normalizeLongitudeData((ArrayLong) data, variable);
    } else {
        throw new MotuNotImplementedException(
                String.format("Error in NetcdfWriter normalizeLongitudeData - Array type %s is not implemented", data.getClass().getName()));

    }

}
 

import ucar.ma2.ArrayDouble; //导入依赖的package包/类
private void verifyAxisIsMonotonic(CoordinateAxis axis) throws IOException{
    Array array = axis.read();
    if (array instanceof ArrayDouble) {
        ArrayDouble arrayDouble = (ArrayDouble) array;
        Double prevVal = null;
        int direction = 0;
        while (arrayDouble.hasNext()){
            double val = arrayDouble.nextDouble();
            if (prevVal != null) {
                if (direction == 0) {
                    if (prevVal < val) {
                        direction = 1;
                    } else {
                        direction = -1;
                    }
                }
                if (direction == 1) {
                    assertThat(val, greaterThan(prevVal));
                } else {
                    assertThat(val, lessThan(prevVal));                        
                }
            }
            prevVal = val;
        }
    }
}
 

import ucar.ma2.ArrayDouble; //导入依赖的package包/类
private static ArrayDouble factory(final double number) {
    ArrayDouble.D0 array = new ArrayDouble.D0();
    array.set(number);
    return array;
}
 

import ucar.ma2.ArrayDouble; //导入依赖的package包/类
/**
 * Test {@link CurvilinearCoords}.
 * 
 * @throws IOException
 *             if there is a problem when read data in the netCDf file
 * @throws VariableNotFoundException 
 * */

@Test
public void testCurviLinearCoords() throws IOException, VariableNotFoundException {
    Variable varLonRho = cdf.findVariable("lon_rho");
    Variable varLatRho = cdf.findVariable("lat_rho");

    ArrayDouble longitudeData = (ArrayDouble) varLonRho.read();
    ArrayDouble latitudeData = (ArrayDouble) varLatRho.read();

    ValuesArray2D longitudeValuesInEDALFormat = new ValuesArray2D(xiSize, etaSize);
    ValuesArray2D latitudeValuesInEDALFormat = new ValuesArray2D(xiSize, etaSize);
    for (int i = 0; i < longitudeData.getSize(); i++) {
        int m = i % etaSize;
        int n = i / etaSize;
        int[] coords = new int[] { n, m };
        longitudeValuesInEDALFormat.set(longitudeData.getDouble(i), coords);
        latitudeValuesInEDALFormat.set(latitudeData.getDouble(i), coords);
    }

    CurvilinearCoords cCoords = new CurvilinearCoords(longitudeValuesInEDALFormat,
            latitudeValuesInEDALFormat);

    BoundingBox expectedBbox = dataset.getVariableMetadata("allx_u").getHorizontalDomain()
            .getBoundingBox();

    assertEquals(expectedBbox, cCoords.getBoundingBox());
    assertEquals(etaSize, cCoords.getNi());
    assertEquals(xiSize, cCoords.getNj());

    // pick up a horizontal position with id=15000

    int index = 15000;
    HorizontalPosition expectedPos = new HorizontalPosition(longitudeData.getDouble(index),
            latitudeData.getDouble(index));
    int cCoords_i = index % etaSize;
    int cCoords_j = index / etaSize;

    /*
     * CurvilinearCoords use "float" to save coordinates but LatLonPosition
     * use double. This makes a little difficulty for testing. We have to
     * compare them side by side.
     */

    assertEquals(expectedPos.getX(), cCoords.getMidpoint(cCoords_i, cCoords_j).getX(), delta);
    assertEquals(expectedPos.getY(), cCoords.getMidpoint(cCoords_i, cCoords_j).getY(), delta);
    assertEquals(expectedPos.getCoordinateReferenceSystem(),
            cCoords.getMidpoint(cCoords_i, cCoords_j).getCoordinateReferenceSystem());

    List<Cell> cellList = cCoords.getCells();
    Cell cell = cCoords.getCell(cCoords_i, cCoords_j);
    assertEquals(cellList.get(index), cell);

    assertEquals(cCoords_i, cell.getI());
    assertEquals(cCoords_j, cell.getJ());
    assertEquals(expectedPos.getX(), cell.getCentre().getX(), delta);
    assertEquals(expectedPos.getY(), cell.getCentre().getY(), delta);
    assertEquals(expectedPos.getCoordinateReferenceSystem(), cell.getCentre()
            .getCoordinateReferenceSystem());
}