Java Variable.getShape方法代码示例

import ucar.nc2.Variable; //导入方法依赖的package包/类
public double[] getExchangeItemValues(String varName, int stationIndex, int layerIndex) {

		Variable variable = this.netcdfFile.findVariable(varName);

		int[] origin = createOrigin(variable);
		int[] sizeArray = variable.getShape();

		//select only the given station and layer
		origin[timeDimensionIndex] = 0;
		origin[lstsciDimensionIndex] = 0; //Only a single constituent possible for now, if several, arguments need to be changed
		origin[kmaxOutRestrDimensionIndex] = layerIndex;
		origin[statDimensionIndex] = stationIndex;

		//only one station and layer
		sizeArray[kmaxOutRestrDimensionIndex] = 1;
		sizeArray[statDimensionIndex] = 1;
		return NetcdfUtils.readSelectedData(variable, origin, sizeArray, -1);

	}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
/**
 * Reads and returns the data from the given variable.
 *
 * @param variable
 * @return Object.
 */
public static Object readData(Variable variable) {
	double[] values;
	try {
		values = (double[]) variable.read().get1DJavaArray(double.class);
	} catch (IOException e) {
		throw new RuntimeException("Error while reading data from netcdf variable '" + variable.getShortName()
				+ "'. Message was: " + e.getMessage(), e);
	}

	//apply scale factor and offset and replace missing values with Double.NaN.
	double missingValue = getMissingValueDouble(variable);
	double scaleFactor = getScaleFactorDouble(variable);
	double offSet = getOffSetDouble(variable);
	NetcdfUtils.convertDoubleValuesFromNetcdf(values, missingValue, scaleFactor, offSet);

	return new Array(values, variable.getShape(), false);
}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
public static void writeDataForVariableForSingleTimeSingleLocationSingleRealization(NetcdfFileWriter netcdfFileWriter, Variable variable,
		int timeIndex, int realizationDimensionIndex, int realizationIndex, int stationDimensionIndex, int stationIndex, double[] values) {
	int[] origin = createOrigin(variable);
	int[] sizeArray = variable.getShape();

	//here assume that timeDimensionIndex is 0.
	int timeDimensionIndex = 0;
	//select only the given time, station and realization.
	origin[timeDimensionIndex] = timeIndex;
	sizeArray[timeDimensionIndex] = 1;
	origin[realizationDimensionIndex] = realizationIndex;
	sizeArray[realizationDimensionIndex] = 1;
	origin[stationDimensionIndex] = stationIndex;
	sizeArray[stationDimensionIndex] = 1;

	writeSelectedData(netcdfFileWriter, variable, origin, sizeArray, values);
}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
public double[] getExchangeItemValues(String varName) {

		// find variable
		Variable variable = this.netcdfFile.findVariable(varName);

		int[] origin = createOrigin(variable);
		int[] sizeArray = variable.getShape();

		//select whole 2D or 3D for last time step. Due to huge sizes if we read all time steps I decided for now to keep only the necessary
		ITimeInfo timeInfo = NetcdfUtils.createTimeInfo(variable, this.netcdfFile, timeInfoCache);
		int LastTimeIndex = timeInfo.getTimes().length;
		origin[timeDimensionIndex] = LastTimeIndex-1;
		sizeArray[timeDimensionIndex] = 1;

//		origin[timeDimensionIndex] = 0;
		if (variable.getShortName().equalsIgnoreCase("R1")) {
			origin[lstsciDimensionIndex] = 0; //Only a single constituent possible for now, needs to be changed
		}
		if (!variable.getShortName().equalsIgnoreCase("S1")) {
			origin[kmaxOutRestrDimensionIndex] = 0;
//			sizeArray[kmaxOutRestrDimensionIndex] = 1;
		}

		double[] domainData =  NetcdfUtils.readSelectedData(variable, origin, sizeArray,-1);

		//This calls the intelligence to expand the real to a fictive (full) domain
		if (Arrays.asList(fictiveVariables).contains(variable.getShortName())){
			domainData = expandDomain(domainData,LastTimeIndex);
		}
		return domainData;
	}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
