vortex-nwp 2.0.0b1__py3-none-any.whl

vortex/nwp/algo/coupling.py

@@ -0,0 +1,609 @@
+"""
+AlgoComponents dedicated to the coupling between NWP models.
+"""
+
+import re
+import footprints
+
+from bronx.compat.functools import cached_property
+from bronx.fancies import loggers
+from bronx.stdtypes import date
+
+from .ifsroot import IFSParallel
+from ..tools.drhook import DrHookDecoMixin
+from vortex.algo.components import AlgoComponentError, BlindRun, Parallel
+from vortex.algo.components import AlgoComponentDecoMixin, algo_component_deco_mixin_autodoc
+from vortex.layout.dataflow import intent
+from vortex.tools.grib import EcGribDecoMixin
+
+from .forecasts import FullPos
+
+#: No automatic export
+__all__ = []
+
+logger = loggers.getLogger(__name__)
+
+
+coupling_basedate_fp = footprints.Footprint(
+    attr=dict(
+        basedate=dict(
+            info="The run date of the coupling generating process",
+            type=date.Date,
+            optional=True
+        )
+    )
+)
+
+
+@algo_component_deco_mixin_autodoc
+class CouplingBaseDateNamMixin(AlgoComponentDecoMixin):
+    """Add a basedate attribute and make namelist substitution."""
+
+    _MIXIN_EXTRA_FOOTPRINTS = (coupling_basedate_fp, )
+
+    def _prepare_basedate_hook(self, rh, opts):
+        """Update the namelist with date information."""
+
+        def set_nam_macro(namrh, macro, value):
+            namrh.contents.setmacro(macro, value)
+            logger.info('Setup macro %s=%s in %s', macro, str(value),
+                        namrh.container.actualpath())
+
+        for namsec in self.context.sequence.effective_inputs(kind=('namelist',)):
+            if self.basedate is not None:
+                set_nam_macro(namsec.rh, 'YYYY', int(self.basedate.year))
+                set_nam_macro(namsec.rh, 'MM', int(self.basedate.month))
+                set_nam_macro(namsec.rh, 'DD', int(self.basedate.day))
+                if namsec.rh.contents.dumps_needs_update:
+                    namsec.rh.save()
+
+    _MIXIN_PREPARE_HOOKS = (_prepare_basedate_hook, )
+
+
+class Coupling(FullPos):
+    """Coupling for IFS-like LAM Models.
+
+    OBSOLETE a/c cy46 (use the 903 configuration / fullpos server instead).
+    """
+
+    _footprint = [
+        coupling_basedate_fp,
+        dict(
+            info = "Create coupling files for a Limited Area Model.",
+            attr = dict(
+                kind = dict(
+                    values   = ['coupling'],
+                ),
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'coupling'
+
+    def prepare(self, rh, opts):
+        """Default pre-link for namelist file and domain change."""
+        super().prepare(rh, opts)
+        namsec = self.setlink(initrole='Namelist', initkind='namelist', initname='fort.4')
+        for nam in [x.rh for x in namsec if 'NAMFPC' in x.rh.contents]:
+            logger.info('Substitute "AREA" to CFPDOM namelist entry')
+            nam.contents['NAMFPC']['CFPDOM(1)'] = 'AREA'
+            nam.save()
+
+    def execute(self, rh, opts):
+        """Loop on the various initial conditions provided."""
+
+        sh = self.system
+
+        cplsec = self.context.sequence.effective_inputs(
+            role=('InitialCondition', 'CouplingSource'),
+            kind=('historic', 'analysis')
+        )
+        cplsec.sort(key=lambda s: s.rh.resource.term)
+        ininc = self.naming_convention('ic', rh)
+        infile = ininc()
+        isMany = len(cplsec) > 1
+        outprefix = 'PF{:s}AREA'.format(self.xpname)
+
+        cplguess = self.context.sequence.effective_inputs(role='Guess')
+        cplguess.sort(key=lambda s: s.rh.resource.term)
+        guessing = bool(cplguess)
+
+        cplsurf = self.context.sequence.effective_inputs(role=('SurfaceInitialCondition',
+                                                               'SurfaceCouplingSource'))
+        cplsurf.sort(key=lambda s: s.rh.resource.term)
+        surfacing = bool(cplsurf)
+        inisurfnc = self.naming_convention('ic', rh, model='surfex')
+        infilesurf = inisurfnc()
+        if surfacing:
+            # Link in the Surfex's PGD
+            sclimnc = self.naming_convention(kind='targetclim', rh=rh, model='surfex')
+            self.setlink(
+                initrole=('ClimPGD',),
+                initkind=('pgdfa', 'pgdlfi'),
+                initname=sclimnc(area='AREA')
+            )
+
+        for sec in cplsec:
+            r = sec.rh
+            sh.subtitle('Loop on {!s}'.format(r.resource))
+
+            # First attempt to set actual date as the one of the source model
+            actualdate = r.resource.date + r.resource.term
+
+            # Expect the coupling source to be there...
+            self.grab(sec, comment='coupling source')
+
+            # Set the actual init file
+            if sh.path.exists(infile):
+                if isMany:
+                    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)
+
+            # If the surface file is needed, set the actual initsurf file
+            if cplsurf:
+                # Expecting the coupling surface source to be there...
+                cplsurf_in = cplsurf.pop(0)
+                self.grab(cplsurf_in, comment='coupling surface source')
+                if sh.path.exists(infilesurf):
+                    if isMany:
+                        logger.critical('Cannot process multiple surface historic files if %s exists.',
+                                        infilesurf)
+                else:
+                    sh.cp(cplsurf_in.rh.container.localpath(), infilesurf,
+                          fmt=cplsurf_in.rh.container.actualfmt, intent=intent.IN)
+            elif surfacing:
+                logger.error('No more surface source to loop on for coupling')
+
+            # The output could be an input as well
+            if cplguess:
+                cplout = cplguess.pop(0)
+                cplpath = cplout.rh.container.localpath()
+                if sh.path.exists(cplpath):
+                    actualdateguess = cplout.rh.resource.date + cplout.rh.resource.term
+                    if (actualdate == actualdateguess):
+                        logger.error('The guess date, %s, is different from the source date %s, !',
+                                     actualdateguess.reallynice(), actualdate.reallynice())
+                    # Expect the coupling guess to be there...
+                    self.grab(cplout, comment='coupling guess')
+                    logger.info('Coupling with existing guess <%s>', cplpath)
+                    inoutfile = outprefix + '+0000'
+                    if cplpath != inoutfile:
+                        sh.remove(inoutfile, fmt=cplout.rh.container.actualfmt)
+                        sh.move(cplpath, inoutfile,
+                                fmt=cplout.rh.container.actualfmt,
+                                intent=intent.INOUT)
+                else:
+                    logger.warning('Missing guess input for coupling <%s>', cplpath)
+            elif guessing:
+                logger.error('No more guess to loop on for coupling')
+
+            # Find out actual monthly climatological resource
+            actualmonth = date.Month(actualdate)
+            self.climfile_fixer(rh, convkind='modelclim', month=actualmonth,
+                                inputrole=('GlobalClim', 'InitialClim'),
+                                inputkind='clim_model')
+            self.climfile_fixer(rh, convkind='targetclim', month=actualmonth,
+                                inputrole=('LocalClim', 'TargetClim'),
+                                inputkind='clim_model', area='AREA')
+
+            # Standard execution
+            super().execute(rh, opts)
+
+            # Set a local appropriate file
+            posfile = [x for x in sh.glob(outprefix + '+*')
+                       if re.match(outprefix + r'\+\d+(?:\:\d+)?(?:\.sfx)?$', x)]
+            if (len(posfile) > 1):
+                logger.critical('Many ' + outprefix + ' files, do not know how to adress that')
+            posfile = posfile[0]
+            if self.basedate is None:
+                actualterm = r.resource.term
+            else:
+                actualterm = (actualdate - self.basedate).time()
+            actualname = (re.sub(r'^.+?((?:_\d+)?)(?:\+[:\d]+)?$', r'CPLOUT\1+', r.container.localpath()) +
+                          actualterm.fmthm)
+            if isMany:
+                sh.move(sh.path.realpath(posfile), actualname,
+                        fmt=r.container.actualfmt)
+                if sh.path.exists(posfile):
+                    sh.rm(posfile)
+            else:
+                # This is here because of legacy with .sfx files
+                sh.cp(sh.path.realpath(posfile), actualname,
+                      fmt=r.container.actualfmt, intent=intent.IN)
+
+            # promises management
+            expected = [x for x in self.promises if x.rh.container.localpath() == actualname]
+            if expected:
+                for thispromise in expected:
+                    thispromise.put(incache=True)
+
+            # The only one listing
+            if not self.server_run:
+                sh.cat('NODE.001_01', output='NODE.all')
+
+            # prepares the next execution
+            if isMany:
+                # Some cleaning
+                sh.rmall('PXFPOS*', fmt=r.container.actualfmt)
+                sh.remove(infile, fmt=r.container.actualfmt)
+                if cplsurf:
+                    sh.remove(infilesurf, fmt=r.container.actualfmt)
+                if not self.server_run:
+                    sh.rmall('ncf927', 'dirlst', 'NODE.[0123456789]*', 'std*')
+
+
+class CouplingLAM(Coupling):
+    """Coupling for LAM to LAM Models (useless beyond cy40).
+
+    OBSOLETE a/c cy40.
+    """
+
+    _footprint = dict(
+        info = "Create coupling files for a Limited Area Model (useless beyond cy40).",
+        attr = dict(
+            kind = dict(
+                values   = ['lamcoupling'],
+            ),
+        )
+    )
+
+    def spawn_command_options(self):
+        """Dictionary provided for command line factory."""
+        opts = super().spawn_command_options()
+        opts['model'] = 'aladin'
+        return opts
+
+
+@algo_component_deco_mixin_autodoc
+class PrepMixin(AlgoComponentDecoMixin):
+    """Coupling/Interpolation of Surfex files."""
+
+    _MIXIN_EXTRA_FOOTPRINTS = (footprints.Footprint(
+        info="Coupling/Interpolation of Surfex files.",
+        attr=dict(
+            kind=dict(
+                values=['prep'],
+            ),
+            underlyingformat=dict(
+                info="The format of input data (as expected by the PREP executable).",
+                values=['fa', 'lfi', 'netcdf'],
+                optional=True,
+                default='fa'
+            ),
+            underlyingoutputformat=dict(
+                info=("The format of output data (as expected by the PREP executable)." +
+                      "If omited, *underlyingformat* is used."),
+                values=['fa', 'lfi', 'netcdf', 'txt'],
+                optional=True,
+            ),
+            outputformat=dict(
+                info=("The format of output data (as expected by the user)." +
+                      "If omited, same as input data."),
+                values=['fa', 'lfi', 'netcdf', 'txt'],
+                optional=True,
+            ),
+        )
+    ), )
+
+    @cached_property
+    def _actual_u_output_format(self):
+        return (self.underlyingoutputformat
+                if self.underlyingoutputformat is not None else
+                self.underlyingformat)
+
+    def _actual_output_format(self, in_format):
+        return (self.outputformat if self.outputformat is not None
+                else in_format)
+
+    @staticmethod
+    def _sfx_fmt_remap(fmt):
+        return dict(netcdf='nc').get(fmt, fmt)
+
+    @cached_property
+    def _has_sfx_lfi(self):
+        addon_checked = ('sfx' in self.system.loaded_addons() and
+                         'lfi' in self.system.loaded_addons())
+        if not addon_checked:
+            raise RuntimeError("The sfx addon is needed... please load it.")
+        return addon_checked
+
+    def _do_input_format_change(self, section, output_name, output_fmt):
+        (localpath, infmt) = (section.rh.container.localpath(),
+                              section.rh.container.actualfmt)
+        self.system.subtitle("Processing inputs/climatologies")
+        if section.rh.container.actualfmt != output_fmt:
+            if infmt == 'fa' and output_fmt == 'lfi' and self._has_sfx_lfi:
+                if self.system.path.exists(output_name):
+                    raise OSError("The file {!r} already exists.".format(output_name))
+                logger.info("Calling sfxtools' fa2lfi from %s to %s.", localpath, output_name)
+                self.system.sfx_fa2lfi(localpath, output_name)
+            else:
+                raise RuntimeError("Format conversion from {!r} to {!r} is not possible".format(
+                                   infmt, output_fmt))
+        else:
+            if not self.system.path.exists(output_name):
+                logger.info("Linking %s to %s", localpath, output_name)
+                self.system.cp(localpath, output_name, intent=intent.IN, fmt=infmt)
+
+    def _process_outputs(self, binrh, section, output_clim, output_name):
+        (radical, outfmt) = (self.system.path.splitext(section.rh.container.localpath())[0],
+                             self._actual_output_format(section.rh.container.actualfmt))
+        finaloutput = '{:s}_interpolated.{:s}'.format(radical, outfmt)
+        finallisting = '{:s}_listing'.format(radical)
+        self.system.subtitle("Processing outputs")
+        if outfmt != self._actual_u_output_format:
+            # There is a need for a format change
+            if outfmt == 'fa' and self._actual_u_output_format == 'lfi' and self._has_sfx_lfi:
+                logger.info("Calling lfitools' faempty from %s to %s.", output_clim, finaloutput)
+                self.system.fa_empty(output_clim, finaloutput)
+                logger.info("Calling sfxtools' lfi2fa from %s to %s.", output_name, finaloutput)
+                self.system.sfx_lfi2fa(output_name, finaloutput)
+                finallfi = '{:s}_interpolated.{:s}'.format(radical, self._actual_u_output_format)
+                self.system.mv(output_name, finallfi)
+            else:
+                raise RuntimeError("Format conversion from {!r} to {!r} is not possible".format(
+                                   self._actual_u_output_format, outfmt))
+        else:
+            # No format change needed
+            logger.info("Moving %s to %s", output_name, finaloutput)
+            self.system.mv(output_name, finaloutput, fmt=outfmt)
+        # Also rename the listing :-)
+        if binrh.resource.cycle < 'cy48t1':
+            try:
+                self.system.mv('LISTING_PREP.txt', finallisting)
+            except OSError:
+                self.system.mv('LISTING_PREP0.txt', finallisting)
+        else:
+            self.system.mv('LISTING_PREP0.txt', finallisting)
+        return finaloutput
+
+    def _prepare_prep_hook(self, rh, opts):
+        """Default pre-link for namelist file and domain change."""
+        # Convert the initial clim if needed...
+        iniclim = self.context.sequence.effective_inputs(role=('InitialClim',))
+        if not (len(iniclim) == 1):
+            raise AlgoComponentError("One Initial clim have to be provided")
+        self._do_input_format_change(iniclim[0],
+                                     'PGD1.' + self._sfx_fmt_remap(self.underlyingformat),
+                                     self.underlyingformat)
+        # Convert the target clim if needed...
+        targetclim = self.context.sequence.effective_inputs(role=('TargetClim',))
+        if not (len(targetclim) == 1):
+            raise AlgoComponentError("One Target clim have to be provided")
+        self._do_input_format_change(targetclim[0],
+                                     'PGD2.' + self._sfx_fmt_remap(self._actual_u_output_format),
+                                     self._actual_u_output_format)
+
+    _MIXIN_PREPARE_HOOKS = (_prepare_prep_hook, )
+
+    def _spawn_hook_prep_hook(self):
+        """Dump the namelists."""
+        for namsec in self.context.sequence.effective_inputs(kind=('namelist', )):
+            self.system.subtitle("Here is the content of the {:s} namelist"
+                                 .format(namsec.rh.container.actualpath()))
+            namsec.rh.container.cat()
+
+    _MIXIN_SPAWN_HOOKS = (_spawn_hook_prep_hook, )
+
+    def _execute_prep_common(self, rh, opts):
+        """Loop on the various initial conditions provided."""
+        sh = self.system
+
+        cplsec = self.context.sequence.effective_inputs(
+            role=('InitialCondition', 'CouplingSource'),
+            kind=('historic', 'analysis')
+        )
+        cplsec.sort(key=lambda s: s.rh.resource.term)
+        infile = 'PREP1.{:s}'.format(self._sfx_fmt_remap(self.underlyingformat))
+        outfile = 'PREP2.{:s}'.format(self._sfx_fmt_remap(self._actual_u_output_format))
+        targetclim = self.context.sequence.effective_inputs(role=('TargetClim',))
+        targetclim = targetclim[0].rh.container.localpath()
+
+        for sec in cplsec:
+            r = sec.rh
+            sh.header('Loop on {:s}'.format(r.container.localpath()))
+
+            # Expect the coupling source to be there...
+            self.grab(sec, comment='coupling source')
+
+            # Set the actual init file
+            if sh.path.exists(infile):
+                logger.critical('Cannot process input files if %s exists.', infile)
+            self._do_input_format_change(sec, infile, self.underlyingformat)
+
+            # Standard execution
+            super(self.mixin_execute_companion(), self).execute(rh, opts)
+            sh.subtitle("Listing after PREP")
+            sh.dir(output=False, fatal=False)
+
+            # Deal with outputs
+            actualname = self._process_outputs(rh, sec, targetclim, outfile)
+
+            # promises management
+            expected = [x for x in self.promises if x.rh.container.localpath() == actualname]
+            if expected:
+                for thispromise in expected:
+                    thispromise.put(incache=True)
+
+            # Some cleaning
+            sh.rmall('*.des')
+            sh.rmall('PREP1.*')
+
+    _MIXIN_EXECUTE_OVERWRITE = _execute_prep_common
+
+
+class Prep(BlindRun, PrepMixin, CouplingBaseDateNamMixin,
+           DrHookDecoMixin, EcGribDecoMixin):
+    """Coupling/Interpolation of Surfex files (non-MPI version)."""
+    pass
+
+
+class ParallelPrep(Parallel, PrepMixin, CouplingBaseDateNamMixin,
+                   DrHookDecoMixin, EcGribDecoMixin):
+    """Coupling/Interpolation of Surfex files (MPI version)."""
+    pass
+
+
+class C901(IFSParallel):
+    """Run of C901 configuration."""
+
+    _footprint = dict(
+        info = "Run C901 configuration",
+        attr = dict(
+            kind = dict(
+                values = ["c901", ]
+            ),
+            clim = dict(
+                type = bool
+            ),
+            xpname = dict(
+                default = 'a001'
+            )
+        )
+    )
+
+    SPECTRAL_FILE_SH = "ICMSH{prefix}INIT{suffix}"
+    GRIDPOINT_FILE_UA = "ICMUA{prefix}INIT{suffix}"
+    GRIDPOINT_FILE_GG = "ICMGG{prefix}INIT{suffix}"
+    OUTPUT_FILE_NAME = "CN90x{}INIT"
+    OUTPUT_LISTING_NAME = "NODE.001_01"
+    LIST_INPUT_FILES = [("SpectralFileSH", SPECTRAL_FILE_SH),
+                        ("GridpointFileUA", GRIDPOINT_FILE_UA),
+                        ("GridpointFileGG", GRIDPOINT_FILE_GG)]
+    LIST_CST_INPUT_FILES = [("ConstantSpectralFileSH", SPECTRAL_FILE_SH),
+                            ("ConstantGridpointFileUA", GRIDPOINT_FILE_UA),
+                            ("ConstantGridpointFileGG", GRIDPOINT_FILE_GG)]
+
+    @property
+    def realkind(self):
+        return "c901"
+
+    def sort_files_per_prefix(self, list_types, unique=False):
+        """Function used to sort the files according to their prefix in a given type"""
+        result = dict()
+        for (file_role, file_template) in list_types:
+            result[file_role] = dict()
+            input_files = self.context.sequence.effective_inputs(
+                role=file_role
+            )
+            template = file_template.format(prefix=r"(?P<prefix>\S{4})", suffix=r"(?P<suffix>\S*)")
+            for file_s in input_files:
+                file_name = file_s.rh.container.filename
+                find_elements = re.search(template, file_name)
+                if find_elements is None:
+                    logger.error("The name of the file %s do not follow the template %s.",
+                                 file_name, template)
+                    raise ValueError("The name of the file do not follow the template.")
+                else:
+                    if find_elements.group("prefix") not in result[file_role]:
+                        result[file_role][find_elements.group("prefix")] = list()
+                    else:
+                        if unique:
+                            logger.error("Only one file should be present for each type and each suffix.")
+                            raise ValueError("Only one file should be present for each suffix.")
+                    result[file_role][find_elements.group("prefix")].append(file_s)
+            if result[file_role]:
+                for file_prefix in result[file_role]:
+                    result[file_role][file_prefix].sort(key=lambda s: s.rh.resource.date + s.rh.resource.term)
+            else:
+                del result[file_role]
+        return result
+
+    def execute(self, rh, opts):
+        """Loop on the various files provided"""
+
+        sh = self.system
+
+        # Create the template for files to be removed at each validity date and for the outputname
+        deleted_spectral_file_SH = self.SPECTRAL_FILE_SH.format(prefix="*", suffix="")
+        deleted_gridpoint_file_UA = self.GRIDPOINT_FILE_UA.format(prefix="*", suffix="")
+        deleted_gridpoint_file_GG = self.GRIDPOINT_FILE_GG.format(prefix="*", suffix="")
+        output_name = self.OUTPUT_FILE_NAME.format(self.xpname.upper())
+
+        # Sort input files
+        sorted_cst_input_files = self.sort_files_per_prefix(self.LIST_CST_INPUT_FILES, unique=True)
+        sorted_input_files = self.sort_files_per_prefix(self.LIST_INPUT_FILES)
+
+        # Determine the validity present for each non constant input files,
+        # check that they are the same for all.
+        # Also create the list of the filenames that should be deleted
+        input_validity = list()
+        for file_role in sorted_input_files:
+            for file_prefix in sorted_input_files[file_role]:
+                input_validity.append([s.rh.resource.date + s.rh.resource.term
+                                       for s in sorted_input_files[file_role][file_prefix]])
+        test_wrong_input_validity = True
+        for i in range(1, len(input_validity)):
+            test_wrong_input_validity = test_wrong_input_validity and (input_validity[0] == input_validity[i])
+        self.algoassert(test_wrong_input_validity,
+                        "The files of each type must have the same validity dates.")
+
+        # Modify namelist
+        input_namelist = self.context.sequence.effective_inputs(
+            role="Namelist",
+            kind="namelist"
+        )
+        for namelist in input_namelist:
+            namcontents = namelist.rh.contents
+            self._set_nam_macro(namcontents, namelist.rh.container.actualpath(),
+                                'LLCLIM', self.clim)
+            if namcontents.dumps_needs_update:
+                namcontents.rewrite(namelist.rh.container)
+
+        for current_validity in input_validity[0]:
+            # Deal with constant input files (gridpoint and spectral)
+            for (file_role, file_template) in self.LIST_CST_INPUT_FILES:
+                if file_role in sorted_cst_input_files:
+                    for file_prefix in sorted_cst_input_files[file_role]:
+                        file_name = file_template.format(prefix=file_prefix, suffix="")
+                        current_file_input = sorted_cst_input_files[file_role][file_prefix][0]
+                        self.algoassert(not sh.path.exists(file_name),
+                                        "The file {} already exists. It should not.".format(file_name))
+                        sh.cp(current_file_input.rh.container.iotarget(), file_name, intent="in")
+
+            # Deal with other input files (gridpoint and spectral)
+            for (file_role, file_template) in self.LIST_INPUT_FILES:
+                if file_role in sorted_input_files:
+                    for file_prefix in sorted_input_files[file_role]:
+                        file_name = file_template.format(prefix=file_prefix, suffix="")
+                        current_file_input = sorted_input_files[file_role][file_prefix].pop()
+                        self.algoassert(not sh.path.exists(file_name),
+                                        "The file {} already exists. It should not.".format(file_name))
+                        sh.cp(current_file_input.rh.container.iotarget(), file_name, intent="in")
+
+            if self.clim:
+                # Find the right climatology file
+                current_month = date.Month(current_validity)
+                self.climfile_fixer(rh, convkind='modelclim', month=current_month,
+                                    inputrole=('GlobalClim', 'InitialClim'),
+                                    inputkind='clim_model')
+
+            # Standard execution
+            super().execute(rh, opts)
+            # Move the output file
+            current_term = current_file_input.rh.resource.term
+            sh.move(output_name, output_name + "+{}".format(current_term.fmthm))
+            # Cat all the listings into a single one
+            sh.cat(self.OUTPUT_LISTING_NAME, output='NODE.all')
+            # Remove unneeded files
+            sh.rmall(deleted_spectral_file_SH, deleted_gridpoint_file_GG, deleted_gridpoint_file_UA,
+                     'std*', self.OUTPUT_LISTING_NAME)
+
+
+class DomeoForcingAtmo(BlindRun, CouplingBaseDateNamMixin):
+    """Correct the Domeo forcing file."""
+
+    _footprint = dict(
+        info='Domeo Forcing Atmo',
+        attr=dict(
+            kind=dict(
+                values=['domeo_forcing'],
+            ),
+            basedate=dict(
+                optional=False,
+            ),
+        )
+    )