pyamg.readthedocs.io Open in urlscan Pro
2606:4700::6811:2052  Public Scan

Form analysis
2 forms found in the DOM

GET search.html

<form class="bd-search d-flex align-items-center" action="search.html" method="get">
  <svg class="svg-inline--fa fa-magnifying-glass" aria-hidden="true" focusable="false" data-prefix="fas" data-icon="magnifying-glass" role="img" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" data-fa-i2svg="">
    <path fill="currentColor"
      d="M416 208c0 45.9-14.9 88.3-40 122.7L502.6 457.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L330.7 376c-34.4 25.2-76.8 40-122.7 40C93.1 416 0 322.9 0 208S93.1 0 208 0S416 93.1 416 208zM208 352a144 144 0 1 0 0-288 144 144 0 1 0 0 288z"></path>
  </svg><!-- <i class="fa-solid fa-magnifying-glass"></i> Font Awesome fontawesome.com -->
  <input type="search" class="form-control" name="q" id="search-input" placeholder="Search the docs ..." aria-label="Search the docs ..." autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false">
  <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
</form>

GET //readthedocs.org/projects/pyamg/search/

<form id="flyout-search-form" class="wy-form" target="_blank" action="//readthedocs.org/projects/pyamg/search/" method="get">
  <input type="text" name="q" aria-label="Dokumente durchsuchen" placeholder="Dokumente durchsuchen">
</form>

Text Content

Skip to main content

Back to top
Ctrl+K
 * PyAMG Reference

Search Ctrl+K

 * GitHub

Search Ctrl+K
 * PyAMG Reference

 * GitHub

JSONBuddy - JSON text and grid editor and unmatched JSON Schema development
environment.
Ad by EthicalAds   ·   ℹ️
v: latest
Versionen latest Auf Read the Docs Projektstartseite Erstellungsprozesse
Downloads Auf GitHub Ansehen Bearbeiten Suche


--------------------------------------------------------------------------------

Bereitgestellt von Read the Docs · Datenschutz-Bestimmungen


PYAMG 5.0.1.POST1.DEV21+G2195973#


INSTALLATION#

PyAMG requires numpy and scipy

pip install pyamg


or from source:

pip install .


(python setup.py install will no longer work)

or with conda (see details below)

conda config --add channels conda-forge
conda install pyamg



INTRODUCTION#

PyAMG is a library of Algebraic Multigrid (AMG) solvers with a convenient Python
interface.

PyAMG is currently developed and maintained by Luke Olson, Jacob Schroder, and
Ben Southworth. The organization of the project can be found in
``organization.md` <organization.md>`_ and examples of use can be found in
``pyamg-examples` <pyamg/pyamg-examples>`_.

Acknowledgements: PyAMG was created by Nathan Bell, Luke Olson, and Jacob
Schroder. Portions of the project were partially supported by the NSF under
award DMS-0612448.


CITING#

If you use PyAMG in your work, please consider using the following citation:

