/**
* Create a new GridVertCoord with the appropriate params
*
* @param records list of GridRecords that make up this coord
* @param levelName the name of the level
* @param lookup the lookup table
* @param hcs Horizontal coordinate
*/
GridVertCoord(
List<GridRecord> records, String levelName, GridTableLookup lookup, GridHorizCoordSys hcs) {
this.typicalRecord = records.get(0);
this.levelName = levelName;
this.lookup = lookup;
dontUseVertical = !lookup.isVerticalCoordinate(typicalRecord);
positive = lookup.isPositiveUp(typicalRecord) ? "up" : "down";
units = lookup.getLevelUnit(typicalRecord);
usesBounds = lookup.isLayer(this.typicalRecord);
addLevels(records);
if (typicalRecord.getLevelType1() == 109 && lookup instanceof Grib1GridTableLookup)
checkForPressureLevels(records, hcs);
if (GridServiceProvider.debugVert) {
System.out.println(
"GribVertCoord: "
+ getVariableName()
+ "("
+ typicalRecord.getLevelType1()
+ ") useVertical= "
+ (!dontUseVertical)
+ " positive="
+ positive
+ " units="
+ units);
}
}
/**
* Match levels
*
* @param records records to match
* @return true if they have the same levels
*/
boolean matchLevels(List<GridRecord> records) {
// first create a new list
List<LevelCoord> levelList = new ArrayList<LevelCoord>(records.size());
for (GridRecord record : records) {
LevelCoord lc = new LevelCoord(record.getLevel1(), record.getLevel2());
if (!levelList.contains(lc)) {
levelList.add(lc);
}
}
Collections.sort(levelList);
if (positive.equals("down")) {
Collections.reverse(levelList);
}
// gotta equal existing list
return levelList.equals(levels);
}
/**
* Get the coordinate index for the record
*
* @param record record in question
* @return index or -1 if not found
*/
private int coordIndex(GridRecord record) {
double val = record.getLevel1();
double val2 = record.getLevel2();
if (usesBounds && (val > val2)) {
val = record.getLevel2();
val2 = record.getLevel1();
}
for (int i = 0; i < levels.size(); i++) {
LevelCoord lc = (LevelCoord) levels.get(i);
if (usesBounds) {
if (ucar.nc2.util.Misc.closeEnough(lc.value1, val)
&& ucar.nc2.util.Misc.closeEnough(lc.value2, val2)) {
return i;
}
} else {
if (ucar.nc2.util.Misc.closeEnough(lc.value1, val)) {
return i;
}
}
}
return -1;
}
/**
* Add levels
*
* @param records GridRecords, one for each level
*/
void addLevels(List<GridRecord> records) {
for (int i = 0; i < records.size(); i++) {
GridRecord record = records.get(i);
if (coordIndex(record) < 0) {
levels.add(new LevelCoord(record.getLevel1(), record.getLevel2()));
if (dontUseVertical && (levels.size() > 1)) {
if (GridServiceProvider.debugVert) {
logger.warn(
"GribCoordSys: unused level coordinate has > 1 levels = "
+ levelName
+ " "
+ record.getLevelType1()
+ " "
+ levels.size());
}
}
}
}
Collections.sort(levels);
if (positive.equals("down")) {
Collections.reverse(levels);
}
}
/**
* Add this coord as a variable in the netCDF file
*
* @param ncfile netCDF file to add to
* @param g group in file
*/
void addToNetcdfFile(NetcdfFile ncfile, Group g) {
if (dontUseVertical) {
typicalRecord = null;
return;
}
if (g == null) {
g = ncfile.getRootGroup();
}
// coordinate axis
Variable v = new Variable(ncfile, g, null, getVariableName());
v.setDataType(DataType.DOUBLE);
String desc = lookup.getLevelDescription(typicalRecord);
if (lookup instanceof Grib2GridTableLookup && usesBounds) {
desc = "Layer between " + desc;
}
v.addAttribute(new Attribute("long_name", desc));
v.addAttribute(new Attribute("units", lookup.getLevelUnit(typicalRecord)));
// positive attribute needed for CF-1 Height and Pressure
if (positive != null) {
v.addAttribute(new Attribute("positive", positive));
}
if (units != null) {
AxisType axisType;
if (SimpleUnit.isCompatible("millibar", units)) {
axisType = AxisType.Pressure;
} else if (SimpleUnit.isCompatible("m", units)) {
axisType = AxisType.Height;
} else {
axisType = AxisType.GeoZ;
}
if (lookup instanceof Grib2GridTableLookup || lookup instanceof Grib1GridTableLookup) {
v.addAttribute(
new Attribute("GRIB_level_type", Integer.toString(typicalRecord.getLevelType1())));
} else {
v.addAttribute(
new Attribute("level_type", Integer.toString(typicalRecord.getLevelType1())));
}
v.addAttribute(new Attribute(_Coordinate.AxisType, axisType.toString()));
}
if (coordValues == null) {
coordValues = new double[levels.size()];
for (int i = 0; i < levels.size(); i++) {
LevelCoord lc = (LevelCoord) levels.get(i);
coordValues[i] = lc.mid;
}
}
Array dataArray = Array.factory(DataType.DOUBLE, new int[] {coordValues.length}, coordValues);
v.setDimensions(getVariableName());
v.setCachedData(dataArray, true);
ncfile.addVariable(g, v);
if (usesBounds) {
String boundsDimName = "bounds_dim";
if (g.findDimension(boundsDimName) == null) {
ncfile.addDimension(g, new Dimension(boundsDimName, 2, true));
}
String bname = getVariableName() + "_bounds";
v.addAttribute(new Attribute("bounds", bname));
v.addAttribute(new Attribute(_Coordinate.ZisLayer, "true"));
Variable b = new Variable(ncfile, g, null, bname);
b.setDataType(DataType.DOUBLE);
b.setDimensions(getVariableName() + " " + boundsDimName);
b.addAttribute(new Attribute("long_name", "bounds for " + v.getName()));
b.addAttribute(new Attribute("units", lookup.getLevelUnit(typicalRecord)));
Array boundsArray = Array.factory(DataType.DOUBLE, new int[] {coordValues.length, 2});
ucar.ma2.Index ima = boundsArray.getIndex();
for (int i = 0; i < coordValues.length; i++) {
LevelCoord lc = (LevelCoord) levels.get(i);
boundsArray.setDouble(ima.set(i, 0), lc.value1);
boundsArray.setDouble(ima.set(i, 1), lc.value2);
}
b.setCachedData(boundsArray, true);
ncfile.addVariable(g, b);
}
if (factors != null) {
// check if already created
if (g == null) {
g = ncfile.getRootGroup();
}
if (g.findVariable("hybrida") != null) return;
v.addAttribute(new Attribute("standard_name", "atmosphere_hybrid_sigma_pressure_coordinate"));
v.addAttribute(new Attribute("formula_terms", "ap: hybrida b: hybridb ps: Pressure"));
// create hybrid factor variables
// add hybrida variable
Variable ha = new Variable(ncfile, g, null, "hybrida");
ha.setDataType(DataType.DOUBLE);
ha.addAttribute(new Attribute("long_name", "level_a_factor"));
ha.addAttribute(new Attribute("units", ""));
ha.setDimensions(getVariableName());
// add data
int middle = factors.length / 2;
double[] adata;
double[] bdata;
if (levels.size() < middle) { // only partial data wanted
adata = new double[levels.size()];
bdata = new double[levels.size()];
} else {
adata = new double[middle];
bdata = new double[middle];
}
for (int i = 0; i < middle && i < levels.size(); i++) adata[i] = factors[i];
Array haArray = Array.factory(DataType.DOUBLE, new int[] {adata.length}, adata);
ha.setCachedData(haArray, true);
ncfile.addVariable(g, ha);
// add hybridb variable
Variable hb = new Variable(ncfile, g, null, "hybridb");
hb.setDataType(DataType.DOUBLE);
hb.addAttribute(new Attribute("long_name", "level_b_factor"));
hb.addAttribute(new Attribute("units", ""));
hb.setDimensions(getVariableName());
// add data
for (int i = 0; i < middle && i < levels.size(); i++) bdata[i] = factors[i + middle];
Array hbArray = Array.factory(DataType.DOUBLE, new int[] {bdata.length}, bdata);
hb.setCachedData(hbArray, true);
ncfile.addVariable(g, hb);
/* // TODO: delete next time modifying code
double[] adata = new double[ middle ];
for( int i = 0; i < middle; i++ )
adata[ i ] = factors[ i ];
Array haArray = Array.factory(DataType.DOUBLE, new int[]{adata.length}, adata);
ha.setCachedData(haArray, true);
ncfile.addVariable(g, ha);
// add hybridb variable
Variable hb = new Variable(ncfile, g, null, "hybridb");
hb.setDataType(DataType.DOUBLE);
hb.addAttribute(new Attribute("long_name", "level_b_factor" ));
//hb.addAttribute(new Attribute("standard_name", "atmosphere_hybrid_sigma_pressure_coordinate" ));
hb.addAttribute(new Attribute("units", ""));
hb.setDimensions(getVariableName());
// add data
double[] bdata = new double[ middle ];
for( int i = 0; i < middle; i++ )
bdata[ i ] = factors[ i + middle ];
Array hbArray = Array.factory(DataType.DOUBLE, new int[]{bdata.length}, bdata);
hb.setCachedData(hbArray, true);
ncfile.addVariable(g, hb);
*/
}
}