vortex-nwp 2.0.0b1__py3-none-any.whl

vortex/nwp/data/ctpini.py

@@ -0,0 +1,133 @@
+"""
+Ctpini files.
+"""
+
+from bronx.fancies import loggers
+
+from vortex.data.outflow import StaticResource
+from vortex.data.flow import GeoFlowResource
+from ..syntax.stdattrs import gvar
+from vortex.data.contents import DataTemplate
+from .gridfiles import GridPoint
+
+#: No automatic export
+__all__ = []
+
+logger = loggers.getLogger(__name__)
+
+
+class CtpiniDirectiveFile(GeoFlowResource):
+    """
+    Class dealing with Ctpini directive file.
+    """
+
+    _footprint = dict(
+        info = "Ctpini directive file",
+        attr = dict(
+            kind = dict(
+                values = ["ctpini_directives_file", ],
+            ),
+            nativefmt = dict(
+                default = "ascii"
+            )
+        )
+    )
+
+    @property
+    def realkind(self):
+        return "ctpini_directives_file"
+
+
+class AsciiFiles(StaticResource):
+    """
+    Class to deal with miscellaneous ascii files coming from genv.
+    """
+
+    _abstract = True
+    _footprint = [
+        gvar,
+        dict(
+            info = 'Abstract class for ascii files from genv.',
+        )
+    ]
+
+
+class CtpiniAsciiFiles(AsciiFiles):
+    """
+    Class to deal with Genv Ctpini ascii files.
+    """
+
+    _footprint = [
+        dict(
+            info = "Ctpini Genv ascii files.",
+            attr = dict(
+                kind = dict(
+                    values = ["ctpini_ascii_file"],
+                ),
+                source = dict(
+                    values = ["levels", "covano", "fort61", "coor", "cov46"],
+                ),
+                gvar = dict(
+                    default = "tsr_misc_[source]",
+                ),
+                clscontents=dict(
+                    default = DataTemplate
+                ),
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return "ctpini_ascii_file"
+
+
+class GridPointCtpini(GridPoint):
+    """
+    Class to deal with Gridpoint files used as input in Ctpini.
+    """
+
+    _footprint = dict(
+        info = 'Ctpini Gridpoint Fields',
+        attr = dict(
+            kind = dict(
+                values = ['ctpini_gridpoint', ],
+            ),
+            origin = dict(
+                values = ['oper', 'PS', 'dble', 'PX', 'ctpini', 'PTSR', ],
+                remap = dict(
+                    PS = 'oper',
+                    PX = 'dble',
+                    PTSR = 'ctpini',
+                ),
+            ),
+            parameter = dict(
+                values = ['PMERSOL', 'T850HPA', 'Z15PVU', 'Z20PVU', 'Z07PVU', 'TROPO'],
+            ),
+            run_ctpini = dict(
+                optional = True,
+                default = None,
+            ),
+            nativefmt = dict(
+                values = ['geo', ],
+                default = 'geo',
+            ),
+        )
+    )
+
+    @property
+    def realkind(self):
+        return "ctpini_gridpoint"
+
+    def namebuilding_info(self):
+        """Generic information, radical = ``grid``."""
+        ninfo = super().namebuilding_info()
+        if self.origin == 'ctpini' and self.run_ctpini is not None:
+            source = [self.model, self.origin, self.parameter, self.run_ctpini]
+        else:
+            source = [self.model, self.origin, self.parameter]
+        ninfo.update(
+            radical='ctpini-grid',
+            src=source,
+        )
+        return ninfo

vortex/nwp/data/diagnostics.py

@@ -0,0 +1,181 @@
+"""
+TODO: Module documentation.
+"""
+
+import footprints
+
+from vortex.data.flow import GeoFlowResource, GeoPeriodFlowResource
+from vortex.syntax.stdattrs import term_deco
+from vortex.syntax.stddeco import namebuilding_append, namebuilding_insert, overwrite_realkind
+
+#: No automatic export
+__all__ = []
+
+
+class ISP(GeoFlowResource):
+    """Class for Forecasted Satellite Image resource. Obsolete."""
+
+    _footprint = dict(
+        info = 'Forecasted Satellite Image',
+        attr = dict(
+            kind = dict(
+                values = ['isp', 'fsi']
+            ),
+            nativefmt = dict(
+                values = ['foo', ],
+                default = 'foo',
+            ),
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'isp'
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        return 'anim0'
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'ISP' + self.model[:4].upper()
+
+
+@namebuilding_insert('radical', lambda s: 'ddh')
+@namebuilding_append('src', lambda s: s.scope)
+class _DDHcommon(GeoFlowResource):
+    """
+    Abstract class for Horizontal Diagnostics.
+    """
+    _abstract = True
+    _footprint = dict(
+        info = 'Diagnostic on Horizontal Domains',
+        attr = dict(
+            kind = dict(
+                values = ['ddh', 'dhf'],
+                remap = dict(dhf='ddh')
+            ),
+            nativefmt = dict(),
+            scope = dict(
+                values = ['limited', 'dlimited', 'global', 'zonal'],
+                remap = dict(limited='dlimited')
+            ),
+        )
+    )
+
+
+class DDH(_DDHcommon):
+    """
+    Class for Horizontal Diagnostics.
+    Used to be a ``dhf`` !
+    """
+    _footprint = [
+        term_deco,
+        dict(
+            info = 'Diagnostic on Horizontal Domains',
+            attr = dict(
+                nativefmt = dict(
+                    values = ['lfi', 'lfa'],
+                    default = 'lfi',
+                ),
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'ddh'
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        return 'dhf{:s}{:s}+{:s}'.format(self.scope[:2].lower(), self.model[:4].lower(), self.term.fmth)
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'DHF{:s}{:s}+{:s}'.format(self.scope[:2].upper(), self.model[:4].upper(), self.term.fmth)
+
+
+class DDHpack(_DDHcommon):
+    """
+    Class for Horizontal Diagnostics with all terms packed in a single directory.
+    Used to be a ``dhf`` !
+    """
+    _footprint = dict(
+        info = 'Diagnostic on Horizontal Domains packed in a single directory',
+        attr = dict(
+            nativefmt = dict(
+                values = ['ddhpack', ],
+            ),
+        )
+    )
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'DHF{:s}{:s}.tar'.format(self.scope[:2].upper(), self.model[:4].upper())
+
+    @property
+    def realkind(self):
+        return 'ddhpack'
+
+
+_surfex_diag_decofp = footprints.DecorativeFootprint(
+    info='Diagnostic files outputed by surfex during a model run',
+    attr=dict(
+        kind=dict(
+            values=['diagnostics', ]
+        ),
+        scope=dict(
+        ),
+        model=dict(
+            values=['surfex', ]
+        ),
+        nativefmt=dict(
+            values=['netcdf', 'grib', ],
+            default='netcdf',
+            optional=True
+        ),
+    ),
+    decorator=[namebuilding_append('src', lambda s: s.scope),
+               overwrite_realkind('diagnostics')]
+)
+
+
+class SurfexDiagnostics(GeoFlowResource):
+    """Diagnostic files outputed by surfex during a model run (date/term version)."""
+
+    _footprint = [_surfex_diag_decofp, term_deco]
+
+
+class SurfexPeriodDiagnostics(GeoPeriodFlowResource):
+    """Diagnostic files outputed by surfex during a model run (period version)."""
+
+    _footprint = [_surfex_diag_decofp, ]
+
+
+class ObjTrack(GeoFlowResource):
+    """Class for Object Tracks."""
+
+    _footprint = dict(
+        info = 'Object Tracks json file',
+        attr = dict(
+            kind = dict(
+                values = ['objtrack']
+            ),
+            nativefmt = dict(
+                values = ['json', 'hdf5', 'foo', ],
+                default = 'foo',
+            ),
+        )
+    )
+
+    @property
+    def realkind(self):
+        return 'objtrack'
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        return 'track{:s}{:s}+{:s}'.format(self.scope[:2].lower(), self.model[:4].lower(), self.term.fmth)
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return 'track{:s}{:s}+{:s}'.format(self.scope[:2].upper(), self.model[:4].upper(), self.term.fmth)

vortex/nwp/data/eda.py

@@ -0,0 +1,148 @@
+"""
+Resources needed to build the Ensemble Data Assimilation system.
+"""
+
+from bronx.fancies import loggers
+
+from vortex.data.flow import GeoFlowResource
+from .assim import _BackgroundErrorInfo
+from vortex.syntax.stdattrs import term_deco
+from vortex.syntax.stddeco import namebuilding_insert
+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 RawFiles(GeoFlowResource):
+    """Input files for wavelet covariances estimation. To be removed soon."""
+
+    _footprint = [
+        term_deco,
+        gvar,
+        dict(
+            info = 'Input files for wavelet covariances estimation',
+            attr = dict(
+                kind = dict(
+                    values   = ['rawfiles'],
+                ),
+                nativefmt   = dict(
+                    values  = ['rawfiles', 'unknown'],
+                ),
+                gvar = dict(
+                    default = 'aearp_rawfiles_t[geometry:truncation]'
+                ),
+                ipert = dict(
+                    type = int,
+                    optional = True,
+                ),
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return self.kind
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        return 'RAWFILEP(memberfix:member)+{:s}.{:d}'.format(self.term.fmthour, self.geometry.truncation)
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        raise NotImplementedError()
+
+    def gget_basename(self):
+        """GGET specific naming convention."""
+        if self.ipert is None:
+            raise ValueError('ipert is mandatory with the GCO provider')
+        return dict(suffix='.{:03d}.tar'.format(self.ipert))
+
+
+@namebuilding_insert('geo', lambda s: s._geo2basename_info(add_stretching=False))
+class RandBFiles(GeoFlowResource):
+    """Input files for wavelet covariances estimation."""
+
+    _footprint = [
+        term_deco,
+        gvar,
+        dict(
+            info = 'Input files for wavelet covariances estimation',
+            attr = dict(
+                kind = dict(
+                    values   = ['randbfiles', 'famembers'],
+                    remap    = dict(autoremap = 'first')
+                ),
+                nativefmt   = dict(
+                    values  = ['fa', 'unknown'],
+                ),
+                gvar = dict(
+                    default = 'aearp_randb_t[geometry:truncation]'
+                ),
+                ipert = dict(
+                    type = int,
+                    optional = True,
+                ),
+            )
+        )
+    ]
+
+    @property
+    def realkind(self):
+        return 'randbfiles'
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        return 'famember(memberfix:member)+{:s}.{:d}'.format(self.term.fmthour, self.geometry.truncation)
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        raise NotImplementedError()
+
+    def gget_basename(self):
+        """GGET specific naming convention."""
+        if self.ipert is None:
+            raise ValueError('ipert is mandatory with the GCO provider')
+        return dict(suffix='.{:03d}.{}'.format(self.ipert, 'fa'))
+
+
+class InflationFactor(_BackgroundErrorInfo):
+    """
+    Inflation factor profiles.
+    """
+
+    _footprint = dict(
+        info='Inflation factor profiles',
+        attr=dict(
+            kind=dict(
+                values=['infl_factor', 'infl', 'inflation_factor'],
+                remap=dict(autoremap='first'),
+            ),
+            gvar = dict(
+                default = 'inflation_factor'
+            ),
+            nativefmt=dict(
+                values=['ascii'],
+                default='ascii',
+            ),
+            term=dict(
+                optional=True,
+                default=3
+            ),
+        ),
+    )
+
+    @property
+    def realkind(self):
+        return 'inflation_factor'
+
+    def archive_basename(self):
+        """OP ARCHIVE specific naming convention."""
+        return self.realkind
+
+    def olive_basename(self):
+        """OLIVE specific naming convention."""
+        return self.realkind