public static double[] readDataForVariableForSingleLocation(Variable variable, int stationDimensionIndex, int stationIndex) {
	int[] origin = createOrigin(variable);
	int[] sizeArray = variable.getShape();

	//select only the given station.
	origin[stationDimensionIndex] = stationIndex;
	sizeArray[stationDimensionIndex] = 1;
	return readSelectedData(variable, origin, sizeArray, -1);
}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
public static double[] readDataForVariableForSingleLocationAndRealization(Variable variable, int stationDimensionIndex, int stationIndex, int realizationDimensionIndex, int realizationIndex) {
	int[] origin = createOrigin(variable);
	int[] sizeArray = variable.getShape();

	//select only the given station.
	origin[stationDimensionIndex] = stationIndex;
	sizeArray[stationDimensionIndex] = 1;
	//select only the given realization
	origin[realizationDimensionIndex] = realizationIndex;
	sizeArray[realizationDimensionIndex] = 1;
	return readSelectedData(variable, origin, sizeArray, -1);
}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
public static double[] readDataForVariableFor2DGridForSingleTime(Variable variable, int timeDimensionIndex, int timeIndex,
		int dimensionIndexToFlip) {
	int[] origin = createOrigin(variable);
	int[] sizeArray = variable.getShape();

	//select only the given time.
	origin[timeDimensionIndex] = timeIndex;
	sizeArray[timeDimensionIndex] = 1;
	return readSelectedData(variable, origin, sizeArray, dimensionIndexToFlip);
}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
public static double[] readDataForVariableFor2DGridForSingleTimeAndRealization(Variable variable,
	   int realizationDimensionIndex, int realizationIndex, int timeDimensionIndex, int timeIndex, int dimensionIndexToFlip) {
	int[] origin = createOrigin(variable);
	int[] sizeArray = variable.getShape();

	//select only the given time.
	origin[timeDimensionIndex] = timeIndex;
	sizeArray[timeDimensionIndex] = 1;
	//select only the given realization
	origin[realizationDimensionIndex] = realizationIndex;
	sizeArray[realizationDimensionIndex] = 1;
	return readSelectedData(variable, origin, sizeArray, dimensionIndexToFlip);
}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
public static void writeDataForVariableForSingleTime(NetcdfFileWriter netcdfFileWriter, Variable variable, int timeDimensionIndex, int timeIndex, double[] values) {
	int[] origin = createOrigin(variable);
	int[] sizeArray = variable.getShape();

	//select only the given time.
	origin[timeDimensionIndex] = timeIndex;
	sizeArray[timeDimensionIndex] = 1;

	writeSelectedData(netcdfFileWriter, variable, origin, sizeArray, values);
}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
public static void writeDataForVariableForSingleTimeSingleLocation(NetcdfFileWriter netcdfFileWriter, Variable variable, int timeIndex, int stationDimensionIndex, int stationIndex, double[] values) {
	int[] origin = createOrigin(variable);
	int[] sizeArray = variable.getShape();

	//here assume that timeDimensionIndex is 0.
	int timeDimensionIndex = 0;
	//select only the given time and station.
	origin[timeDimensionIndex] = timeIndex;
	sizeArray[timeDimensionIndex] = 1;
	origin[stationDimensionIndex] = stationIndex;
	sizeArray[stationDimensionIndex] = 1;

	writeSelectedData(netcdfFileWriter, variable, origin, sizeArray, values);
}
 

import ucar.nc2.Variable; //导入方法依赖的package包/类
/**
 * Gets the origins and shapes for block data writing. The max. size of a block in Ko to be process is in
 * the Motu configuration file (dataBlocksize attribute of MotuConfig)
 *
 * @param var variable to process
 * @return a map tha contains the shape (blocksize) to extract for each origin
 * @throws MotuException the motu exception
 * @throws MotuNotImplementedException the motu not implemented exception
 */
public static Map<int[], int[]> parseOriginAndShapeForWriting(Variable var) throws MotuException, MotuNotImplementedException {

    Map<int[], int[]> map = null;

    int[] varShape = var.getShape();

    for (int i = 0; i < varShape.length; i++) {
        if (varShape[i] <= 0) {
            throw new MotuException(
                    ErrorType.INVALID_LAT_LON_RANGE,
                    String.format("Error in NetCdfWriter.parseOriginAndShape - incorrect value %d for varShape[%d]", varShape[i], i));
        }
    }
    int nDims = varShape.length;
    int blockElementSize = NetCdfWriter.getElementBlockSize(var);

    if (blockElementSize <= 0) {
        blockElementSize = 1;
    }

    switch (nDims) {
    case 1:
        map = NetCdfWriter.parseOriginAndShape1DimForWriting(varShape);
        break;
    case 2:
        map = NetCdfWriter.parseOriginAndShape2DimForWriting(varShape);
        break;
    case 3:
        map = NetCdfWriter.parseOriginAndShape3DimForWriting(varShape);
        break;
    case 4:
        // map = NetCdfWriter.parseOriginAndShape4DimForWriting(varShape);
        break;
    default:
        throw new MotuNotImplementedException(
                String.format("Error in  NetCdfWriter.parseOriginAndShape1Dim - Processing for %d-dimension is not implemented", nDims));
        // break;
    }

    return map;
}