Add combined GRIB reader for both SEVIRI and FCI L2 products

satpy/readers/eum_l2_grib.py

@@ -23,7 +23,6 @@
 """
 
 import logging
-from datetime import timedelta
 
 import dask.array as da
 import numpy as np
@@ -33,7 +32,7 @@
 from satpy.readers.eum_base import get_service_mode
 from satpy.readers.fci_base import calculate_area_extent as fci_calculate_area_extent
 from satpy.readers.file_handlers import BaseFileHandler
-from satpy.readers.seviri_base import PLATFORM_DICT, REPEAT_CYCLE_DURATION
+from satpy.readers.seviri_base import PLATFORM_DICT, REPEAT_CYCLE_DURATION, REPEAT_CYCLE_DURATION_RSS
 from satpy.readers.seviri_base import calculate_area_extent as seviri_calculate_area_extent
 from satpy.utils import get_legacy_chunk_size
 
@@ -75,10 +74,8 @@ def start_time(self):
     @property
     def end_time(self):
         """Return the sensing end time."""
-        if self.sensor == "seviri":
-            return self.start_time + timedelta(minutes=REPEAT_CYCLE_DURATION)
-        elif self.sensor == "fci":
-            return self.filename_info["end_time"]
+        delta = REPEAT_CYCLE_DURATION_RSS if self._ssp_lon == 9.5 else REPEAT_CYCLE_DURATION
+        return self.start_time + delta
 
     def get_area_def(self, dataset_id):
         """Return the area definition for a dataset."""
@@ -249,10 +246,9 @@ def _get_proj_area(self, gid):
     def _scale_earth_axis(data):
         """Scale Earth axis data to make sure the value matched the expected unit [m].
 
-        The earthMinorAxis value stored in the aerosol over sea product is scaled incorrectly by a factor of 1e8. This
-        method provides a flexible temporarily workaraound by making sure that all earth axis values are scaled such
-        that they are on the order of millions of meters as expected by the reader. As soon as the scaling issue has
-        been resolved by EUMETSAT this workaround can be removed.
+        The earthMinorAxis value stored in the MPEF aerosol over sea product prior to December 12, 2022 has the wrong
+        unit and this method provides a flexible work-around by making sure that all earth axis values are scaled such
+        that they are on the order of millions of meters as expected by the reader.
 
         """
         scale_factor = 10 ** np.ceil(np.log10(1e6/data))

satpy/readers/fci_base.py

@@ -22,7 +22,7 @@
 def calculate_area_extent(area_dict):
         """Calculate the area extent seen by MTG FCI instrument.
 
-        Since the center of the FCI L2 grid is located at the interface between the pixels, there are equally many
+        Since the center of the FCI grids is located at the interface between the pixels, there are equally many
         pixels (e.g. 5568/2 = 2784 for 2km grid) in each direction from the center points. Hence, the area extent
         can be easily computed by simply adding and subtracting half the width and height from teh centre point (=0).
 

satpy/readers/seviri_base.py

@@ -212,6 +212,8 @@
 
 REPEAT_CYCLE_DURATION = 15
 
+REPEAT_CYCLE_DURATION_RSS = 5
+
 C1 = 1.19104273e-5
 C2 = 1.43877523
 

satpy/tests/reader_tests/test_eum_l2_grib.py

@@ -70,132 +70,136 @@
         ec_.codes_grib_new_from_file.side_effect = lambda fh: next(fake_gid_generator)
         self.ec_ = ec_
 
