Rename MRMS importer (#154)

* Rename import_mrms to import_mrms_grib
* Sort importers in alphabetical order
* Update interfaces
* Update tests for interfaces

Co-authored-by: Daniele Nerini

Author: aperezhortal

pysteps/io/importers.py

@@ -69,14 +69,14 @@
 .. autosummary::
     :toctree: ../generated/
 
-    import_mrms
     import_bom_rf3
     import_fmi_geotiff
     import_fmi_pgm
     import_knmi_hdf5
     import_mch_gif
     import_mch_hdf5
     import_mch_metranet
+    import_mrms_grib
     import_opera_hdf5
     import_saf_crri
 """
@@ -145,7 +145,8 @@
 
 
 def _check_coords_range(selected_range, coordinate, full_range):
-    """Check that the coordinates range arguments follow the expected pattern in the **import_mrms** function."""
+    """Check that the coordinates range arguments follow the expected pattern in
+    the **import_mrms_grib** function."""
 
     if selected_range is None:
         return sorted(full_range)
@@ -227,7 +228,7 @@ def _get_threshold_value(precip):
 
 
 @postprocess_import(dtype='float32')
-def import_mrms(filename, extent=None, window_size=4, **kwargs):
+def import_mrms_grib(filename, extent=None, window_size=4, **kwargs):
     """
     Importer for NSSL's Multi-Radar/Multi-Sensor System
     ([MRMS](https://www.nssl.noaa.gov/projects/mrms/)) rainrate product

pysteps/io/interface.py

@@ -15,13 +15,13 @@
 from pysteps.io import importers, exporters
 
 _importer_methods = dict(
-    mrms=importers.import_mrms,
     bom_rf3=importers.import_bom_rf3,
     fmi_geotiff=importers.import_fmi_geotiff,
     fmi_pgm=importers.import_fmi_pgm,
     mch_gif=importers.import_mch_gif,
     mch_hdf5=importers.import_mch_hdf5,
     mch_metranet=importers.import_mch_metranet,
+    mrms_grib=importers.import_mrms_grib,
     opera_hdf5=importers.import_opera_hdf5,
     knmi_hdf5=importers.import_knmi_hdf5,
     saf_crri=importers.import_saf_crri
@@ -73,6 +73,8 @@ def get_method(name, method_type):
         | mch_metranet | metranet files in the MeteoSwiss (MCH) archive       |
         |              | containing precipitation composites.                 |
         +--------------+------------------------------------------------------+
+        | mrms_grib    | Grib2 files used by the NSSL's MRMS product          |
+        +--------------+------------------------------------------------------+
         | opera_hdf5   | ODIM HDF5 file format used by Eumetnet/OPERA.        |
         +--------------+------------------------------------------------------+
         | saf_crri     |  NetCDF SAF CRRI files                               |

pysteps/pystepsrc

@@ -13,15 +13,6 @@
         "colorscale": "pysteps"
     },
     "data_sources": {
-        "mrms": {
-            "root_path": "./mrms",
-            "path_fmt": "%Y/%m/%d",
-            "fn_pattern": "PrecipRate_00.00_%Y%m%d-%H%M%S",
-            "fn_ext": "grib2",
-            "importer": "mrms",
-            "timestep": 2,
-            "importer_kwargs": {}
-        },
         "bom": {
             "root_path": "./radar/bom",
             "path_fmt": "prcp-cscn/2/%Y/%m/%d",
@@ -57,6 +48,15 @@
                 "accutime": 5
             }
         },
+        "mrms": {
+            "root_path": "./mrms",
+            "path_fmt": "%Y/%m/%d",
+            "fn_pattern": "PrecipRate_00.00_%Y%m%d-%H%M%S",
+            "fn_ext": "grib2",
+            "importer": "mrms_grib",
+            "timestep": 2,
+            "importer_kwargs": {}
+        },
         "opera": {
             "root_path": "./radar/OPERA",
             "path_fmt": "%Y%m%d",

pysteps/tests/test_interfaces.py

@@ -78,35 +78,46 @@ def test_io_interface():
     from pysteps.io import import_bom_rf3
     from pysteps.io import import_fmi_geotiff
     from pysteps.io import import_fmi_pgm
+    from pysteps.io import import_knmi_hdf5
     from pysteps.io import import_mch_gif
     from pysteps.io import import_mch_hdf5
     from pysteps.io import import_mch_metranet
+    from pysteps.io import import_mrms_grib
     from pysteps.io import import_opera_hdf5
+    from pysteps.io import import_saf_crri
+
+    from pysteps.io import initialize_forecast_exporter_geotiff
+    from pysteps.io import initialize_forecast_exporter_kineros
     from pysteps.io import initialize_forecast_exporter_netcdf
 
     # Test importers
     valid_names_func_pair = [('bom_rf3', import_bom_rf3),
                              ('fmi_geotiff', import_fmi_geotiff),
                              ('fmi_pgm', import_fmi_pgm),
+                             ('knmi_hdf5', import_knmi_hdf5),
                              ('mch_gif', import_mch_gif),
                              ('mch_hdf5', import_mch_hdf5),
                              ('mch_metranet', import_mch_metranet),
+                             ('mrms_grib', import_mrms_grib),
                              ('opera_hdf5', import_opera_hdf5),
-                             ('mch_gif', import_mch_gif),
-                             ('mch_gif', import_mch_gif),
-                             ('mch_gif', import_mch_gif), ]
+                             ('saf_crri', import_saf_crri),
+                             ]
 
     def method_getter(name):
         return pysteps.io.interface.get_method(name, 'importer')
 
-    invalid_names = ['opera', 'mch', 'fmi']
+    invalid_names = ['bom', 'fmi', 'knmi', 'mch', 'mrms', 'opera', 'saf']
     _generic_interface_test(method_getter, valid_names_func_pair, invalid_names)
 
     # Test exporters
     def method_getter(name):
         return pysteps.io.interface.get_method(name, 'exporter')
 
-    valid_names_func_pair = [('netcdf', initialize_forecast_exporter_netcdf)]
+    valid_names_func_pair = [
+        ('geotiff', initialize_forecast_exporter_geotiff),
+        ('kineros', initialize_forecast_exporter_kineros),
+        ('netcdf', initialize_forecast_exporter_netcdf),
+        ]
     invalid_names = ['hdf']
 
     _generic_interface_test(method_getter, valid_names_func_pair, invalid_names)
@@ -124,18 +135,24 @@ def method_getter(name):
 def test_motion_interface():
     """Test the motion module interface."""
 
+    from pysteps.motion.constant import constant
     from pysteps.motion.darts import DARTS
     from pysteps.motion.lucaskanade import dense_lucaskanade
+    from pysteps.motion.proesmans import proesmans
     from pysteps.motion.vet import vet
 
     method_getter = pysteps.motion.interface.get_method
 
-    valid_names_func_pair = [('lk', dense_lucaskanade),
+    valid_names_func_pair = [
+                             ('constant', constant),
+                             ('darts', DARTS),
+                             ('lk', dense_lucaskanade),
                              ('lucaskanade', dense_lucaskanade),
+                             ('proesmans', proesmans),
                              ('vet', vet),
-                             ('DARTS', DARTS)]
+                             ]
 
-    invalid_names = ['dart', 'pyvet', 'no_method']
+    invalid_names = ['dart', 'pyvet', 'lukascanade', 'lucas-kanade', 'no_method']
 
     _generic_interface_test(method_getter, valid_names_func_pair, invalid_names)
 
@@ -174,22 +191,28 @@ def test_noise_interface():
                     generate_noise_2d_ssft_filter)),
         ('bps', (initialize_bps, generate_bps))]
 
