def process_one_scene(scene_files,
out_path,
use_iband_res=False,
engine='h5netcdf',
all_channels=False,
pps_channels=False,
orbit_n=0):
"""Make level 1c files in PPS-format."""
tic = time.time()
scn_ = Scene(reader='viirs_sdr', filenames=scene_files)
MY_MBAND = MBAND_DEFAULT
MY_IBAND_I = IBAND_DEFAULT_I
MY_IBAND_M = IBAND_DEFAULT_M
if all_channels:
MY_MBAND = MBANDS
MY_IBAND_I = IBANDS
MY_IBAND_M = MBANDS
if pps_channels:
MY_MBAND = MBAND_PPS
MY_IBAND_I = IBAND_PPS_I
MY_IBAND_M = IBAND_PPS_M
if use_iband_res:
scn_.load(MY_IBAND_I + ANGLE_NAMES + ['i_latitude', 'i_longitude'],
resolution=371)
scn_.load(MY_IBAND_M, resolution=742)
scn_ = scn_.resample(resampler='native')
else:
scn_.load(MY_MBAND + ANGLE_NAMES + ['m_latitude', 'm_longitude'],
resolution=742)
# one ir channel
irch = scn_['M15']
# Set header and band attributes
set_header_and_band_attrs(scn_, orbit_n=orbit_n)
# Rename longitude, latitude to lon, lat.
rename_latitude_longitude(scn_)
# Convert angles to PPS
convert_angles(scn_, delete_azimuth=True)
update_angle_attributes(scn_, irch)
filename = compose_filename(scn_, out_path, instrument='viirs', band=irch)
scn_.save_datasets(writer='cf',
filename=filename,
header_attrs=get_header_attrs(scn_,
band=irch,
sensor='viirs'),
engine=engine,
include_lonlats=False,
flatten_attrs=True,
encoding=get_encoding_viirs(scn_))
print("Saved file {:s} after {:3.1f} seconds".format(
os.path.basename(filename),
time.time() - tic))
return filename
def test_update_angle_attributes(self):
"""Test setting of attributes for angles."""
band = mock.MagicMock(
attrs={
'start_time': dt.datetime(2009, 7, 1, 12, 15),
'end_time': dt.datetime(2009, 7, 1, 12, 16)
})
class AngleObj(object):
def __init__(self):
self.attrs = {'area': 'xx'}
self.coords = {}
angle_obj = AngleObj()
setattr(angle_obj, 'attrs', {'area': 'xx'})
setattr(angle_obj, 'coords', {})
angle_dict = {
'satzenith': AngleObj(),
'sunzenith': AngleObj(),
'azimuthdiff': AngleObj()
}
update_angle_attributes(angle_dict, band)
self.assertEqual(angle_dict['satzenith'].attrs['name'], 'satzenith')
self.assertEqual(angle_dict['satzenith'].attrs['id_tag'], 'satzenith')
np.testing.assert_array_equal(
angle_dict['satzenith'].attrs['valid_range'],
np.array([0, 9000], dtype='int16'))
self.assertNotIn('area', angle_dict['satzenith'].attrs.keys())
self.assertIn('time', angle_dict['satzenith'].coords.keys())
self.assertIn('long_name', angle_dict['satzenith'].attrs.keys())
self.assertIn('standard_name', angle_dict['satzenith'].attrs.keys())
def process_one_scene(scene_files,
out_path,
engine='h5netcdf',
all_channels=False,
pps_channels=False,
orbit_n=0):
"""Make level 1c files in PPS-format."""
tic = time.time()
scn_ = Scene(reader='modis_l1b', filenames=scene_files)
MY_BANDNAMES = BANDNAMES_DEFAULT
if all_channels:
MY_BANDNAMES = BANDNAMES
if pps_channels:
MY_BANDNAMES = BANDNAMES_PPS
scn_.load(MY_BANDNAMES + ['latitude', 'longitude'] + ANGLE_NAMES,
resolution=1000)
# one ir channel
irch = scn_['31']
# Set header and band attributes
set_header_and_band_attrs(scn_, orbit_n=orbit_n)
# Rename longitude, latitude to lon, lat.
rename_latitude_longitude(scn_)
# Convert angles to PPS
convert_angles(scn_, delete_azimuth=True)
update_angle_attributes(scn_, irch)
# Apply sunz correction
apply_sunz_correction(scn_, REFL_BANDS)
filename = compose_filename(scn_, out_path, instrument='modis', band=irch)
scn_.save_datasets(writer='cf',
filename=filename,
header_attrs=get_header_attrs(scn_,
band=irch,
sensor='modis'),
engine=engine,
include_lonlats=False,
flatten_attrs=True,
encoding=get_encoding_modis(scn_))
print("Saved file {:s} after {:3.1f} seconds".format(
os.path.basename(filename),
time.time() - tic))
return filename
def process_one_scene(scene_files, out_path):
"""Make level 1c files in PPS-format."""
tic = time.time()
scn_ = Scene(reader='vii_l1b_nc', filenames=scene_files)
scn_.load(BANDNAMES + ANGLE_NAMES + ['lat_pixels', 'lon_pixels'])
# Transpose data to get scanlines as row dimension
for key in BANDNAMES + ANGLE_NAMES + ['lat_pixels', 'lon_pixels']:
if 'num_pixels' in scn_[key].dims:
# satpy <= 0 .26.0
scn_[key] = scn_[key].transpose('num_lines', 'num_pixels')
elif scn_[key].dims[0] == 'x':
# first dim should be y
scn_[key] = scn_[key].transpose('y', 'x')
# one ir channel
irch = scn_['vii_10690']
# Set header and band attributes
set_header_and_band_attrs(scn_)
# Rename longitude, latitude to lon, lat.
rename_latitude_longitude(scn_)
# Adjust lons to valid range:
adjust_lons_to_valid_range(scn_)
# Convert angles to PPS
convert_angles(scn_, delete_azimuth=True)
update_angle_attributes(scn_, irch)
# Apply sunz correction
# apply_sunz_correction(scn_, REFL_BANDS)
filename = compose_filename(scn_, out_path, instrument='metimage', band=irch)
scn_.save_datasets(writer='cf',
filename=filename,
header_attrs=get_header_attrs(scn_, band=irch, sensor='metimage'),
engine='h5netcdf',
include_lonlats=False,
flatten_attrs=True,
encoding=get_encoding_metimage(scn_))
print("Saved file {:s} after {:3.1f} seconds".format(
os.path.basename(filename),
time.time()-tic))
def process_one_scene(scene_files, out_path, engine='h5netcdf', orbit_n=0):
"""Make level 1c files in PPS-format."""
tic = time.time()
if 'AVHR_xxx' in scene_files[0]:
avhrr_reader = 'avhrr_l1b_eps'
angles = ANGLE_NAMES_EPS
else:
avhrr_reader = 'avhrr_l1b_aapp'
angles = ANGLE_NAMES_AAPP
scn_ = Scene(
reader=avhrr_reader,
filenames=scene_files)
scn_.load(BANDNAMES + ['latitude', 'longitude'] + angles)
# one ir channel
irch = scn_['4']
# Check if we have old hrpt format with data only every 20th line
check_broken_data(scn_)
# Set header and band attributes
set_header_and_band_attrs(scn_, orbit_n=orbit_n)
# Rename longitude, latitude to lon, lat.
rename_latitude_longitude(scn_)
# Convert angles to PPS
convert_angles(scn_, delete_azimuth=True)
update_angle_attributes(scn_, irch)
# Apply sunz correction
apply_sunz_correction(scn_, REFL_BANDS)
filename = compose_filename(scn_, out_path, instrument='avhrr', band=irch)
scn_.save_datasets(writer='cf',
filename=filename,
header_attrs=get_header_attrs(scn_, band=irch, sensor='avhrr'),
engine=engine,
include_lonlats=False,
flatten_attrs=True,
encoding=get_encoding_avhrr(scn_))
print("Saved file {:s} after {:3.1f} seconds".format(
os.path.basename(filename),
time.time()-tic))
return filename
def process_one_scene(scene_files, out_path, engine='h5netcdf',
all_channels=False, pps_channels=False):
"""Make level 1c files in PPS-format."""
tic = time.time()
scn_ = Scene(
reader='slstr_l1b',
filenames=scene_files)
MY_BANDNAMES = BANDNAMES_DEFAULT
if all_channels:
MY_BANDNAMES = BANDNAMES
if pps_channels:
MY_BANDNAMES = BANDNAMES_PPS
scn_.load(MY_BANDNAMES + ['latitude', 'longitude'] + ANGLE_NAMES)
# Everything should be on the same grid, to be saved as ppsleve1c
scn_ = scn_.resample(resampler="native")
# one ir channel
irch = scn_['S8']
# Set header and band attributes
set_header_and_band_attrs(scn_)
# Rename longitude, latitude to lon, lat.
rename_latitude_longitude(scn_)
# Convert angles to PPS
convert_angles(scn_, delete_azimuth=True)
update_angle_attributes(scn_, irch)
filename = compose_filename(scn_, out_path, instrument='slstr', band=irch)
scn_.save_datasets(writer='cf',
filename=filename,
header_attrs=get_header_attrs(scn_, band=irch, sensor='slstr'),
engine=engine,
include_lonlats=False,
flatten_attrs=True,
encoding=get_encoding_slstr(scn_))
print("Saved file {:s} after {:3.1f} seconds".format(
os.path.basename(filename),
time.time()-tic))
def process_one_scene(scene_files, out_path, engine='h5netcdf'):
"""Make level 1c files in PPS-format."""
tic = time.time()
scn_ = Scene(reader='mersi2_l1b', filenames=scene_files)
scn_.load(BANDNAMES + ['latitude', 'longitude'] + ANGLE_NAMES,
resolution=1000)
# Remove bad data at first and last column
remove_broken_data(scn_)
# one ir channel
irch = scn_['24']
# Set header and band attributes
set_header_and_band_attrs(scn_)
# Rename longitude, latitude to lon, lat.
rename_latitude_longitude(scn_)
# Convert angles to PPS
convert_angles(scn_, delete_azimuth=True)
update_angle_attributes(scn_, irch)
for angle in ['sunzenith', 'satzenith', 'azimuthdiff']:
scn_[angle].attrs['file_key'] = ANGLE_ATTRIBUTES['mersi2_file_key'][
angle]
filename = compose_filename(scn_, out_path, instrument='mersi2', band=irch)
scn_.save_datasets(writer='cf',
filename=filename,
header_attrs=get_header_attrs(scn_,
band=irch,
sensor='mersi-2'),
engine=engine,
include_lonlats=False,
flatten_attrs=True,
encoding=get_encoding_mersi2(scn_))
print("Saved file {:s} after {:3.1f} seconds".format(
os.path.basename(filename),
time.time() - tic))
return filename
def process_one_file(eumgacfdr_file,
out_path='.',
reader_kwargs=None,
start_line=None,
end_line=None,
engine='h5netcdf',
remove_broken=True):
"""Make level 1c files in PPS-format."""
tic = time.time()
scn_ = Scene(reader='avhrr_l1c_eum_gac_fdr_nc', filenames=[eumgacfdr_file])
scn_.load(BANDNAMES)
scn_.load([
'latitude', 'longitude', 'qual_flags', 'equator_crossing_time',
'equator_crossing_longitude', 'acq_time'
] + ANGLENAMES)
# Only load these if we do not crop data
if start_line is None and end_line is None:
scn_.load(['overlap_free_end', 'overlap_free_start', 'midnight_line'])
# Needs to be done before everything else to avoid problems with attributes.
if remove_broken:
logger.info("Setting low quality data (qual_flags) to nodata.")
remove_broken_data(scn_)
# Crop after all renaming of variables are done
# Problems to rename if cropping is done first.
set_exact_time_and_crop(scn_, start_line, end_line, time_key='acq_time')
irch = scn_[
'brightness_temperature_channel_4'] # Redefine, to get updated start/end_times
# One ir channel
irch = scn_['brightness_temperature_channel_4']
# Set header and band attributes
set_header_and_band_attrs(scn_)
# Rename longitude, latitude to lon, lat.
rename_latitude_longitude(scn_)
# Convert angles to PPS
convert_angles(scn_)
update_angle_attributes(scn_, irch) # Standard name etc
# Handle gac specific datasets qual_flags and scanline_timestamps
update_ancilliary_datasets(scn_)
filename = compose_filename(scn_, out_path, instrument='avhrr', band=irch)
encoding = get_encoding_gac(scn_)
scn_.save_datasets(
writer='cf',
filename=filename,
header_attrs=get_header_attrs(scn_, band=irch, sensor='avhrr'),
engine=engine,
flatten_attrs=True,
include_lonlats=False, # Included anyway as they are datasets in scn_
pretty=True,
encoding=encoding)
logger.info("Saved file {:s} after {:3.1f} seconds".format(
os.path.basename(filename),
time.time() - tic))
return filename
def add_ancillary_datasets(scene,
lons,
lats,
sunz,
satz,
azidiff,
chunks=(512, 3712)):
"""Add ancillary datasets to the scene.
Args:
lons: Longitude coordinates
lats: Latitude coordinates
sunz: Solar zenith angle
satz: Satellite zenith angle
azidiff: Absolute azimuth difference angle
chunks: Chunksize
"""
start_time = scene['IR_108'].attrs['start_time']
end_time = scene['IR_108'].attrs['end_time']
angle_coords = scene['IR_108'].coords
# Latitude
scene['lat'] = xr.DataArray(da.from_array(lats, chunks=chunks),
dims=['y', 'x'],
coords={
'y': scene['IR_108']['y'],
'x': scene['IR_108']['x']
})
scene['lat'].attrs['long_name'] = 'latitude coordinate'
scene['lat'].attrs['standard_name'] = 'latitude'
scene['lat'].attrs['units'] = 'degrees_north'
scene['lat'].attrs['start_time'] = start_time
scene['lat'].attrs['end_time'] = end_time
# Longitude
scene['lon'] = xr.DataArray(da.from_array(lons, chunks=chunks),
dims=['y', 'x'],
coords={
'y': scene['IR_108']['y'],
'x': scene['IR_108']['x']
})
scene['lon'].attrs['long_name'] = 'longitude coordinate'
scene['lon'].attrs['standard_name'] = 'longitude'
scene['lon'].attrs['units'] = 'degrees_east'
scene['lon'].attrs['start_time'] = start_time
scene['lon'].attrs['end_time'] = end_time
# Sunzenith
scene['sunzenith'] = xr.DataArray(da.from_array(sunz[:, :], chunks=chunks),
dims=['y', 'x'],
coords=angle_coords)
# Satzenith
scene['satzenith'] = xr.DataArray(da.from_array(satz[:, :], chunks=chunks),
dims=['y', 'x'],
coords=angle_coords)
# Azidiff
scene['azimuthdiff'] = xr.DataArray(da.from_array(azidiff[:, :],
chunks=chunks),
dims=['y', 'x'],
coords=angle_coords)
# Update the attributes
update_angle_attributes(scene, band=scene['IR_108'])
def process_one_file(gac_file,
out_path='.',
reader_kwargs=None,
engine='h5netcdf',
orbit_n=99999):
"""Make level 1c files in PPS-format."""
tic = time.time()
if reader_kwargs is None:
reader_kwargs = {}
if 'tle_dir' not in reader_kwargs:
from pygac.configuration import get_config
conf = get_config()
tle_dir = conf.get('tle', 'tledir', raw=True)
tle_name = conf.get('tle', 'tlename', raw=True)
reader_kwargs['tle_dir'] = tle_dir
reader_kwargs['tle_name'] = tle_name
scn_ = Scene(reader='avhrr_l1b_gaclac',
filenames=[gac_file],
reader_kwargs=reader_kwargs)
# Loading all at once sometimes fails with newer satpy, so start with BANDNAMES ...
scn_.load(BANDNAMES)
scn_.load([
'latitude', 'longitude', 'qual_flags', 'sensor_zenith_angle',
'solar_zenith_angle', 'solar_azimuth_angle', 'sensor_azimuth_angle',
'sun_sensor_azimuth_difference_angle'
])
# one ir channel
irch = scn_['4']
# Set header and band attributes
set_header_and_band_attrs(scn_, orbit_n=orbit_n)
# Rename longitude, latitude to lon, lat.
rename_latitude_longitude(scn_)
# Convert angles to PPS
convert_angles(scn_)
update_angle_attributes(scn_, irch)
# Handle gac specific datasets qual_flags and scanline_timestamps
update_ancilliary_datasets(scn_)
filename = compose_filename(scn_, out_path, instrument='avhrr', band=irch)
encoding = get_encoding_gac(scn_)
encoding['scanline_timestamps'].pop('units')
scn_.save_datasets(
writer='cf',
filename=filename,
header_attrs=get_header_attrs(scn_, band=irch, sensor='avhrr'),
engine=engine,
flatten_attrs=True,
include_lonlats=False, # Included anyway as they are datasets in scn_
pretty=True,
encoding=encoding)
print("Saved file {:s} after {:3.1f} seconds".format(
os.path.basename(filename),
time.time() - tic))
return filename
