diff --git a/.gitignore b/.gitignore
index d86e4ff..d299c38 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
+# Local test data
+/xcube-viewer/
+
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
diff --git a/README.md b/README.md
index 7aefc5c..1eafbf7 100644
--- a/README.md
+++ b/README.md
@@ -36,8 +36,15 @@ pytest
```
By default, this will run all unit and integration tests. To run only the unit test
suite, use:
+
+```shell
+pytest tests
+```
+
+To run tests and generate a coverage report, use:
+
```shell
-pytest tests/
+pytest --cov xarray_eopf --cov-report html tests
```
### Documentation
diff --git a/docs/api.md b/docs/api.md
new file mode 100644
index 0000000..d9a9847
--- /dev/null
+++ b/docs/api.md
@@ -0,0 +1,3 @@
+## Backend API Reference
+
+::: xarray_eopf.backend.EopfBackend
diff --git a/docs/guide.md b/docs/guide.md
new file mode 100644
index 0000000..2d049a5
--- /dev/null
+++ b/docs/guide.md
@@ -0,0 +1,117 @@
+The xarray backend for EOPF data products `"eopf-zarr"` has two modes of operation,
+namely _analysis mode_ (the default) and _native mode_, which are described in
+the following.
+
+## Analysis Mode
+
+This mode aims at representing the EOPF data products in an analysis-ready and
+convenient form using the `xarray` data models `DataTree` and `Dataset`.
+For this reason, it is the default mode of operation when using the `"eopf-zarr"`
+backend.
+
+The data products are provided in this mode use a unified grid mapping
+for all their data variables. This means that selected variables are
+spatially up-scaled or down-scaled as needed, so that the dataset can use a
+single shared pair of `x` and `y` coordinates in the returned datasets.
+
+### Function `open_dataset()`
+
+Synopsis:
+
+```python
+dataset = xr.open_dataset(
+ filename_or_obj,
+ engine="eopf-zarr",
+ op_mode="analysis",
+ **kwargs
+)
+```
+
+Returns a EOPF data product from Sentinel-1, -2, or -3 in a analysis-ready, convenient
+form. All bands and quality flags are resampled to a unified, user-provided resolution.
+
+Parameters `**params`:
+
+- `resolution`: Target resolution for all spatial data variables / bands.
+ Must be one of `10`, `20`, or `60`.
+- `spline_order`: Spline order to be used for resampling
+ spatial data variables / bands.
+ Must be one of `0` (nearest neighbor), `1` (linear), `2` (bi-linear), or
+ `3` (cubic).
+- `variables`: Variables to include in the dataset. Can be a name or regex pattern
+ or iterable of the latter.
+- `product_type`: Product type name, such as `"S2B_MSIL1C"`.
+ Only required if `filename_or_obj` is not a path or URL
+ that refers to a product path adhering to EOPF naming conventions.
+
+
+### Function `open_datatree()`
+
+Synopsis:
+
+```python
+datatree = xr.open_datatree(
+ filename_or_obj,
+ engine="eopf-zarr",
+ op_mode="analysis",
+ **kwargs
+)
+```
+
+This function is currently not implemented for the analysis mode
+and will raise a `NotImplementedError`.
+
+## Native Mode
+
+The aim of this mode is to represent EOPF data products without modification
+using the `xarray` data models `DataTree` and `Dataset`. Content and structure
+of the original data products are preserved to a maximum extend.
+
+### Function `open_datatree()`
+
+Synopsis:
+
+```python
+datatree = xr.open_datatree(
+ filename_or_obj,
+ engine="eopf-zarr",
+ op_mode="native",
+ **kwargs
+)
+```
+
+Opens a data product as-is including Zarr groups and returns a data tree object.
+
+This function currently returns the result of calling
+`xr.open_datatree(filename_or_obj, engine="zarr", **kwargs)`.
+
+### Function `open_dataset()`
+
+Synopsis:
+
+```python
+dataset = xr.open_dataset(
+ filename_or_obj,
+ engine="eopf-zarr",
+ op_mode="native",
+ **kwargs
+)
+```
+
+Returns a "flattened" version of the data tree returned by `xr.open_datatree()`
+in native mode. Groups are removed by turning their contents into individual datasets
+and merging them into one. Variables and dimensions are prefixed using their original
+group paths to make them unique in the returned dataset. For example, the variable
+`b02` found in the group `measurements/reflectance/r10m` will be renamed to
+`measurements_reflectance_r10m_b02` using the default underscore group separator.
+The separator character is configurable by setting the `group_sep` parameter.
+
+The main use case for this function is to allow passing an EOPF data product
+where the type `xr.Dataset` is expected (not `xr.DataTree`) and where the naming of
+dimensions and variables is not an issue.
+
+Parameters `**params`:
+
+- `group_sep`: Separator string used to concatenate groups names
+ to create prefixes for unique variable and dimension names.
+ Defaults to the underscore character (`"_"`).
diff --git a/docs/index.md b/docs/index.md
index 5e37877..1028aae 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -30,11 +30,11 @@ object including groups:
The backend supports two distinct modes of operation, `"native"` and `"analysis-ready"`:
-- `mode="native"` - using the _native mode_, the returned `Dataset` or `DataTree`
+- `op_mode="native"` - using the _native mode_, the returned `Dataset` or `DataTree`
objects try to serve as a 1:1 representation of the actual Zarr product structure and
content with either none or minimal preprocessing applied.
-- `mode="analysis"` - using the _analysis mode_, the returned `Dataset`
+- `op_mode="analysis"` - using the _analysis mode_, the returned `Dataset`
or `DataTree` objects attempt to be user-friendly and analysis-ready to a maximum
extend. Certain preprocessing steps will be applied depending on the specific
Sentinel product towards an analysis-ready data model and content. For example,
diff --git a/environment.yml b/environment.yml
index 110c505..b3d201a 100644
--- a/environment.yml
+++ b/environment.yml
@@ -6,9 +6,12 @@ dependencies:
# Library Dependencies
- aiohttp
- dask
+ - dask-image
- fsspec
- numpy
+ - pyproj
- requests
+ - s3fs
- xarray >=2024.10
- zarr >=2,<3.0
# Development Dependencies - Tools
diff --git a/examples/open-sen1-native.ipynb b/examples/open-sen1-native.ipynb
new file mode 100644
index 0000000..4aa12c9
--- /dev/null
+++ b/examples/open-sen1-native.ipynb
@@ -0,0 +1,28757 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "cf494469-0283-4a89-904d-ded017c4bbbf",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CPU times: total: 1.12 s\n",
+ "Wall time: 2.71 s\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%time\n",
+ "import matplotlib.pyplot as plt\n",
+ "import xarray as xr"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "95cdbdbb-edd8-4ae4-b9ac-6eecd36bc89e",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "## Sentinel-1 GRD"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "3ade1cd0-0fa9-4f14-9c03-3f1ff0f26042",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CPU times: total: 0 ns\n",
+ "Wall time: 3.34 μs\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%time\n",
+ "path = (\n",
+ " \"s3://e05ab01a9d56408d82ac32d69a5aae2a:sample-data/tutorial_data/\"\n",
+ " \"cpm_v253/S1A_IW_GRDH_1SDV_20240201T164915_20240201T164940_052368_065517_750E.zarr\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "a4c6364b-5573-4cfd-9426-3f68aa8fb469",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CPU times: total: 1.48 s\n",
+ "Wall time: 26.5 s\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'estimated roll angle for this antenna pattern', 'units': 'degrees'}
units :
degrees
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
terrain_height
(azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'mean terrain height in range for this antenna pattern (in metres above the ellipsoid) for the given zero-doppler azimuth time', 'units': 'm'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'ground range origin used for ground range calculation', 'units': 'm'}
units :
m
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
112 B
\n",
+ "
112 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(28,)
\n",
+ "
(28,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
grsr_coefficients
(azimuth_time, degree)
float32
dask.array<chunksize=(28, 9), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f8', 'long_name': 'coefficients to convert from ground range to slant range, slant range = s0 + s1(gr-gr0) + s2(gr-gr0)^2 + s3(gr-gr0)^3 + s4(gr-gr0)^4...+ sN(gr-gr0)^N where gr is the ground range distance to the desired pixel and N is the number of coefficients in the array minus one'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
0.98 kiB
\n",
+ "
0.98 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(28, 9)
\n",
+ "
(28, 9)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
slant_range_time
(azimuth_time)
float32
dask.array<chunksize=(28,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time to first range sample', 'units': 's'}
units :
s
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
112 B
\n",
+ "
112 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(28,)
\n",
+ "
(28,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
sr0
(azimuth_time)
float32
dask.array<chunksize=(28,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'slant range origin used for ground range calculation', 'units': 'm'}
units :
m
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
112 B
\n",
+ "
112 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(28,)
\n",
+ "
(28,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
srgr_coefficients
(azimuth_time, degree)
float32
dask.array<chunksize=(28, 9), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f8', 'long_name': 'coefficients to convert from slant range to ground range, ground range = g0 + g1(sr-sr0) + g2(sr-sr0)^2 + g3(sr-sr0)^3 + g4(sr-sr0)^4...+ gN(sr-sr0)^N where sr is the slant range distance to the desired pixel and N is the number of coefficients in the array minus one'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f4', 'long_name': 'doppler centroid estimated from data, expressed as polynomial with 5 coefficients: doppler centroid = d0 + d1(tsr-t0) + d2(tsr-t0)^2 + d3(tsr-t0)^3 + d4(tsr-t0)^4, where tsr = 2-way slant range time'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
324 B
\n",
+ "
324 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 3)
\n",
+ "
(27, 3)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
data_dc_rms_error
(azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'RMS error of the doppler centroid estimate (calculated as the average of the individual RMS residual errors between input fine doppler centroid estimates and the fitted polynomial; if the doppler centroid was not estimated from data, this is set to 0)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
data_dc_rms_error_above_threshold
(azimuth_time)
bool
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
27 B
\n",
+ "
27 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
fine_dce_azimuth_start_time
(azimuth_time)
bool
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
27 B
\n",
+ "
27 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
fine_dce_azimuth_stop_time
(azimuth_time)
bool
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
27 B
\n",
+ "
27 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
geometry_dc_polynomial
(azimuth_time, degree)
float32
dask.array<chunksize=(27, 3), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f4', 'long_name': 'doppler centroid estimated from orbit, expressed as polynomial with 5 coefficients: doppler centroid = d0 + d1(tsr-t0) + d2(tsr-t0)^2 + d3(tsr-t0)^3 + d4(tsr-t0)^4, where tsr = 2-way slant range time'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
324 B
\n",
+ "
324 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 3)
\n",
+ "
(27, 3)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
t0
(azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time origin for doppler centroid estimate', 'units': 's'}
{'coordinates': ['azimuth_time', 'line'], 'dimensions': ['azimuth_time'], 'dtype': '<u4', 'long_name': 'reference image measurement data set sample to which this geolocation grid point applies'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
840 B
\n",
+ "
840 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(210,)
\n",
+ "
(210,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
slant_range_time
(azimuth_time)
float32
dask.array<chunksize=(210,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time to grid point', 'units': 's'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if |pgProductAmplitude - modelPgProductAmplitude| < maxPgAmpErrorThreshold and |pgProductPhase - modelPgProductPhase| < maxPgPhaseErrorThreshold, false otherwise; PG product values can only be calculated and validated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this flag is set to false for every replica record'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
15 B
\n",
+ "
15 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
cross_correlation_peak_location
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'peak location of cross-correlation function between the reconstructed replica and the nominal replica', 'units': 'samples'}
units :
samples
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
cross_correlation_pslr
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'peak side lobe ratio of replica cross-correlation function between the reconstructed replica and the nominal replica', 'units': 'dB'}
units :
dB
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
internal_time_delay
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'internal time delay representing the calculated deviation of the location of this PG replica from the location of the transmitted pulse or nominal PG replica', 'units': 's'}
units :
s
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
model_pg_product_amplitude
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'PG product amplitude value from the input PG product model'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
model_pg_product_phase
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'PG product phase value from the input PG product model', 'units': 'radians'}
units :
radians
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
pg_product_amplitude
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'amplitude of the power gain product derived from this replica (the amplitude value is:abs(1/PG * meanRxCalPow(swath1)/meanRxCalPow(swathn)) where abs() is the absolute value function for a complex number, meanRxCalPow(swath1) is the mean rx calibration power of swath 1, meanRxCalPow(swathn) is the mean rx calibration power of the current swath; PG product values can only be calculated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this value is set to the default value of 1.0)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
pg_product_phase
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'phase of the power gain product derived from this replica [radians] (the phase value is:arg(1/PG * meanRxCalPow(swath1)/meanRxCalPow(swathn)) where arg() is the phase value function for a complex number, meanRxCalPow(swath1) is the mean rx calibration power of swath 1, meanRxCalPow(swathn) is the mean rx calibration power of the current swath; PG product values can only be calculated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this value is set to the default value of 0.0)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
reconstructed_replica_valid_flag
(azimuth_time)
bool
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if a valid peak location was found in the cross-correlation between the nominal PG replica and this extracted PG replica, false otherwise'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
15 B
\n",
+ "
15 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
relative_pg_product_valid_flag
(azimuth_time)
bool
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if |pgProductAmplitude - meanPgProductAmplitude| < pgAmpStdFractionThreshold * stdPgProductAmplitude and |pgProductPhase - meanPgProductPhase| < pgPhaseStdFractionThreshold * stdPgProductPhase, false otherwise; PG product values can only be calculated and validated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this flag is set to false for every replica record'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'average terrain height above ellipsoid, the value is the average height in the range direction for the given zero-doppler azimuth time', 'units': 'm'}
image line at which the calibration vector applies
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
pixel
(ground_range)
int32
dask.array<chunksize=(663,), meta=np.ndarray>
dimensions :
['ground_range']
dtype :
<u4
long_name :
image pixel at which the calibration vector applies (this array contains the count attribute number of integer values (i.e. one value per point in the noise vector); the maximum length of this array is one value for every pixel in an image line, however in general the vector is subsampled)
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
2.59 kiB
\n",
+ "
2.59 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(663,)
\n",
+ "
(663,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
beta_nought
(azimuth_time, ground_range)
float32
dask.array<chunksize=(27, 663), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'beta nought calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
69.93 kiB
\n",
+ "
69.93 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 663)
\n",
+ "
(27, 663)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
dn
(azimuth_time, ground_range)
float32
dask.array<chunksize=(27, 663), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'digital number calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
69.93 kiB
\n",
+ "
69.93 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 663)
\n",
+ "
(27, 663)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
gamma
(azimuth_time, ground_range)
float32
dask.array<chunksize=(27, 663), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'gamma calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
69.93 kiB
\n",
+ "
69.93 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 663)
\n",
+ "
(27, 663)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
sigma_nought
(azimuth_time, ground_range)
float32
dask.array<chunksize=(27, 663), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'sigma nought calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<u4', 'long_name': 'number of noise lines used to calculate the noise correction factor'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'estimated roll angle for this antenna pattern', 'units': 'degrees'}
units :
degrees
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
terrain_height
(azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'mean terrain height in range for this antenna pattern (in metres above the ellipsoid) for the given zero-doppler azimuth time', 'units': 'm'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'ground range origin used for ground range calculation', 'units': 'm'}
units :
m
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
112 B
\n",
+ "
112 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(28,)
\n",
+ "
(28,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
grsr_coefficients
(azimuth_time, degree)
float32
dask.array<chunksize=(28, 9), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f8', 'long_name': 'coefficients to convert from ground range to slant range, slant range = s0 + s1(gr-gr0) + s2(gr-gr0)^2 + s3(gr-gr0)^3 + s4(gr-gr0)^4...+ sN(gr-gr0)^N where gr is the ground range distance to the desired pixel and N is the number of coefficients in the array minus one'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
0.98 kiB
\n",
+ "
0.98 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(28, 9)
\n",
+ "
(28, 9)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
slant_range_time
(azimuth_time)
float32
dask.array<chunksize=(28,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time to first range sample', 'units': 's'}
units :
s
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
112 B
\n",
+ "
112 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(28,)
\n",
+ "
(28,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
sr0
(azimuth_time)
float32
dask.array<chunksize=(28,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'slant range origin used for ground range calculation', 'units': 'm'}
units :
m
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
112 B
\n",
+ "
112 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(28,)
\n",
+ "
(28,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
srgr_coefficients
(azimuth_time, degree)
float32
dask.array<chunksize=(28, 9), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f8', 'long_name': 'coefficients to convert from slant range to ground range, ground range = g0 + g1(sr-sr0) + g2(sr-sr0)^2 + g3(sr-sr0)^3 + g4(sr-sr0)^4...+ gN(sr-sr0)^N where sr is the slant range distance to the desired pixel and N is the number of coefficients in the array minus one'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f4', 'long_name': 'doppler centroid estimated from data, expressed as polynomial with 5 coefficients: doppler centroid = d0 + d1(tsr-t0) + d2(tsr-t0)^2 + d3(tsr-t0)^3 + d4(tsr-t0)^4, where tsr = 2-way slant range time'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
324 B
\n",
+ "
324 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 3)
\n",
+ "
(27, 3)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
data_dc_rms_error
(azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'RMS error of the doppler centroid estimate (calculated as the average of the individual RMS residual errors between input fine doppler centroid estimates and the fitted polynomial; if the doppler centroid was not estimated from data, this is set to 0)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
data_dc_rms_error_above_threshold
(azimuth_time)
bool
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
27 B
\n",
+ "
27 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
fine_dce_azimuth_start_time
(azimuth_time)
bool
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
27 B
\n",
+ "
27 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
fine_dce_azimuth_stop_time
(azimuth_time)
bool
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
27 B
\n",
+ "
27 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
geometry_dc_polynomial
(azimuth_time, degree)
float32
dask.array<chunksize=(27, 3), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f4', 'long_name': 'doppler centroid estimated from orbit, expressed as polynomial with 5 coefficients: doppler centroid = d0 + d1(tsr-t0) + d2(tsr-t0)^2 + d3(tsr-t0)^3 + d4(tsr-t0)^4, where tsr = 2-way slant range time'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
324 B
\n",
+ "
324 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 3)
\n",
+ "
(27, 3)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
t0
(azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time origin for doppler centroid estimate', 'units': 's'}
{'coordinates': ['azimuth_time', 'line'], 'dimensions': ['azimuth_time'], 'dtype': '<u4', 'long_name': 'reference image measurement data set sample to which this geolocation grid point applies'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
840 B
\n",
+ "
840 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(210,)
\n",
+ "
(210,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
slant_range_time
(azimuth_time)
float32
dask.array<chunksize=(210,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time to grid point', 'units': 's'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if |pgProductAmplitude - modelPgProductAmplitude| < maxPgAmpErrorThreshold and |pgProductPhase - modelPgProductPhase| < maxPgPhaseErrorThreshold, false otherwise; PG product values can only be calculated and validated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this flag is set to false for every replica record'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
15 B
\n",
+ "
15 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
cross_correlation_peak_location
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'peak location of cross-correlation function between the reconstructed replica and the nominal replica', 'units': 'samples'}
units :
samples
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
cross_correlation_pslr
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'peak side lobe ratio of replica cross-correlation function between the reconstructed replica and the nominal replica', 'units': 'dB'}
units :
dB
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
internal_time_delay
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'internal time delay representing the calculated deviation of the location of this PG replica from the location of the transmitted pulse or nominal PG replica', 'units': 's'}
units :
s
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
model_pg_product_amplitude
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'PG product amplitude value from the input PG product model'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
model_pg_product_phase
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'PG product phase value from the input PG product model', 'units': 'radians'}
units :
radians
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
pg_product_amplitude
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'amplitude of the power gain product derived from this replica (the amplitude value is:abs(1/PG * meanRxCalPow(swath1)/meanRxCalPow(swathn)) where abs() is the absolute value function for a complex number, meanRxCalPow(swath1) is the mean rx calibration power of swath 1, meanRxCalPow(swathn) is the mean rx calibration power of the current swath; PG product values can only be calculated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this value is set to the default value of 1.0)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
pg_product_phase
(azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'phase of the power gain product derived from this replica [radians] (the phase value is:arg(1/PG * meanRxCalPow(swath1)/meanRxCalPow(swathn)) where arg() is the phase value function for a complex number, meanRxCalPow(swath1) is the mean rx calibration power of swath 1, meanRxCalPow(swathn) is the mean rx calibration power of the current swath; PG product values can only be calculated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this value is set to the default value of 0.0)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
reconstructed_replica_valid_flag
(azimuth_time)
bool
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if a valid peak location was found in the cross-correlation between the nominal PG replica and this extracted PG replica, false otherwise'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
15 B
\n",
+ "
15 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
relative_pg_product_valid_flag
(azimuth_time)
bool
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if |pgProductAmplitude - meanPgProductAmplitude| < pgAmpStdFractionThreshold * stdPgProductAmplitude and |pgProductPhase - meanPgProductPhase| < pgPhaseStdFractionThreshold * stdPgProductPhase, false otherwise; PG product values can only be calculated and validated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this flag is set to false for every replica record'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'average terrain height above ellipsoid, the value is the average height in the range direction for the given zero-doppler azimuth time', 'units': 'm'}
image line at which the calibration vector applies
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
pixel
(ground_range)
int32
dask.array<chunksize=(663,), meta=np.ndarray>
dimensions :
['ground_range']
dtype :
<u4
long_name :
image pixel at which the calibration vector applies (this array contains the count attribute number of integer values (i.e. one value per point in the noise vector); the maximum length of this array is one value for every pixel in an image line, however in general the vector is subsampled)
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
2.59 kiB
\n",
+ "
2.59 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(663,)
\n",
+ "
(663,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
beta_nought
(azimuth_time, ground_range)
float32
dask.array<chunksize=(27, 663), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'beta nought calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
69.93 kiB
\n",
+ "
69.93 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 663)
\n",
+ "
(27, 663)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
dn
(azimuth_time, ground_range)
float32
dask.array<chunksize=(27, 663), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'digital number calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
69.93 kiB
\n",
+ "
69.93 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 663)
\n",
+ "
(27, 663)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
gamma
(azimuth_time, ground_range)
float32
dask.array<chunksize=(27, 663), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'gamma calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
69.93 kiB
\n",
+ "
69.93 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 663)
\n",
+ "
(27, 663)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
sigma_nought
(azimuth_time, ground_range)
float32
dask.array<chunksize=(27, 663), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'sigma nought calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<u4', 'long_name': 'number of noise lines used to calculate the noise correction factor'}
image line at which the calibration vector applies
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_quality_calibration_pixel
(VH_quality_calibration_ground_range)
int32
dask.array<chunksize=(663,), meta=np.ndarray>
dimensions :
['ground_range']
dtype :
<u4
long_name :
image pixel at which the calibration vector applies (this array contains the count attribute number of integer values (i.e. one value per point in the noise vector); the maximum length of this array is one value for every pixel in an image line, however in general the vector is subsampled)
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
2.59 kiB
\n",
+ "
2.59 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(663,)
\n",
+ "
(663,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_quality_noise_azimuth_time
(VH_quality_noise_azimuth_time)
datetime64[ns]
2024-02-01T16:46:17.009484 ... 2...
_eopf_attrs :
{'_eopf_decode_datetime64': 'datetime64[ns]'}
dimensions :
['azimuth_time']
dtype :
<M8[us]
long_name :
zero doppler azimuth time at which noise vector applies
image line at which the calibration vector applies
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_quality_calibration_pixel
(VV_quality_calibration_ground_range)
int32
dask.array<chunksize=(663,), meta=np.ndarray>
dimensions :
['ground_range']
dtype :
<u4
long_name :
image pixel at which the calibration vector applies (this array contains the count attribute number of integer values (i.e. one value per point in the noise vector); the maximum length of this array is one value for every pixel in an image line, however in general the vector is subsampled)
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
2.59 kiB
\n",
+ "
2.59 kiB
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(663,)
\n",
+ "
(663,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_quality_noise_azimuth_time
(VV_quality_noise_azimuth_time)
datetime64[ns]
2024-02-01T16:46:17.009484 ... 2...
_eopf_attrs :
{'_eopf_decode_datetime64': 'datetime64[ns]'}
dimensions :
['azimuth_time']
dtype :
<M8[us]
long_name :
zero doppler azimuth time at which noise vector applies
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'estimated roll angle for this antenna pattern', 'units': 'degrees'}
units :
degrees
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_antenna_pattern_terrain_height
(VH_conditions_antenna_pattern_azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'mean terrain height in range for this antenna pattern (in metres above the ellipsoid) for the given zero-doppler azimuth time', 'units': 'm'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'ground range origin used for ground range calculation', 'units': 'm'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f8', 'long_name': 'coefficients to convert from ground range to slant range, slant range = s0 + s1(gr-gr0) + s2(gr-gr0)^2 + s3(gr-gr0)^3 + s4(gr-gr0)^4...+ sN(gr-gr0)^N where gr is the ground range distance to the desired pixel and N is the number of coefficients in the array minus one'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time to first range sample', 'units': 's'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'slant range origin used for ground range calculation', 'units': 'm'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f8', 'long_name': 'coefficients to convert from slant range to ground range, ground range = g0 + g1(sr-sr0) + g2(sr-sr0)^2 + g3(sr-sr0)^3 + g4(sr-sr0)^4...+ gN(sr-sr0)^N where sr is the slant range distance to the desired pixel and N is the number of coefficients in the array minus one'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f4', 'long_name': 'doppler centroid estimated from data, expressed as polynomial with 5 coefficients: doppler centroid = d0 + d1(tsr-t0) + d2(tsr-t0)^2 + d3(tsr-t0)^3 + d4(tsr-t0)^4, where tsr = 2-way slant range time'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
324 B
\n",
+ "
324 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 3)
\n",
+ "
(27, 3)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_doppler_centroid_data_dc_rms_error
(VH_conditions_doppler_centroid_azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'RMS error of the doppler centroid estimate (calculated as the average of the individual RMS residual errors between input fine doppler centroid estimates and the fitted polynomial; if the doppler centroid was not estimated from data, this is set to 0)'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
{'coordinates': ['azimuth_time', 'line'], 'dimensions': ['azimuth_time'], 'dtype': '<u4', 'long_name': 'reference image measurement data set sample to which this geolocation grid point applies'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
840 B
\n",
+ "
840 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(210,)
\n",
+ "
(210,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_gcp_slant_range_time
(VH_conditions_gcp_azimuth_time)
float32
dask.array<chunksize=(210,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time to grid point', 'units': 's'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if |pgProductAmplitude - modelPgProductAmplitude| < maxPgAmpErrorThreshold and |pgProductPhase - modelPgProductPhase| < maxPgPhaseErrorThreshold, false otherwise; PG product values can only be calculated and validated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this flag is set to false for every replica record'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'peak location of cross-correlation function between the reconstructed replica and the nominal replica', 'units': 'samples'}
units :
samples
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_replica_cross_correlation_pslr
(VH_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'peak side lobe ratio of replica cross-correlation function between the reconstructed replica and the nominal replica', 'units': 'dB'}
units :
dB
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_replica_internal_time_delay
(VH_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'internal time delay representing the calculated deviation of the location of this PG replica from the location of the transmitted pulse or nominal PG replica', 'units': 's'}
units :
s
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_replica_model_pg_product_amplitude
(VH_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'PG product amplitude value from the input PG product model'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_replica_model_pg_product_phase
(VH_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'PG product phase value from the input PG product model', 'units': 'radians'}
units :
radians
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_replica_pg_product_amplitude
(VH_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'amplitude of the power gain product derived from this replica (the amplitude value is:abs(1/PG * meanRxCalPow(swath1)/meanRxCalPow(swathn)) where abs() is the absolute value function for a complex number, meanRxCalPow(swath1) is the mean rx calibration power of swath 1, meanRxCalPow(swathn) is the mean rx calibration power of the current swath; PG product values can only be calculated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this value is set to the default value of 1.0)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_replica_pg_product_phase
(VH_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'phase of the power gain product derived from this replica [radians] (the phase value is:arg(1/PG * meanRxCalPow(swath1)/meanRxCalPow(swathn)) where arg() is the phase value function for a complex number, meanRxCalPow(swath1) is the mean rx calibration power of swath 1, meanRxCalPow(swathn) is the mean rx calibration power of the current swath; PG product values can only be calculated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this value is set to the default value of 0.0)'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if a valid peak location was found in the cross-correlation between the nominal PG replica and this extracted PG replica, false otherwise'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if |pgProductAmplitude - meanPgProductAmplitude| < pgAmpStdFractionThreshold * stdPgProductAmplitude and |pgProductPhase - meanPgProductPhase| < pgPhaseStdFractionThreshold * stdPgProductPhase, false otherwise; PG product values can only be calculated and validated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this flag is set to false for every replica record'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
15 B
\n",
+ "
15 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VH_conditions_terrain_height_terrain_height
(VH_conditions_terrain_height_azimuth_time)
float32
dask.array<chunksize=(5,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'average terrain height above ellipsoid, the value is the average height in the range direction for the given zero-doppler azimuth time', 'units': 'm'}
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'beta nought calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'digital number calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'gamma calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'sigma nought calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<u4', 'long_name': 'number of noise lines used to calculate the noise correction factor'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'estimated roll angle for this antenna pattern', 'units': 'degrees'}
units :
degrees
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
108 B
\n",
+ "
108 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27,)
\n",
+ "
(27,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_antenna_pattern_terrain_height
(VV_conditions_antenna_pattern_azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'mean terrain height in range for this antenna pattern (in metres above the ellipsoid) for the given zero-doppler azimuth time', 'units': 'm'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'ground range origin used for ground range calculation', 'units': 'm'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f8', 'long_name': 'coefficients to convert from ground range to slant range, slant range = s0 + s1(gr-gr0) + s2(gr-gr0)^2 + s3(gr-gr0)^3 + s4(gr-gr0)^4...+ sN(gr-gr0)^N where gr is the ground range distance to the desired pixel and N is the number of coefficients in the array minus one'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time to first range sample', 'units': 's'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'slant range origin used for ground range calculation', 'units': 'm'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f8', 'long_name': 'coefficients to convert from slant range to ground range, ground range = g0 + g1(sr-sr0) + g2(sr-sr0)^2 + g3(sr-sr0)^3 + g4(sr-sr0)^4...+ gN(sr-sr0)^N where sr is the slant range distance to the desired pixel and N is the number of coefficients in the array minus one'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time', 'degree'], 'dtype': '<f4', 'long_name': 'doppler centroid estimated from data, expressed as polynomial with 5 coefficients: doppler centroid = d0 + d1(tsr-t0) + d2(tsr-t0)^2 + d3(tsr-t0)^3 + d4(tsr-t0)^4, where tsr = 2-way slant range time'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
324 B
\n",
+ "
324 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(27, 3)
\n",
+ "
(27, 3)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_doppler_centroid_data_dc_rms_error
(VV_conditions_doppler_centroid_azimuth_time)
float32
dask.array<chunksize=(27,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'RMS error of the doppler centroid estimate (calculated as the average of the individual RMS residual errors between input fine doppler centroid estimates and the fitted polynomial; if the doppler centroid was not estimated from data, this is set to 0)'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'false if the RMS error is less than the acceptable threshold for the doppler centroid estimated from the data; true if the RMS error is more than or equal to the acceptable threshold'}
{'coordinates': ['azimuth_time', 'line'], 'dimensions': ['azimuth_time'], 'dtype': '<u4', 'long_name': 'reference image measurement data set sample to which this geolocation grid point applies'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
840 B
\n",
+ "
840 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(210,)
\n",
+ "
(210,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
int32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_gcp_slant_range_time
(VV_conditions_gcp_azimuth_time)
float32
dask.array<chunksize=(210,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time', 'line'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'two-way slant range time to grid point', 'units': 's'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if |pgProductAmplitude - modelPgProductAmplitude| < maxPgAmpErrorThreshold and |pgProductPhase - modelPgProductPhase| < maxPgPhaseErrorThreshold, false otherwise; PG product values can only be calculated and validated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this flag is set to false for every replica record'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'peak location of cross-correlation function between the reconstructed replica and the nominal replica', 'units': 'samples'}
units :
samples
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_replica_cross_correlation_pslr
(VV_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'peak side lobe ratio of replica cross-correlation function between the reconstructed replica and the nominal replica', 'units': 'dB'}
units :
dB
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_replica_internal_time_delay
(VV_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'internal time delay representing the calculated deviation of the location of this PG replica from the location of the transmitted pulse or nominal PG replica', 'units': 's'}
units :
s
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_replica_model_pg_product_amplitude
(VV_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'PG product amplitude value from the input PG product model'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_replica_model_pg_product_phase
(VV_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'PG product phase value from the input PG product model', 'units': 'radians'}
units :
radians
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_replica_pg_product_amplitude
(VV_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'amplitude of the power gain product derived from this replica (the amplitude value is:abs(1/PG * meanRxCalPow(swath1)/meanRxCalPow(swathn)) where abs() is the absolute value function for a complex number, meanRxCalPow(swath1) is the mean rx calibration power of swath 1, meanRxCalPow(swathn) is the mean rx calibration power of the current swath; PG product values can only be calculated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this value is set to the default value of 1.0)'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
60 B
\n",
+ "
60 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
float32 numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_replica_pg_product_phase
(VV_conditions_replica_azimuth_time)
float32
dask.array<chunksize=(15,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f4', 'long_name': 'phase of the power gain product derived from this replica [radians] (the phase value is:arg(1/PG * meanRxCalPow(swath1)/meanRxCalPow(swathn)) where arg() is the phase value function for a complex number, meanRxCalPow(swath1) is the mean rx calibration power of swath 1, meanRxCalPow(swathn) is the mean rx calibration power of the current swath; PG product values can only be calculated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this value is set to the default value of 0.0)'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if a valid peak location was found in the cross-correlation between the nominal PG replica and this extracted PG replica, false otherwise'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<b1', 'long_name': 'true if |pgProductAmplitude - meanPgProductAmplitude| < pgAmpStdFractionThreshold * stdPgProductAmplitude and |pgProductPhase - meanPgProductPhase| < pgPhaseStdFractionThreshold * stdPgProductPhase, false otherwise; PG product values can only be calculated and validated for products that have at least one valid extracted reconstructed replica; if no valid extracted reconstructed replica exists within the product then this flag is set to false for every replica record'}
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Array
\n",
+ "
Chunk
\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
Bytes
\n",
+ "
15 B
\n",
+ "
15 B
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
Shape
\n",
+ "
(15,)
\n",
+ "
(15,)
\n",
+ "
\n",
+ "
\n",
+ "
Dask graph
\n",
+ "
1 chunks in 2 graph layers
\n",
+ "
\n",
+ "
\n",
+ "
Data type
\n",
+ "
bool numpy.ndarray
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
VV_conditions_terrain_height_terrain_height
(VV_conditions_terrain_height_azimuth_time)
float32
dask.array<chunksize=(5,), meta=np.ndarray>
_eopf_attrs :
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<f8', 'long_name': 'average terrain height above ellipsoid, the value is the average height in the range direction for the given zero-doppler azimuth time', 'units': 'm'}
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'beta nought calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'digital number calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'gamma calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time', 'line', 'pixel', 'ground_range'], 'dimensions': ['azimuth_time', 'ground_range'], 'dtype': '<f4', 'long_name': 'sigma nought calibration vector (this array contains the count attribute number of floating point values; the values in this vector are aligned with the pixel vector)'}
{'coordinates': ['azimuth_time'], 'dimensions': ['azimuth_time'], 'dtype': '<u4', 'long_name': 'number of noise lines used to calculate the noise correction factor'}
PROJCRS["WGS 84 / UTM zone 32N",BASEGEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],MEMBER["World Geodetic System 1984 (G2296)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4326]],CONVERSION["UTM zone 32N",METHOD["Transverse Mercator",ID["EPSG",9807]],PARAMETER["Latitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8801]],PARAMETER["Longitude of natural origin",9,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8802]],PARAMETER["Scale factor at natural origin",0.9996,SCALEUNIT["unity",1],ID["EPSG",8805]],PARAMETER["False easting",500000,LENGTHUNIT["metre",1],ID["EPSG",8806]],PARAMETER["False northing",0,LENGTHUNIT["metre",1],ID["EPSG",8807]]],CS[Cartesian,2],AXIS["(E)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["(N)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Navigation and medium accuracy spatial referencing."],AREA["Between 6°E and 12°E, northern hemisphere between equator and 84°N, onshore and offshore. Algeria. Austria. Cameroon. Denmark. Equatorial Guinea. France. Gabon. Germany. Italy. Libya. Liechtenstein. Monaco. Netherlands. Niger. Nigeria. Norway. Sao Tome and Principe. Svalbard. Sweden. Switzerland. Tunisia. Vatican City State."],BBOX[0,6,84,12]],ID["EPSG",32632]]
PROJCRS["WGS 84 / UTM zone 32N",BASEGEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],MEMBER["World Geodetic System 1984 (G2296)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4326]],CONVERSION["UTM zone 32N",METHOD["Transverse Mercator",ID["EPSG",9807]],PARAMETER["Latitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8801]],PARAMETER["Longitude of natural origin",9,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8802]],PARAMETER["Scale factor at natural origin",0.9996,SCALEUNIT["unity",1],ID["EPSG",8805]],PARAMETER["False easting",500000,LENGTHUNIT["metre",1],ID["EPSG",8806]],PARAMETER["False northing",0,LENGTHUNIT["metre",1],ID["EPSG",8807]]],CS[Cartesian,2],AXIS["(E)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["(N)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Navigation and medium accuracy spatial referencing."],AREA["Between 6°E and 12°E, northern hemisphere between equator and 84°N, onshore and offshore. Algeria. Austria. Cameroon. Denmark. Equatorial Guinea. France. Gabon. Germany. Italy. Libya. Liechtenstein. Monaco. Netherlands. Niger. Nigeria. Norway. Sao Tome and Principe. Svalbard. Sweden. Switzerland. Tunisia. Vatican City State."],BBOX[0,6,84,12]],ID["EPSG",32632]]
PROJCRS["WGS 84 / UTM zone 32N",BASEGEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1984 ensemble",MEMBER["World Geodetic System 1984 (Transit)"],MEMBER["World Geodetic System 1984 (G730)"],MEMBER["World Geodetic System 1984 (G873)"],MEMBER["World Geodetic System 1984 (G1150)"],MEMBER["World Geodetic System 1984 (G1674)"],MEMBER["World Geodetic System 1984 (G1762)"],MEMBER["World Geodetic System 1984 (G2139)"],MEMBER["World Geodetic System 1984 (G2296)"],ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]],ENSEMBLEACCURACY[2.0]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],ID["EPSG",4326]],CONVERSION["UTM zone 32N",METHOD["Transverse Mercator",ID["EPSG",9807]],PARAMETER["Latitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8801]],PARAMETER["Longitude of natural origin",9,ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8802]],PARAMETER["Scale factor at natural origin",0.9996,SCALEUNIT["unity",1],ID["EPSG",8805]],PARAMETER["False easting",500000,LENGTHUNIT["metre",1],ID["EPSG",8806]],PARAMETER["False northing",0,LENGTHUNIT["metre",1],ID["EPSG",8807]]],CS[Cartesian,2],AXIS["(E)",east,ORDER[1],LENGTHUNIT["metre",1]],AXIS["(N)",north,ORDER[2],LENGTHUNIT["metre",1]],USAGE[SCOPE["Navigation and medium accuracy spatial referencing."],AREA["Between 6°E and 12°E, northern hemisphere between equator and 84°N, onshore and offshore. Algeria. Austria. Cameroon. Denmark. Equatorial Guinea. France. Gabon. Germany. Italy. Libya. Liechtenstein. Monaco. Netherlands. Niger. Nigeria. Norway. Sao Tome and Principe. Svalbard. Sweden. Switzerland. Tunisia. Vatican City State."],BBOX[0,6,84,12]],ID["EPSG",32632]]