-    invalid_names = ['nest', 'sft']
+    invalid_names = ['nest', 'sft', 'ssfft']
 
     _generic_interface_test(method_getter, valid_names_func_pair, invalid_names)
 
 
 def test_nowcasts_interface():
     """Test the nowcasts module interface."""
 
-    from pysteps.nowcasts import steps
-    from pysteps.nowcasts import extrapolation
+    from pysteps.nowcasts import anvil, sprog, steps, sseps, extrapolation
     method_getter = pysteps.nowcasts.interface.get_method
 
-    valid_names_func_pair = [('extrapolation', extrapolation.forecast),
-                             ('steps', steps.forecast)]
+    valid_names_func_pair = [
+        ('anvil', anvil.forecast),
+        ('extrapolation', extrapolation.forecast),
+        ('lagrangian', extrapolation.forecast),
+        ('sprog', sprog.forecast),
+        ('sseps', sseps.forecast),
+        ('steps', steps.forecast),
+        ]
+
 
-    invalid_names = ['extrap', 'step']
+    invalid_names = ['extrap', 'step', 's-prog', 'pysteps']
     _generic_interface_test(method_getter, valid_names_func_pair, invalid_names)
 
     # Test eulerian persistence method

pysteps/tests/test_io_mrms.py renamed to pysteps/tests/test_io_mrms_grib.py

