@Nonnull private CoverageCoordAxisBuilder subsetValuesLatest() { int last = axis.getNcoords() - 1; double val = axis.getCoordMidpoint(last); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(axis); builder.subset(1, val, val, 0.0, makeValues(last)); try { builder.setRange(new Range(last, last)); } catch (InvalidRangeException e) { throw new RuntimeException(e); // cant happen } return builder; }
CoverageCoordAxisBuilder subset(String dependsOn, CoverageCoordAxis.Spacing spacing, int ncoords, double[] values) { assert values != null; if (dependsOn != null) { this.dependenceType = CoverageCoordAxis.DependenceType.dependent; setDependsOn(dependsOn); } this.spacing = spacing; this.ncoords = ncoords; this.reader = null; this.values = values; this.isSubset = true; return this; }
public void setSpacingFromValues(boolean isInterval) { if (isInterval) setSpacingFromIntervalValues(); else setSpacingFromPointValues(); }
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); }
@Override public CoverageCoordAxis copy() { return new CoverageCoordAxis1D(new CoverageCoordAxisBuilder(this)); }
shape[i] = proto.getShape(i); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(); builder.name = name; builder.units = proto.getUnits(); builder.attributes = atts; builder.dependenceType = dependenceType; builder.setDependsOn(dependsOn); builder.spacing = spacing; builder.ncoords = ncoords;
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()); } }
values[count++] = subset.nextDouble(); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(name, units, description, dataType, axisType, AttributeContainerHelper.filter(attributes, "_Coordinate"), dependenceType, getDependsOn(), spacing, n, values[0], values[n - 1], 0.0, values, reader); builder.setIsSubset(true); return new CoverageCoordAxis1D(builder); values[count++] = subset.nextDouble(); CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(name, units, description, dataType, axisType, AttributeContainerHelper.filter(attributes, "_Coordinate"), dependenceType, getDependsOn(), spacing, n / 2, values[0], values[n - 1], 0.0, values, reader); builder.setIsSubset(true); return new CoverageCoordAxis1D(builder);
CoverageCoordAxisBuilder runbuilder = new CoverageCoordAxisBuilder(runAxisSubset) .subset(null, CoverageCoordAxis.Spacing.irregularPoint, ncoords, runValues); // LOOK check for regular (in CovCoordAxis ?) CoverageCoordAxis1D runAxisSubset2 = new CoverageCoordAxis1D(runbuilder); CoverageCoordAxisBuilder timebuilder = new CoverageCoordAxisBuilder(timeOffset) .subset(runAxisSubset2.getName(), CoverageCoordAxis.Spacing.irregularPoint, ncoords, offsetValues); // aux coord (LOOK interval) ?? CoverageCoordAxis1D timeOffsetSubset = new TimeOffsetAxis(timebuilder);
private void setSpacingFromPointValues() { assert (values.length == ncoords); this.startValue = values[0]; this.endValue = values[ncoords - 1]; this.resolution = (ncoords == 1) ? 0.0 : (endValue - startValue) / (ncoords - 1); if (ncoords == 1) { this.spacing = CoverageCoordAxis.Spacing.regularPoint; values = null; return; } this.resolution = (endValue - startValue) / (ncoords - 1); Counters.Counter resol = new Counters.Counter("resol"); for (int i = 0; i < values.length - 1; i++) { double diff = values[i + 1] - values[i]; resol.count(diff); } Comparable resolMode = resol.getMode(); if (resolMode != null) this.resolution = ((Number) resolMode).doubleValue(); boolean isRegular = isRegular(resol); this.spacing = isRegular ? CoverageCoordAxis.Spacing.regularPoint : CoverageCoordAxis.Spacing.irregularPoint; if (isRegular) values = null; }
public Optional<TimeOffsetAxis> subsetFromTime(SubsetParams params, CalendarDate runDate) { CoordAxisHelper helper = new CoordAxisHelper(this); CoverageCoordAxisBuilder builder = null; if (params.isTrue(SubsetParams.timePresent)) { double offset = getOffsetInTimeUnits(runDate, CalendarDate.present()); builder = helper.subsetClosest(offset); } CalendarDate dateWanted = (CalendarDate) params.get(SubsetParams.time); if (dateWanted != null) { // convertFrom, convertTo double offset = getOffsetInTimeUnits(runDate, dateWanted); builder = helper.subsetClosest(offset); } Integer stride = (Integer) params.get(SubsetParams.timeStride); if (stride == null || stride < 0) stride = 1; CalendarDateRange dateRange = (CalendarDateRange) params.get(SubsetParams.timeRange); if (dateRange != null) { double min = getOffsetInTimeUnits(runDate, dateRange.getStart()); double max = getOffsetInTimeUnits(runDate, dateRange.getEnd()); Optional<CoverageCoordAxisBuilder> buildero = helper.subset(min, max, stride); if (buildero.isPresent()) builder = buildero.get(); else return Optional.empty(buildero.getErrorMessage()); } assert (builder != null); // all the offsets are reletive to rundate builder.setReferenceDate(runDate); return Optional.of(new TimeOffsetAxis(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); }
@Override public CoverageCoordAxis copy() { return new TimeAxis2DSwath(new CoverageCoordAxisBuilder(this)); }
CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(); builder.name = name; builder.units = units; builder.attributes = atts; builder.dependenceType = dependenceType; builder.setDependsOn(dependsOn); builder.spacing = spacing; builder.ncoords = ncoords; CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(); builder.name = name; builder.units = units; builder.attributes = dtCoordAxis.getAttributeContainer(); builder.dependenceType = dependenceType; builder.setDependsOn(dependsOn); builder.spacing = spacing; builder.ncoords = ncoords; builder.setDependsOn(dtCoordAxis.getDimension(0).getFullName()); // only the first dimension return ucar.nc2.util.Optional.of(new TimeAxis2DFmrc(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); }
boolean regular = isRegular(resol);
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); }
@Nonnull private CoverageCoordAxisBuilder subsetValuesClosest(double want) { int closest_index = findCoordElement(want, true); // bounded, always valid index CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(axis); if (axis.spacing == CoverageCoordAxis.Spacing.regularPoint) { double val = axis.getCoordMidpoint(closest_index); builder.subset(1, val, val, 0.0, null); } else if (axis.spacing == CoverageCoordAxis.Spacing.regularInterval) { double val1 = axis.getCoordEdge1(closest_index); double val2 = axis.getCoordEdge2(closest_index); builder.subset(1, val1, val2, val2-val1, null); } else { builder.subset(1, 0, 0, 0.0, makeValues(closest_index)); } try { builder.setRange(new Range(closest_index, closest_index)); } catch (InvalidRangeException e) { throw new RuntimeException(e); // cant happen } return builder; }
@Override public CoverageCoordAxis copy() { return new TimeOffsetAxis(new CoverageCoordAxisBuilder(this)); }
CoverageCoordAxisBuilder builder = new CoverageCoordAxisBuilder(); builder.name = name; builder.units = runAxisSubset.getUnits(); builder.attributes = atts; builder.dependenceType = CoverageCoordAxis.DependenceType.dependent; builder.setDependsOn(timeAxisSubset.getName());