veris 0.1.1__tar.gz

veris-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 TeamOcean
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

veris-0.1.1/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: veris
+Version: 0.1.1
+Summary: Sea-ice plugin for Veros, the versatile ocean simulator
+Home-page: https://veris.readthedocs.io
+Author: Jan Gärtner (AWI Bremen)
+Author-email: jph.gaertner@gmail.com
+License: MIT
+Keywords: oceanography python parallel numpy multi-core geophysics ocean-model mpi4py jax
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Veris
+Sea ice plugin for Veros, based on SEAICE package of MITgcm model
+
+## Quick usage
+
+```bash
+$ pip install veros 
+$ git clone https://github.com/team-ocean/veris.git
+$ cd veris
+$ pip install -e .
+$ veros copy-setup seaice_global_4deg --to /tmp/seaice_4deg
+$ cd /tmp/seaice_4deg
+$ veros run seaice_global_4deg.py
+```
+
+## Credits
+
+Veris is based on [SEAICE package](https://mitgcm.readthedocs.io/en/latest/phys_pkgs/seaice.html) by [Martin Losch et al.](https://www.awi.de/ueber-uns/organisation/mitarbeiter/detailseite/martin-losch.html), Alfred Wegener institute.
+
+[Jan Philipp Gärtner](https://github.com/jpgaertner) created Veris plugin as a part of his Master's thesis.

veris-0.1.1/README.md

@@ -0,0 +1,20 @@
+# Veris
+Sea ice plugin for Veros, based on SEAICE package of MITgcm model
+
+## Quick usage
+
+```bash
+$ pip install veros 
+$ git clone https://github.com/team-ocean/veris.git
+$ cd veris
+$ pip install -e .
+$ veros copy-setup seaice_global_4deg --to /tmp/seaice_4deg
+$ cd /tmp/seaice_4deg
+$ veros run seaice_global_4deg.py
+```
+
+## Credits
+
+Veris is based on [SEAICE package](https://mitgcm.readthedocs.io/en/latest/phys_pkgs/seaice.html) by [Martin Losch et al.](https://www.awi.de/ueber-uns/organisation/mitarbeiter/detailseite/martin-losch.html), Alfred Wegener institute.
+
+[Jan Philipp Gärtner](https://github.com/jpgaertner) created Veris plugin as a part of his Master's thesis.

veris-0.1.1/setup.cfg

@@ -0,0 +1,19 @@
+[metadata]
+description-file = README.md
+
+[versioneer]
+VCS = git
+style = pep440
+versionfile_source = veris/_version.py
+versionfile_build = veris/_version.py
+tag_prefix = v
+
+[flake8]
+max-line-length = 120
+select = C,E,F,W,B,B950
+extend-ignore = E203, E501
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

veris-0.1.1/setup.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+# coding=utf-8
+
+from setuptools import setup, find_packages
+from codecs import open
+import sys
+import os
+
+
+here = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(here)
+import versioneer  # noqa: E402
+
+
+CLASSIFIERS = """
+Development Status :: 3 - Alpha
+Intended Audience :: Science/Research
+License :: OSI Approved :: MIT License
+Programming Language :: Python :: 3
+Programming Language :: Python :: 3.7
+Programming Language :: Python :: 3.8
+Programming Language :: Python :: 3.9
+Programming Language :: Python :: 3.10
+Topic :: Scientific/Engineering
+Operating System :: Microsoft :: Windows
+Operating System :: POSIX
+Operating System :: Unix
+Operating System :: MacOS
+"""
+
+INSTALL_REQUIRES = [
+    "veros>=1.4.4"
+]
+
+with open(os.path.join(here, "README.md"), encoding="utf-8") as f:
+    long_description = f.read()
+
+
+setup(
+    name="veris",
+    license="MIT",
+    author="Jan Gärtner (AWI Bremen)",
+    author_email="jph.gaertner@gmail.com",
+    keywords="oceanography python parallel numpy multi-core geophysics ocean-model mpi4py jax",
+    description="Sea-ice plugin for Veros, the versatile ocean simulator",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url='https://veris.readthedocs.io',
+    python_requires=">=3.7",
+    version=versioneer.get_version(),
+    cmdclass=versioneer.get_cmdclass(),
+    packages=find_packages(),
+    install_requires=INSTALL_REQUIRES,
+    entry_points={
+            "veros.setup_dirs": [
+                "seaice = veris.setup"
+            ]
+    },
+    package_data={"veris": ["setup/*/assets.json"]},
+    classifiers=[c for c in CLASSIFIERS.split("\n") if c],
+)

veris-0.1.1/veris/__init__.py

@@ -0,0 +1,24 @@
+try:
+    import veros  # noqa: F401
+except ImportError:
+    raise RuntimeError(
+        'Veris needs Veros to be installed (try `pip install veros`)'
+    )
+
+from . import _version
+__version__ = _version.get_versions()['version']
+
+from veris.model import model
+from veris.set_inits import set_inits
+from veris.variables import VARIABLES
+from veris.settings import SETTINGS
+
+
+__VEROS_INTERFACE__ = dict(
+    name = 'veris',
+    setup_entrypoint = set_inits,
+    run_entrypoint = model,
+    settings = SETTINGS,
+    variables = VARIABLES,
+)
+

veris-0.1.1/veris/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.28) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2023-05-23T13:58:38+0200",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "d83026db00905d9742fe90f38ba4ef16cff23e5f",
+ "version": "0.1.1"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

veris-0.1.1/veris/advection.py

@@ -0,0 +1,175 @@
+from veros.core.operators import numpy as npx
+from veros.core.operators import update, at
+from veros import veros_kernel
+
+from veris.fill_overlap import fill_overlap
+
+# in this routine, the thermodynamic time step is used instead of the dynamic one.
+# this has historical reasons as with lower resolutions, the dynamics change much
+# slower than the thermodynamics (thermodynamics have a daily cycle). calculating
+# the ice velocity as often as the thermodynamics was unnecessarily expensive but
+# the advection is still done with the faster thermodynamic timestep as the ice
+# thickness changes inbetween dynamics timesteps.
+
+
+@veros_kernel
+def Advection(state):
+    """retrieve changes in sea ice fields"""
+
+    vs = state.variables
+
+    hIceMean = calc_Advection(state, vs.hIceMean)
+    hSnowMean = calc_Advection(state, vs.hSnowMean)
+    Area = calc_Advection(state, vs.Area)
+
+    return hIceMean, hSnowMean, Area
+
+
+@veros_kernel
+def calc_Advection(state, field):
+    """calculate change in sea ice field due to advection"""
+
+    vs = state.variables
+    sett = state.settings
+
+    # retrieve cell faces
+    xA = vs.dyG * vs.iceMaskU
+    yA = vs.dxG * vs.iceMaskV
+
+    # calculate ice transport
+    uTrans = vs.uIce * xA
+    vTrans = vs.vIce * yA
+
+    # make local copy of field prior to advective changes
+    fieldLoc = field
+
+    # calculate zonal advective fluxes
+    ZonalFlux = calc_ZonalFlux(state, fieldLoc, uTrans)
+
+    # update field according to zonal fluxes
+    if sett.extensiveFld:
+        fieldLoc = fieldLoc - sett.deltatTherm * vs.maskInC * vs.recip_rA * (
+            npx.roll(ZonalFlux, -1, 0) - ZonalFlux
+        )
+    else:
+        fieldLoc = (
+            fieldLoc
+            - sett.deltatTherm
+            * vs.maskInC
+            * vs.recip_rA
+            * vs.recip_hIceMean
+            * (
+                (npx.roll(ZonalFlux, -1, 1) - ZonalFlux)
+                - (npx.roll(vs.uTrans, -1, 0) - vs.uTrans) * field
+            )
+        )
+
+    # calculate meridional advective fluxes
+    MeridionalFlux = calc_MeridionalFlux(state, fieldLoc, vTrans)
+
+    # update field according to meridional fluxes
+    if sett.extensiveFld:
+        fieldLoc = fieldLoc - sett.deltatTherm * vs.maskInC * vs.recip_rA * (
+            npx.roll(MeridionalFlux, -1, 1) - MeridionalFlux
+        )
+    else:
+        fieldLoc = (
+            fieldLoc
+            - sett.deltatTherm
+            * vs.maskInC
+            * vs.recip_rA
+            * vs.recip_hIceMean
+            * (
+                (npx.roll(MeridionalFlux, -1, 0) - MeridionalFlux)
+                - (npx.roll(vs.vTrans, -1, 1) - vs.vTrans) * field
+            )
+        )
+
+    # apply mask
+    fieldLoc = fieldLoc * vs.iceMask
+
+    return fieldLoc
+
+
+@veros_kernel
+def calc_ZonalFlux(state, field, uTrans):
+    """calculate the zonal advective flux using the second order flux limiter method"""
+
+    vs = state.variables
+    sett = state.settings
+
+    maskLocW = vs.iceMaskU * vs.maskInU
+
+    # CFL number of zonal flow
+    uCFL = npx.abs(vs.uIce * sett.deltatTherm * vs.recip_dxC)
+
+    # calculate slope ratio Cr
+    Rjp = (field[3:, :] - field[2:-1, :]) * maskLocW[3:, :]
+    Rj = (field[2:-1, :] - field[1:-2, :]) * maskLocW[2:-1, :]
+    Rjm = (field[1:-2, :] - field[:-3, :]) * maskLocW[1:-2, :]
+
+    Cr = npx.where(uTrans[2:-1, :] > 0, Rjm, Rjp)
+    Cr = npx.where(
+        npx.abs(Rj) * sett.CrMax > npx.abs(Cr),
+        Cr / Rj,
+        npx.sign(Cr) * sett.CrMax * npx.sign(Rj),
+    )
+    Cr = limiter(Cr)
+
+    # zonal advective flux for the given field
+    ZonalFlux = npx.zeros_like(vs.iceMask)
+    ZonalFlux = update(
+        ZonalFlux,
+        at[2:-1, :],
+        uTrans[2:-1, :] * (field[2:-1, :] + field[1:-2, :]) * 0.5
+        - npx.abs(uTrans[2:-1, :]) * ((1 - Cr) + uCFL[2:-1, :] * Cr) * Rj * 0.5,
+    )
+    ZonalFlux = fill_overlap(state, ZonalFlux)
+
+    return ZonalFlux
+
+
+@veros_kernel
+def calc_MeridionalFlux(state, field, vTrans):
+    """calculate the meridional advective flux using the second order flux limiter method"""
+
+    vs = state.variables
+    sett = state.settings
+
+    maskLocS = vs.iceMaskV * vs.maskInV
+
+    # CFL number of meridional flow
+    vCFL = npx.abs(vs.vIce * sett.deltatTherm * vs.recip_dyC)
+
+    # calculate slope ratio Cr
+    Rjp = (field[:, 3:] - field[:, 2:-1]) * maskLocS[:, 3:]
+    Rj = (field[:, 2:-1] - field[:, 1:-2]) * maskLocS[:, 2:-1]
+    Rjm = (field[:, 1:-2] - field[:, :-3]) * maskLocS[:, 1:-2]
+
+    Cr = npx.where(vTrans[:, 2:-1] > 0, Rjm, Rjp)
+    Cr = npx.where(
+        npx.abs(Rj) * sett.CrMax > npx.abs(Cr),
+        Cr / Rj,
+        npx.sign(Cr) * sett.CrMax * npx.sign(Rj),
+    )
+    Cr = limiter(Cr)
+
+    # meridional advective flux for the given field
+    MeridionalFlux = npx.zeros_like(vs.iceMask)
+    MeridionalFlux = update(
+        MeridionalFlux,
+        at[:, 2:-1],
+        vTrans[:, 2:-1] * (field[:, 2:-1] + field[:, 1:-2]) * 0.5
+        - npx.abs(vTrans[:, 2:-1]) * ((1 - Cr) + vCFL[:, 2:-1] * Cr) * Rj * 0.5,
+    )
+    MeridionalFlux = fill_overlap(state, MeridionalFlux)
+
+    return MeridionalFlux
+
+
+@veros_kernel
+def limiter(Cr):
+    # return 0       (upwind)
+    # return 1       (Lax-Wendroff)
+    # return np.max((0, np.min((1, Cr))))    (Min-Mod)
+    return npx.maximum(0, npx.maximum(npx.minimum(1, 2 * Cr), npx.minimum(2, Cr)))

veris-0.1.1/veris/area_mass.py

@@ -0,0 +1,28 @@
+from veros.core.operators import numpy as npx
+from veros import veros_kernel
+
+
+@veros_kernel
+def AreaWS(state):
+    """calculate sea ice cover fraction centered around velocity points"""
+
+    vs = state.variables
+
+    AreaW = 0.5 * (vs.Area + npx.roll(vs.Area, 1, 0))
+    AreaS = 0.5 * (vs.Area + npx.roll(vs.Area, 1, 1))
+
+    return AreaW, AreaS
+
+
+@veros_kernel
+def SeaIceMass(state):
+    """calculate mass of the ice-snow system centered around c-, u-, and v-points"""
+
+    vs = state.variables
+    sett = state.settings
+
+    SeaIceMassC = sett.rhoIce * vs.hIceMean + sett.rhoSnow * vs.hSnowMean
+    SeaIceMassU = 0.5 * (SeaIceMassC + npx.roll(SeaIceMassC, 1, 0))
+    SeaIceMassV = 0.5 * (SeaIceMassC + npx.roll(SeaIceMassC, 1, 1))
+
+    return SeaIceMassC, SeaIceMassU, SeaIceMassV

veris-0.1.1/veris/averaging.py

@@ -0,0 +1,19 @@
+from veros.core.operators import numpy as npx
+
+
+def c_point_to_z_point(state, Cfield, noSlip=True):
+    """calculates value at z-point by averaging c-point values"""
+
+    vs = state.variables
+
+    sumNorm = vs.iceMask + npx.roll(vs.iceMask, 1, 0)
+    sumNorm = sumNorm + npx.roll(sumNorm, 1, 1)
+    if noSlip:
+        sumNorm = npx.where(sumNorm > 0, 1.0 / sumNorm, 0.0)
+    else:
+        sumNorm = npx.where(sumNorm == 4.0, 0.25, 0.0)
+
+    Zfield = Cfield + npx.roll(Cfield, 1, 0)
+    Zfield = sumNorm * (Zfield + npx.roll(Zfield, 1, 1))
+
+    return Zfield

veris-0.1.1/veris/clean_up.py

@@ -0,0 +1,47 @@
+from veros.core.operators import numpy as npx
+from veros import veros_kernel
+
+
+@veros_kernel
+def clean_up_advection(state):
+    """clean up overshoots and other pathological cases after advection"""
+
+    vs = state.variables
+    sett = state.settings
+
+    # case 1: negative values
+    # calculate overshoots of ice and snow thickness
+    os_hIceMean = npx.maximum(-vs.hIceMean, 0)
+    os_hSnowMean = npx.maximum(-vs.hSnowMean, 0)
+
+    # cut off thicknesses and area at zero
+    hIceMean = npx.maximum(vs.hIceMean, 0)
+    hSnowMean = npx.maximum(vs.hSnowMean, 0)
+    Area = npx.maximum(vs.Area, 0)
+
+    # case 2: very thin ice
+    # set thicknesses to zero if the ice thickness is very small
+    thinIce = hIceMean <= sett.hIce_min
+    hIceMean *= ~thinIce
+    hSnowMean *= ~thinIce
+    TSurf = npx.where(thinIce, sett.celsius2K, vs.TSurf)
+
+    # case 3: area but no ice and snow
+    # set area to zero if no ice or snow is present
+    Area = npx.where((hIceMean == 0) & (hSnowMean == 0), 0, Area)
+
+    # case 4: very small area
+    # introduce lower boundary for the area (if ice or snow is present)
+    Area = npx.where(
+        (hIceMean > 0) | (hSnowMean > 0), npx.maximum(Area, sett.Area_min), Area
+    )
+
+    return hIceMean, hSnowMean, Area, TSurf, os_hIceMean, os_hSnowMean
+
+
+@veros_kernel
+def ridging(state):
+    """cut off ice cover fraction at 1 after advection to account for ridging"""
+    Area = npx.minimum(state.variables.Area, 1)
+
+    return Area