public List<VariableBean> getStructureVariables(Structure s) {
List<VariableBean> vlist = new ArrayList<VariableBean>();
for (Variable v : s.getVariables()) {
vlist.add(new VariableBean(v));
}
return vlist;
}
// @todo Make sure units are meters
public Array getElevation(Range range) throws IOException, InvalidRangeException {
List section = new ArrayList(1);
section.add(range);
Array a = elevVar.read(section);
if (elevVarUnitsConversionFactor == 1.0) return (a);
for (IndexIterator it = a.getIndexIterator(); it.hasNext(); ) {
if (elevVar.getDataType() == DataType.DOUBLE) {
double val = it.getDoubleNext();
it.setDoubleCurrent(val * elevVarUnitsConversionFactor);
} else if (elevVar.getDataType() == DataType.FLOAT) {
float val = it.getFloatNext();
it.setFloatCurrent((float) (val * elevVarUnitsConversionFactor));
} else if (elevVar.getDataType() == DataType.INT) {
int val = it.getIntNext();
it.setIntCurrent((int) (val * elevVarUnitsConversionFactor));
} else if (elevVar.getDataType() == DataType.LONG) {
long val = it.getLongNext();
it.setLongCurrent((long) (val * elevVarUnitsConversionFactor));
} else {
throw new IllegalStateException(
"Elevation variable type <"
+ elevVar.getDataType().toString()
+ "> not double, float, int, or long.");
}
}
return (a);
}
private void hideNestedTable(int level) {
int n = nestedTableList.size();
for (int i = n - 1; i >= level; i--) {
NestedTable ntable = nestedTableList.get(i);
ntable.hide();
}
}
public List<VariableBean> getVariableBeans(NetcdfFile ds) {
List<VariableBean> vlist = new ArrayList<VariableBean>();
for (Variable v : ds.getVariables()) {
vlist.add(new VariableBean(v));
}
return vlist;
}
public void showAtts() {
if (ds == null) return;
if (attTable == null) {
// global attributes
attTable =
new BeanTableSorted(
AttributeBean.class, (PreferencesExt) prefs.node("AttributeBeans"), false);
PopupMenu varPopup = new ucar.nc2.ui.widget.PopupMenu(attTable.getJTable(), "Options");
varPopup.addAction(
"Show Attribute",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
AttributeBean bean = (AttributeBean) attTable.getSelectedBean();
if (bean != null) {
infoTA.setText(bean.att.toString());
infoTA.gotoTop();
infoWindow.show();
}
}
});
attWindow =
new IndependentWindow("Global Attributes", BAMutil.getImage("netcdfUI"), attTable);
attWindow.setBounds(
(Rectangle) prefs.getBean("AttWindowBounds", new Rectangle(300, 100, 500, 800)));
}
List<AttributeBean> attlist = new ArrayList<AttributeBean>();
for (Attribute att : ds.getGlobalAttributes()) {
attlist.add(new AttributeBean(att));
}
attTable.setBeans(attlist);
attWindow.show();
}
/**
* Create a new GridVertCoord for a layer
*
* @param record layer record
* @param levelName name of this level
* @param lookup lookup table
* @param level1 level 1
* @param level2 level 2
*/
GridVertCoord(
GridRecord record,
String levelName,
GridTableLookup lookup,
double[] level1,
double[] level2) {
this.typicalRecord = record;
this.levelName = levelName;
this.lookup = lookup;
// dontUseVertical = !lookup.isVerticalCoordinate(record);
positive = lookup.isPositiveUp(record) ? "up" : "down";
units = lookup.getLevelUnit(record);
usesBounds = lookup.isLayer(this.typicalRecord);
levels = new ArrayList<LevelCoord>(level1.length);
for (int i = 0; i < level1.length; i++) {
levels.add(new LevelCoord(level1[i], (level2 == null) ? 0.0 : level2[i]));
}
Collections.sort(levels);
if (positive.equals("down")) {
Collections.reverse(levels);
}
dontUseVertical = (levels.size() == 1);
}
/** get the shape */
public int[] getShape() {
int[] shape = new int[mydims.size()];
for (int i = 0; i < mydims.size(); i++) {
Dimension d = mydims.get(i);
shape[i] = d.getLength();
}
return shape;
}
private LatLonRect getBoundingBox(List stnList) {
ucar.unidata.geoloc.Station s = (ucar.unidata.geoloc.Station) stnList.get(0);
LatLonPointImpl llpt = new LatLonPointImpl();
llpt.set(s.getLatitude(), s.getLongitude());
LatLonRect rect = new LatLonRect(llpt, .001, .001);
for (int i = 1; i < stnList.size(); i++) {
s = (ucar.unidata.geoloc.Station) stnList.get(i);
llpt.set(s.getLatitude(), s.getLongitude());
rect.extend(llpt);
}
return rect;
}
private void makeSelectStations(StringBuffer sbuff, List stations) {
// ID id1,id2,id3,...idn
// However, it will depend on the dataset as to the variable for the station ID.
// For synoptic data it's IDN (e.g. 72469)
// for METAR it's ID.
// For profiler data, there are two variables IDA and IDB where IDA is the first 4 chars and IDB
// is the second 4.
sbuff.append("ID ");
for (int i = 0; i < stations.size(); i++) {
Station s = (Station) stations.get(i);
if (i > 0) sbuff.append(",");
sbuff.append(s.getName());
}
}
/**
* 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);
}
}
private NestedTable setNestedTable(int level, Structure s) {
NestedTable ntable;
if (nestedTableList.size() < level + 1) {
ntable = new NestedTable(level);
nestedTableList.add(ntable);
} else {
ntable = nestedTableList.get(level);
}
if (s != null) // variables inside of records
ntable.table.setBeans(getStructureVariables(s));
ntable.show();
return ntable;
}
private void createProfiles(int nprofiles) throws IOException {
this.nprofiles = nprofiles;
// add the dimensions
Dimension profileDim = ncfile.addDimension(profileDimName, nprofiles);
profileDims.add(profileDim);
Variable v = ncfile.addVariable(numObsName, DataType.INT, profileDimName);
ncfile.addVariableAttribute(
v, new Attribute("long_name", "number of children in linked list for this profile"));
v = ncfile.addVariable(numProfilesTotalName, DataType.INT, "");
ncfile.addVariableAttribute(v, new Attribute("long_name", "number of valid profiles"));
v = ncfile.addVariable(firstObsName, DataType.INT, profileDimName);
ncfile.addVariableAttribute(
v,
new Attribute("long_name", "record number of first obs in linked list for this profile"));
// time variable
Variable timeVar = ncfile.addStringVariable(timeName, profileDims, 20);
ncfile.addVariableAttribute(
timeVar, new Attribute("long_name", "ISO-8601 Date - time of observation"));
v = ncfile.addVariable(parentStationIndex, DataType.INT, profileDimName);
ncfile.addVariableAttribute(v, new Attribute("long_name", "index of parent station"));
v = ncfile.addVariable(nextProfileName, DataType.INT, profileDimName);
ncfile.addVariableAttribute(
v, new Attribute("long_name", "index of next profile in linked list for this station"));
}
public void setDataset(NetcdfFile ds) {
this.ds = ds;
NestedTable nt = nestedTableList.get(0);
nt.table.setBeans(getVariableBeans(ds));
hideNestedTable(1);
datasetTree.setFile(ds);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GridEnsembleCoord that = (GridEnsembleCoord) o;
return ensCoords.equals(that.ensCoords);
}
/**
* Add this coord as a dimension to the netCDF file
*
* @param ncfile file to add to
* @param g group in the file
*/
void addDimensionsToNetcdfFile(NetcdfFile ncfile, Group g) {
if (dontUseVertical) {
return;
}
int nlevs = levels.size();
if (coordValues != null) nlevs = coordValues.length;
ncfile.addDimension(g, new Dimension(getVariableName(), nlevs, true));
}
public Array getData(Range range, String parameterName)
throws IOException, InvalidRangeException {
Variable variable = ncfile.getRootGroup().findVariable(parameterName);
int varRank = variable.getRank();
int[] varShape = variable.getShape();
List section = new ArrayList(varRank);
section.add(range);
for (int i = 1; i < varRank; i++) {
section.add(new Range(0, varShape[i] - 1));
}
Array array = variable.read(section);
if (array.getShape()[0] == 1) {
return (array.reduce(0));
} else {
return (array);
}
// return( array.getShape()[0] == 1 ? array.reduce( 0 ) : array);
}
/** check for Sigma Pressure Levels */
boolean checkForPressureLevels(List<GridRecord> records, GridHorizCoordSys hcs) {
GridDefRecord gdr = hcs.getGds();
Grib1GDSVariables g1dr = (Grib1GDSVariables) gdr.getGdsv();
if (g1dr == null || !g1dr.hasVerticalPressureLevels()) return false;
// add hybrid numbers
coordValues = new double[levels.size()];
for (int i = 0; i < levels.size(); i++) {
LevelCoord lc = levels.get(i);
coordValues[i] = lc.value1;
}
int NV = g1dr.getNV();
// add new variables
if (NV > 2 && NV < 255) { // Some data doesn't add Pressure Level values
factors = g1dr.getVerticalPressureLevels();
}
return true;
}
/**
* 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);
}
private void writeHeader(ProfileFeature profile, PointFeature obs) throws IOException {
Formatter coordNames = new Formatter().format("%s %s %s", profileTimeName, latName, lonName);
List<VariableSimpleIF> coords = new ArrayList<>();
if (useAlt) {
coords.add(
VariableSimpleImpl.makeScalar(
altitudeCoordinateName, "obs altitude", altUnits, DataType.DOUBLE)
.add(new Attribute(CF.STANDARD_NAME, "altitude"))
.add(
new Attribute(
CF.POSITIVE,
CF1Convention.getZisPositive(altitudeCoordinateName, altUnits))));
coordNames.format(" %s", altitudeCoordinateName);
}
super.writeHeader(
coords, profile.getFeatureData(), obs.getFeatureData(), coordNames.toString());
}
private void setSelected(Variable v) {
eventsOK = false;
List<Variable> vchain = new ArrayList<Variable>();
vchain.add(v);
Variable vp = v;
while (vp.isMemberOfStructure()) {
vp = vp.getParentStructure();
vchain.add(0, vp); // reverse
}
for (int i = 0; i < vchain.size(); i++) {
vp = vchain.get(i);
NestedTable ntable = setNestedTable(i, vp.getParentStructure());
ntable.setSelected(vp);
}
eventsOK = true;
}
private void writeStationData(List<ucar.unidata.geoloc.Station> stnList) throws IOException {
this.stnList = stnList;
int nstns = stnList.size();
stationMap = new HashMap<String, StationTracker>(2 * nstns);
if (debug) System.out.println("stationMap created");
// now write the station data
ArrayDouble.D1 latArray = new ArrayDouble.D1(nstns);
ArrayDouble.D1 lonArray = new ArrayDouble.D1(nstns);
ArrayDouble.D1 altArray = new ArrayDouble.D1(nstns);
ArrayObject.D1 idArray = new ArrayObject.D1(String.class, nstns);
ArrayObject.D1 descArray = new ArrayObject.D1(String.class, nstns);
ArrayObject.D1 wmoArray = new ArrayObject.D1(String.class, nstns);
for (int i = 0; i < stnList.size(); i++) {
ucar.unidata.geoloc.Station stn = stnList.get(i);
stationMap.put(stn.getName(), new StationTracker(i));
latArray.set(i, stn.getLatitude());
lonArray.set(i, stn.getLongitude());
if (useAlt) altArray.set(i, stn.getAltitude());
idArray.set(i, stn.getName());
descArray.set(i, stn.getDescription());
if (useWmoId) wmoArray.set(i, stn.getWmoId());
}
try {
ncfile.write(latName, latArray);
ncfile.write(lonName, lonArray);
if (useAlt) ncfile.write(altName, altArray);
ncfile.writeStringData(idName, idArray);
ncfile.writeStringData(descName, descArray);
if (useWmoId) ncfile.writeStringData(wmoName, wmoArray);
} catch (InvalidRangeException e) {
e.printStackTrace();
throw new IllegalStateException(e);
}
}
/**
* Constructor.
*
* @param ncfile the netccdf file
* @param typedDataVariables list of data variables; all record variables will be added to this
* list, except . You can remove extra
* @param obsTimeVName observation time variable name (required)
* @param nomTimeVName nominal time variable name (may be null)
* @throws IllegalArgumentException if ncfile has no unlimited dimension and recDimName is null.
*/
public RecordDatasetHelper(
NetcdfDataset ncfile,
String obsTimeVName,
String nomTimeVName,
List<VariableSimpleIF> typedDataVariables,
String recDimName,
Formatter errBuffer) {
this.ncfile = ncfile;
this.obsTimeVName = obsTimeVName;
this.nomTimeVName = nomTimeVName;
this.errs = errBuffer;
// check if we already have a structure vs if we have to add it.
if (this.ncfile.hasUnlimitedDimension()) {
this.ncfile.sendIospMessage(NetcdfFile.IOSP_MESSAGE_ADD_RECORD_STRUCTURE);
this.recordVar = (StructureDS) this.ncfile.getRootGroup().findVariable("record");
this.obsDim = ncfile.getUnlimitedDimension();
} else {
if (recDimName == null)
throw new IllegalArgumentException(
"File <"
+ this.ncfile.getLocation()
+ "> has no unlimited dimension, specify psuedo record dimension with observationDimension global attribute.");
this.obsDim = this.ncfile.getRootGroup().findDimension(recDimName);
this.recordVar = new StructurePseudoDS(this.ncfile, null, "record", null, obsDim);
}
// create member variables
List<Variable> recordMembers = ncfile.getVariables();
for (Variable v : recordMembers) {
if (v == recordVar) continue;
if (v.isScalar()) continue;
if (v.getDimension(0) == this.obsDim) typedDataVariables.add(v);
}
// need the time units
Variable timeVar = ncfile.findVariable(obsTimeVName);
String timeUnitString =
ncfile.findAttValueIgnoreCase(timeVar, CDM.UNITS, "seconds since 1970-01-01");
try {
timeUnit = new DateUnit(timeUnitString);
} catch (Exception e) {
if (null != errs) errs.format("Error on string = %s == %s%n", timeUnitString, e.getMessage());
try {
timeUnit = new DateUnit("seconds since 1970-01-01");
} catch (Exception e1) {
// cant happen
}
}
}
/**
* 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;
}
// Constructor for when you already have the StructureData, and need to find Station and times
protected RecordStationObs(StructureData sdata, int recno, boolean useId) {
super(recno);
this.recno = recno;
this.sdata = sdata;
this.timeUnit = RecordDatasetHelper.this.timeUnit;
StructureMembers members = sdata.getStructureMembers();
obsTime = getTime(members.findMember(obsTimeVName), sdata);
nomTime = (nomTimeVName == null) ? obsTime : getTime(members.findMember(nomTimeVName), sdata);
if (useId) {
// this assumes the station id/name is stored in the obs record
String stationId;
if (stationIdType == DataType.INT) {
stationId = Integer.toString(sdata.getScalarInt(stnIdVName));
} else stationId = sdata.getScalarString(stnIdVName).trim();
station = stationHelper.getStation(stationId);
if (null != errs)
errs.format(" cant find station id = <%s> when reading record %d%n", stationId, recno);
log.error(" cant find station id = <" + stationId + "> when reading record " + recno);
} else {
// use a station index
List<Station> stations = stationHelper.getStations();
int stationIndex = sdata.getScalarInt(stnIndexVName);
if (stationIndex < 0 || stationIndex >= stations.size()) {
if (null != errs)
errs.format(
" cant find station at index =%d when reading record %d%n", stationIndex, recno);
log.error(
"cant find station at index = " + stationIndex + " when reading record " + recno);
} else station = stations.get(stationIndex);
}
location = station;
}
/**
* Create a new GeoGrid that is a logical subset of this GeoGrid.
*
* @param t_range subset the time dimension, or null if you want all of it
* @param z_range subset the vertical dimension, or null if you want all of it
* @param bbox a lat/lon bounding box, or null if you want all x,y
* @param z_stride use only if z_range is null, then take all z with this stride (1 means all)
* @param y_stride use this stride on the y coordinate (1 means all)
* @param x_stride use this stride on the x coordinate (1 means all)
* @return subsetted GeoGrid
* @throws InvalidRangeException if bbox does not intersect GeoGrid
*/
public GeoGrid subset(
Range t_range, Range z_range, LatLonRect bbox, int z_stride, int y_stride, int x_stride)
throws InvalidRangeException {
if ((z_range == null) && (z_stride > 1)) {
Dimension zdim = getZDimension();
if (zdim != null) z_range = new Range(0, zdim.getLength() - 1, z_stride);
}
Range y_range = null, x_range = null;
if (bbox != null) {
List yx_ranges = gcs.getRangesFromLatLonRect(bbox);
y_range = (Range) yx_ranges.get(0);
x_range = (Range) yx_ranges.get(1);
}
if (y_stride > 1) {
if (y_range == null) {
Dimension ydim = getYDimension();
y_range = new Range(0, ydim.getLength() - 1, y_stride);
} else {
y_range = new Range(y_range.first(), y_range.last(), y_stride);
}
}
if (x_stride > 1) {
if (x_range == null) {
Dimension xdim = getXDimension();
x_range = new Range(0, xdim.getLength() - 1, x_stride);
} else {
x_range = new Range(x_range.first(), x_range.last(), x_stride);
}
}
return subset(t_range, z_range, y_range, x_range);
}
/**
* 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);
}
}
/**
* Constructor.
*
* @param dataset belongs to this dataset
* @param dsvar wraps this Variable
* @param gcs has this grid coordinate system
*/
public GeoGrid(GridDataset dataset, VariableDS dsvar, GridCoordSys gcs) {
this.dataset = dataset;
this.vs = dsvar;
this.gcs = gcs;
CoordinateAxis xaxis = gcs.getXHorizAxis();
if (xaxis instanceof CoordinateAxis1D) {
xDimOrgIndex = findDimension(gcs.getXHorizAxis().getDimension(0));
yDimOrgIndex = findDimension(gcs.getYHorizAxis().getDimension(0));
} else { // 2D case
yDimOrgIndex = findDimension(gcs.getXHorizAxis().getDimension(0));
xDimOrgIndex = findDimension(gcs.getXHorizAxis().getDimension(1));
}
if (gcs.getVerticalAxis() != null)
zDimOrgIndex = findDimension(gcs.getVerticalAxis().getDimension(0));
if (gcs.getTimeAxis() != null) {
if (gcs.getTimeAxis1D() != null)
tDimOrgIndex = findDimension(gcs.getTimeAxis1D().getDimension(0));
else tDimOrgIndex = findDimension(gcs.getTimeAxis().getDimension(1));
}
if (gcs.getEnsembleAxis() != null)
eDimOrgIndex = findDimension(gcs.getEnsembleAxis().getDimension(0));
if (gcs.getRunTimeAxis() != null)
rtDimOrgIndex = findDimension(gcs.getRunTimeAxis().getDimension(0));
// construct canonical dimension list
int count = 0;
this.mydims = new ArrayList<Dimension>();
if ((rtDimOrgIndex >= 0) && (rtDimOrgIndex != tDimOrgIndex)) {
mydims.add(dsvar.getDimension(rtDimOrgIndex));
rtDimNewIndex = count++;
}
if (eDimOrgIndex >= 0) {
mydims.add(dsvar.getDimension(eDimOrgIndex));
eDimNewIndex = count++;
}
if (tDimOrgIndex >= 0) {
mydims.add(dsvar.getDimension(tDimOrgIndex));
tDimNewIndex = count++;
}
if (zDimOrgIndex >= 0) {
mydims.add(dsvar.getDimension(zDimOrgIndex));
zDimNewIndex = count++;
}
if (yDimOrgIndex >= 0) {
mydims.add(dsvar.getDimension(yDimOrgIndex));
yDimNewIndex = count++;
}
if (xDimOrgIndex >= 0) {
mydims.add(dsvar.getDimension(xDimOrgIndex));
xDimNewIndex = count;
}
}
protected void makeFeatureVariables(StructureData featureData, boolean isExtended)
throws IOException {
// LOOK why not unlimited here ?
Dimension profileDim = writer.addDimension(null, profileDimName, nfeatures);
// Dimension profileDim = isExtendedModel ? writer.addUnlimitedDimension(profileDimName) :
// writer.addDimension(null, profileDimName, nprofiles);
// add the profile Variables using the profile dimension
List<VariableSimpleIF> profileVars = new ArrayList<>();
profileVars.add(
VariableSimpleImpl.makeScalar(latName, "profile latitude", CDM.LAT_UNITS, DataType.DOUBLE));
profileVars.add(
VariableSimpleImpl.makeScalar(
lonName, "profile longitude", CDM.LON_UNITS, DataType.DOUBLE));
profileVars.add(
VariableSimpleImpl.makeString(profileIdName, "profile identifier", null, id_strlen)
.add(new Attribute(CF.CF_ROLE, CF.PROFILE_ID))); // profileId:cf_role = "profile_id";
profileVars.add(
VariableSimpleImpl.makeScalar(
numberOfObsName, "number of obs for this profile", null, DataType.INT)
.add(
new Attribute(
CF.SAMPLE_DIMENSION, recordDimName))); // rowSize:sample_dimension = "obs"
profileVars.add(
VariableSimpleImpl.makeScalar(
profileTimeName,
"nominal time of profile",
timeUnit.getUnitsString(),
DataType.DOUBLE));
for (StructureMembers.Member m : featureData.getMembers()) {
VariableSimpleIF dv = getDataVar(m.getName());
if (dv != null) profileVars.add(dv);
}
if (isExtended) {
profileStruct =
(Structure)
writer.addVariable(null, profileStructName, DataType.STRUCTURE, profileDimName);
addCoordinatesExtended(profileStruct, profileVars);
} else {
addCoordinatesClassic(profileDim, profileVars, featureVarMap);
}
}
/**
* Add this as a variable to the netCDF file
*
* @param ncfile the netCDF file
* @param g the group in the file
*/
void addToNetcdfFile(NetcdfFile ncfile, Group g) {
Variable v = new Variable(ncfile, g, null, getName());
v.setDimensions(v.getShortName());
v.setDataType(DataType.STRING);
v.addAttribute(new Attribute("long_name", "ensemble"));
v.addAttribute(new Attribute(_Coordinate.AxisType, AxisType.Ensemble.toString()));
String[] data = new String[getNEnsembles()];
for (int i = 0; i < getNEnsembles(); i++) {
EnsCoord ec = ensCoords.get(i);
data[i] = Grib2Tables.codeTable4_6(ec.type) + " " + ec.number;
}
Array dataArray = Array.factory(DataType.STRING, new int[] {getNEnsembles()}, data);
v.setCachedData(dataArray, false);
ncfile.addVariable(g, v);
}
private void compareDataset(CompareDialog.Data data) {
if (data.name == null) return;
NetcdfFile compareFile = null;
try {
compareFile = NetcdfDataset.openFile(data.name, null);
Formatter f = new Formatter();
CompareNetcdf2 cn = new CompareNetcdf2(f, data.showCompare, data.showDetails, data.readData);
if (data.howMuch == CompareDialog.HowMuch.All) cn.compare(ds, compareFile);
else {
NestedTable nested = nestedTableList.get(0);
Variable org = getCurrentVariable(nested.table);
if (org == null) return;
Variable ov = compareFile.findVariable(org.getFullNameEscaped());
if (ov != null) cn.compareVariable(org, ov);
}
infoTA.setText(f.toString());
infoTA.gotoTop();
infoWindow.setTitle("Compare");
infoWindow.show();
} catch (Throwable ioe) {
ByteArrayOutputStream bos = new ByteArrayOutputStream(10000);
ioe.printStackTrace(new PrintStream(bos));
infoTA.setText(bos.toString());
infoTA.gotoTop();
infoWindow.show();
} finally {
if (compareFile != null)
try {
compareFile.close();
} catch (Exception eek) {
}
}
}
