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

vortex/nwp/algo/forecasts.py

@@ -35,52 +35,49 @@ class Forecast(IFSParallel):
     _footprint = [
         outputid_deco,
         dict(
-            info = "Run a forecast with Arpege/IFS.",
-            attr = dict(
-                kind = dict(
-                    values   = ['forecast', 'fc'],
-                    remap    = dict(forecast = 'fc')
+            info="Run a forecast with Arpege/IFS.",
+            attr=dict(
+                kind=dict(
+                    values=["forecast", "fc"], remap=dict(forecast="fc")
                 ),
-                hist_terms = dict(
-                    info     = "The list of terms when historical file production is requested.",
-                    type     = footprints.FPList,
-                    optional = True,
+                hist_terms=dict(
+                    info="The list of terms when historical file production is requested.",
+                    type=footprints.FPList,
+                    optional=True,
                 ),
-                surfhist_terms = dict(
-                    info     ="The list of terms when surface file production is requested.",
-                    type     = footprints.FPList,
-                    optional = True,
+                surfhist_terms=dict(
+                    info="The list of terms when surface file production is requested.",
+                    type=footprints.FPList,
+                    optional=True,
                 ),
                 pos_terms=dict(
-                    info     = "The list of terms when post-processed data is requested.",
-                    type     = footprints.FPList,
-                    optional = True,
+                    info="The list of terms when post-processed data is requested.",
+                    type=footprints.FPList,
+                    optional=True,
                 ),
                 s_norm_terms=dict(
-                    info     = "The list of terms when spectal norms should be computed.",
-                    type     = footprints.FPList,
-                    optional = True,
+                    info="The list of terms when spectal norms should be computed.",
+                    type=footprints.FPList,
+                    optional=True,
                 ),
-                flyargs = dict(
-                    default  = ('ICMSH', 'PF'),
+                flyargs=dict(
+                    default=("ICMSH", "PF"),
                 ),
-                xpname = dict(
-                    default  = 'FCST'
+                xpname=dict(default="FCST"),
+                ddhpack=dict(
+                    info="After run, gather the DDH output file in directories.",
+                    type=bool,
+                    optional=True,
+                    default=False,
+                    doc_zorder=-5,
                 ),
-                ddhpack = dict(
-                    info        = "After run, gather the DDH output file in directories.",
-                    type        = bool,
-                    optional    = True,
-                    default     = False,
-                    doc_zorder  = -5,
-                ),
-            )
-        )
+            ),
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'forecast'
+        return "forecast"
 
     def _outputs_configurator(self, bin_rh):
         return footprints.proxy.ifsoutputs_configurator(
@@ -93,10 +90,9 @@ class Forecast(IFSParallel):
         """Default pre-link for the initial condition file"""
         super().prepare(rh, opts)
 
-        ininc = self.naming_convention('ic', rh)
+        ininc = self.naming_convention("ic", rh)
         analysis = self.setlink(
-            initrole=('InitialCondition', 'Analysis'),
-            initname=ininc()
+            initrole=("InitialCondition", "Analysis"), initname=ininc()
         )
 
         if analysis:
@@ -104,10 +100,14 @@ class Forecast(IFSParallel):
             thismonth = analysis.rh.resource.date.month
 
             # Possibly fix the model clim
-            if self.do_climfile_fixer(rh, convkind='modelclim'):
-                self.climfile_fixer(rh, convkind='modelclim', month=thismonth,
-                                    inputrole=('GlobalClim', 'InitialClim'),
-                                    inputkind='clim_model')
+            if self.do_climfile_fixer(rh, convkind="modelclim"):
+                self.climfile_fixer(
+                    rh,
+                    convkind="modelclim",
+                    month=thismonth,
+                    inputrole=("GlobalClim", "InitialClim"),
+                    inputkind="clim_model",
+                )
 
             # Possibly fix post-processing clim files
             self.all_localclim_fixer(rh, thismonth)
@@ -127,10 +127,10 @@ class Forecast(IFSParallel):
             #
             # TODO: Clarify where both regexp keys are coming from
             guesses = self.context.sequence.effective_inputs(
-                role=re.compile(r'IAU_(Background|Guess)', flags=re.IGNORECASE)
+                role=re.compile(r"IAU_(Background|Guess)", flags=re.IGNORECASE)
             )
             analyses = self.context.sequence.effective_inputs(
-                role=re.compile(r'IAU_(Analysis|Ic)', flags=re.IGNORECASE)
+                role=re.compile(r"IAU_(Analysis|Ic)", flags=re.IGNORECASE)
             )
 
             def key(s: Section):
@@ -140,32 +140,41 @@ class Forecast(IFSParallel):
                     s.rh.resource.date,
                     s.rh.resource.date + s.rh.resource.term,
                 )
+
             self._create_ordered_links(
-                bin_handler=rh, sections=analyses,
-                sort_key=key, nameconv_kind="iau_analysis",
+                bin_handler=rh,
+                sections=analyses,
+                sort_key=key,
+                nameconv_kind="iau_analysis",
             )
             self._create_ordered_links(
-                bin_handler=rh, sections=guesses,
-                sort_key=key, nameconv_kind="iau_background",
+                bin_handler=rh,
+                sections=guesses,
+                sort_key=key,
+                nameconv_kind="iau_background",
             )
 
         # Promises should be nicely managed by a co-proccess
         if self.promises:
             prefixes_set = set()
             for pr_res in [pr.rh.resource for pr in self.promises]:
-                if pr_res.realkind == 'historic':
-                    prefixes_set.add('ICMSH')
-                if pr_res.realkind == 'gridpoint':
-                    prefixes_set.add('{:s}PF'.format('GRIB' if pr_res.nativefmt == 'grib' else ''))
+                if pr_res.realkind == "historic":
+                    prefixes_set.add("ICMSH")
+                if pr_res.realkind == "gridpoint":
+                    prefixes_set.add(
+                        "{:s}PF".format(
+                            "GRIB" if pr_res.nativefmt == "grib" else ""
+                        )
+                    )
             self.io_poll_args = tuple(prefixes_set)
             self.flyput = len(self.io_poll_args) > 0
 
     def _create_ordered_links(
-            self,
-            bin_handler: Handler,
-            sections: Iterable[Section],
-            sort_key: Callable[[Section], Any],
-            nameconv_kind: str,
+        self,
+        bin_handler: Handler,
+        sections: Iterable[Section],
+        sort_key: Callable[[Section], Any],
+        nameconv_kind: str,
     ):
         """Create links to local files, with ordered names
 
@@ -181,7 +190,8 @@ class Forecast(IFSParallel):
         """
         for i, sec in enumerate(sorted(sections, key=sort_key)):
             nameconv = self.naming_convention(
-                nameconv_kind, bin_handler,
+                nameconv_kind,
+                bin_handler,
                 actualfmt=sec.rh.container.actualfmt,
             )
             target = nameconv(number=(i + 1))
@@ -189,7 +199,9 @@ class Forecast(IFSParallel):
             if self.system.path.exists(target):
                 logger.warning(
                     "%s should be linked to %s but %s already exists.",
-                    link_name, target, target
+                    link_name,
+                    target,
+                    target,
                 )
                 continue
             logger.info("Linking %s to %s.", link_name, target)
@@ -198,15 +210,16 @@ class Forecast(IFSParallel):
 
     def find_namelists(self, opts=None):
         """Find any namelists candidates in actual context inputs."""
-        return [x.rh
-                for x in self.context.sequence.effective_inputs(role='Namelist',
-                                                                kind='namelist')]
+        return [
+            x.rh
+            for x in self.context.sequence.effective_inputs(
+                role="Namelist", kind="namelist"
+            )
+        ]
 
     def prepare_namelist_delta(self, rh, namcontents, namlocal):
-        nam_updated = super().prepare_namelist_delta(
-            rh, namcontents, namlocal
-        )
-        if namlocal == 'fort.4':
+        nam_updated = super().prepare_namelist_delta(rh, namcontents, namlocal)
+        if namlocal == "fort.4":
             o_conf = self._outputs_configurator(rh)
             o_conf.modelstate = self.hist_terms
             o_conf.surf_modelstate = self.surfhist_terms
@@ -222,34 +235,40 @@ class Forecast(IFSParallel):
         sh = self.system
 
         # Look up for the gridpoint files
-        gp_out = sh.ls('PF{}*'.format(self.xpname))
+        gp_out = sh.ls("PF{}*".format(self.xpname))
         gp_map = defaultdict(list)
         if gp_out:
-            re_pf = re.compile(r'^PF{}(\w+)\+(\d+(?::\d+)?)$'.format(self.xpname))
+            re_pf = re.compile(
+                r"^PF{}(\w+)\+(\d+(?::\d+)?)$".format(self.xpname)
+            )
             for fname in gp_out:
                 match_pf = re_pf.match(fname)
                 if match_pf:
-                    gp_map[match_pf.group(1).lower()].append(Time(match_pf.group(2)))
+                    gp_map[match_pf.group(1).lower()].append(
+                        Time(match_pf.group(2))
+                    )
             for k, v in gp_map.items():
                 v.sort()
-                logger.info('Gridpoint files found: domain=%s, terms=%s',
-                            k,
-                            ','.join([str(t) for t in v]))
+                logger.info(
+                    "Gridpoint files found: domain=%s, terms=%s",
+                    k,
+                    ",".join([str(t) for t in v]),
+                )
         if len(gp_map) == 0:
-            logger.info('No gridpoint file was found.')
-        sh.json_dump(gp_map, 'gridpoint_map.out', indent=4, cls=ShellEncoder)
+            logger.info("No gridpoint file was found.")
+        sh.json_dump(gp_map, "gridpoint_map.out", indent=4, cls=ShellEncoder)
 
         # Gather DDH in folders
         if self.ddhpack:
-            ddhmap = dict(DL='dlimited', GL='global', ZO='zonal')
-            for (prefix, ddhkind) in ddhmap.items():
-                flist = sh.glob('DHF{}{}+*'.format(prefix, self.xpname))
+            ddhmap = dict(DL="dlimited", GL="global", ZO="zonal")
+            for prefix, ddhkind in ddhmap.items():
+                flist = sh.glob("DHF{}{}+*".format(prefix, self.xpname))
                 if flist:
-                    dest = 'ddhpack_{}'.format(ddhkind)
-                    logger.info('Creating a DDH pack: %s', dest)
+                    dest = "ddhpack_{}".format(ddhkind)
+                    logger.info("Creating a DDH pack: %s", dest)
                     sh.mkdir(dest)
                     for lfa in flist:
-                        sh.mv(lfa, dest, fmt='lfa')
+                        sh.mv(lfa, dest, fmt="lfa")
 
         super().postfix(rh, opts)
 
@@ -258,36 +277,27 @@ class LAMForecast(Forecast):
     """Forecast for IFS-like Limited Area Models."""
 
     _footprint = dict(
-        info = "Run a forecast with an Arpege/IFS like Limited Area Model.",
-        attr = dict(
-            kind = dict(
-                values   = ['lamfc', 'lamforecast'],
-                remap    = dict(lamforecast = 'lamfc'),
-            ),
-            synctool = dict(
-                info            = 'The name of the script called when waiting for coupling files',
-                optional        = True,
-                default         = 'atcp.alad',
-                doc_visibility  = footprints.doc.visibility.ADVANCED,
+        info="Run a forecast with an Arpege/IFS like Limited Area Model.",
+        attr=dict(
+            kind=dict(
+                values=["lamfc", "lamforecast"],
+                remap=dict(lamforecast="lamfc"),
             ),
-            synctpl = dict(
-                info            = 'The template used to generate the *synctool* script',
-                optional        = True,
-                default         = '@sync-fetch.tpl',
-                doc_visibility  = footprints.doc.visibility.ADVANCED,
-            ),
-        )
+        ),
     )
 
+    synctool = "atcp.alad"
+    synctpl = "sync-fetch.tpl"
+
     def spawn_command_options(self):
         """Dictionary provided for command line factory."""
         return dict(
-            name=(self.xpname + 'xxxx')[:4].upper(),
+            name=(self.xpname + "xxxx")[:4].upper(),
             timescheme=self.timescheme,
             timestep=self.timestep,
             fcterm=self.fcterm,
             fcunit=self.fcunit,
-            model='aladin',
+            model="aladin",
         )
 
     def prepare(self, rh, opts):
@@ -297,31 +307,36 @@ class LAMForecast(Forecast):
         sh = self.system
 
         # Check boundaries conditions
-        cplrh = [x.rh for x in self.context.sequence.effective_inputs(
-            role='BoundaryConditions',
-            kind='boundary'
-        )]
+        cplrh = [
+            x.rh
+            for x in self.context.sequence.effective_inputs(
+                role="BoundaryConditions", kind="boundary"
+            )
+        ]
         cplrh.sort(key=lambda rh: rh.resource.date + rh.resource.term)
 
         # Ordered pre-linking of boundaring and building ot the synchronization tools
         firstsync = None
-        sh.header('Check boundaries...')
+        sh.header("Check boundaries...")
         if any([x.is_expected() for x in cplrh]):
-            logger.info('Some boundaries conditions are still expected')
+            logger.info("Some boundaries conditions are still expected")
             self.mksync = True
         else:
-            logger.info('All boundaries conditions available')
+            logger.info("All boundaries conditions available")
             self.mksync = False
 
         for i, bound in enumerate(cplrh):
             thisbound = bound.container.localpath()
-            lbcnc = self.naming_convention('lbc', rh, actualfmt=bound.container.actualfmt)
+            lbcnc = self.naming_convention(
+                "lbc", rh, actualfmt=bound.container.actualfmt
+            )
             sh.softlink(thisbound, lbcnc(number=i))
             if self.mksync:
-                thistool = self.synctool + '.{:03d}'.format(i)
-                bound.mkgetpr(pr_getter=thistool, tplfetch=self.synctpl)
+                bound.mkgetpr(
+                    pr_getter=self.synctool + ".{:03d}".format(i),
+                )
                 if firstsync is None:
-                    firstsync = thistool
+                    firstsync = self.synctool + ".{:03d}".format(i)
 
         # Set up the first synchronization step
         if firstsync is not None:
@@ -332,7 +347,7 @@ class LAMForecast(Forecast):
         sh = self.system
 
         if self.mksync:
-            synclog = self.synctool + '.log'
+            synclog = self.synctool + ".log"
             if sh.path.exists(synclog):
                 sh.subtitle(synclog)
                 sh.cat(synclog, output=False)
@@ -344,19 +359,19 @@ class DFIForecast(LAMForecast):
     """OBSOLETE CODE: do not use."""
 
     _footprint = dict(
-        info = "Run a forecast with an Arpege/IFS like Limited Area Model (with DFIs).",
-        attr = dict(
-            kind = dict(
-                values = ['fcdfi'],
+        info="Run a forecast with an Arpege/IFS like Limited Area Model (with DFIs).",
+        attr=dict(
+            kind=dict(
+                values=["fcdfi"],
             ),
-        )
+        ),
     )
 
     def prepare(self, rh, opts):
         """Pre-link boundary conditions as special DFI files."""
         super().prepare(rh, opts)
-        ininc = self.naming_convention('ic', rh)
-        lbcnc = self.naming_convention('lbc', rh, actualfmt='fa')
+        ininc = self.naming_convention("ic", rh)
+        lbcnc = self.naming_convention("lbc", rh, actualfmt="fa")
         for pseudoterm in (999, 0, 1):
             self.system.softlink(ininc(), lbcnc(number=pseudoterm))
 
@@ -369,29 +384,27 @@ class FullPos(IFSParallel):
 
     _abstract = True
     _footprint = dict(
-        attr = dict(
-            xpname = dict(
-                default = 'FPOS'
-            ),
-            flyput = dict(
-                default  = False,
-                values   = [False],
+        attr=dict(
+            xpname=dict(default="FPOS"),
+            flyput=dict(
+                default=False,
+                values=[False],
             ),
-            server_run = dict(
-                values   = [True, False],
+            server_run=dict(
+                values=[True, False],
             ),
-            serversync_method = dict(
-                default  = 'simple_socket',
+            serversync_method=dict(
+                default="simple_socket",
             ),
-            serversync_medium = dict(
-                default  = 'cnt3_wait',
+            serversync_medium=dict(
+                default="cnt3_wait",
             ),
         )
     )
 
     @property
     def realkind(self):
-        return 'fullpos'
+        return "fullpos"
 
 
 class FullPosGeo(FullPos):
@@ -401,68 +414,100 @@ class FullPosGeo(FullPos):
     """
 
     _footprint = dict(
-        info = "Run a fullpos to interpolate to a new geometry",
-        attr = dict(
-            kind = dict(
-                values  = ['l2h', 'h2l'],
+        info="Run a fullpos to interpolate to a new geometry",
+        attr=dict(
+            kind=dict(
+                values=["l2h", "h2l"],
             ),
-        )
+        ),
     )
 
-    _RUNSTORE = 'RUNOUT'
+    _RUNSTORE = "RUNOUT"
 
     def _compute_target_name(self, r):
-        return ('PF' + re.sub('^(?:ICMSH)(.*?)(?:INIT)(.*)$', r'\1\2',
-                              r.container.localpath()).format(self.xpname))
+        return "PF" + re.sub(
+            "^(?:ICMSH)(.*?)(?:INIT)(.*)$", r"\1\2", r.container.localpath()
+        ).format(self.xpname)
 
     def execute(self, rh, opts):
         """Loop on the various initial conditions provided."""
 
         sh = self.system
 
-        initrh = [x.rh for x in self.context.sequence.effective_inputs(
-            role=('Analysis', 'Guess', 'InitialCondition'),
-            kind=('analysis', 'historic', 'ic', re.compile('(stp|ana)min'),
-                  re.compile('pert'), ),
-        )]
+        initrh = [
+            x.rh
+            for x in self.context.sequence.effective_inputs(
+                role=("Analysis", "Guess", "InitialCondition"),
+                kind=(
+                    "analysis",
+                    "historic",
+                    "ic",
+                    re.compile("(stp|ana)min"),
+                    re.compile("pert"),
+                ),
+            )
+        ]
 
         # is there one (deterministic forecast) or many (ensemble forecast) fullpos to perform ?
         isMany = len(initrh) > 1
-        do_fix_input_clim = self.do_climfile_fixer(rh, convkind='modelclim')
-        do_fix_output_clim = self.do_climfile_fixer(rh, convkind='targetclim', area='000')
-        ininc = self.naming_convention('ic', rh)
+        do_fix_input_clim = self.do_climfile_fixer(rh, convkind="modelclim")
+        do_fix_output_clim = self.do_climfile_fixer(
+            rh, convkind="targetclim", area="000"
+        )
+        ininc = self.naming_convention("ic", rh)
         infile = ininc()
 
         for num, r in enumerate(initrh):
-            str_subtitle = 'Fullpos execution on {}'.format(r.container.localpath())
+            str_subtitle = "Fullpos execution on {}".format(
+                r.container.localpath()
+            )
             sh.subtitle(str_subtitle)
 
             # Set the actual init file
             if sh.path.exists(infile):
                 if isMany:
-                    logger.critical('Cannot process multiple Historic files if %s exists.', infile)
+                    logger.critical(
+                        "Cannot process multiple Historic files if %s exists.",
+                        infile,
+                    )
             else:
-                sh.cp(r.container.localpath(), infile, fmt=r.container.actualfmt, intent=intent.IN)
+                sh.cp(
+                    r.container.localpath(),
+                    infile,
+                    fmt=r.container.actualfmt,
+                    intent=intent.IN,
+                )
 
             # Fix links for climatology files
             actualmonth = Month(r.resource.date + r.resource.term)
             startingclim = r.resource.geometry
 
             if do_fix_input_clim:
-                self.climfile_fixer(rh, convkind='modelclim', month=actualmonth, geo=startingclim,
-                                    inputrole=(re.compile('^Clim'), re.compile('Clim$')),
-                                    inputkind='clim_model')
+                self.climfile_fixer(
+                    rh,
+                    convkind="modelclim",
+                    month=actualmonth,
+                    geo=startingclim,
+                    inputrole=(re.compile("^Clim"), re.compile("Clim$")),
+                    inputkind="clim_model",
+                )
 
             if do_fix_output_clim:
-                self.climfile_fixer(rh, convkind='targetclim', month=actualmonth, notgeo=startingclim,
-                                    inputrole=(re.compile('^Clim'), re.compile('Clim$')),
-                                    inputkind='clim_model', area='000')
+                self.climfile_fixer(
+                    rh,
+                    convkind="targetclim",
+                    month=actualmonth,
+                    notgeo=startingclim,
+                    inputrole=(re.compile("^Clim"), re.compile("Clim$")),
+                    inputkind="clim_model",
+                    area="000",
+                )
 
             # Standard execution
             super().execute(rh, opts)
 
             # Find the output filename
-            output_file = [x for x in sh.glob('PF{:s}*+*'.format(self.xpname))]
+            output_file = [x for x in sh.glob("PF{:s}*+*".format(self.xpname))]
             if len(output_file) != 1:
                 raise AlgoComponentError("No or multiple output files found.")
             output_file = output_file[0]
@@ -472,35 +517,53 @@ class FullPosGeo(FullPos):
                 # Set a local storage place
                 sh.mkdir(self._RUNSTORE)
                 # Freeze the current output
-                sh.move(output_file, sh.path.join(self._RUNSTORE, 'pfout_{:d}'.format(num)),
-                        fmt=r.container.actualfmt)
+                sh.move(
+                    output_file,
+                    sh.path.join(self._RUNSTORE, "pfout_{:d}".format(num)),
+                    fmt=r.container.actualfmt,
+                )
                 sh.remove(infile, fmt=r.container.actualfmt)
                 # Cleaning/Log management
                 if not self.server_run:
                     # The only one listing
-                    sh.cat('NODE.001_01', output='NODE.all')
+                    sh.cat("NODE.001_01", output="NODE.all")
                     # Some cleaning
-                    sh.rmall('ncf927', 'dirlst')
+                    sh.rmall("ncf927", "dirlst")
             else:
                 # Link the output files to new style names
-                sh.cp(output_file, self._compute_target_name(r),
-                      fmt=r.container.actualfmt, intent='in')
+                sh.cp(
+                    output_file,
+                    self._compute_target_name(r),
+                    fmt=r.container.actualfmt,
+                    intent="in",
+                )
                 # Link the listing to NODE.all
-                sh.cp('NODE.001_01', 'NODE.all', intent='in')
+                sh.cp("NODE.001_01", "NODE.all", intent="in")
 
     def postfix(self, rh, opts):
         """Post processing cleaning."""
         sh = self.system
 
-        initrh = [x.rh for x in self.context.sequence.effective_inputs(
-            role=('Analysis', 'Guess', 'InitialCondition'),
-            kind=('analysis', 'historic', 'ic', re.compile('(stp|ana)min'),
-                  re.compile('pert'), ),
-        )]
+        initrh = [
+            x.rh
+            for x in self.context.sequence.effective_inputs(
+                role=("Analysis", "Guess", "InitialCondition"),
+                kind=(
+                    "analysis",
+                    "historic",
+                    "ic",
+                    re.compile("(stp|ana)min"),
+                    re.compile("pert"),
+                ),
+            )
+        ]
         if len(initrh) > 1:
             for num, r in enumerate(initrh):
-                sh.move('{:s}/pfout_{:d}'.format(self._RUNSTORE, num),
-                        self._compute_target_name(r), fmt=r.container.actualfmt)
+                sh.move(
+                    "{:s}/pfout_{:d}".format(self._RUNSTORE, num),
+                    self._compute_target_name(r),
+                    fmt=r.container.actualfmt,
+                )
 
         super().postfix(rh, opts)
 
@@ -512,29 +575,32 @@ class FullPosBDAP(FullPos):
     """
 
     _footprint = dict(
-        info = "Run a fullpos to post-process raw model outputs",
-        attr = dict(
-            kind = dict(
-                values  = ['fullpos', 'fp'],
-                remap   = dict(fp= 'fullpos')
-            ),
-            fcterm = dict(
-                values = [0, ],
+        info="Run a fullpos to post-process raw model outputs",
+        attr=dict(
+            kind=dict(values=["fullpos", "fp"], remap=dict(fp="fullpos")),
+            fcterm=dict(
+                values=[
+                    0,
+                ],
             ),
-            outputid = dict(
-                info        = "The identifier for the encoding of post-processed fields.",
-                optional    = True,
+            outputid=dict(
+                info="The identifier for the encoding of post-processed fields.",
+                optional=True,
             ),
-            server_run = dict(
-                values   = [False, ],
+            server_run=dict(
+                values=[
+                    False,
+                ],
             ),
         ),
     )
 
     def prepare(self, rh, opts):
         """Some additional checks."""
-        if self.system.path.exists('xxt00000000'):
-            raise AlgoComponentError('There should be no file named xxt00000000 in the working directory')
+        if self.system.path.exists("xxt00000000"):
+            raise AlgoComponentError(
+                "There should be no file named xxt00000000 in the working directory"
+            )
         super().prepare(rh, opts)
 
     def execute(self, rh, opts):
@@ -542,93 +608,137 @@ class FullPosBDAP(FullPos):
 
         sh = self.system
 
-        namrh = [x.rh for x in self.context.sequence.effective_inputs(
-            kind='namelistfp'
-        )]
+        namrh = [
+            x.rh
+            for x in self.context.sequence.effective_inputs(kind="namelistfp")
+        ]
 
-        namxx = [x.rh for x in self.context.sequence.effective_inputs(
-            role='FullPosSelection',
-            kind='namselect',
-        )]
+        namxx = [
+            x.rh
+            for x in self.context.sequence.effective_inputs(
+                role="FullPosSelection",
+                kind="namselect",
+            )
+        ]
 
-        initsec = [x for x in self.context.sequence.effective_inputs(
-            role=('InitialCondition', 'ModelState'),
-            kind='historic',
-        )]
+        initsec = [
+            x
+            for x in self.context.sequence.effective_inputs(
+                role=("InitialCondition", "ModelState"),
+                kind="historic",
+            )
+        ]
         initsec.sort(key=lambda sec: sec.rh.resource.term)
 
-        do_fix_input_clim = self.do_climfile_fixer(rh, convkind='modelclim')
+        do_fix_input_clim = self.do_climfile_fixer(rh, convkind="modelclim")
 
-        ininc = self.naming_convention('ic', rh)
+        ininc = self.naming_convention("ic", rh)
         infile = ininc()
 
         for sec in initsec:
             r = sec.rh
-            sh.subtitle('Loop on {:s}'.format(r.resource.term.fmthm))
+            sh.subtitle("Loop on {:s}".format(r.resource.term.fmthm))
 
             thisdate = r.resource.date + r.resource.term
             thismonth = thisdate.month
-            logger.info('Fullpos <month:%s>' % thismonth)
+            logger.info("Fullpos <month:%s>" % thismonth)
 
             if do_fix_input_clim:
-                self.climfile_fixer(rh, convkind='modelclim',
-                                    month=thismonth, geo=r.resource.geometry,
-                                    inputrole=(re.compile('^Clim'), re.compile('Clim$')),
-                                    inputkind='clim_model')
+                self.climfile_fixer(
+                    rh,
+                    convkind="modelclim",
+                    month=thismonth,
+                    geo=r.resource.geometry,
+                    inputrole=(re.compile("^Clim"), re.compile("Clim$")),
+                    inputkind="clim_model",
+                )
 
             thesenames = self.all_localclim_fixer(rh, thismonth)
 
             # Set a local storage place
-            runstore = 'RUNOUT' + r.resource.term.fmtraw
+            runstore = "RUNOUT" + r.resource.term.fmtraw
             sh.mkdir(runstore)
 
             # Define an input namelist
             try:
-                namfp = [x for x in namrh if x.resource.term == r.resource.term].pop()
+                namfp = [
+                    x for x in namrh if x.resource.term == r.resource.term
+                ].pop()
                 namfplocal = namfp.container.localpath()
                 if self.outputid is not None:
-                    self._set_nam_macro(namfp.contents, namfplocal, 'OUTPUTID', self.outputid)
+                    self._set_nam_macro(
+                        namfp.contents, namfplocal, "OUTPUTID", self.outputid
+                    )
                 namfp.contents.rewrite(namfp.container)
-                sh.remove('fort.4')
-                sh.symlink(namfplocal, 'fort.4')
+                sh.remove("fort.4")
+                sh.symlink(namfplocal, "fort.4")
             except Exception:
-                logger.critical('Could not get a fullpos namelist for term %s', r.resource.term)
+                logger.critical(
+                    "Could not get a fullpos namelist for term %s",
+                    r.resource.term,
+                )
                 raise
 
             # Define an selection namelist
             if namxx:
-                namxt = [x for x in namxx if x.resource.term == r.resource.term]
+                namxt = [
+                    x for x in namxx if x.resource.term == r.resource.term
+                ]
                 if namxt:
-                    sh.remove('xxt00000000')
-                    sh.symlink(namxt.pop().container.localpath(), 'xxt00000000')
+                    sh.remove("xxt00000000")
+                    sh.symlink(
+                        namxt.pop().container.localpath(), "xxt00000000"
+                    )
                 else:
-                    logger.critical('Could not get a selection namelist for term %s', r.resource.term)
+                    logger.critical(
+                        "Could not get a selection namelist for term %s",
+                        r.resource.term,
+                    )
                     raise AlgoComponentError()
             else:
                 logger.info("No selection namelist are provided.")
 
             # Finally set the actual init file
             sh.remove(infile)
-            self.grab(sec, comment='Fullpos source (term={:s})'.format(r.resource.term.fmthm))
+            self.grab(
+                sec,
+                comment="Fullpos source (term={:s})".format(
+                    r.resource.term.fmthm
+                ),
+            )
             sh.softlink(r.container.localpath(), infile)
 
             # Standard execution
             super().execute(rh, opts)
 
             # Freeze the current output
-            for posfile in [x for x in (sh.glob('PF{:s}*+*'.format(self.xpname)) +
-                                        sh.glob('GRIBPF{:s}*+*'.format(self.xpname)))]:
-                rootpos = re.sub('0+$', '', posfile)
-                fmtpos = 'grib' if posfile.startswith('GRIB') else 'lfi'
-                targetfile = sh.path.join(runstore, rootpos + r.resource.term.fmthm)
+            for posfile in [
+                x
+                for x in (
+                    sh.glob("PF{:s}*+*".format(self.xpname))
+                    + sh.glob("GRIBPF{:s}*+*".format(self.xpname))
+                )
+            ]:
+                rootpos = re.sub("0+$", "", posfile)
+                fmtpos = "grib" if posfile.startswith("GRIB") else "lfi"
+                targetfile = sh.path.join(
+                    runstore, rootpos + r.resource.term.fmthm
+                )
                 targetbase = sh.path.basename(targetfile)
 
                 # Deal with potential promises
-                expected = [x for x in self.promises
-                            if x.rh.container.localpath() == targetbase]
+                expected = [
+                    x
+                    for x in self.promises
+                    if x.rh.container.localpath() == targetbase
+                ]
                 if expected:
-                    logger.info("Start dealing with promises for: %s.",
-                                ", ".join([x.rh.container.localpath() for x in expected]))
+                    logger.info(
+                        "Start dealing with promises for: %s.",
+                        ", ".join(
+                            [x.rh.container.localpath() for x in expected]
+                        ),
+                    )
                     if posfile != targetbase:
                         sh.move(posfile, targetbase, fmt=fmtpos)
                         posfile = targetbase
@@ -637,12 +747,12 @@ class FullPosBDAP(FullPos):
 
                 sh.move(posfile, targetfile, fmt=fmtpos)
 
-            for logfile in sh.glob('NODE.*', 'std*'):
+            for logfile in sh.glob("NODE.*", "std*"):
                 sh.move(logfile, sh.path.join(runstore, logfile))
 
             # Some cleaning
-            sh.rmall('PX{:s}*'.format(self.xpname), fmt='lfi')
-            sh.rmall('ncf927', 'dirlst')
+            sh.rmall("PX{:s}*".format(self.xpname), fmt="lfi")
+            sh.rmall("ncf927", "dirlst")
             for clim in thesenames:
                 sh.rm(clim)
 
@@ -650,12 +760,20 @@ class FullPosBDAP(FullPos):
         """Post processing cleaning."""
         sh = self.system
 
-        for fpfile in [x for x in (sh.glob('RUNOUT*/PF{:s}*'.format(self.xpname)) +
-                                   sh.glob('RUNOUT*/GRIBPF{:s}*+*'.format(self.xpname)))
-                       if sh.path.isfile(x)]:
-            sh.move(fpfile, sh.path.basename(fpfile),
-                    fmt='grib' if 'GRIBPF' in fpfile else 'lfi')
-        sh.cat('RUNOUT*/NODE.001_01', output='NODE.all')
+        for fpfile in [
+            x
+            for x in (
+                sh.glob("RUNOUT*/PF{:s}*".format(self.xpname))
+                + sh.glob("RUNOUT*/GRIBPF{:s}*+*".format(self.xpname))
+            )
+            if sh.path.isfile(x)
+        ]:
+            sh.move(
+                fpfile,
+                sh.path.basename(fpfile),
+                fmt="grib" if "GRIBPF" in fpfile else "lfi",
+            )
+        sh.cat("RUNOUT*/NODE.001_01", output="NODE.all")
 
         super().postfix(rh, opts)
 
@@ -666,80 +784,103 @@ class OfflineSurfex(Parallel, DrHookDecoMixin):
     _footprint = [
         model,
         dict(
-            info = "Run a forecast with the SURFEX's offline binary.",
-            attr = dict(
-                kind = dict(
-                    values      = ['offline_forecast', ],
+            info="Run a forecast with the SURFEX's offline binary.",
+            attr=dict(
+                kind=dict(
+                    values=[
+                        "offline_forecast",
+                    ],
                 ),
-                model = dict(
-                    values      = ['surfex', ],
+                model=dict(
+                    values=[
+                        "surfex",
+                    ],
                 ),
-                model_tstep = dict(
-                    info        = "The timestep of the model",
-                    type        = Period,
+                model_tstep=dict(
+                    info="The timestep of the model",
+                    type=Period,
                 ),
-                diag_tstep = dict(
-                    info        = "The timestep for writing diagnostics outputs",
-                    type        = Period,
+                diag_tstep=dict(
+                    info="The timestep for writing diagnostics outputs",
+                    type=Period,
                 ),
-                fcterm = dict(
-                    info        = "The forecast's term",
-                    type        = Period,
+                fcterm=dict(
+                    info="The forecast's term",
+                    type=Period,
                 ),
-                forcing_read_interval = dict(
-                    info        = "Read the forcing file every...",
-                    type        = Period,
-                    default     = Period('PT12H'),
-                    optional    = True,
-                )
-            )
-        )
+                forcing_read_interval=dict(
+                    info="Read the forcing file every...",
+                    type=Period,
+                    default=Period("PT12H"),
+                    optional=True,
+                ),
+            ),
+        ),
     ]
 
     def valid_executable(self, rh):
         """Check the executable's resource."""
-        bmodel = getattr(rh.resource, 'model', None)
-        rc = bmodel == 'surfex' and rh.resource.realkind == 'offline'
+        bmodel = getattr(rh.resource, "model", None)
+        rc = bmodel == "surfex" and rh.resource.realkind == "offline"
         if not rc:
-            logger.error('Inapropriate binary provided')
+            logger.error("Inapropriate binary provided")
         return rc and super().valid_executable(rh)
 
     @staticmethod
     def _fix_nam_macro(sec, macro, value):
         """Set a given namelist macro and issue a log message."""
         sec.rh.contents.setmacro(macro, value)
-        logger.info('Setup %s macro to %s.', macro, str(value))
+        logger.info("Setup %s macro to %s.", macro, str(value))
 
     def prepare(self, rh, opts):
         """Setup the appropriate namelist macros."""
         self.system.subtitle("Offline SURFEX Settings.")
         # Find the run/final date
         ic = self.context.sequence.effective_inputs(
-            role=('InitialConditions', 'ModelState', 'Analysis'))
+            role=("InitialConditions", "ModelState", "Analysis")
+        )
         if ic:
             if len(ic) > 1:
-                logger.warning('Multiple initial conditions, using only the first one...')
+                logger.warning(
+                    "Multiple initial conditions, using only the first one..."
+                )
             rundate = ic[0].rh.resource.date
-            if hasattr(ic[0].rh.resource, 'term'):
+            if hasattr(ic[0].rh.resource, "term"):
                 rundate += ic[0].rh.resource.term
             finaldate = rundate + self.fcterm
-            finaldate = [finaldate.year, finaldate.month, finaldate.day,
-                         finaldate.hour * 3600 + finaldate.minute * 60 + finaldate.second]
-            logger.info('The final date is : %s', str(finaldate))
-            nbreads = int(math.ceil((finaldate - rundate).length /
-                                    self.forcing_read_interval.length))
+            finaldate = [
+                finaldate.year,
+                finaldate.month,
+                finaldate.day,
+                finaldate.hour * 3600
+                + finaldate.minute * 60
+                + finaldate.second,
+            ]
+            logger.info("The final date is : %s", str(finaldate))
+            nbreads = int(
+                math.ceil(
+                    (finaldate - rundate).length
+                    / self.forcing_read_interval.length
+                )
+            )
         else:
-            logger.warning('No initial conditions were found. Hope you know what you are doing...')
+            logger.warning(
+                "No initial conditions were found. Hope you know what you are doing..."
+            )
             finaldate = None
         # Ok, let's find the namelist
-        namsecs = self.context.sequence.effective_inputs(role=('Namelist', 'Namelistsurf'))
+        namsecs = self.context.sequence.effective_inputs(
+            role=("Namelist", "Namelistsurf")
+        )
         for namsec in namsecs:
             logger.info("Processing: %s", namsec.rh.container.localpath())
-            self._fix_nam_macro(namsec, 'TSTEP', self.model_tstep.length)
-            self._fix_nam_macro(namsec, 'TSTEP_OUTPUTS', self.diag_tstep.length)
+            self._fix_nam_macro(namsec, "TSTEP", self.model_tstep.length)
+            self._fix_nam_macro(
+                namsec, "TSTEP_OUTPUTS", self.diag_tstep.length
+            )
             if finaldate:
-                self._fix_nam_macro(namsec, 'FINAL_STOP', finaldate)
-                self._fix_nam_macro(namsec, 'NB_READS', nbreads)
+                self._fix_nam_macro(namsec, "FINAL_STOP", finaldate)
+                self._fix_nam_macro(namsec, "NB_READS", nbreads)
             if namsec.rh.contents.dumps_needs_update:
                 namsec.rh.save()
             logger.info("Namelist dump: \n%s", namsec.rh.container.read())