@Override public CoverageCoordAxis copy() { return new CoverageCoordAxis1D(new CoverageCoordAxisBuilder(this)); }
private static CoverageCoordAxis makeCoordAxisFromDimension(Dimension dim) { CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(); builder.name = dim.getFullName(); builder.dataType = DataType.INT; builder.axisType = AxisType.Dimension; builder.dependenceType = CoverageCoordAxis.DependenceType.dimension; builder.spacing = CoverageCoordAxis.Spacing.regularPoint; builder.ncoords = dim.getLength(); builder.startValue = 0; builder.endValue = dim.getLength()-1; builder.resolution = 1; return new CoverageCoordAxis1D(builder); }
public Optional<CoverageCoordAxis> subsetByIndex(Range range) { try { CoordAxisHelper helper = new CoordAxisHelper(this); CoverageCoordAxisBuilder builder = helper.subsetByIndex(range); return Optional.of(new CoverageCoordAxis1D(builder)); } catch (InvalidRangeException e) { return Optional.empty(e.getMessage()); } }
@Override public Optional<CoverageCoordAxis> subsetDependent(CoverageCoordAxis1D dependsOn) { CoverageCoordAxisBuilder builder; try { builder = new CoordAxisHelper(this).subsetByIndex(dependsOn.getRange()); // LOOK Other possible subsets? } catch (InvalidRangeException e) { return Optional.empty(e.getMessage()); } return Optional.of(new CoverageCoordAxis1D(builder)); }
@Override public Optional<CoverageCoordAxis> subset(SubsetParams params) { Optional<CoverageCoordAxisBuilder> buildero = subsetBuilder(params); return !buildero.isPresent() ? Optional.empty(buildero.getErrorMessage()) : Optional.of(new CoverageCoordAxis1D(buildero.get())); }
@Override public Optional<CoverageCoordAxis> subset(double minValue, double maxValue, int stride) throws InvalidRangeException { CoordAxisHelper helper = new CoordAxisHelper(this); Optional<CoverageCoordAxisBuilder> buildero = helper.subset(minValue, maxValue, stride); return !buildero.isPresent() ? Optional.empty(buildero.getErrorMessage()) : Optional.of(new CoverageCoordAxis1D(buildero.get())); }
result.add(new CoverageCoordAxis1D(new CoverageCoordAxisBuilder(CF.LATITUDE, CDM.LAT_UNITS, null, DataType.FLOAT, AxisType.Lat, atts, CoverageCoordAxis.DependenceType.independent, null, spacing, hcs.ny, hcs.getStartY(), hcs.getEndY(), hcs.dy, values, this))); result.add(new CoverageCoordAxis1D(new CoverageCoordAxisBuilder(CF.LONGITUDE, CDM.LON_UNITS, null, DataType.FLOAT, AxisType.Lon, atts, CoverageCoordAxis.DependenceType.independent, null, CoverageCoordAxis.Spacing.regularPoint, hcs.nx, hcs.getStartX(), hcs.getEndX(), hcs.dx, null, this))); AttributeContainerHelper atts = new AttributeContainerHelper("y"); atts.addAttribute(new Attribute(CDM.UNITS, "km")); result.add(new CoverageCoordAxis1D(new CoverageCoordAxisBuilder("y", "km", CF.PROJECTION_Y_COORDINATE, DataType.FLOAT, AxisType.GeoY, atts, CoverageCoordAxis.DependenceType.independent, null, CoverageCoordAxis.Spacing.regularPoint, hcs.ny, hcs.getStartY(), hcs.getEndY(), hcs.dy, null, this))); result.add(new CoverageCoordAxis1D(new CoverageCoordAxisBuilder("x", "km", CF.PROJECTION_X_COORDINATE, DataType.FLOAT, AxisType.GeoX, atts, CoverageCoordAxis.DependenceType.independent, null, CoverageCoordAxis.Spacing.regularPoint, hcs.nx, hcs.getStartX(), hcs.getEndX(), hcs.dx, null, this)));
private CoverageCoordAxis makeCoordAxis(CoordinateEns ensCoord) { int n = ensCoord.getSize(); double[] values = new double[n]; for (int i = 0; i < n; i++) values[i] = ((EnsCoord.Coord) ensCoord.getValue(i)).getEnsMember(); AttributeContainerHelper atts = new AttributeContainerHelper(ensCoord.getName()); String units = ensCoord.getUnit(); atts.addAttribute(new Attribute(CDM.UNITS, units)); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(ensCoord.getName(), units, null, DataType.DOUBLE, AxisType.Ensemble, atts, CoverageCoordAxis.DependenceType.independent, null, null, ensCoord.getSize(), 0, 0, 0, values, this); builder.setSpacingFromValues(false); return new CoverageCoordAxis1D(builder); }
0.0, values, reader); builder.setIsSubset(true); return new CoverageCoordAxis1D(builder); return new CoverageCoordAxis1D(builder);
public Optional<CoverageCoordAxis> subsetByIntervals(List<MAMath.MinMax> lonIntvs, int stride) { if (axisType != AxisType.Lon) return Optional.empty("subsetByIntervals only for longitude"); if (!isRegular()) return Optional.empty("subsetByIntervals only for regular longitude"); CoordAxisHelper helper = new CoordAxisHelper(this); double start = Double.NaN; boolean first = true; List<RangeIterator> ranges = new ArrayList<>(); for (MAMath.MinMax lonIntv : lonIntvs) { if (first) start = lonIntv.min; first = false; Optional<RangeIterator> opt = helper.makeRange(lonIntv.min, lonIntv.max, stride); if (!opt.isPresent()) return Optional.empty(opt.getErrorMessage()); ranges.add(opt.get()); } try { RangeComposite compositeRange = new RangeComposite(AxisType.Lon.toString(), ranges); int npts = compositeRange.length(); double end = start + npts * resolution; CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(this); // copy builder.subset(npts, start, end, resolution, null); builder.setRange(null); builder.setCompositeRange(compositeRange); return Optional.of(new CoverageCoordAxis1D(builder)); } catch (InvalidRangeException e) { return Optional.empty(e.getMessage()); } }
private CoverageCoordAxis makeScalarTimeCoord(double val, CoverageCoordAxis1D runAxisSubset) { String name = "constantForecastTime"; String desc = "forecast time"; AttributeContainerHelper atts = new AttributeContainerHelper(name); atts.addAttribute(new Attribute(CDM.UNITS, runAxisSubset.getUnits())); atts.addAttribute(new Attribute(CF.STANDARD_NAME, CF.TIME)); atts.addAttribute(new Attribute(CDM.LONG_NAME, desc)); atts.addAttribute(new Attribute(CF.CALENDAR, runAxisSubset.getCalendar().toString())); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(name, runAxisSubset.getUnits(), desc, DataType.DOUBLE, AxisType.Time, atts, CoverageCoordAxis.DependenceType.scalar, null, CoverageCoordAxis.Spacing.regularPoint, 1, val, val, 0.0, null, null); builder.setIsSubset(true); return new CoverageCoordAxis1D(builder); }
private CoverageCoordAxis makeScalarTimeCoord(double val, CoverageCoordAxis1D runAxisSubset) { String name = "constantForecastTime"; String desc = "forecast time"; AttributeContainerHelper atts = new AttributeContainerHelper(name); atts.addAttribute(new Attribute(CDM.UNITS, runAxisSubset.getUnits())); atts.addAttribute(new Attribute(CF.STANDARD_NAME, CF.TIME)); atts.addAttribute(new Attribute(CDM.LONG_NAME, desc)); atts.addAttribute(new Attribute(CF.CALENDAR, runAxisSubset.getCalendar().toString())); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(name, runAxisSubset.getUnits(), desc, DataType.DOUBLE, AxisType.Time, atts, CoverageCoordAxis.DependenceType.scalar, null, CoverageCoordAxis.Spacing.regularPoint, 1, val, val, 0.0, null, null); builder.setIsSubset(true); return new CoverageCoordAxis1D(builder); }
private CoverageCoordAxis makeCoordAxis(CoordinateVert vertCoord) { List<VertCoord.Level> levels = vertCoord.getLevelSorted(); int n = vertCoord.getSize(); double[] values; if (vertCoord.isLayer()) { int count = 0; values = new double[2 * n]; for (int i = 0; i < n; i++) { values[count++] = levels.get(i).getValue1(); values[count++] = levels.get(i).getValue2(); } } else { values = new double[n]; for (int i = 0; i < n; i++) values[i] = levels.get(i).getValue1(); } AttributeContainerHelper atts = new AttributeContainerHelper(vertCoord.getName()); String units = vertCoord.getUnit(); atts.addAttribute(new Attribute(CDM.UNITS, units)); AxisType axisType = AxisType.GeoZ; if (SimpleUnit.isCompatible("mbar", units)) axisType = AxisType.Pressure; else if (SimpleUnit.isCompatible("m", units)) axisType = AxisType.Height; String desc = vertCoord.getVertUnit().getDesc(); if (desc != null) atts.addAttribute(new Attribute(CDM.LONG_NAME, desc)); atts.addAttribute(new Attribute(CF.POSITIVE, vertCoord.isPositiveUp() ? CF.POSITIVE_UP : CF.POSITIVE_DOWN)); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(vertCoord.getName(), vertCoord.getUnit(), null, DataType.DOUBLE, axisType, atts, CoverageCoordAxis.DependenceType.independent, null, null, n, 0.0, 0.0, 0.0, values, this); builder.setSpacingFromValues(vertCoord.isLayer()); return new CoverageCoordAxis1D(builder); }
private CoverageCoordAxis makeCoordAxis(CoordinateTime time) { trackDateRange(time.makeCalendarDateRange(null)); // default calendar List<Integer> offsets = time.getOffsetSorted(); int n = offsets.size(); double[] values = new double[n]; int count = 0; for (int offset : offsets) values[count++] = offset; AttributeContainerHelper atts = new AttributeContainerHelper(time.getName()); atts.addAttribute(new Attribute(CDM.UNITS, time.getUnit())); atts.addAttribute(new Attribute(CF.STANDARD_NAME, CF.TIME)); atts.addAttribute(new Attribute(CDM.LONG_NAME, Grib.GRIB_VALID_TIME)); atts.addAttribute(new Attribute(CF.CALENDAR, ucar.nc2.time.Calendar.proleptic_gregorian.toString())); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(time.getName(), time.getTimeUdUnit(), Grib.GRIB_VALID_TIME, DataType.DOUBLE, AxisType.Time, atts, CoverageCoordAxis.DependenceType.independent, null, null, n, 0, 0, 0, values, this); builder.setSpacingFromValues(false); return new CoverageCoordAxis1D(builder); }
private CoverageCoordAxis1D makeRuntimeCoord(CoordinateRuntime runtime) { String units = runtime.getPeriodName() + " since " + gribCollection.getMasterFirstDate().toString(); List<Double> offsets = runtime.getOffsetsInTimeUnits(); int n = offsets.size(); // CoordinateRuntime master = gribCollection.getMasterRuntime(); boolean isScalar = (n == 1); // this is the case of runtime[1] CoverageCoordAxis.DependenceType dependence = isScalar ? CoverageCoordAxis.DependenceType.scalar : CoverageCoordAxis.DependenceType.independent; double[] values = new double[n]; int count = 0; for (Double offset : runtime.getOffsetsInTimeUnits()) values[count++] = offset; AttributeContainerHelper atts = new AttributeContainerHelper(runtime.getName()); atts.addAttribute(new Attribute(CDM.UNITS, units)); atts.addAttribute(new Attribute(CF.STANDARD_NAME, CF.TIME_REFERENCE)); atts.addAttribute(new Attribute(CDM.LONG_NAME, "GRIB reference time")); atts.addAttribute(new Attribute(CF.CALENDAR, ucar.nc2.time.Calendar.proleptic_gregorian.toString())); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(runtime.getName(), units, "GRIB reference time", DataType.DOUBLE, AxisType.RunTime, atts, dependence, null, null, n, 0.0, 0.0, 0.0, values, this); builder.setSpacingFromValues(false); return new CoverageCoordAxis1D(builder); }
private CoverageCoordAxis makeCoordAxis(CoordinateTimeIntv time) { trackDateRange(time.makeCalendarDateRange(null)); // default calendar List<TimeCoord.Tinv> offsets = time.getTimeIntervals(); int n = offsets.size(); double[] values = new double[2 * n]; int count = 0; for (TimeCoord.Tinv offset : offsets) { values[count++] = offset.getBounds1(); values[count++] = offset.getBounds2(); } AttributeContainerHelper atts = new AttributeContainerHelper(time.getName()); atts.addAttribute(new Attribute(CDM.UNITS, time.getUnit())); atts.addAttribute(new Attribute(CF.STANDARD_NAME, CF.TIME)); atts.addAttribute(new Attribute(CDM.LONG_NAME, Grib.GRIB_VALID_TIME)); atts.addAttribute(new Attribute(CF.CALENDAR, ucar.nc2.time.Calendar.proleptic_gregorian.toString())); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(time.getName(), time.getTimeUdUnit(), Grib.GRIB_VALID_TIME, DataType.DOUBLE, AxisType.Time, atts, CoverageCoordAxis.DependenceType.independent, null, null, n, 0, 0, 0, values, this); builder.setSpacingFromValues(true); return new CoverageCoordAxis1D(builder); }
private CoverageCoordAxis makeRuntimeAuxCoord(CoordinateTimeAbstract time) { if (time.getTime2runtime() == null) return null; String refName = "ref" + time.getName(); int length = time.getSize(); double[] data = new double[length]; for (int i = 0; i < length; i++) data[i] = Double.NaN; int count = 0; CoordinateRuntime master = gribCollection.getMasterRuntime(); List<Double> masterOffsets = master.getOffsetsInTimeUnits(); for (int masterIdx : time.getTime2runtime()) { data[count++] = masterOffsets.get(masterIdx - 1); } AttributeContainerHelper atts = new AttributeContainerHelper(time.getName()); atts.addAttribute(new Attribute(CDM.UNITS, time.getTimeUdUnit())); atts.addAttribute(new Attribute(CF.STANDARD_NAME, CF.TIME_REFERENCE)); atts.addAttribute(new Attribute(CDM.LONG_NAME, Grib.GRIB_RUNTIME)); atts.addAttribute(new Attribute(CF.CALENDAR, ucar.nc2.time.Calendar.proleptic_gregorian.toString())); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(refName, master.getUnit(), Grib.GRIB_RUNTIME, DataType.DOUBLE, AxisType.RunTime, atts, CoverageCoordAxis.DependenceType.dependent, time.getName(), null, length, 0, 0, 0, data, this); builder.setSpacingFromValues(false); return new CoverageCoordAxis1D(builder); }
private CoverageCoordAxis makeRuntimeAuxCoord(CoordinateTime2D time2D, int ntimes) { CoordinateRuntime runtimeU = time2D.getRuntimeCoordinate(); List<Double> runOffsets = runtimeU.getOffsetsInTimeUnits(); double[] values = new double[ntimes]; int count = 0; for (int run = 0; run < time2D.getNruns(); run++) { CoordinateTimeAbstract timeCoord = time2D.getTimeCoordinate(run); for (int time = 0; time < timeCoord.getNCoords(); time++) values[count++] = runOffsets.get(run); } boolean isScalar = (time2D.getNruns() == 1); // this is the case of runtime[1] CoverageCoordAxis.DependenceType dependence = isScalar ? CoverageCoordAxis.DependenceType.scalar : CoverageCoordAxis.DependenceType.dependent; String refName = "ref" + time2D.getName(); AttributeContainerHelper atts = new AttributeContainerHelper(time2D.getName()); atts.addAttribute(new Attribute(CDM.UNITS, time2D.getTimeUdUnit())); atts.addAttribute(new Attribute(CF.STANDARD_NAME, CF.TIME_REFERENCE)); atts.addAttribute(new Attribute(CDM.LONG_NAME, Grib.GRIB_RUNTIME)); atts.addAttribute(new Attribute(CF.CALENDAR, ucar.nc2.time.Calendar.proleptic_gregorian.toString())); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(refName, time2D.getTimeUdUnit(), Grib.GRIB_RUNTIME, DataType.DOUBLE, AxisType.RunTime, atts, dependence, time2D.getName(), null, ntimes, 0, 0, 0, values, this); builder.setSpacingFromValues(false); return new CoverageCoordAxis1D(builder); }
return new CoverageCoordAxis1D(builder);
builder.setSpacingFromValues(time2D.isTimeInterval()); return new CoverageCoordAxis1D(builder);