+    def common_checks(self, mock_file, dataset_id):
+        """Commmon checks for fci and seviri data."""
+         # Checks that the codes_grib_multi_support_on function has been called
+        self.ec_.codes_grib_multi_support_on.assert_called()
+
+        # Restarts the id generator and clears the call history
+        fake_gid_generator = (i for i in FAKE_GID)
+        self.ec_.codes_grib_new_from_file.side_effect = lambda fh: next(fake_gid_generator)
+        self.ec_.codes_grib_new_from_file.reset_mock()
+        self.ec_.codes_release.reset_mock()
+
+        # Checks the correct execution of the get_dataset function with a valid parameter_number
+        valid_dataset = self.reader.get_dataset(dataset_id, {"parameter_number": 30})
+        # Checks the correct file open call
+        mock_file.assert_called_with("test.grib", "rb")
+        # Checks that the dataset has been created as a DataArray object
+        assert valid_dataset._extract_mock_name() == "xr.DataArray()"
+        # Checks that codes_release has been called after each codes_grib_new_from_file call
+        # (except after the last one which has returned a None)
+        assert self.ec_.codes_grib_new_from_file.call_count == self.ec_.codes_release.call_count + 1
+
+        # Restarts the id generator and clears the call history
+        fake_gid_generator = (i for i in FAKE_GID)
+        self.ec_.codes_grib_new_from_file.side_effect = lambda fh: next(fake_gid_generator)
+        self.ec_.codes_grib_new_from_file.reset_mock()
+        self.ec_.codes_release.reset_mock()
+
+        # Checks the correct execution of the get_dataset function with an invalid parameter_number
+        invalid_dataset = self.reader.get_dataset(dataset_id, {"parameter_number": 50})
+        # Checks that the function returns None
+        assert invalid_dataset is None
+        # Checks that codes_release has been called after each codes_grib_new_from_file call
+        # (except after the last one which has returned a None)
+        assert self.ec_.codes_grib_new_from_file.call_count == self.ec_.codes_release.call_count + 1
+
     @unittest.skipIf(sys.platform.startswith("win"), "'eccodes' not supported on Windows")
     @mock.patch("satpy.readers.eum_l2_grib.xr")
     @mock.patch("satpy.readers.eum_l2_grib.da")
     def test_seviri_data_reading(self, da_, xr_):
         """Test the reading of data from the product."""
         from satpy.readers.eum_l2_grib import REPEAT_CYCLE_DURATION, EUML2GribFileHandler
         from satpy.utils import get_legacy_chunk_size
         CHUNK_SIZE = get_legacy_chunk_size()
 
         with mock.patch("builtins.open", mock.mock_open()) as mock_file:
             with mock.patch("satpy.readers.eum_l2_grib.ec", self.ec_):
                 self.ec_.codes_get_values.return_value = np.ones(1000*1200)
                 self.ec_.codes_get.side_effect = lambda gid, key: FAKE_SEVIRI_MESSAGE[key]
                 self.reader = EUML2GribFileHandler(
                     filename="test.grib",
                     filename_info={
                         "spacecraft": "MET11",
                         "start_time": datetime.datetime(year=2020, month=10, day=20,
                                                         hour=19, minute=45, second=0)
                     },
                     filetype_info={
                         "file_type" : "seviri"
                     }
                 )
 
                 dataset_id = make_dataid(name="dummmy", resolution=3000)
 
-                # Checks that the codes_grib_multi_support_on function has been called
-                self.ec_.codes_grib_multi_support_on.assert_called()
-
-                # Restarts the id generator and clears the call history
-                fake_gid_generator = (i for i in FAKE_GID)
-                self.ec_.codes_grib_new_from_file.side_effect = lambda fh: next(fake_gid_generator)
-                self.ec_.codes_grib_new_from_file.reset_mock()
-                self.ec_.codes_release.reset_mock()
-
-                # Checks the correct execution of the get_dataset function with a valid parameter_number
-                valid_dataset = self.reader.get_dataset(dataset_id, {"parameter_number": 30})
-                # Checks the correct file open call
-                mock_file.assert_called_with("test.grib", "rb")
-                # Checks that the dataset has been created as a DataArray object
-                assert valid_dataset._extract_mock_name() == "xr.DataArray()"
-                # Checks that codes_release has been called after each codes_grib_new_from_file call
-                # (except after the last one which has returned a None)
-                assert self.ec_.codes_grib_new_from_file.call_count == self.ec_.codes_release.call_count + 1
-
-                # Restarts the id generator and clears the call history
-                fake_gid_generator = (i for i in FAKE_GID)
-                self.ec_.codes_grib_new_from_file.side_effect = lambda fh: next(fake_gid_generator)
-                self.ec_.codes_grib_new_from_file.reset_mock()
-                self.ec_.codes_release.reset_mock()
-
-                # Checks the correct execution of the get_dataset function with an invalid parameter_number
-                invalid_dataset = self.reader.get_dataset(dataset_id, {"parameter_number": 50})
-                # Checks that the function returns None
-                assert invalid_dataset is None
-                # Checks that codes_release has been called after each codes_grib_new_from_file call
-                # (except after the last one which has returned a None)
-                assert self.ec_.codes_grib_new_from_file.call_count == self.ec_.codes_release.call_count + 1
+                self.common_checks(mock_file, dataset_id)
 
                 # Checks the basic data reading
                 assert REPEAT_CYCLE_DURATION == 15
 
                 # Checks the correct execution of the _get_global_attributes and _get_metadata_from_msg functions
                 attributes = self.reader._get_attributes()
                 expected_attributes = {
                     "orbital_parameters": {
                         "projection_longitude": 9.5
                     },
                     "sensor": "seviri",
                     "platform_name": "Meteosat-11"
                 }
                 assert attributes == expected_attributes
 
                 # Checks the reading of an array from the message
                 self.reader._get_xarray_from_msg(0)
 
                 # Checks that dask.array has been called with the correct arguments
                 name, args, kwargs = da_.mock_calls[0]
                 assert np.all(args[0] == np.ones((1200, 1000)))
                 assert args[1] == CHUNK_SIZE
 
                 # Checks that xarray.DataArray has been called with the correct arguments
                 name, args, kwargs = xr_.mock_calls[0]
                 assert kwargs["dims"] == ("y", "x")
 
                 # Checks the correct execution of the _get_proj_area function
                 pdict, area_dict = self.reader._get_proj_area(0)
 
                 expected_pdict = {
                     "a": 6400000.,
                     "b": 6300000.,
                     "h": 32000000.,
                     "ssp_lon": 9.5,
                     "nlines": 1000,
                     "ncols": 1200,
                     "a_name": "msg_seviri_rss_3km",
                     "a_desc": "MSG SEVIRI Rapid Scanning Service area definition with 3 km resolution",
                     "p_id": "",
                 }
                 assert pdict == expected_pdict
                 expected_area_dict = {
                     "center_point": 500,
                     "north": 1200,
                     "east": 1,
                     "west": 1000,
                     "south": 1,
                 }
                 assert area_dict == expected_area_dict
 
                 # Checks the correct execution of the get_area_def function
                 with mock.patch("satpy.readers.eum_l2_grib.seviri_calculate_area_extent",
                                 mock.Mock(name="seviri_calculate_area_extent")) as cae:
                     with mock.patch("satpy.readers.eum_l2_grib.get_area_definition", mock.Mock()) as gad:
                         dataset_id = make_dataid(name="dummmy", resolution=400.)
                         self.reader.get_area_def(dataset_id)
                         # Asserts that seviri_calculate_area_extent has been called with the correct arguments
                         expected_args = ({"center_point": 500, "east": 1, "west": 1000, "south": 1, "north": 1200,
                                          "column_step": 400., "line_step": 400.},)
                         name, args, kwargs = cae.mock_calls[0]
                         assert args == expected_args
                         # Asserts that get_area_definition has been called with the correct arguments
                         name, args, kwargs = gad.mock_calls[0]
                         assert args[0] == expected_pdict
                         # The second argument must be the return result of seviri_calculate_area_extent
                         assert args[1]._extract_mock_name() == "seviri_calculate_area_extent()"
 
     @unittest.skipIf(sys.platform.startswith("win"), "'eccodes' not supported on Windows")
     @mock.patch("satpy.readers.eum_l2_grib.xr")
