vortex-nwp 2.0.0b1__py3-none-any.whl → 2.1.0__py3-none-any.whl

vortex/nwp/algo/clim.py

@@ -26,12 +26,12 @@ class BuildPGD(BlindRun, DrHookDecoMixin, EcGribDecoMixin):
     """Preparation of physiographic fields for Surfex."""
 
     _footprint = dict(
-        info = "Physiographic fields for Surfex.",
-        attr = dict(
-            kind = dict(
-                values   = ['buildpgd'],
+        info="Physiographic fields for Surfex.",
+        attr=dict(
+            kind=dict(
+                values=["buildpgd"],
             ),
-        )
+        ),
     )
 
 
@@ -39,12 +39,12 @@ class BuildPGD_MPI(Parallel, DrHookDecoMixin, EcGribDecoMixin):
     """Preparation of physiographic fields for Surfex."""
 
     _footprint = dict(
-        info = "Physiographic fields for Surfex.",
-        attr = dict(
-            kind = dict(
-                values   = ['buildpgd'],
+        info="Physiographic fields for Surfex.",
+        attr=dict(
+            kind=dict(
+                values=["buildpgd"],
             ),
-        )
+        ),
     )
 
 
@@ -52,64 +52,74 @@ class C923(IFSParallel):
     """Preparation of climatologic fields."""
 
     _footprint = dict(
-        info = "Climatologic fields for Arpege/Arome.",
-        attr = dict(
-            kind = dict(
-                values   = ['c923'],
+        info="Climatologic fields for Arpege/Arome.",
+        attr=dict(
+            kind=dict(
+                values=["c923"],
             ),
-            step = dict(
-                info = """Step of conf 923 (NAMCLI::N923).
+            step=dict(
+                info="""Step of conf 923 (NAMCLI::N923).
                           Defines the kind of fields and database processed.""",
-                type = int,
-                values = footprints.util.rangex(1, 10)
+                type=int,
+                values=footprints.util.rangex(1, 10),
             ),
-            orog_in_pgd = dict(
-                info = """Whether orography may be read in a PGD file.
+            orog_in_pgd=dict(
+                info="""Whether orography may be read in a PGD file.
                           (NAMCLA::LIPGD=.TRUE.)""",
-                type = bool,
-                optional = True,
-                default = False,
+                type=bool,
+                optional=True,
+                default=False,
             ),
-            input_orog_name = dict(
-                info = "Filename for input orography file (case LNORO=.T.).",
-                optional = True,
-                default = 'Neworog',
+            input_orog_name=dict(
+                info="Filename for input orography file (case LNORO=.T.).",
+                optional=True,
+                default="Neworog",
             ),
-            xpname = dict(
-                default = 'CLIM',
+            xpname=dict(
+                default="CLIM",
             ),
-        )
+        ),
     )
 
     def prepare(self, rh, opts):
         super().prepare(rh, opts)
         # check PGD if needed
         if self.orog_in_pgd:
-            pgd = self.context.sequence.effective_inputs(role=('Pgd',))
+            pgd = self.context.sequence.effective_inputs(role=("Pgd",))
             if len(pgd) == 0:
-                raise ValueError("As long as 'orog_in_pgd' attribute of this " +
-                                 "algo component is True, a 'Role: Pgd' " +
-                                 "resource must be provided.")
+                raise ValueError(
+                    "As long as 'orog_in_pgd' attribute of this "
+                    + "algo component is True, a 'Role: Pgd' "
+                    + "resource must be provided."
+                )
             pgd = pgd[0].rh
-            if pgd.resource.nativefmt == 'fa':
+            if pgd.resource.nativefmt == "fa":
                 self.algoassert(
                     pgd.container.basename == self.input_orog_name,
-                    "Local name for resource Pgd must be '{}'".
-                    format(self.input_orog_name))
-            elif pgd.resource.nativefmt == 'lfi':
-                raise NotImplementedError('CY43T2 onwards: lfi PGD should not be used.')
+                    "Local name for resource Pgd must be '{}'".format(
+                        self.input_orog_name
+                    ),
+                )
+            elif pgd.resource.nativefmt == "lfi":
+                raise NotImplementedError(
+                    "CY43T2 onwards: lfi PGD should not be used."
+                )
 
     def find_namelists(self, opts=None):
-        namrh_list = [x.rh
-                      for x in self.context.sequence.effective_inputs(role=('Namelist',))]
-        self.algoassert(len(namrh_list) == 1,
-                        "One and only one namelist necessary as input.")
+        namrh_list = [
+            x.rh
+            for x in self.context.sequence.effective_inputs(role=("Namelist",))
+        ]
+        self.algoassert(
+            len(namrh_list) == 1,
+            "One and only one namelist necessary as input.",
+        )
         return namrh_list
 
     def prepare_namelist_delta(self, rh, namcontents, namlocal):
         super().prepare_namelist_delta(rh, namcontents, namlocal)
-        namcontents['NAMMCC']['N923'] = self.step
-        namcontents.setmacro('LPGD', self.orog_in_pgd)
+        namcontents["NAMMCC"]["N923"] = self.step
+        namcontents.setmacro("LPGD", self.orog_in_pgd)
         return True
 
 
@@ -122,64 +132,87 @@ class FinalizePGD(AlgoComponent):
     """
 
     _footprint = dict(
-        info = "Finalisation of PGD.",
-        attr = dict(
-            kind = dict(
-                values   = ['finalize_pgd'],
-            ),
-            pgd_out_name = dict(
-                optional = True,
-                default = 'PGD_final.fa'
+        info="Finalisation of PGD.",
+        attr=dict(
+            kind=dict(
+                values=["finalize_pgd"],
             ),
-        )
+            pgd_out_name=dict(optional=True, default="PGD_final.fa"),
+        ),
     )
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         from ..util.usepygram import epygram_checker
-        ev = '1.2.14'
-        self.algoassert(epygram_checker.is_available(version=ev), "Epygram >= " + ev +
-                        " is needed here")
+
+        ev = "1.2.14"
+        self.algoassert(
+            epygram_checker.is_available(version=ev),
+            "Epygram >= " + ev + " is needed here",
+        )
 
     def execute(self, rh, opts):  # @UnusedVariable
         """Convert SURFGEOPOTENTIEL from clim to SFX.ZS in pgd."""
         import numpy
         from ..util.usepygram import epygram, epy_env_prepare
         from bronx.meteo.constants import g0
+
         # Handle resources
-        clim = self.context.sequence.effective_inputs(role=('Clim',))
-        self.algoassert(len(clim) == 1, "One and only one Clim has to be provided")
-        pgdin = self.context.sequence.effective_inputs(role=('InputPGD',))
-        self.algoassert(len(pgdin) == 1, "One and only one InputPGD has to be provided")
+        clim = self.context.sequence.effective_inputs(role=("Clim",))
+        self.algoassert(
+            len(clim) == 1, "One and only one Clim has to be provided"
+        )
+        pgdin = self.context.sequence.effective_inputs(role=("InputPGD",))
+        self.algoassert(
+            len(pgdin) == 1, "One and only one InputPGD has to be provided"
+        )
         if self.system.path.exists(self.pgd_out_name):
-            raise OSError("The output pgd file {!r} already exists.".format(self.pgd_out_name))
+            raise OSError(
+                "The output pgd file {!r} already exists.".format(
+                    self.pgd_out_name
+                )
+            )
         # copy fields
         with epy_env_prepare(self.ticket):
             epyclim = clim[0].rh.contents.data
             epypgd = pgdin[0].rh.contents.data
             epyclim.open()
             epypgd.open()
-            pgdout = epygram.formats.resource(self.pgd_out_name, 'w', fmt='FA',
-                                              headername=epyclim.headername,
-                                              geometry=epyclim.geometry,
-                                              cdiden=epypgd.cdiden,
-                                              validity=epypgd.validity,
-                                              processtype=epypgd.processtype)
-            g = epyclim.readfield('SURFGEOPOTENTIEL')
-            g.operation('/', g0)
-            g.fid['FA'] = 'SFX.ZS'
+            pgdout = epygram.formats.resource(
+                self.pgd_out_name,
+                "w",
+                fmt="FA",
+                headername=epyclim.headername,
+                geometry=epyclim.geometry,
+                cdiden=epypgd.cdiden,
+                validity=epypgd.validity,
+                processtype=epypgd.processtype,
+            )
+            g = epyclim.readfield("SURFGEOPOTENTIEL")
+            g.operation("/", g0)
+            g.fid["FA"] = "SFX.ZS"
             for f in epypgd.listfields():
                 fld = epypgd.readfield(f)
-                if f == 'SFX.ZS':
+                if f == "SFX.ZS":
                     fld = g
-                elif (isinstance(fld, epygram.fields.H2DField) and
-                      fld.geometry.grid.get('LAMzone') is not None):
-                    ext_data = numpy.ma.masked_equal(numpy.zeros(g.data.shape), 0.)
-                    ext_data[:fld.geometry.dimensions['Y'],
-                             :fld.geometry.dimensions['X']] = fld.data[:, :]
-                    fld = footprints.proxy.fields.almost_clone(fld, geometry=g.geometry)
+                elif (
+                    isinstance(fld, epygram.fields.H2DField)
+                    and fld.geometry.grid.get("LAMzone") is not None
+                ):
+                    ext_data = numpy.ma.masked_equal(
+                        numpy.zeros(g.data.shape), 0.0
+                    )
+                    ext_data[
+                        : fld.geometry.dimensions["Y"],
+                        : fld.geometry.dimensions["X"],
+                    ] = fld.data[:, :]
+                    fld = footprints.proxy.fields.almost_clone(
+                        fld, geometry=g.geometry
+                    )
                     fld.setdata(ext_data)
-                pgdout.writefield(fld, compression=epypgd.fieldscompression.get(f, None))
+                pgdout.writefield(
+                    fld, compression=epypgd.fieldscompression.get(f, None)
+                )
 
 
 class SetFilteredOrogInPGD(AlgoComponent):
@@ -188,48 +221,58 @@ class SetFilteredOrogInPGD(AlgoComponent):
     """
 
     _footprint = dict(
-        info = "Report spectrally optimized, filtered orography from Clim to PGD.",
-        attr = dict(
-            kind = dict(
-                values   = ['set_filtered_orog_in_pgd'],
+        info="Report spectrally optimized, filtered orography from Clim to PGD.",
+        attr=dict(
+            kind=dict(
+                values=["set_filtered_orog_in_pgd"],
             ),
-        )
+        ),
     )
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         from ..util.usepygram import epygram_checker
-        ev = '1.3.2'
-        self.algoassert(epygram_checker.is_available(version=ev), "Epygram >= " + ev +
-                        " is needed here")
+
+        ev = "1.3.2"
+        self.algoassert(
+            epygram_checker.is_available(version=ev),
+            "Epygram >= " + ev + " is needed here",
+        )
 
     def execute(self, rh, opts):  # @UnusedVariable
         """Convert SURFGEOPOTENTIEL from clim to SFX.ZS in pgd."""
         from ..util.usepygram import epygram_checker, epy_env_prepare
         from bronx.meteo.constants import g0
+
         # Handle resources
-        clim = self.context.sequence.effective_inputs(role=('Clim',))
+        clim = self.context.sequence.effective_inputs(role=("Clim",))
         self.algoassert(len(clim) == 1, "One and only one Clim to be provided")
-        pgdin = self.context.sequence.effective_inputs(role=('InputPGD',))
-        self.algoassert(len(pgdin) == 1, "One and only one InputPGD to be provided")
+        pgdin = self.context.sequence.effective_inputs(role=("InputPGD",))
+        self.algoassert(
+            len(pgdin) == 1, "One and only one InputPGD to be provided"
+        )
         # copy fields
         with epy_env_prepare(self.ticket):
             epyclim = clim[0].rh.contents.data
             epypgd = pgdin[0].rh.contents.data
             epyclim.open()
-            epypgd.open(openmode='a')
+            epypgd.open(openmode="a")
             # read spectrally fitted surface geopotential
-            g = epyclim.readfield('SURFGEOPOTENTIEL')
+            g = epyclim.readfield("SURFGEOPOTENTIEL")
             # convert to SURFEX orography
-            g.operation('/', g0)
-            g.fid['FA'] = 'SFX.ZS'
+            g.operation("/", g0)
+            g.fid["FA"] = "SFX.ZS"
             # write as orography
-            if epygram_checker.is_available(version='1.3.6'):
-                epypgd.fieldencoding(g.fid['FA'], update_fieldscompression=True)
+            if epygram_checker.is_available(version="1.3.6"):
+                epypgd.fieldencoding(
+                    g.fid["FA"], update_fieldscompression=True
+                )
             else:
                 # blank read, just to update fieldscompression
-                epypgd.readfield(g.fid['FA'], getdata=False)
-            epypgd.writefield(g, compression=epypgd.fieldscompression.get(g.fid['FA'], None))
+                epypgd.readfield(g.fid["FA"], getdata=False)
+            epypgd.writefield(
+                g, compression=epypgd.fieldscompression.get(g.fid["FA"], None)
+            )
             epypgd.close()
 
 
@@ -240,70 +283,78 @@ class MakeLAMDomain(AlgoComponent):
     """
 
     _footprint = dict(
-        attr = dict(
-            kind = dict(
-                values = ['make_domain', 'make_lam_domain'],
-            ),
-            geometry = dict(
-                info = "The horizontal geometry to be generated.",
-                type = HorizontalGeometry,
-            ),
-            mode = dict(
-                info = ("Kind of input for building geometry:" +
-                        "'center_dims' to build domain given its centre and" +
-                        "dimensions; 'lonlat_included' to build domain given" +
-                        "an included lon/lat area."),
-                values = ['center_dims', 'lonlat_included']
-            ),
-            geom_params = dict(
-                info = ("Set of parameters and/or options to be passed to" +
-                        "epygram.geometries.domain_making.build.build_geometry()" +
-                        "or" +
-                        "epygram.geometries.domain_making.build.build_geometry_fromlonlat()"),
-                type = footprints.FPDict,
-            ),
-            truncation = dict(
-                info = ("Type of spectral truncation, among" +
-                        "('linear', 'quadratic', 'cubic')."),
-                optional = True,
-                default = 'linear',
-            ),
-            orography_truncation = dict(
-                info = ("Type of truncation of orography, among" +
-                        "('linear', 'quadratic', 'cubic')."),
-                optional = True,
-                default = 'quadratic',
-            ),
-            e_zone_in_pgd = dict(
-                info = "Add E-zone sizes in BuildPGD namelist.",
-                optional = True,
-                type = bool,
-                default = False
-            ),
-            i_width_in_pgd = dict(
-                info = "Add I-width size in BuildPGD namelist.",
-                optional = True,
-                type = bool,
-                default = False
+        attr=dict(
+            kind=dict(
+                values=["make_domain", "make_lam_domain"],
+            ),
+            geometry=dict(
+                info="The horizontal geometry to be generated.",
+                type=HorizontalGeometry,
+            ),
+            mode=dict(
+                info=(
+                    "Kind of input for building geometry:"
+                    + "'center_dims' to build domain given its centre and"
+                    + "dimensions; 'lonlat_included' to build domain given"
+                    + "an included lon/lat area."
+                ),
+                values=["center_dims", "lonlat_included"],
+            ),
+            geom_params=dict(
+                info=(
+                    "Set of parameters and/or options to be passed to"
+                    + "epygram.geometries.domain_making.build.build_geometry()"
+                    + "or"
+                    + "epygram.geometries.domain_making.build.build_geometry_fromlonlat()"
+                ),
+                type=footprints.FPDict,
+            ),
+            truncation=dict(
+                info=(
+                    "Type of spectral truncation, among"
+                    + "('linear', 'quadratic', 'cubic')."
+                ),
+                optional=True,
+                default="linear",
+            ),
+            orography_truncation=dict(
+                info=(
+                    "Type of truncation of orography, among"
+                    + "('linear', 'quadratic', 'cubic')."
+                ),
+                optional=True,
+                default="quadratic",
+            ),
+            e_zone_in_pgd=dict(
+                info="Add E-zone sizes in BuildPGD namelist.",
+                optional=True,
+                type=bool,
+                default=False,
+            ),
+            i_width_in_pgd=dict(
+                info="Add I-width size in BuildPGD namelist.",
+                optional=True,
+                type=bool,
+                default=False,
             ),
             # plot
-            illustration = dict(
-                info = "Create the domain illustration image.",
-                type = bool,
-                optional = True,
-                default = True
-            ),
-            illustration_fmt = dict(
-                info = "The format of the domain illustration image.",
-                values = ['png', 'pdf'],
-                optional = True,
-                default = 'png'
-            ),
-            plot_params = dict(
-                info = "Plot geometry parameters.",
-                type = footprints.FPDict,
-                optional = True,
-                default = footprints.FPDict({'background': True})
+            illustration=dict(
+                info="Create the domain illustration image.",
+                type=bool,
+                optional=True,
+                default=True,
+            ),
+            illustration_fmt=dict(
+                info="The format of the domain illustration image.",
+                values=["png", "pdf"],
+                optional=True,
+                default="png",
+            ),
+            plot_params=dict(
+                info="Plot geometry parameters.",
+                type=footprints.FPDict,
+                optional=True,
+                default=footprints.FPDict({"background": True}),
             ),
         )
     )
@@ -311,61 +362,87 @@ class MakeLAMDomain(AlgoComponent):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         from ..util.usepygram import epygram_checker
-        ev = '1.2.14'
+
+        ev = "1.2.14"
         if self.e_zone_in_pgd:
-            ev = '1.3.2'
+            ev = "1.3.2"
         if self.i_width_in_pgd:
-            ev = '1.3.3'
-        self.algoassert(epygram_checker.is_available(version=ev), "Epygram >= " + ev +
-                        " is needed here")
+            ev = "1.3.3"
+        self.algoassert(
+            epygram_checker.is_available(version=ev),
+            "Epygram >= " + ev + " is needed here",
+        )
         self._check_geometry()
 
     def _check_geometry(self):
-        if self.mode == 'center_dims':
-            params = ['center_lon', 'center_lat', 'Xpoints_CI', 'Ypoints_CI',
-                      'resolution']
-            params_extended = params + ['tilting', 'Iwidth', 'force_projection',
-                                        'maximize_CI_in_E', 'reference_lat']
-        elif self.mode == 'lonlat_included':
-            params = ['lonmin', 'lonmax', 'latmin', 'latmax',
-                      'resolution']
-            params_extended = params + ['Iwidth', 'force_projection', 'maximize_CI_in_E']
-        self.algoassert(set(params).issubset(set(self.geom_params.keys())),
-                        "With mode=={!s}, geom_params must contain at least {!s}".
-                        format(self.mode, params))
-        self.algoassert(set(self.geom_params.keys()).issubset(set(params_extended)),
-                        "With mode=={!s}, geom_params must contain at most {!s}".
-                        format(self.mode, params))
+        if self.mode == "center_dims":
+            params = [
+                "center_lon",
+                "center_lat",
+                "Xpoints_CI",
+                "Ypoints_CI",
+                "resolution",
+            ]
+            params_extended = params + [
+                "tilting",
+                "Iwidth",
+                "force_projection",
+                "maximize_CI_in_E",
+                "reference_lat",
+            ]
+        elif self.mode == "lonlat_included":
+            params = ["lonmin", "lonmax", "latmin", "latmax", "resolution"]
+            params_extended = params + [
+                "Iwidth",
+                "force_projection",
+                "maximize_CI_in_E",
+            ]
+        self.algoassert(
+            set(params).issubset(set(self.geom_params.keys())),
+            "With mode=={!s}, geom_params must contain at least {!s}".format(
+                self.mode, params
+            ),
+        )
+        self.algoassert(
+            set(self.geom_params.keys()).issubset(set(params_extended)),
+            "With mode=={!s}, geom_params must contain at most {!s}".format(
+                self.mode, params
+            ),
+        )
 
     def execute(self, rh, opts):  # @UnusedVariable
         from ..util.usepygram import epygram
+
         dm = epygram.geometries.domain_making
-        if self.mode == 'center_dims':
+        if self.mode == "center_dims":
             build_func = dm.build.build_geometry
             lonlat_included = None
-        elif self.mode == 'lonlat_included':
+        elif self.mode == "lonlat_included":
             build_func = dm.build.build_geometry_fromlonlat
             lonlat_included = self.geom_params
         # build geometry
         geometry = build_func(interactive=False, **self.geom_params)
         # summary, plot, namelists:
-        with open(self.geometry.tag + '_summary.txt', 'w') as o:
+        with open(self.geometry.tag + "_summary.txt", "w") as o:
             o.write(str(dm.output.summary(geometry)))
         if self.illustration:
-            dm.output.plot_geometry(geometry,
-                                    lonlat_included=lonlat_included,
-                                    out='.'.join([self.geometry.tag,
-                                                  self.illustration_fmt]),
-                                    **self.plot_params)
+            dm.output.plot_geometry(
+                geometry,
+                lonlat_included=lonlat_included,
+                out=".".join([self.geometry.tag, self.illustration_fmt]),
+                **self.plot_params,
+            )
         dm_extra_params = dict()
         if self.e_zone_in_pgd:
-            dm_extra_params['Ezone_in_pgd'] = self.e_zone_in_pgd
+            dm_extra_params["Ezone_in_pgd"] = self.e_zone_in_pgd
         if self.i_width_in_pgd:
-            dm_extra_params['Iwidth_in_pgd'] = self.i_width_in_pgd
-        namelists = dm.output.lam_geom2namelists(geometry,
-                                                 truncation=self.truncation,
-                                                 orography_subtruncation=self.orography_truncation,
-                                                 **dm_extra_params)
+            dm_extra_params["Iwidth_in_pgd"] = self.i_width_in_pgd
+        namelists = dm.output.lam_geom2namelists(
+            geometry,
+            truncation=self.truncation,
+            orography_subtruncation=self.orography_truncation,
+            **dm_extra_params,
+        )
         dm.output.write_namelists(namelists, prefix=self.geometry.tag)
 
 
@@ -376,95 +453,95 @@ class MakeGaussGeometry(Parallel):
     """
 
     _footprint = dict(
-        attr = dict(
-            kind = dict(
-                values = ['make_gauss_grid'],
-            ),
-            geometry = dict(
-                info = "The vortex horizontal geometry to be generated.",
-                type = HorizontalGeometry,
-            ),
-            truncation = dict(
-                info = 'nominal truncation',
-                type = int,
-            ),
-            grid = dict(
-                info = 'type of grid with regards to truncation, among (linear, quadratic, cubic)',
-                optional = True,
-                default = 'linear'
-            ),
-            orography_grid = dict(
-                info = 'orography subtruncation (linear, quadratic, cubic)',
-                optional = True,
-                default = 'quadratic'
-            ),
-            stretching = dict(
-                info = 'stretching factor',
-                type = float,
-                optional = True,
-                default = 1.,
-            ),
-            pole = dict(
-                info = 'pole of stretching (lon, lat), angles in degrees',
-                type = footprints.FPDict,
-                optional = True,
-                default = {'lon': 0., 'lat': 90.}
+        attr=dict(
+            kind=dict(
+                values=["make_gauss_grid"],
+            ),
+            geometry=dict(
+                info="The vortex horizontal geometry to be generated.",
+                type=HorizontalGeometry,
+            ),
+            truncation=dict(
+                info="nominal truncation",
+                type=int,
+            ),
+            grid=dict(
+                info="type of grid with regards to truncation, among (linear, quadratic, cubic)",
+                optional=True,
+                default="linear",
+            ),
+            orography_grid=dict(
+                info="orography subtruncation (linear, quadratic, cubic)",
+                optional=True,
+                default="quadratic",
+            ),
+            stretching=dict(
+                info="stretching factor",
+                type=float,
+                optional=True,
+                default=1.0,
+            ),
+            pole=dict(
+                info="pole of stretching (lon, lat), angles in degrees",
+                type=footprints.FPDict,
+                optional=True,
+                default={"lon": 0.0, "lat": 90.0},
             ),
             # RGRID commandline options
-            latitudes = dict(
-                info = 'number of Gaussian latitudes',
-                type = int,
-                optional = True,
-                default = None
-            ),
-            longitudes = dict(
-                info = 'maximum (equatorial) number of longitudes',
-                type = int,
-                optional = True,
-                default = None
-            ),
-            orthogonality = dict(
-                info = 'orthogonality precision, as Log10() value',
-                type = int,
-                optional = True,
-                default = None
-            ),
-            aliasing = dict(
-                info = 'allowed aliasing, as a Log10() value',
-                type = int,
-                optional = True,
-                default = None
-            ),
-            oddity = dict(
-                info = 'odd numbers allowed (1) or not (0)',
-                type = int,
-                optional = True,
-                default = None
-            ),
-            verbosity = dict(
-                info = 'verbosity (0 or 1)',
-                type = int,
-                optional = True,
-                default = None
+            latitudes=dict(
+                info="number of Gaussian latitudes",
+                type=int,
+                optional=True,
+                default=None,
+            ),
+            longitudes=dict(
+                info="maximum (equatorial) number of longitudes",
+                type=int,
+                optional=True,
+                default=None,
+            ),
+            orthogonality=dict(
+                info="orthogonality precision, as Log10() value",
+                type=int,
+                optional=True,
+                default=None,
+            ),
+            aliasing=dict(
+                info="allowed aliasing, as a Log10() value",
+                type=int,
+                optional=True,
+                default=None,
+            ),
+            oddity=dict(
+                info="odd numbers allowed (1) or not (0)",
+                type=int,
+                optional=True,
+                default=None,
+            ),
+            verbosity=dict(
+                info="verbosity (0 or 1)",
+                type=int,
+                optional=True,
+                default=None,
             ),
             # plot
-            illustration = dict(
-                info = "Create the domain illustration image.",
-                type = bool,
-                optional = True,
-                default = True
-            ),
-            illustration_fmt = dict(
-                info = "The format of the domain illustration image.",
-                values = ['png', 'pdf'],
-                optional = True,
-                default = 'png'
-            ),
-            plot_params = dict(
-                info = "Plot geometry parameters.",
-                type = footprints.FPDict,
-                optional = True,
-                default = footprints.FPDict({'background': True})
+            illustration=dict(
+                info="Create the domain illustration image.",
+                type=bool,
+                optional=True,
+                default=True,
+            ),
+            illustration_fmt=dict(
+                info="The format of the domain illustration image.",
+                values=["png", "pdf"],
+                optional=True,
+                default="png",
+            ),
+            plot_params=dict(
+                info="Plot geometry parameters.",
+                type=footprints.FPDict,
+                optional=True,
+                default=footprints.FPDict({"background": True}),
             ),
         )
     )
@@ -472,51 +549,68 @@ class MakeGaussGeometry(Parallel):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         from ..util.usepygram import epygram_checker
-        ev = '1.2.14'
-        self.algoassert(epygram_checker.is_available(version=ev), "Epygram >= " + ev +
-                        " is needed here")
+
+        ev = "1.2.14"
+        self.algoassert(
+            epygram_checker.is_available(version=ev),
+            "Epygram >= " + ev + " is needed here",
+        )
         self._complete_dimensions()
         self._unit = 4
 
     def _complete_dimensions(self):
         from ..util.usepygram import epygram_checker
-        if epygram_checker.is_available(version='1.4.4'):
-            from epygram.geometries.SpectralGeometry import complete_gridpoint_dimensions
-            longitudes, latitudes = complete_gridpoint_dimensions(self.longitudes,
-                                                                  self.latitudes,
-                                                                  self.truncation,
-                                                                  self.grid,
-                                                                  self.stretching)
-            self._attributes['longitudes'] = longitudes
-            self._attributes['latitudes'] = latitudes
+
+        if epygram_checker.is_available(version="1.4.4"):
+            from epygram.geometries.SpectralGeometry import (
+                complete_gridpoint_dimensions,
+            )
+
+            longitudes, latitudes = complete_gridpoint_dimensions(
+                self.longitudes,
+                self.latitudes,
+                self.truncation,
+                self.grid,
+                self.stretching,
+            )
+            self._attributes["longitudes"] = longitudes
+            self._attributes["latitudes"] = latitudes
         else:
             self._old_internal_complete_dimensions()
 
     def _old_internal_complete_dimensions(self):
-        from epygram.geometries.SpectralGeometry import gridpoint_dims_from_truncation
+        from epygram.geometries.SpectralGeometry import (
+            gridpoint_dims_from_truncation,
+        )
+
         if self.latitudes is None and self.longitudes is None:
-            dims = gridpoint_dims_from_truncation({'max': self.truncation},
-                                                  grid=self.grid)
-            self._attributes['latitudes'] = dims['lat_number']
-            self._attributes['longitudes'] = dims['max_lon_number']
+            dims = gridpoint_dims_from_truncation(
+                {"max": self.truncation}, grid=self.grid
+            )
+            self._attributes["latitudes"] = dims["lat_number"]
+            self._attributes["longitudes"] = dims["max_lon_number"]
         elif self.longitudes is None:
-            self._attributes['longitudes'] = 2 * self.latitudes
+            self._attributes["longitudes"] = 2 * self.latitudes
         elif self.latitudes is None:
             if self.longitudes % 4 != 0:
-                self._attributes['latitudes'] = self.longitudes // 2 + 1
+                self._attributes["latitudes"] = self.longitudes // 2 + 1
             else:
-                self._attributes['latitudes'] = self.longitudes // 2
+                self._attributes["latitudes"] = self.longitudes // 2
 
     def spawn_command_options(self):
         """Prepare options for the resource's command line."""
-        options = {'t': str(self.truncation),
-                   'g': str(self.latitudes),
-                   'l': str(self.longitudes),
-                   'f': str(self._unit)}
-        options_dict = {'orthogonality': 'o',
-                        'aliasing': 'a',
-                        'oddity': 'n',
-                        'verbosity': 'v'}
+        options = {
+            "t": str(self.truncation),
+            "g": str(self.latitudes),
+            "l": str(self.longitudes),
+            "f": str(self._unit),
+        }
+        options_dict = {
+            "orthogonality": "o",
+            "aliasing": "a",
+            "oddity": "n",
+            "verbosity": "v",
+        }
         for k in options_dict.keys():
             if getattr(self, k) is not None:
                 options[options_dict[k]] = str(getattr(self, k))
@@ -525,16 +619,22 @@ class MakeGaussGeometry(Parallel):
     def postfix(self, rh, opts):
         """Complete and write namelists."""
         from ..util.usepygram import epygram_checker
-        if epygram_checker.is_available(version='1.4.4'):
-            from epygram.geometries.domain_making.output import gauss_rgrid2namelists
-            gauss_rgrid2namelists('fort.{!s}'.format(self._unit),
-                                  self.geometry.tag,
-                                  self.latitudes,
-                                  self.longitudes,
-                                  self.truncation,
-                                  self.stretching,
-                                  self.orography_grid,
-                                  self.pole)
+
+        if epygram_checker.is_available(version="1.4.4"):
+            from epygram.geometries.domain_making.output import (
+                gauss_rgrid2namelists,
+            )
+
+            gauss_rgrid2namelists(
+                "fort.{!s}".format(self._unit),
+                self.geometry.tag,
+                self.latitudes,
+                self.longitudes,
+                self.truncation,
+                self.stretching,
+                self.orography_grid,
+                self.pole,
+            )
         else:
             self._old_internal_postfix(rh, opts)
         super().postfix(rh, opts)
@@ -542,82 +642,97 @@ class MakeGaussGeometry(Parallel):
     def _old_internal_postfix(self, rh, opts):
         """Complete and write namelists."""
         import math
-        from epygram.geometries.SpectralGeometry import truncation_from_gridpoint_dims
+        from epygram.geometries.SpectralGeometry import (
+            truncation_from_gridpoint_dims,
+        )
+
         # complete scalar parameters
         nam = namelist.NamelistSet()
-        nam.add(namelist.NamelistBlock('NAM_PGD_GRID'))
-        nam.add(namelist.NamelistBlock('NAMDIM'))
-        nam.add(namelist.NamelistBlock('NAMGEM'))
-        nam['NAM_PGD_GRID']['CGRID'] = 'GAUSS'
-        nam['NAMDIM']['NDGLG'] = self.latitudes
-        nam['NAMDIM']['NDLON'] = self.longitudes
-        nam['NAMDIM']['NSMAX'] = self.truncation
-        nam['NAMGEM']['NHTYP'] = 2
-        nam['NAMGEM']['NSTTYP'] = 2 if self.pole != {'lon': 0., 'lat': 90.} else 1
-        nam['NAMGEM']['RMUCEN'] = math.sin(math.radians(float(self.pole['lat'])))
-        nam['NAMGEM']['RLOCEN'] = math.radians(float(self.pole['lon']))
-        nam['NAMGEM']['RSTRET'] = self.stretching
+        nam.add(namelist.NamelistBlock("NAM_PGD_GRID"))
+        nam.add(namelist.NamelistBlock("NAMDIM"))
+        nam.add(namelist.NamelistBlock("NAMGEM"))
+        nam["NAM_PGD_GRID"]["CGRID"] = "GAUSS"
+        nam["NAMDIM"]["NDGLG"] = self.latitudes
+        nam["NAMDIM"]["NDLON"] = self.longitudes
+        nam["NAMDIM"]["NSMAX"] = self.truncation
+        nam["NAMGEM"]["NHTYP"] = 2
+        nam["NAMGEM"]["NSTTYP"] = (
+            2 if self.pole != {"lon": 0.0, "lat": 90.0} else 1
+        )
+        nam["NAMGEM"]["RMUCEN"] = math.sin(
+            math.radians(float(self.pole["lat"]))
+        )
+        nam["NAMGEM"]["RLOCEN"] = math.radians(float(self.pole["lon"]))
+        nam["NAMGEM"]["RSTRET"] = self.stretching
         # numbers of longitudes
-        with open('fort.{!s}'.format(self._unit)) as n:
+        with open("fort.{!s}".format(self._unit)) as n:
             namrgri = namelist.namparse(n)
             nam.merge(namrgri)
         # PGD namelist
         nam_pgd = copy.deepcopy(nam)
-        nam_pgd['NAMGEM'].delvar('NHTYP')
-        nam_pgd['NAMGEM'].delvar('NSTTYP')
-        nam_pgd['NAMDIM'].delvar('NSMAX')
-        nam_pgd['NAMDIM'].delvar('NDLON')
-        with open('.'.join([self.geometry.tag,
-                            'namel_buildpgd',
-                            'geoblocks']),
-                  'w') as out:
+        nam_pgd["NAMGEM"].delvar("NHTYP")
+        nam_pgd["NAMGEM"].delvar("NSTTYP")
+        nam_pgd["NAMDIM"].delvar("NSMAX")
+        nam_pgd["NAMDIM"].delvar("NDLON")
+        with open(
+            ".".join([self.geometry.tag, "namel_buildpgd", "geoblocks"]), "w"
+        ) as out:
             out.write(nam_pgd.dumps(sorting=namelist.SECOND_ORDER_SORTING))
         # C923 namelist
-        del nam['NAM_PGD_GRID']
-        with open('.'.join([self.geometry.tag,
-                            'namel_c923',
-                            'geoblocks']),
-                  'w') as out:
+        del nam["NAM_PGD_GRID"]
+        with open(
+            ".".join([self.geometry.tag, "namel_c923", "geoblocks"]), "w"
+        ) as out:
             out.write(nam.dumps(sorting=namelist.SECOND_ORDER_SORTING))
         # subtruncated grid for orography
         from ..util.usepygram import epygram_checker
-        ev = '1.4.4'
+
+        ev = "1.4.4"
         if epygram_checker.is_available(version=ev):
-            trunc_nsmax = truncation_from_gridpoint_dims({'lat_number': self.latitudes,
-                                                          'max_lon_number': self.longitudes},
-                                                         grid=self.orography_grid,
-                                                         stretching_coef=self.stretching
-                                                         )['max']
+            trunc_nsmax = truncation_from_gridpoint_dims(
+                {
+                    "lat_number": self.latitudes,
+                    "max_lon_number": self.longitudes,
+                },
+                grid=self.orography_grid,
+                stretching_coef=self.stretching,
+            )["max"]
         else:
-            trunc_nsmax = truncation_from_gridpoint_dims({'lat_number': self.latitudes,
-                                                          'max_lon_number': self.longitudes},
-                                                         grid=self.orography_grid
-                                                         )['max']
-        nam['NAMDIM']['NSMAX'] = trunc_nsmax
-        with open('.'.join([self.geometry.tag,
-                            'namel_c923_orography',
-                            'geoblocks']),
-                  'w') as out:
+            trunc_nsmax = truncation_from_gridpoint_dims(
+                {
+                    "lat_number": self.latitudes,
+                    "max_lon_number": self.longitudes,
+                },
+                grid=self.orography_grid,
+            )["max"]
+        nam["NAMDIM"]["NSMAX"] = trunc_nsmax
+        with open(
+            ".".join([self.geometry.tag, "namel_c923_orography", "geoblocks"]),
+            "w",
+        ) as out:
             out.write(nam.dumps(sorting=namelist.SECOND_ORDER_SORTING))
         # C927 (fullpos) namelist
         nam = namelist.NamelistSet()
-        nam.add(namelist.NamelistBlock('NAMFPD'))
-        nam.add(namelist.NamelistBlock('NAMFPG'))
-        nam['NAMFPD']['NLAT'] = self.latitudes
-        nam['NAMFPD']['NLON'] = self.longitudes
-        nam['NAMFPG']['NFPMAX'] = self.truncation
-        nam['NAMFPG']['NFPHTYP'] = 2
-        nam['NAMFPG']['NFPTTYP'] = 2 if self.pole != {'lon': 0., 'lat': 90.} else 1
-        nam['NAMFPG']['FPMUCEN'] = math.sin(math.radians(float(self.pole['lat'])))
-        nam['NAMFPG']['FPLOCEN'] = math.radians(float(self.pole['lon']))
-        nam['NAMFPG']['FPSTRET'] = self.stretching
-        nrgri = [v for _, v in sorted(namrgri['NAMRGRI'].items())]
+        nam.add(namelist.NamelistBlock("NAMFPD"))
+        nam.add(namelist.NamelistBlock("NAMFPG"))
+        nam["NAMFPD"]["NLAT"] = self.latitudes
+        nam["NAMFPD"]["NLON"] = self.longitudes
+        nam["NAMFPG"]["NFPMAX"] = self.truncation
+        nam["NAMFPG"]["NFPHTYP"] = 2
+        nam["NAMFPG"]["NFPTTYP"] = (
+            2 if self.pole != {"lon": 0.0, "lat": 90.0} else 1
+        )
+        nam["NAMFPG"]["FPMUCEN"] = math.sin(
+            math.radians(float(self.pole["lat"]))
+        )
+        nam["NAMFPG"]["FPLOCEN"] = math.radians(float(self.pole["lon"]))
+        nam["NAMFPG"]["FPSTRET"] = self.stretching
+        nrgri = [v for _, v in sorted(namrgri["NAMRGRI"].items())]
         for i in range(len(nrgri)):
-            nam['NAMFPG']['NFPRGRI({:>4})'.format(i + 1)] = nrgri[i]
-        with open('.'.join([self.geometry.tag,
-                            'namel_c927',
-                            'geoblocks']),
-                  'w') as out:
+            nam["NAMFPG"]["NFPRGRI({:>4})".format(i + 1)] = nrgri[i]
+        with open(
+            ".".join([self.geometry.tag, "namel_c927", "geoblocks"]), "w"
+        ) as out:
             out.write(nam.dumps(sorting=namelist.SECOND_ORDER_SORTING))
 
 
@@ -628,68 +743,70 @@ class MakeBDAPDomain(AlgoComponent):
     """
 
     _footprint = dict(
-        attr = dict(
-            kind = dict(
-                values = ['make_domain', 'make_bdap_domain'],
-            ),
-            geometry = dict(
-                info = "The horizontal geometry to be generated.",
-                type = HorizontalGeometry,
-            ),
-            mode = dict(
-                info = ("Kind of input for building geometry:" +
-                        "'boundaries' to build domain given its lon/lat boundaries" +
-                        "(+ resolution); 'inside_model' to build domain given" +
-                        "a model geometry to be included in (+ resolution)."),
-                values = ['boundaries', 'inside_model']
-            ),
-            resolution = dict(
-                info = "Resolution in degrees.",
-                type = float,
-                optional = True,
-                default = None,
+        attr=dict(
+            kind=dict(
+                values=["make_domain", "make_bdap_domain"],
+            ),
+            geometry=dict(
+                info="The horizontal geometry to be generated.",
+                type=HorizontalGeometry,
+            ),
+            mode=dict(
+                info=(
+                    "Kind of input for building geometry:"
+                    + "'boundaries' to build domain given its lon/lat boundaries"
+                    + "(+ resolution); 'inside_model' to build domain given"
+                    + "a model geometry to be included in (+ resolution)."
+                ),
+                values=["boundaries", "inside_model"],
+            ),
+            resolution=dict(
+                info="Resolution in degrees.",
+                type=float,
+                optional=True,
+                default=None,
             ),
             resolution_x=dict(
                 info="X resolution in degrees (if different from Y).",
                 type=float,
-                optional = True,
-                default = None,
+                optional=True,
+                default=None,
             ),
             resolution_y=dict(
                 info="Y resolution in degrees (if different from X).",
                 type=float,
-                optional = True,
-                default = None,
+                optional=True,
+                default=None,
             ),
-            boundaries = dict(
-                info = "Lonlat boundaries of the domain, case mode='boundaries'.",
-                type = footprints.FPDict,
-                optional = True,
-                default = None,
+            boundaries=dict(
+                info="Lonlat boundaries of the domain, case mode='boundaries'.",
+                type=footprints.FPDict,
+                optional=True,
+                default=None,
             ),
-            model_clim = dict(
-                info = "Filename of the model clim, case mode='inside_model'.",
-                optional = True,
-                default = None,
+            model_clim=dict(
+                info="Filename of the model clim, case mode='inside_model'.",
+                optional=True,
+                default=None,
             ),
             # plot
-            illustration = dict(
-                info = "Create the domain illustration image.",
-                type = bool,
-                optional = True,
-                default = True
-            ),
-            illustration_fmt = dict(
-                info = "The format of the domain illustration image.",
-                values = ['png', 'pdf'],
-                optional = True,
-                default = 'png'
-            ),
-            plot_params = dict(
-                info = "Plot geometry parameters.",
-                type = footprints.FPDict,
-                optional = True,
-                default = footprints.FPDict({'background': True})
+            illustration=dict(
+                info="Create the domain illustration image.",
+                type=bool,
+                optional=True,
+                default=True,
+            ),
+            illustration_fmt=dict(
+                info="The format of the domain illustration image.",
+                values=["png", "pdf"],
+                optional=True,
+                default="png",
+            ),
+            plot_params=dict(
+                info="Plot geometry parameters.",
+                type=footprints.FPDict,
+                optional=True,
+                default=footprints.FPDict({"background": True}),
             ),
         )
     )
@@ -697,37 +814,50 @@ class MakeBDAPDomain(AlgoComponent):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         from ..util.usepygram import epygram_checker
-        ev = '1.2.14'
-        self.algoassert(epygram_checker.is_available(version=ev), "Epygram >= " + ev +
-                        " is needed here")
-        if self.mode == 'boundaries':
-            params = ['lonmin', 'lonmax', 'latmin', 'latmax']
-            self.algoassert(set(params) == set(self.boundaries.keys()),
-                            "With mode=={}, boundaries must contain at least {}".
-                            format(self.mode, str(params)))
+
+        ev = "1.2.14"
+        self.algoassert(
+            epygram_checker.is_available(version=ev),
+            "Epygram >= " + ev + " is needed here",
+        )
+        if self.mode == "boundaries":
+            params = ["lonmin", "lonmax", "latmin", "latmax"]
+            self.algoassert(
+                set(params) == set(self.boundaries.keys()),
+                "With mode=={}, boundaries must contain at least {}".format(
+                    self.mode, str(params)
+                ),
+            )
             if self.model_clim is not None:
-                logger.info('attribute *model_clim* ignored')
-        elif self.mode == 'inside_model':
-            self.algoassert(self.model_clim is not None,
-                            "attribute *model_clim* must be provided with " +
-                            "mode=='inside_model'.")
+                logger.info("attribute *model_clim* ignored")
+        elif self.mode == "inside_model":
+            self.algoassert(
+                self.model_clim is not None,
+                "attribute *model_clim* must be provided with "
+                + "mode=='inside_model'.",
+            )
             self.algoassert(self.sh.path.exists(self.model_clim))
             if self.boundaries is not None:
-                logger.info('attribute *boundaries* ignored')
+                logger.info("attribute *boundaries* ignored")
         if self.resolution is None:
-            self.algoassert(None not in (self.resolution_x, self.resolution_y),
-                            "Must provide *resolution* OR *resolution_x/resolution_y*")
+            self.algoassert(
+                None not in (self.resolution_x, self.resolution_y),
+                "Must provide *resolution* OR *resolution_x/resolution_y*",
+            )
         else:
-            self.algoassert(self.resolution_x is None and self.resolution_y is None,
-                            "Must provide *resolution* OR *resolution_x/resolution_y*")
+            self.algoassert(
+                self.resolution_x is None and self.resolution_y is None,
+                "Must provide *resolution* OR *resolution_x/resolution_y*",
+            )
 
     def execute(self, rh, opts):  # @UnusedVariable
         from ..util.usepygram import epygram
+
         dm = epygram.geometries.domain_making
-        if self.mode == 'inside_model':
-            r = epygram.formats.resource(self.model_clim, 'r')
-            if r.format == 'FA':
-                g = r.readfield('SURFGEOPOTENTIEL')
+        if self.mode == "inside_model":
+            r = epygram.formats.resource(self.model_clim, "r")
+            if r.format == "FA":
+                g = r.readfield("SURFGEOPOTENTIEL")
             else:
                 raise NotImplementedError()
             boundaries = dm.build.compute_lonlat_included(g.geometry)
@@ -735,28 +865,28 @@ class MakeBDAPDomain(AlgoComponent):
             boundaries = self.boundaries
         # build geometry
         if self.resolution is None:
-            geometry = dm.build.build_lonlat_geometry(boundaries,
-                                                      resolution=(self.resolution_x,
-                                                                  self.resolution_y))
+            geometry = dm.build.build_lonlat_geometry(
+                boundaries, resolution=(self.resolution_x, self.resolution_y)
+            )
         else:
-            geometry = dm.build.build_lonlat_geometry(boundaries,
-                                                      resolution=self.resolution)
+            geometry = dm.build.build_lonlat_geometry(
+                boundaries, resolution=self.resolution
+            )
         # summary, plot, namelists:
         if self.illustration:
-            fig, _ = geometry.plotgeometry(color='red',
-                                           title=self.geometry.tag,
-                                           **self.plot_params)
-            fig.savefig('.'.join([self.geometry.tag,
-                                  self.illustration_fmt]),
-                        bbox_inches='tight')
+            fig, _ = geometry.plotgeometry(
+                color="red", title=self.geometry.tag, **self.plot_params
+            )
+            fig.savefig(
+                ".".join([self.geometry.tag, self.illustration_fmt]),
+                bbox_inches="tight",
+            )
         namelists = dm.output.regll_geom2namelists(geometry)
         dm.output.write_namelists(namelists, prefix=self.geometry.tag)
-        self.system.symlink('.'.join([self.geometry.tag,
-                                      'namel_c923',
-                                      'geoblocks']),
-                            '.'.join([self.geometry.tag,
-                                      'namel_c923_orography',
-                                      'geoblocks']))
+        self.system.symlink(
+            ".".join([self.geometry.tag, "namel_c923", "geoblocks"]),
+            ".".join([self.geometry.tag, "namel_c923_orography", "geoblocks"]),
+        )
 
 
 class AddPolesToGLOB(TaylorRun):
@@ -765,44 +895,50 @@ class AddPolesToGLOB(TaylorRun):
     """
 
     _footprint = dict(
-        info = "Add poles to a GLOB* regular FA Lon/Lat file that do not contain them.",
-        attr = dict(
-            kind = dict(
-                values   = ['add_poles'],
+        info="Add poles to a GLOB* regular FA Lon/Lat file that do not contain them.",
+        attr=dict(
+            kind=dict(
+                values=["add_poles"],
             ),
-        )
+        ),
     )
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         from ..util.usepygram import epygram_checker
-        ev = '1.3.4'
-        self.algoassert(epygram_checker.is_available(version=ev), "Epygram >= " + ev +
-                        " is needed here")
+
+        ev = "1.3.4"
+        self.algoassert(
+            epygram_checker.is_available(version=ev),
+            "Epygram >= " + ev + " is needed here",
+        )
 
     def execute(self, rh, opts):  # @UnusedVariable
         """Add poles to a GLOB* regular FA Lon/Lat file that do not contain them."""
         self._default_pre_execute(rh, opts)
         common_i = self._default_common_instructions(rh, opts)
-        clims = self.context.sequence.effective_inputs(role=('Clim',))
-        self._add_instructions(common_i, dict(filename=[s.rh.container.localpath()
-                                                        for s in clims]))
+        clims = self.context.sequence.effective_inputs(role=("Clim",))
+        self._add_instructions(
+            common_i,
+            dict(filename=[s.rh.container.localpath() for s in clims]),
+        )
         self._default_post_execute(rh, opts)
 
 
 class _AddPolesWorker(TaylorVortexWorker):
     _footprint = dict(
-        attr = dict(
-            kind = dict(
-                values = ['add_poles']
-            ),
-            filename = dict(
-                info='The file to be processed.'),
+        attr=dict(
+            kind=dict(values=["add_poles"]),
+            filename=dict(info="The file to be processed."),
         )
     )
 
     def vortex_task(self, **_):
-        from ..util.usepygram import add_poles_to_reglonlat_file, epy_env_prepare
+        from ..util.usepygram import (
+            add_poles_to_reglonlat_file,
+            epy_env_prepare,
+        )
+
         with epy_env_prepare(self.ticket):
             add_poles_to_reglonlat_file(self.filename)
 
@@ -813,21 +949,23 @@ class Festat(Parallel):
     """
 
     _footprint = dict(
-        info = "Run festat",
-        attr = dict(
-            kind = dict(
-                values = ['run_festat', ],
-            ),
-            nb_digits = dict(
-                info = "Number of digits on which the name of the files should be written",
-                type = int,
-                default = 3,
-                optional = True,
-            ),
-            prefix = dict(
-                info = "Name of the files for the binary",
-                optional = True,
-                default = "CNAME",
+        info="Run festat",
+        attr=dict(
+            kind=dict(
+                values=[
+                    "run_festat",
+                ],
+            ),
+            nb_digits=dict(
+                info="Number of digits on which the name of the files should be written",
+                type=int,
+                default=3,
+                optional=True,
+            ),
+            prefix=dict(
+                info="Name of the files for the binary",
+                optional=True,
+                default="CNAME",
             ),
         ),
     )
@@ -836,34 +974,52 @@ class Festat(Parallel):
 
     def prepare(self, rh, opts):
         # Check the namelist
-        input_namelist = self.context.sequence.effective_inputs(role="Namelist", kind="namelist")
+        input_namelist = self.context.sequence.effective_inputs(
+            role="Namelist", kind="namelist"
+        )
         if len(input_namelist) != 1:
             logger.error("One and only one namelist must be provided.")
             raise ValueError("One and only one namelist must be provided.")
         else:
             input_namelist = input_namelist[0].rh
         # Create links for the input files
-        maxinsec = 10 ** self.nb_digits
+        maxinsec = 10**self.nb_digits
         insec = self.context.sequence.effective_inputs(role="InputFiles")
         nbinsec = len(insec)
         if nbinsec > maxinsec:
-            logger.error("The number of input files %s exceed the maximum number of files available %s.",
-                         nbinsec, maxinsec)
-            raise ValueError("The number of input files exceed the maximum number of files available.")
+            logger.error(
+                "The number of input files %s exceed the maximum number of files available %s.",
+                nbinsec,
+                maxinsec,
+            )
+            raise ValueError(
+                "The number of input files exceed the maximum number of files available."
+            )
         else:
             logger.info("%s input files will be treated.", nbinsec)
         i = 0
         for sec in insec:
             i += 1
-            self.system.symlink(sec.rh.container.actualpath(),
-                                "{prefix}{number}".format(prefix=self.prefix,
-                                                          number=str(i).zfill(self.nb_digits)))
+            self.system.symlink(
+                sec.rh.container.actualpath(),
+                "{prefix}{number}".format(
+                    prefix=self.prefix, number=str(i).zfill(self.nb_digits)
+                ),
+            )
         # Put the number of sections and the prefix of the input files in the namelist
         namcontents = input_namelist.contents
-        logger.info('Setup macro CNAME=%s in %s', self.prefix, input_namelist.container.actualpath())
-        namcontents.setmacro('CNAME', self.prefix)
-        logger.info('Setup macro NCASES=%s in %s', i, input_namelist.container.actualpath())
-        namcontents.setmacro('NCASES', i)
+        logger.info(
+            "Setup macro CNAME=%s in %s",
+            self.prefix,
+            input_namelist.container.actualpath(),
+        )
+        namcontents.setmacro("CNAME", self.prefix)
+        logger.info(
+            "Setup macro NCASES=%s in %s",
+            i,
+            input_namelist.container.actualpath(),
+        )
+        namcontents.setmacro("NCASES", i)
         namcontents.rewrite(input_namelist.container)
         self._nb_input_files = i
         # Call the super class
@@ -873,19 +1029,27 @@ class Festat(Parallel):
         # Rename stabal files
         list_stabal = self.system.glob("stab*")
         for stabal in list_stabal:
-            self.system.mv(stabal,
-                           "{stabal}.ncases_{ncases}".format(stabal=stabal, ncases=self._nb_input_files))
+            self.system.mv(
+                stabal,
+                "{stabal}.ncases_{ncases}".format(
+                    stabal=stabal, ncases=self._nb_input_files
+                ),
+            )
         # Deal with diag files
         list_diag_stat = self.system.glob("co*y")
         if len(list_diag_stat) > 0:
-            diastat_dir_name = "dia.stat.ncases_{ncases}".format(ncases=self._nb_input_files)
+            diastat_dir_name = "dia.stat.ncases_{ncases}".format(
+                ncases=self._nb_input_files
+            )
             self.system.mkdir(diastat_dir_name)
             for file in list_diag_stat:
                 self.system.mv(file, diastat_dir_name + "/")
             self.system.tar(diastat_dir_name + ".tar", diastat_dir_name)
         list_diag_expl = self.system.glob("expl*y")
         if len(list_diag_expl) > 0:
-            diaexpl_dir_name = "dia.expl.ncases_{ncases}".format(ncases=self._nb_input_files)
+            diaexpl_dir_name = "dia.expl.ncases_{ncases}".format(
+                ncases=self._nb_input_files
+            )
             self.system.mkdir(diaexpl_dir_name)
             for file in list_diag_expl:
                 self.system.mv(file, diaexpl_dir_name + "/")
@@ -900,10 +1064,12 @@ class Fediacov(Parallel):
     """
 
     _footprint = dict(
-        info = "Run fediacov",
-        attr = dict(
-            kind = dict(
-                values = ['run_fediacov', ],
+        info="Run fediacov",
+        attr=dict(
+            kind=dict(
+                values=[
+                    "run_fediacov",
+                ],
             ),
         ),
     )