@@ -10,16 +10,16 @@
 pytest.importorskip('pygrib')
 
 
-def test_io_import_mrms():
+def test_io_import_mrms_grib():
     """Test the importer for NSSL data."""
 
     root_path = pysteps.rcparams.data_sources["mrms"]["root_path"]
 
     filename = os.path.join(root_path, "2019/06/10/", "PrecipRate_00.00_20190610-000000.grib2")
 
-    precip_full, _, metadata = pysteps.io.import_mrms(filename,
-                                                      fillna=0,
-                                                      window_size=1)
+    precip_full, _, metadata = pysteps.io.import_mrms_grib(filename,
+                                                           fillna=0,
+                                                           window_size=1)
     assert precip_full.shape == (3500, 7000)
     assert precip_full.dtype == 'single'
 
@@ -38,46 +38,46 @@ def test_io_import_mrms():
     # The full longitude range is (230.005, 299.995)
 
     # Test that if the bounding box is larger than the domain, all the points are returned.
-    precip_full2 = pysteps.io.import_mrms(filename,
-                                          fillna=0,
-                                          extent=(220, 300, 20, 55),
-                                          window_size=1)[0]
+    precip_full2 = pysteps.io.import_mrms_grib(filename,
+                                               fillna=0,
+                                               extent=(220, 300, 20, 55),
+                                               window_size=1)[0]
     assert precip_full2.shape == (3500, 7000)
 
     assert_array_almost_equal(precip_full, precip_full2)
 
     del precip_full2
 
     # Test that a portion of the domain is returned correctly
-    precip_clipped = pysteps.io.import_mrms(filename,
-                                            fillna=0,
-                                            extent=(250, 260, 30, 35),
-                                            window_size=1)[0]
+    precip_clipped = pysteps.io.import_mrms_grib(filename,
+                                                 fillna=0,
+                                                 extent=(250, 260, 30, 35),
+                                                 window_size=1)[0]
 
     assert precip_clipped.shape == (500, 1000)
     assert_array_almost_equal(precip_clipped, precip_full[2000:2500, 2000:3000])
     del precip_clipped
 
-    precip_single = pysteps.io.import_mrms(filename, dtype="double", fillna=0)[0]
+    precip_single = pysteps.io.import_mrms_grib(filename, dtype="double", fillna=0)[0]
     assert precip_single.dtype == 'double'
     del precip_single
 
-    precip_single = pysteps.io.import_mrms(filename,
-                                           dtype="single",
-                                           fillna=0)[0]
+    precip_single = pysteps.io.import_mrms_grib(filename,
+                                                dtype="single",
+                                                fillna=0)[0]
     assert precip_single.dtype == 'single'
     del precip_single
 
-    precip_donwscaled = pysteps.io.import_mrms(filename,
-                                               dtype="single",
-                                               fillna=0,
-                                               window_size=2)[0]
+    precip_donwscaled = pysteps.io.import_mrms_grib(filename,
+                                                    dtype="single",
+                                                    fillna=0,
+                                                    window_size=2)[0]
     assert precip_donwscaled.shape == (3500 / 2, 7000 / 2)
 
-    precip_donwscaled, _, metadata = pysteps.io.import_mrms(filename,
-                                                            dtype="single",
-                                                            fillna=0,
-                                                            window_size=3)
+    precip_donwscaled, _, metadata = pysteps.io.import_mrms_grib(filename,
+                                                                 dtype="single",
+                                                                 fillna=0,
+                                                                 window_size=3)
     expected_metadata = dict(
         xpixelsize=0.03,
         ypixelsize=0.03,