@@ -224,38 +228,7 @@
 
                 dataset_id = make_dataid(name="dummmy", resolution=2000)
 
-                # Checks that the codes_grib_multi_support_on function has been called
-                self.ec_.codes_grib_multi_support_on.assert_called()
-
-                # Restarts the id generator and clears the call history
-                fake_gid_generator = (i for i in FAKE_GID)
-                self.ec_.codes_grib_new_from_file.side_effect = lambda fh: next(fake_gid_generator)
-                self.ec_.codes_grib_new_from_file.reset_mock()
-                self.ec_.codes_release.reset_mock()
-
-                # Checks the correct execution of the get_dataset function with a valid parameter_number
-                valid_dataset = self.reader.get_dataset(dataset_id, {"parameter_number": 30})
-                # Checks the correct file open call
-                mock_file.assert_called_with("test.grib", "rb")
-                # Checks that the dataset has been created as a DataArray object
-                assert valid_dataset._extract_mock_name() == "xr.DataArray()"
-                # Checks that codes_release has been called after each codes_grib_new_from_file call
-                # (except after the last one which has returned a None)
-                assert self.ec_.codes_grib_new_from_file.call_count == self.ec_.codes_release.call_count + 1
-
-                # Restarts the id generator and clears the call history
-                fake_gid_generator = (i for i in FAKE_GID)
-                self.ec_.codes_grib_new_from_file.side_effect = lambda fh: next(fake_gid_generator)
-                self.ec_.codes_grib_new_from_file.reset_mock()
-                self.ec_.codes_release.reset_mock()
-
-                # Checks the correct execution of the get_dataset function with an invalid parameter_number
-                invalid_dataset = self.reader.get_dataset(dataset_id, {"parameter_number": 50})
-                # Checks that the function returns None
-                assert invalid_dataset is None
-                # Checks that codes_release has been called after each codes_grib_new_from_file call
-                # (except after the last one which has returned a None)
-                assert self.ec_.codes_grib_new_from_file.call_count == self.ec_.codes_release.call_count + 1
+                self.common_checks(mock_file, dataset_id)
 
                 # Checks the correct execution of the _get_global_attributes and _get_metadata_from_msg functions
                 attributes = self.reader._get_attributes()