Metadata-Version: 2.1
Name: pymgrit
Version: 0.1.2
Summary: Python implementation of the MGRIT algorithm
Home-page: https://github.com/pymgrit/pymgrit
Author: Jens Hahne <jens.hahne@math.uni-wuppertal.de>, Stephanie Friedhoff <friedhoff@math.uni-wuppertal.de>
Author-email: jens.hahne@math.uni-wuppertal.de
License: MIT
Description: |Test Status| |Lint Status| |Docs Status| |Publish Status|
        
        .. |Lint Status| image:: https://github.com/pymgrit/pymgrit/workflows/Lint/badge.svg
           :target: https://github.com/pymgrit/pymgrit/actions?query=workflow%3ALint
        .. |Test Status| image:: https://github.com/pymgrit/pymgrit/workflows/Test/badge.svg
           :target: https://github.com/pymgrit/pymgrit/actions?query=workflow%3ATest
        .. |Docs Status| image:: https://github.com/pymgrit/pymgrit/workflows/Docs/badge.svg
           :target: https://github.com/pymgrit/pymgrit/actions?query=workflow%3ADocs
        .. |Publish Status| image:: https://github.com/pymgrit/pymgrit/workflows/Publish/badge.svg
           :target: https://github.com/pymgrit/pymgrit/actions?query=workflow%3APublish
        
        Introduction
        ------------
        
        PyMGRIT is a package for the Multigrid-Reduction-in-Time (MGRIT) algorithm in Python.
        
        PyMGRIT is currently developed by `Jens Hahne`_ and `Stephanie Friedhoff`_.
        
        .. _Jens Hahne: https://www.hpc.uni-wuppertal.de/en/scientific-computing-and-high-performance-computing/members/jens-hahne.html
        
        .. _Stephanie Friedhoff: https://www.hpc.uni-wuppertal.de/en/scientific-computing-and-high-performance-computing/members/dr-stephanie-friedhoff.html
        
        
        What is MGRIT?
        ---------------
        
        The MGRIT algorithm is a reduction-based time-multigrid method for solving time-dependent problems. A *reduction-based*
        method attempts to reduce the solving of one problem to equivalently solving two smaller problems. Reduction-based
        multigrid methods are iterative solvers that consist of two parts: relaxation and coarse-grid correction, which are,
        in the spirit of reduction, designed to be complementary in reducing error associated with different degrees of
        freedom. Applying this idea in the time domain, MGRIT combines local time stepping on the discretized temporal domain,
        the fine grid, for a relaxation scheme, with time stepping on a coarse temporal mesh (or a hierarchy of coarse
        temporal meshes) that uses a larger time step for the coarse-grid correction.
        
        PyMGRIT Features
        ----------------
        
        PyMGRIT features:
        
        * Classical Multigrid-Reduction-in-Time (MGRIT) for solving evolutionary systems of equations
        
          * Non-intrusive approach
          * Optimal time-multigrid algorithm
          * A variety of cycling strategies, relaxation schemes, and coarsening strategies
        
        * Time parallelism
        
        * Specific to space-time problems
        
          * Space & time parallelism
          * Additional coarsening in space
        
        Citing
        ------
        
        ::
        
            @MISC{PyMGRIT,
              author = "Hahne, J. and Friedhoff, S.",
              title = "{PyMGRIT}: Multigrid-Reduction-in-Time in {Python} v1.0",
              year = "2020",
              url = "https://github.com/pymgrit/pymgrit",
              note = "Release 1.0"
              }
        
        Installation
        ------------
        
        PyMGRIT requires ``mpicc`` (from ``openmpi`` or ``mpich``)
        
            >>> pip3 install pymgrit
        
        or
        
            >>> pip3 install .
        
        Example Usage
        ----------------
        
        PyMGRIT is easy to use! The following code generates a discrete Dahlquist test problem and solves the resulting linear
        system using a two-level MGRIT algorithm.::
        
            # Import PyMGRIT
            from pymgrit import *
        
            # Create Dahlquist's test problem with 101 time steps in the interval [0, 5]
            dahlquist = Dahlquist(t_start=0, t_stop=5, nt=101)
        
            # Construct a two-level multigrid hierarchy for the test problem using a coarsening factor of 2
            dahlquist_multilevel_structure = simple_setup_problem(problem=dahlquist, level=2, coarsening=2)
        
            # Set up the MGRIT solver for the test problem and set the solver tolerance to 1e-10
            mgrit = Mgrit(problem=dahlquist_multilevel_structure, tol=1e-10)
        
            # Solve the test problem
            info = mgrit.solve()
        
        Program output::
        
            INFO - 21-02-20 16:18:43 - Start setup
            INFO - 21-02-20 16:18:43 - Setup took 0.009232759475708008 s
            INFO - 21-02-20 16:18:43 - Start solve
            INFO - 21-02-20 16:18:43 - iter 1  | conv: 7.186185937031941e-05  | conv factor: -                       | runtime: 0.013237237930297852 s
            INFO - 21-02-20 16:18:43 - iter 2  | conv: 1.2461067076355103e-06 | conv factor: 0.017340307063501627    | runtime: 0.010195493698120117 s
            INFO - 21-02-20 16:18:43 - iter 3  | conv: 2.1015566145245807e-08 | conv factor: 0.016864981158092696    | runtime: 0.008922338485717773 s
            INFO - 21-02-20 16:18:43 - iter 4  | conv: 3.144127445017594e-10  | conv factor: 0.014960945726074891    | runtime: 0.0062139034271240234 s
            INFO - 21-02-20 16:18:43 - iter 5  | conv: 3.975214076032893e-12  | conv factor: 0.01264329816633959     | runtime: 0.006150722503662109 s
            INFO - 21-02-20 16:18:43 - Solve took 0.05394101142883301 s
            INFO - 21-02-20 16:18:43 - Run parameter overview
              time interval             : [0.0, 5.0]
              number of time points     : 101
              max dt                    : 0.05000000000000071
              number of levels          : 2
              coarsening factors        : [2]
              cf_iter                   : 1
              nested iteration          : True
              cycle type                : V
              stopping tolerance        : 1e-10
              time communicator size    : 1
              space communicator size   : -99
        
        
        Getting Help
        ------------
        
        For documentation see https://pymgrit.github.io/pymgrit/
        
        Create an issue_.
        
        .. _issue: https://github.com/pymgrit/pymgrit/issues
        
        Look at the Quickstart_, Tutorial_ or the Examples_.
        
        .. _Examples: https://pymgrit.github.io/pymgrit/usage/examples.html
        .. _Tutorial: https://pymgrit.github.io/pymgrit/usage/tutorial.html
        .. _Quickstart: https://pymgrit.github.io/pymgrit/usage/quickstart.html
        
        
Platform: UNKNOWN
Requires-Python: >=3.5
Description-Content-Type: text/x-rst
Provides-Extra: docs
Provides-Extra: tests
