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)