@article{pyamg2023,
  author    = {Nathan Bell and Luke N. Olson and Jacob Schroder and Ben Southworth},
  title     = {{PyAMG}: Algebraic Multigrid Solvers in Python},
  journal   = {Journal of Open Source Software}
  year      = {2023},
  publisher = {The Open Journal},
  volume    = {8},
  number    = {87},
  pages     = {5495},
  doi       = {10.21105/joss.05495},
  url       = {https://doi.org/10.21105/joss.05495},
}



GETTING HELP#

 * For documentation see http://pyamg.readthedocs.io/en/latest/.

 * Create an issue.

 * Look at the Tutorial or the examples (for instance the 0_start_here example).

 * Run the unit tests (pip install pytest):
   
   * With PyAMG installed and from a non-source directory: .. code-block::
     python
     
     > import pyamg pyamg.test()
   
   * From the PyAMG source directory and installed (e.g. with pip install -e .):
     .. code-block:: python
     
     > pytest .


WHAT IS AMG?#

> AMG is a multilevel technique for solving large-scale linear systems with
> optimal or near-optimal efficiency. Unlike geometric multigrid, AMG requires
> little or no geometric information about the underlying problem and develops a
> sequence of coarser grids directly from the input matrix. This feature is
> especially important for problems discretized on unstructured meshes and
> irregular grids.


PYAMG FEATURES#

PyAMG features implementations of:

 * Ruge-Stuben (RS) or Classical AMG

 * AMG based on Smoothed Aggregation (SA)

and experimental support for:

 * Adaptive Smoothed Aggregation (αSA)

 * Compatible Relaxation (CR)

The predominant portion of PyAMG is written in Python with a smaller amount of
supporting C++ code for performance critical operations.


EXAMPLE USAGE#

PyAMG is easy to use! The following code constructs a two-dimensional Poisson
problem and solves the resulting linear system with Classical AMG.

import pyamg
import numpy as np
A = pyamg.gallery.poisson((500,500), format='csr')  # 2D Poisson problem on 500x500 grid
ml = pyamg.ruge_stuben_solver(A)                    # construct the multigrid hierarchy
print(ml)                                           # print hierarchy information
b = np.random.rand(A.shape[0])                      # pick a random right hand side
x = ml.solve(b, tol=1e-10)                          # solve Ax=b to a tolerance of 1e-10
print("residual: ", np.linalg.norm(b-A*x))          # compute norm of residual vector


Program output:

multilevel_solver
Number of Levels:     9
Operator Complexity:  2.199
Grid Complexity:      1.667
Coarse Solver:        'pinv2'
  level   unknowns     nonzeros
    0       250000      1248000 [45.47%]
    1       125000      1121002 [40.84%]
    2        31252       280662 [10.23%]
    3         7825        70657 [ 2.57%]
    4         1937        17971 [ 0.65%]
    5          483         4725 [ 0.17%]
    6          124         1352 [ 0.05%]
    7           29          293 [ 0.01%]
    8            7           41 [ 0.00%]

residual:  1.24748994988e-08



CONDA#

More information can be found at conda-forge/pyamg-feedstock.

Linux:

OSX:

Windows:

Version:

Downloads:

Installing pyamg from the conda-forge channel can be achieved by adding
conda-forge to your channels with:

conda config --add channels conda-forge


Once the conda-forge channel has been enabled, pyamg can be installed with:

conda install pyamg


It is possible to list all of the versions of pyamg available on your platform
with:

conda search pyamg --channel conda-forge



REFERENCE#

 * Index

 * Module Index

 * PyAMG Reference
   * Multigrid data structure (“The Multilevel Hierarchy”)
     * pyamg.multilevel
       * MultilevelSolver
       * coarse_grid_solver()
       * multilevel_solver
   * Core AMG Methods
     * pyamg.aggregation
       * adaptive_sa_solver()
       * balanced_lloyd_aggregation()
       * energy_prolongation_smoother()
       * fit_candidates()
       * jacobi_prolongation_smoother()
       * lloyd_aggregation()
       * naive_aggregation()
       * pairwise_solver()
       * richardson_prolongation_smoother()
       * rootnode_solver()
       * smoothed_aggregation_solver()
       * standard_aggregation()
     * pyamg.classical
       * air_solver()
       * ruge_stuben_solver()
   * Common AMG Components
     * pyamg.relaxation
     * pyamg.strength
       * affinity_distance()
       * algebraic_distance()
       * classical_strength_of_connection()
       * distance_measure_common()
       * distance_strength_of_connection()
       * energy_based_strength_of_connection()
       * evolution_strength_of_connection()
       * ode_strength_of_connection()
       * relaxation_vectors()
       * symmetric_strength_of_connection()
   * Helper Routings
     * pyamg.graph
       * asgraph()
       * bellman_ford()
       * breadth_first_search()
       * connected_components()
       * lloyd_cluster()
       * maximal_independent_set()
       * pseudo_peripheral_node()
       * symmetric_rcm()
       * vertex_coloring()
     * pyamg.util
       * make_system()
       * upcast()
   * Krylov Methods
     * pyamg.krylov
       * Functions
       * References
       * bicgstab()
       * cg()
       * cgne()
       * cgnr()
       * cr()
       * fgmres()
       * gmres()
       * gmres_householder()
       * gmres_mgs()
       * minimal_residual()
       * steepest_descent()
   * Gallery Problems
     * pyamg.gallery
       * Functions
       * advection_2d()
       * demo()
       * diffusion_stencil_2d()
       * gauge_laplacian()
       * linear_elasticity()
       * linear_elasticity_p1()
       * load_example()
       * poisson()
       * regular_triangle_mesh()
       * sprand()
       * stencil_grid()
   * amg_core
     * pyamg.amg_core
       * apply_absolute_distance_filter()
       * apply_distance_filter()
       * apply_givens()
       * apply_householders()
       * approx_ideal_restriction_pass1()
       * approx_ideal_restriction_pass2()
       * bellman_ford()
       * block_approx_ideal_restriction_pass2()
       * block_gauss_seidel()
       * block_jacobi()
       * block_jacobi_indexed()
       * breadth_first_search()
       * bsr_gauss_seidel()
       * bsr_jacobi()
       * bsr_jacobi_indexed()
       * calc_BtB()
       * classical_strength_of_connection_abs()
       * classical_strength_of_connection_min()
       * cljp_naive_splitting()
       * cluster_center()
       * cluster_node_incidence()
       * connected_components()
       * cr_helper()
       * csc_scale_columns()
       * csc_scale_rows()
       * evolution_strength_helper()
       * extract_subblocks()
       * filter_matrix_rows()
       * fit_candidates()
       * gauss_seidel()
       * gauss_seidel_indexed()
       * gauss_seidel_ne()
       * gauss_seidel_nr()
       * householder_hornerscheme()
       * incomplete_mat_mult_bsr()
       * incomplete_mat_mult_csr()
       * jacobi()
       * jacobi_indexed()
       * jacobi_ne()
       * lloyd_cluster()
       * lloyd_cluster_exact()
       * maximal_independent_set_k_parallel()
       * maximal_independent_set_parallel()
       * maximal_independent_set_serial()
       * maximum_row_value()
       * min_blocks()
       * naive_aggregation()
       * one_point_interpolation()
       * overlapping_schwarz_csr()
       * pairwise_aggregation()
       * pinv_array()
       * remove_strong_FF_connections()
       * rs_cf_splitting()
       * rs_cf_splitting_pass2()
       * rs_classical_interpolation_pass1()
       * rs_classical_interpolation_pass2()
       * rs_direct_interpolation_pass1()
       * rs_direct_interpolation_pass2()
       * satisfy_constraints_helper()
       * standard_aggregation()
       * symmetric_strength_of_connection()
       * truncate_rows_csr()
       * vertex_coloring_LDF()
       * vertex_coloring_jones_plassmann()
       * vertex_coloring_mis()

next

PyAMG Reference

On this page
 * PyAMG 5.0.1.post1.dev21+g2195973
 * Installation
 * Introduction
 * Citing
 * Getting Help
 * What is AMG?
 * PyAMG Features
 * Example Usage
 * Conda
 * Reference

Show Source


© Copyright 2022, Luke Olson.


Created using Sphinx 7.2.6.


Built with the PyData Sphinx Theme 0.15.2.