{'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'}
{'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'}