def get_tile_coordinates(h, v): """ use pre-fetched lat and lon bounds to get coordinates for a single tile """ lat_start, lat_stop = SINUSOIDAL_VERTICAL[v] lon_start, lon_stop = SINUSOIDAL_HORIZONTAL[h] lat = podpac.clinspace(lat_start, lat_stop, 2400, name="lat") lon = podpac.clinspace(lon_start, lon_stop, 2400, name="lon") return podpac.Coordinates([lat, lon], crs=CRS)
def test_mask_defaults_bool_op(self): coords = podpac.Coordinates( [podpac.clinspace(0, 1, 4), podpac.clinspace(0, 1, 3)], dims=["lat", "lon"]) sine_node = Arange() a = sine_node.eval(coords).copy() # Less than node = Mask(source=sine_node, mask=sine_node, bool_op="<") output = node.eval(coords) b = a.copy() b.data[a.data < 1] = np.nan np.testing.assert_allclose(output, b) # Less than equal node = Mask(source=sine_node, mask=sine_node, bool_op="<=") output = node.eval(coords) b = a.copy() b.data[a.data <= 1] = np.nan np.testing.assert_allclose(output, b) # Greater than node = Mask(source=sine_node, mask=sine_node, bool_op=">") output = node.eval(coords) b = a.copy() b.data[a.data > 1] = np.nan np.testing.assert_allclose(output, b) # Greater than equal node = Mask(source=sine_node, mask=sine_node, bool_op=">=") output = node.eval(coords) b = a.copy() b.data[a.data >= 1] = np.nan np.testing.assert_allclose(output, b)
def test_eval_multiple_outputs(self): lat = clinspace(45, 66, 30, name="lat") lon = clinspace(-80, 70, 40, name="lon") kernel = [[1, 2, 1]] coords = Coordinates([lat, lon]) multi = Array(source=np.random.random(coords.shape + (2, )), coordinates=coords, outputs=["a", "b"]) node = Convolution(source=multi, kernel=kernel, kernel_dims=["lat", "lon"]) o1 = node.eval(Coordinates([lat, lon])) kernel = [[[1, 2]]] coords = Coordinates([lat, lon]) multi = Array(source=np.random.random(coords.shape + (2, )), coordinates=coords, outputs=["a", "b"]) node1 = Convolution(source=multi, kernel=kernel, kernel_dims=["lat", "lon", "output"], force_eval=True) node2 = Convolution(source=multi, kernel=kernel[0], kernel_dims=["lat", "lon"], force_eval=True) o1 = node1.eval(Coordinates([lat, lon])) o2 = node2.eval(Coordinates([lat, lon])) assert np.any(o2.data != o1.data)
def setup_method(self, method): self.coord_src = podpac.Coordinates([ podpac.clinspace(45, 0, 16), podpac.clinspace(-70, -65, 16), podpac.clinspace(0, 1, 2) ], dims=['lat', 'lon', 'time']) LON, LAT, TIME = np.meshgrid(self.coord_src['lon'].coordinates, self.coord_src['lat'].coordinates, self.coord_src['time'].coordinates) self.latSource = LAT self.lonSource = LON self.timeSource = TIME self.nasLat = Array(source=LAT.astype(float), native_coordinates=self.coord_src, interpolation='bilinear') self.nasLon = Array(source=LON.astype(float), native_coordinates=self.coord_src, interpolation='bilinear') self.nasTime = Array(source=TIME.astype(float), native_coordinates=self.coord_src, interpolation='bilinear') self.sources = np.array([self.nasLat, self.nasLon, self.nasTime])
def get_native_coordinates(self): return podpac.Coordinates([ podpac.crange('2010-01-01', '2018-01-01', '4,h'), podpac.clinspace(-180, 180, 6), podpac.clinspace(-80, -70, 6) ], dims=['time', 'lat', 'lon'])
def test_debuggable_source(self): with podpac.settings: podpac.settings["DEBUG"] = False lat = clinspace(45, 66, 30, name="lat") lon = clinspace(-80, 70, 40, name="lon") coords = Coordinates([lat, lon]) # normal version a = Arange() node = Convolution(source=a, kernel=[[1, 2, 1]], kernel_dims=["lat", "lon"]) node.eval(coords) assert node.source is a # debuggable podpac.settings["DEBUG"] = True a = Arange() node = Convolution(source=a, kernel=[[1, 2, 1]], kernel_dims=["lat", "lon"]) node.eval(coords) assert node.source is not a assert node._requested_coordinates == coords assert node.source._requested_coordinates is not None assert node.source._requested_coordinates != coords assert a._requested_coordinates is None
def setup_class(cls): cls.c1 = podpac.Coordinates( [podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=['lat_lon', 'time']) cls.c2 = podpac.Coordinates( [podpac.clinspace((0.5, 0.1), (1.5, 1.1), 15)], dims=['lat_lon']) cls.crds = [cls.c1, cls.c2]
def get_coordinates(self): return podpac.Coordinates( [["2018-01-01", "2018-01-03", "2018-01-05"], podpac.clinspace(0, 11, 12), podpac.clinspace(0, 11, 12)], dims=["time", "lat", "lon"], )
def test_extra_kernel_dims(self): lat = clinspace(45, 66, 8, name="lat") lon = clinspace(-80, 70, 16, name="lon") coords = Coordinates([lat, lon]) node = Convolution(source=Arange(), kernel=[[[1, 2, 1]]], kernel_dims=["time", "lat", "lon"]) o = node.eval(coords)
def test_eval(self): lat = clinspace(45, 66, 30, name="lat") lon = clinspace(-80, 70, 40, name="lon") time = crange("2017-09-01", "2017-10-31", "1,D", name="time") kernel1d = [1, 2, 1] kernel2d = [[1, 2, 1]] kernel3d = [[[1, 2, 1]]] node1d = Convolution(source=Arange(), kernel=kernel1d, kernel_dims=["time"]) node2d = Convolution(source=Arange(), kernel=kernel2d, kernel_dims=["lat", "lon"]) node3d = Convolution(source=Arange(), kernel=kernel3d, kernel_dims=["lon", "lat", "time"]) o = node1d.eval(Coordinates([time])) o = node2d.eval(Coordinates([lat, lon])) o = node3d.eval(Coordinates([lat, lon, time])) with pytest.raises( ValueError, match="Kernel dims must contain all of the dimensions in source but not all of " ): node2d.eval(Coordinates([lat, lon, time])) with pytest.raises( ValueError, match="Kernel dims must contain all of the dimensions in source but not all of " ): node2d.eval(Coordinates([lat, time]))
def setup_module(module): global COORDS COORDS = podpac.Coordinates([ "2017-09-01", podpac.clinspace(45, 66, 4), podpac.clinspace(-80, -70, 5) ], dims=["time", "lat", "lon"])
def test_eval_with_output_argument(self): lat = clinspace(45, 66, 30, name="lat") lon = clinspace(-80, 70, 40, name="lon") coords = Coordinates([lat, lon]) node = Convolution(source=Arange(), kernel=[[1, 2, 1]], kernel_dims=["lat", "lon"]) a = node.create_output_array(coords) o = node.eval(coords, output=a) assert_array_equal(a, o)
def test_extra_coord_dims(self): lat = clinspace(-0.25, 1.25, 7, name="lat") lon = clinspace(-0.125, 1.125, 11, name="lon") time = ["2012-05-19", "2016-01-31", "2018-06-20"] coords = Coordinates([lat, lon, time], dims=["lat", "lon", "time"]) source = Array(source=np.random.random(coords.drop("time").shape), coordinates=coords.drop("time")) node = Convolution(source=source, kernel=[[-1, 2, -1]], kernel_dims=["lat", "lon"], force_eval=True) o = node.eval(coords) assert np.all([d in ["lat", "lon"] for d in o.dims])
def test_eval_uniform(self): node = OGR(source=self.source, driver=self.driver, layer=self.layer, attribute=self.attribute) coords = podpac.Coordinates( [podpac.clinspace(43, 44, 10), podpac.clinspace(-73, -72, 10)], dims=["lat", "lon"]) output = node.eval(coords)
def test_eval_nan(self): lat = clinspace(45, 66, 30, name="lat") lon = clinspace(-80, 70, 40, name="lon") coords = Coordinates([lat, lon]) data = np.ones(coords.shape) data[10, 10] = np.nan source = Array(source=data, coordinates=coords) node = Convolution(source=source, kernel=[[1, 2, 1]], kernel_dims=["lat", "lon"]) o = node.eval(coords[8:12, 7:13])
def test_eval_extra_dims(self): node = OGRRaw(source=self.source, driver=self.driver, layer=self.layer, attribute=self.attribute) coords = podpac.Coordinates([ podpac.clinspace(43, 44, 10), podpac.clinspace(-73, -72, 10), "2018-01-01" ], dims=["lat", "lon", "time"]) output = node.eval(coords)
def test_coordinates(self): node = TileCompositor() with pytest.raises(NotImplementedError): node.coordinates node = MockTileCompositor() assert node.coordinates == podpac.Coordinates( [["2018-01-01", "2018-01-03", "2018-01-05"], podpac.clinspace(0, 11, 12), podpac.clinspace(0, 11, 12)], dims=["time", "lat", "lon"], )
def setup_module(): global coords, source, data coords = podpac.Coordinates( [podpac.clinspace(0, 1, 10), podpac.clinspace(0, 1, 10), podpac.crange('2018-01-01', '2018-01-10', '1,D')], dims=['lat', 'lon', 'time']) a = np.random.random(coords.shape) a[3, 0, 0] = np.nan a[0, 3, 0] = np.nan a[0, 0, 3] = np.nan source = Array(source=a, native_coordinates=coords) data = source.eval(coords)
class MyDataSource(DataSource): coordinates = podpac.Coordinates( [ podpac.crange("2010-01-01", "2018-01-01", "4,h"), podpac.clinspace(-180, 180, 6), podpac.clinspace(-80, -70, 6), ], dims=["time", "lat", "lon"], ) def get_data(self, coordinates, slc): node = Arange() return node.eval(coordinates)
def get_terrain_tiles(which): # create coordinates to get tiles node = TerrainTiles(tile_format='geotiff', zoom=5) coords = Coordinates( [clinspace(75, -60, 1000), clinspace(-155, -35, 1000)], dims=['lat', 'lon']) # evaluate node ev = node.eval(coords) data = np.asarray(ev.data) return data
def test_masked_val(self): coords = podpac.Coordinates( [podpac.clinspace(0, 1, 4), podpac.clinspace(0, 1, 3)], dims=["lat", "lon"]) sine_node = Arange() a = sine_node.eval(coords).copy() a.data[a.data == 1] = -9999 node = Mask(source=sine_node, mask=sine_node, masked_val=-9999) output = node.eval(coords) np.testing.assert_allclose(output, a)
def _eval(self, coordinates, output=None, _selector=None): if "lat" not in coordinates.udims or "lon" not in coordinates.udims: raise RuntimeError("OGR source requires lat and lon dims") requested_coordinates = coordinates coordinates = coordinates.udrop(["time", "alt"], ignore_missing=True) if coordinates.size == 1 or "lat_lon" in coordinates or "lon_lat" in coordinates: # point or points eps = 1e-6 data = np.empty(coordinates.size) for i, (lat, lon) in enumerate( zip(coordinates["lat"].coordinates, coordinates["lon"].coordinates)): geotransform = [ lon - eps / 2.0, eps, 0.0, lat - eps / 2.0, 0.0, -1.0 * eps ] data[i] = self._get_data(1, 1, geotransform) data = data.reshape(coordinates.shape) else: # resample non-uniform coordinates if necessary if not coordinates["lat"].is_uniform: coordinates["lat"] = clinspace(coordinates["lat"].bounds[0], coordinates["lat"].bounds[1], coordinates["lat"].size, name="lat") if not coordinates["lon"].is_uniform: coordinates["lon"] = clinspace(coordinates["lon"].bounds[0], coordinates["lon"].bounds[1], coordinates["lon"].size, name="lon") # evaluate uniform grid data = self._get_data(coordinates["lon"].size, coordinates["lat"].size, coordinates.geotransform) if output is None: output = self.create_output_array(coordinates, data=data) else: output.data[:] = data # nan values output.data[np.isin(output.data, self.nan_vals)] = self.nan_val if settings["DEBUG"]: self._requested_coordinates = requested_coordinates self._evaluated_coordinates = coordinates return output
def test_eval_level_3(self): # level 3 access c = podpac.Coordinates( [ podpac.clinspace(-82, -81, 10), podpac.clinspace(38, 39, 10), podpac.clinspace("2015-07-06", "2015-07-08", 10), ], dims=["lon", "lat", "time"], ) node = podpac.datalib.smap_egi.SMAP(product="SPL3SMP_AM") output = node.eval(c) print(output)
def test_coords_order(self): lat = clinspace(-0.25, 1.25, 7, name="lat") lon = clinspace(-0.125, 1.125, 11, name="lon") coords = Coordinates([lat, lon]) lat = clinspace(0, 1, 5, name="lat") lon = clinspace(0, 1, 9, name="lon") coords1 = Coordinates([lat, lon]) coords2 = Coordinates([lon, lat]) source = Array(source=np.random.random(coords.shape), coordinates=coords) node = Convolution(source=source, kernel=[[-1, 2, -1]], kernel_dims=["lat", "lon"], force_eval=True) o1 = node.eval(coords1) o2 = node.eval(coords2) assert np.all(o2.data == o1.data.T)
def test_tile_coordinates_index(self): class MyTile(UniformTileMixin, DataSource): pass grid = MockTileCompositor() tile = MyTile(grid=grid, tile=(1, 1, 0)) assert tile.width == grid.tile_width assert tile.coordinates == podpac.Coordinates( [ "2018-01-03", podpac.clinspace(4, 7, 4), podpac.clinspace(0, 3, 4) ], dims=["time", "lat", "lon"])
def test_partial_source_convolution(self): lat = clinspace(-0.25, 1.25, 7, name="lat") lon = clinspace(-0.125, 1.125, 11, name="lon") time = ["2012-05-19", "2016-01-31", "2018-06-20"] coords = Coordinates([lat, lon, time], dims=["lat", "lon", "time"]) source = Array(source=np.random.random(coords.shape), coordinates=coords) node = Convolution(source=source, kernel=[[-1, 2, -1]], kernel_dims=["lat", "lon"], force_eval=True) o = node.eval(coords[:, 1:-1, :]) expected = source.source[:, 1: -1] * 2 - source.source[:, 2:] - source.source[:, : -2] assert np.abs(o.data - expected).max() < 1e-14
def test_create_output_array_crs(self): crs = "+proj=merc +lat_ts=56.5 +ellps=GRS80" c = podpac.Coordinates( [podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=["lat_lon", "time"], crs=crs) node = Node() output = node.create_output_array(c) assert output.crs == crs
def test_composite_stacked_unstacked(self): anative = podpac.Coordinates( [podpac.clinspace((0, 1), (1, 2), size=3)], dims=["lat_lon"]) bnative = podpac.Coordinates( [podpac.clinspace(-2, 3, 3), podpac.clinspace(-1, 4, 3)], dims=["lat", "lon"]) a = Array(source=np.random.rand(3), coordinates=anative) b = Array(source=np.random.rand(3, 3) + 2, coordinates=bnative) coords = podpac.Coordinates( [podpac.clinspace(-3, 4, 32), podpac.clinspace(-2, 5, 32)], dims=["lat", "lon"]) node = OrderedCompositor(sources=[a, b], interpolation="nearest") o = node.eval(coords) # Check that both data sources are being used in the interpolation assert np.any(o.data >= 2) assert np.any(o.data <= 1)
def test_create_output_array_units(self): c = podpac.Coordinates( [podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=["lat_lon", "time"]) node = Node(units="meters") output = node.create_output_array(c) assert isinstance(output, UnitsDataArray) from podpac.core.units import ureg as _ureg assert output.units == _ureg.meters
def test_create_output_array_dtype(self): c = podpac.Coordinates( [podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=["lat_lon", "time"]) node = Node(dtype=bool) output = node.create_output_array(c, data=0) assert isinstance(output, UnitsDataArray) assert output.shape == c.shape assert output.dtype == node.dtype assert output.crs == c.crs assert np.all(~output)