vortex-nwp 2.0.0b1__py3-none-any.whl

vortex/nwp/data/__init__.py

@@ -0,0 +1,12 @@
+"""
+Data resources (mostly NWP).
+"""
+
+# Recursive inclusion of packages with potential FootprintBase classes
+from . import boundaries, climfiles, consts, diagnostics, executables, fields
+from . import assim, gridfiles, logs, modelstates, namelists, obs, surfex, eps, eda
+from . import providers, stores, query, monitoring, ctpini
+from . import oopsexec, configfiles
+
+#: No automatic export
+__all__ = []

vortex/nwp/data/assim.py

@@ -0,0 +1,392 @@
+"""
+Various resources needed to build ad Data Assimilmation system.
+"""
+
+from bronx.fancies import loggers
+from bronx.stdtypes.date import Time
+
+from vortex.data.flow import FlowResource, GeoFlowResource
+from vortex.data.contents import JsonDictContent
+from vortex.data.executables import Script
+from vortex.syntax.stddeco import namebuilding_append, namebuilding_insert
+from vortex.syntax.stdattrs import FmtInt, term_deco
+from ..syntax.stdattrs import gvar
+
+#: Automatic export off
+__all__ = []
+
+logger = loggers.getLogger(__name__)
+
+
+@namebuilding_insert('geo', lambda s: s._geo2basename_info(add_stretching=False))
+class _BackgroundErrorInfo(GeoFlowResource):
+    """
+    A generic class for data in grib format related to the background error.
+    """
+
+    _abstract = True
+    _footprint = [
+        term_deco,
+        gvar,
+        dict(
+            info='Background standard deviation',
+            attr=dict(
+                term=dict(
+                    optional=True,
+                    default=3
+                ),
+                nativefmt=dict(
+                    default='grib',
+                ),
+                gvar = dict(
+                    default = 'errgrib_t[geometry:truncation]'
+                ),
+            ),
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'bgstdinfo'
+
+
+class BackgroundStdError(_BackgroundErrorInfo):
+    """Background error standard deviation.
+
+    stage:
+        * unbal/vor: unbalanced variables fields
+        * scr: obs. related fields
+        * profile: full variables global and latitude bands horizontal averages
+        * full: full variables fields
+
+    origin:
+        * ens: diagnosed from an ensemble
+        * diag: diagnosed from randomized (a priori climatological) covariances
+
+    """
+
+    _footprint = dict(
+        info='Background error standard deviation',
+        attr=dict(
+            kind=dict(
+                values=['bgstderr', 'bg_stderr', 'bgerrstd'],
+                remap=dict(autoremap='first'),
+            ),
+            stage=dict(
+                optional=True,
+                default='unbal',
+                values=['scr', 'vor', 'full', 'unbal', 'profile'],
+                remap=dict(vor='unbal'),
+            ),
+            origin=dict(
+                optional=True,
+                values=['ens', 'diag'],
+                default = 'ens',
+            ),
+            gvar = dict(
+                default = 'errgrib_vor_monthly'
+            ),
+            nativefmt=dict(
+                values=['grib', 'ascii'],
+                default='grib',
+            ),
+        ),
+    )
+
+    @property
+    def realkind(self):
+        return 'bgstderr'
+
+    def namebuilding_info(self):
+        """Generic information for names fabric, with radical = ``bcor``."""
+        infos = super().namebuilding_info()
+        infos['src'].append(self.stage)
+        if self.stage != 'scr':
+            infos['src'].append(self.origin)
+        return infos
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        if self.stage in ('unbal',):
+            return '(errgribfix:igakey)'
+        else:
+            return 'errgrib_' + self.stage
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        if self.stage in ('unbal',):
+            return 'errgribvor'
+        else:
+            return 'sigma_b'
+
+    def gget_basename(self):
+        """GGET specific naming convention."""
+        return dict(suffix='.m{:02d}'.format(self.date.month))
+
+
+@namebuilding_append('src', lambda s: s.variable)
+class SplitBackgroundStdError(BackgroundStdError):
+    """Background error standard deviation, for a given variable."""
+
+    _footprint = dict(
+        info='Background error standard deviation',
+        attr=dict(
+            variable=dict(
+                info = "Variable contained in this resource.",
+            ),
+            gvar = dict(
+                default = 'errgrib_vor_[variable]_monthly'
+            ),
+        ),
+    )
+
+
+class BackgroundErrorNorm(_BackgroundErrorInfo):
+    """Background error normalisation data for wavelet covariances."""
+
+    _footprint = [
+        dict(
+            info='Background error normalisation data for wavelet covariances',
+            attr=dict(
+                kind=dict(
+                    values=['bgstdrenorm', 'bgerrnorm'],
+                    remap=dict(autoremap='first'),
+                ),
+                gvar = dict(
+                    default = 'srenorm_t[geometry:truncation]'
+                ),
+            ),
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'bgstdrenorm'
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        return 'srenorm.{!s}'.format(self.geometry.truncation)
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'srenorm.t{!s}'.format(self.geometry.truncation)
+
+    def archive_pathinfo(self):
+        """Op Archive specific pathname needs."""
+        return dict(
+            nativefmt=self.nativefmt,
+            model=self.model,
+            date=self.date,
+            cutoff=self.cutoff,
+            arpege_aearp_directory='wavelet',
+        )
+
+
+@namebuilding_insert('geo', lambda s: s._geo2basename_info(add_stretching=False))
+class Wavelet(GeoFlowResource):
+    """Background error wavelet covariances."""
+
+    _footprint = [
+        term_deco,
+        gvar,
+        dict(
+            info = 'Background error wavelet covariances',
+            attr = dict(
+                kind = dict(
+                    values   = ['wavelet', 'waveletcv'],
+                    remap    = dict(autoremap = 'first'),
+                ),
+                gvar = dict(
+                    default = 'wavelet_cv_t[geometry:truncation]'
+                ),
+                term=dict(
+                    optional=True,
+                    default=3
+                ),
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'wavelet'
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        return 'wavelet.cv.{!s}'.format(self.geometry.truncation)
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'wavelet.cv.t{!s}'.format(self.geometry.truncation)
+
+    def archive_pathinfo(self):
+        """Op Archive specific pathname needs."""
+        return dict(
+            nativefmt=self.nativefmt,
+            model=self.model,
+            date=self.date,
+            cutoff=self.cutoff,
+            arpege_aearp_directory=self.realkind,
+        )
+
+
+@namebuilding_insert('geo', lambda s: s._geo2basename_info(add_stretching=False))
+class RawControlVector(GeoFlowResource):
+    """Raw Control Vector as issued by minimisation, playing the role of an Increment."""
+
+    _footprint = dict(
+        info = 'Raw Control Vector',
+        attr = dict(
+            kind = dict(
+                values   = ['rawcv', 'rcv', 'increment', 'minimcv'],
+                remap    = dict(autoremap = 'first'),
+            ),
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'rawcv'
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'MININCR'
+
+
+@namebuilding_insert('geo', lambda s: s._geo2basename_info(add_stretching=False))
+class InternalMinim(GeoFlowResource):
+    """Generic class for resources internal to minimisation."""
+
+    _abstract = True
+    _footprint = dict(
+        attr = dict(
+            nativefmt = dict(
+                values  = ['fa', 'lfi', 'grib'],
+                default = 'fa',
+            ),
+            term = dict(
+                type     = Time,
+                optional = True,
+                default  = Time(-3),
+            ),
+        )
+    )
+
+    def olive_suffixtr(self):
+        """Return BR or HR specific OLIVE suffix according to geo streching."""
+        return 'HR' if self.geometry.stretching > 1 else 'BR'
+
+
+class StartingPointMinim(InternalMinim):
+    """Guess as reprocessed by the minimisation."""
+
+    _footprint = dict(
+        info = 'Starting Point Output Minim',
+        attr = dict(
+            kind = dict(
+                values  = ['stpmin'],
+            ),
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'stpmin'
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'STPMIN' + self.olive_suffixtr()
+
+
+class AnalysedStateMinim(InternalMinim):
+    """Analysed state as produced by the minimisation."""
+
+    _footprint = dict(
+        info = 'Analysed Output Minim',
+        attr = dict(
+            kind = dict(
+                values  = ['anamin'],
+            ),
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'anamin'
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'ANAMIN' + self.olive_suffixtr()
+
+
+class PrecevMap(FlowResource):
+    """Map of the precondionning eigenvectors as produced by minimisation."""
+
+    _footprint = dict(
+        info = 'Prec EV Map',
+        attr = dict(
+            kind = dict(
+                values   = ['precevmap'],
+            ),
+            clscontents = dict(
+                default = JsonDictContent,
+            ),
+            nativefmt   = dict(
+                values  = ['json'],
+                default = 'json',
+            ),
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'precevmap'
+
+
+@namebuilding_append('src', lambda s: str(s.evnum))
+class Precev(FlowResource):
+    """Precondionning eigenvectors as produced by minimisation."""
+
+    _footprint = dict(
+        info = 'Starting Point Output Minim',
+        attr = dict(
+            kind = dict(
+                values   = ['precev'],
+            ),
+            evnum = dict(
+                type    = FmtInt,
+                args    = dict(fmt = '03'),
+            ),
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'precev'
+
+
+class IOassignScript(Script):
+    """Scripts for IOASSIGN."""
+
+    _footprint = [
+        gvar,
+        dict(
+            info = 'Script for IOASSIGN',
+            attr = dict(
+                kind = dict(
+                    values = ['ioassign_script']
+                ),
+                gvar = dict(
+                    default = 'ioassign_script_[purpose]'
+                ),
+                purpose=dict(
+                    info = "The purpose of the script",
+                    values = ['merge', 'create']
+                ),
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'ioassign_script'

vortex/nwp/data/boundaries.py

@@ -0,0 +1,261 @@
+"""
+Resources to handle any boundary conditions data for a coupled model.
+"""
+
+import re
+
+from bronx.stdtypes import date
+import footprints
+from vortex.tools import env
+from vortex.data.flow import GeoFlowResource, GeoPeriodFlowResource
+from vortex.syntax.stddeco import namebuilding_append, namebuilding_insert, overwrite_realkind
+from vortex.syntax.stdattrs import term_deco, timeperiod_deco, a_cutoff
+from vortex.data.geometries import LonlatGeometry
+
+from ..tools.igastuff import archive_suffix
+
+#: No automatic export
+__all__ = []
+
+
+@namebuilding_insert('radical', lambda s: 'cpl')
+@namebuilding_insert('src', lambda s: s._mysrc)
+class _AbstractLAMBoundary(GeoFlowResource):
+    """
+    Class of a coupling file for a Limited Area Model.
+    A SpectralGeometry object is needed.
+    """
+
+    _abstract = True
+    _footprint = [
+        term_deco,
+        dict(
+            info = 'Coupling file for a limited area model',
+            attr = dict(
+                kind = dict(
+                    values  = ['boundary', 'elscf', 'coupled'],
+                    remap   = dict(autoremap = 'first'),
+                ),
+                nativefmt = dict(
+                    values  = ['fa', 'grib', 'netcdf', 'ascii', 'wbcpack', 'unknown'],
+                    default = 'fa',
+                ),
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'boundary'
+
+    @property
+    def _mysrc(self):
+        raise NotImplementedError
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        if self.mailbox.get('block', '-') == 'surfan':
+            hhreal = self.term
+        else:
+            e = env.current()
+            if 'HHDELTA_CPL' in e:
+                actualbase = self.date - date.Time(e.HHDELTA_CPL + 'H')
+            else:
+                actualbase = date.synop(base=self.date)
+            hhreal = (self.date - actualbase).time() + self.term
+        return 'ELSCFALAD_' + self.geometry.area + '+' + hhreal.fmthour
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        suffix = archive_suffix(self.model, self.cutoff, self.date)
+        prefix = 'COUPL'
+        source = self._mysrc[0] if isinstance(self._mysrc, list) else self._mysrc
+        if re.match('assist1bis|testms1', self.geometry.area):
+            prefix = 'COUPL1'
+        if re.match('ifs|ecmwf', source) and '16km' in self.geometry.rnice:
+            prefix = 'COUPLIFS'
+
+        if self.model == 'mocage':
+            valid = (self.date + self.term).ymd
+            return 'SM' + self.geometry.area + '+' + valid
+
+        return prefix + self.term.fmthour + '.r{!s}'.format(suffix)
+
+    def iga_pathinfo(self):
+        """Standard path information for IGA inline cache."""
+        if self.model == 'arome':
+            directory = 'fic_day'
+        elif self.model == 'mfwam':
+            directory = 'guess'
+        else:
+            directory = 'autres'
+        return dict(
+            fmt=directory,
+            model=self.model,
+            nativefmt=self.nativefmt,
+        )
+
+    def _geo2basename_info(self, add_stretching=True):
+        """Particular geometry dictionnary for _AbstractLamBoundary class and derivated ones."""
+        if isinstance(self.geometry, LonlatGeometry):
+            lgeo = [self.geometry.area, self.geometry.rnice]
+        else:
+            lgeo = super()._geo2basename_info(add_stretching)
+        return lgeo
+
+
+class LAMBoundary(_AbstractLAMBoundary):
+    """
+    Class of a coupling file for a Limited Area Model.
+    A SpectralGeometry object is needed and the source model is given in the footprint.
+    """
+
+    _footprint = dict(
+        attr = dict(
+            source = dict(
+                values  = [
+                    'arpege', 'aladin', 'arome', 'ifs', 'ecmwf', 'psy4',
+                    'mercator_global', 'glo12', 'mfwam'
+                ]
+            ),
+        )
+    )
+
+    @property
+    def _mysrc(self):
+        return self.source
+
+
+_a_source_cutoff = a_cutoff
+del _a_source_cutoff['alias']
+_a_source_cutoff['optional'] = True
+_a_source_cutoff['default'] = 'production'
+
+
+class EnhancedLAMBoundary(_AbstractLAMBoundary):
+    """
+    Class of a coupling file for a Limited Area Model.
+    A SpectralGeometry object is needed and the source app, source conf and
+    source cutoff is given in the footprint.
+    """
+
+    _footprint = dict(
+        attr = dict(
+            source_app = dict(),
+            source_conf = dict(),
+            source_cutoff = _a_source_cutoff,
+        )
+    )
+
+    @property
+    def _mysrc(self):
+        return [self.source_app, self.source_conf,
+                {'cutoff': self.source_cutoff}]
+
+
+_abs_forcing_fp = footprints.DecorativeFootprint(
+    info='Coupling file for any offline model.',
+    attr=dict(
+        kind=dict(
+            values=['forcing', ],
+        ),
+        filling=dict(),
+        source_app=dict(),
+        source_conf=dict(),
+        source_cutoff=_a_source_cutoff,
+    ),
+    decorator=[namebuilding_insert('src', lambda s: [s.source_app, s.source_conf,
+                                                     {'cutoff': s.source_cutoff}]),
+               overwrite_realkind('forcing'), ]
+)
+
+
+class _AbstractForcing(GeoFlowResource):
+    """Abstract class for date-based coupling file for any offline model."""
+
+    _abstract = True
+    _footprint = [_abs_forcing_fp, ]
+
+
+class _AbstractPeriodForcing(GeoPeriodFlowResource):
+    """Abstract class for period-based coupling file for any offline model."""
+
+    _abstract = True
+    _footprint = [_abs_forcing_fp, ]
+
+
+_abs_external_forcing_fp = footprints.DecorativeFootprint(
+    dict(
+        attr=dict(
+            model=dict(
+                outcast=['surfex', ],
+            ),
+        ),
+    ),
+    decorator=[namebuilding_append('src', lambda s: s.filling)],
+)
+
+
+class ExternalForcing(_AbstractForcing):
+    """Class for date-based coupling file for any offline model.
+
+    This class takes an optional **term** attribute.
+    """
+
+    _footprint = [term_deco, _abs_external_forcing_fp]
+
+
+class ExternalTimePeriodForcing(_AbstractForcing):
+    """Class for date-based coupling file for any offline model.
+
+    This class needs a **begintime**/**endtime** attribute.
+    """
+
+    _footprint = [timeperiod_deco, _abs_external_forcing_fp]
+
+
+_abs_surfex_forcing_fp = footprints.DecorativeFootprint(
+    dict(
+        info='Coupling/Forcing file for Surfex.',
+        attr=dict(
+            model=dict(
+                values=['surfex', ],
+            ),
+            filling=dict(
+                optional=True,
+                default='atm',
+            ),
+            nativefmt=dict(
+                values=['netcdf', 'ascii', 'tar'],
+                default='netcdf',
+            ),
+        )
+    ),
+    decorator=[namebuilding_append('src',
+                                   lambda s: None if s.filling == 'atm' else s.filling,
+                                   none_discard=True)]
+)
+
+
+class SurfexForcing(_AbstractForcing):
+    """Class for date-based coupling file for Surfex.
+
+    This class takes an optional **term** attribute.
+    """
+
+    _footprint = [term_deco, _abs_surfex_forcing_fp, ]
+
+
+class SurfexTimePeriodForcing(_AbstractForcing):
+    """Class for date-based coupling file for Surfex.
+
+    This class needs a **begintime**/**endtime** attribute.
+    """
+
+    _footprint = [timeperiod_deco, _abs_surfex_forcing_fp, ]
+
+
+class SurfexPeriodForcing(_AbstractPeriodForcing):
+    """Class for period-based coupling file for Surfex."""
+
+    _footprint = [_abs_surfex_forcing_fp, ]