Metadata-Version: 2.1
Name: veros
Version: 1.3.2
Summary: The versatile ocean simulator, in pure Python, powered by JAX.
Home-page: https://veros.readthedocs.io
Author: Dion Häfner (NBI Copenhagen)
Author-email: dion.haefner@nbi.ku.dk
License: MIT
Description: <p align="center">
        <img src="doc/_images/veros-logo-400px.png?raw=true">
        </p>
        
        <p align="center">
          <a href="http://veros.readthedocs.io/?badge=latest">
            <img src="https://readthedocs.org/projects/veros/badge/?version=latest" alt="Documentation status">
          </a>
          <a href="https://github.com/team-ocean/veros/actions/workflows/test-all.yml">
            <img src="https://github.com/team-ocean/veros/actions/workflows/test-all.yml/badge.svg" alt="Test status">
          </a>
          <a href="https://codecov.io/gh/team-ocean/veros">
            <img src="https://codecov.io/gh/team-ocean/veros/branch/master/graph/badge.svg" alt="Code Coverage">
          </a>
          <a href="https://zenodo.org/badge/latestdoi/87419383">
            <img src="https://zenodo.org/badge/87419383.svg" alt="DOI">
          </a>
        </p>
        
        Veros is the *versatile ocean simulator* -- it aims to be a powerful tool
        that makes high-performance ocean modeling approachable and fun. Because
        Veros is a pure Python module, the days of struggling with complicated
        model setup workflows, ancient programming environments, and obscure
        legacy code are finally over.
        
        Veros supports a NumPy backend for small-scale problems and a
        high-performance [JAX](https://github.com/google/jax) backend
        with CPU and GPU support. It is fully parallelized via MPI and supports distributed execution.
        
        The underlying numerics are based on
        [pyOM2](https://wiki.cen.uni-hamburg.de/ifm/TO/pyOM2), a Fortran ocean model
        developed at Institut für Meereskunde, Hamburg
        University.
        
        Veros is currently being developed at Niels Bohr Institute,
        Copenhagen University.
        
        #### How about a demonstration?
        
        <p align="center">
          <a href="https://vimeo.com/391237951">
              <img src="doc/_images/veros-preview.gif?raw=true" alt="0.25×0.25° high-resolution model spin-up">
          </a>
        </p>
        
        <p align="center">
        (0.25×0.25° high-resolution model spin-up, click for better
        quality)
        </p>
        
        ## Features
        
        Veros provides
        
        -   a fully staggered **3-D grid geometry** (*C-grid*)
        -   support for both **idealized and realistic configurations** in
            Cartesian or pseudo-spherical coordinates
        -   several **friction and advection schemes** to choose from
        -   isoneutral mixing, eddy-kinetic energy, turbulent kinetic energy,
            and internal wave energy **parameterizations**
        -   several **pre-implemented diagnostics** such as energy fluxes,
            variable time averages, and a vertical overturning stream function
            (written to netCDF output)
        -   **pre-configured idealized and realistic set-ups** that are ready to
            run and easy to adapt
        -   **accessibility and extensibility** - thanks to the
            power of Python!
        
        ## Veros for the impatient
        
        A minimal example to install and run Veros:
        
        ```bash
        $ pip install veros
        $ veros copy-setup acc --to /tmp/acc
        $ veros run /tmp/acc/acc.py
        ```
        
        For more detailed installation instructions, have a look at [our
        documentation](https://veros.readthedocs.io).
        
        ## Basic usage
        
        To run Veros, you need to set up a model - i.e., specify which settings
        and model domain you want to use. This is done by subclassing the
        `VerosSetup` base class in a *setup script* that is written in Python. You
        should use the `veros copy-setup` command to copy one into your current
        folder. A good place to start is the
        [ACC model](https://github.com/team-ocean/veros/blob/master/veros/setups/acc/acc.py):
        
        ```bash
        $ veros copy-setup acc
        ```
        
        After setting up your model, all you need to do is call the `setup` and
        `run` methods on your setup class. The pre-implemented setups can all be
        executed via `veros run`:
        
        ```bash
        $ veros run acc.py
        ```
        
        For more information on using Veros, have a look at [our
        documentation](http://veros.readthedocs.io).
        
        ## Contributing
        
        Contributions to Veros are always welcome, no matter if you spotted an
        inaccuracy in [the documentation](https://veros.readthedocs.io), wrote a
        new setup, fixed a bug, or even extended Veros\' core mechanics. There
        are 2 ways to contribute:
        
        1.  If you want to report a bug or request a missing feature, please
            [open an issue](https://github.com/team-ocean/veros/issues). If you
            are reporting a bug, make sure to include all relevant information
            for reproducing it (ideally through a *minimal* code sample).
        2.  If you want to fix the issue yourself, or wrote an extension for
            Veros - great! You are welcome to submit your code for review by
            committing it to a repository and opening a [pull
            request](https://github.com/team-ocean/veros/pulls). However,
            before you do so, please check [the contribution
            guide](http://veros.readthedocs.io/quickstart/get-started.html#enhancing-veros)
            for some tips on testing and benchmarking, and to make sure that
            your modifications adhere with our style policies. Most importantly,
            please ensure that you follow the [PEP8
            guidelines](https://www.python.org/dev/peps/pep-0008/), use
            *meaningful* variable names, and document your code using
            [Google-style
            docstrings](http://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html).
        
Keywords: oceanography python parallel numpy multi-core geophysics ocean-model mpi4py jax
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Topic :: Scientific/Engineering
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX
Classifier: Operating System :: Unix
Classifier: Operating System :: MacOS
Requires-Python: >=3.6
Description-Content-Type: text/markdown
Provides-Extra: test
Provides-Extra: jax
