petsc4py - PETSc for Python

       Lisandro Dalcin

3.22                                              Mar 12, 2025                                       PETSC4PY(3)

       If  PETSc  for  Python  has  been  significant to a project that leads to an academic publication, please
       acknowledge that fact by citing the project.

       • L. Dalcin, P. Kler, R. Paz, and A. Cosimo, ParallelDistributedComputingusingPython,  Advances  in
         Water Resources, 34(9):1124-1139, 2011.  https://doi.org/10.1016/j.advwatres.2011.04.013

       • S.  Balay,  S. Abhyankar, M. Adams, S. Benson, J. Brown, P. Brune, K. Buschelman, E. Constantinescu, L.
         Dalcin, A. Dener, V. Eijkhout, J. Faibussowitsch,  W.  Gropp,  V.  Hapla,  T.  Isaac,  P.  Jolivet,  D.
         Karpeyev,  D.  Kaushik,  M.  Knepley,  F.  Kong,  S.  Kruger,  D. May, L. Curfman McInnes, R. Mills, L.
         Mitchell, T. Munson, J. Roman, K. Rupp, P. Sanan, J Sarich, B. Smith, H. Suh, S. Zampini, H. Zhang, and
         H.   Zhang,   J.   Zhang,   PETSc/TAOUsersManual,   ANL-21/39   -   Revision   3.22,   2024.    ‐
         https://doi.org/10.2172/2205494, https://petsc.org/release/docs/manual/manual.pdf

       Contributions  from  the  user  community are welcome. See the PETScdevelopers documentation for general
       information on contributions.

       New contributions to petsc4py must adhere with the coding standards.  We use cython-lint for Cython and ‐
       ruff for Python source codes.  These can be installed using:

          $ python -m pip install -r src/binding/petsc4py/conf/requirements-lint.txt

       If you are contributing Cython code, you can check compliance with:

          $ make cython-lint -C src/binding/petsc4py

       For Python code, run:

          $ make ruff-lint -C src/binding/petsc4py

       Python code can be auto-formatted using:

          $ make ruff-lint RUFF_OPTS='format' -C src/binding/petsc4py

       New contributions to petsc4py must be tested.  Tests are located in the src/binding/petsc4py/test folder.
       To add a new test, either add a new test_xxx.py or modify a pre-existing file according to  the  unittest
       specifications.

       If you add a new test_xxx.py, you can run the tests using:

          $ cd src/binding/petsc4py
          $ python test/runtests.py -k test_xxx

       If  instead  you  are  modifying  an existing test_xxx.py, you can test your additions by using the fully
       qualified name of the Python class or method you are modifying, e.g.:

          $ python test/runtests.py -k test_xxx.class_name.method_name

       All new code must include documentation in accordance with  the  documentationstandard.  To  check  for
       compliance, run:

          $ make html SPHINXOPTS='-W' -C src/binding/petsc4py/docs/source

       WARNING:
          The docstrings must not cause Sphinx warnings.

       Subject to exceptions given below, new contributions  to  petsc4py  must  include  typeannotations  for
       function parameters and results, and docstrings on every class, function and method.

       The documentation should be consistent with the corresponding C API documentation, including copying text
       where  this  is  appropriate. More in-depth documentation from the C API (such as extended discussions of
       algorithmic or performance factors) should not be copied.

   Docstringstandards
       Docstrings are to be written in numpydoc:format format.

       The first line of a class, function or method docstring must be a short  description  of  the  method  in
       imperative  mood  ("Return  the  norm  of  the  matrix.")  "Return" is to be preferred over "Get" in this
       sentence. A blank line must follow this description. Use one-liner descriptions for properties.

       If the corresponding C API documentation of a method lists a function  as  being  collective,  then  this
       information  must  be  repeated  on the next line of the docstring. Valid strings are: "Not collective.",
       "Logically collective.", "Collective.", "Neighborwise collective.", or "Collective the first time  it  is
       called".

       The  initial description section can contain more information if this is useful.  In particular, if there
       is a PETSc manual chapter about a class, then this should be referred to from here.

       Use double backticks around literals (like strings and numbers), e.g., ``2``, ``"foo"``.

       Reference PETSc functions simply using backticks, e.g., KSP refers to the PETSc C documentation for  KSP.
       Do not use URLs in docstrings. Always use Intersphinx references.

       The  following  sections describe the use of numpydoc sections. Other sections allowed by numpydoc may be
       included if they are useful.

   Parameters
       This is required for methods unless there are no parameters, or it will be completely obvious to  even  a
       novice user what the parameters do.

       If  a  class  has  a  non-trivial  constructor,  the arguments of the constructor and their types must be
       explicitly documented within this section.

       For methods, types should only be specified in this section if for some  reason  the  types  provided  by
       typing  prove to be inadequate. If no type is being specified, do not include a colon (:) to the right of
       the parameter name.

       Use Sys.getDefaultComm when specifying the default communicator.

   Returns
       This should only be specified if the return value is not obvious from the initial description and typing.

       If a "Returns" section is required, the type of the returned  items  must  be  specified,  even  if  this
       duplicates typing information.

   SeeAlso
       If  any  of the following apply, then this section is required. The order of entries is as follows. Other
       links are permitted in this section if they add information useful to users.

       Every setFromOptions must include the link `petsc_options`.

       Any closely related part of the petsc4py API not already linked in  the  docstring  should  appear  (e.g.
       setters and getters should cross-refer).

       If  there  is  a corresponding C API documentation page, this must be linked from the "See also" section,
       e.g. `petsc.MatSetValues`.

       End docstring with an empty line - "closing three quotation marks must be on a line by itself, preferably
       preceded by a blank line"

   Typehintstandards
       If returning self, use ->Self in function signature.

       Type hints are not required when the static type signature includes a PETSc type (e.g. Vecx). These will
       be automatically generated. This will also work for =None. When using type hints, use spacing around the
       equals in any =None.

       Communicators in type signatures must use Python typing instead of c-typing (i.e.  comm:Comm  not  Commcomm). This is because communicators can come from mpi4py and not just the petsc4py.PETSc.Comm class.

       For  petsc4py  native  types  that  are  strings, the type is argument:KSP.Type|str (not e.g.: KSPTypeargument). If the type is strictly an enum the |str can be omitted. Full signature example:

          def setType(self, ksp_type: KSP.Type | str) -> None:

       If a NumPy array is returned, use ArrayBool/ArrayInt/ArrayReal/ArrayScalar as the return type.

InstallfromPyPIusingpip
       You can use pip to install petsc4py and its dependencies (mpi4py is optional but highly recommended):

          $ python -m pip install mpi4py petsc petsc4py

   InstallfromthePETScsourcetree
       First buildPETSc. Next cd to the top of the PETSc source tree  and  set  the  PETSC_DIR  and  PETSC_ARCH
       environment variables. Run:

          $ python -m pip install src/binding/petsc4py

       The installation of petsc4py supports multiple PETSC_ARCH in the form of colon separated list:

          $ PETSC_ARCH='arch-0:...:arch-N' python -m pip install src/binding/petsc4py

       If  you  are  cross-compiling,  and  the  numpy  module  cannot be loaded on your build host, then before
       invoking pip, set the NUMPY_INCLUDE environment variable to the path that would  be  returned  by  importnumpy;numpy.get_include():

          $ export NUMPY_INCLUDE=/usr/lib/pythonX/site-packages/numpy/core/include

   Runningthetestingsuite
       When installing from source, the petsc4py complete testsuite can be run as:

          $ cd src/binding/petsc4py
          $ python test/runtests.py

       or via the makefile rule test:

          $ make test -C src/binding/petsc4py

       Specific tests can be run using the command-line option -k, e.g.:

          $ python test/runtests.py -k test_optdb

       to run all the tests provided in tests/test_optdb.py.

       For other command-line options, run:

          $ python test/runtests.py --help

       If not otherwise specified, all tests will be run in sequential mode.  To run all the tests with the same
       number of MPI processes, for example 4, run:

          $ mpiexec -n 4 python test/runtests.py

       or:

          $ make test-4 -C src/binding/petsc4py

   Buildingthedocumentation
       Install the documentation dependencies:

          $ python -m pip install -r ${PETSC_DIR/doc/requirements.txt

       Then:

          $ cd src/binding/petsc4py/docs/source
          $ make html

       The resulting HTML files will be in _build/html.

       NOTE:
          Building the documentation requires Python 3.11 or later.

       petsc4py - PETSc for Python

       Author Lisandro Dalcin

       Contactdalcinl@gmail.comWebSitehttps://gitlab.com/petsc/petscDate   Mar 12, 2025

   Abstract
       This document describes petsc4py, a Python wrapper to the PETSc libraries.

       PETSc  (the  Portable,  Extensible  Toolkit for Scientific Computation) is a suite of data structures and
       routines for the scalable (parallel) solution of scientific applications modeled by partial  differential
       equations. It employs the MPI standard for all message-passing communication.

       This  package  provides an important subset of PETSc functionalities and uses NumPy to efficiently manage
       input and output of array data.

       A goodfriend of petsc4py is:

          • mpi4py: Python bindings for MPI, the MessagePassingInterface.

       Other projects depend on petsc4py:

          • slepc4py: Python bindings for SLEPc, the ScalableLibraryforEigenvalueProblemComputations.

PETSc is a suite of data structures and routines for  the  scalable  (parallel)  solution  of  scientific
       applications   modeled   by  partial  differential  equations.  It  employs  the  MPI  standard  for  all
       message-passing communication.

       PETSc is intended for use in large-scale application  projects  [petsc-efficient],  and  several  ongoing
       computational  science  projects are built around the PETSc libraries. With strict attention to component
       interoperability, PETSc facilitates the integration of independently developed application modules, which
       often most naturally employ different coding styles and data structures.

       PETSc is easy to use for beginners [petsc-user-ref]. Moreover, its careful design allows  advanced  users
       to  have detailed control over the solution process. PETSc includes an expanding suite of parallel linear
       and nonlinear equation solvers that are easily used in application codes written in C, C++, and  Fortran.
       PETSc  provides  many of the mechanisms needed within parallel application codes, such as simple parallel
       matrix and vector assembly routines that allow the overlap of communication and computation.

       [petsc-user-ref]
            S. Balay, S. Abhyankar, M. Adams, S. Benson, J. Brown, P. Brune, K. Buschelman,  E.  Constantinescu,
            L.  Dalcin,  A.  Dener, V. Eijkhout, J. Faibussowitsch, W. Gropp, V. Hapla, T. Isaac, P. Jolivet, D.
            Karpeyev, D. Kaushik, M. Knepley, F. Kong, S. Kruger, D. May,  L.  Curfman  McInnes,  R.  Mills,  L.
            Mitchell,  T. Munson, J. Roman, K. Rupp, P. Sanan, J Sarich, B. Smith, H. Suh, S. Zampini, H. Zhang,
            and  H.  Zhang,  J.  Zhang,  PETSc/TAOUsersManual,  ANL-21/39  -   Revision   3.22,   2024.    ‐
            http://dx.doi.org/10.2172/2205494, https://petsc.org/release/docs/manual/manual.pdf

       [petsc-efficient]
            Satish  Balay, Victor Eijkhout, William D. Gropp, Lois Curfman McInnes and Barry F. Smith. Efficient
            Management of Parallelism in Object Oriented Numerical Software Libraries. Modern Software Tools  in
            Scientific  Computing.  E.  Arge,  A. M. Bruaset and H. P. Langtangen, editors. 163--202. Birkhauser
            Press. 1997.

   Components
       PETSc is designed with an object-oriented style. Almost all user-visible types  are  abstract  interfaces
       with  implementations  that may be chosen at runtime. Those objects are managed through handles to opaque
       data structures which are created, accessed and destroyed by calling appropriate library routines.

       PETSc consists of a variety of components. Each component manipulates a particular family of objects  and
       the  operations  one  would  like to perform on these objects. These components provide the functionality
       required for many parallel solutions of PDEs.

       Vec    Provides the vector operations  required  for  setting  up  and  solving  large-scale  linear  and
              nonlinear  problems.  Includes  easy-to-use  parallel  scatter  and  gather operations, as well as
              special-purpose code for handling ghost points for regular data structures.

       Mat    A large suite of data structures and code  for  the  manipulation  of  parallel  sparse  matrices.
              Includes several different parallel matrix data structures, each appropriate for a different class
              of problems.

       PC     A  collection  of  sequential and parallel preconditioners, including (sequential) ILU(k), LU, and
              (both sequential and parallel) block Jacobi, overlapping additive Schwarz methods.

       KSP    Parallel implementations of many popular Krylov subspace iterative methods, including  GMRES,  CG,
              CGS,  Bi-CG-Stab,  two variants of TFQMR, CR, and LSQR. All are coded so that they are immediately
              usable with any preconditioners and any matrix data structures, including matrix-free methods.

       SNES   Data-structure-neutral implementations of Newton-like methods for nonlinear systems. Includes both
              line search and trust region techniques with a single interface. Employs by default the above data
              structures and linear solvers. Users can set custom  monitoring  routines,  convergence  criteria,
              etc.

       TS     Code  for  the  time  evolution  of  solutions  of  PDEs.  In  addition, provides pseudo-transient
              continuation techniques for computing steady-state solutions.

       Here we discuss details about Python-aware PETSc types that can be used within the library.

       In  particular,  we  discuss  matrices,  preconditioners,  Krylov  solvers,  nonlinear  solvers  and  ODE
       integrators.

       The    low-level,    Cython    implementation    exposing    the    Python    methods     is     in     ‐
       src/petsc4py/PETSc/libpetsc4py.pyx.

       The scripts used here can be found at demo/python_types.

   PETScPythonmatrixtype
       PETSc  provides  a  convenient  way to compute the action of linear operators coded in Python through the
       petsc4py.PETSc.Mat.Type.PYTHON type.

       In addition to the matrix action, the implementation can expose additional methods  for  use  within  the
       library. A template class for the supported methods is given below.

          from petsc4py.typing import Scalar
          from petsc4py.PETSc import Mat
          from petsc4py.PETSc import Vec
          from petsc4py.PETSc import IS
          from petsc4py.PETSc import InsertMode
          from petsc4py.PETSc import NormType
          from petsc4py.PETSc import Viewer

          # A template class with the Python methods supported by MATPYTHON

          class MatPythonProtocol:
              def mult(self, A: Mat, x: Vec, y: Vec) -> None:
                  """Matrix vector multiplication: y = A @ x."""
                  ...

              def multAdd(self, A: Mat, x: Vec, y: Vec, z: Vec) -> None:
                  """Matrix vector multiplication: z = A @ x + y."""
                  ...

              def multTranspose(self, A: Mat, x: Vec, y: Vec) -> None:
                  """Transposed matrix vector multiplication: y = A^T @ x."""
                  ...

              def multTransposeAdd(self, A: Mat, x: Vec, y: Vec, z: Vec) -> None:
                  """Transposed matrix vector multiplication: z = A^T @ x + y."""
                  ...

              def multHermitian(self, A: Mat, x: Vec, y: Vec) -> None:
                  """Hermitian matrix vector multiplication: y = A^H @ x."""
                  ...

              def multHermitianAdd(self, A: Mat, x: Vec, y: Vec, z: Vec) -> None:
                  """Hermitian matrix vector multiplication: z = A^H @ x + y."""
                  ...

              def view(self, A: Mat, viewer: Viewer) -> None:
                  """View the matrix."""
                  ...

              def setFromOptions(self, A: Mat) -> None:
                  """Process command line for customization."""
                  ...

              def multDiagonalBlock(self, A: Mat, x: Vec, y: Vec) -> None:
                  """Perform the on-process matrix vector multiplication."""
                  ...

              def createVecs(self, A: Mat) -> tuple[Vec, Vec]:
                  """Return tuple of vectors (x,y) suitable for A @ x = y."""
                  ...

              def scale(self, A: Mat, s: Scalar) -> None:
                  """Scale the matrix by a scalar."""
                  ...

              def shift(self, A: Mat, s: Scalar) -> None:
                  """Shift the matrix by a scalar."""
                  ...

              def createSubMatrix(self, A: Mat, r: IS, c: IS, out: Mat) -> Mat:
                  """Return the submatrix corresponding to r rows and c columns.

                  Matrix out must be reused if not None.

                  """
                  ...

              def zeroRowsColumns(self, A: Mat, r: IS, diag: Scalar, x: Vec, b: Vec) -> None:
                  """Zero rows and columns of the matrix corresponding to the index set r.

                  Insert diag on the diagonal and modify vectors x and b accordingly if not None.

                  """
                  ...

              def getDiagonal(self, A: Mat, d: Vec) -> None:
                  """Compute the diagonal of the matrix: d = diag(A)."""
                  ...

              def setDiagonal(self, A: Mat, d: Vec, im: InsertMode) -> None:
                  """Set the diagonal of the matrix."""
                  ...

              def missingDiagonal(self, A: Mat, d: Vec, im: InsertMode) -> tuple[bool, int]:
                  """Return a flag indicating if the matrix is missing a diagonal entry and the location."""
                  ...

              def diagonalScale(self, A: Mat, L: Vec, R: Vec) -> None:
                  """Perform left and right diagonal scaling if vectors are not None.

                  A = diag(L)@A@diag(R).

                  """
                  ...

              def getDiagonalBlock(self, A: Mat) -> Mat:
                  """Return the on-process matrix."""
                  ...

              def setUp(self, A: Mat) -> None:
                  """Perform the required setup."""
                  ...

              def duplicate(self, A: Mat, op: Mat.DuplicateOption) -> Mat:
                  """Duplicate the matrix."""
                  ...

              def copy(self, A: Mat, B: Mat, op: Mat.Structure) -> None:
                  """Copy the matrix: B = A."""
                  ...

              def productSetFromOptions(
                  self, A: Mat, prodtype: str, X: Mat, Y: Mat, Z: Mat
              ) -> bool:
                  """The boolean flag indicating if the matrix supports prodtype."""
                  ...

              def productSymbolic(
                  self, A: Mat, product: Mat, producttype: str, X: Mat, Y: Mat, Z: Mat
              ) -> None:
                  """Perform the symbolic stage of the requested matrix product."""
                  ...

              def productNumeric(
                  self, A: Mat, product: Mat, producttype: str, X: Mat, Y: Mat, Z: Mat
              ) -> None:
                  """Perform the numeric stage of the requested matrix product."""
                  ...

              def zeroEntries(self, A: Mat) -> None:
                  """Set the matrix to zero."""
                  ...

              def norm(self, A: Mat, normtype: NormType) -> float:
                  """Compute the norm of the matrix."""
                  ...

              def solve(self, A: Mat, y: Vec, x: Vec) -> None:
                  """Solve the equation: x = inv(A) y."""
                  ...

              def solveAdd(self, A: Mat, y: Vec, z: Vec, x: Vec) -> None:
                  """Solve the equation: x = inv(A) y + z."""
                  ...

              def solveTranspose(self, A: Mat, y: Vec, x: Vec) -> None:
                  """Solve the equation: x = inv(A)^T y."""
                  ...

              def solveTransposeAdd(self, A: Mat, y: Vec, z: Vec, x: Vec) -> None:
                  """Solve the equation: x = inv(A)^T y + z."""
                  ...

              def SOR(
                  self,
                  A: Mat,
                  b: Vec,
                  omega: float,
                  sortype: Mat.SORType,
                  shift: float,
                  its: int,
                  lits: int,
                  x: Vec,
              ) -> None:
                  """Perform SOR iterations."""
                  ...

              def conjugate(self, A: Mat) -> None:
                  """Perform the conjugation of the matrix: A = conj(A)."""
                  ...

              def imagPart(self, A: Mat) -> None:
                  """Set real part to zero. A = imag(A)."""
                  ...

              def realPart(self, A: Mat) -> None:
                  """Set imaginary part to zero. A = real(A)."""
                  ...

       In  the  example  below,  we  create an operator that applies the Laplacian operator on a two-dimensional
       grid, and use it to solve the associated linear system.  The default  preconditioner  in  the  script  is
       petsc4py.PETSc.PC.Type.JACOBI which needs to access the diagonal of the matrix.

          # ------------------------------------------------------------------------
          #
          #  Poisson problem. This problem is modeled by the partial
          #  differential equation
          #
          #          -Laplacian(u) = 1,  0 < x,y < 1,
          #
          #  with boundary conditions
          #
          #           u = 0  for  x = 0, x = 1, y = 0, y = 1
          #
          #  A finite difference approximation with the usual 5-point stencil
          #  is used to discretize the boundary value problem to obtain a
          #  nonlinear system of equations. The problem is solved in a 2D
          #  rectangular domain, using distributed arrays (DAs) to partition
          #  the parallel grid.
          #
          # ------------------------------------------------------------------------

          # We first import petsc4py and sys to initialize PETSc
          import sys
          import petsc4py

          petsc4py.init(sys.argv)

          # Import the PETSc module
          from petsc4py import PETSc

          # Here we define a class representing the discretized operator
          # This allows us to apply the operator "matrix-free"
          class Poisson2D:
              def __init__(self, da):
                  self.da = da
                  self.localX = da.createLocalVec()

              # This is the method that PETSc will look for when applying
              # the operator. `X` is the PETSc input vector, `Y` the output vector,
              # while `mat` is the PETSc matrix holding the PETSc datastructures.
              def mult(self, mat, X, Y):
                  # Grid sizes
                  mx, my = self.da.getSizes()
                  hx, hy = (1.0 / m for m in [mx, my])

                  # Bounds for the local part of the grid this process owns
                  (xs, xe), (ys, ye) = self.da.getRanges()

                  # Map global vector to local vectors
                  self.da.globalToLocal(X, self.localX)

                  # We can access the vector data as NumPy arrays
                  x = self.da.getVecArray(self.localX)
                  y = self.da.getVecArray(Y)

                  # Loop on the local grid and compute the local action of the operator
                  for j in range(ys, ye):
                      for i in range(xs, xe):
                          u = x[i, j]  # center
                          u_e = u_w = u_n = u_s = 0
                          if i > 0:
                              u_w = x[i - 1, j]  # west
                          if i < mx - 1:
                              u_e = x[i + 1, j]  # east
                          if j > 0:
                              u_s = x[i, j - 1]  # south
                          if j < ny - 1:
                              u_n = x[i, j + 1]  # north
                          u_xx = (-u_e + 2 * u - u_w) * hy / hx
                          u_yy = (-u_n + 2 * u - u_s) * hx / hy
                          y[i, j] = u_xx + u_yy

              # This is the method that PETSc will look for when the diagonal of the matrix is needed.
              def getDiagonal(self, mat, D):
                  mx, my = self.da.getSizes()
                  hx, hy = (1.0 / m for m in [mx, my])
                  (xs, xe), (ys, ye) = self.da.getRanges()

                  d = self.da.getVecArray(D)

                  # Loop on the local grid and compute the diagonal
                  for j in range(ys, ye):
                      for i in range(xs, xe):
                          d[i, j] = 2 * hy / hx + 2 * hx / hy

              # The class can contain other methods that PETSc won't use
              def formRHS(self, B):
                  b = self.da.getVecArray(B)
                  mx, my = self.da.getSizes()
                  hx, hy = (1.0 / m for m in [mx, my])
                  (xs, xe), (ys, ye) = self.da.getRanges()
                  for j in range(ys, ye):
                      for i in range(xs, xe):
                          b[i, j] = 1 * hx * hy

          # Access the option database and read options from the command line
          OptDB = PETSc.Options()
          nx, ny = OptDB.getIntArray(
              'grid', (16, 16)
          )  # Read `-grid <int,int>`, defaults to 16,16

          # Create the distributed memory implementation for structured grid
          da = PETSc.DMDA().create([nx, ny], stencil_width=1)

          # Create vectors to hold the solution and the right-hand side
          x = da.createGlobalVec()
          b = da.createGlobalVec()

          # Instantiate an object of our Poisson2D class
          pde = Poisson2D(da)

          # Create a PETSc matrix of type Python using `pde` as context
          A = PETSc.Mat().create(comm=da.comm)
          A.setSizes([x.getSizes(), b.getSizes()])
          A.setType(PETSc.Mat.Type.PYTHON)
          A.setPythonContext(pde)
          A.setUp()

          # Create a Conjugate Gradient Krylov solver
          ksp = PETSc.KSP().create()
          ksp.setType(PETSc.KSP.Type.CG)

          # Use diagonal preconditioning
          ksp.getPC().setType(PETSc.PC.Type.JACOBI)

          # Allow command-line customization
          ksp.setFromOptions()

          # Assemble right-hand side and solve the linear system
          pde.formRHS(b)
          ksp.setOperators(A)
          ksp.solve(b, x)

          # Here we programmatically visualize the solution
          if OptDB.getBool('plot', True):
              # Modify the option database: keep the X window open for 1 second
              OptDB['draw_pause'] = 1

              # Obtain a viewer of type DRAW
              draw = PETSc.Viewer.DRAW(x.comm)

              # View the vector in the X window
              draw(x)

          # We can also visualize the solution by command line options
          # For example, we can dump a VTK file with:
          #
          #     $ python poisson2d.py -plot 0 -view_solution vtk:sol.vts:
          #
          # or obtain the same visualization as programmatically done above as:
          #
          #     $ python poisson2d.py -plot 0 -view_solution draw -draw_pause 1
          #
          x.viewFromOptions('-view_solution')

   PETScPythonpreconditionertype
       The protocol for the petsc4py.PETSc.PC.Type.PYTHON preconditioner is:

          from petsc4py.PETSc import KSP
          from petsc4py.PETSc import PC
          from petsc4py.PETSc import Mat
          from petsc4py.PETSc import Vec
          from petsc4py.PETSc import Viewer

          # A template class with the Python methods supported by PCPYTHON

          class PCPythonProtocol:
              def apply(self, pc: PC, b: Vec, x: Vec) -> None:
                  """Apply the preconditioner on vector b, return in x."""
                  ...

              def applySymmetricLeft(self, pc: PC, b: Vec, x: Vec) -> None:
                  """Apply the symmetric left part of the preconditioner on vector b, return in x."""
                  ...

              def applySymmetricRight(self, pc: PC, b: Vec, x: Vec) -> None:
                  """Apply the symmetric right part of the preconditioner on vector b, return in x."""
                  ...

              def applyTranspose(self, pc: PC, b: Vec, x: Vec) -> None:
                  """Apply the transposed preconditioner on vector b, return in x."""
                  ...

              def applyMat(self, pc: PC, B: Mat, X: Mat) -> None:
                  """Apply the preconditioner on a block of right-hand sides B, return in X."""
                  ...

              def preSolve(self, pc: PC, ksp: KSP, b: Vec, x: Vec) -> None:
                  """Callback called at the beginning of a Krylov method.

                  This method is allowed to modify the right-hand side b and the initial guess x.

                  """
                  ...

              def postSolve(self, pc: PC, ksp: KSP, b: Vec, x: Vec) -> None:
                  """Callback called at the end of a Krylov method.

                  This method is allowed to modify the right-hand side b and the solution x.

                  """

              def view(self, pc: PC, viewer: Viewer) -> None:
                  """View the preconditioner."""
                  ...

              def setFromOptions(self, pc: PC) -> None:
                  """Process command line for customization."""
                  ...

              def setUp(self, pc: PC) -> None:
                  """Perform the required setup."""
                  ...

              def reset(self, pc: PC) -> None:
                  """Reset the preconditioner."""
                  ...

       In  the  example  below,  we  create  a  Jacobi preconditioner, which needs to access the diagonal of the
       matrix. The action of the preconditioner consists of the pointwise multiplication of the inverse diagonal
       with the input vector.

          # The user-defined Python class implementing the Jacobi method.
          class myJacobi:
              # Setup the internal data. In this case, we access the matrix diagonal.
              def setUp(self, pc):
                  _, P = pc.getOperators()
                  self.D = P.getDiagonal()

              # Apply the preconditioner
              def apply(self, pc, x, y):
                  y.pointwiseDivide(x, self.D)

       We can run the script used to test our matrix class and use command line arguments to  specify  that  our
       preconditioner should be used:

          $ python mat.py -pc_type python -pc_python_type pc.myJacobi -ksp_view
          KSP Object: 1 MPI process
            type: cg
            maximum iterations=10000, initial guess is zero
            tolerances: relative=1e-05, absolute=1e-50, divergence=10000.
            left preconditioning
            using PRECONDITIONED norm type for convergence test
          PC Object: 1 MPI process
            type: python
              Python: pc.myJacobi
            linear system matrix = precond matrix:
            Mat Object: 1 MPI process
              type: python
              rows=256, cols=256
                  Python: __main__.Poisson2D

   PETScPythonlinearsolvertype
       The protocol for the petsc4py.PETSc.KSP.Type.PYTHON Krylov solver is:

          from petsc4py.PETSc import KSP
          from petsc4py.PETSc import Vec
          from petsc4py.PETSc import Viewer

          # A template class with the Python methods supported by KSPPYTHON

          class KSPPythonProtocol:
              def solve(self, ksp: KSP, b: Vec, x: Vec) -> None:
                  """Solve the linear system with right-hand side b. Return solution in x."""
                  ...

              def solveTranspose(self, ksp: KSP, b: Vec, x: Vec) -> None:
                  """Solve the transposed linear system with right-hand side b. Return solution in x."""
                  ...

              def view(self, ksp: KSP, viewer: Viewer) -> None:
                  """View the Krylov solver."""
                  ...

              def setFromOptions(self, ksp: KSP) -> None:
                  """Process command line for customization."""
                  ...

              def setUp(self, ksp: KSP) -> None:
                  """Perform the required setup."""
                  ...

              def buildSolution(self, ksp: KSP, x: Vec) -> None:
                  """Compute the solution vector."""
                  ...

              def buildResidual(self, ksp: KSP, t: Vec, r: Vec) -> None:
                  """Compute the residual vector, return it in r. t is a scratch working vector."""
                  ...

              def reset(self, ksp: KSP) -> None:
                  """Reset the Krylov solver."""
                  ...

   PETScPythonnonlinearsolvertype(TODO)PETScPythonode-integratortype(TODO)PETScPythonoptimizationsolvertype(TODO)

                             ┌─────────────────┬───────────────────────────────────────┐
                             │ petsc4py        │ The PETSc for Python package.         │
                             ├─────────────────┼───────────────────────────────────────┤
                             │ petsc4py.typing │ Typing support.                       │
                             ├─────────────────┼───────────────────────────────────────┤
                             │ petsc4py.PETSc  │ Portable,   Extensible   Toolkit  for │
                             │                 │ Scientific Computation.               │
                             └─────────────────┴───────────────────────────────────────┘

   petsc4py
       The PETSc for Python package.

       This package is an interface to PETSc libraries.

       PETSc (the Portable, Extensible Toolkit for Scientific Computation) is a suite  of  data  structures  and
       routines  for the scalable (parallel) solution of scientific applications modeled by partial differential
       equations. It employs the MPI standard for all message-passing communications.

       Functions
                         ┌──────────────────────────┬───────────────────────────────────────┐
                         │ get_config()             │ Return a dictionary with  information │
                         │                          │ about PETSc.                          │
                         ├──────────────────────────┼───────────────────────────────────────┤
                         │ get_include()            │ Return  the  directory in the package │
                         │                          │ that contains header files.           │
                         ├──────────────────────────┼───────────────────────────────────────┤
                         │ init([args, arch, comm]) │ Initialize PETSc.                     │
                         └──────────────────────────┴───────────────────────────────────────┘

   petsc4py.get_configpetsc4py.get_config()
              Return a dictionary with information about PETSc.

              Returntypedict[str, str]

   petsc4py.get_includepetsc4py.get_include()
              Return the directory in the package that contains header files.

              Extension modules that need to compile against petsc4py should use this  function  to  locate  the
              appropriate include directory.

              Example

              Using Python distutils or NumPy distutils:

                 import petsc4py
                 Extension('extension_name', ...
                           include_dirs=[..., petsc4py.get_include()])

              Returntypestrpetsc4py.initpetsc4py.init(args=None,arch=None,comm=None)
              Initialize PETSc.

              Parameters

                     • args (str|list[str]|None) -- Command-line arguments, usually the sys.argv list

                     • arch (str|None) -- Specific configuration to use

                     • comm (Intracomm|None) -- MPI commmunicator

              ReturntypeNone

              Notes

              This  function should be called only once, typically at the very beginning of the bootstrap script
              of an application.

   petsc4py.typing
       Typing support.

       Attributes
                      ┌────────────────────────────────┬───────────────────────────────────────┐
                      │ Scalar                         │ Scalar type.                          │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ ArrayBool                      │ Array of bool.                        │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ ArrayInt                       │ Array of int.                         │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ ArrayReal                      │ Array of float.                       │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ ArrayComplex                   │ Array of complex.                     │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ ArrayScalar                    │ Array of Scalar numbers.              │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ DimsSpec                       │ Dimensions specification.             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ AccessModeSpec                 │ Access mode specification.            │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ InsertModeSpec                 │ Insertion mode specification.         │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ ScatterModeSpec                │ Scatter mode specification.           │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ LayoutSizeSpec                 │ int or 2-tuple of int describing  the │
                      │                                │ layout sizes.                         │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ NormTypeSpec                   │ Norm type specification.              │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ PetscOptionsHandlerFunction    │ Callback    for    processing   extra │
                      │                                │ options.                              │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ MatAssemblySpec                │ Matrix assembly specification.        │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ MatSizeSpec                    │ int  or   (nested)   tuple   of   int │
                      │                                │ describing the matrix sizes.          │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ MatBlockSizeSpec               │ The row and column block sizes.       │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ CSRIndicesSpec                 │ CSR indices format specification.     │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ CSRSpec                        │ CSR format specification.             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ NNZSpec                        │ Nonzero pattern specification.        │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ MatNullFunction                │ PETSc.NullSpace callback.             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ DMCoarsenHookFunction          │ PETSc.DM coarsening hook callback.    │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ DMRestrictHookFunction         │ PETSc.DM restriction hook callback.   │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ KSPRHSFunction                 │ PETSc.KSP  right-hand  side  function │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ KSPOperatorsFunction           │ PETSc.KSP     operators      function │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ KSPConvergenceTestFunction     │ PETSc.KSP convergence test callback.  │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ KSPMonitorFunction             │ PETSc.KSP monitor callback.           │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ KSPPreSolveFunction            │ PETSc.KSP pre solve callback.         │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ KSPPostSolveFunction           │ PETSc.KSP post solve callback.        │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESMonitorFunction            │ SNES monitor callback.                │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESObjFunction                │ SNES objective function callback.     │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESFunction                   │ SNES residual function callback.      │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESJacobianFunction           │ SNES Jacobian callback.               │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESGuessFunction              │ SNES initial guess callback.          │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESUpdateFunction             │ SNES step update callback.            │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESLSPreFunction              │ SNES   linesearch   pre-check  update │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESNGSFunction                │ SNES nonlinear Gauss-Seidel callback. │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ SNESConvergedFunction          │ SNES convergence test callback.       │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSRHSFunction                  │ TS right-hand side function callback. │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSRHSJacobian                  │ TS right-hand side Jacobian callback. │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSRHSJacobianP                 │ TS right-hand side parameter Jacobian │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSIFunction                    │ TS implicit function callback.        │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSIJacobian                    │ TS implicit Jacobian callback.        │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSIJacobianP                   │ TS   implicit   parameter    Jacobian │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSI2Function                   │ TS   implicit   2nd   order  function │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSI2Jacobian                   │ TS  implicit   2nd   order   Jacobian │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSI2JacobianP                  │ TS   implicit   2nd  order  parameter │
                      │                                │ Jacobian callback.                    │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSMonitorFunction              │ TS monitor callback.                  │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSPreStepFunction              │ TS pre-step callback.                 │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSPostStepFunction             │ TS post-step callback.                │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSIndicatorFunction            │ TS event indicator callback.          │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TSPostEventFunction            │ TS post-event callback.               │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOObjectiveFunction           │ TAO objective function callback.      │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOGradientFunction            │ TAO objective gradient callback.      │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOObjectiveGradientFunction   │ TAO objective function  and  gradient │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOHessianFunction             │ TAO objective Hessian callback.       │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOUpdateFunction              │ TAO update callback.                  │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOMonitorFunction             │ TAO monitor callback.                 │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOConvergedFunction           │ TAO convergence test callback.        │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOJacobianFunction            │ TAO Jacobian callback.                │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOResidualFunction            │ TAO residual callback.                │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOJacobianResidualFunction    │ TAO Jacobian residual callback.       │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOVariableBoundsFunction      │ TAO variable bounds callback.         │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOConstraintsFunction         │ TAO constraints callback.             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOLSObjectiveFunction         │ TAOLineSearch    objective   function │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOLSGradientFunction          │ TAOLineSearch   objective    gradient │
                      │                                │ callback.                             │
                      ├────────────────────────────────┼───────────────────────────────────────┤
                      │ TAOLSObjectiveGradientFunction │ TAOLineSearch  objective function and │
                      │                                │ gradient callback.                    │
                      └────────────────────────────────┴───────────────────────────────────────┘

   petsc4py.typing.Scalarpetsc4py.typing.Scalar=float|complex
              Scalar type.

              Scalars can be either float or complex (but not  both)  depending  on  how  PETSc  was  configured
              (./configure--with-scalar-type=real|complex).

   petsc4py.typing.ArrayBoolpetsc4py.typing.ArrayBool
              Array of bool.

              alias of ndarray[tuple[int, ...], dtype[bool]]

   petsc4py.typing.ArrayIntpetsc4py.typing.ArrayInt
              Array of int.

              alias of ndarray[tuple[int, ...], dtype[int]]

   petsc4py.typing.ArrayRealpetsc4py.typing.ArrayReal
              Array of float.

              alias of ndarray[tuple[int, ...], dtype[float]]

   petsc4py.typing.ArrayComplexpetsc4py.typing.ArrayComplex
              Array of complex.

              alias of ndarray[tuple[int, ...], dtype[complex]]

   petsc4py.typing.ArrayScalarpetsc4py.typing.ArrayScalar
              Array of Scalar numbers.

              alias of ndarray[tuple[int, ...], dtype[float | complex]]

   petsc4py.typing.DimsSpecpetsc4py.typing.DimsSpec
              Dimensions specification.

              N-tuples indicates N-dimensional grid sizes.

              alias of tuple[int, ...]

   petsc4py.typing.AccessModeSpecpetsc4py.typing.AccessModeSpec
              Access mode specification.

              Possiblevaluesare:

                     • 'rw' Read-Write mode.

                     • 'r' Read-only mode.

                     • 'w' Write-only mode.

                     • None as 'rw'.

              alias of Literal['rw', 'r', 'w'] | Nonepetsc4py.typing.InsertModeSpecpetsc4py.typing.InsertModeSpec=petsc4py.PETSc.InsertMode|bool|None
              Insertion mode specification.

              Possiblevaluesare:

                     • InsertMode.ADD_VALUES Add new value to existing one.

                     • InsertMode.INSERT_VALUES Replace existing entry with new value.

                     • None as InsertMode.INSERT_VALUES.

                     • False as InsertMode.INSERT_VALUES.

                     • True as InsertMode.ADD_VALUES.

              SEEALSO:InsertModepetsc4py.typing.ScatterModeSpecpetsc4py.typing.ScatterModeSpec=petsc4py.PETSc.ScatterMode|bool|str|None
              Scatter mode specification.

              Possiblevaluesare:

                     • ScatterMode.FORWARD Forward mode.

                     • ScatterMode.REVERSE Reverse mode.

                     • None as ScatterMode.FORWARD.

                     • False as ScatterMode.FORWARD.

                     • True as ScatterMode.REVERSE.

                     • 'forward' as ScatterMode.FORWARD.

                     • 'reverse' as ScatterMode.REVERSE.

              SEEALSO:ScatterModepetsc4py.typing.LayoutSizeSpecpetsc4py.typing.LayoutSizeSpec=int|tuple[int,int]int or 2-tuple of int describing the layout sizes.

              A single int indicates global size.  A tuple of int indicates (local_size,global_size).

              SEEALSO:Sys.splitOwnershippetsc4py.typing.NormTypeSpecpetsc4py.typing.NormTypeSpec=petsc4py.PETSc.NormType|None
              Norm type specification.

              Possible values include:

              • NormType.NORM_1 The 1-norm: Σₙ abs(xₙ) for vectors, maxₙ (Σᵢ abs(xₙᵢ)) for matrices.

              • NormType.NORM_2 The 2-norm: √(Σₙ xₙ²) for vectors, largest singular values for matrices.

              • NormType.NORM_INFINITY The ∞-norm: maxₙ abs(xₙ) for vectors, maxᵢ (Σₙ abs(xₙᵢ)) for matrices.

              • NormType.NORM_FROBENIUS  The  Frobenius  norm:  same  as  2-norm  for  vectors,  √(Σₙᵢ xₙᵢ²) for
                matrices.

              • NormType.NORM_1_AND_2 Compute both NormType.NORM_1 and NormType.NORM_2.

              • None as NormType.NORM_2 for vectors, NormType.NORM_FROBENIUS for matrices.

              SEEALSO:PETSc.NormType, NormTypepetsc4py.typing.PetscOptionsHandlerFunctionpetsc4py.typing.PetscOptionsHandlerFunction
              Callback for processing extra options.

              alias of Callable[[Object], None]

   petsc4py.typing.MatAssemblySpecpetsc4py.typing.MatAssemblySpec=petsc4py.PETSc.Mat.AssemblyType|bool|None
              Matrix assembly specification.

              Possiblevaluesare:

                     • Mat.AssemblyType.FINAL

                     • Mat.AssemblyType.FLUSH

                     • None as Mat.AssemblyType.FINAL

                     • False as Mat.AssemblyType.FINAL

                     • True as Mat.AssemblyType.FLUSHSEEALSO:MatAssemblyTypepetsc4py.typing.MatSizeSpecpetsc4py.typing.MatSizeSpec=int|tuple[int,int]|tuple[tuple[int,int],tuple[int,int]]int or (nested) tuple of int describing the matrix sizes.

              If int then rows = columns.  A single tuple of int indicates (rows,columns).  A nested tuple of ‐
              int indicates ((local_rows,rows),(local_columns,columns)).

              SEEALSO:Sys.splitOwnershippetsc4py.typing.MatBlockSizeSpecpetsc4py.typing.MatBlockSizeSpec=int|tuple[int,int]
              The row and column block sizes.

              If a single int is provided then rows and columns share the same block size.

   petsc4py.typing.CSRIndicesSpecpetsc4py.typing.CSRIndicesSpec
              CSR indices format specification.

              A 2-tuple carrying the (row_start,col_indices) information.

              alias of tuple[Sequence[int], Sequence[int]]

   petsc4py.typing.CSRSpecpetsc4py.typing.CSRSpec
              CSR format specification.

              A 3-tuple carrying the (row_start,col_indices,values) information.

              alias of tuple[Sequence[int], Sequence[int], Sequence[float | complex]]

   petsc4py.typing.NNZSpecpetsc4py.typing.NNZSpec
              Nonzero pattern specification.

              A single int corresponds to fixed number of non-zeros  per  row.   A  Sequence  of  int  indicates
              different  non-zeros  per row.  If a 2-tuple is used, the elements of the tuple corresponds to the
              on-process and off-process parts of the matrix.

              SEEALSO:MatSeqAIJSetPreallocation, MatMPIAIJSetPreallocation

              alias of int | Sequence[int] | tuple[Sequence[int], Sequence[int]]

   petsc4py.typing.MatNullFunctionpetsc4py.typing.MatNullFunctionPETSc.NullSpace callback.

              alias of Callable[[NullSpace, Vec], None]

   petsc4py.typing.DMCoarsenHookFunctionpetsc4py.typing.DMCoarsenHookFunctionPETSc.DM coarsening hook callback.

              alias of Callable[[DM, DM], None]

   petsc4py.typing.DMRestrictHookFunctionpetsc4py.typing.DMRestrictHookFunctionPETSc.DM restriction hook callback.

              alias of Callable[[DM, Mat, Vec, Mat, DM], None]

   petsc4py.typing.KSPRHSFunctionpetsc4py.typing.KSPRHSFunctionPETSc.KSP right-hand side function callback.

              alias of Callable[[KSP, Vec], None]

   petsc4py.typing.KSPOperatorsFunctionpetsc4py.typing.KSPOperatorsFunctionPETSc.KSP operators function callback.

              alias of Callable[[KSP, Mat, Mat], None]

   petsc4py.typing.KSPConvergenceTestFunctionpetsc4py.typing.KSPConvergenceTestFunctionPETSc.KSP convergence test callback.

              alias of Callable[[KSP, int, float], ConvergedReason]

   petsc4py.typing.KSPMonitorFunctionpetsc4py.typing.KSPMonitorFunctionPETSc.KSP monitor callback.

              alias of Callable[[KSP, int, float], None]

   petsc4py.typing.KSPPreSolveFunctionpetsc4py.typing.KSPPreSolveFunctionPETSc.KSP pre solve callback.

              alias of Callable[[KSP, Vec, Vec], None]

   petsc4py.typing.KSPPostSolveFunctionpetsc4py.typing.KSPPostSolveFunctionPETSc.KSP post solve callback.

              alias of Callable[[KSP, Vec, Vec], None]

   petsc4py.typing.SNESMonitorFunctionpetsc4py.typing.SNESMonitorFunctionSNES monitor callback.

              alias of Callable[[SNES, int, float], None]

   petsc4py.typing.SNESObjFunctionpetsc4py.typing.SNESObjFunctionSNES objective function callback.

              alias of Callable[[SNES, Vec], None]

   petsc4py.typing.SNESFunctionpetsc4py.typing.SNESFunctionSNES residual function callback.

              alias of Callable[[SNES, Vec, Vec], None]

   petsc4py.typing.SNESJacobianFunctionpetsc4py.typing.SNESJacobianFunctionSNES Jacobian callback.

              alias of Callable[[SNES, Vec, Mat, Mat], None]

   petsc4py.typing.SNESGuessFunctionpetsc4py.typing.SNESGuessFunctionSNES initial guess callback.

              alias of Callable[[SNES, Vec], None]

   petsc4py.typing.SNESUpdateFunctionpetsc4py.typing.SNESUpdateFunctionSNES step update callback.

              alias of Callable[[SNES, int], None]

   petsc4py.typing.SNESLSPreFunctionpetsc4py.typing.SNESLSPreFunctionSNES linesearch pre-check update callback.

              alias of Callable[[Vec, Vec], None]

   petsc4py.typing.SNESNGSFunctionpetsc4py.typing.SNESNGSFunctionSNES nonlinear Gauss-Seidel callback.

              alias of Callable[[SNES, Vec, Vec], None]

   petsc4py.typing.SNESConvergedFunctionpetsc4py.typing.SNESConvergedFunctionSNES convergence test callback.

              alias of Callable[[SNES, int, tuple[float, float, float]], ConvergedReason]

   petsc4py.typing.TSRHSFunctionpetsc4py.typing.TSRHSFunctionTS right-hand side function callback.

              alias of Callable[[TS, float, Vec, Vec], None]

   petsc4py.typing.TSRHSJacobianpetsc4py.typing.TSRHSJacobianTS right-hand side Jacobian callback.

              alias of Callable[[TS, float, Vec, Mat, Mat], None]

   petsc4py.typing.TSRHSJacobianPpetsc4py.typing.TSRHSJacobianPTS right-hand side parameter Jacobian callback.

              alias of Callable[[TS, float, Vec, Mat], None]

   petsc4py.typing.TSIFunctionpetsc4py.typing.TSIFunctionTS implicit function callback.

              alias of Callable[[TS, float, Vec, Vec, Vec], None]

   petsc4py.typing.TSIJacobianpetsc4py.typing.TSIJacobianTS implicit Jacobian callback.

              alias of Callable[[TS, float, Vec, Vec, float, Mat, Mat], None]

   petsc4py.typing.TSIJacobianPpetsc4py.typing.TSIJacobianPTS implicit parameter Jacobian callback.

              alias of Callable[[TS, float, Vec, Vec, float, Mat], None]

   petsc4py.typing.TSI2Functionpetsc4py.typing.TSI2FunctionTS implicit 2nd order function callback.

              alias of Callable[[TS, float, Vec, Vec, Vec, Vec], None]

   petsc4py.typing.TSI2Jacobianpetsc4py.typing.TSI2JacobianTS implicit 2nd order Jacobian callback.

              alias of Callable[[TS, float, Vec, Vec, Vec, float, float, Mat, Mat], None]

   petsc4py.typing.TSI2JacobianPpetsc4py.typing.TSI2JacobianPTS implicit 2nd order parameter Jacobian callback.

              alias of Callable[[TS, float, Vec, Vec, Vec, float, float, Mat], None]

   petsc4py.typing.TSMonitorFunctionpetsc4py.typing.TSMonitorFunctionTS monitor callback.

              alias of Callable[[TS, int, float, Vec], None]

   petsc4py.typing.TSPreStepFunctionpetsc4py.typing.TSPreStepFunctionTS pre-step callback.

              alias of Callable[[TS], None]

   petsc4py.typing.TSPostStepFunctionpetsc4py.typing.TSPostStepFunctionTS post-step callback.

              alias of Callable[[TS], None]

   petsc4py.typing.TSIndicatorFunctionpetsc4py.typing.TSIndicatorFunctionTS event indicator callback.

              alias of Callable[[TS, float, Vec, ndarray[tuple[int, ...], dtype[float]]], None]

   petsc4py.typing.TSPostEventFunctionpetsc4py.typing.TSPostEventFunctionTS post-event callback.

              alias of Callable[[TS, ndarray[tuple[int, ...], dtype[int]], float, Vec, bool], None]

   petsc4py.typing.TAOObjectiveFunctionpetsc4py.typing.TAOObjectiveFunctionTAO objective function callback.

              alias of Callable[[TAO, Vec], float]

   petsc4py.typing.TAOGradientFunctionpetsc4py.typing.TAOGradientFunctionTAO objective gradient callback.

              alias of Callable[[TAO, Vec, Vec], None]

   petsc4py.typing.TAOObjectiveGradientFunctionpetsc4py.typing.TAOObjectiveGradientFunctionTAO objective function and gradient callback.

              alias of Callable[[TAO, Vec, Vec], float]

   petsc4py.typing.TAOHessianFunctionpetsc4py.typing.TAOHessianFunctionTAO objective Hessian callback.

              alias of Callable[[TAO, Vec, Mat, Mat], None]

   petsc4py.typing.TAOUpdateFunctionpetsc4py.typing.TAOUpdateFunctionTAO update callback.

              alias of Callable[[TAO, int], None]

   petsc4py.typing.TAOMonitorFunctionpetsc4py.typing.TAOMonitorFunctionTAO monitor callback.

              alias of Callable[[TAO], None]

   petsc4py.typing.TAOConvergedFunctionpetsc4py.typing.TAOConvergedFunctionTAO convergence test callback.

              alias of Callable[[TAO], None]

   petsc4py.typing.TAOJacobianFunctionpetsc4py.typing.TAOJacobianFunctionTAO Jacobian callback.

              alias of Callable[[TAO, Vec, Mat, Mat], None]

   petsc4py.typing.TAOResidualFunctionpetsc4py.typing.TAOResidualFunctionTAO residual callback.

              alias of Callable[[TAO, Vec, Vec], None]

   petsc4py.typing.TAOJacobianResidualFunctionpetsc4py.typing.TAOJacobianResidualFunctionTAO Jacobian residual callback.

              alias of Callable[[TAO, Vec, Mat, Mat], None]

   petsc4py.typing.TAOVariableBoundsFunctionpetsc4py.typing.TAOVariableBoundsFunctionTAO variable bounds callback.

              alias of Callable[[TAO, Vec, Vec], None]

   petsc4py.typing.TAOConstraintsFunctionpetsc4py.typing.TAOConstraintsFunctionTAO constraints callback.

              alias of Callable[[TAO, Vec, Vec], None]

   petsc4py.typing.TAOLSObjectiveFunctionpetsc4py.typing.TAOLSObjectiveFunctionTAOLineSearch objective function callback.

              alias of Callable[[TAOLineSearch, Vec], float]

   petsc4py.typing.TAOLSGradientFunctionpetsc4py.typing.TAOLSGradientFunctionTAOLineSearch objective gradient callback.

              alias of Callable[[TAOLineSearch, Vec, Vec], None]

   petsc4py.typing.TAOLSObjectiveGradientFunctionpetsc4py.typing.TAOLSObjectiveGradientFunctionTAOLineSearch objective function and gradient callback.

              alias of Callable[[TAOLineSearch, Vec, Vec], float]

   petsc4py.PETSc
       Portable, Extensible Toolkit for Scientific Computation.

       Basic constants:

       DECIDE Use a default value for an int or float parameter.

       DEFAULT
              Use a default value chosen by PETSc.

       DETERMINE
              Compute a default value for an int or float parameter.  For tolerances this uses the default value
              from when the object's type was set.

       CURRENT
              Do not change the current value that is set.

       UNLIMITED
              For a parameter that is a bound, such as the maximum number of iterations, do not bound the value.

       More constants:

       INFINITY
              Very large real value.

       NINFINITY
              Very large negative real value.

       PINFINITY
              Very large positive real value, same as INFINITY.

       Classes
                           ┌─────────────────────┬───────────────────────────────────────┐
                           │ AO                  │ Application ordering object.          │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Comm                │ Communicator object.                  │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DM                  │ An object describing a  computational │
                           │                     │ grid or mesh.                         │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMComposite         │ A  DM  object  that is used to manage │
                           │                     │ data for a collection of DMs.         │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMDA                │ A DM object that is  used  to  manage │
                           │                     │ data for a structured grid.           │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMInterpolation     │ Interpolation on a mesh.              │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMLabel             │ An  object  representing  a subset of │
                           │                     │ mesh entities from a DM.              │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMPlex              │ Encapsulate an unstructured mesh.     │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMPlexTransform     │ Mesh transformations.                 │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMPlexTransformType │ Transformation types.                 │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMShell             │ A shell DM  object,  used  to  manage │
                           │                     │ user-defined problem data.            │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMStag              │ A DM object representing a "staggered │
                           │                     │ grid" or a structured cell complex.   │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DMSwarm             │ A  DM object used to represent arrays │
                           │                     │ of data (fields) of arbitrary type.   │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DS                  │ Discrete System object.               │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Device              │ The device object.                    │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DeviceContext       │ DeviceContext object.                 │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ DualSpace           │ Dual space to a linear space.         │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ FE                  │ A PETSc object that manages a  finite │
                           │                     │ element space.                        │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ IS                  │ A collection of indices.              │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ InsertMode          │ Insertion mode.                       │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ KSP                 │ Abstract  PETSc  object  that manages │
                           │                     │ all Krylov methods.                   │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ LGMap               │ Mapping from  a  local  to  a  global │
                           │                     │ ordering.                             │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Log                 │ Logging support.                      │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ LogClass            │ Logging support.                      │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ LogEvent            │ Logging support.                      │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ LogStage            │ Logging support for different stages. │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Mat                 │ Matrix object.                        │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ MatPartitioning     │ Object  for managing the partitioning │
                           │                     │ of a matrix or graph.                 │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ NormType            │ Norm type.                            │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ NullSpace           │ Nullspace object.                     │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Object              │ Base class wrapping a PETSc object.   │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Options             │ The options database object.          │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ PC                  │ Preconditioners.                      │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Partitioner         │ A graph partitioner.                  │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Quad                │ Quadrature rule for integration.      │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Random              │ The random number generator object.   │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ SF                  │ Star Forest object for communication. │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ SNES                │ Nonlinear equations solver.           │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Scatter             │ Scatter object.                       │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ ScatterMode         │ Scatter mode.                         │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Section             │ Mapping from integers in a  range  to │
                           │                     │ unstructured set of integers.         │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Space               │ Function space object.                │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Sys                 │ System utilities.                     │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ TAO                 │ Optimization solver.                  │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ TAOLineSearch       │ TAO Line Search.                      │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ TS                  │ ODE integrator.                       │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Vec                 │ A vector object.                      │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ Viewer              │ Viewer object.                        │
                           ├─────────────────────┼───────────────────────────────────────┤
                           │ ViewerHDF5          │ Viewer object for HDF5 file formats.  │
                           └─────────────────────┴───────────────────────────────────────┘

   petsc4py.PETSc.AOclasspetsc4py.PETSc.AO
              Bases: Object

              Application ordering object.

              Enumerations
                                         ┌──────┬─────────────────────────────────┐
                                         │ Type │ The application ordering types. │
                                         └──────┴─────────────────────────────────┘

   petsc4py.PETSc.AO.Typeclasspetsc4py.PETSc.AO.Type
                     Bases: object

                     The application ordering types.

                     Attributes Summary
                                       ┌────────────────┬───────────────────────────────────┐
                                       │ ADVANCED       │ Object ADVANCED of type str       │
                                       ├────────────────┼───────────────────────────────────┤
                                       │ BASIC          │ Object BASIC of type str          │
                                       ├────────────────┼───────────────────────────────────┤
                                       │ MAPPING        │ Object MAPPING of type str        │
                                       ├────────────────┼───────────────────────────────────┤
                                       │ MEMORYSCALABLE │ Object MEMORYSCALABLE of type str │
                                       └────────────────┴───────────────────────────────────┘

                     Attributes Documentation

                     ADVANCED:str=ADVANCED
                            Object ADVANCED of type strBASIC:str=BASIC
                            Object BASIC of type strMAPPING:str=MAPPING
                            Object MAPPING of type strMEMORYSCALABLE:str=MEMORYSCALABLE
                            Object MEMORYSCALABLE of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ app2petsc(indices)                    │ Map  an  application-defined ordering │
                      │                                       │ to the PETSc ordering.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createBasic(app[, petsc, comm])       │ Return a basic  application  ordering │
                      │                                       │ using two orderings.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createMapping(app[, petsc, comm])     │ Return  an  application mapping using │
                      │                                       │ two orderings.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createMemoryScalable(app[,     petsc, │ Return  a memory scalable application │
                      │ comm])                                │ ordering using two orderings.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the application ordering.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the application ordering type. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ petsc2app(indices)                    │ Map   a   PETSc   ordering   to   the │
                      │                                       │ application-defined ordering.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ Display the application ordering.     │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              app2petsc(indices)
                     Map an application-defined ordering to the PETSc ordering.

                     Collective.

                     Any  integers  in indices that are negative are left unchanged. This allows one to convert,
                     for example, neighbor lists that use negative entries to indicate nonexistent neighbors due
                     to boundary conditions, etc.

                     Integers that are out of range are mapped to -1.

                     If IS is used, it cannot be of type stride or block.

                     Parametersindices (Sequence[int]|IS) -- The  indices;  to  be  replaced  with  their  mapped
                            values.

                     ReturntypeSequence[int] | ISSEEALSO:petsc2app, AOApplicationToPetscIS, AOApplicationToPetscSourcecodeatpetsc4py/PETSc/AO.pyx:214createBasic(app,petsc=None,comm=None)
                     Return a basic application ordering using two orderings.

                     Collective.

                     The  arrays/indices  app  and  petsc  must contain all the integers 0 to len(app)-1 with no
                     duplicates; that is there cannot be any "holes" in the indices. Use  createMapping  if  you
                     wish to have "holes" in the indices.

                     Parameters

                            • app (Sequence[int]|IS) -- The application ordering.

                            • petsc (Sequence[int]|IS|None) -- Another ordering (may be None to indicate the
                              natural ordering, that is 0, 1, 2, 3, ...).

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:createMemoryScalable, createMapping, AOCreateBasicIS, AOCreateBasicSourcecodeatpetsc4py/PETSc/AO.pyx:53createMapping(app,petsc=None,comm=None)
                     Return an application mapping using two orderings.

                     Collective.

                     The  arrays  app and petsc need NOT contain all the integers 0 to len(app)-1, that is there
                     CAN be "holes" in the indices.  Use createBasic if  they  do  not  have  holes  for  better
                     performance.

                     Parameters

                            • app (Sequence[int]|IS) -- The application ordering.

                            • petsc (Sequence[int]|IS|None) -- Another ordering. May be None to indicate the
                              identity ordering.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:createBasic, AOCreateMappingIS, AOCreateMappingSourcecodeatpetsc4py/PETSc/AO.pyx:154createMemoryScalable(app,petsc=None,comm=None)
                     Return a memory scalable application ordering using two orderings.

                     Collective.

                     The  arrays/indices  app  and  petsc  must contain all the integers 0 to len(app)-1 with no
                     duplicates; that is there cannot be any "holes" in the indices. Use  createMapping  if  you
                     wish to have "holes" in the indices.

                     Comparing with createBasic, this routine trades memory with message communication.

                     Parameters

                            • app (Sequence[int]|IS) -- The application ordering.

                            • petsc (Sequence[int]|IS|None) -- Another ordering (may be None to indicate the
                              natural ordering, that is 0, 1, 2, 3, ...).

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:createBasic, createMapping, AOCreateMemoryScalableIS, AOCreateMemoryScalableSourcecodeatpetsc4py/PETSc/AO.pyx:102destroy()
                     Destroy the application ordering.

                     Collective.

                     SEEALSO:AODestroySourcecodeatpetsc4py/PETSc/AO.pyx:40ReturntypeSelfgetType()
                     Return the application ordering type.

                     Not collective.

                     SEEALSO:AOGetTypeSourcecodeatpetsc4py/PETSc/AO.pyx:200Returntypestrpetsc2app(indices)
                     Map a PETSc ordering to the application-defined ordering.

                     Collective.

                     Any  integers  in indices that are negative are left unchanged. This allows one to convert,
                     for example, neighbor lists that use negative entries to indicate nonexistent neighbors due
                     to boundary conditions, etc.

                     Integers that are out of range are mapped to -1.

                     If IS is used, it cannot be of type stride or block.

                     Parametersindices (Sequence[int]|IS) -- The  indices;  to  be  replaced  with  their  mapped
                            values.

                     ReturntypeSequence[int] | ISSEEALSO:app2petsc, AOPetscToApplicationIS, AOPetscToApplicationSourcecodeatpetsc4py/PETSc/AO.pyx:248view(viewer=None)
                     Display the application ordering.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the ordering.

                     ReturntypeNoneSEEALSO:AOViewSourcecodeatpetsc4py/PETSc/AO.pyx:21petsc4py.PETSc.Commclasspetsc4py.PETSc.Comm
              Bases: object

              Communicator object.

              Predefined instances:

              COMM_NULL
                     The null (or invalid) communicator.

              COMM_SELF
                     The self communicator.

              COMM_WORLD
                     The world communicator.

              SEEALSO:Sys.setDefaultComm, Sys.getDefaultComm

              Methods Summary
                                   ┌─────────────┬───────────────────────────────────────┐
                                   │ barrier()   │ Barrier synchronization.              │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ destroy()   │ Destroy the communicator.             │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ duplicate() │ Duplicate the communicator.           │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ getRank()   │ Return   the   rank  of  the  calling │
                                   │             │ processes in the communicator.        │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ getSize()   │ Return the number of processes in the │
                                   │             │ communicator.                         │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ tompi4py()  │ Convert communicator to mpi4py.       │
                                   └─────────────┴───────────────────────────────────────┘

              Attributes Summary
                                              ┌─────────┬────────────────────┐
                                              │ fortran │ Fortran handle.    │
                                              ├─────────┼────────────────────┤
                                              │ rank    │ Communicator rank. │
                                              ├─────────┼────────────────────┤
                                              │ size    │ Communicator size. │
                                              └─────────┴────────────────────┘

              Methods Documentation

              barrier()
                     Barrier synchronization.

                     Collective.

                     Sourcecodeatpetsc4py/PETSc/Comm.pyx:123ReturntypeNonedestroy()
                     Destroy the communicator.

                     Collective.

                     SEEALSO:PetscCommDestroySourcecodeatpetsc4py/PETSc/Comm.pyx:61ReturntypeNoneduplicate()
                     Duplicate the communicator.

                     Collective.

                     SEEALSO:PetscCommDuplicateSourcecodeatpetsc4py/PETSc/Comm.pyx:79ReturntypeSelfgetRank()
                     Return the rank of the calling processes in the communicator.

                     Not collective.

                     Sourcecodeatpetsc4py/PETSc/Comm.pyx:111ReturntypeintgetSize()
                     Return the number of processes in the communicator.

                     Not collective.

                     Sourcecodeatpetsc4py/PETSc/Comm.pyx:99Returntypeinttompi4py()
                     Convert communicator to mpi4py.

                     Not collective.

                     SEEALSO:mpi4py.MPI.Comm, mpi4py.MPI.IntracommSourcecodeatpetsc4py/PETSc/Comm.pyx:155ReturntypeIntracomm

              Attributes Documentation

              fortran
                     Fortran handle.

                     Sourcecodeatpetsc4py/PETSc/Comm.pyx:147rank   Communicator rank.

                     Sourcecodeatpetsc4py/PETSc/Comm.pyx:140size   Communicator size.

                     Sourcecodeatpetsc4py/PETSc/Comm.pyx:135petsc4py.PETSc.DMclasspetsc4py.PETSc.DM
              Bases: Object

              An object describing a computational grid or mesh.

              Enumerations
                                  ┌────────────────────┬──────────────────────────────────┐
                                  │ BoundaryType       │ DM Boundary types.               │
                                  ├────────────────────┼──────────────────────────────────┤
                                  │ PolytopeType       │ The DM cell types.               │
                                  ├────────────────────┼──────────────────────────────────┤
                                  │ ReorderDefaultFlag │ The DM reordering default flags. │
                                  ├────────────────────┼──────────────────────────────────┤
                                  │ Type               │ DM types.                        │
                                  └────────────────────┴──────────────────────────────────┘

   petsc4py.PETSc.DM.BoundaryTypeclasspetsc4py.PETSc.DM.BoundaryType
                     Bases: objectDM Boundary types.

                     Attributes Summary
                                            ┌──────────┬───────────────────────────────┐
                                            │ GHOSTED  │ Constant GHOSTED of type int  │
                                            ├──────────┼───────────────────────────────┤
                                            │ MIRROR   │ Constant MIRROR of type int   │
                                            ├──────────┼───────────────────────────────┤
                                            │ NONE     │ Constant NONE of type int     │
                                            ├──────────┼───────────────────────────────┤
                                            │ PERIODIC │ Constant PERIODIC of type int │
                                            ├──────────┼───────────────────────────────┤
                                            │ TWIST    │ Constant TWIST of type int    │
                                            └──────────┴───────────────────────────────┘

                     Attributes Documentation

                     GHOSTED:int=GHOSTED
                            Constant GHOSTED of type intMIRROR:int=MIRROR
                            Constant MIRROR of type intNONE:int=NONE
                            Constant NONE of type intPERIODIC:int=PERIODIC
                            Constant PERIODIC of type intTWIST:int=TWIST
                            Constant TWIST of type intpetsc4py.PETSc.DM.PolytopeTypeclasspetsc4py.PETSc.DM.PolytopeType
                     Bases: object

                     The DM cell types.

                     Attributes Summary
                                   ┌────────────────────┬───────────────────────────────────────┐
                                   │ FV_GHOST           │ Constant FV_GHOST of type int         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HEXAHEDRON         │ Constant HEXAHEDRON of type int       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ INTERIOR_GHOST     │ Constant INTERIOR_GHOST of type int   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ POINT              │ Constant POINT of type int            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ POINT_PRISM_TENSOR │ Constant POINT_PRISM_TENSOR of type ‐ │
                                   │                    │ int                                   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ PYRAMID            │ Constant PYRAMID of type int          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ QUADRILATERAL      │ Constant QUADRILATERAL of type int    │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ QUAD_PRISM_TENSOR  │ Constant QUAD_PRISM_TENSOR of type  ‐ │
                                   │                    │ int                                   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEGMENT            │ Constant SEGMENT of type int          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEG_PRISM_TENSOR   │ Constant SEG_PRISM_TENSOR of type int │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ TETRAHEDRON        │ Constant TETRAHEDRON of type int      │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ TRIANGLE           │ Constant TRIANGLE of type int         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ TRI_PRISM          │ Constant TRI_PRISM of type int        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ TRI_PRISM_TENSOR   │ Constant TRI_PRISM_TENSOR of type int │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ UNKNOWN            │ Constant UNKNOWN of type int          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ UNKNOWN_CELL       │ Constant UNKNOWN_CELL of type int     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ UNKNOWN_FACE       │ Constant UNKNOWN_FACE of type int     │
                                   └────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     FV_GHOST:int=FV_GHOST
                            Constant FV_GHOST of type intHEXAHEDRON:int=HEXAHEDRON
                            Constant HEXAHEDRON of type intINTERIOR_GHOST:int=INTERIOR_GHOST
                            Constant INTERIOR_GHOST of type intPOINT:int=POINT
                            Constant POINT of type intPOINT_PRISM_TENSOR:int=POINT_PRISM_TENSOR
                            Constant POINT_PRISM_TENSOR of type intPYRAMID:int=PYRAMID
                            Constant PYRAMID of type intQUADRILATERAL:int=QUADRILATERAL
                            Constant QUADRILATERAL of type intQUAD_PRISM_TENSOR:int=QUAD_PRISM_TENSOR
                            Constant QUAD_PRISM_TENSOR of type intSEGMENT:int=SEGMENT
                            Constant SEGMENT of type intSEG_PRISM_TENSOR:int=SEG_PRISM_TENSOR
                            Constant SEG_PRISM_TENSOR of type intTETRAHEDRON:int=TETRAHEDRON
                            Constant TETRAHEDRON of type intTRIANGLE:int=TRIANGLE
                            Constant TRIANGLE of type intTRI_PRISM:int=TRI_PRISM
                            Constant TRI_PRISM of type intTRI_PRISM_TENSOR:int=TRI_PRISM_TENSOR
                            Constant TRI_PRISM_TENSOR of type intUNKNOWN:int=UNKNOWN
                            Constant UNKNOWN of type intUNKNOWN_CELL:int=UNKNOWN_CELL
                            Constant UNKNOWN_CELL of type intUNKNOWN_FACE:int=UNKNOWN_FACE
                            Constant UNKNOWN_FACE of type intpetsc4py.PETSc.DM.ReorderDefaultFlagclasspetsc4py.PETSc.DM.ReorderDefaultFlag
                     Bases: object

                     The DM reordering default flags.

                     Attributes Summary
                                              ┌────────┬─────────────────────────────┐
                                              │ FALSE  │ Constant FALSE of type int  │
                                              ├────────┼─────────────────────────────┤
                                              │ NOTSET │ Constant NOTSET of type int │
                                              ├────────┼─────────────────────────────┤
                                              │ TRUE   │ Constant TRUE of type int   │
                                              └────────┴─────────────────────────────┘

                     Attributes Documentation

                     FALSE:int=FALSE
                            Constant FALSE of type intNOTSET:int=NOTSET
                            Constant NOTSET of type intTRUE:int=TRUE
                            Constant TRUE of type intpetsc4py.PETSc.DM.Typeclasspetsc4py.PETSc.DM.Type
                     Bases: objectDM types.

                     Attributes Summary
                                            ┌───────────┬──────────────────────────────┐
                                            │ COMPOSITE │ Object COMPOSITE of type str │
                                            ├───────────┼──────────────────────────────┤
                                            │ DA        │ Object DA of type str        │
                                            ├───────────┼──────────────────────────────┤
                                            │ FOREST    │ Object FOREST of type str    │
                                            ├───────────┼──────────────────────────────┤
                                            │ MOAB      │ Object MOAB of type str      │
                                            ├───────────┼──────────────────────────────┤
                                            │ NETWORK   │ Object NETWORK of type str   │
                                            ├───────────┼──────────────────────────────┤
                                            │ P4EST     │ Object P4EST of type str     │
                                            ├───────────┼──────────────────────────────┤
                                            │ P8EST     │ Object P8EST of type str     │
                                            ├───────────┼──────────────────────────────┤
                                            │ PATCH     │ Object PATCH of type str     │
                                            ├───────────┼──────────────────────────────┤
                                            │ PLEX      │ Object PLEX of type str      │
                                            ├───────────┼──────────────────────────────┤
                                            │ PRODUCT   │ Object PRODUCT of type str   │
                                            ├───────────┼──────────────────────────────┤
                                            │ REDUNDANT │ Object REDUNDANT of type str │
                                            ├───────────┼──────────────────────────────┤
                                            │ SHELL     │ Object SHELL of type str     │
                                            ├───────────┼──────────────────────────────┤
                                            │ SLICED    │ Object SLICED of type str    │
                                            ├───────────┼──────────────────────────────┤
                                            │ STAG      │ Object STAG of type str      │
                                            ├───────────┼──────────────────────────────┤
                                            │ SWARM     │ Object SWARM of type str     │
                                            └───────────┴──────────────────────────────┘

                     Attributes Documentation

                     COMPOSITE:str=COMPOSITE
                            Object COMPOSITE of type strDA:str=DA
                            Object DA of type strFOREST:str=FOREST
                            Object FOREST of type strMOAB:str=MOAB
                            Object MOAB of type strNETWORK:str=NETWORK
                            Object NETWORK of type strP4EST:str=P4EST
                            Object P4EST of type strP8EST:str=P8EST
                            Object P8EST of type strPATCH:str=PATCH
                            Object PATCH of type strPLEX:str=PLEX
                            Object PLEX of type strPRODUCT:str=PRODUCT
                            Object PRODUCT of type strREDUNDANT:str=REDUNDANT
                            Object REDUNDANT of type strSHELL:str=SHELL
                            Object SHELL of type strSLICED:str=SLICED
                            Object SLICED of type strSTAG:str=STAG
                            Object STAG of type strSWARM:str=SWARM
                            Object SWARM of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ adaptLabel(label)                     │ Adapt a DM based on a DMLabel.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ adaptMetric(metric[,         bdLabel, │ Return  a   mesh   adapted   to   the │
                      │ rgLabel])                             │ specified metric field.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ addCoarsenHook(coarsenhook,           │ Add  a  callback  to be executed when │
                      │ restricthook[, ...])                  │ restricting to a coarser grid.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ addField(field[, label])              │ Add a field to a DM object.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ appendOptionsPrefix(prefix)           │ Append  to  the   prefix   used   for │
                      │                                       │ searching    for   options   in   the │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clearDS()                             │ Remove all discrete systems from  the │
                      │                                       │ DM.                                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clearFields()                         │ Remove all fields from the DM.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clearLabelStratum(name, value)        │ Remove all points from a stratum.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clearLabelValue(name, point, value)   │ Remove  a  point  from a DMLabel with │
                      │                                       │ given value.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clone()                               │ Return the cloned DM .                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ coarsen([comm])                       │ Return a coarsened DM object.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ coarsenHierarchy(nlevels)             │ Coarsen  this  DM  and   return   the │
                      │                                       │ coarsened DM hierarchy.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ convert(dm_type)                      │ Return a DM converted to another DM.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ copyDS(dm[, minDegree, maxDegree])    │ Copy the discrete systems for this DM │
                      │                                       │ into another DM.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ copyDisc(dm)                          │ Copy fields and discrete systems of a │
                      │                                       │ DM into another DM.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ copyFields(dm[,            minDegree, │ Copy the discretizations of  this  DM │
                      │ maxDegree])                           │ into another DM.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Return an empty DM.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createDS()                            │ Create discrete systems.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createFieldDecomposition()            │ Return a list of IS objects.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createGlobalVec()                     │ Return a global vector.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createInjection(dm)                   │ Return  the  injection  matrix into a │
                      │                                       │ finer DM.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createInterpolation(dm)               │ Return the interpolation matrix to  a │
                      │                                       │ finer DM.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createLabel(name)                     │ Create  a  label of the given name if │
                      │                                       │ it does not already exist.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createLocalVec()                      │ Return a local vector.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createMassMatrix(dmf)                 │ Return the mass matrix  between  this │
                      │                                       │ DM and the given DM.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createMat()                           │ Return an empty matrix.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createRestriction(dm)                 │ Return the restriction matrix between │
                      │                                       │ this DM and the given DM.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSectionSF(localsec, globalsec)  │ Create  the  SF encoding the parallel │
                      │                                       │ DOF overlap for the DM.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSubDM(fields)                   │ Return  IS  and  DM  encapsulating  a │
                      │                                       │ subproblem.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the object.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getAppCtx()                           │ Return the application context.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getAuxiliaryVec([label, value, part]) │ Return   an   auxiliary   vector  for │
                      │                                       │ region.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBasicAdjacency()                   │ Return  the  flags  for   determining │
                      │                                       │ variable influence.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBlockSize()                        │ Return   the   inherent   block  size │
                      │                                       │ associated with a DM.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBoundingBox()                      │ Return  the  dimension  of  embedding │
                      │                                       │ space for coordinates values.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCellCoordinateDM()                 │ Return the cell coordinate DM.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCellCoordinateSection()            │ Return  the  cell  coordinate  layout │
                      │                                       │ over the DM.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCellCoordinates()                  │ Return  a  global  vector  with   the │
                      │                                       │ cellwise coordinates.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCellCoordinatesLocal()             │ Return   a   local  vector  with  the │
                      │                                       │ cellwise coordinates.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoarseDM()                         │ Return the coarse DM.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoarsenLevel()                     │ Return the number of coarsenings.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoordinateDM()                     │ Return the coordinate DM.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoordinateDim()                    │ Return  the  dimension  of  embedding │
                      │                                       │ space for coordinates values.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoordinateSection()                │ Return  coordinate values layout over │
                      │                                       │ the mesh.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoordinates()                      │ Return  a  global  vector  with   the │
                      │                                       │ coordinates associated.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoordinatesLocal()                 │ Return   a   local  vector  with  the │
                      │                                       │ coordinates associated.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoordinatesLocalized()             │ Check if the  coordinates  have  been │
                      │                                       │ localized for cells.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDS()                               │ Return default DS.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDimension()                        │ Return  the  topological dimension of │
                      │                                       │ the DM.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getField(index)                       │ Return the discretization object  for │
                      │                                       │ a given DM field.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFieldAdjacency(field)              │ Return   the  flags  for  determining │
                      │                                       │ variable influence.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getGlobalSection()                    │ Return  the  Section   encoding   the │
                      │                                       │ global data layout for the DM.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getGlobalVec([name])                  │ Return a global vector.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLGMap()                            │ Return   local   mapping   to  global │
                      │                                       │ mapping.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLabel(name)                        │ Return the label of a given name.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLabelIdIS(name)                    │ Return an IS of all values  that  the │
                      │                                       │ DMLabel takes.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLabelName(index)                   │ Return the name of nth label.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLabelOutput(name)                  │ Return  the  output  flag for a given │
                      │                                       │ label.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLabelSize(name)                    │ Return the number of values that  the │
                      │                                       │ DMLabel takes.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLabelValue(name, point)            │ Return  the  value in DMLabel for the │
                      │                                       │ given point.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalBoundingBox()                 │ Return the bounding box for the piece │
                      │                                       │ of the DM.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalSection()                     │ Return the Section encoding the local │
                      │                                       │ data layout for the DM.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalVec([name])                   │ Return a local vector.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumFields()                        │ Return the number of  fields  in  the │
                      │                                       │ DM.                                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumLabels()                        │ Return  the  number of labels defined │
                      │                                       │ by on the DM.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOptionsPrefix()                    │ Return the prefix used for  searching │
                      │                                       │ for options in the database.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPointSF()                          │ Return  the  SF encoding the parallel │
                      │                                       │ DOF overlap for the DM.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRefineLevel()                      │ Return the refinement level.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSectionSF()                        │ Return  the  Section   encoding   the │
                      │                                       │ parallel DOF overlap.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStratumIS(name, value)             │ Return the points in a label stratum. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStratumSize(name, value)           │ Return  the  number  of  points  in a │
                      │                                       │ label stratum.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the DM type name.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ globalToLocal(vg, vl[, addv])         │ Update  local  vectors  from   global │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ hasLabel(name)                        │ Determine whether the DM has a label. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ load(viewer)                          │ Return a DM stored in binary.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ localToGlobal(vl, vg[, addv])         │ Update   global  vectors  from  local │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ localToLocal(vl, vlg[, addv])         │ Map the values from a local vector to │
                      │                                       │ another local vector.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ localizeCoordinates()                 │ Create local  coordinates  for  cells │
                      │                                       │ having periodic faces.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ refine([comm])                        │ Return a refined DM object.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ refineHierarchy(nlevels)              │ Refine this DM and return the refined │
                      │                                       │ DM hierarchy.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ removeLabel(name)                     │ Remove and destroy the label by name. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreGlobalVec(vg[, name])          │ Restore a global vector obtained with │
                      │                                       │ getGlobalVec.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreLocalVec(vl[, name])           │ Restore  a local vector obtained with │
                      │                                       │ getLocalVec.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setAppCtx(appctx)                     │ Set the application context.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setAuxiliaryVec(aux,  label[,  value, │ Set   an   auxiliary   vector  for  a │
                      │ part])                                │ specific region.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBasicAdjacency(useCone,            │ Set   the   flags   for   determining │
                      │ useClosure)                           │ variable influence.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCellCoordinateDM(dm)               │ Set the cell coordinate DM.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCellCoordinateSection(dim, sec)    │ Set  the  cell coordinate layout over │
                      │                                       │ the DM.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCellCoordinates(c)                 │ Set a global vector with the cellwise │
                      │                                       │ coordinates.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCellCoordinatesLocal(c)            │ Set a local vector with the  cellwise │
                      │                                       │ coordinates.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCoarseDM(dm)                       │ Set the coarse DM.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCoordinateDim(dim)                 │ Set  the dimension of embedding space │
                      │                                       │ for coordinates values.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCoordinateDisc(disc, project)      │ Project coordinates  to  a  different │
                      │                                       │ space.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCoordinates(c)                     │ Set  a  global  vector that holds the │
                      │                                       │ coordinates.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCoordinatesLocal(c)                │ Set a local  vector  with  the  ghost │
                      │                                       │ point holding the coordinates.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDimension(dim)                     │ Set  the topological dimension of the │
                      │                                       │ DM.                                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setField(index, field[, label])       │ Set the discretization object  for  a │
                      │                                       │ given DM field.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFieldAdjacency(field,     useCone, │ Set   the   flags   for   determining │
                      │ useClosure)                           │ variable influence.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Configure the object from the options │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setGlobalSection(sec)                 │ Set  the  Section encoding the global │
                      │                                       │ data layout for the DM.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setKSPComputeOperators(operators[,    │ Matrix  associated  with  the  linear │
                      │ args, kargs])                         │ system.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLabelOutput(name, output)          │ Set  if a given label should be saved │
                      │                                       │ to a view.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLabelValue(name, point, value)     │ Set a point to a DMLabel with a given │
                      │                                       │ value.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLocalSection(sec)                  │ Set the Section  encoding  the  local │
                      │                                       │ data layout for the DM.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMatType(mat_type)                  │ Set   matrix   type  to  be  used  by │
                      │                                       │ DM.createMat.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNumFields(numFields)               │ Set the number of fields in the DM.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOptionsPrefix(prefix)              │ Set the prefix used for searching for │
                      │                                       │ options in the database.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPointSF(sf)                        │ Set the SF encoding the parallel  DOF │
                      │                                       │ overlap for the DM.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRefineLevel(level)                 │ Set the number of refinements.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSNESFunction(function[,      args, │ Set    SNES    residual    evaluation │
                      │ kargs])                               │ function.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSNESJacobian(jacobian[,      args, │ Set  the  SNES  Jacobian   evaluation │
                      │ kargs])                               │ function.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSectionSF(sf)                      │ Set the Section encoding the parallel │
                      │                                       │ DOF overlap for the DM.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(dm_type)                      │ Build a DM.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Return the data structure.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setVecType(vec_type)                  │ Set the type of vector.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View the DM.                          │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                              ┌────────┬──────────────────────┐
                                              │ appctx │ Application context. │
                                              ├────────┼──────────────────────┤
                                              │ ds     │ Discrete space.      │
                                              └────────┴──────────────────────┘

              Methods Documentation

              adaptLabel(label)
                     Adapt a DM based on a DMLabel.

                     Collective.

                     Parameterslabel (str) -- The name of the DMLabel.

                     ReturntypeDMSEEALSO:DMAdaptLabelSourcecodeatpetsc4py/PETSc/DM.pyx:1645adaptMetric(metric,bdLabel=None,rgLabel=None)
                     Return a mesh adapted to the specified metric field.

                     Collective.

                     Parameters

                            • metric (Vec) -- The metric to which the mesh is adapted, defined vertex-wise.

                            • bdLabel (str|None) -- Label for boundary tags.

                            • rgLabel (str|None) -- Label for cell tag.

                     ReturntypeDMSEEALSO:DMAdaptMetricSourcecodeatpetsc4py/PETSc/DM.pyx:1668addCoarsenHook(coarsenhook,restricthook,args=None,kargs=None)
                     Add a callback to be executed when restricting to a coarser grid.

                     Logically collective.

                     Parameters

                            • coarsenhook (DMCoarsenHookFunction) -- The coarsen hook function.

                            • restricthook (DMRestrictHookFunction) -- The restrict hook function.

                            • args (tuple[Any,...]|None) -- Positional arguments for the hooks.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the hooks.

                     ReturntypeNoneSEEALSO:DMCoarsenHookAddSourcecodeatpetsc4py/PETSc/DM.pyx:2333addField(field,label=None)
                     Add a field to a DM object.

                     Logically collective.

                     Parameters

                            • field (Object) -- The discretization object.

                            • label  (str|None) -- The name of the label indicating the support of the field,
                              or None for the entire mesh.

                     ReturntypeNoneSEEALSO:DMAddFieldSourcecodeatpetsc4py/PETSc/DM.pyx:611appendOptionsPrefix(prefix)
                     Append to the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, DMAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/DM.pyx:298Parametersprefix (str|None)

                     ReturntypeNoneclearDS()
                     Remove all discrete systems from the DM.

                     Logically collective.

                     SEEALSO:DMClearDSSourcecodeatpetsc4py/PETSc/DM.pyx:691ReturntypeNoneclearFields()
                     Remove all fields from the DM.

                     Logically collective.

                     SEEALSO:DMClearFieldsSourcecodeatpetsc4py/PETSc/DM.pyx:634ReturntypeNoneclearLabelStratum(name,value)
                     Remove all points from a stratum.

                     Not collective.

                     Parameters

                            • name (str) -- The label name.

                            • value (int) -- The stratum value.

                     ReturntypeNoneSEEALSO:DMClearLabelStratumSourcecodeatpetsc4py/PETSc/DM.pyx:2124clearLabelValue(name,point,value)
                     Remove a point from a DMLabel with given value.

                     Not collective.

                     Parameters

                            • name (str) -- The label name.

                            • point (int) -- The mesh point.

                            • value (int) -- The label value for the point.

                     ReturntypeNoneSEEALSO:DMClearLabelValueSourcecodeatpetsc4py/PETSc/DM.pyx:2010clone()
                     Return the cloned DM .

                     Collective.

                     SEEALSO:DMCloneSourcecodeatpetsc4py/PETSc/DM.pyx:155ReturntypeDMcoarsen(comm=None)
                     Return a coarsened DM object.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeDMSEEALSO:DMCoarsenSourcecodeatpetsc4py/PETSc/DM.pyx:1519coarsenHierarchy(nlevels)
                     Coarsen this DM and return the coarsened DM hierarchy.

                     Collective.

                     Parametersnlevels (int) -- The number of levels of coarsening.

                     ReturntypelistSEEALSO:DMCoarsenHierarchySourcecodeatpetsc4py/PETSc/DM.pyx:1570convert(dm_type)
                     Return a DM converted to another DM.

                     Collective.

                     Parametersdm_type (Type|str) -- The new DM.Type, use “same” for the same type.

                     ReturntypeDMSEEALSO:DM.Type, DMConvertSourcecodeatpetsc4py/PETSc/DM.pyx:1472copyDS(dm,minDegree=None,maxDegree=None)
                     Copy the discrete systems for this DM into another DM.

                     Collective.

                     Parameters

                            • dm (DM) -- The DM that the discrete fields are copied into.

                            • minDegree -- The minimum polynommial degree for the discretization, or None for no
                              limit

                            • maxDegree -- The maximum polynommial degree for the discretization, or None for no
                              limit

                     ReturntypeNoneSEEALSO:DMCopyDSSourcecodeatpetsc4py/PETSc/DM.pyx:718copyDisc(dm)
                     Copy fields and discrete systems of a DM into another DM.

                     Collective.

                     Parametersdm (DM) -- The DM that the fields and discrete systems are copied into.

                     ReturntypeNoneSEEALSO:DMCopyDiscSourcecodeatpetsc4py/PETSc/DM.pyx:751copyFields(dm,minDegree=None,maxDegree=None)
                     Copy the discretizations of this DM into another DM.

                     Collective.

                     Parameters

                            • dm (DM) -- The DM that the fields are copied into.

                            • minDegree -- The minimum polynommial degree for the discretization, or None for no
                              limit

                            • maxDegree -- The maximum polynommial degree for the discretization, or None for no
                              limit

                     ReturntypeNoneSEEALSO:DMCopyFieldsSourcecodeatpetsc4py/PETSc/DM.pyx:646create(comm=None)
                     Return an empty DM.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DMCreateSourcecodeatpetsc4py/PETSc/DM.pyx:134createDS()
                     Create discrete systems.

                     Collective.

                     SEEALSO:DMCreateDSSourcecodeatpetsc4py/PETSc/DM.pyx:679ReturntypeNonecreateFieldDecomposition()
                     Return a list of IS objects.

                     Not collective.

                     Notes

                     The user is responsible for freeing all requested arrays.

                     SEEALSO:DMCreateFieldDecompositionSourcecodeatpetsc4py/PETSc/DM.pyx:2222Returntypetuple[list, list, list]

              createGlobalVec()
                     Return a global vector.

                     Collective.

                     SEEALSO:DMCreateGlobalVectorSourcecodeatpetsc4py/PETSc/DM.pyx:798ReturntypeVeccreateInjection(dm)
                     Return the injection matrix into a finer DM.

                     Collective.

                     Parametersdm (DM) -- The second, finer DM object.

                     ReturntypeMatSEEALSO:DMCreateInjectionSourcecodeatpetsc4py/PETSc/DM.pyx:1434createInterpolation(dm)
                     Return the interpolation matrix to a finer DM.

                     Collective.

                     Parametersdm (DM) -- The second, finer DM.

                     Returntypetuple[Mat, Vec]

                     SEEALSO:DMCreateInterpolationSourcecodeatpetsc4py/PETSc/DM.pyx:1413createLabel(name)
                     Create a label of the given name if it does not already exist.

                     Not collective.

                     Parametersname (str) -- The label name.

                     ReturntypeNoneSEEALSO:DMCreateLabelSourcecodeatpetsc4py/PETSc/DM.pyx:1922createLocalVec()
                     Return a local vector.

                     Not collective.

                     SEEALSO:DMCreateLocalVectorSourcecodeatpetsc4py/PETSc/DM.pyx:812ReturntypeVeccreateMassMatrix(dmf)
                     Return the mass matrix between this DM and the given DM.

                     Collective.

                     Parametersdmf (DM) -- The second DM.

                     ReturntypeMatSEEALSO:DMCreateMassMatrixSourcecodeatpetsc4py/PETSc/DM.pyx:1394createMat()
                     Return an empty matrix.

                     Collective.

                     SEEALSO:DMCreateMatrixSourcecodeatpetsc4py/PETSc/DM.pyx:1380ReturntypeMatcreateRestriction(dm)
                     Return the restriction matrix between this DM and the given DM.

                     Collective.

                     Parametersdm (DM) -- The second, finer DM object.

                     ReturntypeMatSEEALSO:DMCreateRestrictionSourcecodeatpetsc4py/PETSc/DM.pyx:1453createSectionSF(localsec,globalsec)
                     Create the SF encoding the parallel DOF overlap for the DM.

                     Collective.

                     Parameters

                            • localsec (Section) -- Describe the local data layout.

                            • globalsec (Section) -- Describe the global data layout.

                     ReturntypeNone

                     Notes

                     Encoding based on the Section describing the data layout.

                     SEEALSO:DM.getSectionSF, DMCreateSectionSFSourcecodeatpetsc4py/PETSc/DM.pyx:1786createSubDM(fields)
                     Return IS and DM encapsulating a subproblem.

                     Not collective.

                     Returns

                            • iset (IS) -- The global indices for all the degrees of freedom.

                            • subdm (DM) -- The DM for the subproblem.

                     Parametersfields (Sequence[int])

                     Returntypetuple[IS, DM]

                     SEEALSO:DMCreateSubDMSourcecodeatpetsc4py/PETSc/DM.pyx:446destroy()
                     Destroy the object.

                     Collective.

                     SEEALSO:DMDestroySourcecodeatpetsc4py/PETSc/DM.pyx:121ReturntypeSelfgetAppCtx()
                     Return the application context.

                     Sourcecodeatpetsc4py/PETSc/DM.pyx:343ReturntypeAnygetAuxiliaryVec(label=None,value=0,part=0)
                     Return an auxiliary vector for region.

                     Not collective.

                     Parameters

                            • label (str|None) -- The name of the DMLabel.

                            • value (int|None) -- Indicate the region.

                            • part (int|None) -- The equation part, or 0 is unused.

                     ReturntypeVecSEEALSO:DM.getLabel, DMGetAuxiliaryVecSourcecodeatpetsc4py/PETSc/DM.pyx:503getBasicAdjacency()
                     Return the flags for determining variable influence.

                     Not collective.

                     Returns

                            • useCone (bool) -- Whether adjacency uses cone information.

                            • useClosure (bool) -- Whether adjacency is computed using full closure information.

                     Returntypetuple[bool, bool]

                     SEEALSO:DMGetBasicAdjacencySourcecodeatpetsc4py/PETSc/DM.pyx:370getBlockSize()
                     Return the inherent block size associated with a DM.

                     Not collective.

                     SEEALSO:DMGetBlockSizeSourcecodeatpetsc4py/PETSc/DM.pyx:770ReturntypeintgetBoundingBox()
                     Return the dimension of embedding space for coordinates values.

                     Not collective.

                     SEEALSO:DMGetBoundingBoxSourcecodeatpetsc4py/PETSc/DM.pyx:1306Returntypetuple[tuple[float, float], ...]

              getCellCoordinateDM()
                     Return the cell coordinate DM.

                     Collective.

                     SEEALSO:DMGetCellCoordinateDMSourcecodeatpetsc4py/PETSc/DM.pyx:1159ReturntypeDMgetCellCoordinateSection()
                     Return the cell coordinate layout over the DM.

                     Collective.

                     SEEALSO:DMGetCellCoordinateSectionSourcecodeatpetsc4py/PETSc/DM.pyx:1194ReturntypeSectiongetCellCoordinates()
                     Return a global vector with the cellwise coordinates.

                     Collective.

                     SEEALSO:DMGetCellCoordinatesSourcecodeatpetsc4py/PETSc/DM.pyx:1226ReturntypeVecgetCellCoordinatesLocal()
                     Return a local vector with the cellwise coordinates.

                     Collective.

                     SEEALSO:DMGetCellCoordinatesLocalSourcecodeatpetsc4py/PETSc/DM.pyx:1258ReturntypeVecgetCoarseDM()
                     Return the coarse DM.

                     Collective.

                     SEEALSO:DMGetCoarseDMSourcecodeatpetsc4py/PETSc/DM.pyx:1020ReturntypeDMgetCoarsenLevel()
                     Return the number of coarsenings.

                     Not collective.

                     SEEALSO:DMGetCoarsenLevelSourcecodeatpetsc4py/PETSc/DM.pyx:1629ReturntypeintgetCoordinateDM()
                     Return the coordinate DM.

                     Collective.

                     SEEALSO:DMGetCoordinateDMSourcecodeatpetsc4py/PETSc/DM.pyx:1048ReturntypeDMgetCoordinateDim()
                     Return the dimension of embedding space for coordinates values.

                     Not collective.

                     SEEALSO:DMGetCoordinateDimSourcecodeatpetsc4py/PETSc/DM.pyx:238ReturntypeintgetCoordinateSection()
                     Return coordinate values layout over the mesh.

                     Collective.

                     SEEALSO:DMGetCoordinateSectionSourcecodeatpetsc4py/PETSc/DM.pyx:1063ReturntypeSectiongetCoordinates()
                     Return a global vector with the coordinates associated.

                     Collective.

                     SEEALSO:DMGetCoordinatesSourcecodeatpetsc4py/PETSc/DM.pyx:1095ReturntypeVecgetCoordinatesLocal()
                     Return a local vector with the coordinates associated.

                     Collective the first time it is called.

                     SEEALSO:DMGetCoordinatesLocalSourcecodeatpetsc4py/PETSc/DM.pyx:1127ReturntypeVecgetCoordinatesLocalized()
                     Check if the coordinates have been localized for cells.

                     Not collective.

                     SEEALSO:DMGetCoordinatesLocalizedSourcecodeatpetsc4py/PETSc/DM.pyx:1292ReturntypeboolgetDS()
                     Return default DS.

                     Not collective.

                     SEEALSO:DMGetDSSourcecodeatpetsc4py/PETSc/DM.pyx:703ReturntypeDSgetDimension()
                     Return the topological dimension of the DM.

                     Not collective.

                     SEEALSO:DMGetDimensionSourcecodeatpetsc4py/PETSc/DM.pyx:206ReturntypeintgetField(index)
                     Return the discretization object for a given DM field.

                     Not collective.

                     Parametersindex (int) -- The field number.

                     Returntypetuple[Object, None]

                     SEEALSO:DMGetFieldSourcecodeatpetsc4py/PETSc/DM.pyx:586getFieldAdjacency(field)
                     Return the flags for determining variable influence.

                     Not collective.

                     Parametersfield (int) -- The field number.

                     Returns

                            • useCone (bool) -- Whether adjacency uses cone information.

                            • useClosure (bool) -- Whether adjacency is computed using full closure information.

                     Returntypetuple[bool, bool]

                     SEEALSO:DMGetAdjacencySourcecodeatpetsc4py/PETSc/DM.pyx:416getGlobalSection()
                     Return the Section encoding the global data layout for the DM.

                     Collective the first time it is called.

                     SEEALSO:DMGetGlobalSectionSourcecodeatpetsc4py/PETSc/DM.pyx:1762ReturntypeSectiongetGlobalVec(name=None)
                     Return a global vector.

                     Collective.

                     Parametersname (str|None) -- The optional name to retrieve a persistent vector.

                     ReturntypeVec

                     Notes

                     When done with the vector, it must be restored using restoreGlobalVec.

                     SEEALSO:restoreGlobalVec, DMGetGlobalVector, DMGetNamedGlobalVectorSourcecodeatpetsc4py/PETSc/DM.pyx:826getLGMap()
                     Return local mapping to global mapping.

                     Collective.

                     SEEALSO:DMGetLocalToGlobalMappingSourcecodeatpetsc4py/PETSc/DM.pyx:1003ReturntypeLGMapgetLabel(name)
                     Return the label of a given name.

                     Not collective.

                     SEEALSO:DMGetLabelSourcecodeatpetsc4py/PETSc/DM.pyx:1704Parametersname (str)

                     ReturntypeDMLabelgetLabelIdIS(name)
                     Return an IS of all values that the DMLabel takes.

                     Not collective.

                     Parametersname (str) -- The label name.

                     ReturntypeISSEEALSO:DMLabelGetValueIS, DMGetLabelIdISSourcecodeatpetsc4py/PETSc/DM.pyx:2055getLabelName(index)
                     Return the name of nth label.

                     Not collective.

                     Parametersindex (int) -- The label number.

                     ReturntypestrSEEALSO:DMGetLabelNameSourcecodeatpetsc4py/PETSc/DM.pyx:1881getLabelOutput(name)
                     Return the output flag for a given label.

                     Not collective.

                     Parametersname (str) -- The label name.

                     ReturntypeboolSEEALSO:DMGetLabelOutputSourcecodeatpetsc4py/PETSc/DM.pyx:2168getLabelSize(name)
                     Return the number of values that the DMLabel takes.

                     Not collective.

                     Parametersname (str) -- The label name.

                     ReturntypeintSEEALSO:DMLabelGetNumValues, DMGetLabelSizeSourcecodeatpetsc4py/PETSc/DM.pyx:2034getLabelValue(name,point)
                     Return the value in DMLabel for the given point.

                     Not collective.

                     Parameters

                            • name (str) -- The label name.

                            • point (int) -- The mesh point

                     ReturntypeintSEEALSO:DMGetLabelValueSourcecodeatpetsc4py/PETSc/DM.pyx:1963getLocalBoundingBox()
                     Return the bounding box for the piece of the DM.

                     Not collective.

                     SEEALSO:DMGetLocalBoundingBoxSourcecodeatpetsc4py/PETSc/DM.pyx:1323Returntypetuple[tuple[float, float], ...]

              getLocalSection()
                     Return the Section encoding the local data layout for the DM.

                     Not collective.

                     SEEALSO:DMGetGlobalSectionSourcecodeatpetsc4py/PETSc/DM.pyx:1735ReturntypeSectiongetLocalVec(name=None)
                     Return a local vector.

                     Not collective.

                     Parametersname (str|None) -- The optional name to retrieve a persistent vector.

                     ReturntypeVec

                     Notes

                     When done with the vector, it must be restored using restoreLocalVec.

                     SEEALSO:restoreLocalVec, DMGetLocalVector, DMGetNamedLocalVectorSourcecodeatpetsc4py/PETSc/DM.pyx:880getNumFields()
                     Return the number of fields in the DM.

                     Not collective.

                     SEEALSO:DMGetNumFieldsSourcecodeatpetsc4py/PETSc/DM.pyx:546ReturntypeintgetNumLabels()
                     Return the number of labels defined by on the DM.

                     Not collective.

                     SEEALSO:DMGetNumLabelsSourcecodeatpetsc4py/PETSc/DM.pyx:1867ReturntypeintgetOptionsPrefix()
                     Return the prefix used for searching for options in the database.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, DMGetOptionsPrefixSourcecodeatpetsc4py/PETSc/DM.pyx:284ReturntypestrgetPointSF()
                     Return the SF encoding the parallel DOF overlap for the DM.

                     Not collective.

                     SEEALSO:DMGetPointSFSourcecodeatpetsc4py/PETSc/DM.pyx:1840ReturntypeSFgetRefineLevel()
                     Return the refinement level.

                     Not collective.

                     SEEALSO:DMGetRefineLevelSourcecodeatpetsc4py/PETSc/DM.pyx:1597ReturntypeintgetSectionSF()
                     Return the Section encoding the parallel DOF overlap.

                     Collective the first time it is called.

                     SEEALSO:DMGetSectionSFSourcecodeatpetsc4py/PETSc/DM.pyx:1809ReturntypeSFgetStratumIS(name,value)
                     Return the points in a label stratum.

                     Not collective.

                     Parameters

                            • name (str) -- The label name.

                            • value (int) -- The stratum value.

                     ReturntypeISSEEALSO:DMGetStratumISSourcecodeatpetsc4py/PETSc/DM.pyx:2100getStratumSize(name,value)
                     Return the number of points in a label stratum.

                     Not collective.

                     Parameters

                            • name (str) -- The label name.

                            • value (int) -- The stratum value.

                     ReturntypeintSEEALSO:DMGetStratumSizeSourcecodeatpetsc4py/PETSc/DM.pyx:2076getType()
                     Return the DM type name.

                     Not collective.

                     SEEALSO:DMGetTypeSourcecodeatpetsc4py/PETSc/DM.pyx:192ReturntypestrglobalToLocal(vg,vl,addv=None)
                     Update local vectors from global vector.

                     Neighborwise collective.

                     Parameters

                            • vg (Vec) -- The global vector.

                            • vl (Vec) -- The local vector.

                            • addv (InsertModeSpec|None) -- Insertion mode.

                     ReturntypeNoneSEEALSO:DMGlobalToLocalBegin, DMGlobalToLocalEndSourcecodeatpetsc4py/PETSc/DM.pyx:934hasLabel(name)
                     Determine whether the DM has a label.

                     Not collective.

                     Parametersname (str) -- The label name.

                     ReturntypeboolSEEALSO:DMHasLabelSourcecodeatpetsc4py/PETSc/DM.pyx:1901load(viewer)
                     Return a DM stored in binary.

                     Collective.

                     Parametersviewer (Viewer)  --  Viewer  used  to  store  the  DM,  like  Viewer.Type.BINARY  or
                            Viewer.Type.HDF5.

                     ReturntypeSelf

                     Notes

                     When  using  Viewer.Type.HDF5  format, one can save multiple DMPlex meshes in a single HDF5
                     files. This in turn requires one to name  the  DMPlex  object  with  Object.setName  before
                     saving  it  with  DM.view and before loading it with DM.load for identification of the mesh
                     object.

                     SEEALSO:DM.view, DM.load, Object.setName, DMLoadSourcecodeatpetsc4py/PETSc/DM.pyx:95localToGlobal(vl,vg,addv=None)
                     Update global vectors from local vector.

                     Neighborwise collective.

                     Parameters

                            • vl (Vec) -- The local vector.

                            • vg (Vec) -- The global vector.

                            • addv (InsertModeSpec|None) -- Insertion mode.

                     ReturntypeNoneSEEALSO:DMLocalToGlobalBegin, DMLocalToGlobalEndSourcecodeatpetsc4py/PETSc/DM.pyx:957localToLocal(vl,vlg,addv=None)
                     Map the values from a local vector to another local vector.

                     Neighborwise collective.

                     Parameters

                            • vl (Vec) -- The local vector.

                            • vlg (Vec) -- The global vector.

                            • addv (InsertModeSpec|None) -- Insertion mode.

                     ReturntypeNoneSEEALSO:DMLocalToLocalBegin, DMLocalToLocalEndSourcecodeatpetsc4py/PETSc/DM.pyx:980localizeCoordinates()
                     Create local coordinates for cells having periodic faces.

                     Collective.

                     Notes

                     Used if the mesh is periodic.

                     SEEALSO:DMLocalizeCoordinatesSourcecodeatpetsc4py/PETSc/DM.pyx:1340ReturntypeNonerefine(comm=None)
                     Return a refined DM object.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeDMSEEALSO:DMRefineSourcecodeatpetsc4py/PETSc/DM.pyx:1495refineHierarchy(nlevels)
                     Refine this DM and return the refined DM hierarchy.

                     Collective.

                     Parametersnlevels (int) -- The number of levels of refinement.

                     ReturntypelistSEEALSO:DMRefineHierarchySourcecodeatpetsc4py/PETSc/DM.pyx:1543removeLabel(name)
                     Remove and destroy the label by name.

                     Not collective.

                     Parametersname (str) -- The label name.

                     ReturntypeNoneSEEALSO:DMRemoveLabelSourcecodeatpetsc4py/PETSc/DM.pyx:1941restoreGlobalVec(vg,name=None)
                     Restore a global vector obtained with getGlobalVec.

                     Logically collective.

                     Parameters

                            • vg (Vec) -- The global vector.

                            • name (str|None) -- The name used to retrieve the persistent vector, if any.

                     ReturntypeNoneSEEALSO:getGlobalVec, DMRestoreGlobalVector, DMRestoreNamedGlobalVectorSourcecodeatpetsc4py/PETSc/DM.pyx:855restoreLocalVec(vl,name=None)
                     Restore a local vector obtained with getLocalVec.

                     Not collective.

                     Parameters

                            • vl (Vec) -- The local vector.

                            • name (str|None) -- The name used to retrieve the persistent vector, if any.

                     ReturntypeNoneSEEALSO:getLocalVec, DMRestoreLocalVector, DMRestoreNamedLocalVectorSourcecodeatpetsc4py/PETSc/DM.pyx:909setAppCtx(appctx)
                     Set the application context.

                     Sourcecodeatpetsc4py/PETSc/DM.pyx:339Parametersappctx (Any)

                     ReturntypeNonesetAuxiliaryVec(aux,label,value=0,part=0)
                     Set an auxiliary vector for a specific region.

                     Not collective.

                     Parameters

                            • aux (Vec) -- The auxiliary vector.

                            • label (DMLabel|None) -- The name of the DMLabel.

                            • value -- Indicate the region.

                            • part -- The equation part, or 0 is unused.

                     ReturntypeNoneSEEALSO:DMGetLabel, DMSetAuxiliaryVecSourcecodeatpetsc4py/PETSc/DM.pyx:473setBasicAdjacency(useCone,useClosure)
                     Set the flags for determining variable influence.

                     Not collective.

                     Parameters

                            • useCone (bool) -- Whether adjacency uses cone information.

                            • useClosure (bool) -- Whether adjacency is computed using full closure information.

                     ReturntypeNoneSEEALSO:DMSetBasicAdjacencySourcecodeatpetsc4py/PETSc/DM.pyx:349setCellCoordinateDM(dm)
                     Set the cell coordinate DM.

                     Collective.

                     Parametersdm (DM) -- The cell coordinate DM.

                     ReturntypeNoneSEEALSO:DMSetCellCoordinateDMSourcecodeatpetsc4py/PETSc/DM.pyx:1142setCellCoordinateSection(dim,sec)
                     Set the cell coordinate layout over the DM.

                     Collective.

                     Parameters

                            • dim (int) -- The embedding dimension, or DETERMINE.

                            • sec (Section) -- The cell coordinate Section.

                     ReturntypeNoneSEEALSO:DMSetCellCoordinateSectionSourcecodeatpetsc4py/PETSc/DM.pyx:1174setCellCoordinates(c)
                     Set a global vector with the cellwise coordinates.

                     Collective.

                     Parametersc (Vec) -- The global cell coordinate vector.

                     ReturntypeNoneSEEALSO:DMSetCellCoordinatesSourcecodeatpetsc4py/PETSc/DM.pyx:1209setCellCoordinatesLocal(c)
                     Set a local vector with the cellwise coordinates.

                     Not collective.

                     Parametersc (Vec) -- The local cell coordinate vector.

                     ReturntypeNoneSEEALSO:DMSetCellCoordinatesLocalSourcecodeatpetsc4py/PETSc/DM.pyx:1241setCoarseDM(dm)
                     Set the coarse DM.

                     Collective.

                     SEEALSO:DMSetCoarseDMSourcecodeatpetsc4py/PETSc/DM.pyx:1035Parametersdm (DM)

                     ReturntypeNonesetCoordinateDim(dim)
                     Set the dimension of embedding space for coordinates values.

                     Not collective.

                     Parametersdim (int) -- The embedding dimension.

                     ReturntypeNoneSEEALSO:DMSetCoordinateDimSourcecodeatpetsc4py/PETSc/DM.pyx:252setCoordinateDisc(disc,project)
                     Project coordinates to a different space.

                     Collective.

                     Parameters

                            • disc (FE) -- The new coordinates discretization.

                            • project (bool)

                     ReturntypeSelfSEEALSO:DMSetCoordinateDiscSourcecodeatpetsc4py/PETSc/DM.pyx:1273setCoordinates(c)
                     Set a global vector that holds the coordinates.

                     Collective.

                     Parametersc (Vec) -- Coordinate Vector.

                     ReturntypeNoneSEEALSO:DMSetCoordinatesSourcecodeatpetsc4py/PETSc/DM.pyx:1078setCoordinatesLocal(c)
                     Set a local vector with the ghost point holding the coordinates.

                     Not collective.

                     Parametersc (Vec) -- Coordinate Vector.

                     ReturntypeNoneSEEALSO:DMSetCoordinatesLocalSourcecodeatpetsc4py/PETSc/DM.pyx:1110setDimension(dim)
                     Set the topological dimension of the DM.

                     Collective.

                     Parametersdim (int) -- Topological dimension.

                     ReturntypeNoneSEEALSO:DMSetDimensionSourcecodeatpetsc4py/PETSc/DM.pyx:220setField(index,field,label=None)
                     Set the discretization object for a given DM field.

                     Logically collective.

                     Parameters

                            • index (int) -- The field number.

                            • field (Object) -- The discretization object.

                            • label (str|None) -- The name of the label indicating the support of  the  field,
                              or None for the entire mesh.

                     ReturntypeNoneSEEALSO:DMSetFieldSourcecodeatpetsc4py/PETSc/DM.pyx:560setFieldAdjacency(field,useCone,useClosure)
                     Set the flags for determining variable influence.

                     Not collective.

                     Parameters

                            • field (int) -- The field number.

                            • useCone (bool) -- Whether adjacency uses cone information.

                            • useClosure (bool) -- Whether adjacency is computed using full closure information.

                     ReturntypeNoneSEEALSO:DMSetAdjacencySourcecodeatpetsc4py/PETSc/DM.pyx:392setFromOptions()
                     Configure the object from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, DMSetFromOptionsSourcecodeatpetsc4py/PETSc/DM.pyx:312ReturntypeNonesetGlobalSection(sec)
                     Set the Section encoding the global data layout for the DM.

                     Collective.

                     SEEALSO:DMSetGlobalSectionSourcecodeatpetsc4py/PETSc/DM.pyx:1750Parameterssec (Section)

                     ReturntypeNonesetKSPComputeOperators(operators,args=None,kargs=None)
                     Matrix associated with the linear system.

                     Collective.

                     Parameters

                            • operator -- Callback function to compute the operators.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:DMKSPSetComputeOperatorsSourcecodeatpetsc4py/PETSc/DM.pyx:2194setLabelOutput(name,output)
                     Set if a given label should be saved to a view.

                     Not collective.

                     Parameters

                            • name (str) -- The label name.

                            • output (bool) -- If True, the label is saved to the viewer.

                     ReturntypeNoneSEEALSO:DMSetLabelOutputSourcecodeatpetsc4py/PETSc/DM.pyx:2146setLabelValue(name,point,value)
                     Set a point to a DMLabel with a given value.

                     Not collective.

                     Parameters

                            • name (str) -- The label name.

                            • point (int) -- The mesh point.

                            • value (int) -- The label value for the point.

                     ReturntypeNoneSEEALSO:DMSetLabelValueSourcecodeatpetsc4py/PETSc/DM.pyx:1986setLocalSection(sec)
                     Set the Section encoding the local data layout for the DM.

                     Collective.

                     SEEALSO:DMSetLocalSectionSourcecodeatpetsc4py/PETSc/DM.pyx:1723Parameterssec (Section)

                     ReturntypeNonesetMatType(mat_type)
                     Set matrix type to be used by DM.createMat.

                     Logically collective.

                     Parametersmat_type (Type|str) -- The matrix type.

                     ReturntypeNone

                     Notes

                     The option -dm_mat_type is used to set the matrix type.

                     SEEALSO:WorkingwithPETScoptions, DMSetMatTypeSourcecodeatpetsc4py/PETSc/DM.pyx:1357setNumFields(numFields)
                     Set the number of fields in the DM.

                     Logically collective.

                     SEEALSO:DMSetNumFieldsSourcecodeatpetsc4py/PETSc/DM.pyx:533ParametersnumFields (int)

                     ReturntypeNonesetOptionsPrefix(prefix)
                     Set the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, getOptionsPrefix, DMSetOptionsPrefixSourcecodeatpetsc4py/PETSc/DM.pyx:270Parametersprefix (str|None)

                     ReturntypeNonesetPointSF(sf)
                     Set the SF encoding the parallel DOF overlap for the DM.

                     Logically collective.

                     SEEALSO:DMSetPointSFSourcecodeatpetsc4py/PETSc/DM.pyx:1855Parameterssf (SF)

                     ReturntypeNonesetRefineLevel(level)
                     Set the number of refinements.

                     Not collective.

                     Parameters

                            • nlevels -- The number of refinement.

                            • level (int)

                     ReturntypeNoneSEEALSO:DMSetRefineLevelSourcecodeatpetsc4py/PETSc/DM.pyx:1611setSNESFunction(function,args=None,kargs=None)
                     Set SNES residual evaluation function.

                     Not collective.

                     Parameters

                            • function (SNESFunction) -- The callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:SNES.setFunction, DMSNESSetFunctionSourcecodeatpetsc4py/PETSc/DM.pyx:2270setSNESJacobian(jacobian,args=None,kargs=None)
                     Set the SNES Jacobian evaluation function.

                     Not collective.

                     Parameters

                            • jacobian (SNESJacobianFunction) -- The Jacobian callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:SNES.setJacobian, DMSNESSetJacobianSourcecodeatpetsc4py/PETSc/DM.pyx:2302setSectionSF(sf)
                     Set the Section encoding the parallel DOF overlap for the DM.

                     Logically collective.

                     SEEALSO:DMSetSectionSFSourcecodeatpetsc4py/PETSc/DM.pyx:1824Parameterssf (SF)

                     ReturntypeNonesetType(dm_type)
                     Build a DM.

                     Collective.

                     Parametersdm_type (Type|str) -- The type of DM.

                     ReturntypeNone

                     Notes

                     DM types are available in DM.Type class.

                     SEEALSO:DM.Type, DMSetTypeSourcecodeatpetsc4py/PETSc/DM.pyx:169setUp()
                     Return the data structure.

                     Collective.

                     SEEALSO:DMSetUpSourcecodeatpetsc4py/PETSc/DM.pyx:324ReturntypeSelfsetVecType(vec_type)
                     Set the type of vector.

                     Logically collective.

                     SEEALSO:Vec.Type, DMSetVecTypeSourcecodeatpetsc4py/PETSc/DM.pyx:784Parametersvec_type (Type|str)

                     ReturntypeNoneview(viewer=None)
                     View the DM.

                     Collective.

                     Parametersviewer (Viewer|None) -- The DM viewer.

                     ReturntypeNoneSEEALSO:DMViewSourcecodeatpetsc4py/PETSc/DM.pyx:76

              Attributes Documentation

              appctx Application context.

                     Sourcecodeatpetsc4py/PETSc/DM.pyx:2386ds     Discrete space.

                     Sourcecodeatpetsc4py/PETSc/DM.pyx:2396petsc4py.PETSc.DMCompositeclasspetsc4py.PETSc.DMComposite
              Bases: DM

              A DM object that is used to manage data for a collection of DMs.

              Methods Summary
                           ┌────────────────────────────┬───────────────────────────────────────┐
                           │ addDM(dm, *args)           │ Add a DM vector to the composite.     │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ create([comm])             │ Create a composite object.            │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ gather(gvec, imode, lvecs) │ Gather  split  local  vectors  into a │
                           │                            │ coupled global vector.                │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getAccess(gvec[, locs])    │ Get access to the individual  vectors │
                           │                            │ from the global vector.               │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getEntries()               │ Return   sub-DMs   contained  in  the │
                           │                            │ composite.                            │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getGlobalISs()             │ Return  the  index  sets   for   each │
                           │                            │ composed object in the composite.     │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getLGMaps()                │ Return  a local-to-global mapping for │
                           │                            │ each DM in the composite.             │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getLocalISs()              │ Return index sets for each  component │
                           │                            │ of a composite local vector.          │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getNumber()                │ Get  number  of  sub-DMs contained in │
                           │                            │ the composite.                        │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ scatter(gvec, lvecs)       │ Scatter coupled  global  vector  into │
                           │                            │ split local vectors.                  │
                           └────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              addDM(dm,*args)
                     Add a DM vector to the composite.

                     Collective.

                     Parameters

                            • dm (DM) -- The DM object.

                            • *args (DM) -- Additional DM objects.

                     ReturntypeNoneSEEALSO:DMCompositeAddDMSourcecodeatpetsc4py/PETSc/DMComposite.pyx:28create(comm=None)
                     Create a composite object.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DMCompositeCreateSourcecodeatpetsc4py/PETSc/DMComposite.pyx:6gather(gvec,imode,lvecs)
                     Gather split local vectors into a coupled global vector.

                     Collective.

                     Parameters

                            • gvec (Vec) -- The global vector.

                            • imode (InsertModeSpec) -- The insertion mode.

                            • lvecs (Sequence[Vec]) -- The individual sequential vectors.

                     ReturntypeNoneSEEALSO:scatter, DMCompositeGatherArraySourcecodeatpetsc4py/PETSc/DMComposite.pyx:115getAccess(gvec,locs=None)
                     Get access to the individual vectors from the global vector.

                     Not collective.

                     Use via Thewithstatement context manager (PEP 343).

                     Parameters

                            • gvec (Vec) -- The global vector.

                            • locs  (Sequence[int]|None)  --  Indices  of vectors wanted, or None to get all
                              vectors.

                     ReturntypeAnySourcecodeatpetsc4py/PETSc/DMComposite.pyx:219getEntries()
                     Return sub-DMs contained in the composite.

                     Not collective.

                     SEEALSO:DMCompositeGetEntriesArraySourcecodeatpetsc4py/PETSc/DMComposite.pyx:66Returntypelist[DM]

              getGlobalISs()
                     Return the index sets for each composed object in the composite.

                     Collective.

                     These could  be  used  to  extract  a  subset  of  vector  entries  for  a  "multi-physics"
                     preconditioner.

                     Use  getLocalISs  for  index  sets  in the packed local numbering, and getLGMaps for to map
                     local sub-DM (including ghost) indices to packed global indices.

                     SEEALSO:DMCompositeGetGlobalISsSourcecodeatpetsc4py/PETSc/DMComposite.pyx:143Returntypelist[IS]

              getLGMaps()
                     Return a local-to-global mapping for each DM in the composite.

                     Collective.

                     Note that this includes all the ghost points that individual ghosted DMDA may have.

                     SEEALSO:DMCompositeGetISLocalToGlobalMappingsSourcecodeatpetsc4py/PETSc/DMComposite.pyx:196Returntypelist[LGMap]

              getLocalISs()
                     Return index sets for each component of a composite local vector.

                     Not collective.

                     To get the composite global indices at all local points (including ghosts), use getLGMaps.

                     To get index sets for pieces of the composite global vector, use getGlobalISs.

                     SEEALSO:DMCompositeGetLocalISsSourcecodeatpetsc4py/PETSc/DMComposite.pyx:170Returntypelist[IS]

              getNumber()
                     Get number of sub-DMs contained in the composite.

                     Not collective.

                     SEEALSO:DMCompositeGetNumberDMSourcecodeatpetsc4py/PETSc/DMComposite.pyx:51Returntypeintscatter(gvec,lvecs)
                     Scatter coupled global vector into split local vectors.

                     Collective.

                     Parameters

                            • gvec (Vec) -- The global vector.

                            • lvecs (Sequence[Vec]) -- Array of local vectors.

                     ReturntypeNoneSEEALSO:gather, DMCompositeScatterArraySourcecodeatpetsc4py/PETSc/DMComposite.pyx:90petsc4py.PETSc.DMDAclasspetsc4py.PETSc.DMDA
              Bases: DM

              A DM object that is used to manage data for a structured grid.

              Enumerations
                                        ┌───────────────────┬──────────────────────┐
                                        │ ElementType       │ Element types.       │
                                        ├───────────────────┼──────────────────────┤
                                        │ InterpolationType │ Interpolation types. │
                                        ├───────────────────┼──────────────────────┤
                                        │ StencilType       │ Stencil types.       │
                                        └───────────────────┴──────────────────────┘

   petsc4py.PETSc.DMDA.ElementTypeclasspetsc4py.PETSc.DMDA.ElementType
                     Bases: object

                     Element types.

                     Attributes Summary
                                                  ┌────┬─────────────────────────┐
                                                  │ P1 │ Constant P1 of type int │
                                                  ├────┼─────────────────────────┤
                                                  │ Q1 │ Constant Q1 of type int │
                                                  └────┴─────────────────────────┘

                     Attributes Documentation

                     P1:int=P1
                            Constant P1 of type intQ1:int=Q1
                            Constant Q1 of type intpetsc4py.PETSc.DMDA.InterpolationTypeclasspetsc4py.PETSc.DMDA.InterpolationType
                     Bases: object

                     Interpolation types.

                     Attributes Summary
                                                  ┌────┬─────────────────────────┐
                                                  │ Q0 │ Constant Q0 of type int │
                                                  ├────┼─────────────────────────┤
                                                  │ Q1 │ Constant Q1 of type int │
                                                  └────┴─────────────────────────┘

                     Attributes Documentation

                     Q0:int=Q0
                            Constant Q0 of type intQ1:int=Q1
                            Constant Q1 of type intpetsc4py.PETSc.DMDA.StencilTypeclasspetsc4py.PETSc.DMDA.StencilType
                     Bases: object

                     Stencil types.

                     Attributes Summary
                                                ┌──────┬───────────────────────────┐
                                                │ BOX  │ Constant BOX of type int  │
                                                ├──────┼───────────────────────────┤
                                                │ STAR │ Constant STAR of type int │
                                                └──────┴───────────────────────────┘

                     Attributes Documentation

                     BOX:int=BOX
                            Constant BOX of type intSTAR:int=STAR
                            Constant STAR of type int

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ create([dim, dof, sizes,  proc_sizes, │ Create a DMDA object.                 │
                      │ ...])                                 │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createNaturalVec()                    │ Create a vector that will hold values │
                      │                                       │ in the natural numbering.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ duplicate([dof, boundary_type, ...])  │ Duplicate a DMDA.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getAO()                               │ Return   the   application   ordering │
                      │                                       │ context for a distributed array.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBoundaryType()                     │ Return the type  of  ghost  nodes  at │
                      │                                       │ boundary in each dimension.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoordinateName(index)              │ Return   the  name  of  a  coordinate │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCorners()                          │ Return the lower left corner and  the │
                      │                                       │ sizes of the owned local region.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDim()                              │ Return the topological dimension.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDof()                              │ Return   the  number  of  degrees  of │
                      │                                       │ freedom per node.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getElementType()                      │ Return  the  element   type   to   be │
                      │                                       │ returned by getElements.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getElements([elem_type])              │ Return   an   array   containing  the │
                      │                                       │ indices of all the local elements.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFieldName(field)                   │ Return  the  name  of  an  individual │
                      │                                       │ field component.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getGhostCorners()                     │ Return  the lower left corner and the │
                      │                                       │ size of the ghosted local region.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getGhostRanges()                      │ Return the ranges of the local region │
                      │                                       │ in each  dimension,  including  ghost │
                      │                                       │ nodes.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getInterpolationType()                │ Return the type of interpolation.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipRanges()                  │ Return  the ranges of indices in each │
                      │                                       │ dimension owned by each process.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getProcSizes()                        │ Return the  number  of  processes  in │
                      │                                       │ each dimension.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRanges()                           │ Return  the ranges of the owned local │
                      │                                       │ region in each dimension.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRefinementFactor()                 │ Return the ratios that the DMDA  grid │
                      │                                       │ is refined in each dimension.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getScatter()                          │ Return   the   global-to-local,   and │
                      │                                       │ local-to-local scatter contexts.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSizes()                            │ Return the number of grid  points  in │
                      │                                       │ each dimension.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStencil()                          │ Return the stencil type and width.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStencilType()                      │ Return the stencil type.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStencilWidth()                     │ Return the stencil width.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getVecArray(vec[, readonly])          │ Get  access to the vector as laid out │
                      │                                       │ on a N-d grid.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ globalToNatural(vg, vn[, addv])       │ Map  values  to  the  "natural"  grid │
                      │                                       │ ordering.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ naturalToGlobal(vn, vg[, addv])       │ Map values the to grid ordering.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBoundaryType(boundary_type)        │ Set the type of ghost nodes on domain │
                      │                                       │ boundaries.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCoordinateName(index, name)        │ Set   the   name  of  the  coordinate │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDim(dim)                           │ Set the topological dimension.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDof(dof)                           │ Set the number of degrees of  freedom │
                      │                                       │ per vertex.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setElementType(elem_type)             │ Set  the  element type to be returned │
                      │                                       │ by getElements.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFieldName(field, name)             │ Set  the  name  of  individual  field │
                      │                                       │ components.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setInterpolationType(interp_type)     │ Set the type of interpolation.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setProcSizes(proc_sizes)              │ Set  the  number of processes in each │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRefinementFactor([refine_x,        │ Set the  ratios  for  the  DMDA  grid │
                      │ refine_y, ...])                       │ refinement.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSizes(sizes)                       │ Set the number of grid points in each │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStencil(stencil_type,              │ Set the stencil type and width.       │
                      │ stencil_width)                        │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStencilType(stencil_type)          │ Set the stencil type.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStencilWidth(stencil_width)        │ Set the stencil width.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUniformCoordinates([xmin,    xmax, │ Set the  DMDA  coordinates  to  be  a │
                      │ ymin, ...])                           │ uniform grid.                         │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                  ┌───────────────┬───────────────────────────────────────┐
                                  │ boundary_type │ Boundary types in each dimension.     │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ corners       │ The  lower  left  corner  and size of │
                                  │               │ local region in each dimension.       │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ dim           │ The grid dimension.                   │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ dof           │ The number of  DOFs  associated  with │
                                  │               │ each stratum of the grid.             │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ ghost_corners │ The  lower  left  corner  and size of │
                                  │               │ local region in each dimension.       │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ ghost_ranges  │ Ranges  of  local  region,  including │
                                  │               │ ghost nodes.                          │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ proc_sizes    │ The   number  of  processes  in  each │
                                  │               │ dimension     in      the      global │
                                  │               │ decomposition.                        │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ ranges        │ Ranges  of  the  local region in each │
                                  │               │ dimension.                            │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ sizes         │ The global dimension.                 │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ stencil       │ Stencil type and width.               │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ stencil_type  │ Stencil type.                         │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ stencil_width │ Elementwise stencil width.            │
                                  └───────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(dim=None,dof=None,sizes=None,proc_sizes=None,boundary_type=None,stencil_type=None,stencil_width=None,setup=True,ownership_ranges=None,comm=None)
                     Create a DMDA object.

                     Collective.

                     This  routine  performs  the  following  steps  of  the  C  API:   -   petsc.DMDACreate   -
                     petsc.DMSetDimension  -  petsc.DMDASetDof  -  petsc.DMDASetSizes  - petsc.DMDASetNumProcs -
                     petsc.DMDASetOwnershipRanges  -  petsc.DMDASetBoundaryType  -  petsc.DMDASetStencilType   -
                     petsc.DMDASetStencilWidth - petsc.DMSetUp (optionally)

                     Parameters

                            • dim (int|None) -- The number of dimensions.

                            • dof (int|None) -- The number of degrees of freedom.

                            • sizes (DimsSpec|None) -- The number of elements in each dimension.

                            • proc_sizes (DimsSpec|None) -- The number of processes in x, y, z dimensions.

                            • boundary_type  (tuple[DM.BoundaryType|int|str|bool,...]|None) -- The
                              boundary types.

                            • stencil_type (StencilType|None) -- The ghost/halo stencil type.

                            • stencil_width (int|None) -- The width of the ghost/halo region.

                            • setup (bool) -- Whether to call the setup routine after creating the object.

                            • ownership_ranges (tuple[Sequence[int],...]|None)  --  Local  x,  y,  z  element
                              counts, of length equal to proc_sizes, summing to sizes.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:DMDACreate,     DMSetDimension,    DMDASetDof,    DMDASetSizes,    DMDASetNumProcs,    ‐
                        DMDASetOwnershipRanges, DMDASetBoundaryType, DMDASetStencilType, DMDASetStencilWidth,  ‐
                        DMSetUpSourcecodeatpetsc4py/PETSc/DMDA.pyx:32createNaturalVec()
                     Create a vector that will hold values in the natural numbering.

                     Collective.

                     The  number  of  local  entries  in  the  vector on each process is the same as in a vector
                     created with DM.createGlobalVec.

                     SEEALSO:DMDACreateNaturalVectorSourcecodeatpetsc4py/PETSc/DMDA.pyx:832ReturntypeVecduplicate(dof=None,boundary_type=None,stencil_type=None,stencil_width=None)
                     Duplicate a DMDA.

                     Collective.

                     This routine retrieves the information from the DMDA and  recreates  it.   Parameters  dof,
                     boundary_type, stencil_type, stencil_width will be overwritten, if provided.

                     Parameters

                            • dof (int|None) -- The number of degrees of freedom.

                            • boundary_type  (tuple[DM.BoundaryType|int|str|bool,...]|None) -- Boundary
                              types.

                            • stencil_type (StencilType|None) -- The ghost/halo stencil type.

                            • stencil_width (int|None) -- The width of the ghost/halo region.

                     ReturntypeDMDASEEALSO:create, DMDAGetInfo, DMSetUpSourcecodeatpetsc4py/PETSc/DMDA.pyx:148getAO()
                     Return the application ordering context for a distributed array.

                     Collective.

                     The returned AO maps to the natural grid ordering that would be used for the DMDA if only 1
                     processor were employed (ordering most  rapidly  in  the  x-dimension,  then  y,  then  z).
                     Multiple  degrees  of  freedom  are numbered for each node (rather than 1 component for the
                     whole grid, then the next component, etc.).

                     SEEALSO:DMDAGetAOSourcecodeatpetsc4py/PETSc/DMDA.pyx:909ReturntypeAOgetBoundaryType()
                     Return the type of ghost nodes at boundary in each dimension.

                     Not collective.

                     SEEALSO:setBoundaryTypeSourcecodeatpetsc4py/PETSc/DMDA.pyx:407Returntypetuple[BoundaryType, ...]

              getCoordinateName(index)
                     Return the name of a coordinate dimension.

                     Not collective.

                     Parametersindex (int) -- The coordinate number for the DMDA (0, 1, ..., dim-1).

                     ReturntypestrSEEALSO:setCoordinateName, DMDAGetCoordinateNameSourcecodeatpetsc4py/PETSc/DMDA.pyx:810getCorners()
                     Return the lower left corner and the sizes of the owned local region.

                     Not collective.

                     Returns the global (x,y,z) indices of the lower left corner (first tuple) and size  of  the
                     local region (second tuple).

                     Excluding ghost points.

                     The  corner  information  is independent of the number of degrees of freedom per node. Thus
                     the returned values can be thought of as coordinates on a logical  grid,  where  each  grid
                     point has (potentially) several degrees of freedom.

                     SEEALSO:getRanges, getGhostRanges, getOwnershipRanges, getGhostCorners, DMDAGetCornersSourcecodeatpetsc4py/PETSc/DMDA.pyx:622Returntypetuple[tuple[int, ...], tuple[int, ...]]

              getDim()
                     Return the topological dimension.

                     Not collective.

                     SEEALSO:setDim, DMGetDimensionSourcecodeatpetsc4py/PETSc/DMDA.pyx:234ReturntypeintgetDof()
                     Return the number of degrees of freedom per node.

                     Not collective.

                     SEEALSO:setDof, DMDAGetInfoSourcecodeatpetsc4py/PETSc/DMDA.pyx:264ReturntypeintgetElementType()
                     Return the element type to be returned by getElements.

                     Not collective.

                     SEEALSO:setElementType, DMDAGetElementTypeSourcecodeatpetsc4py/PETSc/DMDA.pyx:1050ReturntypeElementTypegetElements(elem_type=None)
                     Return an array containing the indices of all the local elements.

                     Not collective.

                     The elements are in local coordinates.

                     Each process uniquely owns a subset of the elements. That is, no element is owned by two or
                     more processes.

                     Parameterselem_type (ElementType|None) -- The element type.

                     ReturntypeArrayIntSEEALSO:DMDAGetElementsSourcecodeatpetsc4py/PETSc/DMDA.pyx:1064getFieldName(field)
                     Return the name of an individual field component.

                     Not collective.

                     Parametersfield (int) -- The field number for the DMDA (0, 1, ..., dof-1), where dof indicates
                            the number of degrees of freedom per node within the DMDA.

                     ReturntypestrSEEALSO:setFieldName, DMDAGetFieldNameSourcecodeatpetsc4py/PETSc/DMDA.pyx:699getGhostCorners()
                     Return the lower left corner and the size of the ghosted local region.

                     Not collective.

                     Returns  the  global (x,y,z) indices of the lower left corner (first tuple) and size of the
                     local region (second tuple).

                     SEEALSO:getRanges, getGhostRanges, getOwnershipRanges, getCorners, DMDAGetGhostCornersSourcecodeatpetsc4py/PETSc/DMDA.pyx:651Returntypetuple[tuple[int, ...], tuple[int, ...]]

              getGhostRanges()
                     Return the ranges of the local region in each dimension, including ghost nodes.

                     Not collective.

                     SEEALSO:getRanges, getOwnershipRanges, getCorners, getGhostCorners, DMDAGetGhostCornersSourcecodeatpetsc4py/PETSc/DMDA.pyx:577Returntypetuple[tuple[int, int], ...]

              getInterpolationType()
                     Return the type of interpolation.

                     Not collective.

                     SEEALSO:setInterpolationType, DMDAGetInterpolationTypeSourcecodeatpetsc4py/PETSc/DMDA.pyx:1020ReturntypeInterpolationTypegetOwnershipRanges()
                     Return the ranges of indices in each dimension owned by each process.

                     Not collective.

                     These numbers are not multiplied by the number of DOFs per node.

                     SEEALSO:getRanges, getGhostRanges, getCorners, getGhostCorners, DMDAGetOwnershipRangesSourcecodeatpetsc4py/PETSc/DMDA.pyx:597Returntypetuple[ArrayInt, ...]

              getProcSizes()
                     Return the number of processes in each dimension.

                     Not collective.

                     SEEALSO:setProcSizes, DMDAGetInfoSourcecodeatpetsc4py/PETSc/DMDA.pyx:361Returntypetuple[int, ...]

              getRanges()
                     Return the ranges of the owned local region in each dimension.

                     Not collective.

                     Excluding ghost nodes.

                     SEEALSO:getGhostRanges, getOwnershipRanges, getCorners, getGhostCorners, DMDAGetCornersSourcecodeatpetsc4py/PETSc/DMDA.pyx:555Returntypetuple[tuple[int, int], ...]

              getRefinementFactor()
                     Return the ratios that the DMDA grid is refined in each dimension.

                     Not collective.

                     SEEALSO:setRefinementFactor, DMDAGetRefinementFactorSourcecodeatpetsc4py/PETSc/DMDA.pyx:981Returntypetuple[int, ...]

              getScatter()
                     Return the global-to-local, and local-to-local scatter contexts.

                     Collective.

                     SEEALSO:DMDAGetScatterSourcecodeatpetsc4py/PETSc/DMDA.pyx:930Returntypetuple[Scatter, Scatter]

              getSizes()
                     Return the number of grid points in each dimension.

                     Not collective.

                     SEEALSO:setSizes, DMDAGetInfoSourcecodeatpetsc4py/PETSc/DMDA.pyx:311Returntypetuple[int, ...]

              getStencil()
                     Return the stencil type and width.

                     Not collective.

                     SEEALSO:getStencilType, getStencilWidthSourcecodeatpetsc4py/PETSc/DMDA.pyx:532Returntypetuple[StencilType, int]

              getStencilType()
                     Return the stencil type.

                     Not collective.

                     SEEALSO:setStencilType, DMDAGetInfoSourcecodeatpetsc4py/PETSc/DMDA.pyx:448ReturntypeStencilTypegetStencilWidth()
                     Return the stencil width.

                     Not collective.

                     SEEALSO:setStencilWidthSourcecodeatpetsc4py/PETSc/DMDA.pyx:486ReturntypeintgetVecArray(vec,readonly=False)
                     Get access to the vector as laid out on a N-d grid.

                     Logically collective.

                     Parameters

                            • vec (Vec) -- The vector to which access is being requested.

                            • readonly (bool) -- Request read-only access.

                     ReturntypeAnySEEALSO:Vec.getArray, DMDAVecGetArray, DMDAVecGetArrayDOFSourcecodeatpetsc4py/PETSc/DMDA.pyx:723globalToNatural(vg,vn,addv=None)
                     Map values to the "natural" grid ordering.

                     Neighborwise collective.

                     You must call createNaturalVec before using this routine.

                     Parameters

                            • vg (Vec) -- The global vector in a grid ordering.

                            • vn (Vec) -- The global vector in a "natural" ordering.

                            • addv (InsertMode|None) -- The insertion mode.

                     ReturntypeNoneSEEALSO:naturalToGlobal, DMDAGlobalToNaturalBegin, DMDAGlobalToNaturalEndSourcecodeatpetsc4py/PETSc/DMDA.pyx:849naturalToGlobal(vn,vg,addv=None)
                     Map values the to grid ordering.

                     Neighborwise collective.

                     Parameters

                            • vn (Vec) -- The global vector in a natural ordering.

                            • vg (Vec) -- the global vector in a grid ordering.

                            • addv (InsertMode|None) -- The insertion mode.

                     ReturntypeNoneSEEALSO:globalToNatural, DMDANaturalToGlobalBegin, DMDANaturalToGlobalEndSourcecodeatpetsc4py/PETSc/DMDA.pyx:879setBoundaryType(boundary_type)
                     Set the type of ghost nodes on domain boundaries.

                     Not collective.

                     Parametersboundary_type (tuple[BoundaryType|int|str|bool,...]) -- The boundary type  in
                            (x), (x, y), or (x, y, z) dimensions.

                     ReturntypeNoneSEEALSO:getBoundaryType, DMDASetBoundaryTypeSourcecodeatpetsc4py/PETSc/DMDA.pyx:384setCoordinateName(index,name)
                     Set the name of the coordinate dimension.

                     Logically collective.

                     Parameters

                            • index (int) -- The coordinate number for the DMDA (0, 1, ..., dim-1).

                            • name (str) -- The name of the coordinate.

                     ReturntypeNoneSEEALSO:getCoordinateName, DMDASetCoordinateNameSourcecodeatpetsc4py/PETSc/DMDA.pyx:788setDim(dim)
                     Set the topological dimension.

                     Collective.

                     Parametersdim (int) -- Topological dimension.

                     ReturntypeNoneSEEALSO:getDim, DMSetDimensionSourcecodeatpetsc4py/PETSc/DMDA.pyx:217setDof(dof)
                     Set the number of degrees of freedom per vertex.

                     Not collective.

                     Parametersdof (int) -- The number of degrees of freedom.

                     ReturntypeNoneSEEALSO:getDof, DMDASetDofSourcecodeatpetsc4py/PETSc/DMDA.pyx:246setElementType(elem_type)
                     Set the element type to be returned by getElements.

                     Not collective.

                     SEEALSO:getElementType, DMDASetElementTypeSourcecodeatpetsc4py/PETSc/DMDA.pyx:1036Parameterselem_type (ElementType|str)

                     ReturntypeNonesetFieldName(field,name)
                     Set the name of individual field components.

                     Logically collective.

                     Parameters

                            • field  (int)  --  The  field  number  for  the  DMDA (0, 1, ..., dof-1), where dof
                              indicates the number of degrees of freedom per node within the DMDA.

                            • name (str) -- The name of the field (component).

                     ReturntypeNoneSEEALSO:getFieldName, DMDASetFieldNameSourcecodeatpetsc4py/PETSc/DMDA.pyx:675setInterpolationType(interp_type)
                     Set the type of interpolation.

                     Logically collective.

                     You should call this on the coarser of the two DMDAs you pass to DM.createInterpolation.

                     Parametersinterp_type (InterpolationType) -- The interpolation type.

                     ReturntypeNoneSEEALSO:getInterpolationType, DMDASetInterpolationTypeSourcecodeatpetsc4py/PETSc/DMDA.pyx:999setProcSizes(proc_sizes)
                     Set the number of processes in each dimension.

                     Logically collective.

                     Parametersproc_sizes (DimsSpec) -- The number of processes in (x,),  (x,  y),  or  (x,  y,  z)
                            dimensions.

                     ReturntypeNoneSEEALSO:getProcSizes, DMDASetNumProcsSourcecodeatpetsc4py/PETSc/DMDA.pyx:334setRefinementFactor(refine_x=2,refine_y=2,refine_z=2)
                     Set the ratios for the DMDA grid refinement.

                     Logically collective.

                     Parameters

                            • refine_x (int) -- Ratio of fine grid to coarse in x dimension.

                            • refine_y (int) -- Ratio of fine grid to coarse in y dimension.

                            • refine_z (int) -- Ratio of fine grid to coarse in z dimension.

                     ReturntypeNoneSEEALSO:getRefinementFactor, DMDASetRefinementFactorSourcecodeatpetsc4py/PETSc/DMDA.pyx:949setSizes(sizes)
                     Set the number of grid points in each dimension.

                     Logically collective.

                     Parameterssizes (DimsSpec) -- The global (x,), (x, y), or (x, y, z) size.

                     ReturntypeNoneSEEALSO:getSizes, DMDASetSizesSourcecodeatpetsc4py/PETSc/DMDA.pyx:284setStencil(stencil_type,stencil_width)
                     Set the stencil type and width.

                     Not collective.

                     Parameters

                            • stencil_type (StencilType) -- The stencil type.

                            • stencil_width (int) -- The stencil width.

                     ReturntypeNoneSEEALSO:setStencilWidth, setStencilType, DMDASetStencilType, DMDASetStencilWidthSourcecodeatpetsc4py/PETSc/DMDA.pyx:506setStencilType(stencil_type)
                     Set the stencil type.

                     Logically collective.

                     Parameters

                            • stype -- The stencil type.

                            • stencil_type (StencilType)

                     ReturntypeNoneSEEALSO:getStencilType, setStencil, DMDASetStencilTypeSourcecodeatpetsc4py/PETSc/DMDA.pyx:430setStencilWidth(stencil_width)
                     Set the stencil width.

                     Logically collective.

                     Parametersstencil_width (int) -- The stencil width.

                     ReturntypeNoneSEEALSO:getStencilWidth, setStencil, DMDASetStencilWidthSourcecodeatpetsc4py/PETSc/DMDA.pyx:468setUniformCoordinates(xmin=0,xmax=1,ymin=0,ymax=1,zmin=0,zmax=1)
                     Set the DMDA coordinates to be a uniform grid.

                     Collective.

                     Parameters

                            • xmin (float) -- The minimum in the x dimension.

                            • xmax (float) -- The maximum in the x dimension.

                            • ymin  (float)  --  The minimum in the y dimension (value ignored for 1 dimensional
                              problems).

                            • ymax (float) -- The maximum in the y dimension (value ignored  for  1  dimensional
                              problems).

                            • zmin  (float)  --  The  minimum  in  the  z  dimension  (value  ignored for 1 or 2
                              dimensional problems).

                            • zmax (float) -- The maximum  in  the  z  dimension  (value  ignored  for  1  or  2
                              dimensional problems).

                     ReturntypeNoneSEEALSO:DMDASetUniformCoordinatesSourcecodeatpetsc4py/PETSc/DMDA.pyx:744

              Attributes Documentation

              boundary_type
                     Boundary types in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1123corners
                     The lower left corner and size of local region in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1153dim    The grid dimension.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1103dof    The number of DOFs associated with each stratum of the grid.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1108ghost_corners
                     The lower left corner and size of local region in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1158ghost_ranges
                     Ranges of local region, including ghost nodes.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1148proc_sizes
                     The number of processes in each dimension in the global decomposition.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1118ranges Ranges of the local region in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1143sizes  The global dimension.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1113stencil
                     Stencil type and width.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1128stencil_type
                     Stencil type.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1133stencil_width
                     Elementwise stencil width.

                     Sourcecodeatpetsc4py/PETSc/DMDA.pyx:1138petsc4py.PETSc.DMInterpolationclasspetsc4py.PETSc.DMInterpolation
              Bases: object

              Interpolation on a mesh.

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ create([comm])                        │ Create a DMInterpolation context.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the DMInterpolation context.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ evaluate(dm, x[, v])                  │ Calculate  interpolated  field values │
                      │                                       │ at the interpolation points.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCoordinates()                      │ Return  the   coordinates   of   each │
                      │                                       │ interpolation point.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDim()                              │ Return  the  spatial dimension of the │
                      │                                       │ interpolation context.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDof()                              │ Return   the   number    of    fields │
                      │                                       │ interpolated at a point.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getVector()                           │ Return  a  Vec which can hold all the │
                      │                                       │ interpolated field values.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreVector(vec)                    │ Restore a Vec which can hold all  the │
                      │                                       │ interpolated field values.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDim(dim)                           │ Set  the  spatial  dimension  for the │
                      │                                       │ interpolation context.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDof(dof)                           │ Set the number of fields interpolated │
                      │                                       │ at a point.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp(dm[,           redundantPoints, │ Compute  spatial  indices  for  point │
                      │ ignoreOutsideDomain])                 │ location during interpolation.        │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Create a DMInterpolation context.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to COMM_SELF.

                     ReturntypeSelfSEEALSO:destroy, DMInterpolationCreateSourcecodeatpetsc4py/PETSc/DMUtils.pyx:13destroy()
                     Destroy the DMInterpolation context.

                     Collective.

                     SEEALSO:create, DMInterpolationDestroySourcecodeatpetsc4py/PETSc/DMUtils.pyx:35ReturntypeSelfevaluate(dm,x,v=None)
                     Calculate interpolated field values at the interpolation points.

                     Collective.

                     Parameters

                            • dm (DM) -- The DM.

                            • x (Vec) -- The local vector containing the field to be interpolated.

                            • v (Vec|None) -- A vector capable of holding the interpolated field values.

                     ReturntypeVecSEEALSO:DMInterpolationEvaluateSourcecodeatpetsc4py/PETSc/DMUtils.pyx:48getCoordinates()
                     Return the coordinates of each interpolation point.

                     Collective.

                     The local vector  entries  correspond  to  interpolation  points  lying  on  this  process,
                     according to the associated DM.

                     SEEALSO:DMInterpolationGetCoordinatesSourcecodeatpetsc4py/PETSc/DMUtils.pyx:74ReturntypeVecgetDim()
                     Return the spatial dimension of the interpolation context.

                     Not collective.

                     SEEALSO:setDim, DMInterpolationGetDimSourcecodeatpetsc4py/PETSc/DMUtils.pyx:92ReturntypeintgetDof()
                     Return the number of fields interpolated at a point.

                     Not collective.

                     SEEALSO:setDof, DMInterpolationGetDofSourcecodeatpetsc4py/PETSc/DMUtils.pyx:106ReturntypeintgetVector()
                     Return a Vec which can hold all the interpolated field values.

                     Collective.

                     This vector should be returned using restoreVector.

                     SEEALSO:restoreVector, DMInterpolationGetVectorSourcecodeatpetsc4py/PETSc/DMUtils.pyx:185ReturntypeVecrestoreVector(vec)
                     Restore a Vec which can hold all the interpolated field values.

                     Collective.

                     Parametersvec (Vec) -- A vector capable of holding the interpolated field values.

                     ReturntypeNoneSEEALSO:getVector, DMInterpolationRestoreVectorSourcecodeatpetsc4py/PETSc/DMUtils.pyx:201setDim(dim)
                     Set the spatial dimension for the interpolation context.

                     Not collective.

                     Parametersdim (int) -- The spatial dimension.

                     ReturntypeNoneSEEALSO:getDim, DMInterpolationSetDimSourcecodeatpetsc4py/PETSc/DMUtils.pyx:120setDof(dof)
                     Set the number of fields interpolated at a point.

                     Not collective.

                     Parametersdof (int) -- The number of fields.

                     ReturntypeNoneSEEALSO:getDof, DMInterpolationSetDofSourcecodeatpetsc4py/PETSc/DMUtils.pyx:138setUp(dm,redundantPoints=False,ignoreOutsideDomain=False)
                     Compute spatial indices for point location during interpolation.

                     Collective.

                     Parameters

                            • dm (DM) -- The DM for the function space used for interpolation.

                            • redundantPoints  (bool) -- If True, all processes are passing in the same array of
                              points.  Otherwise, points need to be communicated among processes.

                            • ignoreOutsideDomain (bool) --  Ignore  points  outside  of  the  domain  if  True;
                              otherwise, return an error.

                     ReturntypeNoneSEEALSO:DMInterpolationSetUpSourcecodeatpetsc4py/PETSc/DMUtils.pyx:156petsc4py.PETSc.DMLabelclasspetsc4py.PETSc.DMLabel
              Bases: Object

              An object representing a subset of mesh entities from a DM.

              Methods Summary
                          ┌───────────────────────────────┬───────────────────────────────────────┐
                          │ addStrata(strata)             │ Add new stratum values in a DMLabel.  │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ addStrataIS(iset)             │ Add new stratum values in a DMLabel.  │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ addStratum(value)             │ Add a new stratum value in a DMLabel. │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ clearStratum(stratum)         │ Remove a stratum.                     │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ clearValue(point, value)      │ Clear  the value a label assigns to a │
                          │                               │ point.                                │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ computeIndex()                │ Create   an   index   structure   for │
                          │                               │ membership determination.             │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ convertToSection()            │ Return  a  Section and IS that encode │
                          │                               │ the label.                            │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ create(name[, comm])          │ Create a DMLabel object, which  is  a │
                          │                               │ multimap.                             │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ createIndex(pStart, pEnd)     │ Create   an   index   structure   for │
                          │                               │ membership determination.             │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ destroy()                     │ Destroy the label.                    │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ destroyIndex()                │ Destroy the index structure.          │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ distribute(sf)                │ Create a  new  label  pushed  forward │
                          │                               │ over the SF.                          │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ duplicate()                   │ Duplicate the DMLabel.                │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ filter(start, end)            │ Remove  all points outside of [start, │
                          │                               │ end).                                 │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ gather(sf)                    │ Gather all label values  from  leaves │
                          │                               │ into roots.                           │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getBounds()                   │ Return the smallest and largest point │
                          │                               │ in the label.                         │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getDefaultValue()             │ Return  the default value returned by │
                          │                               │ getValue.                             │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getNonEmptyStratumValuesIS()  │ Return an IS of all values  that  the │
                          │                               │ DMLabel takes.                        │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getNumValues()                │ Return  the number of values that the │
                          │                               │ DMLabel takes.                        │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getStratumIS(stratum)         │ Return an IS with the stratum points. │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getStratumSize(stratum)       │ Return the size of a stratum.         │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getValue(point)               │ Return the value a label assigns to a │
                          │                               │ point.                                │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getValueIS()                  │ Return an IS of all values  that  the │
                          │                               │ DMLabel takes.                        │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ hasPoint(point)               │ Determine  whether the label contains │
                          │                               │ a point.                              │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ hasStratum(value)             │ Determine whether points  exist  with │
                          │                               │ the given value.                      │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ hasValue(value)               │ Determine whether a label assigns the │
                          │                               │ value to any point.                   │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ insertIS(iset, value)         │ Set all points in the IS to a value.  │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ permute(permutation)          │ Create  a  new  label  with  permuted │
                          │                               │ points.                               │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ reset()                       │ Destroy internal data  structures  in │
                          │                               │ the DMLabel.                          │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ setDefaultValue(value)        │ Set  the  default  value  returned by │
                          │                               │ getValue.                             │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ setStratumIS(stratum, iset)   │ Set the stratum points using an IS.   │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ setValue(point, value)        │ Set the value a label  assigns  to  a │
                          │                               │ point.                                │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ stratumHasPoint(value, point) │ Return whether the stratum contains a │
                          │                               │ point.                                │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ view([viewer])                │ View the label.                       │
                          └───────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              addStrata(strata)
                     Add new stratum values in a DMLabel.

                     Not collective.

                     Parametersstrata (Sequence[int]) -- The stratum values.

                     ReturntypeNoneSEEALSO:addStrataIS, addStratum, DMLabelAddStrataSourcecodeatpetsc4py/PETSc/DMLabel.pyx:238addStrataIS(iset)
                     Add new stratum values in a DMLabel.

                     Not collective.

                     Parametersiset (IS) -- Index set with stratum values.

                     ReturntypeNoneSEEALSO:addStrata, addStratum, DMLabelAddStrataISSourcecodeatpetsc4py/PETSc/DMLabel.pyx:258addStratum(value)
                     Add a new stratum value in a DMLabel.

                     Not collective.

                     Parametersvalue (int) -- The stratum value.

                     ReturntypeNoneSEEALSO:addStrata, addStrataIS, DMLabelAddStratumSourcecodeatpetsc4py/PETSc/DMLabel.pyx:220clearStratum(stratum)
                     Remove a stratum.

                     Not collective.

                     Parametersstratum (int) -- The stratum value.

                     ReturntypeNoneSEEALSO:DMLabelClearStratumSourcecodeatpetsc4py/PETSc/DMLabel.pyx:406clearValue(point,value)
                     Clear the value a label assigns to a point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • value (int) -- The point value.

                     ReturntypeNoneSEEALSO:DMLabelClearValueSourcecodeatpetsc4py/PETSc/DMLabel.pyx:199computeIndex()
                     Create an index structure for membership determination.

                     Not collective.

                     Automatically determines the bounds.

                     SEEALSO:DMLabelComputeIndexSourcecodeatpetsc4py/PETSc/DMLabel.pyx:424ReturntypeNoneconvertToSection()
                     Return a Section and IS that encode the label.

                     Not collective.

                     SEEALSO:DMLabelConvertToSectionSourcecodeatpetsc4py/PETSc/DMLabel.pyx:607Returntypetuple[Section, IS]

              create(name,comm=None)
                     Create a DMLabel object, which is a multimap.

                     Collective.

                     Parameters

                            • name (str) -- The label name.

                            • comm (Comm|None) -- MPI communicator, defaults to COMM_SELF.

                     ReturntypeSelfSEEALSO:DMLabelCreateSourcecodeatpetsc4py/PETSc/DMLabel.pyx:40createIndex(pStart,pEnd)
                     Create an index structure for membership determination.

                     Not collective.

                     Parameters

                            • pStart (int) -- The smallest point.

                            • pEnd (int) -- The largest point + 1.

                     ReturntypeNoneSEEALSO:destroyIndex, DMLabelCreateIndexSourcecodeatpetsc4py/PETSc/DMLabel.pyx:438destroy()
                     Destroy the label.

                     Collective.

                     SEEALSO:DMLabelDestroySourcecodeatpetsc4py/PETSc/DMLabel.pyx:8ReturntypeSelfdestroyIndex()
                     Destroy the index structure.

                     Not collective.

                     SEEALSO:createIndex, DMLabelDestroyIndexSourcecodeatpetsc4py/PETSc/DMLabel.pyx:458ReturntypeNonedistribute(sf)
                     Create a new label pushed forward over the SF.

                     Collective.

                     Parameterssf (SF) -- The map from old to new distribution.

                     ReturntypeDMLabelSEEALSO:gather, DMLabelDistributeSourcecodeatpetsc4py/PETSc/DMLabel.pyx:567duplicate()
                     Duplicate the DMLabel.

                     Collective.

                     SEEALSO:DMLabelDuplicateSourcecodeatpetsc4py/PETSc/DMLabel.pyx:65ReturntypeDMLabelfilter(start,end)
                     Remove all points outside of [start, end).

                     Not collective.

                     Parameters

                            • start (int) -- The first point kept.

                            • end (int) -- One more than the last point kept.

                     ReturntypeNoneSEEALSO:DMLabelFilterSourcecodeatpetsc4py/PETSc/DMLabel.pyx:528gather(sf)
                     Gather all label values from leaves into roots.

                     Collective.

                     This is the inverse operation to distribute.

                     Parameterssf (SF) -- The SF communication map.

                     ReturntypeDMLabelSEEALSO:distribute, DMLabelGatherSourcecodeatpetsc4py/PETSc/DMLabel.pyx:586getBounds()
                     Return the smallest and largest point in the label.

                     Not collective.

                     The returned values are the smallest point and the largest point + 1.

                     SEEALSO:DMLabelGetBoundsSourcecodeatpetsc4py/PETSc/DMLabel.pyx:512Returntypetuple[int, int]

              getDefaultValue()
                     Return the default value returned by getValue.

                     Not collective.

                     The  default  value  is  returned  if a point has not been explicitly given a value. When a
                     label is created, it is initialized to -1.

                     SEEALSO:setDefaultValue, DMLabelGetDefaultValueSourcecodeatpetsc4py/PETSc/DMLabel.pyx:161ReturntypeintgetNonEmptyStratumValuesIS()
                     Return an IS of all values that the DMLabel takes.

                     Not collective.

                     SEEALSO:DMLabelGetNonEmptyStratumValuesISSourcecodeatpetsc4py/PETSc/DMLabel.pyx:622ReturntypeISgetNumValues()
                     Return the number of values that the DMLabel takes.

                     Not collective.

                     SEEALSO:DMLabelGetNumValuesSourcecodeatpetsc4py/PETSc/DMLabel.pyx:275ReturntypeintgetStratumIS(stratum)
                     Return an IS with the stratum points.

                     Not collective.

                     Parametersstratum (int) -- The stratum value.

                     ReturntypeISSEEALSO:setStratumIS, DMLabelGetStratumISSourcecodeatpetsc4py/PETSc/DMLabel.pyx:366getStratumSize(stratum)
                     Return the size of a stratum.

                     Not collective.

                     Parametersstratum (int) -- The stratum value.

                     ReturntypeintSEEALSO:DMLabelGetStratumSizeSourcecodeatpetsc4py/PETSc/DMLabel.pyx:346getValue(point)
                     Return the value a label assigns to a point.

                     Not collective.

                     If no value was assigned, a default value will be returned The default value, initially -1,
                     can be changed with setDefaultValue.

                     Parameterspoint (int) -- The point.

                     ReturntypeintSEEALSO:setValue, setDefaultValue, DMLabelGetValueSourcecodeatpetsc4py/PETSc/DMLabel.pyx:137getValueIS()
                     Return an IS of all values that the DMLabel takes.

                     Not collective.

                     SEEALSO:DMLabelGetValueISSourcecodeatpetsc4py/PETSc/DMLabel.pyx:289ReturntypeIShasPoint(point)
                     Determine whether the label contains a point.

                     Not collective.

                     The user must call createIndex before this function.

                     Parameterspoint (int) -- The point.

                     ReturntypeboolSEEALSO:hasValue, DMLabelHasPointSourcecodeatpetsc4py/PETSc/DMLabel.pyx:490hasStratum(value)
                     Determine whether points exist with the given value.

                     Not collective.

                     Parametersvalue (int) -- The stratum value.

                     ReturntypeboolSEEALSO:DMLabelHasStratumSourcecodeatpetsc4py/PETSc/DMLabel.pyx:326hasValue(value)
                     Determine whether a label assigns the value to any point.

                     Not collective.

                     Parametersvalue (int) -- The value.

                     ReturntypeboolSEEALSO:hasPoint, DMLabelHasValueSourcecodeatpetsc4py/PETSc/DMLabel.pyx:470insertIS(iset,value)
                     Set all points in the IS to a value.

                     Not collective.

                     Parameters

                            • iset (IS) -- The point IS.

                            • value (int) -- The point value.

                     ReturntypeSelfSEEALSO:DMLabelInsertISSourcecodeatpetsc4py/PETSc/DMLabel.pyx:91permute(permutation)
                     Create a new label with permuted points.

                     Not collective.

                     Parameterspermutation (IS) -- The point permutation.

                     ReturntypeDMLabelSEEALSO:DMLabelPermuteSourcecodeatpetsc4py/PETSc/DMLabel.pyx:548reset()
                     Destroy internal data structures in the DMLabel.

                     Not collective.

                     SEEALSO:DMLabelResetSourcecodeatpetsc4py/PETSc/DMLabel.pyx:79ReturntypeNonesetDefaultValue(value)
                     Set the default value returned by getValue.

                     Not collective.

                     The value is used if a point has not been explicitly  given  a  value.   When  a  label  is
                     created, the default value is initialized to -1.

                     Parametersvalue (int) -- The default value.

                     ReturntypeNoneSEEALSO:getDefaultValue, DMLabelSetDefaultValueSourcecodeatpetsc4py/PETSc/DMLabel.pyx:178setStratumIS(stratum,iset)
                     Set the stratum points using an IS.

                     Not collective.

                     Parameters

                            • stratum (int) -- The stratum value.

                            • iset (IS) -- The stratum points.

                     ReturntypeNoneSEEALSO:getStratumIS, DMLabelSetStratumISSourcecodeatpetsc4py/PETSc/DMLabel.pyx:386setValue(point,value)
                     Set the value a label assigns to a point.

                     Not collective.

                     If  the  value  is the same as the label's default value (which is initially -1, and can be
                     changed with setDefaultValue), this function will do nothing.

                     Parameters

                            • point (int) -- The point.

                            • value (int) -- The point value.

                     ReturntypeNoneSEEALSO:getValue, setDefaultValue, DMLabelSetValueSourcecodeatpetsc4py/PETSc/DMLabel.pyx:112stratumHasPoint(value,point)
                     Return whether the stratum contains a point.

                     Not collective.

                     Parameters

                            • value (int) -- The stratum value.

                            • point (int) -- The point.

                     ReturntypeboolSEEALSO:DMLabelStratumHasPointSourcecodeatpetsc4py/PETSc/DMLabel.pyx:303view(viewer=None)
                     View the label.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the graph.

                     ReturntypeNoneSEEALSO:DMLabelViewSourcecodeatpetsc4py/PETSc/DMLabel.pyx:21petsc4py.PETSc.DMPlexclasspetsc4py.PETSc.DMPlex
              Bases: DM

              Encapsulate an unstructured mesh.

              DMPlex encapsulates both topology  and  geometry.   It  is  capable  of  parallel  refinement  and
              coarsening (using Pragmatic or ParMmg) and parallel redistribution for load balancing.

              Methods Summary
                   ┌─────────────────────────────────────────────┬───────────────────────────────────────┐
                   │ computeCellGeometryFVM(cell)                │ Compute the volume for a given cell.  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ computeGradientClementInterpolant(locX,     │ Return   the  L2  projection  of  the │
                   │ locC)                                       │ cellwise gradient of a function  onto │
                   │                                             │ P1.                                   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ constructGhostCells([labelName])            │ Construct  ghost  cells which connect │
                   │                                             │ to every boundary face.               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ coordinatesLoad(viewer, sfxc)               │ Load  coordinates  into  this  DMPlex │
                   │                                             │ object.                               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ coordinatesView(viewer)                     │ Save DMPlex coordinates into a file.  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ create([comm])                              │ Create   a   DMPlex   object,   which │
                   │                                             │ encapsulates an unstructured mesh.    │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createBoxMesh(faces[,   lower,   upper,     │ Create  a  mesh on the tensor product │
                   │ ...])                                       │ of intervals.                         │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createBoxSurfaceMesh(faces[,     lower,     │ Create a mesh on the surface of a box │
                   │ upper, ...])                                │ mesh using tensor cells.              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createCGNS(cgid[, interpolate, comm])       │ Create  a  DMPlex  mesh  from  a CGNS │
                   │                                             │ file.                                 │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createCGNSFromFile(filename[,               │ "Create a DMPlex  mesh  from  a  CGNS │
                   │ interpolate, comm])                         │ file.                                 │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createClosureIndex(sec)                     │ Calculate  an  index  for sec for the │
                   │                                             │ closure operation.                    │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createCoarsePointIS()                       │ Create  an  IS  covering  the  coarse │
                   │                                             │ DMPlex  chart with the fine points as │
                   │                                             │ data.                                 │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createCohesiveSubmesh(hasLagrange,          │ Extract the hypersurface  defined  by │
                   │ value)                                      │ one face of the cohesive cells.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createExodus(exoid[,       interpolate,     │ Create a DMPlex mesh from an ExodusII │
                   │ comm])                                      │ file ID.                              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createExodusFromFile(filename[, ...])       │ Create a DMPlex mesh from an ExodusII │
                   │                                             │ file.                                 │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createFromCellList(dim, cells, coords[,     │ Create  a  DMPlex  from  a  list   of │
                   │ ...])                                       │ vertices for each cell on process 0.  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createFromFile(filename[,     plexname,     │ Create DMPlex from a file.            │
                   │ ...])                                       │                                       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createGmsh(viewer[, interpolate, comm])     │ Create a DMPlex mesh from a Gmsh file │
                   │                                             │ viewer.                               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createPointNumbering()                      │ Create a  global  numbering  for  all │
                   │                                             │ points.                               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ createSection(numComp,         numDof[,     │ Create a Section based upon  the  DOF │
                   │ bcField, ...])                              │ layout specification provided.        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ distribute([overlap])                       │ Distribute    the    mesh   and   any │
                   │                                             │ associated sections.                  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ distributeField(sf, sec, vec[,  newsec,     │ Distribute  field  data with a with a │
                   │ newvec])                                    │ given SF.                             │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ distributeGetDefault()                      │ Return a flag indicating whether  the │
                   │                                             │ DM should be distributed by default.  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ distributeOverlap([overlap])                │ Add    partition    overlap    to   a │
                   │                                             │ distributed non-overlapping DMPlex.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ distributeSetDefault(flag)                  │ Set  flag  indicating   whether   the │
                   │                                             │ DMPlex   should   be  distributed  by │
                   │                                             │ default.                              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ distributionGetName()                       │ Retrieve the  name  of  the  specific │
                   │                                             │ parallel distribution.                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ distributionSetName(name)                   │ Set the name of the specific parallel │
                   │                                             │ distribution.                         │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ generate(boundary[, name, interpolate])     │ Generate a mesh.                      │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getAdjacency(p)                             │ Return  all  points  adjacent  to the │
                   │                                             │ given point.                          │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getAdjacencyUseAnchors()                    │ Query whether adjacency in  the  mesh │
                   │                                             │ uses the point-to-point constraints.  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getCellNumbering()                          │ Return  a  global  cell numbering for │
                   │                                             │ all cells on this process.            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getCellType(p)                              │ Return the polytope type of  a  given │
                   │                                             │ cell.                                 │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getCellTypeLabel()                          │ Return   the  DMLabel  recording  the │
                   │                                             │ polytope type of each cell.           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getChart()                                  │ Return  the  interval  for  all  mesh │
                   │                                             │ points [pStart, pEnd).                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getCone(p)                                  │ Return the points on the in-edges for │
                   │                                             │ this point in the DAG.                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getConeOrientation(p)                       │ Return   the   orientations   on  the │
                   │                                             │ in-edges for this point in the DAG.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getConeSize(p)                              │ Return the  number  of  in-edges  for │
                   │                                             │ this point in the DAG.                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getDepth()                                  │ Return   the   depth   of   the   DAG │
                   │                                             │ representing this mesh.               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getDepthStratum(svalue)                     │ Return the bounds  [start,  end)  for │
                   │                                             │ all points at a certain depth.        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getFullJoin(points)                         │ Return  an  array for the join of the │
                   │                                             │ set of points.                        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getHeightStratum(svalue)                    │ Return the bounds  [start,  end)  for │
                   │                                             │ all points at a certain height.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getJoin(points)                             │ Return  an  array for the join of the │
                   │                                             │ set of points.                        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getMaxSizes()                               │ Return the maximum number of in-edges │
                   │                                             │ and out-edges of the DAG.             │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getMeet(points)                             │ Return an array for the meet  of  the │
                   │                                             │ set of points.                        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getMinRadius()                              │ Return  the minimum distance from any │
                   │                                             │ cell centroid to a face.              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getOrdering(otype)                          │ Calculate a reordering of the mesh.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getPartitioner()                            │ Return the mesh partitioner.          │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getPointDepth(point)                        │ Return the depth of a given point.    │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getPointGlobal(point)                       │ Return  location  of  point  data  in │
                   │                                             │ global Vec.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getPointGlobalField(point, field)           │ Return  location  of point field data │
                   │                                             │ in global Vec.                        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getPointHeight(point)                       │ Return the height of a given point.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getPointLocal(point)                        │ Return  location  of  point  data  in │
                   │                                             │ local Vec.                            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getPointLocalField(point, field)            │ Return  location  of point field data │
                   │                                             │ in local Vec.                         │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getRefinementLimit()                        │ Retrieve the maximum cell volume  for │
                   │                                             │ refinement.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getRefinementUniform()                      │ Retrieve   the   flag   for   uniform │
                   │                                             │ refinement.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getSubpointIS()                             │ Return  an  IS  covering  the  entire │
                   │                                             │ subdm chart.                          │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getSubpointMap()                            │ Return a DMLabel with point dimension │
                   │                                             │ as values.                            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getSupport(p)                               │ Return  the  points  on the out-edges │
                   │                                             │ for this point in the DAG.            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getSupportSize(p)                           │ Return the number  of  out-edges  for │
                   │                                             │ this point in the DAG.                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getTransitiveClosure(p[, useCone])          │ Return the points and orientations on │
                   │                                             │ the transitive closure of this point. │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getVecClosure(sec, vec, point)              │ Return  an array of the values on the │
                   │                                             │ closure of a point.                   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ getVertexNumbering()                        │ Return a global vertex numbering  for │
                   │                                             │ all vertices on this process.         │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ globalVectorLoad(viewer, sectiondm, sf,     │ Load   on-disk  vector  data  into  a │
                   │ vec)                                        │ global vector.                        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ globalVectorView(viewer,     sectiondm,     │ Save a global vector.                 │
                   │ vec)                                        │                                       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ insertCone(p, conePos, conePoint)           │ DMPlexInsertCone  -  Insert  a  point │
                   │                                             │ into the in-edges for the point p  in │
                   │                                             │ the DAG.                              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ insertConeOrientation(p, conePos, ...)      │ Insert  a  point  orientation for the │
                   │                                             │ in-edge for the point p in the DAG.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ interpolate()                               │ Convert   to   a   mesh   with    all │
                   │                                             │ intermediate faces, edges, etc.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ isDistributed()                             │ Return  the  flag  indicating  if the │
                   │                                             │ mesh is distributed.                  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ isSimplex()                                 │ Return the  flag  indicating  if  the │
                   │                                             │ first cell is a simplex.              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ labelCohesiveComplete(label,   bdlabel,     │ Add all other mesh pieces to complete │
                   │ ...)                                        │ the surface.                          │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ labelComplete(label)                        │ Add the  transitive  closure  to  the │
                   │                                             │ surface.                              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ labelsLoad(viewer, sfxc)                    │ Load labels into this DMPlex object.  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ labelsView(viewer)                          │ Save DMPlex labels into a file.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ localVectorLoad(viewer,  sectiondm, sf,     │ Load on-disk vector data into a local │
                   │ vec)                                        │ vector.                               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ localVectorView(viewer, sectiondm, vec)     │ Save a local vector.                  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ markBoundaryFaces(label[, value])           │ Mark all faces on the boundary.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricAverage2(metric1,        metric2,     │ Compute  and  return  the  unweighted │
                   │ metricAvg)                                  │ average of two metrics.               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricAverage3(metric1,        metric2,     │ Compute  and  return  the  unweighted │
                   │ metric3, ...)                               │ average of three metrics.             │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricCreate([field])                       │ Create a Riemannian metric field.     │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricCreateIsotropic(indicator[,           │ Construct an isotropic metric from an │
                   │ field])                                     │ error indicator.                      │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricCreateUniform(alpha[, field])         │ Construct a uniform isotropic metric. │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricDeterminantCreate([field])            │ Create the determinant  field  for  a │
                   │                                             │ Riemannian metric.                    │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricEnforceSPD(metric,       ometric,     │ Enforce                     symmetric │
                   │ determinant)                                │ positive-definiteness of a metric.    │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetGradationFactor()                  │ Return the metric gradation factor.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetHausdorffNumber()                  │ Return the metric Hausdorff number.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetMaximumAnisotropy()                │ Return  the  maximum tolerated metric │
                   │                                             │ anisotropy.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetMaximumMagnitude()                 │ Return the maximum  tolerated  metric │
                   │                                             │ magnitude.                            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetMinimumMagnitude()                 │ Return  the  minimum tolerated metric │
                   │                                             │ magnitude.                            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetNormalizationOrder()               │ Return   the   order   p   for    L-p │
                   │                                             │ normalization.                        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetNumIterations()                    │ Return   the   number   of   parallel │
                   │                                             │ adaptation iterations.                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetTargetComplexity()                 │ Return the target metric complexity.  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricGetVerbosity()                        │ Return  the  verbosity  of  the  mesh │
                   │                                             │ adaptation package.                   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricIntersection2(metric1,   metric2,     │ Compute and return  the  intersection │
                   │ metricInt)                                  │ of two metrics.                       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricIntersection3(metric1,   metric2,     │ Compute  the  intersection  of  three │
                   │ ...)                                        │ metrics.                              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricIsIsotropic()                         │ Return  the  flag  indicating whether │
                   │                                             │ the metric is isotropic or not.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricIsUniform()                           │ Return the  flag  indicating  whether │
                   │                                             │ the metric is uniform or not.         │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricNoInsertion()                         │ Return  the  flag  indicating whether │
                   │                                             │ node  insertion  and   deletion   are │
                   │                                             │ turned off.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricNoMovement()                          │ Return  the  flag  indicating whether │
                   │                                             │ node movement is turned off.          │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricNoSurf()                              │ Return the  flag  indicating  whether │
                   │                                             │ surface modification is turned off.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricNoSwapping()                          │ Return  the  flag  indicating whether │
                   │                                             │ facet swapping is turned off.         │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricNormalize(metric,        ometric,     │ Apply L-p normalization to a metric.  │
                   │ determinant)                                │                                       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricRestrictAnisotropyFirst()             │ Return    true   if   anisotropy   is │
                   │                                             │ restricted before normalization.      │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetFromOptions()                      │ Configure the object from the options │
                   │                                             │ database.                             │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetGradationFactor(beta)              │ Set the metric gradation factor.      │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetHausdorffNumber(hausd)             │ Set the metric Hausdorff number.      │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetIsotropic(isotropic)               │ Record   whether   the   metric    is │
                   │                                             │ isotropic or not.                     │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetMaximumAnisotropy(a_max)           │ Set   the  maximum  tolerated  metric │
                   │                                             │ anisotropy.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetMaximumMagnitude(h_max)            │ Set  the  maximum  tolerated   metric │
                   │                                             │ magnitude.                            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetMinimumMagnitude(h_min)            │ Set   the  minimum  tolerated  metric │
                   │                                             │ magnitude.                            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetNoInsertion(noInsert)              │ Set the flag indicating whether  node │
                   │                                             │ insertion should be turned off.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetNoMovement(noMove)                 │ Set  the flag indicating whether node │
                   │                                             │ movement should be turned off.        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetNoSurf(noSurf)                     │ Set  the  flag   indicating   whether │
                   │                                             │ surface modification should be turned │
                   │                                             │ off.                                  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetNoSwapping(noSwap)                 │ Set the flag indicating whether facet │
                   │                                             │ swapping should be turned off.        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetNormalizationOrder(p)              │ Set    the    order    p    for   L-p │
                   │                                             │ normalization.                        │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetNumIterations(numIter)             │ Set the number of parallel adaptation │
                   │                                             │ iterations.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetRestrictAnisotropyFirst(...)       │ Record  whether  anisotropy   is   be │
                   │                                             │ restricted  before  normalization  or │
                   │                                             │ after.                                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetTargetComplexity(targetComplexity) │ Set the target metric complexity.     │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetUniform(uniform)                   │ Record whether the metric is  uniform │
                   │                                             │ or not.                               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ metricSetVerbosity(verbosity)               │ Set   the   verbosity   of  the  mesh │
                   │                                             │ adaptation package.                   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ orient()                                    │ Give a consistent orientation to  the │
                   │                                             │ input mesh.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ permute(perm)                               │ Reorder  the  mesh  according  to the │
                   │                                             │ input permutation.                    │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ rebalanceSharedPoints([entityDepth, ...])   │ Redistribute shared points  in  order │
                   │                                             │ to achieve better balancing.          │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ reorderGetDefault()                         │ Return  flag  indicating  whether the │
                   │                                             │ DMPlex   should   be   reordered   by │
                   │                                             │ default.                              │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ reorderSetDefault(flag)                     │ Set  flag  indicating  whether the DM │
                   │                                             │ should be reordered by default.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ sectionLoad(viewer, sectiondm, sfxc)        │ Load section into a DM.               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ sectionView(viewer, sectiondm)              │ Save  a  section  associated  with  a │
                   │                                             │ DMPlex.                               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setAdjacencyUseAnchors([useAnchors])        │ Define  adjacency  in  the mesh using │
                   │                                             │ the point-to-point constraints.       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setCellType(p, ctype)                       │ Set the  polytope  type  of  a  given │
                   │                                             │ cell.                                 │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setChart(pStart, pEnd)                      │ Set  the interval for all mesh points │
                   │                                             │ [pStart, pEnd).                       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setCone(p, cone[, orientation])             │ Set the points on  the  in-edges  for │
                   │                                             │ this point in the DAG.                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setConeOrientation(p, orientation)          │ Set  the orientations on the in-edges │
                   │                                             │ for this point in the DAG.            │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setConeSize(p, size)                        │ Set the number of in-edges  for  this │
                   │                                             │ point in the DAG.                     │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setMatClosure(sec,    gsec,   mat,   point, │ Set an array of  the  values  on  the │
                   │ values)                                     │ closure of point.                     │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setPartitioner(part)                        │ Set the mesh partitioner.             │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setRefinementLimit(refinementLimit)         │ Set   the  maximum  cell  volume  for │
                   │                                             │ refinement.                           │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setRefinementUniform([refinementUniform])   │ Set the flag for uniform refinement.  │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setSupport(p, supp)                         │ Set the points on the  out-edges  for │
                   │                                             │ this point in the DAG.                │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setSupportSize(p, size)                     │ Set  the number of out-edges for this │
                   │                                             │ point in the DAG.                     │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setTetGenOptions(opts)                      │ Set the options used for  the  Tetgen │
                   │                                             │ mesh generator.                       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setTriangleOptions(opts)                    │ Set the options used for the Triangle │
                   │                                             │ mesh generator.                       │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ setVecClosure(sec,   vec,  point,  values[, │ Set an array of  the  values  on  the │
                   │ addv])                                      │ closure of point.                     │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ stratify()                                  │ Calculate the strata of DAG.          │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ symmetrize()                                │ Create support (out-edge) information │
                   │                                             │ from cone (in-edge) information.      │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ topologyLoad(viewer)                        │ Load  a  topology  into  this  DMPlex │
                   │                                             │ object.                               │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ topologyView(viewer)                        │ Save a DMPlex topology into a file.   │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ uninterpolate()                             │ Convert to a mesh with only cells and │
                   │                                             │ vertices.                             │
                   ├─────────────────────────────────────────────┼───────────────────────────────────────┤
                   │ vecGetClosure(sec, vec, p)                  │ Return an  array  of  values  on  the │
                   │                                             │ closure of p.                         │
                   └─────────────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              computeCellGeometryFVM(cell)
                     Compute the volume for a given cell.

                     Not collective.

                     Parameterscell (int) -- The cell.

                     Returns

                            • volume (float) -- The cell volume.

                            • centroid (ArrayReal) -- The cell centroid.

                            • normal (ArrayReal) -- The cell normal, if appropriate.

                     Returntypetuple[float, ArrayReal, ArrayReal]

                     SEEALSO:DMPlex, DM.getCoordinateSection, DM.getCoordinates, DMPlexComputeCellGeometryFVMSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2217computeGradientClementInterpolant(locX,locC)
                     Return the L2 projection of the cellwise gradient of a function onto P1.

                     Collective.

                     Parameters

                            • locX (Vec) -- The coefficient vector of the function.

                            • locC (Vec) -- The output Vec which holds the Clement interpolant of the gradient.

                     ReturntypeVecSEEALSO:DM, DMPlex, DMPlexComputeGradientClementInterpolantSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3151constructGhostCells(labelName=None)
                     Construct ghost cells which connect to every boundary face.

                     Collective.

                     ParameterslabelName  (str|None)  --  The  name of the label specifying the boundary faces.
                            Defaults to "FaceSets".

                     ReturnsnumGhostCells -- The number of ghost cells added to the DMPlex.

                     ReturntypeintSEEALSO:DM, DMPlex, DM.create, DMPlexConstructGhostCellsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2249coordinatesLoad(viewer,sfxc)
                     Load coordinates into this DMPlex object.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer for the saved coordinates.

                            • sfxc (SF) -- The SF returned by topologyLoad.

                     ReturntypeNoneSEEALSO:DM, DMPlex, DM.load, DMPlex.topologyLoad,  DMPlex.labelsLoad,  DM.view,  SF,  Viewer,  ‐
                        DMPlexCoordinatesLoadSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3324coordinatesView(viewer)
                     Save DMPlex coordinates into a file.

                     Collective.

                     Parametersviewer (Viewer) -- The Viewer for saving.

                     ReturntypeNoneSEEALSO:DM,  DMPlex,  DM.view,  DMPlex.topologyView,  DMPlex.labelsView, DMPlex.coordinatesLoad,
                        Viewer, DMPlexCoordinatesViewSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3191create(comm=None)
                     Create a DMPlex object, which encapsulates an unstructured mesh.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM, DMPlex, DM.create, DM.setType, DMPlexCreateSourcecodeatpetsc4py/PETSc/DMPlex.pyx:14createBoxMesh(faces,lower=(0,0,0),upper=(1,1,1),simplex=True,periodic=False,interpolate=True,localizationHeight=0,sparseLocalize=True,comm=None)
                     Create a mesh on the tensor product of intervals.

                     Collective.

                     Parameters

                            • faces (Sequence[int]) -- Number of faces per dimension, or None for the default.

                            • lower (Sequence[float]|None) -- The lower left corner.

                            • upper (Sequence[float]|None) -- The upper right corner.

                            • simplex (bool|None) -- True for simplices, False for tensor cells.

                            • periodic (Sequence|str|int|bool|None) -- The boundary type for the X, Y, Z
                              direction, or None for DM.BoundaryType.NONE.

                            • interpolate (bool|None) -- Flag to create  intermediate  mesh  entities  (edges,
                              faces).

                            • localizationHeight (int|None) -- Flag to localize edges and faces in addition to
                              cells; only significant for periodic meshes.

                            • sparseLocalize  (bool|None) -- Flag to localize coordinates only for cells near
                              the periodic boundary; only significant for periodic meshes.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM,  DMPlex,  DM.setFromOptions,   DMPlex.createFromFile,   DM.setType,   DM.create,   ‐
                        DMPlexCreateBoxMeshSourcecodeatpetsc4py/PETSc/DMPlex.pyx:90createBoxSurfaceMesh(faces,lower=(0,0,0),upper=(1,1,1),interpolate=True,comm=None)
                     Create a mesh on the surface of a box mesh using tensor cells.

                     Collective.

                     Parameters

                            • faces (Sequence[int]) -- Number of faces per dimension, or None for the default.

                            • lower (Sequence[float]|None) -- The lower left corner.

                            • upper (Sequence[float]|None) -- The upper right corner.

                            • interpolate  (bool|None)  --  Flag  to create intermediate mesh pieces (edges,
                              faces).

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM, DMPlex, DM.setFromOptions, DMPlex.createBoxMesh, DMPlex.createFromFile,  DM.setType,
                        DM.create, DMPlexCreateBoxSurfaceMeshSourcecodeatpetsc4py/PETSc/DMPlex.pyx:149createCGNS(cgid,interpolate=True,comm=None)
                     Create a DMPlex mesh from a CGNS file.

                     Collective.

                     Parameters

                            • cgid (int) -- The CG id associated with a file and obtained using cg_open.

                            • interpolate (bool|None) -- Create faces and edges in the mesh.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM,    DMPlex,    DMPlex.create,   DMPlex.createCGNSFromFile,   DMPlex.createExodus,   ‐
                        DMPlexCreateCGNSSourcecodeatpetsc4py/PETSc/DMPlex.pyx:226createCGNSFromFile(filename,interpolate=True,comm=None)
                     "Create a DMPlex mesh from a CGNS file.

                     Collective.

                     Parameters

                            • filename (str) -- The name of the CGNS file.

                            • interpolate (bool|None) -- Create faces and edges in the mesh.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM, DMPlex, DMPlex.create, DMPlex.createCGNS, DMPlex.createExodus, DMPlexCreateCGNSSourcecodeatpetsc4py/PETSc/DMPlex.pyx:254createClosureIndex(sec)
                     Calculate an index for sec for the closure operation.

                     Not collective.

                     Parameterssec (Section) -- The Section describing the layout in the local vector, or  None  to
                            use the default section.

                     ReturntypeNoneSEEALSO:DM, DMPlex, Section, DMPlex.vecGetClosure, DMPlexCreateClosureIndexSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2031createCoarsePointIS()
                     Create an IS covering the coarse DMPlex chart with the fine points as data.

                     Collective.

                     ReturnsfpointIS -- The IS of all the fine points which exist in the original coarse mesh.

                     ReturntypeISSEEALSO:DM, DMPlex, IS, DM.refine, DMPlex.setRefinementUniform, DMPlexCreateCoarsePointISSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1817createCohesiveSubmesh(hasLagrange,value)
                     Extract the hypersurface defined by one face of the cohesive cells.

                     Collective.

                     Parameters

                            • hasLagrange  (bool)  --  Flag indicating whether the mesh has Lagrange dofs in the
                              cohesive cells.

                            • value (int) -- A label value.

                     ReturntypeDMPlexSEEALSO:DM, DMPlex, DMPlexCreateCohesiveSubmeshSourcecodeatpetsc4py/PETSc/DMPlex.pyx:377createExodus(exoid,interpolate=True,comm=None)
                     Create a DMPlex mesh from an ExodusII file ID.

                     Collective.

                     Parameters

                            • exoid (int) -- The ExodusII id associated with a file obtained using ex_open.

                            • interpolate (bool|None) -- Create faces and edges in the mesh,

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM, DMPlex, DM.create, DMPlexCreateExodusSourcecodeatpetsc4py/PETSc/DMPlex.pyx:312createExodusFromFile(filename,interpolate=True,comm=None)
                     Create a DMPlex mesh from an ExodusII file.

                     Collective.

                     Parameters

                            • filename (str) -- The name of the ExodusII file.

                            • interpolate (bool|None) -- Create faces and edges in the mesh.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM, DMPlex, DM.create, DMPlex.createExodus, DMPlexCreateExodusFromFileSourcecodeatpetsc4py/PETSc/DMPlex.pyx:283createFromCellList(dim,cells,coords,interpolate=True,comm=None)
                     Create a DMPlex from a list of vertices for each cell on process 0.

                     Collective.

                     Parameters

                            • dim (int) -- The topological dimension of the mesh.

                            • cells (Sequence[int]) -- An array of number of cells times number of  vertices  on
                              each cell.

                            • coords (Sequence[float]) -- An array of number of vertices times spatial dimension
                              for coordinates.

                            • interpolate (bool|None) -- Flag to interpolate the mesh.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM, DMPlex, DMPlex.create, DMPlex.interpolate, DMPlexCreateFromCellListPetscSourcecodeatpetsc4py/PETSc/DMPlex.pyx:35createFromFile(filename,plexname='unnamed',interpolate=True,comm=None)
                     Create DMPlex from a file.

                     Collective.

                     Parameters

                            • filename (str) -- A file name.

                            • plexname  (str|None)  --  The  name  of  the  resulting  DMPlex, also used for
                              intra-datafile lookup by some formats.

                            • interpolate (bool|None) -- Flag  to  create  intermediate  mesh  pieces  (edges,
                              faces).

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DM,  DMPlex, DMPlex.createFromCellList, DMPlex.create, Object.setName, DM.view, DM.load,
                        WorkingwithPETScoptions, DMPlexCreateFromFileSourcecodeatpetsc4py/PETSc/DMPlex.pyx:192createGmsh(viewer,interpolate=True,comm=None)
                     Create a DMPlex mesh from a Gmsh file viewer.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer associated with a Gmsh file.

                            • interpolate (bool|None) -- Create faces and edges in the mesh.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelf

                     Notes

                     -dm_plex_gmsh_hybrid forces triangular prisms to use tensor order.

                     -dm_plex_gmsh_periodic allows for reading Gmsh periodic section.

                     -dm_plex_gmsh_highorder allows for generating high-order coordinates.

                     -dm_plex_gmsh_project projects high-order coordinates to a different space, use the  prefix
                     -dm_plex_gmsh_project_ to define the space.

                     -dm_plex_gmsh_use_regions generates labels with region names.

                     -dm_plex_gmsh_mark_vertices adds vertices to generated labels.

                     -dm_plex_gmsh_multiple_tags allows multiple tags for default labels.

                     -dm_plex_gmsh_spacedim<d> embedding space dimension.

                     SEEALSO:DM, DMPlex, DM.create, WorkingwithPETScoptions, DMPlexCreateGmshSourcecodeatpetsc4py/PETSc/DMPlex.pyx:339createPointNumbering()
                     Create a global numbering for all points.

                     Collective.

                     SEEALSO:DM, DMPlex, DMPlex.getCellNumbering, DMPlexCreatePointNumberingSourcecodeatpetsc4py/PETSc/DMPlex.pyx:915ReturntypeIScreateSection(numComp,numDof,bcField=None,bcComps=None,bcPoints=None,perm=None)
                     Create a Section based upon the DOF layout specification provided.

                     Not collective.

                     Parameters

                            • numComp  (Sequence[int])  --  An  array  of  size  numFields holding the number of
                              components per field.

                            • numDof (Sequence[int]) -- An array of size numFields*(dim+1) holding the number of
                              DOFs per field on a mesh piece of dimension dim.

                            • bcField (Sequence[int]|None) -- An array of size numBC giving the  field  number
                              for each boundary condition, where numBC is the number of boundary conditions.

                            • bcComps  (Sequence[IS]|None) -- An array of size numBC giving an IS holding the
                              field components to which each boundary condition applies.

                            • bcPoints (Sequence[IS]|None) -- An array of size numBC giving an IS holding  the
                              DMPlex points to which each boundary condition applies.

                            • perm (IS|None) -- Permutation of the chart.

                     ReturntypeSectionSEEALSO:DM, DMPlex, DMPlex.create, Section.create, Section.setPermutation, DMPlexCreateSectionSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1837distribute(overlap=0)
                     Distribute the mesh and any associated sections.

                     Collective.

                     Parametersoverlap (int|None) -- The overlap of partitions.

                     Returnssf -- The SF used for point distribution, or None if not distributed.

                     ReturntypeSF or NoneSEEALSO:DM, DMPlex, DMPlex.create, DMPlexDistributeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1561distributeField(sf,sec,vec,newsec=None,newvec=None)
                     Distribute field data with a with a given SF.

                     Collective.

                     Parameters

                            • sf (SF) -- The SF describing the communication pattern.

                            • sec (Section) -- The Section for existing data layout.

                            • vec (Vec) -- The existing data in a local vector.

                            • newsec (Section|None) -- The SF describing the new data layout.

                            • newvec (Vec|None) -- The new data in a local vector.

                     Returns

                            • newSection (Section) -- The SF describing the new data layout.

                            • newVec (Vec) -- The new data in a local vector.

                     Returntypetuple[Section, Vec]

                     SEEALSO:DMPlex, DMPlex.distribute, DMPlexDistributeFieldSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1758distributeGetDefault()
                     Return a flag indicating whether the DM should be distributed by default.

                     Not collective.

                     Returnsdist -- Flag indicating whether the DMPlex should be distributed by default.

                     ReturntypeboolSEEALSO:DM, DMPlex, DMPlex.distributeSetDefault, DMPlex.distribute, DMPlexDistributeGetDefaultSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1647distributeOverlap(overlap=0)
                     Add partition overlap to a distributed non-overlapping DMPlex.

                     Collective.

                     Parametersoverlap (int|None) -- The overlap of partitions (the same on all ranks).

                     Returnssf -- The SF used for point distribution.

                     ReturntypeSFSEEALSO:DM, DMPlex, SF, DMPlex.create, DMPlex.distribute, DMPlexDistributeOverlapSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1589distributeSetDefault(flag)
                     Set flag indicating whether the DMPlex should be distributed by default.

                     Logically collective.

                     Parametersflag (bool) -- Flag indicating whether the DMPlex should be distributed by default.

                     ReturntypeNoneSEEALSO:DMPlex, DMPlex.distributeGetDefault, DMPlex.distribute, DMPlexDistributeSetDefaultSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1667distributionGetName()
                     Retrieve the name of the specific parallel distribution.

                     Not collective.

                     Returnsname -- The name of the specific parallel distribution.

                     ReturntypestrSEEALSO:DMPlex,    DMPlex.distributionSetName,   DMPlex.topologyView,   DMPlex.topologyLoad,   ‐
                        DMPlexDistributionGetNameSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1708distributionSetName(name)
                     Set the name of the specific parallel distribution.

                     Logically collective.

                     Parametersname (str) -- The name of the specific parallel distribution.

                     ReturntypeNoneSEEALSO:DMPlex,   DMPlex.distributionGetName,   DMPlex.topologyView,   DMPlex.topologyLoad,    ‐
                        DMPlexDistributionSetNameSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1687generate(boundary,name=None,interpolate=True)
                     Generate a mesh.

                     Not collective.

                     Parameters

                            • boundary (DMPlex) -- The DMPlex boundary object.

                            • name (str|None) -- The mesh generation package name.

                            • interpolate (bool|None) -- Flag to create intermediate mesh elements.

                     ReturntypeSelfSEEALSO:DM, DMPlex, DMPlex.create, DM.refine, WorkingwithPETScoptions, DMPlexGenerateSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1284getAdjacency(p)
                     Return all points adjacent to the given point.

                     Not collective.

                     Parametersp (int) -- The point.

                     ReturntypeArrayIntSEEALSO:DMPlex, DMPlex.distribute, DMPlexGetAdjacencySourcecodeatpetsc4py/PETSc/DMPlex.pyx:1467getAdjacencyUseAnchors()
                     Query whether adjacency in the mesh uses the point-to-point constraints.

                     Not collective.

                     SEEALSO:DMPlex, DMPlex.getAdjacency, DMPlex.distribute, DMPlexGetAdjacencyUseAnchorsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1452ReturntypeboolgetCellNumbering()
                     Return a global cell numbering for all cells on this process.

                     Collective the first time it is called.

                     SEEALSO:DM, DMPlex, DMPlex.getVertexNumbering, DMPlexGetCellNumberingSourcecodeatpetsc4py/PETSc/DMPlex.pyx:885ReturntypeISgetCellType(p)
                     Return the polytope type of a given cell.

                     Not collective.

                     Parametersp (int) -- The cell.

                     ReturntypePolytopeTypeSEEALSO:DM, DMPlex, DM.PolytopeType, DMPlex.getCellTypeLabel, DMPlex.getDepth, DMPlexGetCellTypeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:685getCellTypeLabel()
                     Return the DMLabel recording the polytope type of each cell.

                     Not collective.

                     SEEALSO:DM, DMPlex, DMPlex.getCellType, DM.createLabel, DMPlexGetCellTypeLabelSourcecodeatpetsc4py/PETSc/DMPlex.pyx:706ReturntypeDMLabelgetChart()
                     Return the interval for all mesh points [pStart, pEnd).

                     Not collective.

                     Returns

                            • pStart (int) -- The first mesh point.

                            • pEnd (int) -- The upper bound for mesh points.

                     Returntypetuple[int, int]

                     SEEALSO:DM, DMPlex, DMPlex.create, DMPlex.setChart, DMPlexGetChartSourcecodeatpetsc4py/PETSc/DMPlex.pyx:400getCone(p)
                     Return the points on the in-edges for this point in the DAG.

                     Not collective.

                     Parametersp (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                     ReturntypeArrayIntSEEALSO:DM, DMPlex, DMPlex.getConeSize, DMPlex.setCone, DMPlex.setChart, DMPlexGetConeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:491getConeOrientation(p)
                     Return the orientations on the in-edges for this point in the DAG.

                     Not collective.

                     Parametersp (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                     ReturntypeArrayIntSEEALSO:DM,   DMPlex,   DMPlex.create,   DMPlex.getCone,   DMPlex.setCone,   DMPlex.setChart,  ‐
                        DMPlexGetConeOrientationSourcecodeatpetsc4py/PETSc/DMPlex.pyx:606getConeSize(p)
                     Return the number of in-edges for this point in the DAG.

                     Not collective.

                     Parametersp (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                     ReturntypeintSEEALSO:DM, DMPlex, DMPlex.create, DMPlex.setConeSize, DMPlex.setChart, DMPlexGetConeSizeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:442getDepth()
                     Return the depth of the DAG representing this mesh.

                     Not collective.

                     SEEALSO:DM, DMPlex, DMPlex.getDepthStratum, DMPlex.symmetrize, DMPlexGetDepthSourcecodeatpetsc4py/PETSc/DMPlex.pyx:929ReturntypeintgetDepthStratum(svalue)
                     Return the bounds [start, end) for all points at a certain depth.

                     Not collective.

                     Parameterssvalue (int) -- The requested depth.

                     Returns

                            • pStart (int) -- The first stratum point.

                            • pEnd (int) -- The upper bound for stratum points.

                     Returntypetuple[int, int]

                     SEEALSO:DM,     DMPlex,     DMPlex.getHeightStratum,     DMPlex.getDepth,     DMPlex.symmetrize,
                        DMPlex.interpolate, DMPlexGetDepthStratumSourcecodeatpetsc4py/PETSc/DMPlex.pyx:944getFullJoin(points)
                     Return an array for the join of the set of points.

                     Not collective.

                     Parameterspoints (Sequence[int]) -- The input points.

                     ReturntypeArrayIntSEEALSO:DM, DMPlex, DMPlex.getJoin, DMPlex.getMeet, DMPlexGetFullJoinSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1092getHeightStratum(svalue)
                     Return the bounds [start, end) for all points at a certain height.

                     Not collective.

                     Parameterssvalue (int) -- The requested height.

                     Returns

                            • pStart (int) -- The first stratum point.

                            • pEnd (int) -- The upper bound for stratum points.

                     Returntypetuple[int, int]

                     SEEALSO:DM, DMPlex, DMPlex.getDepthStratum, DMPlex.getDepth, DMPlexGetHeightStratumSourcecodeatpetsc4py/PETSc/DMPlex.pyx:971getJoin(points)
                     Return an array for the join of the set of points.

                     Not collective.

                     Parameterspoints (Sequence[int]) -- The input points.

                     ReturntypeArrayIntSEEALSO:DM, DMPlex, DMPlex.getMeet, DMPlexGetJoinSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1066getMaxSizes()
                     Return the maximum number of in-edges and out-edges of the DAG.

                     Not collective.

                     Returns

                            • maxConeSize (int) -- The maximum number of in-edges.

                            • maxSupportSize (int) -- The maximum number of out-edges.

                     Returntypetuple[int, int]

                     SEEALSO:DM, DMPlex, DMPlex.create, DMPlex.setConeSize, DMPlex.setChart, DMPlexGetMaxSizesSourcecodeatpetsc4py/PETSc/DMPlex.pyx:826getMeet(points)
                     Return an array for the meet of the set of points.

                     Not collective.

                     Parameterspoints (Sequence[int]) -- The input points.

                     ReturntypeArrayIntSEEALSO:DM, DMPlex, DMPlex.getJoin, DMPlexGetMeetSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1040getMinRadius()
                     Return the minimum distance from any cell centroid to a face.

                     Not collective.

                     SEEALSO:DMPlex, DM.getCoordinates, DMPlexGetMinRadiusSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1803ReturntypefloatgetOrdering(otype)
                     Calculate a reordering of the mesh.

                     Collective.

                     Parametersotype (OrderingType) -- Type of reordering, see Mat.OrderingType.

                     Returnsperm -- The point permutation.

                     ReturntypeISSEEALSO:DMPlex, DMPlex.permute, Mat.OrderingType, Mat.getOrdering, DMPlexGetOrderingSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2130getPartitioner()
                     Return the mesh partitioner.

                     Not collective.

                     SEEALSO:DM,    DMPlex,    Partitioner,    Section,   DMPlex.distribute,   DMPlex.setPartitioner,
                        Partitioner.create, PetscPartitionerDMPlexPartition, DMPlexGetPartitionerSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1510ReturntypePartitionergetPointDepth(point)
                     Return the depth of a given point.

                     Not collective.

                     Parameterspoint (int) -- The point.

                     ReturntypeintSEEALSO:DM, DMPlex, DMPlex.getDepthStratum, DMPlex.getDepth, DMPlexGetPointDepthSourcecodeatpetsc4py/PETSc/DMPlex.pyx:998getPointGlobal(point)
                     Return location of point data in global Vec.

                     Not collective.

                     Parameterspoint (int) -- The topological point.

                     Returns

                            • start (int) -- Start of point data;  returns  -(globalStart+1)  if  point  is  not
                              owned.

                            • end (int) -- End of point data; returns -(globalEnd+1) if point is not owned.

                     Returntypetuple[int, int]

                     SEEALSO:DM,     DMPlex,     DMPlex.getPointGlobalField,    Section.getOffset,    Section.getDof,
                        DMPlex.getPointLocal, DMPlexGetPointGlobalSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1972getPointGlobalField(point,field)
                     Return location of point field data in global Vec.

                     Not collective.

                     Parameters

                            • point (int) -- The topological point.

                            • field (int) -- The field number.

                     Returns

                            • start (int) -- Start of point data;  returns  -(globalStart+1)  if  point  is  not
                              owned.

                            • end (int) -- End of point data; returns -(globalEnd+1) if point is not owned.

                     Returntypetuple[int, int]

                     SEEALSO:DM,      DMPlex,      DMPlex.getPointGlobal,      Section.getOffset,     Section.getDof,
                        DMPlex.getPointLocal, DMPlexGetPointGlobalFieldSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2000getPointHeight(point)
                     Return the height of a given point.

                     Not collective.

                     Parameterspoint (int) -- The point.

                     ReturntypeintSEEALSO:DM, DMPlex, DMPlex.getHeightStratum, DMPlexGetPointHeightSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1019getPointLocal(point)
                     Return location of point data in local Vec.

                     Not collective.

                     Parameterspoint (int) -- The topological point.

                     Returns

                            • start (int) -- Start of point data.

                            • end (int) -- End of point data.

                     Returntypetuple[int, int]

                     SEEALSO:DM,   DMPlex,   DMPlex.getPointLocalField,    Section.getOffset,    Section.getDof,    ‐
                        DMPlexGetPointLocalSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1913getPointLocalField(point,field)
                     Return location of point field data in local Vec.

                     Not collective.

                     Parameters

                            • point (int) -- The topological point.

                            • field (int) -- The field number.

                     Returns

                            • start (int) -- Start of point data.

                            • end (int) -- End of point data.

                     Returntypetuple[int, int]

                     SEEALSO:DM, DMPlex, DMPlex.getPointLocal, Section.getOffset, DMPlexGetPointLocalFieldSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1941getRefinementLimit()
                     Retrieve the maximum cell volume for refinement.

                     Not collective.

                     SEEALSO:DM,    DMPlex,    DM.refine,   DMPlex.setRefinementLimit,   DMPlex.getRefinementUniform,
                        DMPlex.setRefinementUniform, DMPlexGetRefinementLimitSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2114ReturntypefloatgetRefinementUniform()
                     Retrieve the flag for uniform refinement.

                     Not collective.

                     ReturnsrefinementUniform -- The flag for uniform refinement.

                     ReturntypeboolSEEALSO:DM,   DMPlex,   DM.refine,    DMPlex.setRefinementUniform,    DMPlex.getRefinementLimit,
                        DMPlex.setRefinementLimit, DMPlexGetRefinementUniformSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2073getSubpointIS()
                     Return an IS covering the entire subdm chart.

                     Not collective.

                     Returnsiset -- The IS containing subdm's parent's points.

                     ReturntypeISSEEALSO:DM, DMPlex, DMPlexGetSubpointISSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2278getSubpointMap()
                     Return a DMLabel with point dimension as values.

                     Not collective.

                     Returnslabel -- The DMLabel whose values are subdm's point dimensions.

                     ReturntypeDMLabelSEEALSO:DM, DMPlex, DMPlexGetSubpointMapSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2298getSupport(p)
                     Return the points on the out-edges for this point in the DAG.

                     Not collective.

                     Parametersp (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                     ReturntypeArrayIntSEEALSO:DM, DMPlex, DMPlex.getSupportSize, DMPlex.setSupport, DMPlex.getCone, DMPlex.setChart, ‐
                        DMPlexGetSupportSourcecodeatpetsc4py/PETSc/DMPlex.pyx:771getSupportSize(p)
                     Return the number of out-edges for this point in the DAG.

                     Not collective.

                     Parametersp (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                     ReturntypeintSEEALSO:DM,  DMPlex,  DMPlex.create,  DMPlex.setConeSize, DMPlex.setChart, DMPlex.getConeSize, ‐
                        DMPlexGetSupportSizeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:722getTransitiveClosure(p,useCone=True)
                     Return the points and orientations on the transitive closure of this point.

                     Not collective.

                     Parameters

                            • p (int) -- The mesh point.

                            • useCone (bool|None) -- True for the closure, otherwise return the star.

                     Returns

                            • points (ArrayInt) -- The points.

                            • orientations (ArrayInt) -- The orientations.

                     Returntypetuple[ArrayInt, ArrayInt]

                     SEEALSO:DM,  DMPlex,   DMPlex.create,   DMPlex.setCone,   DMPlex.setChart,   DMPlex.getCone,   ‐
                        DMPlexGetTransitiveClosureSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1118getVecClosure(sec,vec,point)
                     Return an array of the values on the closure of a point.

                     Not collective.

                     Parameters

                            • sec  (Section)  --  The  Section  describing  the layout in vec or None to use the
                              default section.

                            • vec (Vec) -- The local vector.

                            • point (int) -- The point in the DMPlex.

                     ReturntypeArrayScalarSEEALSO:DM, DMPlex, DMPlexVecRestoreClosureSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1185getVertexNumbering()
                     Return a global vertex numbering for all vertices on this process.

                     Collective the first time it is called.

                     SEEALSO:DM, DMPlex, DMPlex.getCellNumbering, DMPlexGetVertexNumberingSourcecodeatpetsc4py/PETSc/DMPlex.pyx:900ReturntypeISglobalVectorLoad(viewer,sectiondm,sf,vec)
                     Load on-disk vector data into a global vector.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer that represents the on-disk vector data.

                            • sectiondm (DM) -- The DM that contains the global section on which vec is defined.

                            • sf (SF) -- The SF that migrates the on-disk vector data into vec.

                            • vec (Vec) -- The global vector to set values of.

                     ReturntypeNoneSEEALSO:DM,    DMPlex,    DMPlex.topologyLoad,    DMPlex.sectionLoad,    DMPlex.localVectorLoad,
                        DMPlex.globalVectorView, DMPlex.localVectorView, SF, Viewer, DMPlexGlobalVectorLoadSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3401globalVectorView(viewer,sectiondm,vec)
                     Save a global vector.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer to save data with.

                            • sectiondm  (DM)  --  The DM containing the global section on which vec is defined;
                              may be the same as this DMPlex object.

                            • vec (Vec) -- The global vector to be saved.

                     ReturntypeNoneSEEALSO:DM,    DMPlex,    DMPlex.topologyView,    DMPlex.sectionView,    DMPlex.localVectorView,
                        DMPlex.globalVectorLoad, DMPlex.localVectorLoad, DMPlexGlobalVectorViewSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3248insertCone(p,conePos,conePoint)
                     DMPlexInsertCone - Insert a point into the in-edges for the point p in the DAG.

                     Not collective.

                     Parameters

                            • p (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                            • conePos (int) -- The local index in the cone where the point should be put.

                            • conePoint (int) -- The mesh point to insert.

                     ReturntypeNoneSEEALSO:DM,   DMPlex,   DMPlex.create,   DMPlex.getCone,   DMPlex.setChart,  DMPlex.setConeSize,
                        DM.setUp, DMPlexInsertConeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:556insertConeOrientation(p,conePos,coneOrientation)
                     Insert a point orientation for the in-edge for the point p in the DAG.

                     Not collective.

                     Parameters

                            • p (int) -- The point, which must lie in the chart set with DMPlex.setChart

                            • conePos (int) -- The local index in the cone where the point should be put.

                            • coneOrientation (int) -- The point orientation to insert.

                     ReturntypeNoneSEEALSO:DM,  DMPlex,   DMPlex.create,   DMPlex.getCone,   DMPlex.setChart,   DMPlex.setConeSize,
                        DM.setUp, DMPlexInsertConeOrientationSourcecodeatpetsc4py/PETSc/DMPlex.pyx:581interpolate()
                     Convert to a mesh with all intermediate faces, edges, etc.

                     Collective.

                     SEEALSO:DMPlex, DMPlex.uninterpolate, DMPlex.createFromCellList, DMPlexInterpolateSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1728ReturntypeNoneisDistributed()
                     Return the flag indicating if the mesh is distributed.

                     Collective.

                     SEEALSO:DM, DMPlex, DMPlex.distribute, DMPlexIsDistributedSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1618ReturntypeboolisSimplex()
                     Return the flag indicating if the first cell is a simplex.

                     Not collective.

                     SEEALSO:DM, DMPlex, DMPlex.getCellType, DMPlex.getHeightStratum, DMPlexIsSimplexSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1632ReturntypeboollabelCohesiveComplete(label,bdlabel,bdvalue,flip,split,subdm)
                     Add all other mesh pieces to complete the surface.

                     Not collective.

                     Parameters

                            • label (DMLabel) -- A DMLabel marking the surface.

                            • bdlabel (DMLabel) -- A DMLabel marking the vertices on the boundary which will not
                              be duplicated.

                            • bdvalue (int) -- Value of DMLabel marking the vertices on the boundary.

                            • flip  (bool)  --  Flag  to flip the submesh normal and replace points on the other
                              side.

                            • split (bool) -- Flag to split faces incident on the surface boundary, rather  than
                              clamping those faces to the boundary

                            • subdm (DMPlex) -- The DMPlex associated with the label.

                     ReturntypeNoneSEEALSO:DM, DMPlex, DMPlex.labelComplete, DMPlexLabelCohesiveCompleteSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1396labelComplete(label)
                     Add the transitive closure to the surface.

                     Not collective.

                     Parameterslabel (DMLabel) -- A DMLabel marking the surface points.

                     ReturntypeNoneSEEALSO:DM, DMPlex, DMPlex.labelCohesiveComplete, DMPlexLabelCompleteSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1379labelsLoad(viewer,sfxc)
                     Load labels into this DMPlex object.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer for the saved labels.

                            • sfxc (SF) -- The SF returned by topologyLoad.

                     ReturntypeNoneSEEALSO:DM, DMPlex, DM.load, DMPlex.topologyLoad, DMPlex.coordinatesLoad, DM.view, SF, Viewer, ‐
                        DMPlexLabelsLoadSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3344labelsView(viewer)
                     Save DMPlex labels into a file.

                     Collective.

                     Parametersviewer (Viewer) -- The Viewer for saving.

                     ReturntypeNoneSEEALSO:DM,  DMPlex,  DM.view,  DMPlex.topologyView,  DMPlex.coordinatesView, DMPlex.labelsLoad,
                        Viewer, DMPlexLabelsViewSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3209localVectorLoad(viewer,sectiondm,sf,vec)
                     Load on-disk vector data into a local vector.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer that represents the on-disk vector data.

                            • sectiondm (DM) -- The DM that contains the local section on which vec is defined.

                            • sf (SF) -- The SF that migrates the on-disk vector data into vec.

                            • vec (Vec) -- The local vector to set values of.

                     ReturntypeNoneSEEALSO:DM,   DMPlex,    DMPlex.topologyLoad,    DMPlex.sectionLoad,    DMPlex.globalVectorLoad,
                        DMPlex.globalVectorView, DMPlex.localVectorView, SF, Viewer, DMPlexLocalVectorLoadSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3426localVectorView(viewer,sectiondm,vec)
                     Save a local vector.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer to save data with.

                            • sectiondm  (DM) -- The DM that contains the local section on which vec is defined;
                              may be the same as this DMPlex object.

                            • vec (Vec) -- The local vector to be saved.

                     ReturntypeNoneSEEALSO:DM,   DMPlex,    DMPlex.topologyView,    DMPlex.sectionView,    DMPlex.globalVectorView,
                        DMPlex.globalVectorLoad, DMPlex.localVectorLoad, DMPlexLocalVectorViewSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3272markBoundaryFaces(label,value=None)
                     Mark all faces on the boundary.

                     Not collective.

                     Parameters

                            • value  (int|None) -- The marker value, or DETERMINE or None to use some value in
                              the closure (or 1 if none are found).

                            • label (str)

                     ReturntypeDMLabelSEEALSO:DM, DMPlex, DMLabel.create, DM.createLabel, DMPlexMarkBoundaryFacesSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1352metricAverage2(metric1,metric2,metricAvg)
                     Compute and return the unweighted average of two metrics.

                     Collective.

                     Parameters

                            • metric1 (Vec) -- The first metric to be averaged.

                            • metric2 (Vec) -- The second metric to be averaged.

                            • metricAvg (Vec) -- The output averaged metric.

                     ReturntypeVecSEEALSO:DMPlex.metricAverage3, DMPlexMetricAverage2Sourcecodeatpetsc4py/PETSc/DMPlex.pyx:3059metricAverage3(metric1,metric2,metric3,metricAvg)
                     Compute and return the unweighted average of three metrics.

                     Collective.

                     Parameters

                            • metric1 (Vec) -- The first metric to be averaged.

                            • metric2 (Vec) -- The second metric to be averaged.

                            • metric3 (Vec) -- The third metric to be averaged.

                            • metricAvg (Vec) -- The output averaged metric.

                     ReturntypeVecSEEALSO:DMPlex.metricAverage2, DMPlexMetricAverage3Sourcecodeatpetsc4py/PETSc/DMPlex.pyx:3081metricCreate(field=0)
                     Create a Riemannian metric field.

                     Collective.

                     Parametersfield (int|None) -- The field number to use.

                     ReturntypeVecSEEALSO:DMPlex.metricCreateUniform, DMPlex.metricCreateIsotropic, WorkingwithPETScoptions,  ‐
                        DMPlexMetricCreateSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2890metricCreateIsotropic(indicator,field=0)
                     Construct an isotropic metric from an error indicator.

                     Collective.

                     Parameters

                            • indicator (Vec) -- The error indicator.

                            • field (int|None) -- The field number to use.

                     ReturntypeVecSEEALSO:DMPlex.metricCreate, DMPlex.metricCreateUniform, DMPlexMetricCreateIsotropicSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2935metricCreateUniform(alpha,field=0)
                     Construct a uniform isotropic metric.

                     Collective.

                     Parameters

                            • alpha (float) -- Scaling parameter for the diagonal.

                            • field (int|None) -- The field number to use.

                     ReturntypeVecSEEALSO:DMPlex.metricCreate, DMPlex.metricCreateIsotropic, DMPlexMetricCreateUniformSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2911metricDeterminantCreate(field=0)
                     Create the determinant field for a Riemannian metric.

                     Collective.

                     Parametersfield (int|None) -- The field number to use.

                     Returns

                            • determinant (Vec) -- The determinant field.

                            • dmDet (DM) -- The corresponding DM

                     Returntypetuple[Vec, DM]

                     SEEALSO:DMPlex.metricCreateUniform,    DMPlex.metricCreateIsotropic,    DMPlex.metricCreate,   ‐
                        DMPlexMetricDeterminantCreateSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2958metricEnforceSPD(metric,ometric,determinant,restrictSizes=False,restrictAnisotropy=False)
                     Enforce symmetric positive-definiteness of a metric.

                     Collective.

                     Parameters

                            • metric (Vec) -- The metric.

                            • ometric (Vec) -- The output metric.

                            • determinant (Vec) -- The output determinant.

                            • restrictSizes (bool|None) -- Flag indicating whether maximum/minimum  magnitudes
                              should be enforced.

                            • restrictAnisotropy  (bool|None)  -- Flag indicating whether maximum anisotropy
                              should be enforced.

                     Returns

                            • ometric (Vec) -- The output metric.

                            • determinant (Vec) -- The output determinant.

                     Returntypetuple[Vec, Vec]

                     SEEALSO:DMPlex.metricNormalize, DMPlex.metricIntersection2, DMPlex.metricIntersection3,  WorkingwithPETScoptions, DMPlexMetricEnforceSPDSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2987metricGetGradationFactor()
                     Return the metric gradation factor.

                     Not collective.

                     SEEALSO:DMPlex.metricSetGradationFactor,            DMPlex.metricGetHausdorffNumber,           ‐
                        DMPlexMetricGetGradationFactorSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2841ReturntypefloatmetricGetHausdorffNumber()
                     Return the metric Hausdorff number.

                     Not collective.

                     SEEALSO:DMPlex.metricGetGradationFactor,           DMPlex.metricSetHausdorffNumber,            ‐
                        DMPlexMetricGetHausdorffNumberSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2875ReturntypefloatmetricGetMaximumAnisotropy()
                     Return the maximum tolerated metric anisotropy.

                     Not collective.

                     SEEALSO:DMPlex.metricSetMaximumAnisotropy,          DMPlex.metricGetMaximumMagnitude,          ‐
                        DMPlexMetricGetMaximumAnisotropySourcecodeatpetsc4py/PETSc/DMPlex.pyx:2739ReturntypefloatmetricGetMaximumMagnitude()
                     Return the maximum tolerated metric magnitude.

                     Not collective.

                     SEEALSO:DMPlex.metricSetMaximumMagnitude,          DMPlex.metricGetMinimumMagnitude,           ‐
                        DMPlexMetricGetMaximumMagnitudeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2705ReturntypefloatmetricGetMinimumMagnitude()
                     Return the minimum tolerated metric magnitude.

                     Not collective.

                     SEEALSO:DMPlex.metricSetMinimumMagnitude,           DMPlex.metricGetMaximumMagnitude,          ‐
                        DMPlexMetricGetMinimumMagnitudeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2671ReturntypefloatmetricGetNormalizationOrder()
                     Return the order p for L-p normalization.

                     Not collective.

                     SEEALSO:DMPlex.metricSetNormalizationOrder,         DMPlex.metricGetTargetComplexity,          ‐
                        DMPlexMetricGetNormalizationOrderSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2807ReturntypefloatmetricGetNumIterations()
                     Return the number of parallel adaptation iterations.

                     Not collective.

                     SEEALSO:DMPlex.metricSetNumIterations, DMPlex.metricGetVerbosity, DMPlexMetricGetNumIterationsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2637ReturntypeintmetricGetTargetComplexity()
                     Return the target metric complexity.

                     Not collective.

                     SEEALSO:DMPlex.metricSetTargetComplexity,          DMPlex.metricGetNormalizationOrder,         ‐
                        DMPlexMetricGetTargetComplexitySourcecodeatpetsc4py/PETSc/DMPlex.pyx:2773ReturntypefloatmetricGetVerbosity()
                     Return the verbosity of the mesh adaptation package.

                     Not collective.

                     Returnsverbosity -- The verbosity, where -1 is silent and 10 is maximum.

                     ReturntypeintSEEALSO:DMPlex.metricSetVerbosity, DMPlex.metricGetNumIterations, DMPlexMetricGetVerbositySourcecodeatpetsc4py/PETSc/DMPlex.pyx:2598metricIntersection2(metric1,metric2,metricInt)
                     Compute and return the intersection of two metrics.

                     Collective.

                     Parameters

                            • metric1 (Vec) -- The first metric to be intersected.

                            • metric2 (Vec) -- The second metric to be intersected.

                            • metricInt (Vec) -- The output intersected metric.

                     ReturntypeVecSEEALSO:DMPlex.metricIntersection3, DMPlexMetricIntersection2Sourcecodeatpetsc4py/PETSc/DMPlex.pyx:3105metricIntersection3(metric1,metric2,metric3,metricInt)
                     Compute the intersection of three metrics.

                     Collective.

                     Parameters

                            • metric1 (Vec) -- The first metric to be intersected.

                            • metric2 (Vec) -- The second metric to be intersected.

                            • metric3 (Vec) -- The third metric to be intersected.

                            • metricInt (Vec) -- The output intersected metric.

                     ReturntypeVecSEEALSO:DMPlex.metricIntersection2, DMPlexMetricIntersection3Sourcecodeatpetsc4py/PETSc/DMPlex.pyx:3127metricIsIsotropic()
                     Return the flag indicating whether the metric is isotropic or not.

                     Not collective.

                     SEEALSO:DMPlex.metricSetIsotropic, DMPlex.metricIsUniform, DMPlex.metricRestrictAnisotropyFirst,
                        DMPlexMetricIsIsotropicSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2386ReturntypeboolmetricIsUniform()
                     Return the flag indicating whether the metric is uniform or not.

                     Not collective.

                     SEEALSO:DMPlex.metricSetUniform, DMPlex.metricRestrictAnisotropyFirst, DMPlexMetricIsUniformSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2352ReturntypeboolmetricNoInsertion()
                     Return the flag indicating whether node insertion and deletion are turned off.

                     Not collective.

                     SEEALSO:DMPlex.metricSetNoInsertion,      DMPlex.metricNoSwapping,      DMPlex.metricNoMovement,
                        DMPlex.metricNoSurf, DMPlexMetricNoInsertionSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2455ReturntypeboolmetricNoMovement()
                     Return the flag indicating whether node movement is turned off.

                     Not collective.

                     SEEALSO:DMPlex.metricSetNoMovement,      DMPlex.metricNoInsertion,      DMPlex.metricNoSwapping,
                        DMPlex.metricNoSurf, DMPlexMetricNoMovementSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2527ReturntypeboolmetricNoSurf()
                     Return the flag indicating whether surface modification is turned off.

                     Not collective.

                     SEEALSO:DMPlex.metricSetNoSurf,        DMPlex.metricNoMovement,        DMPlex.metricNoInsertion,
                        DMPlex.metricNoSwapping, DMPlexMetricNoSurfSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2563ReturntypeboolmetricNoSwapping()
                     Return the flag indicating whether facet swapping is turned off.

                     Not collective.

                     SEEALSO:DMPlex.metricSetNoSwapping,      DMPlex.metricNoInsertion,      DMPlex.metricNoMovement,
                        DMPlex.metricNoSurf, DMPlexMetricNoSwappingSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2491ReturntypeboolmetricNormalize(metric,ometric,determinant,restrictSizes=True,restrictAnisotropy=True)
                     Apply L-p normalization to a metric.

                     Collective.

                     Parameters

                            • metric (Vec) -- The metric.

                            • ometric (Vec) -- The output metric.

                            • determinant (Vec) -- The output determinant.

                            • restrictSizes (bool|None) -- Flag indicating whether maximum/minimum  magnitudes
                              should be enforced.

                            • restrictAnisotropy  (bool|None)  -- Flag indicating whether maximum anisotropy
                              should be enforced.

                     Returns

                            • ometric (Vec) -- The output normalized metric.

                            • determinant (Vec) -- The output determinant.

                     Returntypetuple[Vec, Vec]

                     SEEALSO:DMPlex.metricEnforceSPD, DMPlex.metricIntersection2, DMPlex.metricIntersection3, WorkingwithPETScoptions, DMPlexMetricNormalizeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3023metricRestrictAnisotropyFirst()
                     Return true if anisotropy is restricted before normalization.

                     Not collective.

                     SEEALSO:DMPlex.metricIsIsotropic,           DMPlex.metricSetRestrictAnisotropyFirst,           ‐
                        DMPlexMetricRestrictAnisotropyFirstSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2420ReturntypeboolmetricSetFromOptions()
                     Configure the object from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptionsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2320ReturntypeNonemetricSetGradationFactor(beta)
                     Set the metric gradation factor.

                     Logically collective.

                     Parametersbeta (float) -- The metric gradation factor.

                     ReturntypeNoneSEEALSO:DMPlex.metricGetGradationFactor,            DMPlex.metricSetHausdorffNumber,           ‐
                        DMPlexMetricSetGradationFactorSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2822metricSetHausdorffNumber(hausd)
                     Set the metric Hausdorff number.

                     Logically collective.

                     Parametershausd (float) -- The metric Hausdorff number.

                     ReturntypeNoneSEEALSO:DMPlex.metricSetGradationFactor,           DMPlex.metricGetHausdorffNumber,            ‐
                        DMPlexMetricSetHausdorffNumberSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2856metricSetIsotropic(isotropic)
                     Record whether the metric is isotropic or not.

                     Logically collective.

                     Parametersisotropic (bool) -- Flag indicating whether the metric is isotropic or not.

                     ReturntypeNoneSEEALSO:DMPlex.metricIsIsotropic,                                       DMPlex.metricSetUniform,
                        DMPlex.metricSetRestrictAnisotropyFirst, DMPlexMetricSetIsotropicSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2367metricSetMaximumAnisotropy(a_max)
                     Set the maximum tolerated metric anisotropy.

                     Logically collective.

                     Parametersa_max (float) -- The maximum tolerated metric anisotropy.

                     ReturntypeNoneSEEALSO:DMPlex.metricGetMaximumAnisotropy,          DMPlex.metricSetMaximumMagnitude,          ‐
                        DMPlexMetricSetMaximumAnisotropySourcecodeatpetsc4py/PETSc/DMPlex.pyx:2720metricSetMaximumMagnitude(h_max)
                     Set the maximum tolerated metric magnitude.

                     Logically collective.

                     Parametersh_max (float) -- The maximum tolerated metric magnitude.

                     ReturntypeNoneSEEALSO:DMPlex.metricGetMaximumMagnitude,           DMPlex.metricSetMinimumMagnitude,          ‐
                        DMPlexMetricSetMaximumMagnitudeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2686metricSetMinimumMagnitude(h_min)
                     Set the minimum tolerated metric magnitude.

                     Logically collective.

                     Parametersh_min (float) -- The minimum tolerated metric magnitude.

                     ReturntypeNoneSEEALSO:DMPlex.metricGetMinimumMagnitude,          DMPlex.metricSetMaximumMagnitude,           ‐
                        DMPlexMetricSetMinimumMagnitudeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2652metricSetNoInsertion(noInsert)
                     Set the flag indicating whether node insertion should be turned off.

                     Logically collective.

                     ParametersnoInsert  (bool)  --  Flag  indicating whether node insertion and deletion should be
                            turned off.

                     ReturntypeNoneSEEALSO:DMPlex.metricNoInsertion,    DMPlex.metricSetNoSwapping,     DMPlex.metricSetNoMovement,
                        DMPlex.metricSetNoSurf, DMPlexMetricSetNoInsertionSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2435metricSetNoMovement(noMove)
                     Set the flag indicating whether node movement should be turned off.

                     Logically collective.

                     ParametersnoMove (bool) -- Flag indicating whether node movement should be turned off.

                     ReturntypeNoneSEEALSO:DMPlex.metricNoMovement,     DMPlex.metricSetNoInsertion,    DMPlex.metricSetNoSwapping,
                        DMPlex.metricSetNoSurf, DMPlexMetricSetNoMovementSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2507metricSetNoSurf(noSurf)
                     Set the flag indicating whether surface modification should be turned off.

                     Logically collective.

                     ParametersnoSurf (bool) -- Flag indicating whether surface modification should be turned off.

                     ReturntypeNoneSEEALSO:DMPlex.metricNoSurf,      DMPlex.metricSetNoMovement,       DMPlex.metricSetNoInsertion,
                        DMPlex.metricSetNoSwapping, DMPlexMetricSetNoSurfSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2543metricSetNoSwapping(noSwap)
                     Set the flag indicating whether facet swapping should be turned off.

                     Logically collective.

                     ParametersnoSwap (bool) -- Flag indicating whether facet swapping should be turned off.

                     ReturntypeNoneSEEALSO:DMPlex.metricNoSwapping,     DMPlex.metricSetNoInsertion,    DMPlex.metricSetNoMovement,
                        DMPlex.metricSetNoSurf, DMPlexMetricSetNoSwappingSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2471metricSetNormalizationOrder(p)
                     Set the order p for L-p normalization.

                     Logically collective.

                     Parametersp (float) -- The normalization order.

                     ReturntypeNoneSEEALSO:DMPlex.metricGetNormalizationOrder,         DMPlex.metricSetTargetComplexity,          ‐
                        DMPlexMetricSetNormalizationOrderSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2788metricSetNumIterations(numIter)
                     Set the number of parallel adaptation iterations.

                     Logically collective.

                     ParametersnumIter (int) -- The number of parallel adaptation iterations.

                     ReturntypeNoneSEEALSO:DMPlex.metricSetVerbosity, DMPlex.metricGetNumIterations, DMPlexMetricSetNumIterationsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2618metricSetRestrictAnisotropyFirst(restrictAnisotropyFirst)
                     Record whether anisotropy is be restricted before normalization or after.

                     Logically collective.

                     ParametersrestrictAnisotropyFirst (bool) -- Flag indicating if anisotropy is restricted before
                            normalization or after.

                     ReturntypeNoneSEEALSO:DMPlex.metricSetIsotropic,            DMPlex.metricRestrictAnisotropyFirst,            ‐
                        DMPlexMetricSetRestrictAnisotropyFirstSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2401metricSetTargetComplexity(targetComplexity)
                     Set the target metric complexity.

                     Logically collective.

                     ParameterstargetComplexity (float) -- The target metric complexity.

                     ReturntypeNoneSEEALSO:DMPlex.metricGetTargetComplexity,         DMPlex.metricSetNormalizationOrder,          ‐
                        DMPlexMetricSetTargetComplexitySourcecodeatpetsc4py/PETSc/DMPlex.pyx:2754metricSetUniform(uniform)
                     Record whether the metric is uniform or not.

                     Logically collective.

                     Parametersuniform (bool) -- Flag indicating whether the metric is uniform or not.

                     ReturntypeNoneSEEALSO:DMPlex.metricIsUniform,                                       DMPlex.metricSetIsotropic,
                        DMPlex.metricSetRestrictAnisotropyFirst, DMPlexMetricSetUniformSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2333metricSetVerbosity(verbosity)
                     Set the verbosity of the mesh adaptation package.

                     Logically collective.

                     Parametersverbosity (int) -- The verbosity, where -1 is silent and 10 is maximum.

                     ReturntypeNoneSEEALSO:DMPlex.metricGetVerbosity, DMPlex.metricSetNumIterations, DMPlexMetricSetVerbositySourcecodeatpetsc4py/PETSc/DMPlex.pyx:2579orient()
                     Give a consistent orientation to the input mesh.

                     Collective.

                     SEEALSO:DM, DMPlex, DM.create, DMPlexOrientSourcecodeatpetsc4py/PETSc/DMPlex.pyx:873ReturntypeNonepermute(perm)
                     Reorder the mesh according to the input permutation.

                     Collective.

                     Parametersperm (IS) -- The point permutation, perm[oldpointnumber]=newpointnumber.

                     Returnspdm -- The permuted DMPlex.

                     ReturntypeDMPlexSEEALSO:DMPlex, Mat.permute, DMPlexPermuteSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2158rebalanceSharedPoints(entityDepth=0,useInitialGuess=True,parallel=True)
                     Redistribute shared points in order to achieve better balancing.

                     Collective.

                     Parameters

                            • entityDepth (int|None) -- Depth of the entity to balance  (e.g.,  0  ->  balance
                              vertices).

                            • useInitialGuess  (bool|None)  --  Whether  to  use the current distribution as
                              initial guess.

                            • parallel (bool|None) -- Whether to use ParMETIS and do the partition in parallel
                              or gather the graph onto a single process.

                     Returnssuccess -- Whether the graph  partitioning  was  successful  or  not.   Unsuccessful
                            simply means no change to the partitioning.

                     ReturntypeboolSEEALSO:DM, DMPlex, DMPlex.distribute, WorkingwithPETScoptions, DMPlexRebalanceSharedPointsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1527reorderGetDefault()
                     Return flag indicating whether the DMPlex should be reordered by default.

                     Not collective.

                     SEEALSO:None, DMPlexReorderGetDefaultSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2182ReturntypeReorderDefaultFlagreorderSetDefault(flag)
                     Set flag indicating whether the DM should be reordered by default.

                     Logically collective.

                     Parameters

                            • reorder -- Flag for reordering.

                            • flag (ReorderDefaultFlag)

                     ReturntypeNoneSEEALSO:DMPlex.reorderGetDefault, DMPlexReorderSetDefaultSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2196sectionLoad(viewer,sectiondm,sfxc)
                     Load section into a DM.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer that represents the on-disk section (sectionA).

                            • sectiondm (DM) -- The DM into which the on-disk section (sectionA) is migrated.

                            • sfxc (SF) -- The SF returned by topologyLoad.

                     Returns

                            • gsf  (SF)  --  The  SF that migrates any on-disk Vec data associated with sectionA
                              into a global Vec associated with the sectiondm's  global  section  (None  if  not
                              needed).

                            • lsf  (SF)  --  The  SF that migrates any on-disk Vec data associated with sectionA
                              into a local Vec associated with  the  sectiondm's  local  section  (None  if  not
                              needed).

                     Returntypetuple[SF, SF]

                     SEEALSO:DM,  DMPlex,  DM.load,  DMPlex.topologyLoad,  DMPlex.coordinatesLoad, DMPlex.labelsLoad,
                        DMPlex.globalVectorLoad,  DMPlex.localVectorLoad,  DMPlex.sectionView,  SF,  Viewer,   ‐
                        DMPlexSectionLoadSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3364sectionView(viewer,sectiondm)
                     Save a section associated with a DMPlex.

                     Collective.

                     Parameters

                            • viewer (Viewer) -- The Viewer for saving.

                            • sectiondm (DM) -- The DM that contains the section to be saved.

                     ReturntypeNoneSEEALSO:DM,  DMPlex,  DM.view,  DMPlex.topologyView,  DMPlex.coordinatesView, DMPlex.labelsView,
                        DMPlex.globalVectorView,   DMPlex.localVectorView,   DMPlex.sectionLoad,    Viewer,    ‐
                        DMPlexSectionViewSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3227setAdjacencyUseAnchors(useAnchors=True)
                     Define adjacency in the mesh using the point-to-point constraints.

                     Logically collective.

                     ParametersuseAnchors  (bool) -- Flag to use the constraints.  If True, then constrained points
                            are omitted from DMPlex.getAdjacency, and their anchor points appear in their place.

                     ReturntypeNoneSEEALSO:DMPlex, DMPlex.getAdjacency, DMPlex.distribute, DMPlexSetAdjacencyUseAnchorsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1431setCellType(p,ctype)
                     Set the polytope type of a given cell.

                     Not collective.

                     Parameters

                            • p (int) -- The cell.

                            • ctype (PolytopeType) -- The polytope type of the cell.

                     ReturntypeNoneSEEALSO:DM, DMPlex, DMPlex.getCellTypeLabel, DMPlex.getDepth, DM.createLabel, DMPlexSetCellTypeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:663setChart(pStart,pEnd)
                     Set the interval for all mesh points [pStart, pEnd).

                     Not collective.

                     Parameters

                            • pStart (int) -- The first mesh point.

                            • pEnd (int) -- The upper bound for mesh points.

                     ReturntypeNoneSEEALSO:DM, DMPlex, DMPlex.create, DMPlex.getChart, DMPlexSetChartSourcecodeatpetsc4py/PETSc/DMPlex.pyx:421setCone(p,cone,orientation=None)
                     Set the points on the in-edges for this point in the DAG.

                     Not collective.

                     Parameters

                            • p (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                            • cone (Sequence[int]) -- An array of points which are on the in-edges for point p.

                            • orientation (Sequence[int]|None) -- An array of orientations, defaults to None.

                     ReturntypeNoneSEEALSO:DM,  DMPlex,   DMPlex.create,   DMPlex.getCone,   DMPlex.setChart,   DMPlex.setConeSize,
                        DM.setUp, DMPlex.setSupport, DMPlex.setSupportSize, DMPlexSetConeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:517setConeOrientation(p,orientation)
                     Set the orientations on the in-edges for this point in the DAG.

                     Not collective.

                     Parameters

                            • p (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                            • orientation (Sequence[int]) -- An array of orientations.

                     ReturntypeNoneSEEALSO:DM,  DMPlex,  DMPlex.create, DMPlex.getConeOrientation, DMPlex.setCone, DMPlex.setChart,
                        DMPlex.setConeSize, DM.setUp, DMPlexSetConeOrientationSourcecodeatpetsc4py/PETSc/DMPlex.pyx:632setConeSize(p,size)
                     Set the number of in-edges for this point in the DAG.

                     Not collective.

                     Parameters

                            • p (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                            • size (int) -- The cone size for point p.

                     ReturntypeNoneSEEALSO:DM, DMPlex, DMPlex.create, DMPlex.getConeSize, DMPlex.setChart, DMPlexSetConeSizeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:466setMatClosure(sec,gsec,mat,point,values,addv=None)
                     Set an array of the values on the closure of point.

                     Not collective.

                     Parameters

                            • sec (Section) -- The section describing the layout in mat,  or  None  to  use  the
                              default section.

                            • gsec  (Section)  --  The  section describing the layout in mat, or None to use the
                              default global section.

                            • mat (Mat) -- The matrix.

                            • point (int) -- The point in the DMPlex.

                            • values (Sequence[Scalar]) -- The array of values.

                            • mode -- The insertion mode.

                            • addv (InsertModeSpec|None)

                     ReturntypeNoneSEEALSO:DM, DMPlex, DMPlexMatSetClosureSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1247setPartitioner(part)
                     Set the mesh partitioner.

                     Logically collective.

                     Parameterspart (Partitioner) -- The partitioner.

                     ReturntypeNoneSEEALSO:DM, DMPlex, Partitioner, DMPlex.distribute, DMPlex.getPartitioner, Partitioner.create, ‐
                        DMPlexSetPartitionerSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1492setRefinementLimit(refinementLimit)
                     Set the maximum cell volume for refinement.

                     Logically collective.

                     ParametersrefinementLimit (float) -- The maximum cell volume in the refined mesh.

                     ReturntypeNoneSEEALSO:DM,   DMPlex,   DM.refine,    DMPlex.getRefinementLimit,    DMPlex.getRefinementUniform,
                        DMPlex.setRefinementUniform, DMPlexSetRefinementLimitSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2094setRefinementUniform(refinementUniform=True)
                     Set the flag for uniform refinement.

                     Logically collective.

                     ParametersrefinementUniform (bool|None) -- The flag for uniform refinement.

                     ReturntypeNoneSEEALSO:DM,    DMPlex,    DM.refine,   DMPlex.getRefinementUniform,   DMPlex.getRefinementLimit,
                        DMPlex.setRefinementLimit, DMPlexSetRefinementUniformSourcecodeatpetsc4py/PETSc/DMPlex.pyx:2053setSupport(p,supp)
                     Set the points on the out-edges for this point in the DAG.

                     Not collective.

                     Parameters

                            • p (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                            • supp (Sequence[int]) -- An array of points which are on the out-edges for point p.

                     ReturntypeNoneSEEALSO:DM,  DMPlex,  DMPlex.setCone,  DMPlex.setConeSize,   DMPlex.create,   DMPlex.getSupport,
                        DMPlex.setChart, DMPlex.setSupportSize, DM.setUp, DMPlexSetSupportSourcecodeatpetsc4py/PETSc/DMPlex.pyx:797setSupportSize(p,size)
                     Set the number of out-edges for this point in the DAG.

                     Not collective.

                     Parameters

                            • p (int) -- The point, which must lie in the chart set with DMPlex.setChart.

                            • size (int) -- The support size for point p.

                     ReturntypeNoneSEEALSO:DM, DMPlex, DMPlex.create, DMPlex.getSupportSize, DMPlex.setChart, DMPlexSetSupportSizeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:746setTetGenOptions(opts)
                     Set the options used for the Tetgen mesh generator.

                     Not collective.

                     Parametersopts (str) -- The command line options.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, DM, DMPlex, DMPlex.setTriangleOptions, DMPlex.generate, ‐
                        DMPlexTetgenSetOptionsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1332setTriangleOptions(opts)
                     Set the options used for the Triangle mesh generator.

                     Not collective.

                     Parametersopts (str) -- The command line options.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions,  DM,  DMPlex,  DMPlex.setTetGenOptions,  DMPlex.generate,  ‐
                        DMPlexTriangleSetOptionsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1312setVecClosure(sec,vec,point,values,addv=None)
                     Set an array of the values on the closure of point.

                     Not collective.

                     Parameters

                            • sec  (Section)  --  The  section  describing the layout in vec, or None to use the
                              default section.

                            • vec (Vec) -- The local vector.

                            • point (int) -- The point in the DMPlex.

                            • values (Sequence[Scalar]) -- The array of values.

                            • mode -- The insertion mode.

                            • addv (InsertModeSpec|None)

                     ReturntypeNoneSEEALSO:DM, DMPlex, DMPlexVecSetClosureSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1215stratify()
                     Calculate the strata of DAG.

                     Collective.

                     SEEALSO:DM, DMPlex, DMPlex.create, DMPlex.symmetrize, DMPlexStratifySourcecodeatpetsc4py/PETSc/DMPlex.pyx:861ReturntypeNonesymmetrize()
                     Create support (out-edge) information from cone (in-edge) information.

                     Not collective.

                     SEEALSO:DM,  DMPlex,  DMPlex.create,  DMPlex.setChart,  DMPlex.setConeSize,  DMPlex.setCone,   ‐
                        DMPlexSymmetrizeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:848ReturntypeNonetopologyLoad(viewer)
                     Load a topology into this DMPlex object.

                     Collective.

                     Parametersviewer (Viewer) -- The Viewer for the saved topology

                     Returnssfxc  --  The SF that pushes points in [0,N) to the associated points in the loaded
                            DMPlex, where N is the global number of points.

                     ReturntypeSFSEEALSO:DM, DMPlex, DM.load, DMPlex.coordinatesLoad, DMPlex.labelsLoad, DM.view, SF,  Viewer,  ‐
                        DMPlexTopologyLoadSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3298topologyView(viewer)
                     Save a DMPlex topology into a file.

                     Collective.

                     Parametersviewer (Viewer) -- The Viewer for saving.

                     ReturntypeNoneSEEALSO:DM,  DMPlex,  DM.view,  DMPlex.coordinatesView,  DMPlex.labelsView, DMPlex.topologyLoad,
                        Viewer, DMPlexTopologyViewSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3173uninterpolate()
                     Convert to a mesh with only cells and vertices.

                     Collective.

                     SEEALSO:DMPlex, DMPlex.interpolate, DMPlex.createFromCellList, DMPlexUninterpolateSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1743ReturntypeNonevecGetClosure(sec,vec,p)
                     Return an array of values on the closure of p.

                     Not collective.

                     Parameters

                            • sec (Section) -- The section describing the layout in vec.

                            • vec (Vec) -- The local vector.

                            • p (int) -- The point in the DMPlex.

                     ReturntypeArrayScalarSEEALSO:DM, DMPlex, DMPlexVecRestoreClosureSourcecodeatpetsc4py/PETSc/DMPlex.pyx:1157petsc4py.PETSc.DMPlexTransformclasspetsc4py.PETSc.DMPlexTransform
              Bases: Object

              Mesh transformations.

              Methods Summary
                                ┌──────────────────┬───────────────────────────────────────┐
                                │ apply(dm)        │ Apply a mesh transformation.          │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ create([comm])   │ Create a mesh transformation.         │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ destroy()        │ Destroy a mesh transformation.        │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ getType()        │ Return the transformation type name.  │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ setDM(dm)        │ Set the DM for the transformation.    │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ setFromOptions() │ Configure the transformation from the │
                                │                  │ options database.                     │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ setType(tr_type) │ Set the transformation type.          │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ setUp()          │ Setup a mesh transformation.          │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ view([viewer])   │ View the mesh transformation.         │
                                └──────────────────┴───────────────────────────────────────┘

              Methods Documentation

              apply(dm)
                     Apply a mesh transformation.

                     Collective.

                     Sourcecodeatpetsc4py/PETSc/DMPlex.pyx:3475Parametersdm (DM)

                     ReturntypeDMcreate(comm=None)
                     Create a mesh transformation.

                     Collective.

                     SEEALSO:DMPlexTransformCreateSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3486Parameterscomm (Comm|None)

                     ReturntypeSelfdestroy()
                     Destroy a mesh transformation.

                     Collective.

                     SEEALSO:DMPlexTransformDestroySourcecodeatpetsc4py/PETSc/DMPlex.pyx:3503ReturntypeSelfgetType()
                     Return the transformation type name.

                     Not collective.

                     SEEALSO:DMPlexTransformGetTypeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3516ReturntypestrsetDM(dm)
                     Set the DM for the transformation.

                     Logically collective.

                     Sourcecodeatpetsc4py/PETSc/DMPlex.pyx:3554Parametersdm (DM)

                     ReturntypeNonesetFromOptions()
                     Configure the transformation from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, DMPlexTransformSetFromOptionsSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3563ReturntypeNonesetType(tr_type)
                     Set the transformation type.

                     Collective.

                     SEEALSO:DMPlexTransformSetTypeSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3540Parameterstr_type (DMPlexTransformType|str)

                     ReturntypeNonesetUp()
                     Setup a mesh transformation.

                     Collective.

                     Sourcecodeatpetsc4py/PETSc/DMPlex.pyx:3530ReturntypeSelfview(viewer=None)
                     View the mesh transformation.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:Viewer, DMPlexTransformViewSourcecodeatpetsc4py/PETSc/DMPlex.pyx:3575petsc4py.PETSc.DMPlexTransformTypeclasspetsc4py.PETSc.DMPlexTransformType
              Bases: object

              Transformation types.

              Attributes Summary
                               ┌─────────────────────┬───────────────────────────────────────┐
                               │ EXTRUDE             │ Object EXTRUDE of type str            │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ REFINE1D            │ Object REFINE1D of type str           │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ REFINEALFELD        │ Object REFINEALFELD of type str       │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ REFINEBOUNDARYLAYER │ Object REFINEBOUNDARYLAYER of type  ‐ │
                               │                     │ str                                   │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ REFINEPOWELLSABIN   │ Object REFINEPOWELLSABIN of type str  │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ REFINEREGULAR       │ Object REFINEREGULAR of type str      │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ REFINESBR           │ Object REFINESBR of type str          │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ REFINETOBOX         │ Object REFINETOBOX of type str        │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ REFINETOSIMPLEX     │ Object REFINETOSIMPLEX of type str    │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ TRANSFORMFILTER     │ Object TRANSFORMFILTER of type str    │
                               └─────────────────────┴───────────────────────────────────────┘

              Attributes Documentation

              EXTRUDE:str=EXTRUDE
                     Object EXTRUDE of type strREFINE1D:str=REFINE1D
                     Object REFINE1D of type strREFINEALFELD:str=REFINEALFELD
                     Object REFINEALFELD of type strREFINEBOUNDARYLAYER:str=REFINEBOUNDARYLAYER
                     Object REFINEBOUNDARYLAYER of type strREFINEPOWELLSABIN:str=REFINEPOWELLSABIN
                     Object REFINEPOWELLSABIN of type strREFINEREGULAR:str=REFINEREGULAR
                     Object REFINEREGULAR of type strREFINESBR:str=REFINESBR
                     Object REFINESBR of type strREFINETOBOX:str=REFINETOBOX
                     Object REFINETOBOX of type strREFINETOSIMPLEX:str=REFINETOSIMPLEX
                     Object REFINETOSIMPLEX of type strTRANSFORMFILTER:str=TRANSFORMFILTER
                     Object TRANSFORMFILTER of type strpetsc4py.PETSc.DMShellclasspetsc4py.PETSc.DMShell
              Bases: DM

              A shell DM object, used to manage user-defined problem data.

              Methods Summary
                  ┌───────────────────────────────────────────────┬───────────────────────────────────────┐
                  │ create([comm])                                │ Creates a shell DM object.            │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCoarsen(coarsen[, args, kargs])            │ Set  the  routine used to coarsen the │
                  │                                               │ DMShell.                              │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateDomainDecomposition(decomp[,         │ Set the  routine  used  to  create  a │
                  │ args, ...])                                   │ domain decomposition.                 │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateDomainDecompositionScatters(scatter) │ Set  the  routine  used to create the │
                  │                                               │ scatter    contexts    for     domain │
                  │                                               │ decomposition.                        │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateFieldDecomposition(decomp[,    args, │ Set the  routine  used  to  create  a │
                  │ ...])                                         │ field decomposition.                  │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateGlobalVector(create_gvec[,     args, │ Set the routine to  create  a  global │
                  │ kargs])                                       │ vector.                               │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateInjection(create_injection[,   args, │ Set the routine used  to  create  the │
                  │ ...])                                         │ injection operator.                   │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateInterpolation(create_interpolation)  │ Set  the  routine  used to create the │
                  │                                               │ interpolation operator.               │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateLocalVector(create_lvec[,      args, │ Set  the  routine  to  create a local │
                  │ kargs])                                       │ vector.                               │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateMatrix(create_matrix[, args, kargs]) │ Set the routine to create a matrix.   │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateRestriction(create_restriction[,     │ Set the routine used  to  create  the │
                  │ ...])                                         │ restriction operator.                 │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setCreateSubDM(create_subdm[, args, kargs])   │ Set  the routine used to create a sub │
                  │                                               │ DM from the DMShell.                  │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setGlobalToLocal(begin,   end[,   begin_args, │ Set  the  routines  used to perform a │
                  │ ...])                                         │ global to local scatter.              │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setGlobalToLocalVecScatter(gtol)              │ Set a Scatter context for  global  to │
                  │                                               │ local communication.                  │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setGlobalVector(gv)                           │ Set a template global vector.         │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setLocalToGlobal(begin,   end[,   begin_args, │ Set the routines used  to  perform  a │
                  │ ...])                                         │ local to global scatter.              │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setLocalToGlobalVecScatter(ltog)              │ Set  a  Scatter  context for local to │
                  │                                               │ global communication.                 │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setLocalToLocal(begin,   end[,    begin_args, │ Set  the  routines  used to perform a │
                  │ ...])                                         │ local to local scatter.               │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setLocalToLocalVecScatter(ltol)               │ Set a Scatter context  for  local  to │
                  │                                               │ local communication.                  │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setLocalVector(lv)                            │ Set a template local vector.          │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setMatrix(mat)                                │ Set a template matrix.                │
                  ├───────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setRefine(refine[, args, kargs])              │ Set  the  routine  used to refine the │
                  │                                               │ DMShell.                              │
                  └───────────────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Creates a shell DM object.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DMShellCreateSourcecodeatpetsc4py/PETSc/DMShell.pyx:4setCoarsen(coarsen,args=None,kargs=None)
                     Set the routine used to coarsen the DMShell.

                     Logically collective.

                     Parameters

                            • coarsen (Callable[[DM,Comm],DM]|None) -- The routine which coarsens the DM.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for coarsen.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for coarsen.

                     ReturntypeNoneSEEALSO:setRefine, DMShellSetCoarsenSourcecodeatpetsc4py/PETSc/DMShell.pyx:368setCreateDomainDecomposition(decomp,args=None,kargs=None)
                     Set the routine used to create a domain decomposition.

                     Logically collective.

                     Parameters

                            • decomp (Callable[[DM],tuple[list[str]|None,list[IS]|None,list[IS]|None, ‐
                              list[DM]|None]]|None) -- The routine to create the decomposition.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for decomp.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for decomp.

                     ReturntypeNoneSEEALSO:DMShellSetCreateDomainDecompositionSourcecodeatpetsc4py/PETSc/DMShell.pyx:560setCreateDomainDecompositionScatters(scatter,args=None,kargs=None)
                     Set the routine used to create the scatter contexts for domain decomposition.

                     Logically collective.

                     Parameters

                            • scatter  (Callable[[DM,list[DM]],tuple[list[Scatter],list[Scatter],list[‐Scatter]]]|None) -- The routine to create the scatters.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for scatter.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for scatter.

                     ReturntypeNoneSEEALSO:DMShellSetCreateDomainDecompositionScattersSourcecodeatpetsc4py/PETSc/DMShell.pyx:592setCreateFieldDecomposition(decomp,args=None,kargs=None)
                     Set the routine used to create a field decomposition.

                     Logically collective.

                     Parameters

                            • decomp  (Callable[[DM],tuple[list[str]|None,list[IS]|None,list[DM]|None]]|None) -- The routine to create the decomposition.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for decomp.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for decomp.

                     ReturntypeNoneSEEALSO:DMShellSetCreateFieldDecompositionSourcecodeatpetsc4py/PETSc/DMShell.pyx:528setCreateGlobalVector(create_gvec,args=None,kargs=None)
                     Set the routine to create a global vector.

                     Logically collective.

                     Parameters

                            • create_gvec (Callable[[DM],Vec]|None) -- The creation routine.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for create_gvec.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for create_gvec.

                     ReturntypeNoneSEEALSO:setCreateLocalVector, DMShellSetCreateGlobalVectorSourcecodeatpetsc4py/PETSc/DMShell.pyx:76setCreateInjection(create_injection,args=None,kargs=None)
                     Set the routine used to create the injection operator.

                     Logically collective.

                     Parameters

                            • create_injection (Callable[[DM,DM],Mat]|None) -- The  routine  to  create  the
                              injection.

                            • args   (tuple[Any,...]|None)   --  Additional  positional  arguments  for
                              create_injection.

                            • kargs  (dict[str,Any]|None)   --   Additional   keyword   arguments   for
                              create_injection.

                     ReturntypeNoneSEEALSO:DMShellSetCreateInjectionSourcecodeatpetsc4py/PETSc/DMShell.pyx:464setCreateInterpolation(create_interpolation,args=None,kargs=None)
                     Set the routine used to create the interpolation operator.

                     Logically collective.

                     Parameters

                            • create_interpolation  (Callable[[DM,DM],tuple[Mat,Vec]]|None) -- The routine
                              to create the interpolation.

                            • args  (tuple[Any,...]|None)   --   Additional   positional   arguments   for
                              create_interpolation.

                            • kargs   (dict[str,Any]|None)   --   Additional   keyword   arguments  for
                              create_interpolation.

                     ReturntypeNoneSEEALSO:DMShellSetCreateInterpolationSourcecodeatpetsc4py/PETSc/DMShell.pyx:432setCreateLocalVector(create_lvec,args=None,kargs=None)
                     Set the routine to create a local vector.

                     Logically collective.

                     Parameters

                            • create_lvec (Callable[[DM],Vec]|None) -- The creation routine.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for create_lvec.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for create_lvec.

                     ReturntypeNoneSEEALSO:setCreateGlobalVector, DMShellSetCreateLocalVectorSourcecodeatpetsc4py/PETSc/DMShell.pyx:108setCreateMatrix(create_matrix,args=None,kargs=None)
                     Set the routine to create a matrix.

                     Logically collective.

                     Parameters

                            • create_matrix (Callable[[DM],Mat]|None) -- The function to create a matrix.

                            • args  (tuple[Any,...]|None)   --   Additional   positional   arguments   for
                              create_matrix.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for create_matrix.

                     ReturntypeNoneSEEALSO:DMShellSetCreateMatrixSourcecodeatpetsc4py/PETSc/DMShell.pyx:336setCreateRestriction(create_restriction,args=None,kargs=None)
                     Set the routine used to create the restriction operator.

                     Logically collective.

                     Parameters

                            • create_restriction  (Callable[[DM,DM],Mat]|None) -- The routine to create the
                              restriction

                            • args  (tuple[Any,...]|None)   --   Additional   positional   arguments   for
                              create_restriction.

                            • kargs   (dict[str,Any]|None)   --   Additional   keyword   arguments  for
                              create_restriction.

                     ReturntypeNoneSEEALSO:DMShellSetCreateRestrictionSourcecodeatpetsc4py/PETSc/DMShell.pyx:496setCreateSubDM(create_subdm,args=None,kargs=None)
                     Set the routine used to create a sub DM from the DMShell.

                     Logically collective.

                     Parameters

                            • subdm -- The routine to create the decomposition.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for subdm.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for subdm.

                            • create_subdm (Callable[[DM,Sequence[int]],tuple[IS,DM]]|None)

                     ReturntypeNoneSEEALSO:DMShellSetCreateSubDMSourcecodeatpetsc4py/PETSc/DMShell.pyx:624setGlobalToLocal(begin,end,begin_args=None,begin_kargs=None,end_args=None,end_kargs=None)
                     Set the routines used to perform a global to local scatter.

                     Logically collective.

                     Parameters

                            • dm -- The DMShell.

                            • begin (Callable[[DM,Vec,InsertMode,Vec],None]|None)  --  The  routine  which
                              begins the global to local scatter.

                            • end  (Callable[[DM,Vec,InsertMode,Vec],None]|None) -- The routine which ends
                              the global to local scatter.

                            • begin_args (tuple[Any,...]|None) -- Additional positional arguments for begin.

                            • begin_kargs (dict[str,Any]|None) -- Additional keyword arguments for begin.

                            • end_args (tuple[Any,...]|None) -- Additional positional arguments for end.

                            • end_kargs (dict[str,Any]|None) -- Additional keyword arguments for end.

                     ReturntypeNoneSEEALSO:DMShellSetGlobalToLocalSourcecodeatpetsc4py/PETSc/DMShell.pyx:140setGlobalToLocalVecScatter(gtol)
                     Set a Scatter context for global to local communication.

                     Logically collective.

                     Parametersgtol (Scatter) -- The global to local Scatter context.

                     ReturntypeNoneSEEALSO:DMShellSetGlobalToLocalVecScatterSourcecodeatpetsc4py/PETSc/DMShell.pyx:189setGlobalVector(gv)
                     Set a template global vector.

                     Logically collective.

                     Parametersgv (Vec) -- Template vector.

                     ReturntypeNoneSEEALSO:setLocalVector, DMShellSetGlobalVectorSourcecodeatpetsc4py/PETSc/DMShell.pyx:42setLocalToGlobal(begin,end,begin_args=None,begin_kargs=None,end_args=None,end_kargs=None)
                     Set the routines used to perform a local to global scatter.

                     Logically collective.

                     Parameters

                            • begin (Callable[[DM,Vec,InsertMode,Vec],None]|None)  --  The  routine  which
                              begins the local to global scatter.

                            • end  (Callable[[DM,Vec,InsertMode,Vec],None]|None) -- The routine which ends
                              the local to global scatter.

                            • begin_args (tuple[Any,...]|None) -- Additional positional arguments for begin.

                            • begin_kargs (dict[str,Any]|None) -- Additional keyword arguments for begin.

                            • end_args (tuple[Any,...]|None) -- Additional positional arguments for end.

                            • end_kargs (dict[str,Any]|None) -- Additional keyword arguments for end.

                     ReturntypeNoneSEEALSO:DMShellSetLocalToGlobalSourcecodeatpetsc4py/PETSc/DMShell.pyx:206setLocalToGlobalVecScatter(ltog)
                     Set a Scatter context for local to global communication.

                     Logically collective.

                     Parametersltog (Scatter) -- The local to global Scatter context.

                     ReturntypeNoneSEEALSO:DMShellSetLocalToGlobalVecScatterSourcecodeatpetsc4py/PETSc/DMShell.pyx:253setLocalToLocal(begin,end,begin_args=None,begin_kargs=None,end_args=None,end_kargs=None)
                     Set the routines used to perform a local to local scatter.

                     Logically collective.

                     Parameters

                            • begin (Callable[[DM,Vec,InsertMode,Vec],None]|None)  --  The  routine  which
                              begins the local to local scatter.

                            • end  (Callable[[DM,Vec,InsertMode,Vec],None]|None) -- The routine which ends
                              the local to local scatter.

                            • begin_args (tuple[Any,...]|None) -- Additional positional arguments for begin.

                            • begin_kargs (dict[str,Any]|None) -- Additional keyword arguments for begin.

                            • end_args (tuple[Any,...]|None) -- Additional positional arguments for end.

                            • end_kargs (dict[str,Any]|None) -- Additional keyword arguments for end.

                     ReturntypeNoneSEEALSO:DMShellSetLocalToLocalSourcecodeatpetsc4py/PETSc/DMShell.pyx:270setLocalToLocalVecScatter(ltol)
                     Set a Scatter context for local to local communication.

                     Logically collective.

                     Parametersltol (Scatter) -- The local to local Scatter context.

                     ReturntypeNoneSEEALSO:DMShellSetLocalToLocalVecScatterSourcecodeatpetsc4py/PETSc/DMShell.pyx:319setLocalVector(lv)
                     Set a template local vector.

                     Logically collective.

                     Parameterslv (Vec) -- Template vector.

                     ReturntypeNoneSEEALSO:setGlobalVector, DMShellSetLocalVectorSourcecodeatpetsc4py/PETSc/DMShell.pyx:59setMatrix(mat)
                     Set a template matrix.

                     Collective.

                     Parametersmat (Mat) -- The template matrix.

                     ReturntypeNoneSEEALSO:DMShellSetMatrixSourcecodeatpetsc4py/PETSc/DMShell.pyx:25setRefine(refine,args=None,kargs=None)
                     Set the routine used to refine the DMShell.

                     Logically collective.

                     Parameters

                            • refine (Callable[[DM,Comm],DM]|None) -- The routine which refines the DM.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for refine.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for refine.

                     ReturntypeNoneSEEALSO:setCoarsen, DMShellSetRefineSourcecodeatpetsc4py/PETSc/DMShell.pyx:400petsc4py.PETSc.DMStagclasspetsc4py.PETSc.DMStag
              Bases: DM

              A DM object representing a "staggered grid" or a structured cell complex.

              Enumerations
                                        ┌─────────────────┬─────────────────────────┐
                                        │ StencilLocation │ Stencil location types. │
                                        ├─────────────────┼─────────────────────────┤
                                        │ StencilType     │ Stencil types.          │
                                        └─────────────────┴─────────────────────────┘

   petsc4py.PETSc.DMStag.StencilLocationclasspetsc4py.PETSc.DMStag.StencilLocation
                     Bases: object

                     Stencil location types.

                     Attributes Summary
                                    ┌──────────────────┬───────────────────────────────────────┐
                                    │ BACK             │ Constant BACK of type int             │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ BACK_DOWN        │ Constant BACK_DOWN of type int        │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ BACK_DOWN_LEFT   │ Constant BACK_DOWN_LEFT of type int   │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ BACK_DOWN_RIGHT  │ Constant BACK_DOWN_RIGHT of type int  │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ BACK_LEFT        │ Constant BACK_LEFT of type int        │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ BACK_RIGHT       │ Constant BACK_RIGHT of type int       │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ BACK_UP          │ Constant BACK_UP of type int          │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ BACK_UP_LEFT     │ Constant BACK_UP_LEFT of type int     │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ BACK_UP_RIGHT    │ Constant BACK_UP_RIGHT of type int    │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ DOWN             │ Constant DOWN of type int             │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ DOWN_LEFT        │ Constant DOWN_LEFT of type int        │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ DOWN_RIGHT       │ Constant DOWN_RIGHT of type int       │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ ELEMENT          │ Constant ELEMENT of type int          │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT            │ Constant FRONT of type int            │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT_DOWN       │ Constant FRONT_DOWN of type int       │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT_DOWN_LEFT  │ Constant FRONT_DOWN_LEFT of type int  │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT_DOWN_RIGHT │ Constant FRONT_DOWN_RIGHT of type int │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT_LEFT       │ Constant FRONT_LEFT of type int       │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT_RIGHT      │ Constant FRONT_RIGHT of type int      │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT_UP         │ Constant FRONT_UP of type int         │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT_UP_LEFT    │ Constant FRONT_UP_LEFT of type int    │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ FRONT_UP_RIGHT   │ Constant FRONT_UP_RIGHT of type int   │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ LEFT             │ Constant LEFT of type int             │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ NULLLOC          │ Constant NULLLOC of type int          │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ RIGHT            │ Constant RIGHT of type int            │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ UP               │ Constant UP of type int               │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ UP_LEFT          │ Constant UP_LEFT of type int          │
                                    ├──────────────────┼───────────────────────────────────────┤
                                    │ UP_RIGHT         │ Constant UP_RIGHT of type int         │
                                    └──────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     BACK:int=BACK
                            Constant BACK of type intBACK_DOWN:int=BACK_DOWN
                            Constant BACK_DOWN of type intBACK_DOWN_LEFT:int=BACK_DOWN_LEFT
                            Constant BACK_DOWN_LEFT of type intBACK_DOWN_RIGHT:int=BACK_DOWN_RIGHT
                            Constant BACK_DOWN_RIGHT of type intBACK_LEFT:int=BACK_LEFT
                            Constant BACK_LEFT of type intBACK_RIGHT:int=BACK_RIGHT
                            Constant BACK_RIGHT of type intBACK_UP:int=BACK_UP
                            Constant BACK_UP of type intBACK_UP_LEFT:int=BACK_UP_LEFT
                            Constant BACK_UP_LEFT of type intBACK_UP_RIGHT:int=BACK_UP_RIGHT
                            Constant BACK_UP_RIGHT of type intDOWN:int=DOWN
                            Constant DOWN of type intDOWN_LEFT:int=DOWN_LEFT
                            Constant DOWN_LEFT of type intDOWN_RIGHT:int=DOWN_RIGHT
                            Constant DOWN_RIGHT of type intELEMENT:int=ELEMENT
                            Constant ELEMENT of type intFRONT:int=FRONT
                            Constant FRONT of type intFRONT_DOWN:int=FRONT_DOWN
                            Constant FRONT_DOWN of type intFRONT_DOWN_LEFT:int=FRONT_DOWN_LEFT
                            Constant FRONT_DOWN_LEFT of type intFRONT_DOWN_RIGHT:int=FRONT_DOWN_RIGHT
                            Constant FRONT_DOWN_RIGHT of type intFRONT_LEFT:int=FRONT_LEFT
                            Constant FRONT_LEFT of type intFRONT_RIGHT:int=FRONT_RIGHT
                            Constant FRONT_RIGHT of type intFRONT_UP:int=FRONT_UP
                            Constant FRONT_UP of type intFRONT_UP_LEFT:int=FRONT_UP_LEFT
                            Constant FRONT_UP_LEFT of type intFRONT_UP_RIGHT:int=FRONT_UP_RIGHT
                            Constant FRONT_UP_RIGHT of type intLEFT:int=LEFT
                            Constant LEFT of type intNULLLOC:int=NULLLOC
                            Constant NULLLOC of type intRIGHT:int=RIGHT
                            Constant RIGHT of type intUP:int=UP
                            Constant UP of type intUP_LEFT:int=UP_LEFT
                            Constant UP_LEFT of type intUP_RIGHT:int=UP_RIGHT
                            Constant UP_RIGHT of type intpetsc4py.PETSc.DMStag.StencilTypeclasspetsc4py.PETSc.DMStag.StencilType
                     Bases: object

                     Stencil types.

                     Attributes Summary
                                                ┌──────┬───────────────────────────┐
                                                │ BOX  │ Constant BOX of type int  │
                                                ├──────┼───────────────────────────┤
                                                │ NONE │ Constant NONE of type int │
                                                ├──────┼───────────────────────────┤
                                                │ STAR │ Constant STAR of type int │
                                                └──────┴───────────────────────────┘

                     Attributes Documentation

                     BOX:int=BOX
                            Constant BOX of type intNONE:int=NONE
                            Constant NONE of type intSTAR:int=STAR
                            Constant STAR of type int

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ VecSplitToDMDA(vec, loc, c)           │ Return DMDA, Vec from a subgrid of  a │
                      │                                       │ DMStag, its Vec.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create(dim[,       dofs,       sizes, │ Create a DMDA object.                 │
                      │ boundary_types, ...])                 │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createCompatibleDMStag(dofs)          │ Create  a  compatible   DMStag   with │
                      │                                       │ different DOFs/stratum.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ get1dCoordinatecArrays()              │ Not implemented.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBoundaryTypes()                    │ Return   boundary   types   in   each │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCorners()                          │ Return starting element index,  width │
                      │                                       │ and number of partial elements.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDim()                              │ Return the number of dimensions.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDof()                              │ Get  number  of  DOFs associated with │
                      │                                       │ each stratum of the grid.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getEntriesPerElement()                │ Return  the  number  of  entries  per │
                      │                                       │ element in the local representation.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getGhostCorners()                     │ Return  starting  element  index  and │
                      │                                       │ width of local region.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getGlobalSizes()                      │ Return global element counts in  each │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getIsFirstRank()                      │ Return  whether this process is first │
                      │                                       │ in  each  dimension  in  the  process │
                      │                                       │ grid.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getIsLastRank()                       │ Return  whether  this process is last │
                      │                                       │ in  each  dimension  in  the  process │
                      │                                       │ grid.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalSizes()                       │ Return  local  elementwise  sizes  in │
                      │                                       │ each dimension.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocationDof(loc)                   │ Return number of DOFs associated with │
                      │                                       │ a given point on the grid.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocationSlot(loc, c)               │ Return index to use in accessing  raw │
                      │                                       │ local arrays.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipRanges()                  │ Return  elements  per process in each │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getProcSizes()                        │ Return number of  processes  in  each │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getProductCoordinateLocationSlot(loc) │ Return   slot   for  use  with  local │
                      │                                       │ product coordinate arrays.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStencilType()                      │ Return elementwise ghost/halo stencil │
                      │                                       │ type.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStencilWidth()                     │ Return elementwise stencil width.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getVecArray(vec)                      │ Not implemented.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ migrateVec(vec, dmTo, vecTo)          │ Transfer a vector between two  DMStag │
                      │                                       │ objects.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBoundaryTypes(boundary_types)      │ Set the boundary types.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCoordinateDMType(dmtype)           │ Set the type to store coordinates.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDof(dofs)                          │ Set DOFs/stratum.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setGlobalSizes(sizes)                 │ Set  global  element  counts  in each │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOwnershipRanges(ranges)            │ Set  elements  per  process  in  each │
                      │                                       │ dimension.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setProcSizes(sizes)                   │ Set  the  number of processes in each │
                      │                                       │ dimension in the global process grid. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStencilType(stenciltype)           │ Set  elementwise  ghost/halo  stencil │
                      │                                       │ type.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStencilWidth(swidth)               │ Set elementwise stencil width.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUniformCoordinates([xmin,    xmax, │ Set the coordinates to be  a  uniform │
                      │ ymin, ...])                           │ grid..                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUniformCoordinatesExplicit([xmin,  │ Set coordinates to be a uniform grid, │
                      │ xmax, ...])                           │ storing all values.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUniformCoordinatesProduct([xmin,   │ Create   uniform  coordinates,  as  a │
                      │ xmax, ...])                           │ product of 1D arrays.                 │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                               ┌─────────────────────┬───────────────────────────────────────┐
                               │ boundary_types      │ Boundary types in each dimension.     │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ corners             │ The lower left  corner  and  size  of │
                               │                     │ local region in each dimension.       │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ dim                 │ The dimension.                        │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ dofs                │ The  number  of  DOFs associated with │
                               │                     │ each stratum of the grid.             │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ entries_per_element │ The number of entries per element  in │
                               │                     │ the local representation.             │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ ghost_corners       │ The  lower  left  corner  and size of │
                               │                     │ local region in each dimension.       │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ global_sizes        │ Global   element   counts   in   each │
                               │                     │ dimension.                            │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ local_sizes         │ Local   elementwise   sizes  in  each │
                               │                     │ dimension.                            │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ proc_sizes          │ The  number  of  processes  in   each │
                               │                     │ dimension      in      the     global │
                               │                     │ decomposition.                        │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ stencil_type        │ Stencil type.                         │
                               ├─────────────────────┼───────────────────────────────────────┤
                               │ stencil_width       │ Elementwise stencil width.            │
                               └─────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              VecSplitToDMDA(vec,loc,c)
                     Return DMDA, Vec from a subgrid of a DMStag, its Vec.

                     Collective.

                     If a c value of -k is provided, the first k DOFs for that position are  extracted,  padding
                     with zero values if needed. If a non-negative value is provided, a single DOF is extracted.

                     Parameters

                            • vec (Vec) -- The Vec object.

                            • loc (StencilLocation) -- Which subgrid to extract.

                            • c (int) -- Which component to extract.

                     Returntypetuple[DMDA, Vec]

                     SEEALSO:DMStagVecSplitToDMDASourcecodeatpetsc4py/PETSc/DMStag.pyx:790create(dim,dofs=None,sizes=None,boundary_types=None,stencil_type=None,stencil_width=None,proc_sizes=None,ownership_ranges=None,comm=None,setUp=False)
                     Create a DMDA object.

                     Collective.

                     Creates an object to manage data living on the elements and vertices / the elements, faces,
                     and vertices / the elements, faces, edges, and vertices of a parallelized regular 1D / 2D /
                     3D grid.

                     Parameters

                            • dim (int) -- The number of dimensions.

                            • dofs  (tuple[int,...]|None)  -- The number of degrees of freedom per vertex,
                              element (1D); vertex, face, element (2D); or vertex, edge, face, element (3D).

                            • sizes (tuple[int,...]|None) -- The number of elements in each dimension.

                            • boundary_types (tuple[DM.BoundaryType|int|str|bool,...]|None)  --  The
                              boundary types.

                            • stencil_type (StencilType|None) -- The ghost/halo stencil type.

                            • stencil_width (int|None) -- The width of the ghost/halo region.

                            • proc_sizes  (tuple[int,...]|None)  --  The  number  of  processes in x, y, z
                              dimensions.

                            • ownership_ranges (tuple[Sequence[int],...]|None)  --  Local  x,  y,  z  element
                              counts, of length equal to proc_sizes, summing to sizes.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                            • setUp  (bool|None)  --  Whether  to  call the setup routine after creating the
                              object.

                     Returntype
                            Self

                     SEEALSO:DMStagCreate1d, DMStagCreate2d, DMStagCreate3d, DMSetUpSourcecodeatpetsc4py/PETSc/DMStag.pyx:50createCompatibleDMStag(dofs)
                     Create a compatible DMStag with different DOFs/stratum.

                     Collective.

                     Parametersdofs (tuple[int,...]) -- The number of DOFs on the strata in the new DMStag.

                     ReturntypeDMSEEALSO:DMStagCreateCompatibleDMStagSourcecodeatpetsc4py/PETSc/DMStag.pyx:766get1dCoordinatecArrays()
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:832ReturntypeNonegetBoundaryTypes()
                     Return boundary types in each dimension.

                     Not collective.

                     SEEALSO:setBoundaryTypes, DMStagGetBoundaryTypesSourcecodeatpetsc4py/PETSc/DMStag.pyx:478Returntypetuple[str, ...]

              getCorners()
                     Return starting element index, width and number of partial elements.

                     Not collective.

                     The returned value is calculated excluding ghost points.

                     The number of extra partial elements is either 1 or 0. The value is 1 on  right,  top,  and
                     front  non-periodic  domain  ("physical")  boundaries,  in  the  x,  y,  and  z  dimensions
                     respectively, and otherwise 0.

                     SEEALSO:getGhostCorners, DMStagGetCorners, DMGetDimensionSourcecodeatpetsc4py/PETSc/DMStag.pyx:363Returntypetuple[tuple[int, ...], tuple[int, ...], tuple[int, ...]]

              getDim()
                     Return the number of dimensions.

                     Not collective.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:310ReturntypeintgetDof()
                     Get number of DOFs associated with each stratum of the grid.

                     Not collective.

                     SEEALSO:DMStagGetDOFSourcecodeatpetsc4py/PETSc/DMStag.pyx:348Returntypetuple[int, ...]

              getEntriesPerElement()
                     Return the number of entries per element in the local representation.

                     Not collective.

                     This is the natural block size for most local operations.

                     SEEALSO:DMStagGetEntriesPerElementSourcecodeatpetsc4py/PETSc/DMStag.pyx:318ReturntypeintgetGhostCorners()
                     Return starting element index and width of local region.

                     Not collective.

                     SEEALSO:getCorners, DMStagGetGhostCornersSourcecodeatpetsc4py/PETSc/DMStag.pyx:385Returntypetuple[tuple[int, ...], tuple[int, ...]]

              getGlobalSizes()
                     Return global element counts in each dimension.

                     Not collective.

                     SEEALSO:getLocalSizes, DMStagGetGlobalSizesSourcecodeatpetsc4py/PETSc/DMStag.pyx:417Returntypetuple[int, ...]

              getIsFirstRank()
                     Return whether this process is first in each dimension in the process grid.

                     Not collective.

                     SEEALSO:DMStagGetIsFirstRankSourcecodeatpetsc4py/PETSc/DMStag.pyx:496Returntypetuple[int, ...]

              getIsLastRank()
                     Return whether this process is last in each dimension in the process grid.

                     Not collective.

                     SEEALSO:DMStagGetIsLastRankSourcecodeatpetsc4py/PETSc/DMStag.pyx:512Returntypetuple[int, ...]

              getLocalSizes()
                     Return local elementwise sizes in each dimension.

                     Not collective.

                     The returned value is calculated excluding ghost points.

                     SEEALSO:getGlobalSizes, DMStagGetLocalSizesSourcecodeatpetsc4py/PETSc/DMStag.pyx:400Returntypetuple[int, ...]

              getLocationDof(loc)
                     Return number of DOFs associated with a given point on the grid.

                     Not collective.

                     Parametersloc (StencilLocation) -- The grid point.

                     ReturntypeintSEEALSO:DMStagGetLocationDOFSourcecodeatpetsc4py/PETSc/DMStag.pyx:721getLocationSlot(loc,c)
                     Return index to use in accessing raw local arrays.

                     Not collective.

                     Parameters

                            • loc (StencilLocation) -- Location relative to an element.

                            • c (int) -- Component.

                     ReturntypeintSEEALSO:DMStagGetLocationSlotSourcecodeatpetsc4py/PETSc/DMStag.pyx:678getOwnershipRanges()
                     Return elements per process in each dimension.

                     Not collective.

                     SEEALSO:setOwnershipRanges, DMStagGetOwnershipRangesSourcecodeatpetsc4py/PETSc/DMStag.pyx:461Returntypetuple[Sequence[int], ...]

              getProcSizes()
                     Return number of processes in each dimension.

                     Not collective.

                     SEEALSO:DMStagGetNumRanksSourcecodeatpetsc4py/PETSc/DMStag.pyx:432Returntypetuple[int, ...]

              getProductCoordinateLocationSlot(loc)
                     Return slot for use with local product coordinate arrays.

                     Not collective.

                     Parametersloc (StencilLocation) -- The grid location.

                     ReturntypeNoneSEEALSO:DMStagGetProductCoordinateLocationSlotSourcecodeatpetsc4py/PETSc/DMStag.pyx:701getStencilType()
                     Return elementwise ghost/halo stencil type.

                     Not collective.

                     SEEALSO:setStencilType, DMStagGetStencilTypeSourcecodeatpetsc4py/PETSc/DMStag.pyx:447ReturntypestrgetStencilWidth()
                     Return elementwise stencil width.

                     Not collective.

                     SEEALSO:DMStagGetStencilWidthSourcecodeatpetsc4py/PETSc/DMStag.pyx:334ReturntypeintgetVecArray(vec)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:828Parametersvec (Vec)

                     ReturntypeNonemigrateVec(vec,dmTo,vecTo)
                     Transfer a vector between two DMStag objects.

                     Collective.

                     Currently only implemented to migrate global vectors to global vectors.

                     Parameters

                            • vec (Vec) -- The source vector.

                            • dmTo (DM) -- The compatible destination object.

                            • vecTo (Vec) -- The destination vector.

                     ReturntypeNoneSEEALSO:DMStagMigrateVecSourcecodeatpetsc4py/PETSc/DMStag.pyx:743setBoundaryTypes(boundary_types)
                     Set the boundary types.

                     Logically collective.

                     Parametersboundary_types (tuple[BoundaryType|int|str|bool,...]) -- Boundary  types  for
                            one/two/three dimensions.

                     ReturntypeNoneSEEALSO:getBoundaryTypes, DMStagSetBoundaryTypesSourcecodeatpetsc4py/PETSc/DMStag.pyx:201setCoordinateDMType(dmtype)
                     Set the type to store coordinates.

                     Logically collective.

                     Parametersdmtype (Type) -- The type to store coordinates.

                     ReturntypeNoneSEEALSO:DMStagSetCoordinateDMTypeSourcecodeatpetsc4py/PETSc/DMStag.pyx:657setDof(dofs)
                     Set DOFs/stratum.

                     Logically collective.

                     Parametersdofs  (tuple[int,...])  --  The  number of points per 0-cell (vertex/node), 1-cell
                            (element in 1D, edge in 2D and 3D), 2-cell (element in 2D, face in  3D),  or  3-cell
                            (element in 3D).

                     ReturntypeNoneSEEALSO:DMStagSetDOFSourcecodeatpetsc4py/PETSc/DMStag.pyx:224setGlobalSizes(sizes)
                     Set global element counts in each dimension.

                     Logically collective.

                     Parameterssizes (tuple[int,...]) -- Global elementwise size in the one/two/three dimensions.

                     ReturntypeNoneSEEALSO:DMStagSetGlobalSizesSourcecodeatpetsc4py/PETSc/DMStag.pyx:246setOwnershipRanges(ranges)
                     Set elements per process in each dimension.

                     Logically collective.

                     Parametersranges   (tuple[Sequence[int],...])   --  Element  counts  for  each  process  in
                            one/two/three dimensions.

                     ReturntypeNoneSEEALSO:getOwnershipRanges, DMStagSetOwnershipRangesSourcecodeatpetsc4py/PETSc/DMStag.pyx:286setProcSizes(sizes)
                     Set the number of processes in each dimension in the global process grid.

                     Logically collective.

                     Parameterssizes (tuple[int,...]) -- Number of processes in one/two/three dimensions.

                     ReturntypeNoneSEEALSO:DMStagSetNumRanksSourcecodeatpetsc4py/PETSc/DMStag.pyx:266setStencilType(stenciltype)
                     Set elementwise ghost/halo stencil type.

                     Logically collective.

                     Parametersstenciltype (StencilType|str) -- The elementwise ghost stencil type.

                     ReturntypeNoneSEEALSO:getStencilType, DMStagSetStencilTypeSourcecodeatpetsc4py/PETSc/DMStag.pyx:183setStencilWidth(swidth)
                     Set elementwise stencil width.

                     Logically collective.

                     The width value is not used when StencilType.NONE is specified.

                     Parametersswidth (int) -- Stencil/halo/ghost width in elements.

                     ReturntypeNoneSEEALSO:DMStagSetStencilWidthSourcecodeatpetsc4py/PETSc/DMStag.pyx:163setUniformCoordinates(xmin=0,xmax=1,ymin=0,ymax=1,zmin=0,zmax=1)
                     Set the coordinates to be a uniform grid..

                     Collective.

                     Local coordinates are populated, linearly extrapolated  to  ghost  cells,  including  those
                     outside the physical domain. This is also done in case of periodic boundaries, meaning that
                     the  same  global  point may have different coordinates in different local representations,
                     which are equivalent assuming a periodicity implied by  the  arguments  to  this  function,
                     i.e.,  two  points  are  equivalent if their difference is a multiple of xmax-xmin in the x
                     dimension, ymax-ymin in the y dimension, and zmax-zmin in the z dimension.

                     Parameters

                            • xmin (float) -- The minimum global coordinate value in the x dimension.

                            • xmax (float) -- The maximum global coordinate value in the x dimension.

                            • ymin (float) -- The minimum global coordinate value in the y dimension.

                            • ymax (float) -- The maximum global coordinate value in the y dimension.

                            • zmin (float) -- The minimum global coordinate value in the z dimension.

                            • zmax (float) -- The maximum global coordinate value in the z dimension.

                     ReturntypeNoneSEEALSO:setUniformCoordinatesExplicit, setUniformCoordinatesProduct, DMStagSetUniformCoordinatesSourcecodeatpetsc4py/PETSc/DMStag.pyx:610setUniformCoordinatesExplicit(xmin=0,xmax=1,ymin=0,ymax=1,zmin=0,zmax=1)
                     Set coordinates to be a uniform grid, storing all values.

                     Collective.

                     Parameters

                            • xmin (float) -- The minimum global coordinate value in the x dimension.

                            • xmax (float) -- The maximum global coordinate value in the x dimension.

                            • ymin (float) -- The minimum global coordinate value in the y dimension.

                            • ymax (float) -- The maximum global coordinate value in the y dimension.

                            • zmin (float) -- The minimum global coordinate value in the z dimension.

                            • zmax (float) -- The maximum global coordinate value in the z dimension.

                     ReturntypeNoneSEEALSO:setUniformCoordinatesProduct, setUniformCoordinates, DMStagSetUniformCoordinatesExplicitSourcecodeatpetsc4py/PETSc/DMStag.pyx:530setUniformCoordinatesProduct(xmin=0,xmax=1,ymin=0,ymax=1,zmin=0,zmax=1)
                     Create uniform coordinates, as a product of 1D arrays.

                     Collective.

                     The per-dimension 1-dimensional DMStag objects that comprise the product always have active
                     0-cells (vertices, element boundaries) and 1-cells (element centers).

                     Parameters

                            • xmin (float) -- The minimum global coordinate value in the x dimension.

                            • xmax (float) -- The maximum global coordinate value in the x dimension.

                            • ymin (float) -- The minimum global coordinate value in the y dimension.

                            • ymax (float) -- The maximum global coordinate value in the y dimension.

                            • zmin (float) -- The minimum global coordinate value in the z dimension.

                            • zmax (float) -- The maximum global coordinate value in the z dimension.

                     ReturntypeNoneSEEALSO:setUniformCoordinatesExplicit, setUniformCoordinates, DMStagSetUniformCoordinatesProductSourcecodeatpetsc4py/PETSc/DMStag.pyx:568

              Attributes Documentation

              boundary_types
                     Boundary types in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:866corners
                     The lower left corner and size of local region in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:881dim    The dimension.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:836dofs   The number of DOFs associated with each stratum of the grid.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:841entries_per_element
                     The number of entries per element in the local representation.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:846ghost_corners
                     The lower left corner and size of local region in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:886global_sizes
                     Global element counts in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:851local_sizes
                     Local elementwise sizes in each dimension.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:856proc_sizes
                     The number of processes in each dimension in the global decomposition.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:861stencil_type
                     Stencil type.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:871stencil_width
                     Elementwise stencil width.

                     Sourcecodeatpetsc4py/PETSc/DMStag.pyx:876petsc4py.PETSc.DMSwarmclasspetsc4py.PETSc.DMSwarm
              Bases: DM

              A DM object used to represent arrays of data (fields) of arbitrary type.

              Enumerations
                                         ┌───────────────┬─────────────────────────┐
                                         │ CollectType   │ Swarm collection types. │
                                         ├───────────────┼─────────────────────────┤
                                         │ MigrateType   │ Swarm migration types.  │
                                         ├───────────────┼─────────────────────────┤
                                         │ PICLayoutType │ Swarm PIC layout types. │
                                         ├───────────────┼─────────────────────────┤
                                         │ Type          │ Swarm types.            │
                                         └───────────────┴─────────────────────────┘

   petsc4py.PETSc.DMSwarm.CollectTypeclasspetsc4py.PETSc.DMSwarm.CollectType
                     Bases: object

                     Swarm collection types.

                     Attributes Summary
                                ┌─────────────────────────┬───────────────────────────────────────┐
                                │ COLLECT_BASIC           │ Constant COLLECT_BASIC of type int    │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ COLLECT_DMDABOUNDINGBOX │ Constant  COLLECT_DMDABOUNDINGBOX  of │
                                │                         │ type int                              │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ COLLECT_GENERAL         │ Constant COLLECT_GENERAL of type int  │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ COLLECT_USER            │ Constant COLLECT_USER of type int     │
                                └─────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     COLLECT_BASIC:int=COLLECT_BASIC
                            Constant COLLECT_BASIC of type intCOLLECT_DMDABOUNDINGBOX:int=COLLECT_DMDABOUNDINGBOX
                            Constant COLLECT_DMDABOUNDINGBOX of type intCOLLECT_GENERAL:int=COLLECT_GENERAL
                            Constant COLLECT_GENERAL of type intCOLLECT_USER:int=COLLECT_USER
                            Constant COLLECT_USER of type intpetsc4py.PETSc.DMSwarm.MigrateTypeclasspetsc4py.PETSc.DMSwarm.MigrateType
                     Bases: object

                     Swarm migration types.

                     Attributes Summary
                                 ┌────────────────────────┬───────────────────────────────────────┐
                                 │ MIGRATE_BASIC          │ Constant MIGRATE_BASIC of type int    │
                                 ├────────────────────────┼───────────────────────────────────────┤
                                 │ MIGRATE_DMCELLEXACT    │ Constant  MIGRATE_DMCELLEXACT of type │
                                 │                        │ int                                   │
                                 ├────────────────────────┼───────────────────────────────────────┤
                                 │ MIGRATE_DMCELLNSCATTER │ Constant  MIGRATE_DMCELLNSCATTER   of │
                                 │                        │ type int                              │
                                 ├────────────────────────┼───────────────────────────────────────┤
                                 │ MIGRATE_USER           │ Constant MIGRATE_USER of type int     │
                                 └────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     MIGRATE_BASIC:int=MIGRATE_BASIC
                            Constant MIGRATE_BASIC of type intMIGRATE_DMCELLEXACT:int=MIGRATE_DMCELLEXACT
                            Constant MIGRATE_DMCELLEXACT of type intMIGRATE_DMCELLNSCATTER:int=MIGRATE_DMCELLNSCATTER
                            Constant MIGRATE_DMCELLNSCATTER of type intMIGRATE_USER:int=MIGRATE_USER
                            Constant MIGRATE_USER of type intpetsc4py.PETSc.DMSwarm.PICLayoutTypeclasspetsc4py.PETSc.DMSwarm.PICLayoutType
                     Bases: object

                     Swarm PIC layout types.

                     Attributes Summary
                                   ┌────────────────────┬───────────────────────────────────────┐
                                   │ LAYOUT_GAUSS       │ Constant LAYOUT_GAUSS of type int     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LAYOUT_REGULAR     │ Constant LAYOUT_REGULAR of type int   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LAYOUT_SUBDIVISION │ Constant LAYOUT_SUBDIVISION of type ‐ │
                                   │                    │ int                                   │
                                   └────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     LAYOUT_GAUSS:int=LAYOUT_GAUSS
                            Constant LAYOUT_GAUSS of type intLAYOUT_REGULAR:int=LAYOUT_REGULAR
                            Constant LAYOUT_REGULAR of type intLAYOUT_SUBDIVISION:int=LAYOUT_SUBDIVISION
                            Constant LAYOUT_SUBDIVISION of type intpetsc4py.PETSc.DMSwarm.Typeclasspetsc4py.PETSc.DMSwarm.Type
                     Bases: object

                     Swarm types.

                     Attributes Summary
                                               ┌───────┬────────────────────────────┐
                                               │ BASIC │ Constant BASIC of type int │
                                               ├───────┼────────────────────────────┤
                                               │ PIC   │ Constant PIC of type int   │
                                               └───────┴────────────────────────────┘

                     Attributes Documentation

                     BASIC:int=BASIC
                            Constant BASIC of type intPIC:int=PIC
                            Constant PIC of type int

              Methods Summary
                    ┌──────────────────────────────────────────┬───────────────────────────────────────┐
                    │ addNPoints(npoints)                      │ Add  space for a number of new points │
                    │                                          │ in the DMSwarm.                       │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ addPoint()                               │ Add space for one new  point  in  the │
                    │                                          │ DMSwarm.                              │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ collectViewCreate()                      │ Apply  a collection method and gather │
                    │                                          │ points in neighbor ranks.             │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ collectViewDestroy()                     │ Reset the DMSwarm to the  size  prior │
                    │                                          │ to calling collectViewCreate.         │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ copyPoint(pi, pj)                        │ Copy  point  pi  to  point  pj in the │
                    │                                          │ DMSwarm.                              │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ create([comm])                           │ Create an empty DM object and set its │
                    │                                          │ type to DM.Type.SWARM.                │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ createGlobalVectorFromField(fieldname)   │ Create a global Vec object associated │
                    │                                          │ with a given field.                   │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ createLocalVectorFromField(fieldname)    │ Create a local Vec object  associated │
                    │                                          │ with a given field.                   │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ destroyGlobalVectorFromField(fieldname)  │ Destroy   the   global   Vec   object │
                    │                                          │ associated with a given field.        │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ destroyLocalVectorFromField(fieldname)   │ Destroy   the   local   Vec    object │
                    │                                          │ associated with a given field.        │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ finalizeFieldRegister()                  │ Finalize  the  registration of fields │
                    │                                          │ to a DMSwarm.                         │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ getCellDM()                              │ Return DM cell attached to DMSwarm.   │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ getField(fieldname)                      │ Return  arrays  storing  all  entries │
                    │                                          │ associated with a field.              │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ getLocalSize()                           │ Return  the  local  length  of fields │
                    │                                          │ registered.                           │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ getSize()                                │ Return the  total  length  of  fields │
                    │                                          │ registered.                           │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ initializeFieldRegister()                │ Initiate  the  registration of fields │
                    │                                          │ to a DMSwarm.                         │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ insertPointUsingCellDM(layoutType,       │ Insert point coordinates within  each │
                    │ fill_param)                              │ cell.                                 │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ migrate([remove_sent_points])            │ Relocate   points   defined   in  the │
                    │                                          │ DMSwarm to other MPI ranks.           │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ projectFields(dm,  fieldnames,   vecs[,  │ Project  a set of DMSwarm fields onto │
                    │ mode])                                   │ the cell DM.                          │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ registerField(fieldname,    blocksize[,  │ Register  a field to a DMSwarm with a │
                    │ dtype])                                  │ native PETSc data type.               │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ removePoint()                            │ Remove  the  last  point   from   the │
                    │                                          │ DMSwarm.                              │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ removePointAtIndex(index)                │ Remove  a  specific  point  from  the │
                    │                                          │ DMSwarm.                              │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ restoreField(fieldname)                  │ Restore accesses  associated  with  a │
                    │                                          │ registered field.                     │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ setCellDM(dm)                            │ Attach a DM to a DMSwarm.             │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ setLocalSizes(nlocal, buffer)            │ Set  the  length  of  all  registered │
                    │                                          │ fields on the DMSwarm.                │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ setPointCoordinates(coordinates[, ...])  │ Set point coordinates  in  a  DMSwarm │
                    │                                          │ from a user-defined list.             │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ setPointCoordinatesCellwise(coordinates) │ Insert  point coordinates within each │
                    │                                          │ cell.                                 │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ setPointsUniformCoordinates(min,    max, │ Set point coordinates in a DMSwarm on │
                    │ npoints)                                 │ a regular (ijk) grid.                 │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ setType(dmswarm_type)                    │ Set particular flavor of DMSwarm.     │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ sortGetAccess()                          │ Setup   up   a   DMSwarm  point  sort │
                    │                                          │ context.                              │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ sortGetIsValid()                         │ Return whether the  sort  context  is │
                    │                                          │ up-to-date.                           │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ sortGetNumberOfPointsPerCell(e)          │ Return  the  number  of  points  in a │
                    │                                          │ cell.                                 │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ sortGetPointsPerCell(e)                  │ Create an array of point indices  for │
                    │                                          │ all points in a cell.                 │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ sortGetSizes()                           │ Return  the  sizes  associated with a │
                    │                                          │ DMSwarm point sorting context.        │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ sortRestoreAccess()                      │ Invalidate the DMSwarm point  sorting │
                    │                                          │ context.                              │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ vectorDefineField(fieldname)             │ Set  the field from which to define a │
                    │                                          │ Vec object.                           │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ viewFieldsXDMF(filename, fieldnames)     │ Write a selection of  DMSwarm  fields │
                    │                                          │ to an XDMF3 file.                     │
                    ├──────────────────────────────────────────┼───────────────────────────────────────┤
                    │ viewXDMF(filename)                       │ Write this DMSwarm fields to an XDMF3 │
                    │                                          │ file.                                 │
                    └──────────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              addNPoints(npoints)
                     Add space for a number of new points in the DMSwarm.

                     Not collective.

                     Parametersnpoints (int) -- The number of new points to add.

                     ReturntypeNoneSEEALSO:DMSwarmAddNPointsSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:329addPoint()
                     Add space for one new point in the DMSwarm.

                     Not collective.

                     SEEALSO:DMSwarmAddPointSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:317ReturntypeNonecollectViewCreate()
                     Apply a collection method and gather points in neighbor ranks.

                     Collective.

                     SEEALSO:collectViewDestroy, DMSwarmCollectViewCreateSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:445ReturntypeNonecollectViewDestroy()
                     Reset the DMSwarm to the size prior to calling collectViewCreate.

                     Collective.

                     SEEALSO:collectViewCreate, DMSwarmCollectViewDestroySourcecodeatpetsc4py/PETSc/DMSwarm.pyx:457ReturntypeNonecopyPoint(pi,pj)
                     Copy point pi to point pj in the DMSwarm.

                     Not collective.

                     Parameters

                            • pi (int) -- The index of the point to copy (source).

                            • pj (int) -- The point index where the copy should be located (destination).

                     ReturntypeNoneSEEALSO:DMSwarmCopyPointSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:377create(comm=None)
                     Create an empty DM object and set its type to DM.Type.SWARM.

                     Collective.

                     DMs  are  the abstract objects in PETSc that mediate between meshes and discretizations and
                     the algebraic solvers, time integrators, and optimization algorithms.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:DMCreate, DMSetTypeSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:39createGlobalVectorFromField(fieldname)
                     Create a global Vec object associated with a given field.

                     Collective.

                     The   vector   must   be   returned   to   the   DMSwarm   using   a   matching   call   to
                     destroyGlobalVectorFromField.

                     Parametersfieldname (str) -- The textual name given to a registered field.

                     ReturntypeVecSEEALSO:destroyGlobalVectorFromField, DMSwarmCreateGlobalVectorFromFieldSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:65createLocalVectorFromField(fieldname)
                     Create a local Vec object associated with a given field.

                     Collective.

                     The   vector   must   be   returned   to   the   DMSwarm   using   a   matching   call   to
                     destroyLocalVectorFromField.

                     Parametersfieldname (str) -- The textual name given to a registered field.

                     ReturntypeVecSEEALSO:destroyLocalVectorFromField, DMSwarmCreateLocalVectorFromFieldSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:109destroyGlobalVectorFromField(fieldname)
                     Destroy the global Vec object associated with a given field.

                     Collective.

                     Parametersfieldname (str) -- The textual name given to a registered field.

                     ReturntypeNoneSEEALSO:createGlobalVectorFromField, DMSwarmDestroyGlobalVectorFromFieldSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:89destroyLocalVectorFromField(fieldname)
                     Destroy the local Vec object associated with a given field.

                     Collective.

                     Parametersfieldname (str) -- The textual name given to a registered field.

                     ReturntypeNoneSEEALSO:createLocalVectorFromField, DMSwarmDestroyLocalVectorFromFieldSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:133finalizeFieldRegister()
                     Finalize the registration of fields to a DMSwarm.

                     Collective.

                     SEEALSO:initializeFieldRegister, DMSwarmFinalizeFieldRegisterSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:167ReturntypeNonegetCellDM()
                     Return DM cell attached to DMSwarm.

                     Collective.

                     SEEALSO:setCellDM, DMSwarmGetCellDMSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:486ReturntypeDMgetField(fieldname)
                     Return arrays storing all entries associated with a field.

                     Not collective.

                     The returned array contains underlying values of the field.

                     The array must be returned to the DMSwarm using a matching call to restoreField.

                     Parametersfieldname (str) -- The textual name to identify this field.

                     Returns
                            The type of the entries in the array will match the type of the field.

                     Returntypenumpy.ndarraySEEALSO:restoreField, DMSwarmGetFieldSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:231getLocalSize()
                     Return the local length of fields registered.

                     Not collective.

                     SEEALSO:DMSwarmGetLocalSizeSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:398ReturntypeintgetSize()
                     Return the total length of fields registered.

                     Collective.

                     SEEALSO:DMSwarmGetSizeSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:412ReturntypeintinitializeFieldRegister()
                     Initiate the registration of fields to a DMSwarm.

                     Collective.

                     After all fields have been registered, you must call finalizeFieldRegister.

                     SEEALSO:finalizeFieldRegister, DMSwarmInitializeFieldRegisterSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:153ReturntypeNoneinsertPointUsingCellDM(layoutType,fill_param)
                     Insert point coordinates within each cell.

                     Not collective.

                     Parameters

                            • layout_type -- Method used to fill each cell with the cell DM.

                            • fill_param (int) -- Parameter controlling how many points per cell are added  (the
                              meaning of this parameter is dependent on the layout type).

                            • layoutType (PICLayoutType)

                     ReturntypeNoneSEEALSO:DMSwarmInsertPointsUsingCellDMSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:601migrate(remove_sent_points=False)
                     Relocate points defined in the DMSwarm to other MPI ranks.

                     Collective.

                     Parametersremove_sent_points  (bool)  -- Flag indicating if sent points should be removed from
                            the current MPI rank.

                     ReturntypeNoneSEEALSO:DMSwarmMigrateSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:426projectFields(dm,fieldnames,vecs,mode=None)
                     Project a set of DMSwarm fields onto the cell DM.

                     Collective.

                     Parameters

                            • dm (DM) -- The continuum DM.

                            • fieldnames (Sequence[str]) -- The textual names of the swarm fields to project.

                            • vecs (Sequence[Vec])

                            • mode (ScatterModeSpec)

                     ReturntypeNoneSEEALSO:DMSwarmProjectFieldsSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:810registerField(fieldname,blocksize,dtype=ScalarType)
                     Register a field to a DMSwarm with a native PETSc data type.

                     Collective.

                     Parameters

                            • fieldname (str) -- The textual name to identify this field.

                            • blocksize (int) -- The number of each data type.

                            • dtype (dtype) -- A valid PETSc data type.

                     ReturntypeNoneSEEALSO:DMSwarmRegisterPetscDatatypeFieldSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:201removePoint()
                     Remove the last point from the DMSwarm.

                     Not collective.

                     SEEALSO:DMSwarmRemovePointSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:347ReturntypeNoneremovePointAtIndex(index)
                     Remove a specific point from the DMSwarm.

                     Not collective.

                     Parametersindex (int) -- Index of point to remove

                     ReturntypeNoneSEEALSO:DMSwarmRemovePointAtIndexSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:359restoreField(fieldname)
                     Restore accesses associated with a registered field.

                     Not collective.

                     Parametersfieldname (str) -- The textual name to identify this field.

                     ReturntypeNoneSEEALSO:getField, DMSwarmRestoreFieldSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:274setCellDM(dm)
                     Attach a DM to a DMSwarm.

                     Collective.

                     Parametersdm (DM) -- The DM to attach to the DMSwarm.

                     ReturntypeNoneSEEALSO:getCellDM, DMSwarmSetCellDMSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:469setLocalSizes(nlocal,buffer)
                     Set the length of all registered fields on the DMSwarm.

                     Not collective.

                     Parameters

                            • nlocal (int) -- The length of each registered field.

                            • buffer (int) -- The length of the buffer used for efficient dynamic resizing.

                     ReturntypeSelfSEEALSO:DMSwarmSetLocalSizesSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:179setPointCoordinates(coordinates,redundant=False,mode=None)
                     Set point coordinates in a DMSwarm from a user-defined list.

                     Collective.

                     Parameters

                            • coordinates (Sequence[float]) -- The coordinate values.

                            • redundant (bool) -- If set to True, it is assumed that coordinates are only  valid
                              on rank 0 and should be broadcast to other ranks.

                            • mode  (InsertMode|None)  -- Indicates whether to append points to the swarm (‐
                              InsertMode.ADD), or override existing points (InsertMode.INSERT).

                     ReturntypeNoneSEEALSO:DMSwarmSetPointCoordinatesSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:565setPointCoordinatesCellwise(coordinates)
                     Insert point coordinates within each cell.

                     Not collective.

                     Point coordinates are defined over the reference cell.

                     Parameterscoordinates (Sequence[float]) -- The coordinates (defined in  the  local  coordinate
                            system for each cell) to insert.

                     ReturntypeNoneSEEALSO:DMSwarmSetPointCoordinatesCellwiseSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:623setPointsUniformCoordinates(min,max,npoints,mode=None)
                     Set point coordinates in a DMSwarm on a regular (ijk) grid.

                     Collective.

                     Parameters

                            • min  (Sequence[float])  --  Minimum  coordinate  values  in the x, y, z directions
                              (array of length dim).

                            • max (Sequence[float]) -- Maximum coordinate values  in  the  x,  y,  z  directions
                              (array of length dim).

                            • npoints  (Sequence[int])  --  Number of points in each spatial direction (array of
                              length dim).

                            • mode (InsertMode|None) -- Indicates whether to append points  to  the  swarm  (‐
                              InsertMode.ADD), or override existing points (InsertMode.INSERT).

                     ReturntypeSelfSEEALSO:DMSwarmSetPointsUniformCoordinatesSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:521setType(dmswarm_type)
                     Set particular flavor of DMSwarm.

                     Collective.

                     Parametersdmswarm_type (Type|str) -- The DMSwarm type.

                     ReturntypeNoneSEEALSO:DMSwarmSetTypeSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:503sortGetAccess()
                     Setup up a DMSwarm point sort context.

                     Not collective.

                     The point sort context is used for efficient traversal of points within a cell.

                     You must call sortRestoreAccess when you no longer need access to the sort context.

                     SEEALSO:sortRestoreAccess, DMSwarmSortGetAccessSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:698ReturntypeNonesortGetIsValid()
                     Return whether the sort context is up-to-date.

                     Not collective.

                     Returns the flag associated with a DMSwarm point sorting context.

                     SEEALSO:DMSwarmSortGetIsValidSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:772ReturntypeboolsortGetNumberOfPointsPerCell(e)
                     Return the number of points in a cell.

                     Not collective.

                     Parameterse (int) -- The index of the cell.

                     ReturntypeintSEEALSO:DMSwarmSortGetNumberOfPointsPerCellSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:752sortGetPointsPerCell(e)
                     Create an array of point indices for all points in a cell.

                     Not collective.

                     Parameterse (int) -- The index of the cell.

                     Returntypelist[int]

                     SEEALSO:DMSwarmSortGetPointsPerCellSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:728sortGetSizes()
                     Return the sizes associated with a DMSwarm point sorting context.

                     Not collective.

                     Returns

                            • ncells (int) -- Number of cells within the sort context.

                            • npoints (int) -- Number of points used to create the sort context.

                     Returntypetuple[int, int]

                     SEEALSO:DMSwarmSortGetSizesSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:788sortRestoreAccess()
                     Invalidate the DMSwarm point sorting context.

                     Not collective.

                     SEEALSO:sortGetAccess, DMSwarmSortRestoreAccessSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:716ReturntypeNonevectorDefineField(fieldname)
                     Set the field from which to define a Vec object.

                     Collective.

                     The field will be used when DM.createLocalVec, or DM.createGlobalVec is called.

                     Parametersfieldname (str) -- The textual name given to a registered field.

                     ReturntypeNoneSEEALSO:DMSwarmVectorDefineFieldSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:295viewFieldsXDMF(filename,fieldnames)
                     Write a selection of DMSwarm fields to an XDMF3 file.

                     Collective.

                     Parameters

                            • filename (str) -- The file name of the XDMF file (must have the extension .xmf).

                            • fieldnames  (Sequence[str])  --  Array  containing  the textual names of fields to
                              write.

                     ReturntypeNoneSEEALSO:DMSwarmViewFieldsXDMFSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:650viewXDMF(filename)
                     Write this DMSwarm fields to an XDMF3 file.

                     Collective.

                     Parametersfilename (str) -- The file name of the XDMF file (must have the extension .xmf).

                     ReturntypeNoneSEEALSO:DMSwarmViewXDMFSourcecodeatpetsc4py/PETSc/DMSwarm.pyx:679petsc4py.PETSc.DSclasspetsc4py.PETSc.DS
              Bases: Object

              Discrete System object.

              Enumerations
                                            ┌──────┬────────────────────────────┐
                                            │ Type │ The Discrete System types. │
                                            └──────┴────────────────────────────┘

   petsc4py.PETSc.DS.Typeclasspetsc4py.PETSc.DS.Type
                     Bases: object

                     The Discrete System types.

                     Attributes Summary
                                                ┌───────┬──────────────────────────┐
                                                │ BASIC │ Object BASIC of type str │
                                                └───────┴──────────────────────────┘

                     Attributes Documentation

                     BASIC:str=BASIC
                            Object BASIC of type str

              Methods Summary
                           ┌────────────────────────────┬───────────────────────────────────────┐
                           │ create([comm])             │ Create an empty DS.                   │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ destroy()                  │ Destroy the discrete system.          │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getComponents()            │ Return the number of  components  for │
                           │                            │ each field on an evaluation point.    │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getCoordinateDimension()   │ Return  the  coordinate  dimension of │
                           │                            │ the DS.                               │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getDimensions()            │ Return the size of the space for each │
                           │                            │ field on an evaluation point.         │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getFieldIndex(disc)        │ Return the index of the given field.  │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getNumFields()             │ Return the number of  fields  in  the │
                           │                            │ DS.                                   │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getSpatialDimension()      │ Return  the  spatial dimension of the │
                           │                            │ DS.                                   │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getTotalComponents()       │ Return the total number of components │
                           │                            │ in this system.                       │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getTotalDimensions()       │ Return  the   total   size   of   the │
                           │                            │ approximation space for this system.  │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getType()                  │ Return   the  type  of  the  discrete │
                           │                            │ system.                               │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ setDiscretisation(f, disc) │ Set the discretization object for the │
                           │                            │ given field.                          │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ setFromOptions()           │ Set  parameters  in  a  DS  from  the │
                           │                            │ options database.                     │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ setType(ds_type)           │ Build a particular type of a discrete │
                           │                            │ system.                               │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ setUp()                    │ Construct  data  structures  for  the │
                           │                            │ discrete system.                      │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ view([viewer])             │ View a discrete system.               │
                           └────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Create an empty DS.

                     Collective.

                     The type can then be set with setType.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:setType, destroy, PetscDSCreateSourcecodeatpetsc4py/PETSc/DS.pyx:53destroy()
                     Destroy the discrete system.

                     Collective.

                     SEEALSO:create, PetscDSDestroySourcecodeatpetsc4py/PETSc/DS.pyx:40ReturntypeSelfgetComponents()
                     Return the number of components for each field on an evaluation point.

                     Not collective.

                     SEEALSO:PetscDSGetComponentsSourcecodeatpetsc4py/PETSc/DS.pyx:246ReturntypeArrayIntgetCoordinateDimension()
                     Return the coordinate dimension of the DS.

                     Not collective.

                     The coordinate dimension  of  the  DS  is  the  dimension  of  the  space  into  which  the
                     discretiaztions are embedded.

                     SEEALSO:PetscDSGetCoordinateDimensionSourcecodeatpetsc4py/PETSc/DS.pyx:153ReturntypeintgetDimensions()
                     Return the size of the space for each field on an evaluation point.

                     Not collective.

                     SEEALSO:PetscDSGetDimensionsSourcecodeatpetsc4py/PETSc/DS.pyx:231ReturntypeArrayIntgetFieldIndex(disc)
                     Return the index of the given field.

                     Not collective.

                     Parametersdisc (Object) -- The discretization object.

                     ReturntypeintSEEALSO:PetscDSGetFieldIndexSourcecodeatpetsc4py/PETSc/DS.pyx:184getNumFields()
                     Return the number of fields in the DS.

                     Not collective.

                     SEEALSO:PetscDSGetNumFieldsSourcecodeatpetsc4py/PETSc/DS.pyx:170ReturntypeintgetSpatialDimension()
                     Return the spatial dimension of the DS.

                     Not collective.

                     The spatial dimension of the DS is the topological dimension of the discretizations.

                     SEEALSO:PetscDSGetSpatialDimensionSourcecodeatpetsc4py/PETSc/DS.pyx:136ReturntypeintgetTotalComponents()
                     Return the total number of components in this system.

                     Not collective.

                     SEEALSO:PetscDSGetTotalComponentsSourcecodeatpetsc4py/PETSc/DS.pyx:217ReturntypeintgetTotalDimensions()
                     Return the total size of the approximation space for this system.

                     Not collective.

                     SEEALSO:PetscDSGetTotalDimensionSourcecodeatpetsc4py/PETSc/DS.pyx:203ReturntypeintgetType()
                     Return the type of the discrete system.

                     Not collective.

                     SEEALSO:setType, PetscDSGetTypeSourcecodeatpetsc4py/PETSc/DS.pyx:95ReturntypestrsetDiscretisation(f,disc)
                     Set the discretization object for the given field.

                     Not collective.

                     Parameters

                            • f (int) -- The field number.

                            • disc (Object) -- The discretization object.

                     ReturntypeNoneSEEALSO:PetscDSSetDiscretizationSourcecodeatpetsc4py/PETSc/DS.pyx:261setFromOptions()
                     Set parameters in a DS from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, PetscDSSetFromOptionsSourcecodeatpetsc4py/PETSc/DS.pyx:109ReturntypeNonesetType(ds_type)
                     Build a particular type of a discrete system.

                     Collective.

                     Parametersds_type (Type|str) -- The type of the discrete system.

                     ReturntypeNoneSEEALSO:getType, PetscDSSetTypeSourcecodeatpetsc4py/PETSc/DS.pyx:76setUp()
                     Construct data structures for the discrete system.

                     Collective.

                     SEEALSO:PetscDSSetUpSourcecodeatpetsc4py/PETSc/DS.pyx:121ReturntypeSelfview(viewer=None)
                     View a discrete system.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the system.

                     ReturntypeNoneSEEALSO:PetscDSViewSourcecodeatpetsc4py/PETSc/DS.pyx:21petsc4py.PETSc.Deviceclasspetsc4py.PETSc.Device
              Bases: object

              The device object.

              Represents a handle to an accelerator (which may be the host).

              SEEALSO:DeviceContext, PetscDevice

              Enumerations
                                               ┌──────┬─────────────────────┐
                                               │ Type │ The type of device. │
                                               └──────┴─────────────────────┘

   petsc4py.PETSc.Device.Typeclasspetsc4py.PETSc.Device.Type
                     Bases: object

                     The type of device.

                     SEEALSO:Device, Device.create, Device.getDeviceType, Device.type, PetscDeviceType

                     Attributes Summary
                                             ┌─────────┬──────────────────────────────┐
                                             │ CUDA    │ Constant CUDA of type int    │
                                             ├─────────┼──────────────────────────────┤
                                             │ DEFAULT │ Constant DEFAULT of type int │
                                             ├─────────┼──────────────────────────────┤
                                             │ HIP     │ Constant HIP of type int     │
                                             ├─────────┼──────────────────────────────┤
                                             │ HOST    │ Constant HOST of type int    │
                                             ├─────────┼──────────────────────────────┤
                                             │ SYCL    │ Constant SYCL of type int    │
                                             └─────────┴──────────────────────────────┘

                     Attributes Documentation

                     CUDA:int=CUDA
                            Constant CUDA of type intDEFAULT:int=DEFAULT
                            Constant DEFAULT of type intHIP:int=HIP
                            Constant HIP of type intHOST:int=HOST
                            Constant HOST of type intSYCL:int=SYCL
                            Constant SYCL of type int

              Methods Summary
                           ┌─────────────────────────────┬───────────────────────────────────────┐
                           │ configure()                 │ Configure and setup a device object.  │
                           ├─────────────────────────────┼───────────────────────────────────────┤
                           │ create([dtype, device_id])  │ Create a device object.               │
                           ├─────────────────────────────┼───────────────────────────────────────┤
                           │ destroy()                   │ Destroy a device object.              │
                           ├─────────────────────────────┼───────────────────────────────────────┤
                           │ getDeviceId()               │ Return the device id.                 │
                           ├─────────────────────────────┼───────────────────────────────────────┤
                           │ getDeviceType()             │ Return the type of the device.        │
                           ├─────────────────────────────┼───────────────────────────────────────┤
                           │ setDefaultType(device_type) │ Set the device type to be used as the │
                           │                             │ default   in   subsequent   calls  to │
                           │                             │ create.                               │
                           ├─────────────────────────────┼───────────────────────────────────────┤
                           │ view([viewer])              │ View a device object.                 │
                           └─────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                              ┌───────────┬──────────────────┐
                                              │ device_id │ The device id.   │
                                              ├───────────┼──────────────────┤
                                              │ type      │ The device type. │
                                              └───────────┴──────────────────┘

              Methods Documentation

              configure()
                     Configure and setup a device object.

                     Not collective.

                     SEEALSO:create, PetscDeviceConfigureSourcecodeatpetsc4py/PETSc/Device.pyx:132ReturntypeNoneclassmethodcreate(dtype=None,device_id=DECIDE)
                     Create a device object.

                     Not collective.

                     Parameters

                            • dtype (Type|None) -- The type of device to create (or None for the default).

                            • device_id (int) -- The numeric id of the device to create.

                     ReturntypeDeviceSEEALSO:destroy, PetscDeviceCreateSourcecodeatpetsc4py/PETSc/Device.pyx:94destroy()
                     Destroy a device object.

                     Not collective.

                     SEEALSO:create, PetscDeviceDestroySourcecodeatpetsc4py/PETSc/Device.pyx:120ReturntypeNonegetDeviceId()
                     Return the device id.

                     Not collective.

                     SEEALSO:create, PetscDeviceGetDeviceIdSourcecodeatpetsc4py/PETSc/Device.pyx:180ReturntypeintgetDeviceType()
                     Return the type of the device.

                     Not collective.

                     SEEALSO:type, PetscDeviceGetTypeSourcecodeatpetsc4py/PETSc/Device.pyx:165ReturntypestrstaticsetDefaultType(device_type)
                     Set the device type to be used as the default in subsequent calls to create.

                     Not collective.

                     SEEALSO:create, PetscDeviceSetDefaultDeviceTypeSourcecodeatpetsc4py/PETSc/Device.pyx:195Parametersdevice_type (Type|str)

                     ReturntypeNoneview(viewer=None)
                     View a device object.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:PetscDeviceViewSourcecodeatpetsc4py/PETSc/Device.pyx:144

              Attributes Documentation

              device_id
                     The device id.

                     Sourcecodeatpetsc4py/PETSc/Device.pyx:215type   The device type.

                     Sourcecodeatpetsc4py/PETSc/Device.pyx:210petsc4py.PETSc.DeviceContextclasspetsc4py.PETSc.DeviceContext
              Bases: Object

              DeviceContext object.

              Represents an abstract handle to a device context.

              SEEALSO:Device, PetscDeviceContext

              Enumerations
                                      ┌────────────────┬──────────────────────────────┐
                                      │ DeviceJoinMode │ The type of join to perform. │
                                      ├────────────────┼──────────────────────────────┤
                                      │ StreamType     │ The type of stream.          │
                                      └────────────────┴──────────────────────────────┘

   petsc4py.PETSc.DeviceContext.DeviceJoinModeclasspetsc4py.PETSc.DeviceContext.DeviceJoinMode
                     Bases: object

                     The type of join to perform.

                     SEEALSO:DeviceContext, DeviceContext.join, DeviceContext.fork, PetscDeviceContextJoinMode

                     Attributes Summary
                                             ┌─────────┬──────────────────────────────┐
                                             │ DESTROY │ Constant DESTROY of type int │
                                             ├─────────┼──────────────────────────────┤
                                             │ NO_SYNC │ Constant NO_SYNC of type int │
                                             ├─────────┼──────────────────────────────┤
                                             │ SYNC    │ Constant SYNC of type int    │
                                             └─────────┴──────────────────────────────┘

                     Attributes Documentation

                     DESTROY:int=DESTROY
                            Constant DESTROY of type intNO_SYNC:int=NO_SYNC
                            Constant NO_SYNC of type intSYNC:int=SYNC
                            Constant SYNC of type intpetsc4py.PETSc.DeviceContext.StreamTypeclasspetsc4py.PETSc.DeviceContext.StreamType
                     Bases: object

                     The type of stream.

                     SEEALSO:DeviceContext, DeviceContext.getStreamType, DeviceContext.setStreamType, PetscStreamType

                     Attributes Summary
                                ┌──────────────────────────┬───────────────────────────────────────┐
                                │ DEFAULT                  │ Constant DEFAULT of type int          │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DEFAULT_WITH_BARRIER     │ Constant DEFAULT_WITH_BARRIER of type │
                                │                          │ int                                   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ NONBLOCKING              │ Constant NONBLOCKING of type int      │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ NONBLOCKING_WITH_BARRIER │ Constant NONBLOCKING_WITH_BARRIER  of │
                                │                          │ type int                              │
                                └──────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     DEFAULT:int=DEFAULT
                            Constant DEFAULT of type intDEFAULT_WITH_BARRIER:int=DEFAULT_WITH_BARRIER
                            Constant DEFAULT_WITH_BARRIER of type intNONBLOCKING:int=NONBLOCKING
                            Constant NONBLOCKING of type intNONBLOCKING_WITH_BARRIER:int=NONBLOCKING_WITH_BARRIER
                            Constant NONBLOCKING_WITH_BARRIER of type int

              Methods Summary
                          ┌──────────────────────────────┬───────────────────────────────────────┐
                          │ create()                     │ Create an empty DeviceContext.        │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ destroy()                    │ Destroy a device context.             │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ duplicate()                  │ Duplicate a the device context.       │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ fork(n[, stream_type])       │ Create multiple device contexts which │
                          │                              │ are  all  logically dependent on this │
                          │                              │ one.                                  │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ getCurrent()                 │ Return the current device context.    │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ getDevice()                  │ Get the Device which this instance is │
                          │                              │ attached to.                          │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ getStreamType()              │ Return the StreamType.                │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ idle()                       │ Return whether the underlying  stream │
                          │                              │ for the device context is idle.       │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ join(join_mode, py_sub_ctxs) │ Join a set of device contexts on this │
                          │                              │ one.                                  │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ setCurrent(dctx)             │ Set the current device context.       │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ setDevice(device)            │ Set    the    Device    which    this │
                          │                              │ DeviceContext is attached to.         │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ setFromOptions([comm])       │ Configure the DeviceContext from  the │
                          │                              │ options database.                     │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ setStreamType(stream_type)   │ Set the StreamType.                   │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ setUp()                      │ Set  up  the internal data structures │
                          │                              │ for using the device context.         │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ synchronize()                │ Synchronize a device context.         │
                          ├──────────────────────────────┼───────────────────────────────────────┤
                          │ waitFor(other)               │ Make this instance wait for other.    │
                          └──────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                   ┌─────────────┬───────────────────────────────────────┐
                                   │ current     │ The current global device context.    │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ device      │ The device associated to  the  device │
                                   │             │ context.                              │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ stream_type │ The stream type.                      │
                                   └─────────────┴───────────────────────────────────────┘

              Methods Documentation

              create()
                     Create an empty DeviceContext.

                     Not collective.

                     SEEALSO:destroy, Device, PetscDeviceContextCreateSourcecodeatpetsc4py/PETSc/Device.pyx:240ReturntypeSelfdestroy()
                     Destroy a device context.

                     Not collective.

                     SEEALSO:create, PetscDeviceContextDestroySourcecodeatpetsc4py/PETSc/Device.pyx:255ReturntypeSelfduplicate()
                     Duplicate a the device context.

                     Not collective.

                     SEEALSO:create, PetscDeviceContextDuplicateSourcecodeatpetsc4py/PETSc/Device.pyx:348ReturntypeDeviceContextfork(n,stream_type=None)
                     Create multiple device contexts which are all logically dependent on this one.

                     Not collective.

                     Parameters

                            • n (int) -- The number of device contexts to create.

                            • stream_type  (StreamType|str|None) -- The type of stream of the forked device
                              context.

                     Returntypelist[DeviceContext]

                     Examples

                     The device contexts created must be destroyed using join.

                     >>> dctx = PETSc.DeviceContext().getCurrent()
                     >>> dctxs = dctx.fork(4)
                     >>> ... # perform computations
                     >>> # we can mix various join modes
                     >>> dctx.join(PETSc.DeviceContext.JoinMode.SYNC, dctxs[0:2])
                     >>> dctx.join(PETSc.DeviceContext.JoinMode.SYNC, dctxs[2:])
                     >>> ... # some more computations and joins
                     >>> # dctxs must be all destroyed with joinMode.DESTROY
                     >>> dctx.join(PETSc.DeviceContext.JoinMode.DESTROY, dctxs)

                     SEEALSO:join, waitFor, PetscDeviceContextForkSourcecodeatpetsc4py/PETSc/Device.pyx:399staticgetCurrent()
                     Return the current device context.

                     Not collective.

                     SEEALSO:current, setCurrent, PetscDeviceContextGetCurrentContextSourcecodeatpetsc4py/PETSc/Device.pyx:519ReturntypeDeviceContextgetDevice()
                     Get the Device which this instance is attached to.

                     Not collective.

                     SEEALSO:setDevice, device, Device, PetscDeviceContextGetDeviceSourcecodeatpetsc4py/PETSc/Device.pyx:302ReturntypeDevicegetStreamType()
                     Return the StreamType.

                     Not collective.

                     SEEALSO:stream_type, setStreamType, PetscDeviceContextGetStreamTypeSourcecodeatpetsc4py/PETSc/Device.pyx:268Returntypestridle() Return whether the underlying stream for the device context is idle.

                     Not collective.

                     SEEALSO:synchronize, PetscDeviceContextQueryIdleSourcecodeatpetsc4py/PETSc/Device.pyx:363Returntypebooljoin(join_mode,py_sub_ctxs)
                     Join a set of device contexts on this one.

                     Not collective.

                     Parameters

                            • join_mode (DeviceJoinMode|str) -- The type of join to perform.

                            • py_sub_ctxs (list[DeviceContext]) -- The list of device contexts to join.

                     ReturntypeNoneSEEALSO:fork, waitFor, PetscDeviceContextJoinSourcecodeatpetsc4py/PETSc/Device.pyx:448staticsetCurrent(dctx)
                     Set the current device context.

                     Not collective.

                     Parametersdctx (DeviceContext|None) -- The DeviceContext to set as current (or None  to  use
                            the default context).

                     ReturntypeNoneSEEALSO:current, getCurrent, PetscDeviceContextSetCurrentContextSourcecodeatpetsc4py/PETSc/Device.pyx:535setDevice(device)
                     Set the Device which this DeviceContext is attached to.

                     Collective.

                     Parametersdevice (Device) -- The Device to which this instance is attached to.

                     ReturntypeNoneSEEALSO:getDevice, device, Device, PetscDeviceContextSetDeviceSourcecodeatpetsc4py/PETSc/Device.pyx:317setFromOptions(comm=None)
                     Configure the DeviceContext from the options database.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeNoneSEEALSO:Sys.getDefaultComm, PetscDeviceContextSetFromOptionsSourcecodeatpetsc4py/PETSc/Device.pyx:500setStreamType(stream_type)
                     Set the StreamType.

                     Not collective.

                     Parametersstream_type (StreamType|str) -- The type of stream to set

                     ReturntypeNoneSEEALSO:stream_type, getStreamType, PetscDeviceContextSetStreamTypeSourcecodeatpetsc4py/PETSc/Device.pyx:283setUp()
                     Set up the internal data structures for using the device context.

                     Not collective.

                     SEEALSO:create, PetscDeviceContextSetUpSourcecodeatpetsc4py/PETSc/Device.pyx:336ReturntypeNonesynchronize()
                     Synchronize a device context.

                     Not collective.

                     Notes

                     The  underlying stream is considered idle after this routine returns, i.e. idle will return
                     True.

                     SEEALSO:idle, PetscDeviceContextSynchronizeSourcecodeatpetsc4py/PETSc/Device.pyx:483ReturntypeNonewaitFor(other)
                     Make this instance wait for other.

                     Not collective.

                     Parametersother (DeviceContext|None) -- The other DeviceContext to wait for

                     ReturntypeNoneSEEALSO:fork, join, PetscDeviceContextWaitForContextSourcecodeatpetsc4py/PETSc/Device.pyx:378

              Attributes Documentation

              current
                     The current global device context.

                     Sourcecodeatpetsc4py/PETSc/Device.pyx:574device The device associated to the device context.

                     Sourcecodeatpetsc4py/PETSc/Device.pyx:566stream_type
                     The stream type.

                     Sourcecodeatpetsc4py/PETSc/Device.pyx:558petsc4py.PETSc.DualSpaceclasspetsc4py.PETSc.DualSpace
              Bases: Object

              Dual space to a linear space.

              Enumerations
                                              ┌──────┬───────────────────────┐
                                              │ Type │ The dual space types. │
                                              └──────┴───────────────────────┘

   petsc4py.PETSc.DualSpace.Typeclasspetsc4py.PETSc.DualSpace.Type
                     Bases: object

                     The dual space types.

                     Attributes Summary
                                             ┌──────────┬─────────────────────────────┐
                                             │ BDM      │ Object BDM of type str      │
                                             ├──────────┼─────────────────────────────┤
                                             │ LAGRANGE │ Object LAGRANGE of type str │
                                             ├──────────┼─────────────────────────────┤
                                             │ REFINED  │ Object REFINED of type str  │
                                             ├──────────┼─────────────────────────────┤
                                             │ SIMPLE   │ Object SIMPLE of type str   │
                                             └──────────┴─────────────────────────────┘

                     Attributes Documentation

                     BDM:str=BDM
                            Object BDM of type strLAGRANGE:str=LAGRANGE
                            Object LAGRANGE of type strREFINED:str=REFINED
                            Object REFINED of type strSIMPLE:str=SIMPLE
                            Object SIMPLE of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ create([comm])                        │ Create an empty DualSpace object.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the DualSpace object.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ duplicate()                           │ Create a duplicate  DualSpace  object │
                      │                                       │ that is not set up.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDM()                               │ Return   the   DM   representing  the │
                      │                                       │ reference cell of a DualSpace.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDimension()                        │ Return  the  dimension  of  the  dual │
                      │                                       │ space.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFunctional(i)                      │ Return  the  i-th basis functional in │
                      │                                       │ the dual space.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getInteriorDimension()                │ Return the interior dimension of  the │
                      │                                       │ dual space.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLagrangeContinuity()               │ Return   whether   the   element   is │
                      │                                       │ continuous.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLagrangeTensor()                   │ Return the tensor nature of the  dual │
                      │                                       │ space.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLagrangeTrimmed()                  │ Return the trimmed nature of the dual │
                      │                                       │ space.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumComponents()                    │ Return  the  number of components for │
                      │                                       │ this space.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumDof()                           │ Return  the  number  of  degrees   of │
                      │                                       │ freedom for each spatial dimension.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOrder()                            │ Return the order of the dual space.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return  the  type  of  the dual space │
                      │                                       │ object.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDM(dm)                             │ Set the DM representing the reference │
                      │                                       │ cell.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLagrangeContinuity(continuous)     │ Indicate  whether  the   element   is │
                      │                                       │ continuous.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLagrangeTensor(tensor)             │ Set  the  tensor  nature  of the dual │
                      │                                       │ space.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLagrangeTrimmed(trimmed)           │ Set the trimmed nature  of  the  dual │
                      │                                       │ space.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNumComponents(nc)                  │ Set the number of components for this │
                      │                                       │ space.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOrder(order)                       │ Set the order of the dual space.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSimpleDimension(dim)               │ Set  the number of functionals in the │
                      │                                       │ dual space basis.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSimpleFunctional(func, functional) │ Set the given basis element for  this │
                      │                                       │ dual space.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(dualspace_type)               │ Build   a  particular  type  of  dual │
                      │                                       │ space.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Construct a basis for a DualSpace.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View a DualSpace.                     │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Create an empty DualSpace object.

                     Collective.

                     The type can then be set with setType.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PetscDualSpaceCreateSourcecodeatpetsc4py/PETSc/Space.pyx:594destroy()
                     Destroy the DualSpace object.

                     Collective.

                     SEEALSO:PetscDualSpaceDestroySourcecodeatpetsc4py/PETSc/Space.pyx:636ReturntypeSelfduplicate()
                     Create a duplicate DualSpace object that is not set up.

                     Collective.

                     SEEALSO:PetscDualSpaceDuplicateSourcecodeatpetsc4py/PETSc/Space.pyx:649ReturntypeDualSpacegetDM()
                     Return the DM representing the reference cell of a DualSpace.

                     Not collective.

                     SEEALSO:setDM, PetscDualSpaceGetDMSourcecodeatpetsc4py/PETSc/Space.pyx:662ReturntypeDMgetDimension()
                     Return the dimension of the dual space.

                     Not collective.

                     The dimension of the dual space, i.e. the number of basis functionals.

                     SEEALSO:PetscDualSpaceGetDimensionSourcecodeatpetsc4py/PETSc/Space.pyx:696ReturntypeintgetFunctional(i)
                     Return the i-th basis functional in the dual space.

                     Not collective.

                     Parametersi (int) -- The basis number.

                     ReturntypeQuadSEEALSO:PetscDualSpaceGetFunctionalSourcecodeatpetsc4py/PETSc/Space.pyx:826getInteriorDimension()
                     Return the interior dimension of the dual space.

                     Not collective.

                     The interior dimension of the dual space, i.e. the number of basis functionals assigned  to
                     the interior of the reference domain.

                     SEEALSO:PetscDualSpaceGetInteriorDimensionSourcecodeatpetsc4py/PETSc/Space.pyx:847ReturntypeintgetLagrangeContinuity()
                     Return whether the element is continuous.

                     Not collective.

                     SEEALSO:setLagrangeContinuity, PetscDualSpaceLagrangeGetContinuitySourcecodeatpetsc4py/PETSc/Space.pyx:864ReturntypeboolgetLagrangeTensor()
                     Return the tensor nature of the dual space.

                     Not collective.

                     SEEALSO:setLagrangeTensor, PetscDualSpaceLagrangeGetTensorSourcecodeatpetsc4py/PETSc/Space.pyx:896ReturntypeboolgetLagrangeTrimmed()
                     Return the trimmed nature of the dual space.

                     Not collective.

                     SEEALSO:setLagrangeTrimmed, PetscDualSpaceLagrangeGetTrimmedSourcecodeatpetsc4py/PETSc/Space.pyx:928ReturntypeboolgetNumComponents()
                     Return the number of components for this space.

                     Not collective.

                     SEEALSO:setNumComponents, PetscDualSpaceGetNumComponentsSourcecodeatpetsc4py/PETSc/Space.pyx:712ReturntypeintgetNumDof()
                     Return the number of degrees of freedom for each spatial dimension.

                     Not collective.

                     SEEALSO:PetscDualSpaceGetNumDofSourcecodeatpetsc4py/PETSc/Space.pyx:810ReturntypeArrayIntgetOrder()
                     Return the order of the dual space.

                     Not collective.

                     SEEALSO:setOrder, PetscDualSpaceGetOrderSourcecodeatpetsc4py/PETSc/Space.pyx:778ReturntypeintgetType()
                     Return the type of the dual space object.

                     Not collective.

                     SEEALSO:setType, PetscDualSpaceGetTypeSourcecodeatpetsc4py/PETSc/Space.pyx:744ReturntypestrsetDM(dm)
                     Set the DM representing the reference cell.

                     Not collective.

                     Parametersdm (DM) -- The reference cell.

                     ReturntypeNoneSEEALSO:getDM, PetscDualSpaceSetDMSourcecodeatpetsc4py/PETSc/Space.pyx:679setLagrangeContinuity(continuous)
                     Indicate whether the element is continuous.

                     Not collective.

                     Parameterscontinuous (bool) -- The flag for element continuity.

                     ReturntypeNoneSEEALSO:getLagrangeContinuity, PetscDualSpaceLagrangeSetContinuitySourcecodeatpetsc4py/PETSc/Space.pyx:878setLagrangeTensor(tensor)
                     Set the tensor nature of the dual space.

                     Not collective.

                     Parameterstensor (bool) -- Whether the dual space has tensor layout (vs. simplicial).

                     ReturntypeNoneSEEALSO:getLagrangeTensor, PetscDualSpaceLagrangeSetTensorSourcecodeatpetsc4py/PETSc/Space.pyx:910setLagrangeTrimmed(trimmed)
                     Set the trimmed nature of the dual space.

                     Not collective.

                     Parameterstrimmed  (bool)  --  Whether  the  dual  space represents to dual basis of a trimmed
                            polynomial  space  (e.g.  Raviart-Thomas  and  higher  order  /  other  form  degree
                            variants).

                     ReturntypeNoneSEEALSO:getLagrangeTrimmed, PetscDualSpaceLagrangeSetTrimmedSourcecodeatpetsc4py/PETSc/Space.pyx:942setNumComponents(nc)
                     Set the number of components for this space.

                     Logically collective.

                     Parametersnc (int) -- The number of components

                     ReturntypeNoneSEEALSO:getNumComponents, PetscDualSpaceSetNumComponentsSourcecodeatpetsc4py/PETSc/Space.pyx:726setOrder(order)
                     Set the order of the dual space.

                     Not collective.

                     Parametersorder (int) -- The order.

                     ReturntypeNoneSEEALSO:getOrder, PetscDualSpaceSetOrderSourcecodeatpetsc4py/PETSc/Space.pyx:792setSimpleDimension(dim)
                     Set the number of functionals in the dual space basis.

                     Logically collective.

                     Parametersdim (int) -- The basis dimension.

                     ReturntypeNoneSEEALSO:PetscDualSpaceSimpleSetDimensionSourcecodeatpetsc4py/PETSc/Space.pyx:962setSimpleFunctional(func,functional)
                     Set the given basis element for this dual space.

                     Not collective.

                     Parameters

                            • func (int) -- The basis index.

                            • functional (Quad) -- The basis functional.

                     ReturntypeNoneSEEALSO:PetscDualSpaceSimpleSetFunctionalSourcecodeatpetsc4py/PETSc/Space.pyx:980setType(dualspace_type)
                     Build a particular type of dual space.

                     Collective.

                     Parametersdualspace_type (Type|str) -- The kind of space.

                     Returntype
                            Self

                     SEEALSO:getType, PetscDualSpaceSetTypeSourcecodeatpetsc4py/PETSc/Space.pyx:758setUp()
                     Construct a basis for a DualSpace.

                     Collective.

                     SEEALSO:PetscDualSpaceSetUpSourcecodeatpetsc4py/PETSc/Space.pyx:582ReturntypeNoneview(viewer=None)
                     View a DualSpace.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the DualSpace.

                     ReturntypeNoneSEEALSO:PetscDualSpaceViewSourcecodeatpetsc4py/PETSc/Space.pyx:617petsc4py.PETSc.FEclasspetsc4py.PETSc.FE
              Bases: Object

              A PETSc object that manages a finite element space.

              Enumerations
                                            ┌──────┬───────────────────────────┐
                                            │ Type │ The finite element types. │
                                            └──────┴───────────────────────────┘

   petsc4py.PETSc.FE.Typeclasspetsc4py.PETSc.FE.Type
                     Bases: object

                     The finite element types.

                     Attributes Summary
                                            ┌───────────┬──────────────────────────────┐
                                            │ BASIC     │ Object BASIC of type str     │
                                            ├───────────┼──────────────────────────────┤
                                            │ COMPOSITE │ Object COMPOSITE of type str │
                                            ├───────────┼──────────────────────────────┤
                                            │ OPENCL    │ Object OPENCL of type str    │
                                            └───────────┴──────────────────────────────┘

                     Attributes Documentation

                     BASIC:str=BASIC
                            Object BASIC of type strCOMPOSITE:str=COMPOSITE
                            Object COMPOSITE of type strOPENCL:str=OPENCL
                            Object OPENCL of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ create([comm])                        │ Create an empty FE object.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createDefault(dim,   nc,  isSimplex[, │ Create   a   FE   for    basic    FEM │
                      │ qorder, ...])                         │ computation.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createLagrange(dim,   nc,  isSimplex, │ Create a FE for  the  basic  Lagrange │
                      │ k[, ...])                             │ space of degree k.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the FE object.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBasisSpace()                       │ Return   the   Space   used  for  the │
                      │                                       │ approximation of the FE solution.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDimension()                        │ Return the dimension  of  the  finite │
                      │                                       │ element space on a cell.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDualSpace()                        │ Return  the  DualSpace used to define │
                      │                                       │ the inner product for the FE.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFaceQuadrature()                   │ Return the  Quad  used  to  calculate │
                      │                                       │ inner products on faces.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumComponents()                    │ Return  the  number  of components in │
                      │                                       │ the element.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumDof()                           │ Return the number of DOFs.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getQuadrature()                       │ Return the  Quad  used  to  calculate │
                      │                                       │ inner products.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSpatialDimension()                 │ Return  the  spatial dimension of the │
                      │                                       │ element.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTileSizes()                        │ Return the tile sizes for evaluation. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBasisSpace(sp)                     │ Set   the   Space   used   for    the │
                      │                                       │ approximation of the solution.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDualSpace(dspace)                  │ Set  the DualSpace used to define the │
                      │                                       │ inner product.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFaceQuadrature(quad)               │ Set the Quad used to calculate  inner │
                      │                                       │ products on faces.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Set  parameters  in  a  FE  from  the │
                      │                                       │ options database.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNumComponents(comp)                │ Set the number of field components in │
                      │                                       │ the element.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setQuadrature(quad)                   │ Set the Quad used to calculate  inner │
                      │                                       │ products.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTileSizes(blockSize,    numBlocks, │ Set the tile sizes for evaluation.    │
                      │ ...)                                  │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(fe_type)                      │ Build a particular FE.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Construct data structures for the  FE │
                      │                                       │ after the Type has been set.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View a FE object.                     │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Create an empty FE object.

                     Collective.

                     The type can then be set with setType.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:setType, PetscFECreateSourcecodeatpetsc4py/PETSc/FE.pyx:53createDefault(dim,nc,isSimplex,qorder=DETERMINE,prefix=None,comm=None)
                     Create a FE for basic FEM computation.

                     Collective.

                     Parameters

                            • dim (int) -- The spatial dimension.

                            • nc (int) -- The number of components.

                            • isSimplex  (bool)  --  Flag  for  simplex  reference cell, otherwise it's a tensor
                              product.

                            • qorder (int) -- The quadrature order or DETERMINE to use Space polynomial degree.

                            • prefix (str) -- The options prefix, or None.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PetscFECreateDefaultSourcecodeatpetsc4py/PETSc/FE.pyx:76createLagrange(dim,nc,isSimplex,k,qorder=DETERMINE,comm=None)
                     Create a FE for the basic Lagrange space of degree k.

                     Collective.

                     Parameters

                            • dim (int) -- The spatial dimension.

                            • nc (int) -- The number of components.

                            • isSimplex (bool) -- Flag for simplex  reference  cell,  otherwise  it's  a  tensor
                              product.

                            • k (int) -- The degree of the space.

                            • qorder (int) -- The quadrature order or DETERMINE to use Space polynomial degree.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PetscFECreateLagrangeSourcecodeatpetsc4py/PETSc/FE.pyx:122destroy()
                     Destroy the FE object.

                     Collective.

                     SEEALSO:PetscFEDestroySourcecodeatpetsc4py/PETSc/FE.pyx:40ReturntypeSelfgetBasisSpace()
                     Return the Space used for the approximation of the FE solution.

                     Not collective.

                     SEEALSO:setBasisSpace, PetscFEGetBasisSpaceSourcecodeatpetsc4py/PETSc/FE.pyx:387ReturntypeSpacegetDimension()
                     Return the dimension of the finite element space on a cell.

                     Not collective.

                     SEEALSO:PetscFEGetDimensionSourcecodeatpetsc4py/PETSc/FE.pyx:181ReturntypeintgetDualSpace()
                     Return the DualSpace used to define the inner product for the FE.

                     Not collective.

                     SEEALSO:setDualSpace, DualSpace, PetscFEGetDualSpaceSourcecodeatpetsc4py/PETSc/FE.pyx:443ReturntypeDualSpacegetFaceQuadrature()
                     Return the Quad used to calculate inner products on faces.

                     Not collective.

                     SEEALSO:setFaceQuadrature, PetscFEGetFaceQuadratureSourcecodeatpetsc4py/PETSc/FE.pyx:316ReturntypeQuadgetNumComponents()
                     Return the number of components in the element.

                     Not collective.

                     SEEALSO:setNumComponents, PetscFEGetNumComponentsSourcecodeatpetsc4py/PETSc/FE.pyx:209ReturntypeintgetNumDof()
                     Return the number of DOFs.

                     Not collective.

                     Return the number of DOFs (dual basis vectors) associated with mesh points on the reference
                     cell of a given dimension.

                     SEEALSO:PetscFEGetNumDofSourcecodeatpetsc4py/PETSc/FE.pyx:241ReturntypendarraygetQuadrature()
                     Return the Quad used to calculate inner products.

                     Not collective.

                     SEEALSO:setQuadrature, PetscFEGetQuadratureSourcecodeatpetsc4py/PETSc/FE.pyx:166ReturntypeQuadgetSpatialDimension()
                     Return the spatial dimension of the element.

                     Not collective.

                     SEEALSO:PetscFEGetSpatialDimensionSourcecodeatpetsc4py/PETSc/FE.pyx:195ReturntypeintgetTileSizes()
                     Return the tile sizes for evaluation.

                     Not collective.

                     Returns

                            • blockSize (int) -- The number of elements in a block.

                            • numBlocks (int) -- The number of blocks in a batch.

                            • batchSize (int) -- The number of elements in a batch.

                            • numBatches (int) -- The number of batches in a chunk.

                     Returntypetuple(int, int, int, int)

                     SEEALSO:setTileSizes, PetscFEGetTileSizesSourcecodeatpetsc4py/PETSc/FE.pyx:260setBasisSpace(sp)
                     Set the Space used for the approximation of the solution.

                     Not collective.

                     Parameterssp (Space) -- The Space object.

                     ReturntypeNoneSEEALSO:getBasisSpace, PetscFESetBasisSpaceSourcecodeatpetsc4py/PETSc/FE.pyx:402setDualSpace(dspace)
                     Set the DualSpace used to define the inner product.

                     Not collective.

                     Parametersdspace (DualSpace) -- The DualSpace object.

                     ReturntypeNoneSEEALSO:getDualSpace, DualSpace, PetscFESetDualSpaceSourcecodeatpetsc4py/PETSc/FE.pyx:458setFaceQuadrature(quad)
                     Set the Quad used to calculate inner products on faces.

                     Not collective.

                     Parametersquad (Quad) -- The Quad object.

                     ReturntypeQuadSEEALSO:getFaceQuadrature, PetscFESetFaceQuadratureSourcecodeatpetsc4py/PETSc/FE.pyx:349setFromOptions()
                     Set parameters in a FE from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, PetscFESetFromOptionsSourcecodeatpetsc4py/PETSc/FE.pyx:419ReturntypeNonesetNumComponents(comp)
                     Set the number of field components in the element.

                     Not collective.

                     Parameterscomp (int) -- The number of field components.

                     ReturntypeNoneSEEALSO:getNumComponents, PetscFESetNumComponentsSourcecodeatpetsc4py/PETSc/FE.pyx:223setQuadrature(quad)
                     Set the Quad used to calculate inner products.

                     Not collective.

                     Parametersquad (Quad) -- The Quad object.

                     ReturntypeSelfSEEALSO:getQuadrature, PetscFESetQuadratureSourcecodeatpetsc4py/PETSc/FE.pyx:331setTileSizes(blockSize,numBlocks,batchSize,numBatches)
                     Set the tile sizes for evaluation.

                     Not collective.

                     Parameters

                            • blockSize (int) -- The number of elements in a block.

                            • numBlocks (int) -- The number of blocks in a batch.

                            • batchSize (int) -- The number of elements in a batch.

                            • numBatches (int) -- The number of batches in a chunk.

                     ReturntypeNoneSEEALSO:getTileSizes, PetscFESetTileSizesSourcecodeatpetsc4py/PETSc/FE.pyx:286setType(fe_type)
                     Build a particular FE.

                     Collective.

                     Parametersfe_type (Type|str) -- The kind of FEM space.

                     Returntype
                            Self

                     SEEALSO:PetscFESetTypeSourcecodeatpetsc4py/PETSc/FE.pyx:367setUp()
                     Construct data structures for the FE after the Type has been set.

                     Collective.

                     SEEALSO:PetscFESetUpSourcecodeatpetsc4py/PETSc/FE.pyx:431ReturntypeNoneview(viewer=None)
                     View a FE object.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the graph.

                     ReturntypeNoneSEEALSO:PetscFEViewSourcecodeatpetsc4py/PETSc/FE.pyx:21petsc4py.PETSc.ISclasspetsc4py.PETSc.IS
              Bases: Object

              A collection of indices.

              IS objects are used to index into vectors and matrices and to set up vector scatters.

              SEEALSO:IS

              Enumerations
                                               ┌──────┬──────────────────────┐
                                               │ Type │ The index set types. │
                                               └──────┴──────────────────────┘

   petsc4py.PETSc.IS.Typeclasspetsc4py.PETSc.IS.Type
                     Bases: object

                     The index set types.

                     Attributes Summary
                                              ┌─────────┬────────────────────────────┐
                                              │ BLOCK   │ Object BLOCK of type str   │
                                              ├─────────┼────────────────────────────┤
                                              │ GENERAL │ Object GENERAL of type str │
                                              ├─────────┼────────────────────────────┤
                                              │ STRIDE  │ Object STRIDE of type str  │
                                              └─────────┴────────────────────────────┘

                     Attributes Documentation

                     BLOCK:str=BLOCK
                            Object BLOCK of type strGENERAL:str=GENERAL
                            Object GENERAL of type strSTRIDE:str=STRIDE
                            Object STRIDE of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ allGather()                           │ Concatenate  index sets stored across │
                      │                                       │ processors.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ buildTwoSided([toindx])               │ Create  an  index  set  describing  a │
                      │                                       │ global mapping.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ complement(nmin, nmax)                │ Create a complement index set.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ copy([result])                        │ Copy  the  contents  of the index set │
                      │                                       │ into another.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create an IS.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createBlock(bsize, indices[, comm])   │ Create a blocked index set.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createGeneral(indices[, comm])        │ Create an IS with indices.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createStride(size[,   first,    step, │ Create  an  index  set  consisting of │
                      │ comm])                                │ evenly spaced values.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the index set.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ difference(iset)                      │ Return  the  difference  between  two │
                      │                                       │ index sets.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ duplicate()                           │ Create a copy of the index set.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ embed(iset, drop)                     │ Embed self into iset.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ equal(iset)                           │ Return  whether  the  index sets have │
                      │                                       │ the same set of indices or not.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ expand(iset)                          │ Return the  union  of  two  (possibly │
                      │                                       │ unsorted) index sets.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBlockIndices()                     │ Return  the  indices  of an index set │
                      │                                       │ with type IS.Type.BLOCK.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBlockSize()                        │ Return the number of  elements  in  a │
                      │                                       │ block.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getIndices()                          │ Return the indices of the index set.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getInfo()                             │ Return   stride  information  for  an │
                      │                                       │ index set with type IS.Type.STRIDE.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalSize()                        │ Return the  process-local  length  of │
                      │                                       │ the index set.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSize()                             │ Return  the global length of an index │
                      │                                       │ set.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSizes()                            │ Return the local and global sizes  of │
                      │                                       │ the index set.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStride()                           │ Return size and stride information.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return  the index set type associated │
                      │                                       │ with the IS.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ invertPermutation([nlocal])           │ Invert the index set.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isIdentity()                          │ Return whether the index set has been │
                      │                                       │ declared as an identity.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isPermutation()                       │ Return whether an index set has  been │
                      │                                       │ declared to be a permutation.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isSorted()                            │ Return  whether the indices have been │
                      │                                       │ sorted.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ load(viewer)                          │ Load a stored index set.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ renumber([mult])                      │ Renumber the non-negative entries  of │
                      │                                       │ an index set, starting from 0.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBlockIndices(bsize, indices)       │ Set the indices for an index set with │
                      │                                       │ type IS.Type.BLOCK.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBlockSize(bs)                      │ Set the block size of the index set.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setIdentity()                         │ Mark   the  index  set  as  being  an │
                      │                                       │ identity.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setIndices(indices)                   │ Set the indices of an index set.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPermutation()                      │ Mark  the  index  set  as   being   a │
                      │                                       │ permutation.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStride(size[, first, step])        │ Set  the  stride  information  for an │
                      │                                       │ index set with type IS.Type.STRIDE.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(is_type)                      │ Set the type of the index set.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ sort()                                │ Sort the indices of an index set.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ sum(iset)                             │ Return  the  union  of  two  (sorted) │
                      │                                       │ index sets.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ toGeneral()                           │ Convert   the   index   set  type  to │
                      │                                       │ IS.Type.GENERAL.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ union(iset)                           │ Return the  union  of  two  (possibly │
                      │                                       │ unsorted) index sets.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ Display the index set.                │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                   ┌─────────────┬───────────────────────────────────────┐
                                   │ array       │ View  of the index set as an array of │
                                   │             │ integers.                             │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ block_size  │ The number of elements in a block.    │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ identity    │ True if index set is an  identity,  ‐ │
                                   │             │ False otherwise.                      │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ indices     │ The indices of the index set.         │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ local_size  │ The local size of the index set.      │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ permutation │ True if index set is a permutation, ‐ │
                                   │             │ False otherwise.                      │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ size        │ The global size of the index set.     │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ sizes       │ The  local  and  global  sizes of the │
                                   │             │ index set.                            │
                                   ├─────────────┼───────────────────────────────────────┤
                                   │ sorted      │ True if index set  is  sorted,  False │
                                   │             │ otherwise.                            │
                                   └─────────────┴───────────────────────────────────────┘

              Methods Documentation

              allGather()
                     Concatenate index sets stored across processors.

                     Collective.

                     The returned index set will be the same on every processor.

                     SEEALSO:ISAllGatherSourcecodeatpetsc4py/PETSc/IS.pyx:304ReturntypeISbuildTwoSided(toindx=None)
                     Create an index set describing a global mapping.

                     Collective.

                     This  function generates an index set that contains new numbers from remote or local on the
                     index set.

                     Parameterstoindx (IS|None) -- Index set describing which indices to send, default is to send
                            natural numbering.

                     Returns
                            New index set containing the new numbers from remote or local.

                     ReturntypeISSEEALSO:ISBuildTwoSidedSourcecodeatpetsc4py/PETSc/IS.pyx:333complement(nmin,nmax)
                     Create a complement index set.

                     Collective.

                     The complement set of indices is all indices that are not in the provided set  (and  within
                     the provided bounds).

                     Parameters

                            • nmin  (int) -- Minimum index that can be found in the local part of the complement
                              index set.

                            • nmax (int) -- One greater than the maximum index that can be found  in  the  local
                              part of the complement index set.

                     ReturntypeIS

                     Notes

                     For  a  parallel  index  set,  this  will generate the local part of the complement on each
                     process.

                     To generate the entire complement (on each process) of a parallel  index  set,  first  call
                     IS.allGather and then call this method.

                     SEEALSO:IS.allGather, ISComplementSourcecodeatpetsc4py/PETSc/IS.pyx:674copy(result=None)
                     Copy the contents of the index set into another.

                     Collective.

                     Parametersresult  (IS|None)  --  The target index set. If None then IS.duplicate is called
                            first.

                     Returns
                            The copied index set. If result is not None then this is returned here.

                     ReturntypeISSEEALSO:IS.duplicate, ISCopySourcecodeatpetsc4py/PETSc/IS.pyx:253create(comm=None)
                     Create an IS.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:ISCreateSourcecodeatpetsc4py/PETSc/IS.pyx:88createBlock(bsize,indices,comm=None)
                     Create a blocked index set.

                     Collective.

                     Parameters

                            • bsize (int) -- Block size.

                            • indices (Sequence[int]) -- Integer array of indices.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:ISCreateBlockSourcecodeatpetsc4py/PETSc/IS.pyx:171createGeneral(indices,comm=None)
                     Create an IS with indices.

                     Collective.

                     Parameters

                            • indices (Sequence[int]) -- Integer array.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:ISCreateGeneralSourcecodeatpetsc4py/PETSc/IS.pyx:142createStride(size,first=0,step=0,comm=None)
                     Create an index set consisting of evenly spaced values.

                     Collective.

                     Parameters

                            • size (int) -- The length of the locally owned portion of the index set.

                            • first (int) -- The first element of the index set.

                            • step (int) -- The difference between adjacent indices.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:ISCreateStrideSourcecodeatpetsc4py/PETSc/IS.pyx:204destroy()
                     Destroy the index set.

                     Collective.

                     SEEALSO:ISDestroySourcecodeatpetsc4py/PETSc/IS.pyx:75ReturntypeSelfdifference(iset)
                     Return the difference between two index sets.

                     Collective.

                     Parametersiset (IS) -- Index set to compute the difference with.

                     Returns
                            Index set representing the difference between self and iset.

                     ReturntypeISSEEALSO:ISDifferenceSourcecodeatpetsc4py/PETSc/IS.pyx:650duplicate()
                     Create a copy of the index set.

                     Collective.

                     SEEALSO:IS.copy, ISDuplicateSourcecodeatpetsc4py/PETSc/IS.pyx:239ReturntypeISembed(iset,drop)
                     Embed self into iset.

                     Not collective.

                     The embedding is performed by finding the locations in iset that have the same  indices  as
                     self.

                     Parameters

                            • iset (IS) -- The index set to embed into.

                            • drop  (bool)  -- Flag indicating whether to drop indices from self that are not in
                              iset.

                     Returns
                            The embedded index set.

                     ReturntypeISSEEALSO:ISEmbedSourcecodeatpetsc4py/PETSc/IS.pyx:710equal(iset)
                     Return whether the index sets have the same set of indices or not.

                     Collective.

                     Parametersiset (IS) -- The index set to compare indices with.

                     ReturntypeboolSEEALSO:ISEqualSourcecodeatpetsc4py/PETSc/IS.pyx:550expand(iset)
                     Return the union of two (possibly unsorted) index sets.

                     Collective.

                     To compute the union, expand concatenates the two index sets and removes any duplicates.

                     Parametersiset (IS) -- Index set to compute the union with.

                     Returns
                            The new, combined, index set.

                     ReturntypeISSEEALSO:ISExpandSourcecodeatpetsc4py/PETSc/IS.pyx:588getBlockIndices()
                     Return the indices of an index set with type IS.Type.BLOCK.

                     Not collective.

                     SEEALSO:ISBlockGetIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:833ReturntypeArrayIntgetBlockSize()
                     Return the number of elements in a block.

                     Not collective.

                     SEEALSO:ISGetBlockSizeSourcecodeatpetsc4py/PETSc/IS.pyx:437ReturntypeintgetIndices()
                     Return the indices of the index set.

                     Not collective.

                     SEEALSO:ISGetIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:789ReturntypeArrayIntgetInfo()
                     Return stride information for an index set with type IS.Type.STRIDE.

                     Not collective.

                     Returns

                            • first (int) -- First element of the index set.

                            • step (int) -- Difference between adjacent indices.

                     Returntypetuple[int, int]

                     SEEALSO:IS.getStride, ISStrideGetInfoSourcecodeatpetsc4py/PETSc/IS.pyx:903getLocalSize()
                     Return the process-local length of the index set.

                     Not collective.

                     SEEALSO:ISGetLocalSizeSourcecodeatpetsc4py/PETSc/IS.pyx:401ReturntypeintgetSize()
                     Return the global length of an index set.

                     Not collective.

                     SEEALSO:ISGetSizeSourcecodeatpetsc4py/PETSc/IS.pyx:387ReturntypeintgetSizes()
                     Return the local and global sizes of the index set.

                     Not collective.

                     Returns

                            • local_size (int) -- The local size.

                            • global_size (int) -- The global size.

                     Returntypetuple[int, int]

                     SEEALSO:IS.getLocalSize, IS.getSizeSourcecodeatpetsc4py/PETSc/IS.pyx:415getStride()
                     Return size and stride information.

                     Not collective.

                     Returns

                            • size (int) -- Length of the locally owned portion of the index set.

                            • first (int) -- First element of the index set.

                            • step (int) -- Difference between adjacent indices.

                     Returntypetuple[int, int, int]

                     SEEALSO:ISGetLocalSize, ISStrideGetInfoSourcecodeatpetsc4py/PETSc/IS.pyx:879getType()
                     Return the index set type associated with the IS.

                     Not collective.

                     SEEALSO:ISGetTypeSourcecodeatpetsc4py/PETSc/IS.pyx:128ReturntypestrinvertPermutation(nlocal=None)
                     Invert the index set.

                     Collective.

                     For this to be correct the index set must be a permutation.

                     Parametersnlocal (int|None) -- The number of indices on  this  processor  in  the  resulting
                            index set, defaults to PETSC_DECIDE.

                     ReturntypeISSEEALSO:ISInvertPermutationSourcecodeatpetsc4py/PETSc/IS.pyx:363isIdentity()
                     Return whether the index set has been declared as an identity.

                     Collective.

                     SEEALSO:ISIdentitySourcecodeatpetsc4py/PETSc/IS.pyx:536ReturntypeboolisPermutation()
                     Return whether an index set has been declared to be a permutation.

                     Logically collective.

                     SEEALSO:ISPermutationSourcecodeatpetsc4py/PETSc/IS.pyx:509ReturntypeboolisSorted()
                     Return whether the indices have been sorted.

                     Collective.

                     SEEALSO:ISSortedSourcecodeatpetsc4py/PETSc/IS.pyx:482Returntypeboolload(viewer)
                     Load a stored index set.

                     Collective.

                     Parametersviewer    (Viewer)   --   Binary   file   viewer,   either   Viewer.Type.BINARY   or
                            Viewer.Type.HDF5.

                     ReturntypeSelfSEEALSO:ISLoadSourcecodeatpetsc4py/PETSc/IS.pyx:281renumber(mult=None)
                     Renumber the non-negative entries of an index set, starting from 0.

                     Collective.

                     Parametersmult (IS|None) -- The multiplicity of  each  entry  in  self,  default  implies  a
                            multiplicity of 1.

                     Returns

                            • int -- One past the largest entry of the new index set.

                            • IS -- The renumbered index set.

                     Returntypetuple[int, IS]

                     SEEALSO:ISRenumberSourcecodeatpetsc4py/PETSc/IS.pyx:741setBlockIndices(bsize,indices)
                     Set the indices for an index set with type IS.Type.BLOCK.

                     Collective.

                     Parameters

                            • bsize (int) -- Number of elements in each block.

                            • indices (Sequence[int]) -- List of integers.

                     ReturntypeNoneSEEALSO:ISBlockSetIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:810setBlockSize(bs)
                     Set the block size of the index set.

                     Logically collective.

                     Parametersbs (int) -- Block size.

                     ReturntypeNoneSEEALSO:ISSetBlockSizeSourcecodeatpetsc4py/PETSc/IS.pyx:451setIdentity()
                     Mark the index set as being an identity.

                     Logically collective.

                     SEEALSO:ISSetIdentitySourcecodeatpetsc4py/PETSc/IS.pyx:523ReturntypeSelfsetIndices(indices)
                     Set the indices of an index set.

                     Logically collective.

                     The index set is assumed to be of type IS.Type.GENERAL.

                     SEEALSO:ISGeneralSetIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:772Parametersindices (Sequence[int])

                     ReturntypeNonesetPermutation()
                     Mark the index set as being a permutation.

                     Logically collective.

                     SEEALSO:ISSetPermutationSourcecodeatpetsc4py/PETSc/IS.pyx:496ReturntypeSelfsetStride(size,first=0,step=1)
                     Set the stride information for an index set with type IS.Type.STRIDE.

                     Logically collective.

                     Parameters

                            • size (int) -- Length of the locally owned portion of the index set.

                            • first (int) -- First element of the index set.

                            • step (int) -- Difference between adjacent indices.

                     ReturntypeNoneSEEALSO:ISStrideSetStrideSourcecodeatpetsc4py/PETSc/IS.pyx:855setType(is_type)
                     Set the type of the index set.

                     Collective.

                     Parametersis_type (Type|str) -- The index set type.

                     ReturntypeNoneSEEALSO:ISSetTypeSourcecodeatpetsc4py/PETSc/IS.pyx:109sort() Sort the indices of an index set.

                     Collective.

                     SEEALSO:ISSortSourcecodeatpetsc4py/PETSc/IS.pyx:469ReturntypeSelfsum(iset)
                     Return the union of two (sorted) index sets.

                     Collective.

                     Parametersiset (IS) -- The index set to compute the union with.

                     ReturntypeISSEEALSO:ISSumSourcecodeatpetsc4py/PETSc/IS.pyx:569toGeneral()
                     Convert the index set type to IS.Type.GENERAL.

                     Collective.

                     SEEALSO:ISToGeneral, ISTypeSourcecodeatpetsc4py/PETSc/IS.pyx:320ReturntypeSelfunion(iset)
                     Return the union of two (possibly unsorted) index sets.

                     Collective.

                     This function will call either ISSum or ISExpand depending on whether or not the input sets
                     are already sorted.

                     Sequential only (as ISSum is sequential only).

                     Parametersiset (IS) -- Index set to compute the union with.

                     Returns
                            The new, combined, index set.

                     ReturntypeISSEEALSO:IS.expand, IS.sumSourcecodeatpetsc4py/PETSc/IS.pyx:615view(viewer=None)
                     Display the index set.

                     Collective.

                     Parametersviewer (Viewer|None) -- Viewer used to display the IS.

                     ReturntypeNoneSEEALSO:ISViewSourcecodeatpetsc4py/PETSc/IS.pyx:56

              Attributes Documentation

              array  View of the index set as an array of integers.

                     Not collective.

                     Sourcecodeatpetsc4py/PETSc/IS.pyx:1032block_size
                     The number of elements in a block.

                     Not collective.

                     SEEALSO:IS.getBlockSizeSourcecodeatpetsc4py/PETSc/IS.pyx:1006identityTrue if index set is an identity, False otherwise.

                     Collective.

                     SEEALSO:IS.isIdentitySourcecodeatpetsc4py/PETSc/IS.pyx:939indices
                     The indices of the index set.

                     Not collective.

                     SEEALSO:IS.getIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:1019local_size
                     The local size of the index set.

                     Not collective.

                     SEEALSO:IS.getLocalSizeSourcecodeatpetsc4py/PETSc/IS.pyx:993permutationTrue if index set is a permutation, False otherwise.

                     Logically collective.

                     SEEALSO:IS.isPermutationSourcecodeatpetsc4py/PETSc/IS.pyx:926size   The global size of the index set.

                     Not collective.

                     SEEALSO:IS.getSizeSourcecodeatpetsc4py/PETSc/IS.pyx:980sizes  The local and global sizes of the index set.

                     Not collective.

                     SEEALSO:IS.getSizesSourcecodeatpetsc4py/PETSc/IS.pyx:967sortedTrue if index set is sorted, False otherwise.

                     Collective.

                     SEEALSO:IS.isSortedSourcecodeatpetsc4py/PETSc/IS.pyx:952petsc4py.PETSc.InsertModeclasspetsc4py.PETSc.InsertMode
              Bases: object

              Insertion mode.

              Most commonly used insertion modes are:

              INSERT Insert provided value/s discarding previous value/s.

              ADD    Add provided value/s to current value/s.

              MAX    Insert the maximum of provided value/s and current value/s.

              SEEALSO:InsertMode

              Attributes Summary
                                ┌───────────────────┬───────────────────────────────────────┐
                                │ ADD               │ Constant ADD of type int              │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ ADD_ALL           │ Constant ADD_ALL of type int          │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ ADD_ALL_VALUES    │ Constant ADD_ALL_VALUES of type int   │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ ADD_BC            │ Constant ADD_BC of type int           │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ ADD_BC_VALUES     │ Constant ADD_BC_VALUES of type int    │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ ADD_VALUES        │ Constant ADD_VALUES of type int       │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ INSERT            │ Constant INSERT of type int           │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ INSERT_ALL        │ Constant INSERT_ALL of type int       │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ INSERT_ALL_VALUES │ Constant  INSERT_ALL_VALUES of type ‐ │
                                │                   │ int                                   │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ INSERT_BC         │ Constant INSERT_BC of type int        │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ INSERT_BC_VALUES  │ Constant INSERT_BC_VALUES of type int │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ INSERT_VALUES     │ Constant INSERT_VALUES of type int    │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ MAX               │ Constant MAX of type int              │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ MAX_VALUES        │ Constant MAX_VALUES of type int       │
                                ├───────────────────┼───────────────────────────────────────┤
                                │ NOT_SET_VALUES    │ Constant NOT_SET_VALUES of type int   │
                                └───────────────────┴───────────────────────────────────────┘

              Attributes Documentation

              ADD:int=ADD
                     Constant ADD of type intADD_ALL:int=ADD_ALL
                     Constant ADD_ALL of type intADD_ALL_VALUES:int=ADD_ALL_VALUES
                     Constant ADD_ALL_VALUES of type intADD_BC:int=ADD_BC
                     Constant ADD_BC of type intADD_BC_VALUES:int=ADD_BC_VALUES
                     Constant ADD_BC_VALUES of type intADD_VALUES:int=ADD_VALUES
                     Constant ADD_VALUES of type intINSERT:int=INSERT
                     Constant INSERT of type intINSERT_ALL:int=INSERT_ALL
                     Constant INSERT_ALL of type intINSERT_ALL_VALUES:int=INSERT_ALL_VALUES
                     Constant INSERT_ALL_VALUES of type intINSERT_BC:int=INSERT_BC
                     Constant INSERT_BC of type intINSERT_BC_VALUES:int=INSERT_BC_VALUES
                     Constant INSERT_BC_VALUES of type intINSERT_VALUES:int=INSERT_VALUES
                     Constant INSERT_VALUES of type intMAX:int=MAX
                     Constant MAX of type intMAX_VALUES:int=MAX_VALUES
                     Constant MAX_VALUES of type intNOT_SET_VALUES:int=NOT_SET_VALUES
                     Constant NOT_SET_VALUES of type intpetsc4py.PETSc.KSPclasspetsc4py.PETSc.KSP
              Bases: Object

              Abstract PETSc object that manages all Krylov methods.

              This is the object that manages the linear solves in PETSc (even those such as direct solvers that
              do no use Krylov accelerators).

              Notes

              When a direct solver is used, but no Krylov solver is used, the KSP object is still used but  with
              a Type.PREONLY, meaning that only application of the preconditioner is used as the linear solver.

              SEEALSO:create, setType, SNES, TS, PC, Type.CG, Type.GMRES, KSP

              Enumerations
                                     ┌─────────────────┬───────────────────────────────┐
                                     │ ConvergedReason │ KSP Converged Reason.         │
                                     ├─────────────────┼───────────────────────────────┤
                                     │ HPDDMType       │ The HPDDM Krylov solver type. │
                                     ├─────────────────┼───────────────────────────────┤
                                     │ NormType        │ KSP norm type.                │
                                     ├─────────────────┼───────────────────────────────┤
                                     │ Type            │ KSP Type.                     │
                                     └─────────────────┴───────────────────────────────┘

   petsc4py.PETSc.KSP.ConvergedReasonclasspetsc4py.PETSc.KSP.ConvergedReason
                     Bases: object

                     KSP Converged Reason.

                     CONVERGED_ITERATING
                            Still iterating

                     ITERATING
                            Still iterating

                     CONVERGED_RTOL_NORMAL
                            Undocumented.

                     CONVERGED_ATOL_NORMAL
                            Undocumented.

                     CONVERGED_RTOL
                            ∥r∥ <= rtolnorm(b) or rtolnorm(b - Ax₀)

                     CONVERGED_ATOL
                            ∥r∥ <= atol

                     CONVERGED_ITS
                            Used  by the Type.PREONLY solver after the single iteration of the preconditioner is
                            applied. Also used when the KSPConvergedSkip convergence test routine is set in KSP.

                     CONVERGED_NEG_CURVE
                            Undocumented.

                     CONVERGED_STEP_LENGTH
                            Undocumented.

                     CONVERGED_HAPPY_BREAKDOWN
                            Undocumented.

                     DIVERGED_NULL
                            Undocumented.

                     DIVERGED_MAX_IT
                            Ran out of iterations before any convergence criteria was reached.

                     DIVERGED_DTOL
                            norm(r) >= dtol*norm(b)

                     DIVERGED_BREAKDOWN
                            A breakdown in the Krylov method was detected so the method could  not  continue  to
                            enlarge  the  Krylov  space. Could be due to a singular matrix or preconditioner. In
                            KSPHPDDM, this is also returned when some  search  directions  within  a  block  are
                            colinear.

                     DIVERGED_BREAKDOWN_BICG
                            A  breakdown  in the KSPBICG method was detected so the method could not continue to
                            enlarge the Krylov space.

                     DIVERGED_NONSYMMETRIC
                            It appears the operator or preconditioner is not symmetric and this Krylov method (‐
                            Type.CG, Type.MINRES, Type.CR) requires symmetry.

                     DIVERGED_INDEFINITE_PC
                            It appears  the  preconditioner  is  indefinite  (has  both  positive  and  negative
                            eigenvalues) and this Krylov method (Type.CG) requires it to be positive definite.

                     DIVERGED_NANORINF
                            Undocumented.

                     DIVERGED_INDEFINITE_MAT
                            Undocumented.

                     DIVERGED_PCSETUP_FAILED
                            It  was  not  possible to build or use the requested preconditioner. This is usually
                            due to a zero pivot in a factorization. It can also  result  from  a  failure  in  a
                            subpreconditioner inside a nested preconditioner such as PC.Type.FIELDSPLIT.

                     SEEALSO:None

                     Attributes Summary
                               ┌───────────────────────────┬───────────────────────────────────────┐
                               │ CONVERGED_ATOL            │ Constant CONVERGED_ATOL of type int   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ CONVERGED_ATOL_NORMAL     │ Constant   CONVERGED_ATOL_NORMAL   of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ CONVERGED_HAPPY_BREAKDOWN │ Constant CONVERGED_HAPPY_BREAKDOWN of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ CONVERGED_ITERATING       │ Constant CONVERGED_ITERATING of  type │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ CONVERGED_ITS             │ Constant CONVERGED_ITS of type int    │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ CONVERGED_NEG_CURVE       │ Constant  CONVERGED_NEG_CURVE of type │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ CONVERGED_RTOL            │ Constant CONVERGED_RTOL of type int   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ CONVERGED_RTOL_NORMAL     │ Constant   CONVERGED_RTOL_NORMAL   of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ CONVERGED_STEP_LENGTH     │ Constant   CONVERGED_STEP_LENGTH   of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_BREAKDOWN        │ Constant DIVERGED_BREAKDOWN of type ‐ │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_BREAKDOWN_BICG   │ Constant  DIVERGED_BREAKDOWN_BICG  of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_DTOL             │ Constant DIVERGED_DTOL of type int    │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_INDEFINITE_MAT   │ Constant  DIVERGED_INDEFINITE_MAT  of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_INDEFINITE_PC    │ Constant  DIVERGED_INDEFINITE_PC   of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_MAX_IT           │ Constant DIVERGED_MAX_IT of type int  │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_NANORINF         │ Constant  DIVERGED_NANORINF of type ‐ │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_NONSYMMETRIC     │ Constant   DIVERGED_NONSYMMETRIC   of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_NULL             │ Constant DIVERGED_NULL of type int    │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIVERGED_PCSETUP_FAILED   │ Constant  DIVERGED_PCSETUP_FAILED  of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ ITERATING                 │ Constant ITERATING of type int        │
                               └───────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     CONVERGED_ATOL:int=CONVERGED_ATOL
                            Constant CONVERGED_ATOL of type intCONVERGED_ATOL_NORMAL:int=CONVERGED_ATOL_NORMAL
                            Constant CONVERGED_ATOL_NORMAL of type intCONVERGED_HAPPY_BREAKDOWN:int=CONVERGED_HAPPY_BREAKDOWN
                            Constant CONVERGED_HAPPY_BREAKDOWN of type intCONVERGED_ITERATING:int=CONVERGED_ITERATING
                            Constant CONVERGED_ITERATING of type intCONVERGED_ITS:int=CONVERGED_ITS
                            Constant CONVERGED_ITS of type intCONVERGED_NEG_CURVE:int=CONVERGED_NEG_CURVE
                            Constant CONVERGED_NEG_CURVE of type intCONVERGED_RTOL:int=CONVERGED_RTOL
                            Constant CONVERGED_RTOL of type intCONVERGED_RTOL_NORMAL:int=CONVERGED_RTOL_NORMAL
                            Constant CONVERGED_RTOL_NORMAL of type intCONVERGED_STEP_LENGTH:int=CONVERGED_STEP_LENGTH
                            Constant CONVERGED_STEP_LENGTH of type intDIVERGED_BREAKDOWN:int=DIVERGED_BREAKDOWN
                            Constant DIVERGED_BREAKDOWN of type intDIVERGED_BREAKDOWN_BICG:int=DIVERGED_BREAKDOWN_BICG
                            Constant DIVERGED_BREAKDOWN_BICG of type intDIVERGED_DTOL:int=DIVERGED_DTOL
                            Constant DIVERGED_DTOL of type intDIVERGED_INDEFINITE_MAT:int=DIVERGED_INDEFINITE_MAT
                            Constant DIVERGED_INDEFINITE_MAT of type intDIVERGED_INDEFINITE_PC:int=DIVERGED_INDEFINITE_PC
                            Constant DIVERGED_INDEFINITE_PC of type intDIVERGED_MAX_IT:int=DIVERGED_MAX_IT
                            Constant DIVERGED_MAX_IT of type intDIVERGED_NANORINF:int=DIVERGED_NANORINF
                            Constant DIVERGED_NANORINF of type intDIVERGED_NONSYMMETRIC:int=DIVERGED_NONSYMMETRIC
                            Constant DIVERGED_NONSYMMETRIC of type intDIVERGED_NULL:int=DIVERGED_NULL
                            Constant DIVERGED_NULL of type intDIVERGED_PCSETUP_FAILED:int=DIVERGED_PCSETUP_FAILED
                            Constant DIVERGED_PCSETUP_FAILED of type intITERATING:int=ITERATING
                            Constant ITERATING of type intpetsc4py.PETSc.KSP.HPDDMTypeclasspetsc4py.PETSc.KSP.HPDDMType
                     Bases: object

                     The HPDDM Krylov solver type.

                     Attributes Summary
                                             ┌─────────┬──────────────────────────────┐
                                             │ BCG     │ Constant BCG of type int     │
                                             ├─────────┼──────────────────────────────┤
                                             │ BFBCG   │ Constant BFBCG of type int   │
                                             ├─────────┼──────────────────────────────┤
                                             │ BGCRODR │ Constant BGCRODR of type int │
                                             ├─────────┼──────────────────────────────┤
                                             │ BGMRES  │ Constant BGMRES of type int  │
                                             ├─────────┼──────────────────────────────┤
                                             │ CG      │ Constant CG of type int      │
                                             ├─────────┼──────────────────────────────┤
                                             │ GCRODR  │ Constant GCRODR of type int  │
                                             ├─────────┼──────────────────────────────┤
                                             │ GMRES   │ Constant GMRES of type int   │
                                             ├─────────┼──────────────────────────────┤
                                             │ PREONLY │ Constant PREONLY of type int │
                                             └─────────┴──────────────────────────────┘

                     Attributes Documentation

                     BCG:int=BCG
                            Constant BCG of type intBFBCG:int=BFBCG
                            Constant BFBCG of type intBGCRODR:int=BGCRODR
                            Constant BGCRODR of type intBGMRES:int=BGMRES
                            Constant BGMRES of type intCG:int=CG
                            Constant CG of type intGCRODR:int=GCRODR
                            Constant GCRODR of type intGMRES:int=GMRES
                            Constant GMRES of type intPREONLY:int=PREONLY
                            Constant PREONLY of type intpetsc4py.PETSc.KSP.NormTypeclasspetsc4py.PETSc.KSP.NormType
                     Bases: object

                     KSP norm type.

                     The available norm types are:

                     NONE   Skips computing the norm, this should generally only be used if you  are  using  the
                            Krylov method as a smoother with a fixed small number of iterations. Implicitly sets
                            KSPConvergedSkip  as  KSP  convergence  test.  Note  that certain algorithms such as
                            Type.GMRES ALWAYS require the norm calculation, for  these  methods  the  norms  are
                            still computed, they are just not used in the convergence test.

                     PRECONDITIONED
                            The  default  for left preconditioned solves, uses the l₂ norm of the preconditioned
                            residual P⁻¹(b - Ax).

                     UNPRECONDITIONED
                            Uses the l₂ norm of the true b - Ax residual.

                     NATURAL
                            Supported by Type.CG, Type.CR, Type.CGNE, Type.CGS.

                     Attributes Summary
                                 ┌───────────────────────┬───────────────────────────────────────┐
                                 │ DEFAULT               │ Constant DEFAULT of type int          │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ NATURAL               │ Constant NATURAL of type int          │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ NO                    │ Constant NO of type int               │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ NONE                  │ Constant NONE of type int             │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ NORM_DEFAULT          │ Constant NORM_DEFAULT of type int     │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ NORM_NATURAL          │ Constant NORM_NATURAL of type int     │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ NORM_NONE             │ Constant NORM_NONE of type int        │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ NORM_PRECONDITIONED   │ Constant NORM_PRECONDITIONED of  type │
                                 │                       │ int                                   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ NORM_UNPRECONDITIONED │ Constant   NORM_UNPRECONDITIONED   of │
                                 │                       │ type int                              │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ PRECONDITIONED        │ Constant PRECONDITIONED of type int   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ UNPRECONDITIONED      │ Constant UNPRECONDITIONED of type int │
                                 └───────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     DEFAULT:int=DEFAULT
                            Constant DEFAULT of type intNATURAL:int=NATURAL
                            Constant NATURAL of type intNO:int=NO
                            Constant NO of type intNONE:int=NONE
                            Constant NONE of type intNORM_DEFAULT:int=NORM_DEFAULT
                            Constant NORM_DEFAULT of type intNORM_NATURAL:int=NORM_NATURAL
                            Constant NORM_NATURAL of type intNORM_NONE:int=NORM_NONE
                            Constant NORM_NONE of type intNORM_PRECONDITIONED:int=NORM_PRECONDITIONED
                            Constant NORM_PRECONDITIONED of type intNORM_UNPRECONDITIONED:int=NORM_UNPRECONDITIONED
                            Constant NORM_UNPRECONDITIONED of type intPRECONDITIONED:int=PRECONDITIONED
                            Constant PRECONDITIONED of type intUNPRECONDITIONED:int=UNPRECONDITIONED
                            Constant UNPRECONDITIONED of type intpetsc4py.PETSc.KSP.Typeclasspetsc4py.PETSc.KSP.Type
                     Bases: object

                     KSP Type.

                     The available types are:

                     RICHARDSON
                            The preconditioned Richardson iterative method KSPRICHARDSON.

                     CHEBYSHEV
                            The preconditioned Chebyshev iterative method.  KSPCHEBYSHEV.

                     CG     The Preconditioned Conjugate Gradient (PCG) iterative method.  KSPCGGROPPCG
                            A pipelined conjugate gradient method (Gropp).  KSPGROPPCGPIPECG A pipelined conjugate gradient method.  KSPPIPECGPIPECGRR
                            Pipelined Conjugate Gradients with Residual Replacement.  KSPPIPECGRRPIPELCG
                            Deep pipelined (length l) Conjugate Gradient method.  KSPPIPELCGPIPEPRCG
                            Pipelined predict-and-recompute conjugate gradient method.  KSPPIPEPRCGPIPECG2
                            Pipelined conjugate gradient method with a single  non-blocking  reduction  per  two
                            iterations. KSPPIPECG2CGNE   Applies the preconditioned conjugate gradient method to the normal equations without
                            explicitly forming AᵀA. KSPCGNENASH   Conjugate gradient method subject to a constraint on the solution norm. KSPNASHSTCG   Conjugate gradient method subject to a constraint on the solution norm. KSPSTCGGLTR   Conjugate gradient method subject to a constraint on the solution norm. KSPGLTRFCG    Flexible  Conjugate  Gradient  method (FCG). Unlike most KSP methods this allows the
                            preconditioner to be nonlinear.  KSPFCGPIPEFCG
                            Pipelined, Flexible Conjugate Gradient method.  KSPPIPEFCGGMRES  Generalized Minimal Residual method with restart.  KSPGMRESPIPEFGMRES
                            Pipelined (1-stage) Flexible Generalized Minimal Residual method. KSPPIPEFGMRESFGMRES Implements the Flexible Generalized Minimal Residual method.  KSPFGMRESLGMRES Augments the standard Generalized Minimal Residual method approximation  space  with
                            approximations to the error from previous restart cycles. KSPLGMRESDGMRES Deflated  Generalized  Minimal Residual method. In this implementation, the adaptive
                            strategy allows to switch to the  deflated  GMRES  when  the  stagnation  occurs.  ‐
                            KSPDGMRESPGMRES Pipelined Generalized Minimal Residual method.  KSPPGMRESTCQMR  A variant of Quasi Minimal Residual (QMR).  KSPTCQMRBCGS   Stabilized version of Biconjugate Gradient (BiCGStab) method.  KSPBCGSIBCGS  Improved  Stabilized  version  of  BiConjugate  Gradient  (IBiCGStab)  method  in an
                            alternative form to have only a single global reduction  operation  instead  of  the
                            usual 3 (or 4).  KSPIBCGSQMRCGS Quasi-  Minimal  Residual  variant  of the Bi-CGStab algorithm (QMRCGStab) method. ‐
                            KSPQMRCGSFBCGS  Flexible Stabilized version of BiConjugate Gradient (BiCGStab) method. KSPFBCGSFBCGSR A mathematically equivalent variant  of  flexible  stabilized  BiConjugate  Gradient
                            (BiCGStab). KSPFBCGSRBCGSL  Variant  of the L-step stabilized BiConjugate Gradient (BiCGStab(L)) algorithm. Uses
                            "L-step" Minimal Residual (MR) polynomials. The variation concerns cases  when  some
                            parameters are negative due to round-off. KSPBCGSLPIPEBCGS
                            Pipelined stabilized BiConjugate Gradient (BiCGStab) method.  KSPPIPEBCGSCGS    Conjugate Gradient Squared method.  KSPCGSTFQMR  A Transpose Tree Quasi- Minimal Residual (QMR).  KSPCRCR     (Preconditioned) Conjugate Residuals (CR) method.  KSPCRPIPECR Pipelined Conjugate Residual (CR) method.  KSPPIPECRLSQR   Least squares solver.  KSPLSQRPREONLY
                            Applies  ONLY the preconditioner exactly once. This may be used in inner iterations,
                            where it is desired to allow multiple iterations as well as the "0-iteration"  case.
                            It is commonly used with the direct solver preconditioners like PCLU and PCCHOLESKY.
                            There is an alias of KSPNONE.  KSPPREONLYNONE   No solver KSPNONEQCG    Conjugate Gradient (CG) method subject to a constraint on the solution norm. KSPQCGBICG   Implements the Biconjugate gradient method (BiCG).  Similar to running the conjugate
                            gradient on the normal equations.  KSPBICGMINRES Minimum Residual (MINRES) method.  KSPMINRESSYMMLQ Symmetric LQ method (SymmLQ). Uses LQ decomposition (lower trapezoidal).  KSPSYMMLQLCD    Left Conjugate Direction (LCD) method.  KSPLCDPYTHON Python shell solver. Call Python function to implement solver.  KSPPYTHONGCR    Preconditioned flexible Generalized Conjugate Residual (GCR) method.  KSPGCRPIPEGCR
                            Pipelined Generalized Conjugate Residual method.  KSPPIPEGCRTSIRM  Two-Stage Iteration with least-squares Residual Minimization method. KSPTSIRMCGLS   Conjugate   Gradient   method   for   Least-Squares  problems.  Supports  non-square
                            (rectangular) matrices. KSPCGLSFETIDP Dual-Primal (DP) Finite Element Tearing and Interconnect (FETI) method. KSPFETIDPHPDDM  Interface with the HPDDM library. This KSP may be used  to  further  select  methods
                            that  are  currently  not  implemented  natively  in PETSc, e.g., GCRODR, a recycled
                            Krylov method which is similar to KSPLGMRES. KSPHPDDMSEEALSO:WorkingwithPETScoptions, KSPType

                     Attributes Summary
                                           ┌────────────┬───────────────────────────────┐
                                           │ BCGS       │ Object BCGS of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ BCGSL      │ Object BCGSL of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ BICG       │ Object BICG of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ CG         │ Object CG of type str         │
                                           ├────────────┼───────────────────────────────┤
                                           │ CGLS       │ Object CGLS of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ CGNE       │ Object CGNE of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ CGS        │ Object CGS of type str        │
                                           ├────────────┼───────────────────────────────┤
                                           │ CHEBYSHEV  │ Object CHEBYSHEV of type str  │
                                           ├────────────┼───────────────────────────────┤
                                           │ CR         │ Object CR of type str         │
                                           ├────────────┼───────────────────────────────┤
                                           │ DGMRES     │ Object DGMRES of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ FBCGS      │ Object FBCGS of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ FBCGSR     │ Object FBCGSR of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ FCG        │ Object FCG of type str        │
                                           ├────────────┼───────────────────────────────┤
                                           │ FETIDP     │ Object FETIDP of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ FGMRES     │ Object FGMRES of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ GCR        │ Object GCR of type str        │
                                           ├────────────┼───────────────────────────────┤
                                           │ GLTR       │ Object GLTR of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ GMRES      │ Object GMRES of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ GROPPCG    │ Object GROPPCG of type str    │
                                           ├────────────┼───────────────────────────────┤
                                           │ HPDDM      │ Object HPDDM of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ IBCGS      │ Object IBCGS of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ LCD        │ Object LCD of type str        │
                                           ├────────────┼───────────────────────────────┤
                                           │ LGMRES     │ Object LGMRES of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ LSQR       │ Object LSQR of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ MINRES     │ Object MINRES of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ NASH       │ Object NASH of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ NONE       │ Object NONE of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ PGMRES     │ Object PGMRES of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPEBCGS   │ Object PIPEBCGS of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPECG     │ Object PIPECG of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPECG2    │ Object PIPECG2 of type str    │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPECGRR   │ Object PIPECGRR of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPECR     │ Object PIPECR of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPEFCG    │ Object PIPEFCG of type str    │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPEFGMRES │ Object PIPEFGMRES of type str │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPEGCR    │ Object PIPEGCR of type str    │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPELCG    │ Object PIPELCG of type str    │
                                           ├────────────┼───────────────────────────────┤
                                           │ PIPEPRCG   │ Object PIPEPRCG of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ PREONLY    │ Object PREONLY of type str    │
                                           ├────────────┼───────────────────────────────┤
                                           │ PYTHON     │ Object PYTHON of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ QCG        │ Object QCG of type str        │
                                           ├────────────┼───────────────────────────────┤
                                           │ QMRCGS     │ Object QMRCGS of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ RICHARDSON │ Object RICHARDSON of type str │
                                           ├────────────┼───────────────────────────────┤
                                           │ STCG       │ Object STCG of type str       │
                                           ├────────────┼───────────────────────────────┤
                                           │ SYMMLQ     │ Object SYMMLQ of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ TCQMR      │ Object TCQMR of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ TFQMR      │ Object TFQMR of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ TSIRM      │ Object TSIRM of type str      │
                                           └────────────┴───────────────────────────────┘

                     Attributes Documentation

                     BCGS:str=BCGS
                            Object BCGS of type strBCGSL:str=BCGSL
                            Object BCGSL of type strBICG:str=BICG
                            Object BICG of type strCG:str=CG
                            Object CG of type strCGLS:str=CGLS
                            Object CGLS of type strCGNE:str=CGNE
                            Object CGNE of type strCGS:str=CGS
                            Object CGS of type strCHEBYSHEV:str=CHEBYSHEV
                            Object CHEBYSHEV of type strCR:str=CR
                            Object CR of type strDGMRES:str=DGMRES
                            Object DGMRES of type strFBCGS:str=FBCGS
                            Object FBCGS of type strFBCGSR:str=FBCGSR
                            Object FBCGSR of type strFCG:str=FCG
                            Object FCG of type strFETIDP:str=FETIDP
                            Object FETIDP of type strFGMRES:str=FGMRES
                            Object FGMRES of type strGCR:str=GCR
                            Object GCR of type strGLTR:str=GLTR
                            Object GLTR of type strGMRES:str=GMRES
                            Object GMRES of type strGROPPCG:str=GROPPCG
                            Object GROPPCG of type strHPDDM:str=HPDDM
                            Object HPDDM of type strIBCGS:str=IBCGS
                            Object IBCGS of type strLCD:str=LCD
                            Object LCD of type strLGMRES:str=LGMRES
                            Object LGMRES of type strLSQR:str=LSQR
                            Object LSQR of type strMINRES:str=MINRES
                            Object MINRES of type strNASH:str=NASH
                            Object NASH of type strNONE:str=NONE
                            Object NONE of type strPGMRES:str=PGMRES
                            Object PGMRES of type strPIPEBCGS:str=PIPEBCGS
                            Object PIPEBCGS of type strPIPECG:str=PIPECG
                            Object PIPECG of type strPIPECG2:str=PIPECG2
                            Object PIPECG2 of type strPIPECGRR:str=PIPECGRR
                            Object PIPECGRR of type strPIPECR:str=PIPECR
                            Object PIPECR of type strPIPEFCG:str=PIPEFCG
                            Object PIPEFCG of type strPIPEFGMRES:str=PIPEFGMRES
                            Object PIPEFGMRES of type strPIPEGCR:str=PIPEGCR
                            Object PIPEGCR of type strPIPELCG:str=PIPELCG
                            Object PIPELCG of type strPIPEPRCG:str=PIPEPRCG
                            Object PIPEPRCG of type strPREONLY:str=PREONLY
                            Object PREONLY of type strPYTHON:str=PYTHON
                            Object PYTHON of type strQCG:str=QCG
                            Object QCG of type strQMRCGS:str=QMRCGS
                            Object QMRCGS of type strRICHARDSON:str=RICHARDSON
                            Object RICHARDSON of type strSTCG:str=STCG
                            Object STCG of type strSYMMLQ:str=SYMMLQ
                            Object SYMMLQ of type strTCQMR:str=TCQMR
                            Object TCQMR of type strTFQMR:str=TFQMR
                            Object TFQMR of type strTSIRM:str=TSIRM
                            Object TSIRM of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ addConvergenceTest(converged[,  args, │ Add   the  function  to  be  used  to │
                      │ kargs, ...])                          │ determine convergence.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ appendOptionsPrefix(prefix)           │ Append to prefix  used  for  all  KSP │
                      │                                       │ options in the database.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ buildResidual([r])                    │ Return  the  residual  of  the linear │
                      │                                       │ system.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ buildSolution([x])                    │ Return the solution vector.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ callConvergenceTest(its, rnorm)       │ Call the convergence test callback.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeEigenvalues()                  │ Compute the extreme  eigenvalues  for │
                      │                                       │ the preconditioned operator.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeExtremeSingularValues()        │ Compute  the  extreme singular values │
                      │                                       │ for the preconditioned operator.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create the KSP context.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createPython([context, comm])         │ Create  a  linear  solver  of  Python │
                      │                                       │ type.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy KSP context.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getAppCtx()                           │ Return  the  user-defined context for │
                      │                                       │ the linear solver.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCGObjectiveValue()                 │ Return  the  CG  objective   function │
                      │                                       │ value.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getComputeEigenvalues()               │ Return    flag   indicating   whether │
                      │                                       │ eigenvalues will be calculated.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getComputeSingularValues()            │ Return   flag   indicating    whether │
                      │                                       │ singular values will be calculated.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConvergedReason()                  │ Use reason property.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConvergenceHistory()               │ Return  array containing the residual │
                      │                                       │ history.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConvergenceTest()                  │ Return the function  to  be  used  to │
                      │                                       │ determine convergence.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDM()                               │ Return  the  DM  that  may be used by │
                      │                                       │ some preconditioners.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getErrorIfNotConverged()              │ Return the flag indicating the solver │
                      │                                       │ will error if divergent.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getHPDDMType()                        │ Return the Krylov solver type.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getInitialGuessKnoll()                │ Determine whether the KSP  solver  is │
                      │                                       │ using the Knoll trick.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getInitialGuessNonzero()              │ Determine whether the KSP solver uses │
                      │                                       │ a zero initial guess.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getIterationNumber()                  │ Use its property.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMonitor()                          │ Return  function  used to monitor the │
                      │                                       │ residual.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNormType()                         │ Return the  norm  that  is  used  for │
                      │                                       │ convergence testing.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOperators()                        │ Return the matrix associated with the │
                      │                                       │ linear system.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOptionsPrefix()                    │ Return  the  prefix  used for all KSP │
                      │                                       │ options in the database.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPC()                               │ Return the preconditioner.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPCSide()                           │ Return the preconditioning side.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPythonContext()                    │ Return  the  instance  of  the  class │
                      │                                       │ implementing Python methods.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPythonType()                       │ Return  the  fully  qualified  Python │
                      │                                       │ name of the class used by the solver. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getResidualNorm()                     │ Use norm property.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRhs()                              │ Return the right-hand side vector for │
                      │                                       │ the linear system.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSolution()                         │ Return the solution  for  the  linear │
                      │                                       │ system to be solved.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTolerances()                       │ Return various tolerances used by the │
                      │                                       │ KSP convergence tests.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return  the KSP type as a string from │
                      │                                       │ the KSP object.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getWorkVecs([right, left])            │ Create working vectors.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ logConvergenceHistory(rnorm)          │ Add residual to convergence history.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ matSolve(B, X)                        │ Solve a linear system  with  multiple │
                      │                                       │ right-hand sides.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ matSolveTranspose(B, X)               │ Solve   the  transpose  of  a  linear │
                      │                                       │ system with multiple RHS.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ monitor(its, rnorm)                   │ Run   the   user   provided   monitor │
                      │                                       │ routines, if they exist.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ monitorCancel()                       │ Clear all monitors for a KSP object.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reset()                               │ Resets a KSP context.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setAppCtx(appctx)                     │ Set the optional user-defined context │
                      │                                       │ for the linear solver.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setComputeEigenvalues(flag)           │ Set a flag to compute eigenvalues.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setComputeOperators(operators[, args, │ Set  routine  to  compute  the linear │
                      │ kargs])                               │ operators.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setComputeRHS(rhs[, args, kargs])     │ Set routine to compute the right-hand │
                      │                                       │ side of the linear system.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setComputeSingularValues(flag)        │ Set  flag   to   calculate   singular │
                      │                                       │ values.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConvergedReason(reason)            │ Use reason property.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConvergenceHistory([length,        │ Set   the  array  used  to  hold  the │
                      │ reset])                               │ residual history.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConvergenceTest(converged[,  args, │ Set   the  function  to  be  used  to │
                      │ kargs])                               │ determine convergence.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDM(dm)                             │ Set the DM that may be used  by  some │
                      │                                       │ preconditioners.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDMActive(flag)                     │ DM  should be used to generate system │
                      │                                       │ matrix & RHS vector.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setErrorIfNotConverged(flag)          │ Cause solve to generate an  error  if │
                      │                                       │ not converged.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Set  KSP  options  from  the  options │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setGMRESRestart(restart)              │ Set number of iterations at which KSP │
                      │                                       │ restarts.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setHPDDMType(hpddm_type)              │ Set the Krylov solver type.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setInitialGuessKnoll(flag)            │ Tell  solver  to  use   PC.apply   to │
                      │                                       │ compute the initial guess.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setInitialGuessNonzero(flag)          │ Tell  the  iterative  solver that the │
                      │                                       │ initial guess is nonzero.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setIterationNumber(its)               │ Use its property.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMonitor(monitor[, args, kargs])    │ Set additional  function  to  monitor │
                      │                                       │ the residual.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNormType(normtype)                 │ Set   the   norm  that  is  used  for │
                      │                                       │ convergence testing.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOperators([A, P])                  │ Set matrix associated with the linear │
                      │                                       │ system.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOptionsPrefix(prefix)              │ Set  the  prefix  used  for  all  KSP │
                      │                                       │ options in the database.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPC(pc)                             │ Set the preconditioner.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPCSide(side)                       │ Set the preconditioning side.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPostSolve(postsolve[,        args, │ Set the function that  is  called  at │
                      │ kargs])                               │ the end of each KSP.solve.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPreSolve(presolve[, args, kargs])  │ Set  the  function  that is called at │
                      │                                       │ the beginning of each KSP.solve.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPythonContext([context])           │ Set  the  instance   of   the   class │
                      │                                       │ implementing Python methods.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPythonType(py_type)                │ Set  the  fully qualified Python name │
                      │                                       │ of the class to be used.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setResidualNorm(rnorm)                │ Use norm property.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTolerances([rtol,  atol,   divtol, │ Set  various  tolerances  used by the │
                      │ max_it])                              │ KSP convergence testers.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(ksp_type)                     │ Build the KSP data  structure  for  a │
                      │                                       │ particular Type.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Set  up  internal data structures for │
                      │                                       │ an iterative solver.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUpOnBlocks()                       │ Set up the  preconditioner  for  each │
                      │                                       │ block in a block method.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUseFischerGuess(model, size)       │ Use  the  Paul  Fischer  algorithm to │
                      │                                       │ compute initial guesses.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solve(b, x)                           │ Solve the linear system.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solveTranspose(b, x)                  │ Solve  the  transpose  of  a   linear │
                      │                                       │ system.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ Print the KSP data structure.         │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                  ┌───────────────┬───────────────────────────────────────┐
                                  │ appctx        │ The solver application context.       │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ atol          │ The absolute tolerance of the solver. │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ divtol        │ The   divergence   tolerance  of  the │
                                  │               │ solver.                               │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ dm            │ The solver DM.                        │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ guess_knoll   │ Whether solver uses Knoll trick.      │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ guess_nonzero │ Whether guess is non-zero.            │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ history       │ The  convergence   history   of   the │
                                  │               │ solver.                               │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ is_converged  │ Boolean  indicating if the solver has │
                                  │               │ converged.                            │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ is_diverged   │ Boolean indicating if the solver  has │
                                  │               │ failed.                               │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ is_iterating  │ Boolean  indicating if the solver has │
                                  │               │ not converged yet.                    │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ its           │ The current number of iterations  the │
                                  │               │ solver has taken.                     │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ mat_op        │ The system matrix operator.           │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ mat_pc        │ The preconditioner operator.          │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ max_it        │ The  maximum  number of iteration the │
                                  │               │ solver may take.                      │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ norm          │ The  norm  of  the  residual  at  the │
                                  │               │ current iteration.                    │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ norm_type     │ The norm used by the solver.          │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ pc            │ The PC of the solver.                 │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ pc_side       │ The  side on which preconditioning is │
                                  │               │ performed.                            │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ reason        │ The converged reason.                 │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ rtol          │ The relative tolerance of the solver. │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ vec_rhs       │ The right-hand side vector.           │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ vec_sol       │ The solution vector.                  │
                                  └───────────────┴───────────────────────────────────────┘

              Methods Documentation

              addConvergenceTest(converged,args=None,kargs=None,prepend=False)
                     Add the function to be used to determine convergence.

                     Logically collective.

                     Parameters

                            • converged (KSPConvergenceTestFunction) -- Callback which computes the convergence.

                            • args (tuple[Any,...]|None) -- Positional arguments for callback function.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for callback function.

                            • prepend (bool) -- Whether to prepend this call before the default convergence test
                              or call it after.

                     ReturntypeNone

                     Notes

                     Cannot be mixed with a call to setConvergenceTest.  It can only be called once.  If  called
                     multiple times, it will generate an error.

                     SEEALSO:setTolerances,    getConvergenceTest,   setConvergenceTest,   KSPSetConvergenceTest,   ‐
                        KSPConvergedDefaultSourcecodeatpetsc4py/PETSc/KSP.pyx:1065appendOptionsPrefix(prefix)
                     Append to prefix used for all KSP options in the database.

                     Logically collective.

                     Parametersprefix (str|None) -- The options prefix to append.

                     ReturntypeNone

                     Notes

                     A hyphen (-) must NOT be given at the beginning of the prefix name. The first character  of
                     all runtime options is AUTOMATICALLY the hyphen.

                     SEEALSO:KSPAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/KSP.pyx:575buildResidual(r=None)
                     Return the residual of the linear system.

                     Collective.

                     Parametersr (Vec|None) -- Optional vector to use for the result.

                     ReturntypeVecSEEALSO:buildSolution, KSPBuildResidualSourcecodeatpetsc4py/PETSc/KSP.pyx:2063buildSolution(x=None)
                     Return the solution vector.

                     Collective.

                     Parametersx (Vec|None) -- Optional vector to store the solution.

                     ReturntypeVecSEEALSO:buildResidual, KSPBuildSolutionSourcecodeatpetsc4py/PETSc/KSP.pyx:2041callConvergenceTest(its,rnorm)
                     Call the convergence test callback.

                     Collective.

                     Parameters

                            • its (int) -- Number of iterations.

                            • rnorm (float) -- The residual norm.

                     ReturntypeNone

                     Notes

                     This functionality is implemented in petsc4py.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:1121computeEigenvalues()
                     Compute the extreme eigenvalues for the preconditioned operator.

                     Not collective.

                     SEEALSO:KSPComputeEigenvaluesSourcecodeatpetsc4py/PETSc/KSP.pyx:2085ReturntypeArrayComplexcomputeExtremeSingularValues()
                     Compute the extreme singular values for the preconditioned operator.

                     Collective.

                     Returns

                            • smax (float) -- The maximum singular value.

                            • smin (float) -- The minimum singular value.

                     Returntypetuple[float, float]

                     SEEALSO:KSPComputeExtremeSingularValuesSourcecodeatpetsc4py/PETSc/KSP.pyx:2108create(comm=None)
                     Create the KSP context.

                     Collective.

                     SEEALSO:KSPCreateSourcecodeatpetsc4py/PETSc/KSP.pyx:457Parameterscomm (Comm|None)

                     ReturntypeSelfcreatePython(context=None,comm=None)
                     Create a linear solver of Python type.

                     Collective.

                     Parameters

                            • context  (Any)  --  An  instance  of  the  Python  class implementing the required
                              methods.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PETScPythonlinearsolvertype, setType, setPythonContext, Type.PYTHONSourcecodeatpetsc4py/PETSc/KSP.pyx:2154destroy()
                     Destroy KSP context.

                     Collective.

                     SEEALSO:KSPDestroySourcecodeatpetsc4py/PETSc/KSP.pyx:444ReturntypeSelfgetAppCtx()
                     Return the user-defined context for the linear solver.

                     Not collective.

                     SEEALSO:setAppCtxSourcecodeatpetsc4py/PETSc/KSP.pyx:640ReturntypeAnygetCGObjectiveValue()
                     Return the CG objective function value.

                     Not collective.

                     SEEALSO:KSPCGGetObjFcnSourcecodeatpetsc4py/PETSc/KSP.pyx:1882ReturntypefloatgetComputeEigenvalues()
                     Return flag indicating whether eigenvalues will be calculated.

                     Not collective.

                     Return the flag indicating that the extreme eigenvalues values will  be  calculated  via  a
                     Lanczos or Arnoldi process as the linear system is solved.

                     SEEALSO:setComputeEigenvalues, KSPSetComputeEigenvaluesSourcecodeatpetsc4py/PETSc/KSP.pyx:1430ReturntypeboolgetComputeSingularValues()
                     Return flag indicating whether singular values will be calculated.

                     Not collective.

                     Return  the  flag  indicating  whether the extreme singular values will be calculated via a
                     Lanczos or Arnoldi process as the linear system is solved.

                     SEEALSO:setComputeSingularValues, KSPGetComputeSingularValuesSourcecodeatpetsc4py/PETSc/KSP.pyx:1474ReturntypeboolgetConvergedReason()
                     Use reason property.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:1876ReturntypeConvergedReasongetConvergenceHistory()
                     Return array containing the residual history.

                     Not collective.

                     SEEALSO:setConvergenceHistory, KSPGetResidualHistorySourcecodeatpetsc4py/PETSc/KSP.pyx:1188ReturntypeArrayRealgetConvergenceTest()
                     Return the function to be used to determine convergence.

                     Logically collective.

                     SEEALSO:setTolerances, setConvergenceTest, KSPGetConvergenceTest, KSPConvergedDefaultSourcecodeatpetsc4py/PETSc/KSP.pyx:1108ReturntypeKSPConvergenceTestFunctiongetDM()
                     Return the DM that may be used by some preconditioners.

                     Not collective.

                     SEEALSO:PETSc.KSP, DM, KSPGetDMSourcecodeatpetsc4py/PETSc/KSP.pyx:654ReturntypeDMgetErrorIfNotConverged()
                     Return the flag indicating the solver will error if divergent.

                     Not collective.

                     SEEALSO:KSPGetErrorIfNotConvergedSourcecodeatpetsc4py/PETSc/KSP.pyx:1946ReturntypeboolgetHPDDMType()
                     Return the Krylov solver type.

                     Not collective.

                     SEEALSO:KSPHPDDMGetTypeSourcecodeatpetsc4py/PETSc/KSP.pyx:1914ReturntypeHPDDMTypegetInitialGuessKnoll()
                     Determine whether the KSP solver is using the Knoll trick.

                     Not collective.

                     This uses the Knoll trick; using PC.apply to compute the initial guess.

                     SEEALSO:KSPGetInitialGuessKnollSourcecodeatpetsc4py/PETSc/KSP.pyx:1550ReturntypeboolgetInitialGuessNonzero()
                     Determine whether the KSP solver uses a zero initial guess.

                     Not collective.

                     SEEALSO:KSPGetInitialGuessNonzeroSourcecodeatpetsc4py/PETSc/KSP.pyx:1516ReturntypeboolgetIterationNumber()
                     Use its property.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:1854ReturntypeintgetMonitor()
                     Return function used to monitor the residual.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setMonitor, monitor, monitorCancel, KSPGetMonitorContextSourcecodeatpetsc4py/PETSc/KSP.pyx:1266ReturntypeKSPMonitorFunctiongetNormType()
                     Return the norm that is used for convergence testing.

                     Not collective.

                     SEEALSO:NormType, setNormType, KSPGetNormType, KSPConvergedSkipSourcecodeatpetsc4py/PETSc/KSP.pyx:1390ReturntypeNormTypegetOperators()
                     Return the matrix associated with the linear system.

                     Collective.

                     Return the matrix associated with the linear system and a (possibly) different one used  to
                     construct the preconditioner.

                     Returns

                            • A (Mat) -- Matrix that defines the linear system.

                            • P  (Mat) -- Matrix to be used in constructing the preconditioner, usually the same
                              as A.

                     Returntypetuple[Mat, Mat]

                     SEEALSO:PETSc.KSP, solve, setOperators, KSPGetOperatorsSourcecodeatpetsc4py/PETSc/KSP.pyx:850getOptionsPrefix()
                     Return the prefix used for all KSP options in the database.

                     Not collective.

                     SEEALSO:KSPGetOptionsPrefixSourcecodeatpetsc4py/PETSc/KSP.pyx:561ReturntypestrgetPC()
                     Return the preconditioner.

                     Not collective.

                     SEEALSO:PETSc.KSP, setPC, KSPGetPCSourcecodeatpetsc4py/PETSc/KSP.pyx:897ReturntypePCgetPCSide()
                     Return the preconditioning side.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setPCSide, setNormType, getNormType, KSPGetPCSideSourcecodeatpetsc4py/PETSc/KSP.pyx:1349ReturntypeSidegetPythonContext()
                     Return the instance of the class implementing Python methods.

                     Not collective.

                     SEEALSO:PETScPythonlinearsolvertype, setPythonContextSourcecodeatpetsc4py/PETSc/KSP.pyx:2195ReturntypeAnygetPythonType()
                     Return the fully qualified Python name of the class used by the solver.

                     Not collective.

                     SEEALSO:PETScPythonlinearsolvertype, setPythonContext, setPythonType, KSPPythonGetTypeSourcecodeatpetsc4py/PETSc/KSP.pyx:2225ReturntypestrgetResidualNorm()
                     Use norm property.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:1865ReturntypefloatgetRhs()
                     Return the right-hand side vector for the linear system.

                     Not collective.

                     SEEALSO:KSPGetRhsSourcecodeatpetsc4py/PETSc/KSP.pyx:1960ReturntypeVecgetSolution()
                     Return the solution for the linear system to be solved.

                     Not collective.

                     Note that this may not be the solution that is stored during the iterative process.

                     SEEALSO:KSPGetSolutionSourcecodeatpetsc4py/PETSc/KSP.pyx:1975ReturntypeVecgetTolerances()
                     Return various tolerances used by the KSP convergence tests.

                     Not collective.

                     Return the relative, absolute, divergence, and maximum iteration  tolerances  used  by  the
                     default KSP convergence tests.

                     Returns

                            • rtol (float) -- The relative convergence tolerance

                            • atol (float) -- The absolute convergence tolerance

                            • dtol (float) -- The divergence tolerance

                            • maxits (int) -- Maximum number of iterations

                     Returntypetuple[float, float, float, int]

                     SEEALSO:setTolerances, KSPGetTolerancesSourcecodeatpetsc4py/PETSc/KSP.pyx:971getType()
                     Return the KSP type as a string from the KSP object.

                     Not collective.

                     SEEALSO:KSPGetTypeSourcecodeatpetsc4py/PETSc/KSP.pyx:509ReturntypestrgetWorkVecs(right=None,left=None)
                     Create working vectors.

                     Collective.

                     Parameters

                            • right (int|None) -- Number of right hand vectors to allocate.

                            • left (int|None) -- Number of left hand vectors to allocate.

                     Returns

                            • R (list of Vec) -- List of correctly allocated right hand vectors.

                            • L (list of Vec) -- List of correctly allocated left hand vectors.

                     Returntypetuple[list[Vec], list[Vec]] | list[Vec] | NoneSourcecodeatpetsc4py/PETSc/KSP.pyx:1993logConvergenceHistory(rnorm)
                     Add residual to convergence history.

                     Logically collective.

                     Parametersrnorm (float) -- Residual norm to be added to convergence history.

                     ReturntypeNoneSourcecodeatpetsc4py/PETSc/KSP.pyx:1203matSolve(B,X)
                     Solve a linear system with multiple right-hand sides.

                     Collective.

                     These are stored as a Mat.Type.DENSE. Unlike solve, B and X must be different matrices.

                     Parameters

                            • B (Mat) -- Block of right-hand sides.

                            • X (Mat) -- Block of solutions.

                     ReturntypeNoneSEEALSO:solve, KSPMatSolveSourcecodeatpetsc4py/PETSc/KSP.pyx:1808matSolveTranspose(B,X)
                     Solve the transpose of a linear system with multiple RHS.

                     Collective.

                     Parameters

                            • B (Mat) -- Block of right-hand sides.

                            • X (Mat) -- Block of solutions.

                     ReturntypeNoneSEEALSO:solveTranspose, KSPMatSolveSourcecodeatpetsc4py/PETSc/KSP.pyx:1830monitor(its,rnorm)
                     Run the user provided monitor routines, if they exist.

                     Collective.

                     Notes

                     This  routine is called by the KSP implementations. It does not typically need to be called
                     by the user.

                     SEEALSO:setMonitor, KSPMonitorSourcecodeatpetsc4py/PETSc/KSP.pyx:1294Parameters

                            • its (int)

                            • rnorm (float)

                     ReturntypeNonemonitorCancel()
                     Clear all monitors for a KSP object.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, getMonitor, setMonitor, monitor, KSPMonitorCancelSourcecodeatpetsc4py/PETSc/KSP.pyx:1279ReturntypeNonereset()
                     Resets a KSP context.

                     Collective.

                     Resets a KSP context to the kspsetupcalled=0 state and removes  any  allocated  Vecs  and
                     Mats.

                     SEEALSO:KSPResetSourcecodeatpetsc4py/PETSc/KSP.pyx:1607ReturntypeNonesetAppCtx(appctx)
                     Set the optional user-defined context for the linear solver.

                     Not collective.

                     Parametersappctx (Any) -- The user defined context

                     ReturntypeNone

                     Notes

                     The user context is a way for users to attach any information to the KSP that they may need
                     later when interacting with the solver.

                     SEEALSO:getAppCtxSourcecodeatpetsc4py/PETSc/KSP.pyx:617setComputeEigenvalues(flag)
                     Set a flag to compute eigenvalues.

                     Logically collective.

                     Set  a  flag  so  that  the  extreme eigenvalues values will be calculated via a Lanczos or
                     Arnoldi process as the linear system is solved.

                     Parametersflag (bool) -- Boolean whether to compute eigenvalues (or not).

                     ReturntypeNone

                     Notes

                     Currently this option is not valid for all iterative methods.

                     SEEALSO:getComputeEigenvalues, KSPSetComputeEigenvaluesSourcecodeatpetsc4py/PETSc/KSP.pyx:1404setComputeOperators(operators,args=None,kargs=None)
                     Set routine to compute the linear operators.

                     Logically collective.

                     Parameters

                            • operators (KSPOperatorsFunction) -- Function which computes the operators.

                            • args (tuple[Any,...]|None)  --  Positional  arguments  for  callback  function
                              operators.

                            • kargs  (dict[str,Any]|None)  --  Keyword  arguments  for  callback  function
                              operators.

                     ReturntypeNone

                     Notes

                     The user provided function Operators will be called automatically at the very next call  to
                     solve.  It  will  NOT  be called at future solve calls unless either setComputeOperators or
                     setOperators is called before that solve is called. This  allows  the  same  system  to  be
                     solved several times with different right-hand side functions, but is a confusing API since
                     one might expect it to be called for each solve.

                     To  reuse the same preconditioner for the next solve and not compute a new one based on the
                     most recently computed matrix call KSPSetReusePreconditioner.

                     SEEALSO:PETSc.KSP, solve, setOperators, KSPSetComputeOperators, KSPSetReusePreconditionerSourcecodeatpetsc4py/PETSc/KSP.pyx:764setComputeRHS(rhs,args=None,kargs=None)
                     Set routine to compute the right-hand side of the linear system.

                     Logically collective.

                     Parameters

                            • rhs (KSPRHSFunction) -- Function which computes the right-hand side.

                            • args (tuple[Any,...]|None) -- Positional arguments for callback function rhs.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for callback function rhs.

                     ReturntypeNone

                     Notes

                     The routine you provide will be called  each  time  you  call  solve  to  prepare  the  new
                     right-hand side for that solve.

                     SEEALSO:PETSc.KSP, solve, KSPSetComputeRHSSourcecodeatpetsc4py/PETSc/KSP.pyx:730setComputeSingularValues(flag)
                     Set flag to calculate singular values.

                     Logically collective.

                     Set  a flag so that the extreme singular values will be calculated via a Lanczos or Arnoldi
                     process as the linear system is solved.

                     Parametersflag (bool) -- Boolean whether to compute singular values (or not).

                     ReturntypeNone

                     Notes

                     Currently this option is not valid for all iterative methods.

                     SEEALSO:getComputeSingularValues, KSPSetComputeSingularValuesSourcecodeatpetsc4py/PETSc/KSP.pyx:1448setConvergedReason(reason)
                     Use reason property.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:1871Parametersreason (ConvergedReason)

                     ReturntypeNonesetConvergenceHistory(length=None,reset=False)
                     Set the array used to hold the residual history.

                     Not collective.

                     If set, this array will contain the residual  norms  computed  at  each  iteration  of  the
                     solver.

                     Parameters

                            • length (int|None) -- Length of array to store history in.

                            • reset  (bool)  -- True indicates the history counter is reset to zero for each new
                              linear solve.

                     ReturntypeNone

                     Notes

                     If length is not provided or None then a default array of length 10000 is allocated.

                     If the array is not long enough then once the iterations is longer than  the  array  length
                     solve stops recording the history.

                     SEEALSO:getConvergenceHistory, KSPSetResidualHistorySourcecodeatpetsc4py/PETSc/KSP.pyx:1144setConvergenceTest(converged,args=None,kargs=None)
                     Set the function to be used to determine convergence.

                     Logically collective.

                     Parameters

                            • converged (KSPConvergenceTestFunction) -- Callback which computes the convergence.

                            • args (tuple[Any,...]|None) -- Positional arguments for callback function.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for callback function.

                     ReturntypeNone

                     Notes

                     Must  be  called  after  the  KSP type has been set so put this after a call to setType, or
                     setFromOptions.

                     The default is a combination of relative and absolute tolerances. The residual  value  that
                     is tested may be an approximation; routines that need exact values should compute them.

                     SEEALSO:addConvergenceTest, ConvergedReason, setTolerances, getConvergenceTest, buildResidual, ‐
                        KSPSetConvergenceTest, KSPConvergedDefaultSourcecodeatpetsc4py/PETSc/KSP.pyx:1000setDM(dm)
                     Set the DM that may be used by some preconditioners.

                     Logically collective.

                     Parametersdm (DM) -- The DM object, cannot be None.

                     ReturntypeNone

                     Notes

                     If  this  is  used then the KSP will attempt to use the DM to create the matrix and use the
                     routine set with DM.setKSPComputeOperators.  Use  setDMActive(False)  to  instead  use  the
                     matrix you have provided with setOperators.

                     A  DM  can  only  be  used  for solving one problem at a time because information about the
                     problem is stored on the DM, even when not using interfaces like DM.setKSPComputeOperators.
                     Use DM.clone to get a distinct DM when solving different problems using the  same  function
                     space.

                     SEEALSO:PETSc.KSP, DM, DM.setKSPComputeOperators, setOperators, DM.clone, KSPSetDMSourcecodeatpetsc4py/PETSc/KSP.pyx:671setDMActive(flag)DM should be used to generate system matrix & RHS vector.

                     Logically collective.

                     Parametersflag (bool) -- Whether to use the DM.

                     ReturntypeNone

                     Notes

                     By default setDM sets the DM as active, call setDMActive(False) after setDM(dm) to not have
                     the KSP object use the DM to generate the matrices.

                     SEEALSO:PETSc.KSP, DM, setDM, KSPSetDMActiveSourcecodeatpetsc4py/PETSc/KSP.pyx:704setErrorIfNotConverged(flag)
                     Cause solve to generate an error if not converged.

                     Logically collective.

                     Parametersflag (bool) -- True enables this behavior.

                     ReturntypeNoneSEEALSO:KSPSetErrorIfNotConvergedSourcecodeatpetsc4py/PETSc/KSP.pyx:1928setFromOptions()
                     Set KSP options from the options database.

                     Collective.

                     This  routine  must  be  called before setUp if the user is to be allowed to set the Krylov
                     type.

                     SEEALSO:WorkingwithPETScoptions, KSPSetFromOptionsSourcecodeatpetsc4py/PETSc/KSP.pyx:600ReturntypeNonesetGMRESRestart(restart)
                     Set number of iterations at which KSP restarts.

                     Logically collective.

                     Suitable KSPs are: KSPGMRES, KSPFGMRES and KSPLGMRES.

                     Parametersrestart (int) -- Integer restart value.

                     ReturntypeNoneSEEALSO:KSPGMRESSetRestartSourcecodeatpetsc4py/PETSc/KSP.pyx:2132setHPDDMType(hpddm_type)
                     Set the Krylov solver type.

                     Collective.

                     Parametershpddm_type (HPDDMType) -- The type of Krylov solver to use.

                     ReturntypeNoneSEEALSO:KSPHPDDMSetTypeSourcecodeatpetsc4py/PETSc/KSP.pyx:1896setInitialGuessKnoll(flag)
                     Tell solver to use PC.apply to compute the initial guess.

                     Logically collective.

                     This is the Knoll trick.

                     Parametersflag (bool) -- True uses Knoll trick.

                     ReturntypeNoneSEEALSO:KSPSetInitialGuessKnollSourcecodeatpetsc4py/PETSc/KSP.pyx:1530setInitialGuessNonzero(flag)
                     Tell the iterative solver that the initial guess is nonzero.

                     Logically collective.

                     Otherwise KSP assumes the initial guess is to  be  zero  (and  thus  zeros  it  out  before
                     solving).

                     Parametersflag  (bool)  --  True indicates the guess is non-zero, False indicates the guess is
                            zero.

                     ReturntypeNoneSEEALSO:KSPSetInitialGuessNonzeroSourcecodeatpetsc4py/PETSc/KSP.pyx:1494setIterationNumber(its)
                     Use its property.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:1849Parametersits (int)

                     ReturntypeNonesetMonitor(monitor,args=None,kargs=None)
                     Set additional function to monitor the residual.

                     Logically collective.

                     Set an ADDITIONAL function to be called at every iteration to  monitor  the  residual/error
                     etc.

                     Parameters

                            • monitor (KSPMonitorFunction) -- Callback which monitors the convergence.

                            • args (tuple[Any,...]|None) -- Positional arguments for callback function.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for callback function.

                     ReturntypeNone

                     Notes

                     The  default  is  to  do  nothing.  To  print  the  residual, or preconditioned residual if
                     setNormType(NORM_PRECONDITIONED) was called, use monitor as the monitoring routine, with  a
                     PETSc.Viewer.ASCII as the context.

                     Several  different monitoring routines may be set by calling setMonitor multiple times; all
                     will be called in the order in which they were set.

                     SEEALSO:WorkingwithPETScoptions, getMonitor, monitor, monitorCancel, KSPMonitorSetSourcecodeatpetsc4py/PETSc/KSP.pyx:1219setNormType(normtype)
                     Set the norm that is used for convergence testing.

                     Logically collective.

                     Parametersnormtype (NormType) -- The norm type to use (see NormType).

                     ReturntypeNone

                     Notes

                     Not all combinations of preconditioner side (see setPCSide) and norm type are supported  by
                     all  Krylov  methods.  If only one is set, PETSc tries to automatically change the other to
                     find a compatible pair. If no such combination is supported, PETSc will generate an error.

                     SEEALSO:NormType, WorkingwithPETScoptions,  setUp,  solve,  destroy,  setPCSide,  getPCSide,
                        NormType, KSPSetNormType, KSPConvergedSkip, KSPSetCheckNormIterationSourcecodeatpetsc4py/PETSc/KSP.pyx:1363setOperators(A=None,P=None)
                     Set matrix associated with the linear system.

                     Collective.

                     Set  the matrix associated with the linear system and a (possibly) different one from which
                     the preconditioner will be built.

                     Parameters

                            • A (Mat|None) -- Matrix that defines the linear system.

                            • P (Mat|None) -- Matrix to be used in constructing  the  preconditioner,  usually
                              the same as A.

                     ReturntypeNone

                     Notes

                     If   you  know  the  operator  A  has  a  null  space  you  can  use  Mat.setNullSpace  and
                     Mat.setTransposeNullSpace to  supply  the  null  space  to  A  and  the  KSP  solvers  will
                     automatically use that null space as needed during the solution process.

                     All future calls to setOperators must use the same size matrices!

                     Passing None for A or P removes the matrix that is currently used.

                     SEEALSO:PETSc.KSP, solve, setComputeOperators, KSPSetOperatorsSourcecodeatpetsc4py/PETSc/KSP.pyx:809setOptionsPrefix(prefix)
                     Set the prefix used for all KSP options in the database.

                     Logically collective.

                     Parametersprefix (str|None) -- The options prefix.

                     ReturntypeNone

                     Notes

                     A  hyphen (-) must NOT be given at the beginning of the prefix name. The first character of
                     all runtime options is AUTOMATICALLY the hyphen. For example, to  distinguish  between  the
                     runtime  options for two different KSP contexts, one could call `KSPSetOptionsPrefix(ksp1,"sys1_")KSPSetOptionsPrefix(ksp2,"sys2_")`

                     This would enable use of different options for each system, such as `-sys1_ksp_typegmres-sys1_ksp_rtol1.e-3-sys2_ksp_typebcgs-sys2_ksp_rtol1.e-4`SEEALSO:WorkingwithPETScoptions, KSPSetOptionsPrefixSourcecodeatpetsc4py/PETSc/KSP.pyx:523setPC(pc)
                     Set the preconditioner.

                     Collective.

                     Set  the  preconditioner to be used to calculate the application of the preconditioner on a
                     vector.

                     Parameterspc (PC) -- The preconditioner object

                     ReturntypeNoneSEEALSO:PETSc.KSP, getPC, KSPSetPCSourcecodeatpetsc4py/PETSc/KSP.pyx:877setPCSide(side)
                     Set the preconditioning side.

                     Logically collective.

                     Parametersside (Side) -- The preconditioning side (see PC.Side).

                     ReturntypeNone

                     Notes

                     Left preconditioning is used by default for most Krylov methods  except  Type.FGMRES  which
                     only supports right preconditioning.

                     For methods changing the side of the preconditioner changes the norm type that is used, see
                     setNormType.

                     Symmetric  preconditioning  is  currently  available  only  for  the Type.QCG method. Note,
                     however, that symmetric preconditioning can be emulated  by  using  either  right  or  left
                     preconditioning and a pre or post processing step.

                     Setting the PC side often affects the default norm type. See setNormType for details.

                     SEEALSO:PC.Side, WorkingwithPETScoptions, getPCSide, setNormType, getNormType, KSPSetPCSideSourcecodeatpetsc4py/PETSc/KSP.pyx:1315setPostSolve(postsolve,args=None,kargs=None)
                     Set the function that is called at the end of each KSP.solve.

                     Logically collective.

                     Parameters

                            • postsolve (KSPPostSolveFunction|None) -- The callback function.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback function.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback function.

                     ReturntypeNoneSEEALSO:solve, KSPSetPreSolve, KSPSetPostSolveSourcecodeatpetsc4py/PETSc/KSP.pyx:1670setPreSolve(presolve,args=None,kargs=None)
                     Set the function that is called at the beginning of each KSP.solve.

                     Logically collective.

                     Parameters

                            • presolve (KSPPreSolveFunction|None) -- The callback function.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback function.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback function.

                     ReturntypeNoneSEEALSO:solve, KSPSetPreSolve, KSPSetPostSolveSourcecodeatpetsc4py/PETSc/KSP.pyx:1637setPythonContext(context=None)
                     Set the instance of the class implementing Python methods.

                     Not collective.

                     SEEALSO:PETScPythonlinearsolvertype, getPythonContextSourcecodeatpetsc4py/PETSc/KSP.pyx:2183Parameterscontext (Any|None)

                     ReturntypeNonesetPythonType(py_type)
                     Set the fully qualified Python name of the class to be used.

                     Collective.

                     SEEALSO:PETScPythonlinearsolvertype, setPythonContext, getPythonType, KSPPythonSetTypeSourcecodeatpetsc4py/PETSc/KSP.pyx:2210Parameterspy_type (str)

                     ReturntypeNonesetResidualNorm(rnorm)
                     Use norm property.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:1860Parametersrnorm (float)

                     ReturntypeNonesetTolerances(rtol=None,atol=None,divtol=None,max_it=None)
                     Set various tolerances used by the KSP convergence testers.

                     Logically collective.

                     Set  the  relative,  absolute,  divergence,  and  maximum  iteration tolerances used by the
                     default KSP convergence testers.

                     Parameters

                            • rtol (float|None) -- The relative convergence tolerance,  relative  decrease  in
                              the  (possibly  preconditioned) residual norm.  Or DETERMINE to use the value when
                              the object's type was set.

                            • atol (float|None) -- The absolute convergence tolerance  absolute  size  of  the
                              (possibly  preconditioned)  residual norm.  Or DETERMINE to use the value when the
                              object's type was set.

                            • dtol -- The divergence tolerance, amount (possibly preconditioned)  residual  norm
                              can  increase  before  KSPConvergedDefault concludes that the method is diverging.
                              Or DETERMINE to use the value when the object's type was set.

                            • max_it (int|None) -- Maximum number of iterations to use.  Or DETERMINE  to  use
                              the value when the object's type was set.

                            • divtol (float|None)

                     ReturntypeNone

                     Notes

                     Use None to retain the default value of any of the tolerances.

                     SEEALSO:WorkingwithPETScoptions,  getTolerances,  setConvergenceTest,  KSPSetTolerances, ‐
                        KSPConvergedDefaultSourcecodeatpetsc4py/PETSc/KSP.pyx:914setType(ksp_type)
                     Build the KSP data structure for a particular Type.

                     Logically collective.

                     Parametersksp_type (Type|str) -- KSP Type object

                     ReturntypeNone

                     Notes

                     See Type for available methods (for instance, Type.CG or Type.GMRES).

                     Normally, it is best to use the setFromOptions command and then set the KSP type  from  the
                     options database rather than by using this routine. Using the options database provides the
                     user  with maximum flexibility in evaluating the many different Krylov methods. This method
                     is provided for those situations  where  it  is  necessary  to  set  the  iterative  solver
                     independently of the command line or options database. This might be the case, for example,
                     when  the  choice  of iterative solver changes during the execution of the program, and the
                     user's application is taking responsibility for choosing the appropriate method.  In  other
                     words, this routine is not for beginners.

                     SEEALSO:KSPSetTypeSourcecodeatpetsc4py/PETSc/KSP.pyx:473setUp()
                     Set up internal data structures for an iterative solver.

                     Collective.

                     SEEALSO:KSPSetUpSourcecodeatpetsc4py/PETSc/KSP.pyx:1595ReturntypeNonesetUpOnBlocks()
                     Set up the preconditioner for each block in a block method.

                     Collective.

                     Methods include: block Jacobi, block Gauss-Seidel, and overlapping Schwarz methods.

                     SEEALSO:KSPSetUpOnBlocksSourcecodeatpetsc4py/PETSc/KSP.pyx:1622ReturntypeNonesetUseFischerGuess(model,size)
                     Use the Paul Fischer algorithm to compute initial guesses.

                     Logically collective.

                     Use  the  Paul  Fischer  algorithm  or its variants to compute initial guesses for a set of
                     solves with related right hand sides.

                     Parameters

                            • model (int) -- Use model 1, model 2, model 3, any other number to turn it off.

                            • size (int) -- Size of subspace used to generate initial guess.

                     ReturntypeNoneSEEALSO:KSPSetUseFischerGuessSourcecodeatpetsc4py/PETSc/KSP.pyx:1567solve(b,x)
                     Solve the linear system.

                     Collective.

                     Parameters

                            • b (Vec) -- Right hand side vector.

                            • x (Vec) -- Solution vector.

                     ReturntypeNone

                     Notes

                     If one uses setDM then x or b need not be passed. Use getSolution to access the solution in
                     this case.

                     The operator is specified with setOperators.

                     solve will normally return without generating an error regardless  of  whether  the  linear
                     system  was solved or if constructing the preconditioner failed. Call getConvergedReason to
                     determine if the solver converged or failed and why. The option -ksp_error_if_not_converged
                     or function setErrorIfNotConverged will cause solve to error as soon as an error occurs  in
                     the linear solver. In inner solves, DIVERGED_MAX_IT is not treated as an error because when
                     using  nested  solvers  it  may  be  fine  that  inner solvers in the preconditioner do not
                     converge during the solution process.

                     The number of iterations can be obtained from its.

                     If you provide a matrix that has a Mat.setNullSpace and Mat.setTransposeNullSpace this will
                     use that information to solve singular systems in the  least  squares  sense  with  a  norm
                     minimizing solution.

                     Ax  =  b  where b = bₚ + bₜ where bₜ is not in the range of A (and hence by the fundamental
                     theorem of linear algebra is in the nullspace(Aᵀ), see Mat.setNullSpace.

                     KSP first removes bₜ producing the linear system Ax = bₚ (which has multiple solutions) and
                     solves this to find the ∥x∥  minimizing  solution  (and  hence  it  finds  the  solution  x
                     orthogonal  to  the  nullspace(A).  The algorithm is simply in each iteration of the Krylov
                     method we remove the nullspace(A) from the search direction thus the solution  which  is  a
                     linear combination of the search directions has no component in the nullspace(A).

                     We  recommend  always  using  Type.GMRES  for  such  singular  systems.  If  nullspace(A) =
                     nullspace(Aᵀ) (note symmetric matrices always satisfy this property)  then  both  left  and
                     right  preconditioning will work If nullspace(A) != nullspace(Aᵀ) then left preconditioning
                     will work but right preconditioning may not work (or it may).

                     If using a direct method (e.g., via the KSP solver Type.PREONLY and a  preconditioner  such
                     as PC.Type.LU or PC.Type.ILU, then its=1. See setTolerances for more details.

                     UnderstandingConvergence

                     The routines setMonitor and computeEigenvalues provide information on additional options to
                     monitor convergence and print eigenvalue information.

                     SEEALSO:create,    setUp,    destroy,    setTolerances,   is_converged,   solveTranspose,   its,
                        Mat.setNullSpace, Mat.setTransposeNullSpace, Type, setErrorIfNotConverged, KSPSolveSourcecodeatpetsc4py/PETSc/KSP.pyx:1703solveTranspose(b,x)
                     Solve the transpose of a linear system.

                     Collective.

                     Parameters

                            • b (Vec) -- Right hand side vector.

                            • x (Vec) -- Solution vector.

                     ReturntypeNone

                     Notes

                     For complex numbers this solve the non-Hermitian transpose system.

                     SEEALSO:solve, KSPSolveTransposeSourcecodeatpetsc4py/PETSc/KSP.pyx:1784view(viewer=None)
                     Print the KSP data structure.

                     Collective.

                     Parametersviewer (Viewer|None) -- Viewer used to display the KSP.

                     ReturntypeNoneSEEALSO:KSPViewSourcecodeatpetsc4py/PETSc/KSP.pyx:425

              Attributes Documentation

              appctx The solver application context.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2242atol   The absolute tolerance of the solver.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2335divtol The divergence tolerance of the solver.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2343dm     The solver DM.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2252guess_knoll
                     Whether solver uses Knoll trick.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2294guess_nonzero
                     Whether guess is non-zero.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2286history
                     The convergence history of the solver.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2377is_converged
                     Boolean indicating if the solver has converged.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2397is_diverged
                     Boolean indicating if the solver has failed.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2402is_iterating
                     Boolean indicating if the solver has not converged yet.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2392its    The current number of iterations the solver has taken.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2361mat_op The system matrix operator.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2274mat_pc The preconditioner operator.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2279max_it The maximum number of iteration the solver may take.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2351norm   The norm of the residual at the current iteration.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2369norm_type
                     The norm used by the solver.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2317pc     The PC of the solver.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2304pc_side
                     The side on which preconditioning is performed.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2309reason The converged reason.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2384rtol   The relative tolerance of the solver.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2327vec_rhs
                     The right-hand side vector.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2267vec_sol
                     The solution vector.

                     Sourcecodeatpetsc4py/PETSc/KSP.pyx:2262petsc4py.PETSc.LGMapclasspetsc4py.PETSc.LGMap
              Bases: Object

              Mapping from a local to a global ordering.

              SEEALSO:ISLocalToGlobalMapping

              Enumerations
                                    ┌───────────┬───────────────────────────────────────┐
                                    │ GLMapMode │ Enum describing mapping behavior when │
                                    │           │ global indices are missing.           │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ Type      │ Local to global map types.            │
                                    └───────────┴───────────────────────────────────────┘

   petsc4py.PETSc.LGMap.GLMapModeclasspetsc4py.PETSc.LGMap.GLMapMode
                     Bases: object

                     Enum describing mapping behavior when global indices are missing.

                     MASK   Give missing global indices a local index of -1.

                     DROP   Drop missing global indices.

                     SEEALSO:ISGlobalToLocalMappingMode

                     Attributes Summary
                                                ┌──────┬───────────────────────────┐
                                                │ DROP │ Constant DROP of type int │
                                                ├──────┼───────────────────────────┤
                                                │ MASK │ Constant MASK of type int │
                                                └──────┴───────────────────────────┘

                     Attributes Documentation

                     DROP:int=DROP
                            Constant DROP of type intMASK:int=MASK
                            Constant MASK of type intpetsc4py.PETSc.LGMap.Typeclasspetsc4py.PETSc.LGMap.Type
                     Bases: object

                     Local to global map types.

                     Attributes Summary
                                                ┌───────┬──────────────────────────┐
                                                │ BASIC │ Object BASIC of type str │
                                                ├───────┼──────────────────────────┤
                                                │ HASH  │ Object HASH of type str  │
                                                └───────┴──────────────────────────┘

                     Attributes Documentation

                     BASIC:str=BASIC
                            Object BASIC of type strHASH:str=HASH
                            Object HASH of type str

              Methods Summary
                       ┌────────────────────────────────────┬───────────────────────────────────────┐
                       │ apply(indices[, result])           │ Convert a locally  numbered  list  of │
                       │                                    │ integers to a global numbering.       │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ applyBlock(indices[, result])      │ Convert  a local block numbering to a │
                       │                                    │ global block numbering.               │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ applyBlockInverse(indices[, mode]) │ Compute blocked local numbering  from │
                       │                                    │ blocked global numbering.             │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ applyIS(iset)                      │ Create   an  index  set  with  global │
                       │                                    │ numbering from a local numbering.     │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ applyInverse(indices[, mode])      │ Compute local numbering  from  global │
                       │                                    │ numbering.                            │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ create(indices[, bsize, comm])     │ Create a local-to-global mapping.     │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ createIS(iset)                     │ Create a local-to-global mapping from │
                       │                                    │ an index set.                         │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ createSF(sf, start)                │ Create a local-to-global mapping from │
                       │                                    │ a star forest.                        │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ destroy()                          │ Destroy the local-to-global mapping.  │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ getBlockIndices()                  │ Return  the  global  indices for each │
                       │                                    │ local block.                          │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ getBlockInfo()                     │ Determine the  block  indices  shared │
                       │                                    │ with neighboring processes.           │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ getBlockSize()                     │ Return   the   block   size   of  the │
                       │                                    │ local-to-global mapping.              │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ getIndices()                       │ Return the global  indices  for  each │
                       │                                    │ local point in the mapping.           │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ getInfo()                          │ Determine  the  indices  shared  with │
                       │                                    │ neighboring processes.                │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ getSize()                          │ Return  the   local   size   of   the │
                       │                                    │ local-to-global mapping.              │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ setFromOptions()                   │ Set  mapping options from the options │
                       │                                    │ database.                             │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ setType(lgmap_type)                │ Set the type of  the  local-to-global │
                       │                                    │ map.                                  │
                       ├────────────────────────────────────┼───────────────────────────────────────┤
                       │ view([viewer])                     │ View the local-to-global mapping.     │
                       └────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                  ┌───────────────┬───────────────────────────────────────┐
                                  │ block_indices │ The  global  indices  for  each local │
                                  │               │ block in the mapping.                 │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ block_info    │ Mapping  describing   block   indices │
                                  │               │ shared with neighboring processes.    │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ block_size    │ The block size.                       │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ indices       │ The  global  indices  for  each local │
                                  │               │ point in the mapping.                 │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ info          │ Mapping  describing  indices   shared │
                                  │               │ with neighboring processes.           │
                                  ├───────────────┼───────────────────────────────────────┤
                                  │ size          │ The local size.                       │
                                  └───────────────┴───────────────────────────────────────┘

              Methods Documentation

              apply(indices,result=None)
                     Convert a locally numbered list of integers to a global numbering.

                     Not collective.

                     Parameters

                            • indices (Sequence[int]) -- Input indices in local numbering.

                            • result (ArrayInt|None) -- Array to write the global numbering to. If None then a
                              new array will be allocated.

                     Returns
                            Indices in global numbering. If result is not None then this is returned here.

                     ReturntypeArrayIntSEEALSO:LGMap.applyBlock, ISLocalToGlobalMappingApplySourcecodeatpetsc4py/PETSc/IS.pyx:1404applyBlock(indices,result=None)
                     Convert a local block numbering to a global block numbering.

                     Not collective.

                     Parameters

                            • indices (Sequence[int]) -- Input block indices in local numbering.

                            • result (ArrayInt|None) -- Array to write the global numbering to. If None then a
                              new array will be allocated.

                     Returns
                            Block indices in global numbering. If result is not None then this is returned here.

                     ReturntypeArrayIntSEEALSO:LGMap.apply, ISLocalToGlobalMappingApplyBlockSourcecodeatpetsc4py/PETSc/IS.pyx:1441applyBlockInverse(indices,mode=None)
                     Compute blocked local numbering from blocked global numbering.

                     Not collective.

                     Parameters

                            • indices (Sequence[int]) -- Indices with a global block numbering.

                            • mode (GLMapMode|str|None) -- Flag indicating what to do with indices that have
                              no local value, defaults to "mask".

                     Returns
                            Indices with a local block numbering.

                     ReturntypeArrayIntSEEALSO:ISGlobalToLocalMappingApplyBlockSourcecodeatpetsc4py/PETSc/IS.pyx:1542applyIS(iset)
                     Create an index set with global numbering from a local numbering.

                     Collective.

                     Parametersiset (IS) -- Index set with local numbering.

                     Returns
                            Index set with global numbering.

                     ReturntypeISSEEALSO:ISLocalToGlobalMappingApplyISSourcecodeatpetsc4py/PETSc/IS.pyx:1478applyInverse(indices,mode=None)
                     Compute local numbering from global numbering.

                     Not collective.

                     Parameters

                            • indices (Sequence[int]) -- Indices with a global numbering.

                            • mode (GLMapMode|str|None) -- Flag indicating what to do with indices that have
                              no local value, defaults to "mask".

                     Returns
                            Indices with a local numbering.

                     ReturntypeArrayIntSEEALSO:ISGlobalToLocalMappingApplySourcecodeatpetsc4py/PETSc/IS.pyx:1503create(indices,bsize=None,comm=None)
                     Create a local-to-global mapping.

                     Not collective.

                     Parameters

                            • indices (Sequence[int]) -- Global index for each local element.

                            • bsize (int|None) -- Block size, defaults to 1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:ISLocalToGlobalMappingCreateSourcecodeatpetsc4py/PETSc/IS.pyx:1187createIS(iset)
                     Create a local-to-global mapping from an index set.

                     Not collective.

                     Parametersiset (IS) -- Index set containing the global numbers for each local number.

                     ReturntypeSelfSEEALSO:ISLocalToGlobalMappingCreateISSourcecodeatpetsc4py/PETSc/IS.pyx:1222createSF(sf,start)
                     Create a local-to-global mapping from a star forest.

                     Collective.

                     Parameters

                            • sf (SF) -- Star forest mapping contiguous local indices to (rank, offset).

                            • start (int) -- First global index on this process.

                     ReturntypeSelfSEEALSO:ISLocalToGlobalMappingCreateSFSourcecodeatpetsc4py/PETSc/IS.pyx:1243destroy()
                     Destroy the local-to-global mapping.

                     Not collective.

                     SEEALSO:ISLocalToGlobalMappingDestroySourcecodeatpetsc4py/PETSc/IS.pyx:1174ReturntypeSelfgetBlockIndices()
                     Return the global indices for each local block.

                     Not collective.

                     SEEALSO:ISLocalToGlobalMappingGetBlockIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:1318ReturntypeArrayIntgetBlockInfo()
                     Determine the block indices shared with neighboring processes.

                     Collective.

                     Returns
                            Mapping  from  neighboring  processor number to an array of shared block indices (in
                            local numbering).

                     ReturntypedictSEEALSO:ISLocalToGlobalMappingGetBlockInfoSourcecodeatpetsc4py/PETSc/IS.pyx:1373getBlockSize()
                     Return the block size of the local-to-global mapping.

                     Not collective.

                     SEEALSO:ISLocalToGlobalMappingGetBlockSizeSourcecodeatpetsc4py/PETSc/IS.pyx:1280ReturntypeintgetIndices()
                     Return the global indices for each local point in the mapping.

                     Not collective.

                     SEEALSO:ISLocalToGlobalMappingGetIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:1294ReturntypeArrayIntgetInfo()
                     Determine the indices shared with neighboring processes.

                     Collective.

                     Returns
                            Mapping from neighboring processor number to an array of shared  indices  (in  local
                            numbering).

                     ReturntypedictSEEALSO:ISLocalToGlobalMappingGetInfoSourcecodeatpetsc4py/PETSc/IS.pyx:1344getSize()
                     Return the local size of the local-to-global mapping.

                     Not collective.

                     SEEALSO:ISLocalToGlobalMappingGetSizeSourcecodeatpetsc4py/PETSc/IS.pyx:1266ReturntypeintsetFromOptions()
                     Set mapping options from the options database.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, ISLocalToGlobalMappingSetFromOptionsSourcecodeatpetsc4py/PETSc/IS.pyx:1143ReturntypeNonesetType(lgmap_type)
                     Set the type of the local-to-global map.

                     Logically collective.

                     Parameterslgmap_type (Type|str) -- The type of the local-to-global mapping.

                     ReturntypeNone

                     Notes

                     Use -islocaltoglobalmapping_type to set the type in the options database.

                     SEEALSO:WorkingwithPETScoptions, ISLocalToGlobalMappingSetTypeSourcecodeatpetsc4py/PETSc/IS.pyx:1119view(viewer=None)
                     View the local-to-global mapping.

                     Not collective.

                     Parametersviewer   (Viewer|None)   --  Viewer  instance,  defaults  to  an  instance  of
                            Viewer.Type.ASCII.

                     ReturntypeNoneSEEALSO:ISLocalToGlobalMappingViewSourcecodeatpetsc4py/PETSc/IS.pyx:1155

              Attributes Documentation

              block_indices
                     The global indices for each local block in the mapping.

                     Not collective.

                     SEEALSO:LGMap.getBlockIndices, ISLocalToGlobalMappingGetBlockIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:1621block_info
                     Mapping describing block indices shared with neighboring processes.

                     Collective.

                     SEEALSO:LGMap.getBlockInfo, ISLocalToGlobalMappingGetBlockInfoSourcecodeatpetsc4py/PETSc/IS.pyx:1647block_size
                     The block size.

                     Not collective.

                     SEEALSO:LGMap.getBlockSizeSourcecodeatpetsc4py/PETSc/IS.pyx:1595indices
                     The global indices for each local point in the mapping.

                     Not collective.

                     SEEALSO:LGMap.getIndices, ISLocalToGlobalMappingGetIndicesSourcecodeatpetsc4py/PETSc/IS.pyx:1608info   Mapping describing indices shared with neighboring processes.

                     Collective.

                     SEEALSO:LGMap.getInfo, ISLocalToGlobalMappingGetInfoSourcecodeatpetsc4py/PETSc/IS.pyx:1634size   The local size.

                     Not collective.

                     SEEALSO:LGMap.getSizeSourcecodeatpetsc4py/PETSc/IS.pyx:1582petsc4py.PETSc.Logclasspetsc4py.PETSc.Log
              Bases: object

              Logging support.

              Methods Summary
                          ┌───────────────────────────────┬───────────────────────────────────────┐
                          │ Class(name)                   │ Sourcecodeat │
                          │                               │ petsc4py/PETSc/Log.pyx:25             │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ Event(name[, klass])          │ Sourcecodeat │
                          │                               │ petsc4py/PETSc/Log.pyx:39             │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ EventDecorator([name, klass]) │ Decorate  a  function  with  a  PETSc │
                          │                               │ event.                                │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ Stage(name)                   │ Sourcecodeat │
                          │                               │ petsc4py/PETSc/Log.pyx:11             │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ addFlops(flops)               │ Add floating point operations to  the │
                          │                               │ current event.                        │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ begin()                       │ Turn   on   logging  of  objects  and │
                          │                               │ events.                               │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getCPUTime()                  │ Return the CPU time.                  │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getFlops()                    │ Return the number of  flops  used  on │
                          │                               │ this   processor  since  the  program │
                          │                               │ began.                                │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getTime()                     │ Return the current  time  of  day  in │
                          │                               │ seconds.                              │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ isActive()                    │ Return  whether  logging is currently │
                          │                               │ in progress.                          │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ logFlops(flops)               │ Add floating point operations to  the │
                          │                               │ current event.                        │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ view([viewer])                │ Print the log.                        │
                          └───────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              classmethodClass(name)Sourcecodeatpetsc4py/PETSc/Log.pyx:25ReturntypeLogClassclassmethodEvent(name,klass=None)Sourcecodeatpetsc4py/PETSc/Log.pyx:39ReturntypeLogEventclassmethodEventDecorator(name=None,klass=None)
                     Decorate a function with a PETSc event.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:178ReturntypeAnyclassmethodStage(name)Sourcecodeatpetsc4py/PETSc/Log.pyx:11ReturntypeLogStageclassmethodaddFlops(flops)
                     Add floating point operations to the current event.

                     Not collective.

                     Parametersflops (float) -- The number of flops to log.

                     ReturntypeNone

                     Notes

                     This method exists for backward compatibility.

                     SEEALSO:logFlops, PetscLogFlopsSourcecodeatpetsc4py/PETSc/Log.pyx:108classmethodbegin()
                     Turn on logging of objects and events.

                     Collective.

                     SEEALSO:PetscLogDefaultBeginSourcecodeatpetsc4py/PETSc/Log.pyx:55ReturntypeNoneclassmethodgetCPUTime()
                     Return the CPU time.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:171ReturntypefloatclassmethodgetFlops()
                     Return the number of flops used on this processor since the program began.

                     Not collective.

                     Returns
                            Number of floating point operations.

                     ReturntypefloatSEEALSO:PetscGetFlopsSourcecodeatpetsc4py/PETSc/Log.pyx:131classmethodgetTime()
                     Return the current time of day in seconds.

                     Collective.

                     Returnswctime -- Current time.

                     ReturntypefloatSEEALSO:PetscTimeSourcecodeatpetsc4py/PETSc/Log.pyx:151classmethodisActive()
                     Return whether logging is currently in progress.

                     Not collective.

                     SEEALSO:PetscLogIsActiveSourcecodeatpetsc4py/PETSc/Log.pyx:193ReturntypeboolclassmethodlogFlops(flops)
                     Add floating point operations to the current event.

                     Not collective.

                     Parametersflops (float) -- The number of flops to log.

                     ReturntypeNoneSEEALSO:PetscLogFlopsSourcecodeatpetsc4py/PETSc/Log.pyx:89classmethodview(viewer=None)
                     Print the log.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, PetscLogViewSourcecodeatpetsc4py/PETSc/Log.pyx:68petsc4py.PETSc.LogClassclasspetsc4py.PETSc.LogClass
              Bases: object

              Logging support.

              Methods Summary
                                 ┌─────────────────┬───────────────────────────────────────┐
                                 │ activate()      │ Activate the log class.               │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ deactivate()    │ Deactivate the log class.             │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ getActive()     │ Not implemented.                      │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ getName()       │ Return the log class name.            │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ setActive(flag) │ Activate or deactivate the log class. │
                                 └─────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                           ┌────────┬───────────────────────────┐
                                           │ active │ Log class activation.     │
                                           ├────────┼───────────────────────────┤
                                           │ id     │ The log class identifier. │
                                           ├────────┼───────────────────────────┤
                                           │ name   │ The log class name.       │
                                           └────────┴───────────────────────────┘

              Methods Documentation

              activate()
                     Activate the log class.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:431ReturntypeNonedeactivate()
                     Deactivate the log class.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:435ReturntypeNonegetActive()
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:439ReturntypeboolgetName()
                     Return the log class name.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:414ReturntypestrsetActive(flag)
                     Activate or deactivate the log class.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:444Parametersflag (bool)

                     ReturntypeNone

              Attributes Documentation

              active Log class activation.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:451id     The log class identifier.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:401name   The log class name.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:420petsc4py.PETSc.LogEventclasspetsc4py.PETSc.LogEvent
              Bases: object

              Logging support.

              Methods Summary
                              ┌──────────────────────┬───────────────────────────────────────┐
                              │ activate()           │ Indicate  that  the  event  should be │
                              │                      │ logged.                               │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ begin(*objs)         │ Log the beginning of a user event.    │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ deactivate()         │ Indicate that the event should not be │
                              │                      │ logged.                               │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ end(*objs)           │ Log the end of a user event.          │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ getActive()          │ Not implemented.                      │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ getActiveAll()       │ Not implemented.                      │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ getName()            │ The current event name.               │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ getPerfInfo([stage]) │ Get the performance information about │
                              │                      │ the given event in the given event.   │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ setActive(flag)      │ Indicate whether  or  not  the  event │
                              │                      │ should be logged.                     │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ setActiveAll(flag)   │ Turn on logging of all events.        │
                              └──────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                         ┌────────────┬───────────────────────────┐
                                         │ active     │ Event activation.         │
                                         ├────────────┼───────────────────────────┤
                                         │ active_all │ All events activation.    │
                                         ├────────────┼───────────────────────────┤
                                         │ id         │ The log event identifier. │
                                         ├────────────┼───────────────────────────┤
                                         │ name       │ The current event name.   │
                                         └────────────┴───────────────────────────┘

              Methods Documentation

              activate()
                     Indicate that the event should be logged.

                     Logically collective.

                     SEEALSO:PetscLogEventActivateSourcecodeatpetsc4py/PETSc/Log.pyx:552ReturntypeNonebegin(*objs)
                     Log the beginning of a user event.

                     Collective.

                     Parameters*objs -- objects associated with the event

                     ReturntypeNoneSEEALSO:PetscLogEventBeginSourcecodeatpetsc4py/PETSc/Log.pyx:496deactivate()
                     Indicate that the event should not be logged.

                     Logically collective.

                     SEEALSO:PetscLogEventDeactivateSourcecodeatpetsc4py/PETSc/Log.pyx:564ReturntypeNoneend(*objs)
                     Log the end of a user event.

                     Collective.

                     Parameters*objs -- Objects associated with the event.

                     ReturntypeNoneSEEALSO:PetscLogEventEndSourcecodeatpetsc4py/PETSc/Log.pyx:515getActive()
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:576ReturntypeboolgetActiveAll()
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:609ReturntypeboolgetName()
                     The current event name.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:535ReturntypestrgetPerfInfo(stage=None)
                     Get the performance information about the given event in the given event.

                     Not collective.

                     Parametersstage (int|None) -- The stage number.

                     Returnsinfo -- This structure is filled with the performance information.

                     ReturntypedictSEEALSO:PetscLogEventGetPerfInfoSourcecodeatpetsc4py/PETSc/Log.pyx:643setActive(flag)
                     Indicate whether or not the event should be logged.

                     Logically collective.

                     Parametersflag (bool) -- Activate or deactivate the event.

                     ReturntypeNoneSEEALSO:PetscLogEventDeactivate, PetscLogEventActivateSourcecodeatpetsc4py/PETSc/Log.pyx:581setActiveAll(flag)
                     Turn on logging of all events.

                     Logically collective.

                     Parametersflag  (bool)  --  Activate  (if  True)  or  deactivate (if False) the logging of all
                            events.

                     ReturntypeNoneSEEALSO:PetscLogEventSetActiveAllSourcecodeatpetsc4py/PETSc/Log.pyx:614

              Attributes Documentation

              active Event activation.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:601active_all
                     All events activation.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:633id     The log event identifier.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:478name   The current event name.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:541petsc4py.PETSc.LogStageclasspetsc4py.PETSc.LogStage
              Bases: object

              Logging support for different stages.

              Methods Summary
                                ┌──────────────────┬───────────────────────────────────────┐
                                │ activate()       │ Activate the stage.                   │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ deactivate()     │ Deactivate the stage.                 │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ getActive()      │ Check if the stage is activated.      │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ getName()        │ Return the current stage name.        │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ getVisible()     │ Return whether the stage is visible.  │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ pop()            │ Pop a stage from the logging stack.   │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ push()           │ Push a stage on the logging stack.    │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ setActive(flag)  │ Activate or  deactivate  the  current │
                                │                  │ stage.                                │
                                ├──────────────────┼───────────────────────────────────────┤
                                │ setVisible(flag) │ Set the visibility of the stage.      │
                                └──────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                        ┌─────────┬────────────────────────────────┐
                                        │ active  │ Whether the stage is activate. │
                                        ├─────────┼────────────────────────────────┤
                                        │ id      │ The log stage identifier.      │
                                        ├─────────┼────────────────────────────────┤
                                        │ name    │ The current stage name.        │
                                        ├─────────┼────────────────────────────────┤
                                        │ visible │ Whether the stage is visible.  │
                                        └─────────┴────────────────────────────────┘

              Methods Documentation

              activate()
                     Activate the stage.

                     Logically collective.

                     SEEALSO:PetscLogStageSetActiveSourcecodeatpetsc4py/PETSc/Log.pyx:279ReturntypeNonedeactivate()
                     Deactivate the stage.

                     Logically collective.

                     SEEALSO:PetscLogStageSetActiveSourcecodeatpetsc4py/PETSc/Log.pyx:291ReturntypeNonegetActive()
                     Check if the stage is activated.

                     Not collective.

                     SEEALSO:PetscLogStageGetActiveSourcecodeatpetsc4py/PETSc/Log.pyx:303ReturntypeboolgetName()
                     Return the current stage name.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:262ReturntypestrgetVisible()
                     Return whether the stage is visible.

                     Not collective.

                     SEEALSO:LogStage.setVisible, PetscLogStageSetVisibleSourcecodeatpetsc4py/PETSc/Log.pyx:341Returntypeboolpop()  Pop a stage from the logging stack.

                     Logically collective.

                     SEEALSO:LogStage.push, PetscLogStagePopSourcecodeatpetsc4py/PETSc/Log.pyx:247ReturntypeNonepush() Push a stage on the logging stack.

                     Logically collective.

                     SEEALSO:LogStage.pop, PetscLogStagePushSourcecodeatpetsc4py/PETSc/Log.pyx:235ReturntypeNonesetActive(flag)
                     Activate or deactivate the current stage.

                     Logically collective.

                     SEEALSO:PetscLogStageSetActiveSourcecodeatpetsc4py/PETSc/Log.pyx:317Parametersflag (bool)

                     ReturntypeNonesetVisible(flag)
                     Set the visibility of the stage.

                     Logically collective.

                     Parametersflag (bool) -- True to make the stage visible, False otherwise.

                     ReturntypeNoneSEEALSO:LogStage.getVisible, PetscLogStageSetVisibleSourcecodeatpetsc4py/PETSc/Log.pyx:355

              Attributes Documentation

              active Whether the stage is activate.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:331id     The log stage identifier.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:215name   The current stage name.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:268visible
                     Whether the stage is visible.

                     Sourcecodeatpetsc4py/PETSc/Log.pyx:374petsc4py.PETSc.Matclasspetsc4py.PETSc.Mat
              Bases: Object

              Matrix object.

              Mat is described in the PETScmanual.

              SEEALSO:Mat

              Enumerations
                                 ┌─────────────────┬───────────────────────────────────────┐
                                 │ AssemblyType    │ Matrix assembly type.                 │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ DuplicateOption │ Matrix duplicate option.              │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ FactorShiftType │ Factored matrix shift type.           │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ InfoType        │ Matrix info type.                     │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ Option          │ Matrix option.                        │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ OrderingType    │ Factored matrix ordering type.        │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ SORType         │ Matrix SOR type.                      │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ SolverType      │ Factored matrix solver type.          │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ Stencil         │ Associate structured grid coordinates │
                                 │                 │ with matrix indices.                  │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ Structure       │ Matrix modification structure.        │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ Type            │ Matrix type.                          │
                                 └─────────────────┴───────────────────────────────────────┘

   petsc4py.PETSc.Mat.AssemblyTypeclasspetsc4py.PETSc.Mat.AssemblyType
                     Bases: object

                     Matrix assembly type.

                     SEEALSO:MatAssemblyType

                     Attributes Summary
                                      ┌────────────────┬─────────────────────────────────────┐
                                      │ FINAL          │ Constant FINAL of type int          │
                                      ├────────────────┼─────────────────────────────────────┤
                                      │ FINAL_ASSEMBLY │ Constant FINAL_ASSEMBLY of type int │
                                      ├────────────────┼─────────────────────────────────────┤
                                      │ FLUSH          │ Constant FLUSH of type int          │
                                      ├────────────────┼─────────────────────────────────────┤
                                      │ FLUSH_ASSEMBLY │ Constant FLUSH_ASSEMBLY of type int │
                                      └────────────────┴─────────────────────────────────────┘

                     Attributes Documentation

                     FINAL:int=FINAL
                            Constant FINAL of type intFINAL_ASSEMBLY:int=FINAL_ASSEMBLY
                            Constant FINAL_ASSEMBLY of type intFLUSH:int=FLUSH
                            Constant FLUSH of type intFLUSH_ASSEMBLY:int=FLUSH_ASSEMBLY
                            Constant FLUSH_ASSEMBLY of type intpetsc4py.PETSc.Mat.DuplicateOptionclasspetsc4py.PETSc.Mat.DuplicateOption
                     Bases: object

                     Matrix duplicate option.

                     SEEALSO:MatDuplicateOption

                     Attributes Summary
                                 ┌───────────────────────┬───────────────────────────────────────┐
                                 │ COPY_VALUES           │ Constant COPY_VALUES of type int      │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ DO_NOT_COPY_VALUES    │ Constant DO_NOT_COPY_VALUES of type ‐ │
                                 │                       │ int                                   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ SHARE_NONZERO_PATTERN │ Constant   SHARE_NONZERO_PATTERN   of │
                                 │                       │ type int                              │
                                 └───────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     COPY_VALUES:int=COPY_VALUES
                            Constant COPY_VALUES of type intDO_NOT_COPY_VALUES:int=DO_NOT_COPY_VALUES
                            Constant DO_NOT_COPY_VALUES of type intSHARE_NONZERO_PATTERN:int=SHARE_NONZERO_PATTERN
                            Constant SHARE_NONZERO_PATTERN of type intpetsc4py.PETSc.Mat.FactorShiftTypeclasspetsc4py.PETSc.Mat.FactorShiftType
                     Bases: object

                     Factored matrix shift type.

                     SEEALSO:MatFactorShiftType

                     Attributes Summary
                                   ┌───────────────────┬───────────────────────────────────────┐
                                   │ INBLOCKS          │ Constant INBLOCKS of type int         │
                                   ├───────────────────┼───────────────────────────────────────┤
                                   │ NONE              │ Constant NONE of type int             │
                                   ├───────────────────┼───────────────────────────────────────┤
                                   │ NONZERO           │ Constant NONZERO of type int          │
                                   ├───────────────────┼───────────────────────────────────────┤
                                   │ NZ                │ Constant NZ of type int               │
                                   ├───────────────────┼───────────────────────────────────────┤
                                   │ PD                │ Constant PD of type int               │
                                   ├───────────────────┼───────────────────────────────────────┤
                                   │ POSITIVE_DEFINITE │ Constant POSITIVE_DEFINITE of type  ‐ │
                                   │                   │ int                                   │
                                   └───────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     INBLOCKS:int=INBLOCKS
                            Constant INBLOCKS of type intNONE:int=NONE
                            Constant NONE of type intNONZERO:int=NONZERO
                            Constant NONZERO of type intNZ:int=NZ
                            Constant NZ of type intPD:int=PD
                            Constant PD of type intPOSITIVE_DEFINITE:int=POSITIVE_DEFINITE
                            Constant POSITIVE_DEFINITE of type intpetsc4py.PETSc.Mat.InfoTypeclasspetsc4py.PETSc.Mat.InfoType
                     Bases: object

                     Matrix info type.

                     Attributes Summary
                                          ┌────────────┬─────────────────────────────────┐
                                          │ GLOBAL_MAX │ Constant GLOBAL_MAX of type int │
                                          ├────────────┼─────────────────────────────────┤
                                          │ GLOBAL_SUM │ Constant GLOBAL_SUM of type int │
                                          ├────────────┼─────────────────────────────────┤
                                          │ LOCAL      │ Constant LOCAL of type int      │
                                          └────────────┴─────────────────────────────────┘

                     Attributes Documentation

                     GLOBAL_MAX:int=GLOBAL_MAX
                            Constant GLOBAL_MAX of type intGLOBAL_SUM:int=GLOBAL_SUM
                            Constant GLOBAL_SUM of type intLOCAL:int=LOCAL
                            Constant LOCAL of type intpetsc4py.PETSc.Mat.Optionclasspetsc4py.PETSc.Mat.Option
                     Bases: object

                     Matrix option.

                     SEEALSO:MatOption

                     Attributes Summary
                              ┌─────────────────────────────┬───────────────────────────────────────┐
                              │ ERROR_LOWER_TRIANGULAR      │ Constant   ERROR_LOWER_TRIANGULAR  of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ FORCE_DIAGONAL_ENTRIES      │ Constant  FORCE_DIAGONAL_ENTRIES   of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ GETROW_UPPERTRIANGULAR      │ Constant   GETROW_UPPERTRIANGULAR  of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ HERMITIAN                   │ Constant HERMITIAN of type int        │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ IGNORE_LOWER_TRIANGULAR     │ Constant  IGNORE_LOWER_TRIANGULAR  of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ IGNORE_OFF_PROC_ENTRIES     │ Constant  IGNORE_OFF_PROC_ENTRIES  of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ IGNORE_ZERO_ENTRIES         │ Constant IGNORE_ZERO_ENTRIES of  type │
                              │                             │ int                                   │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ KEEP_NONZERO_PATTERN        │ Constant KEEP_NONZERO_PATTERN of type │
                              │                             │ int                                   │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ NEW_NONZERO_ALLOCATION_ERR  │ Constant   NEW_NONZERO_ALLOCATION_ERR │
                              │                             │ of type int                           │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ NEW_NONZERO_LOCATIONS       │ Constant   NEW_NONZERO_LOCATIONS   of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ NEW_NONZERO_LOCATION_ERR    │ Constant  NEW_NONZERO_LOCATION_ERR of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ NO_OFF_PROC_ENTRIES         │ Constant NO_OFF_PROC_ENTRIES of  type │
                              │                             │ int                                   │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ NO_OFF_PROC_ZERO_ROWS       │ Constant   NO_OFF_PROC_ZERO_ROWS   of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ OPTION_MAX                  │ Constant OPTION_MAX of type int       │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ OPTION_MIN                  │ Constant OPTION_MIN of type int       │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ ROW_ORIENTED                │ Constant ROW_ORIENTED of type int     │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ SORTED_FULL                 │ Constant SORTED_FULL of type int      │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ SPD                         │ Constant SPD of type int              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ STRUCTURALLY_SYMMETRIC      │ Constant  STRUCTURALLY_SYMMETRIC   of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ STRUCTURE_ONLY              │ Constant STRUCTURE_ONLY of type int   │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ SUBMAT_SINGLEIS             │ Constant SUBMAT_SINGLEIS of type int  │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ SUBSET_OFF_PROC_ENTRIES     │ Constant  SUBSET_OFF_PROC_ENTRIES  of │
                              │                             │ type int                              │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ SYMMETRIC                   │ Constant SYMMETRIC of type int        │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ SYMMETRY_ETERNAL            │ Constant SYMMETRY_ETERNAL of type int │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ UNUSED_NONZERO_LOCATION_ERR │ Constant  UNUSED_NONZERO_LOCATION_ERR │
                              │                             │ of type int                           │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ USE_HASH_TABLE              │ Constant USE_HASH_TABLE of type int   │
                              ├─────────────────────────────┼───────────────────────────────────────┤
                              │ USE_INODES                  │ Constant USE_INODES of type int       │
                              └─────────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     ERROR_LOWER_TRIANGULAR:int=ERROR_LOWER_TRIANGULAR
                            Constant ERROR_LOWER_TRIANGULAR of type intFORCE_DIAGONAL_ENTRIES:int=FORCE_DIAGONAL_ENTRIES
                            Constant FORCE_DIAGONAL_ENTRIES of type intGETROW_UPPERTRIANGULAR:int=GETROW_UPPERTRIANGULAR
                            Constant GETROW_UPPERTRIANGULAR of type intHERMITIAN:int=HERMITIAN
                            Constant HERMITIAN of type intIGNORE_LOWER_TRIANGULAR:int=IGNORE_LOWER_TRIANGULAR
                            Constant IGNORE_LOWER_TRIANGULAR of type intIGNORE_OFF_PROC_ENTRIES:int=IGNORE_OFF_PROC_ENTRIES
                            Constant IGNORE_OFF_PROC_ENTRIES of type intIGNORE_ZERO_ENTRIES:int=IGNORE_ZERO_ENTRIES
                            Constant IGNORE_ZERO_ENTRIES of type intKEEP_NONZERO_PATTERN:int=KEEP_NONZERO_PATTERN
                            Constant KEEP_NONZERO_PATTERN of type intNEW_NONZERO_ALLOCATION_ERR:int=NEW_NONZERO_ALLOCATION_ERR
                            Constant NEW_NONZERO_ALLOCATION_ERR of type intNEW_NONZERO_LOCATIONS:int=NEW_NONZERO_LOCATIONS
                            Constant NEW_NONZERO_LOCATIONS of type intNEW_NONZERO_LOCATION_ERR:int=NEW_NONZERO_LOCATION_ERR
                            Constant NEW_NONZERO_LOCATION_ERR of type intNO_OFF_PROC_ENTRIES:int=NO_OFF_PROC_ENTRIES
                            Constant NO_OFF_PROC_ENTRIES of type intNO_OFF_PROC_ZERO_ROWS:int=NO_OFF_PROC_ZERO_ROWS
                            Constant NO_OFF_PROC_ZERO_ROWS of type intOPTION_MAX:int=OPTION_MAX
                            Constant OPTION_MAX of type intOPTION_MIN:int=OPTION_MIN
                            Constant OPTION_MIN of type intROW_ORIENTED:int=ROW_ORIENTED
                            Constant ROW_ORIENTED of type intSORTED_FULL:int=SORTED_FULL
                            Constant SORTED_FULL of type intSPD:int=SPD
                            Constant SPD of type intSTRUCTURALLY_SYMMETRIC:int=STRUCTURALLY_SYMMETRIC
                            Constant STRUCTURALLY_SYMMETRIC of type intSTRUCTURE_ONLY:int=STRUCTURE_ONLY
                            Constant STRUCTURE_ONLY of type intSUBMAT_SINGLEIS:int=SUBMAT_SINGLEIS
                            Constant SUBMAT_SINGLEIS of type intSUBSET_OFF_PROC_ENTRIES:int=SUBSET_OFF_PROC_ENTRIES
                            Constant SUBSET_OFF_PROC_ENTRIES of type intSYMMETRIC:int=SYMMETRIC
                            Constant SYMMETRIC of type intSYMMETRY_ETERNAL:int=SYMMETRY_ETERNAL
                            Constant SYMMETRY_ETERNAL of type intUNUSED_NONZERO_LOCATION_ERR:int=UNUSED_NONZERO_LOCATION_ERR
                            Constant UNUSED_NONZERO_LOCATION_ERR of type intUSE_HASH_TABLE:int=USE_HASH_TABLE
                            Constant USE_HASH_TABLE of type intUSE_INODES:int=USE_INODES
                            Constant USE_INODES of type intpetsc4py.PETSc.Mat.OrderingTypeclasspetsc4py.PETSc.Mat.OrderingType
                     Bases: object

                     Factored matrix ordering type.

                     SEEALSO:MatOrderingType

                     Attributes Summary
                                            ┌───────────┬──────────────────────────────┐
                                            │ AMD       │ Object AMD of type str       │
                                            ├───────────┼──────────────────────────────┤
                                            │ METISND   │ Object METISND of type str   │
                                            ├───────────┼──────────────────────────────┤
                                            │ NATURAL   │ Object NATURAL of type str   │
                                            ├───────────┼──────────────────────────────┤
                                            │ ND        │ Object ND of type str        │
                                            ├───────────┼──────────────────────────────┤
                                            │ OWD       │ Object OWD of type str       │
                                            ├───────────┼──────────────────────────────┤
                                            │ QMD       │ Object QMD of type str       │
                                            ├───────────┼──────────────────────────────┤
                                            │ RCM       │ Object RCM of type str       │
                                            ├───────────┼──────────────────────────────┤
                                            │ ROWLENGTH │ Object ROWLENGTH of type str │
                                            ├───────────┼──────────────────────────────┤
                                            │ SPECTRAL  │ Object SPECTRAL of type str  │
                                            ├───────────┼──────────────────────────────┤
                                            │ WBM       │ Object WBM of type str       │
                                            └───────────┴──────────────────────────────┘

                     Attributes Documentation

                     AMD:str=AMD
                            Object AMD of type strMETISND:str=METISND
                            Object METISND of type strNATURAL:str=NATURAL
                            Object NATURAL of type strND:str=ND
                            Object ND of type strOWD:str=OWD
                            Object OWD of type strQMD:str=QMD
                            Object QMD of type strRCM:str=RCM
                            Object RCM of type strROWLENGTH:str=ROWLENGTH
                            Object ROWLENGTH of type strSPECTRAL:str=SPECTRAL
                            Object SPECTRAL of type strWBM:str=WBM
                            Object WBM of type strpetsc4py.PETSc.Mat.SORTypeclasspetsc4py.PETSc.Mat.SORType
                     Bases: object

                     Matrix SOR type.

                     SEEALSO:MatSORType

                     Attributes Summary
                                 ┌───────────────────────┬───────────────────────────────────────┐
                                 │ APPLY_LOWER           │ Constant APPLY_LOWER of type int      │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ APPLY_UPPER           │ Constant APPLY_UPPER of type int      │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ BACKWARD_SWEEP        │ Constant BACKWARD_SWEEP of type int   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ EISENSTAT             │ Constant EISENSTAT of type int        │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ FORWARD_SWEEP         │ Constant FORWARD_SWEEP of type int    │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ LOCAL_BACKWARD_SWEEP  │ Constant LOCAL_BACKWARD_SWEEP of type │
                                 │                       │ int                                   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ LOCAL_FORWARD_SWEEP   │ Constant  LOCAL_FORWARD_SWEEP of type │
                                 │                       │ int                                   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ LOCAL_SYMMETRIC_SWEEP │ Constant   LOCAL_SYMMETRIC_SWEEP   of │
                                 │                       │ type int                              │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ SYMMETRY_SWEEP        │ Constant SYMMETRY_SWEEP of type int   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ ZERO_INITIAL_GUESS    │ Constant ZERO_INITIAL_GUESS of type ‐ │
                                 │                       │ int                                   │
                                 └───────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     APPLY_LOWER:int=APPLY_LOWER
                            Constant APPLY_LOWER of type intAPPLY_UPPER:int=APPLY_UPPER
                            Constant APPLY_UPPER of type intBACKWARD_SWEEP:int=BACKWARD_SWEEP
                            Constant BACKWARD_SWEEP of type intEISENSTAT:int=EISENSTAT
                            Constant EISENSTAT of type intFORWARD_SWEEP:int=FORWARD_SWEEP
                            Constant FORWARD_SWEEP of type intLOCAL_BACKWARD_SWEEP:int=LOCAL_BACKWARD_SWEEP
                            Constant LOCAL_BACKWARD_SWEEP of type intLOCAL_FORWARD_SWEEP:int=LOCAL_FORWARD_SWEEP
                            Constant LOCAL_FORWARD_SWEEP of type intLOCAL_SYMMETRIC_SWEEP:int=LOCAL_SYMMETRIC_SWEEP
                            Constant LOCAL_SYMMETRIC_SWEEP of type intSYMMETRY_SWEEP:int=SYMMETRY_SWEEP
                            Constant SYMMETRY_SWEEP of type intZERO_INITIAL_GUESS:int=ZERO_INITIAL_GUESS
                            Constant ZERO_INITIAL_GUESS of type intpetsc4py.PETSc.Mat.SolverTypeclasspetsc4py.PETSc.Mat.SolverType
                     Bases: object

                     Factored matrix solver type.

                     SEEALSO:MatSolverType

                     Attributes Summary
                                         ┌──────────────┬─────────────────────────────────┐
                                         │ BAS          │ Object BAS of type str          │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ CHOLMOD      │ Object CHOLMOD of type str      │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ CUDA         │ Object CUDA of type str         │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ CUSPARSE     │ Object CUSPARSE of type str     │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ ELEMENTAL    │ Object ELEMENTAL of type str    │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ ESSL         │ Object ESSL of type str         │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ KLU          │ Object KLU of type str          │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ LUSOL        │ Object LUSOL of type str        │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ MATLAB       │ Object MATLAB of type str       │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ MKL_CPARDISO │ Object MKL_CPARDISO of type str │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ MKL_PARDISO  │ Object MKL_PARDISO of type str  │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ MUMPS        │ Object MUMPS of type str        │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ PASTIX       │ Object PASTIX of type str       │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ PETSC        │ Object PETSC of type str        │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ SCALAPACK    │ Object SCALAPACK of type str    │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ SPQR         │ Object SPQR of type str         │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ STRUMPACK    │ Object STRUMPACK of type str    │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ SUPERLU      │ Object SUPERLU of type str      │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ SUPERLU_DIST │ Object SUPERLU_DIST of type str │
                                         ├──────────────┼─────────────────────────────────┤
                                         │ UMFPACK      │ Object UMFPACK of type str      │
                                         └──────────────┴─────────────────────────────────┘

                     Attributes Documentation

                     BAS:str=BAS
                            Object BAS of type strCHOLMOD:str=CHOLMOD
                            Object CHOLMOD of type strCUDA:str=CUDA
                            Object CUDA of type strCUSPARSE:str=CUSPARSE
                            Object CUSPARSE of type strELEMENTAL:str=ELEMENTAL
                            Object ELEMENTAL of type strESSL:str=ESSL
                            Object ESSL of type strKLU:str=KLU
                            Object KLU of type strLUSOL:str=LUSOL
                            Object LUSOL of type strMATLAB:str=MATLAB
                            Object MATLAB of type strMKL_CPARDISO:str=MKL_CPARDISO
                            Object MKL_CPARDISO of type strMKL_PARDISO:str=MKL_PARDISO
                            Object MKL_PARDISO of type strMUMPS:str=MUMPS
                            Object MUMPS of type strPASTIX:str=PASTIX
                            Object PASTIX of type strPETSC:str=PETSC
                            Object PETSC of type strSCALAPACK:str=SCALAPACK
                            Object SCALAPACK of type strSPQR:str=SPQR
                            Object SPQR of type strSTRUMPACK:str=STRUMPACK
                            Object STRUMPACK of type strSUPERLU:str=SUPERLU
                            Object SUPERLU of type strSUPERLU_DIST:str=SUPERLU_DIST
                            Object SUPERLU_DIST of type strUMFPACK:str=UMFPACK
                            Object UMFPACK of type strpetsc4py.PETSc.Mat.Stencilclasspetsc4py.PETSc.Mat.Stencil
                     Bases: object

                     Associate structured grid coordinates with matrix indices.

                     SEEALSO:MatStencil

                     Attributes Summary
                                          ┌───────┬─────────────────────────────────────┐
                                          │ c     │ Field component.                    │
                                          ├───────┼─────────────────────────────────────┤
                                          │ field │ Field component.                    │
                                          ├───────┼─────────────────────────────────────┤
                                          │ i     │ First logical grid coordinate.      │
                                          ├───────┼─────────────────────────────────────┤
                                          │ index │ Logical grid coordinates (i,j,k). │
                                          ├───────┼─────────────────────────────────────┤
                                          │ j     │ Second logical grid coordinate.     │
                                          ├───────┼─────────────────────────────────────┤
                                          │ k     │ Third logical grid coordinate.      │
                                          └───────┴─────────────────────────────────────┘

                     Attributes Documentation

                     c      Field component.

                            Sourcecodeatpetsc4py/PETSc/Mat.pyx:317field  Field component.

                            Sourcecodeatpetsc4py/PETSc/Mat.pyx:336i      First logical grid coordinate.

                            Sourcecodeatpetsc4py/PETSc/Mat.pyx:293index  Logical grid coordinates (i,j,k).

                            Sourcecodeatpetsc4py/PETSc/Mat.pyx:325j      Second logical grid coordinate.

                            Sourcecodeatpetsc4py/PETSc/Mat.pyx:301k      Third logical grid coordinate.

                            Sourcecodeatpetsc4py/PETSc/Mat.pyx:309petsc4py.PETSc.Mat.Structureclasspetsc4py.PETSc.Mat.Structure
                     Bases: object

                     Matrix modification structure.

                     SEEALSO:MatStructure

                     Attributes Summary
                               ┌───────────────────────────┬───────────────────────────────────────┐
                               │ DIFFERENT                 │ Constant DIFFERENT of type int        │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIFFERENT_NONZERO_PATTERN │ Constant DIFFERENT_NONZERO_PATTERN of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DIFFERENT_NZ              │ Constant DIFFERENT_NZ of type int     │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ SAME                      │ Constant SAME of type int             │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ SAME_NONZERO_PATTERN      │ Constant SAME_NONZERO_PATTERN of type │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ SAME_NZ                   │ Constant SAME_NZ of type int          │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ SUBSET                    │ Constant SUBSET of type int           │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ SUBSET_NONZERO_PATTERN    │ Constant   SUBSET_NONZERO_PATTERN  of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ SUBSET_NZ                 │ Constant SUBSET_NZ of type int        │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ UNKNOWN                   │ Constant UNKNOWN of type int          │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ UNKNOWN_NONZERO_PATTERN   │ Constant  UNKNOWN_NONZERO_PATTERN  of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ UNKNOWN_NZ                │ Constant UNKNOWN_NZ of type int       │
                               └───────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     DIFFERENT:int=DIFFERENT
                            Constant DIFFERENT of type intDIFFERENT_NONZERO_PATTERN:int=DIFFERENT_NONZERO_PATTERN
                            Constant DIFFERENT_NONZERO_PATTERN of type intDIFFERENT_NZ:int=DIFFERENT_NZ
                            Constant DIFFERENT_NZ of type intSAME:int=SAME
                            Constant SAME of type intSAME_NONZERO_PATTERN:int=SAME_NONZERO_PATTERN
                            Constant SAME_NONZERO_PATTERN of type intSAME_NZ:int=SAME_NZ
                            Constant SAME_NZ of type intSUBSET:int=SUBSET
                            Constant SUBSET of type intSUBSET_NONZERO_PATTERN:int=SUBSET_NONZERO_PATTERN
                            Constant SUBSET_NONZERO_PATTERN of type intSUBSET_NZ:int=SUBSET_NZ
                            Constant SUBSET_NZ of type intUNKNOWN:int=UNKNOWN
                            Constant UNKNOWN of type intUNKNOWN_NONZERO_PATTERN:int=UNKNOWN_NONZERO_PATTERN
                            Constant UNKNOWN_NONZERO_PATTERN of type intUNKNOWN_NZ:int=UNKNOWN_NZ
                            Constant UNKNOWN_NZ of type intpetsc4py.PETSc.Mat.Typeclasspetsc4py.PETSc.Mat.Type
                     Bases: object

                     Matrix type.

                     SEEALSO:MatType

                     Attributes Summary
                                   ┌────────────────────┬───────────────────────────────────────┐
                                   │ AIJ                │ Object AIJ of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ AIJCRL             │ Object AIJCRL of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ AIJCUSPARSE        │ Object AIJCUSPARSE of type str        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ AIJMKL             │ Object AIJMKL of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ AIJPERM            │ Object AIJPERM of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ AIJSELL            │ Object AIJSELL of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ AIJVIENNACL        │ Object AIJVIENNACL of type str        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ BAIJ               │ Object BAIJ of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ BAIJMKL            │ Object BAIJMKL of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ BLOCKMAT           │ Object BLOCKMAT of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ COMPOSITE          │ Object COMPOSITE of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ CONSTANTDIAGONAL   │ Object CONSTANTDIAGONAL of type str   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DENSE              │ Object DENSE of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DENSECUDA          │ Object DENSECUDA of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DIAGONAL           │ Object DIAGONAL of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DUMMY              │ Object DUMMY of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ELEMENTAL          │ Object ELEMENTAL of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ FFT                │ Object FFT of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ FFTW               │ Object FFTW of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ H2OPUS             │ Object H2OPUS of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HERMITIANTRANSPOSE │ Object HERMITIANTRANSPOSE of type str │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HYPRE              │ Object HYPRE of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HYPRESSTRUCT       │ Object HYPRESSTRUCT of type str       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HYPRESTRUCT        │ Object HYPRESTRUCT of type str        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ IS                 │ Object IS of type str                 │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ KAIJ               │ Object KAIJ of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVM               │ Object LMVM of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMBADBROYDEN     │ Object LMVMBADBROYDEN of type str     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMBFGS           │ Object LMVMBFGS of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMBROYDEN        │ Object LMVMBROYDEN of type str        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMDBFGS          │ Object LMVMDBFGS of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMDDFP           │ Object LMVMDDFP of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMDFP            │ Object LMVMDFP of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMDIAGBBROYDEN   │ Object LMVMDIAGBBROYDEN of type str   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMDQN            │ Object LMVMDQN of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMSR1            │ Object LMVMSR1 of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMSYMBADBROYDEN  │ Object LMVMSYMBADBROYDEN of type str  │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVMSYMBROYDEN     │ Object LMVMSYMBROYDEN of type str     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LOCALREF           │ Object LOCALREF of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LRC                │ Object LRC of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MAIJ               │ Object MAIJ of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MFFD               │ Object MFFD of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIADJ             │ Object MPIADJ of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIAIJ             │ Object MPIAIJ of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIAIJCRL          │ Object MPIAIJCRL of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIAIJCUSPARSE     │ Object MPIAIJCUSPARSE of type str     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIAIJMKL          │ Object MPIAIJMKL of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIAIJPERM         │ Object MPIAIJPERM of type str         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIAIJSELL         │ Object MPIAIJSELL of type str         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIAIJVIENNACL     │ Object MPIAIJVIENNACL of type str     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIBAIJ            │ Object MPIBAIJ of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIBAIJMKL         │ Object MPIBAIJMKL of type str         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIDENSE           │ Object MPIDENSE of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIDENSECUDA       │ Object MPIDENSECUDA of type str       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIKAIJ            │ Object MPIKAIJ of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPIMAIJ            │ Object MPIMAIJ of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPISBAIJ           │ Object MPISBAIJ of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MPISELL            │ Object MPISELL of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ NEST               │ Object NEST of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ NORMAL             │ Object NORMAL of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ NORMALHERMITIAN    │ Object NORMALHERMITIAN of type str    │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ PREALLOCATOR       │ Object PREALLOCATOR of type str       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ PYTHON             │ Object PYTHON of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SAME               │ Object SAME of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SBAIJ              │ Object SBAIJ of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SCATTER            │ Object SCATTER of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SCHURCOMPLEMENT    │ Object SCHURCOMPLEMENT of type str    │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SELL               │ Object SELL of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQAIJ             │ Object SEQAIJ of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQAIJCRL          │ Object SEQAIJCRL of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQAIJCUSPARSE     │ Object SEQAIJCUSPARSE of type str     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQAIJMKL          │ Object SEQAIJMKL of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQAIJPERM         │ Object SEQAIJPERM of type str         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQAIJSELL         │ Object SEQAIJSELL of type str         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQAIJVIENNACL     │ Object SEQAIJVIENNACL of type str     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQBAIJ            │ Object SEQBAIJ of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQBAIJMKL         │ Object SEQBAIJMKL of type str         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQCUFFT           │ Object SEQCUFFT of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQDENSE           │ Object SEQDENSE of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQDENSECUDA       │ Object SEQDENSECUDA of type str       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQKAIJ            │ Object SEQKAIJ of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQMAIJ            │ Object SEQMAIJ of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQSBAIJ           │ Object SEQSBAIJ of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SEQSELL            │ Object SEQSELL of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SHELL              │ Object SHELL of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SUBMATRIX          │ Object SUBMATRIX of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ TRANSPOSE          │ Object TRANSPOSE of type str          │
                                   └────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     AIJ:str=AIJ
                            Object AIJ of type strAIJCRL:str=AIJCRL
                            Object AIJCRL of type strAIJCUSPARSE:str=AIJCUSPARSE
                            Object AIJCUSPARSE of type strAIJMKL:str=AIJMKL
                            Object AIJMKL of type strAIJPERM:str=AIJPERM
                            Object AIJPERM of type strAIJSELL:str=AIJSELL
                            Object AIJSELL of type strAIJVIENNACL:str=AIJVIENNACL
                            Object AIJVIENNACL of type strBAIJ:str=BAIJ
                            Object BAIJ of type strBAIJMKL:str=BAIJMKL
                            Object BAIJMKL of type strBLOCKMAT:str=BLOCKMAT
                            Object BLOCKMAT of type strCOMPOSITE:str=COMPOSITE
                            Object COMPOSITE of type strCONSTANTDIAGONAL:str=CONSTANTDIAGONAL
                            Object CONSTANTDIAGONAL of type strDENSE:str=DENSE
                            Object DENSE of type strDENSECUDA:str=DENSECUDA
                            Object DENSECUDA of type strDIAGONAL:str=DIAGONAL
                            Object DIAGONAL of type strDUMMY:str=DUMMY
                            Object DUMMY of type strELEMENTAL:str=ELEMENTAL
                            Object ELEMENTAL of type strFFT:str=FFT
                            Object FFT of type strFFTW:str=FFTW
                            Object FFTW of type strH2OPUS:str=H2OPUS
                            Object H2OPUS of type strHERMITIANTRANSPOSE:str=HERMITIANTRANSPOSE
                            Object HERMITIANTRANSPOSE of type strHYPRE:str=HYPRE
                            Object HYPRE of type strHYPRESSTRUCT:str=HYPRESSTRUCT
                            Object HYPRESSTRUCT of type strHYPRESTRUCT:str=HYPRESTRUCT
                            Object HYPRESTRUCT of type strIS:str=IS
                            Object IS of type strKAIJ:str=KAIJ
                            Object KAIJ of type strLMVM:str=LMVM
                            Object LMVM of type strLMVMBADBROYDEN:str=LMVMBADBROYDEN
                            Object LMVMBADBROYDEN of type strLMVMBFGS:str=LMVMBFGS
                            Object LMVMBFGS of type strLMVMBROYDEN:str=LMVMBROYDEN
                            Object LMVMBROYDEN of type strLMVMDBFGS:str=LMVMDBFGS
                            Object LMVMDBFGS of type strLMVMDDFP:str=LMVMDDFP
                            Object LMVMDDFP of type strLMVMDFP:str=LMVMDFP
                            Object LMVMDFP of type strLMVMDIAGBBROYDEN:str=LMVMDIAGBBROYDEN
                            Object LMVMDIAGBBROYDEN of type strLMVMDQN:str=LMVMDQN
                            Object LMVMDQN of type strLMVMSR1:str=LMVMSR1
                            Object LMVMSR1 of type strLMVMSYMBADBROYDEN:str=LMVMSYMBADBROYDEN
                            Object LMVMSYMBADBROYDEN of type strLMVMSYMBROYDEN:str=LMVMSYMBROYDEN
                            Object LMVMSYMBROYDEN of type strLOCALREF:str=LOCALREF
                            Object LOCALREF of type strLRC:str=LRC
                            Object LRC of type strMAIJ:str=MAIJ
                            Object MAIJ of type strMFFD:str=MFFD
                            Object MFFD of type strMPIADJ:str=MPIADJ
                            Object MPIADJ of type strMPIAIJ:str=MPIAIJ
                            Object MPIAIJ of type strMPIAIJCRL:str=MPIAIJCRL
                            Object MPIAIJCRL of type strMPIAIJCUSPARSE:str=MPIAIJCUSPARSE
                            Object MPIAIJCUSPARSE of type strMPIAIJMKL:str=MPIAIJMKL
                            Object MPIAIJMKL of type strMPIAIJPERM:str=MPIAIJPERM
                            Object MPIAIJPERM of type strMPIAIJSELL:str=MPIAIJSELL
                            Object MPIAIJSELL of type strMPIAIJVIENNACL:str=MPIAIJVIENNACL
                            Object MPIAIJVIENNACL of type strMPIBAIJ:str=MPIBAIJ
                            Object MPIBAIJ of type strMPIBAIJMKL:str=MPIBAIJMKL
                            Object MPIBAIJMKL of type strMPIDENSE:str=MPIDENSE
                            Object MPIDENSE of type strMPIDENSECUDA:str=MPIDENSECUDA
                            Object MPIDENSECUDA of type strMPIKAIJ:str=MPIKAIJ
                            Object MPIKAIJ of type strMPIMAIJ:str=MPIMAIJ
                            Object MPIMAIJ of type strMPISBAIJ:str=MPISBAIJ
                            Object MPISBAIJ of type strMPISELL:str=MPISELL
                            Object MPISELL of type strNEST:str=NEST
                            Object NEST of type strNORMAL:str=NORMAL
                            Object NORMAL of type strNORMALHERMITIAN:str=NORMALHERMITIAN
                            Object NORMALHERMITIAN of type strPREALLOCATOR:str=PREALLOCATOR
                            Object PREALLOCATOR of type strPYTHON:str=PYTHON
                            Object PYTHON of type strSAME:str=SAME
                            Object SAME of type strSBAIJ:str=SBAIJ
                            Object SBAIJ of type strSCATTER:str=SCATTER
                            Object SCATTER of type strSCHURCOMPLEMENT:str=SCHURCOMPLEMENT
                            Object SCHURCOMPLEMENT of type strSELL:str=SELL
                            Object SELL of type strSEQAIJ:str=SEQAIJ
                            Object SEQAIJ of type strSEQAIJCRL:str=SEQAIJCRL
                            Object SEQAIJCRL of type strSEQAIJCUSPARSE:str=SEQAIJCUSPARSE
                            Object SEQAIJCUSPARSE of type strSEQAIJMKL:str=SEQAIJMKL
                            Object SEQAIJMKL of type strSEQAIJPERM:str=SEQAIJPERM
                            Object SEQAIJPERM of type strSEQAIJSELL:str=SEQAIJSELL
                            Object SEQAIJSELL of type strSEQAIJVIENNACL:str=SEQAIJVIENNACL
                            Object SEQAIJVIENNACL of type strSEQBAIJ:str=SEQBAIJ
                            Object SEQBAIJ of type strSEQBAIJMKL:str=SEQBAIJMKL
                            Object SEQBAIJMKL of type strSEQCUFFT:str=SEQCUFFT
                            Object SEQCUFFT of type strSEQDENSE:str=SEQDENSE
                            Object SEQDENSE of type strSEQDENSECUDA:str=SEQDENSECUDA
                            Object SEQDENSECUDA of type strSEQKAIJ:str=SEQKAIJ
                            Object SEQKAIJ of type strSEQMAIJ:str=SEQMAIJ
                            Object SEQMAIJ of type strSEQSBAIJ:str=SEQSBAIJ
                            Object SEQSBAIJ of type strSEQSELL:str=SEQSELL
                            Object SEQSELL of type strSHELL:str=SHELL
                            Object SHELL of type strSUBMATRIX:str=SUBMATRIX
                            Object SUBMATRIX of type strTRANSPOSE:str=TRANSPOSE
                            Object TRANSPOSE of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ H2OpusCompress(tol)                   │ Compress a hierarchical matrix.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ H2OpusLowRankUpdate(U[, V, s])        │ Perform a low-rank update of the form │
                      │                                       │ self += sUVᵀ.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ H2OpusOrthogonalize()                 │ Orthogonalize  the  basis  tree  of a │
                      │                                       │ hierarchical matrix.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ SOR(b,  x[,  omega,  sortype,  shift, │ Compute        relaxation       (SOR, │
                      │ its, lits])                           │ Gauss-Seidel) sweeps.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ appendOptionsPrefix([prefix])         │ Append  to  the   prefix   used   for │
                      │                                       │ searching    for   options   in   the │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ assemble([assembly])                  │ Assemble the matrix.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ assemblyBegin([assembly])             │ Begin  an  assembling  stage  of  the │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ assemblyEnd([assembly])               │ Complete  an  assembling stage of the │
                      │                                       │ matrix initiated with assemblyBegin.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ axpy(alpha, X[, structure])           │ Perform the matrix summation self + = │
                      │                                       │ ɑ·X.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ aypx(alpha, X[, structure])           │ Perform the matrix summation  self  = │
                      │                                       │ ɑ·self + X.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ bindToCPU(flg)                        │ Mark  a matrix to temporarily stay on │
                      │                                       │ the CPU.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ boundToCPU()                          │ Query if a matrix  is  bound  to  the │
                      │                                       │ CPU.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ chop(tol)                             │ Set   entries  smallest  of  tol  (in │
                      │                                       │ absolute values) to zero.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ conjugate([out])                      │ Return the conjugate matrix.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ convert([mat_type, out])              │ Convert the matrix type.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ copy([result, structure])             │ Return a copy of the matrix.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create the matrix.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createAIJ(size[,  bsize,  nnz,   csr, │ Create   a  sparse  Type.AIJ  matrix, │
                      │ comm])                                │ optionally preallocating.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createAIJCRL(size[, bsize, nnz,  csr, │ Create a sparse Type.AIJCRL matrix.   │
                      │ comm])                                │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createAIJWithArrays(size,       csr[, │ Create a sparse Type.AIJ matrix  with │
                      │ bsize, comm])                         │ data in CSR format.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createBAIJ(size,  bsize[,  nnz,  csr, │ Create  a  sparse  blocked  Type.BAIJ │
                      │ comm])                                │ matrix, optionally preallocating.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createConstantDiagonal(size,   diag[, │ Create  a  diagonal  matrix  of  type │
                      │ comm])                                │ Type.CONSTANTDIAGONAL.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createDense(size[,    bsize,   array, │ Create a Type.DENSE matrix.           │
                      │ comm])                                │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createDenseCUDA(size[, bsize,  array, │ Create  a  Type.DENSECUDA matrix with │
                      │ ...])                                 │ optional host and device data.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createDiagonal(diag)                  │ Create  a  diagonal  matrix  of  type │
                      │                                       │ Type.DIAGONAL.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createH2OpusFromMat(A[,  coordinates, │ Create  a  hierarchical   Type.H2OPUS │
                      │ dist, ...])                           │ matrix   sampling   from  a  provided │
                      │                                       │ operator.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createHermitianTranspose(mat)         │ Create   a    Type.HERMITIANTRANSPOSE │
                      │                                       │ matrix that behaves like (A*)ᵀ.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createIS(size[,     bsize,    lgmapr, │ Create a Type.IS matrix  representing │
                      │ lgmapc, comm])                        │ globally unassembled operators.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createLRC(A, U, c, V)                 │ Create a low-rank correction Type.LRC │
                      │                                       │ matrix representing A + UCVᵀ.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createNest(mats[,   isrows,   iscols, │ Create a Type.NEST matrix  containing │
                      │ comm])                                │ multiple submatrices.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createNormal(mat)                     │ Create     a    Type.NORMAL    matrix │
                      │                                       │ representing AᵀA.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createNormalHermitian(mat)            │ Create a Type.NORMALHERMITIAN  matrix │
                      │                                       │ representing (A*)ᵀA.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createPython(size[, context, comm])   │ Create a Type.PYTHON matrix.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSBAIJ(size,  bsize[,  nnz, csr, │ Create a sparse Type.SBAIJ matrix  in │
                      │ comm])                                │ symmetric block format.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createScatter(scatter[, comm])        │ Create  a  Type.SCATTER matrix from a │
                      │                                       │ vector scatter.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSchurComplement(A00, Ap00, A01, │ Create a Type.SCHURCOMPLEMENT matrix. │
                      │ A10[, A11])                           │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSubMatrices(isrows[,    iscols, │ Return       several       sequential │
                      │ submats])                             │ submatrices.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSubMatrix(isrow[,        iscol, │ Return a submatrix.                   │
                      │ submat])                              │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSubMatrixVirtual(A,     isrow[, │ Create a Type.SUBMATRIX  matrix  that │
                      │ iscol])                               │ acts as a submatrix.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createTranspose(mat)                  │ Create  a  Type.TRANSPOSE matrix that │
                      │                                       │ behaves like Aᵀ.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createVecLeft()                       │ Return a left vector, a  vector  that │
                      │                                       │ the  matrix  vector  product  can  be │
                      │                                       │ stored in.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createVecRight()                      │ Return a right vector, a vector  that │
                      │                                       │ the matrix can be multiplied against. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createVecs([side])                    │ Return  vectors  that  can be used in │
                      │                                       │ matrix vector products.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the matrix.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ diagonalScale([L, R])                 │ Perform left  and/or  right  diagonal │
                      │                                       │ scaling of the matrix.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ duplicate([copy])                     │ Return a clone of the matrix.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ equal(mat)                            │ Return    the    result   of   matrix │
                      │                                       │ comparison.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorCholesky(isperm[, options])     │ Perform    an    in-place    Cholesky │
                      │                                       │ factorization.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorICC(isperm[, options])          │ Perform  an  in-place  an  incomplete │
                      │                                       │ Cholesky factorization.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorILU(isrow, iscol[, options])    │ Perform     an      in-place      ILU │
                      │                                       │ factorization.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorLU(isrow, iscol[, options])     │ Perform an in-place LU factorization. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorNumericCholesky(mat[, options]) │ Not implemented.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorNumericLU(mat[, options])       │ Not implemented.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorSymbolicCholesky(isperm[,       │ Not implemented.                      │
                      │ options])                             │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorSymbolicICC(isperm[, options])  │ Not implemented.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorSymbolicILU(isrow,      iscol[, │ Not implemented.                      │
                      │ options])                             │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ factorSymbolicLU(mat, isrow,  iscol[, │ Not implemented.                      │
                      │ options])                             │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ findZeroRows()                        │ Return the index set of empty rows.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ fixISLocalEmpty([fix])                │ Compress out zero local rows from the │
                      │                                       │ local matrices.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBlockSize()                        │ Return the matrix block size.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBlockSizes()                       │ Return   the  row  and  column  block │
                      │                                       │ sizes.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getColumnIJ([symmetric, compressed])  │ Return the CSC representation of  the │
                      │                                       │ local sparsity pattern.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getColumnVector(column[, result])     │ Return  the columnᵗʰ column vector of │
                      │                                       │ the matrix.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDM()                               │ Return  the  DM  defining  the   data │
                      │                                       │ layout of the matrix.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDenseArray([readonly])             │ Return  the  array  where the data is │
                      │                                       │ stored.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDenseColumnVec(i[, mode])          │ Return the iᵗʰ column vector  of  the │
                      │                                       │ dense matrix.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDenseLDA()                         │ Return  the  leading dimension of the │
                      │                                       │ array used by the dense matrix.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDenseLocalMatrix()                 │ Return the local part  of  the  dense │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDiagonal([result])                 │ Return the diagonal of the matrix.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDiagonalBlock()                    │ Return   the   part   of  the  matrix │
                      │                                       │ associated   with   the    on-process │
                      │                                       │ coupling.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getISAllowRepeated()                  │ Get  the flag for repeated entries in │
                      │                                       │ the local to global map.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getISLocalMat()                       │ Return the local matrix stored inside │
                      │                                       │ a Type.IS matrix.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getInertia()                          │ Return the inertia  from  a  factored │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getInfo([info])                       │ Return summary information.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLGMap()                            │ Return the local-to-global mappings.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLRCMats()                          │ Return the constituents of a Type.LRC │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalSize()                        │ Return  the  local number of rows and │
                      │                                       │ columns.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalSubMatrix(isrow,      iscol[, │ Return  a  reference  to  a submatrix │
                      │ submat])                              │ specified in local numbering.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMumpsCntl(icntl)                   │ Return    the    MUMPS     parameter, │
                      │                                       │ CNTL[icntl].                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMumpsIcntl(icntl)                  │ Return     the    MUMPS    parameter, │
                      │                                       │ ICNTL[icntl].                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMumpsInfo(icntl)                   │ Return    the    MUMPS     parameter, │
                      │                                       │ INFO[icntl].                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMumpsInfog(icntl)                  │ Return     the    MUMPS    parameter, │
                      │                                       │ INFOG[icntl].                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMumpsRinfo(icntl)                  │ Return    the    MUMPS     parameter, │
                      │                                       │ RINFO[icntl].                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMumpsRinfog(icntl)                 │ Return     the    MUMPS    parameter, │
                      │                                       │ RINFOG[icntl].                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNearNullSpace()                    │ Return the near-nullspace.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNestISs()                          │ Return the  index  sets  representing │
                      │                                       │ the row and column spaces.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNestLocalISs()                     │ Return    the    local   index   sets │
                      │                                       │ representing  the  row   and   column │
                      │                                       │ spaces.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNestSize()                         │ Return the number of rows and columns │
                      │                                       │ of the matrix.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNestSubMatrix(i, j)                │ Return a single submatrix.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNullSpace()                        │ Return the nullspace.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOption(option)                     │ Return the option value.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOptionsPrefix()                    │ Return  the prefix used for searching │
                      │                                       │ for options in the database.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOrdering(ord_type)                 │ Return a reordering for a  matrix  to │
                      │                                       │ improve a LU factorization.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipIS()                      │ Return the ranges of rows and columns │
                      │                                       │ owned by each process as index sets.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipRange()                   │ Return  the  locally  owned  range of │
                      │                                       │ rows.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipRangeColumn()             │ Return the  locally  owned  range  of │
                      │                                       │ columns.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipRanges()                  │ Return  the  range  of  rows owned by │
                      │                                       │ each process.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipRangesColumn()            │ Return the range of columns owned  by │
                      │                                       │ each process.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPythonContext()                    │ Return  the  instance  of  the  class │
                      │                                       │ implementing  the   required   Python │
                      │                                       │ methods.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPythonType()                       │ Return  the  fully  qualified  Python │
                      │                                       │ name of the class used by the matrix. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRedundantMatrix(nsubcomm[,         │ Return    redundant    matrices    on │
                      │ subcomm, out])                        │ subcommunicators.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRow(row)                           │ Return  the column indices and values │
                      │                                       │ for the requested row.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRowIJ([symmetric, compressed])     │ Return the CSR representation of  the │
                      │                                       │ local sparsity pattern.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRowSum([result])                   │ Return the row-sum vector.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSchurComplementSubMatrices()       │ Return Schur complement sub-matrices. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSize()                             │ Return  the global number of rows and │
                      │                                       │ columns.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSizes()                            │ Return the tuple of matrix layouts.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTransposeNullSpace()               │ Return the transpose nullspace.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the type of the matrix.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getValue(row, col)                    │ Return the value in  the  (row,  col) │
                      │                                       │ position.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getValues(rows, cols[, values])       │ Return  the  values  in the zip(rows, │
                      │                                       │ cols) positions.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getValuesCSR()                        │ Return the CSR representation of  the │
                      │                                       │ local part of the matrix.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getVecType()                          │ Return  the  vector  type used by the │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ hermitianTranspose([out])             │ Return   the   transposed   Hermitian │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ imagPart([out])                       │ Return  the  imaginary  part  of  the │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ increaseOverlap(iset[, overlap])      │ Increase the overlap of a index set.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ invertBlockDiagonal()                 │ Return    the    inverse    of    the │
                      │                                       │ block-diagonal entries.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isAssembled()                         │ The  boolean  flag  indicating if the │
                      │                                       │ matrix is assembled.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isHermitian([tol])                    │ Return the boolean indicating if  the │
                      │                                       │ matrix is Hermitian.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isHermitianKnown()                    │ Return  the 2-tuple indicating if the │
                      │                                       │ matrix is known to be Hermitian.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isStructurallySymmetric()             │ Return the boolean indicating if  the │
                      │                                       │ matrix is structurally symmetric.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isSymmetric([tol])                    │ Return  the boolean indicating if the │
                      │                                       │ matrix is symmetric.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isSymmetricKnown()                    │ Return the 2-tuple indicating if  the │
                      │                                       │ matrix is known to be symmetric.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isTranspose([mat, tol])               │ Return    the    result   of   matrix │
                      │                                       │ comparison with transposition.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ kron(mat[, result])                   │ Compute C, the Kronecker product of A │
                      │                                       │ and B.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ load(viewer)                          │ Load a matrix.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ matMatMult(B, C[, result, fill])      │ Perform          matrix-matrix-matrix │
                      │                                       │ multiplication D=ABC.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ matMult(mat[, result, fill])          │ Perform  matrix-matrix multiplication │
                      │                                       │ C=AB.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ matSolve(B, X)                        │ Solve AX=B, given a  factored  matrix │
                      │                                       │ A.                                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ matTransposeMult(mat[, result, fill]) │ Perform  matrix-matrix multiplication │
                      │                                       │ C=ABᵀ.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ mult(x, y)                            │ Perform the matrix vector product y = │
                      │                                       │ A @ x.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ multAdd(x, v, y)                      │ Perform  the  matrix  vector  product │
                      │                                       │ with addition y = A @ x + v.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ multHermitian(x, y)                   │ Perform  the  Hermitian matrix vector │
                      │                                       │ product y = A^H @ x.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ multHermitianAdd(x, v, y)             │ Perform the Hermitian  matrix  vector │
                      │                                       │ product  with  addition y = A^H @ x + │
                      │                                       │ v.                                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ multTranspose(x, y)                   │ Perform the transposed matrix  vector │
                      │                                       │ product y = A^T @ x.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ multTransposeAdd(x, v, y)             │ Perform  the transposed matrix vector │
                      │                                       │ product with addition y = A^T @  x  + │
                      │                                       │ v.                                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ norm([norm_type])                     │ Compute the requested matrix norm.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ permute(row, col)                     │ Return the permuted matrix.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ preallocatorPreallocate(A[, fill])    │ Preallocate memory for a matrix using │
                      │                                       │ a preallocator matrix.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ ptap(P[, result, fill])               │ Creates the matrix product C = PᵀAP.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ rart(R[, result, fill])               │ Create the matrix product C = RARᵀ.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ realPart([out])                       │ Return the real part of the matrix.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reorderForNonzeroDiagonal(isrow,      │ Change  a  matrix  ordering to remove │
                      │ iscol[, atol])                        │ zeros from the diagonal.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreDenseColumnVec(i[, mode])      │ Restore the iᵗʰ column vector of  the │
                      │                                       │ dense matrix.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreISLocalMat(local)              │ Restore  the  local  matrix  obtained │
                      │                                       │ with getISLocalMat.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreLocalSubMatrix(isrow,   iscol, │ Restore  a  reference  to a submatrix │
                      │ submat)                               │ obtained with getLocalSubMatrix.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ retrieveValues()                      │ Retrieve a copy of the matrix  values │
                      │                                       │ previously stored with storeValues.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ scale(alpha)                          │ Scale the matrix.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBlockSize(bsize)                   │ Set  the  matrix block size (same for │
                      │                                       │ rows and columns).                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBlockSizes(row_bsize, col_bsize)   │ Set the row and column block sizes.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDM(dm)                             │ Set the DM defining the  data  layout │
                      │                                       │ of the matrix.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDenseLDA(lda)                      │ Set  the  leading  dimension  of  the │
                      │                                       │ array used by the dense matrix.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDiagonal(diag[, addv])             │ Set  the  diagonal  values   of   the │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Configure the matrix from the options │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setISAllowRepeated([allow])           │ Allow  repeated  entries in the local │
                      │                                       │ to global map.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setISLocalMat(local)                  │ Set the local matrix stored inside  a │
                      │                                       │ Type.IS.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setISPreallocation(nnz, onnz)         │ Preallocate   memory  for  a  Type.IS │
                      │                                       │ parallel matrix.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLGMap(rmap[, cmap])                │ Set the local-to-global mappings.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLRCMats(A, U[, c, V])              │ Set the constituents  of  a  Type.LRC │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMumpsCntl(icntl, val)              │ Set  a MUMPS parameter, CNTL[icntl]= │
                      │                                       │ val.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMumpsIcntl(icntl, ival)            │ Set a MUMPS parameter, ICNTL[icntl]= │
                      │                                       │ ival.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNearNullSpace(nsp)                 │ Set the near-nullspace.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNestVecType(vec_type)              │ Set the vector type for  a  Type.NEST │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNullSpace(nsp)                     │ Set the nullspace.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOption(option, flag)               │ Set option.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOptionsPrefix([prefix])            │ Set the prefix used for searching for │
                      │                                       │ options in the database.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPreallocationCSR(csr)              │ Preallocate  memory  for  the  matrix │
                      │                                       │ with a CSR layout.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPreallocationDense(array)          │ Set the array used for storing matrix │
                      │                                       │ elements for a dense matrix.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPreallocationNNZ(nnz)              │ Preallocate  memory  for  the  matrix │
                      │                                       │ with a non-zero pattern.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPythonContext(context)             │ Set   the   instance   of  the  class │
                      │                                       │ implementing  the   required   Python │
                      │                                       │ methods.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPythonType(py_type)                │ Set  the  fully qualified Python name │
                      │                                       │ of the class to be used.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRandom([random])                   │ Set random values in the matrix.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSizes(size[, bsize])               │ Set  the  local,  global  and   block │
                      │                                       │ sizes.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStencil(dims[, starts, dof])       │ Set matrix stencil.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTransposeNullSpace(nsp)            │ Set the transpose nullspace.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTransposePrecursor(out)            │ Set transpose precursor.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(mat_type)                     │ Set the matrix type.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUnfactored()                       │ Set  a  factored matrix to be treated │
                      │                                       │ as unfactored.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Set up the internal  data  structures │
                      │                                       │ for using the matrix.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValue(row, col, value[, addv])     │ Set  a  value to the (row,col) entry │
                      │                                       │ of the matrix.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValueBlockedStagStencil(row,  col, │ Not implemented.                      │
                      │ value)                                │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValueBlockedStencil(row,      col, │ Set a block of values to row and  col │
                      │ value[, addv])                        │ stencil.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValueLocal(row,    col,    value[, │ Set a value to the (row,col)  entry │
                      │ addv])                                │ of the matrix in local ordering.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValueStagStencil(row, col, value[, │ Not implemented.                      │
                      │ addv])                                │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValueStencil(row,   col,   value[, │ Set a value to row and col stencil.   │
                      │ addv])                                │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValues(rows, cols, values[, addv]) │ Set values to the rows ⊗ cols entries │
                      │                                       │ of the matrix.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlocked(rows, cols, values[, │ Set values to the rows  ⊗  col  block │
                      │ addv])                                │ entries of the matrix.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlockedCSR(I, J, V[, addv])  │ Set   values   stored  in  block  CSR │
                      │                                       │ format.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlockedIJV(I, J,  V[,  addv, │ Set  a  subset  of  values  stored in │
                      │ rowmap])                              │ block CSR format.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlockedLocal(rows,     cols, │ Set  values  to  the rows ⊗ col block │
                      │ values[, addv])                       │ entries  of  the  matrix   in   local │
                      │                                       │ ordering.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlockedLocalCSR(I,   J,  V[, │ Set  values  stored  in   block   CSR │
                      │ addv])                                │ format.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlockedLocalIJV(I,   J,  V[, │ Set a  subset  of  values  stored  in │
                      │ addv, rowmap])                        │ block CSR format.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlockedLocalRCV(R,   C,  V[, │ Undocumented.                         │
                      │ addv])                                │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlockedRCV(R, C, V[, addv])  │ Undocumented.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesCSR(I, J, V[, addv])         │ Set values stored in CSR format.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesIJV(I, J, V[, addv, rowmap]) │ Set a subset of values stored in  CSR │
                      │                                       │ format.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesLocal(rows,  cols,  values[, │ Set values to the rows ⊗ col  entries │
                      │ addv])                                │ of the matrix in local ordering.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesLocalCSR(I, J, V[, addv])    │ Set values stored in CSR format.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesLocalIJV(I,   J,  V[,  addv, │ Set a subset of values stored in  CSR │
                      │ rowmap])                              │ format.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesLocalRCV(R, C, V[, addv])    │ Undocumented.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesRCV(R, C, V[, addv])         │ Undocumented.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setVariableBlockSizes(blocks)         │ Set   diagonal  point-blocks  of  the │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setVecType(vec_type)                  │ Set the vector type.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ shift(alpha)                          │ Shift the matrix.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solve(b, x)                           │ Solve Ax=b, given a factored matrix.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solveAdd(b, y, x)                     │ Solve  x=y+A⁻¹b,  given  a   factored │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solveBackward(b, x)                   │ Solve  Ux=b,  given a factored matrix │
                      │                                       │ A=LU.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solveForward(b, x)                    │ Solve Lx = b, given a factored matrix │
                      │                                       │ A = LU.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solveTranspose(b, x)                  │ Solve Aᵀx=b, given a factored matrix. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solveTransposeAdd(b, y, x)            │ Solve  x=y+A⁻ᵀb,  given  a   factored │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ storeValues()                         │ Stash a copy of the matrix values.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ toDLPack([mode])                      │ Return  a  DLPack  PyCapsule wrapping │
                      │                                       │ the vector data.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ transpose([out])                      │ Return the transposed matrix.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ transposeMatMult(mat[, result, fill]) │ Perform matrix-matrix  multiplication │
                      │                                       │ C=AᵀB.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View the matrix.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ zeroEntries()                         │ Zero the entries of the matrix.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ zeroRows(rows[, diag, x, b])          │ Zero selected rows of the matrix.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ zeroRowsColumns(rows[, diag, x, b])   │ Zero selected rows and columns of the │
                      │                                       │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ zeroRowsColumnsLocal(rows[,  diag, x, │ Zero selected rows and columns of the │
                      │ b])                                   │ matrix in local ordering.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ zeroRowsColumnsStencil(rows[,   diag, │ Zero selected rows and columns of the │
                      │ x, b])                                │ matrix.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ zeroRowsLocal(rows[, diag, x, b])     │ Zero  selected  rows of the matrix in │
                      │                                       │ local ordering.                       │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                  ┌──────────────┬───────────────────────────────────────┐
                                  │ assembled    │ The boolean flag  indicating  if  the │
                                  │              │ matrix is assembled.                  │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ block_size   │ Matrix block size.                    │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ block_sizes  │ Matrix row and column block sizes.    │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ hermitian    │ The  boolean  flag  indicating if the │
                                  │              │ matrix is Hermitian.                  │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ local_size   │ Matrix local size.                    │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ owner_range  │ Matrix local row range.               │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ owner_ranges │ Matrix row ranges.                    │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ size         │ Matrix global size.                   │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ sizes        │ Matrix local and global sizes.        │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ structsymm   │ The boolean flag  indicating  if  the │
                                  │              │ matrix is structurally symmetric.     │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ symmetric    │ The  boolean  flag  indicating if the │
                                  │              │ matrix is symmetric.                  │
                                  └──────────────┴───────────────────────────────────────┘

              Methods Documentation

              H2OpusCompress(tol)
                     Compress a hierarchical matrix.

                     Collective.

                     Parameterstol (float) -- The absolute truncation threshold.

                     ReturntypeSelfSEEALSO:MatH2OpusCompressSourcecodeatpetsc4py/PETSc/Mat.pyx:4992H2OpusLowRankUpdate(U,V=None,s=1.0)
                     Perform a low-rank update of the form self += sUVᵀ.

                     Collective.

                     Parameters

                            • U (Mat) -- The dense low-rank update matrix.

                            • V (Mat|None) -- The dense low-rank update matrix. If None, V=U.

                            • s (float) -- The scaling factor.

                     ReturntypeSelfSEEALSO:MatH2OpusLowRankUpdateSourcecodeatpetsc4py/PETSc/Mat.pyx:5011H2OpusOrthogonalize()
                     Orthogonalize the basis tree of a hierarchical matrix.

                     Collective.

                     SEEALSO:MatH2OpusOrthogonalizeSourcecodeatpetsc4py/PETSc/Mat.pyx:4979ReturntypeSelfSOR(b,x,omega=1.0,sortype=None,shift=0.0,its=1,lits=1)
                     Compute relaxation (SOR, Gauss-Seidel) sweeps.

                     Neighborwise collective.

                     SEEALSO:MatSORSourcecodeatpetsc4py/PETSc/Mat.pyx:3825Parameters

                            • b (Vec)

                            • x (Vec)

                            • omega (float)

                            • sortype (SORType|None)

                            • shift (float)

                            • its (int)

                            • lits (int)

                     ReturntypeNoneappendOptionsPrefix(prefix=None)
                     Append to the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, MatAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/Mat.pyx:1751Parametersprefix (str|None)

                     ReturntypeNoneassemble(assembly=None)
                     Assemble the matrix.

                     Collective.

                     Parametersassembly (MatAssemblySpec) -- The assembly type.

                     ReturntypeNoneSEEALSO:assemblyBegin, assemblyEndSourcecodeatpetsc4py/PETSc/Mat.pyx:3338assemblyBegin(assembly=None)
                     Begin an assembling stage of the matrix.

                     Collective.

                     Parametersassembly (MatAssemblySpec) -- The assembly type.

                     ReturntypeNoneSEEALSO:assemblyEnd, assemble, MatAssemblyBeginSourcecodeatpetsc4py/PETSc/Mat.pyx:3302assemblyEnd(assembly=None)
                     Complete an assembling stage of the matrix initiated with assemblyBegin.

                     Collective.

                     Parametersassembly (MatAssemblySpec) -- The assembly type.

                     ReturntypeNoneSEEALSO:assemblyBegin, assemble, MatAssemblyEndSourcecodeatpetsc4py/PETSc/Mat.pyx:3320axpy(alpha,X,structure=None)
                     Perform the matrix summation self + = ɑ·X.

                     Collective.

                     Parameters

                            • alpha (Scalar) -- The scalar.

                            • X (Mat) -- The matrix to be added.

                            • structure (Structure) -- The structure of the operation.

                     ReturntypeNoneSEEALSO:MatAXPYSourcecodeatpetsc4py/PETSc/Mat.pyx:4153aypx(alpha,X,structure=None)
                     Perform the matrix summation self = ɑ·self + X.

                     Collective.

                     Parameters

                            • alpha (Scalar) -- The scalar.

                            • X (Mat) -- The matrix to be added.

                            • structure (Structure) -- The structure of the operation.

                     ReturntypeNoneSEEALSO:MatAYPXSourcecodeatpetsc4py/PETSc/Mat.pyx:4176bindToCPU(flg)
                     Mark a matrix to temporarily stay on the CPU.

                     Collective.

                     Once marked, perform computations on the CPU.

                     Parametersflg (bool) -- Bind to the CPU if True.

                     ReturntypeNoneSEEALSO:MatBindToCPUSourcecodeatpetsc4py/PETSc/Mat.pyx:4520boundToCPU()
                     Query if a matrix is bound to the CPU.

                     Not collective.

                     SEEALSO:MatBoundToCPUSourcecodeatpetsc4py/PETSc/Mat.pyx:4540Returntypeboolchop(tol)
                     Set entries smallest of tol (in absolute values) to zero.

                     Collective.

                     SEEALSO:MatFilterSourcecodeatpetsc4py/PETSc/Mat.pyx:4121Parameterstol (float)

                     ReturntypeNoneconjugate(out=None)
                     Return the conjugate matrix.

                     Collective.

                     Parametersout (Mat|None) -- Optional return matrix. If  None,  the  operation  is  performed
                            in-place.  Otherwise, the operation is performed on out.

                     ReturntypeMatSEEALSO:realPart, imagPart, MatConjugateSourcecodeatpetsc4py/PETSc/Mat.pyx:2215convert(mat_type=None,out=None)
                     Convert the matrix type.

                     Collective.

                     Parameters

                            • mat_type (Type|str) -- The type of the new matrix. If None uses Type.SAME.

                            • out  (Mat|None)  --  Optional  return  matrix.  If None, inplace conversion is
                              performed.  Otherwise, the matrix is reused.

                     ReturntypeMatSEEALSO:MatConvertSourcecodeatpetsc4py/PETSc/Mat.pyx:2071copy(result=None,structure=None)
                     Return a copy of the matrix.

                     Collective.

                     Parameters

                            • result (Mat|None) -- Optional return matrix. If None, it is internally created.

                            • structure (Structure|None) -- The copy structure. Only relevant if result is not
                              None.

                     ReturntypeMatSEEALSO:MatCopy, MatDuplicateSourcecodeatpetsc4py/PETSc/Mat.pyx:2026create(comm=None)
                     Create the matrix.

                     Collective.

                     Once created, the user should call setType  or  setFromOptions  before  using  the  matrix.
                     Alternatively, specific creation routines such as createAIJ or createBAIJ can be used.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:destroy, MatCreateSourcecodeatpetsc4py/PETSc/Mat.pyx:488createAIJ(size,bsize=None,nnz=None,csr=None,comm=None)
                     Create a sparse Type.AIJ matrix, optionally preallocating.

                     Collective.

                     To  preallocate  the matrix the user can either pass nnz or csr describing the sparsity. If
                     neither is set then preallocation will  not  occur.  Consult  the  PETScmanual  for  more
                     information.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • bsize  (MatBlockSizeSpec|None) -- Matrix block size. If None, a block size of 1
                              is set.

                            • nnz (NNZSpec|None) -- Optional non-zeros preallocation pattern.

                            • csr (CSRIndicesSpec|None) -- Optional compressed sparse row layout  information.
                              If provided, it takes precedence on nnz.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:setSizes,     createBAIJ,     MATAIJ,     MATSEQAIJ,    MATMPIAIJ,    MatCreateAIJ,    ‐
                        MatSeqAIJSetPreallocation, MatSeqAIJSetPreallocationCSRSourcecodeatpetsc4py/PETSc/Mat.pyx:693createAIJCRL(size,bsize=None,nnz=None,csr=None,comm=None)
                     Create a sparse Type.AIJCRL matrix.

                     Collective.

                     This is similar to Type.AIJ matrices but stores some additional information  that  improves
                     vectorization for the matrix-vector product.

                     To  preallocate  the matrix the user can either pass nnz or csr describing the sparsity. If
                     neither is set then preallocation will  not  occur.  Consult  the  PETScmanual  for  more
                     information.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • bsize  (MatBlockSizeSpec|None) -- Matrix block size. If None, a block size of 1
                              is set.

                            • nnz (NNZSpec|None) -- Optional non-zeros preallocation pattern.

                            • csr (CSRIndicesSpec|None) -- Optional compressed sparse row layout  information.
                              If provided, it takes precedence on nnz.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:createAIJ, createBAIJ, MatCreateSeqAIJCRL, MatCreateMPIAIJCRLSourcecodeatpetsc4py/PETSc/Mat.pyx:826createAIJWithArrays(size,csr,bsize=None,comm=None)
                     Create a sparse Type.AIJ matrix with data in CSR format.

                     Collective.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • csr  (CSRSpec|tuple[CSRSpec,CSRSpec]) -- Local matrix data in compressed sparse
                              row format.

                            • bsize (MatBlockSizeSpec|None) -- Matrix block size. If None, a block size  of  1
                              is set.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     Notes

                     For  Type.SEQAIJ  matrices,  the csr data is not copied.  For Type.MPIAIJ matrices, the csr
                     data is not copied only in the case it represents on-process and off-process information.

                     SEEALSO:createAIJ,        MatCreateSeqAIJWithArrays,        MatCreateMPIAIJWithArrays,         ‐
                        MatCreateMPIAIJWithSplitArraysSourcecodeatpetsc4py/PETSc/Mat.pyx:956createBAIJ(size,bsize,nnz=None,csr=None,comm=None)
                     Create a sparse blocked Type.BAIJ matrix, optionally preallocating.

                     Collective.

                     To  preallocate  the matrix the user can either pass nnz or csr describing the sparsity. If
                     neither is set then preallocation will  not  occur.  Consult  the  PETScmanual  for  more
                     information.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • bsize (MatBlockSizeSpec) -- Matrix block size.

                            • nnz (NNZSpec|None) -- Optional non-zeros preallocation pattern for block rows.

                            • csr  (CSRIndicesSpec|None)  --  Optional  block-compressed  sparse  row layout
                              information.  If provided, it takes precedence on nnz.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:setSizes, createAIJ, MATBAIJ, MATSEQBAIJ, MATMPIBAIJ, MatCreateBAIJSourcecodeatpetsc4py/PETSc/Mat.pyx:738createConstantDiagonal(size,diag,comm=None)
                     Create a diagonal matrix of type Type.CONSTANTDIAGONAL.

                     Collective.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • diag (float) -- The diagonal value.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:createDiagonalSourcecodeatpetsc4py/PETSc/Mat.pyx:1561createDense(size,bsize=None,array=None,comm=None)
                     Create a Type.DENSE matrix.

                     Collective.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • bsize (MatBlockSizeSpec|None) -- Matrix block size. If None, a block size  of  1
                              is set.

                            • array  (Sequence[Scalar]|None)  --  Optional  matrix  data. If None, memory is
                              internally allocated.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:createDenseCUDA, MATDENSE, MatCreateDenseSourcecodeatpetsc4py/PETSc/Mat.pyx:1047createDenseCUDA(size,bsize=None,array=None,cudahandle=None,comm=None)
                     Create a Type.DENSECUDA matrix with optional host and device data.

                     Collective.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • bsize (MatBlockSizeSpec|None) -- Matrix block size. If None, a block size  of  1
                              is set.

                            • array (Sequence[Scalar]|None) -- Host data. Will be lazily allocated if None.

                            • cudahandle  (int|None)  --  Address  of  the  array on the GPU. Will be lazily
                              allocated if None. If cudahandle is provided, array will be ignored.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:createDense, MatCreateDenseCUDASourcecodeatpetsc4py/PETSc/Mat.pyx:1083createDiagonal(diag)
                     Create a diagonal matrix of type Type.DIAGONAL.

                     Collective.

                     Parametersdiag (Vec) -- The vector holding diagonal values.

                     ReturntypeSelfSEEALSO:createConstantDiagonalSourcecodeatpetsc4py/PETSc/Mat.pyx:1594createH2OpusFromMat(A,coordinates=None,dist=None,eta=None,leafsize=None,maxrank=None,bs=None,rtol=None)
                     Create a hierarchical Type.H2OPUS matrix sampling from a provided operator.

                     Collective.

                     Parameters

                            • A (Mat) -- Matrix to be sampled.

                            • coordinates (Sequence[Scalar]|None) -- Coordinates of the points.

                            • dist (bool|None) -- Whether or not coordinates are distributed,  defaults  to  ‐
                              False.

                            • eta (float|None) -- Admissibility condition tolerance, defaults to DECIDE.

                            • leafsize (int|None) -- Leaf size in cluster tree, defaults to DECIDE.

                            • maxrank (int|None) -- Maximum rank permitted, defaults to DECIDE.

                            • bs  (int|None)  -- Maximum number of samples to take concurrently, defaults to
                              DECIDE.

                            • rtol (float|None) -- Relative tolerance for construction, defaults to DECIDE.

                     ReturntypeSelf

                     Notes

                     See MatCreateH2OpusFromMat for the appropriate database options.

                     SEEALSO:WorkingwithPETScoptions, MatCreateH2OpusFromMatSourcecodeatpetsc4py/PETSc/Mat.pyx:1427createHermitianTranspose(mat)
                     Create a Type.HERMITIANTRANSPOSE matrix that behaves like (A*)ᵀ.

                     Collective.

                     Parametersmat (Mat) -- Matrix A to represent the hermitian transpose of.

                     ReturntypeSelf

                     Notes

                     The Hermitian transpose is never actually formed.

                     SEEALSO:createNormal,       createNormalHermitian,        MATHERMITIANTRANSPOSEVIRTUAL,        ‐
                        MatCreateHermitianTransposeSourcecodeatpetsc4py/PETSc/Mat.pyx:1263createIS(size,bsize=None,lgmapr=None,lgmapc=None,comm=None)
                     Create a Type.IS matrix representing globally unassembled operators.

                     Collective.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • bsize  (MatBlockSizeSpec|None) -- Matrix block size. If None, a block size of 1
                              is set.

                            • lgmapr (LGMap|None) -- Optional local-to-global mapping for the rows.  If  None,
                              the local row space matches the global row space.

                            • lgmapc  (LGMap|None) -- Optional local-to-global mapping for the columns.  If ‐
                              None, the local column space matches the global column space.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:MATISSourcecodeatpetsc4py/PETSc/Mat.pyx:1508createLRC(A,U,c,V)
                     Create a low-rank correction Type.LRC matrix representing A + UCVᵀ.

                     Collective.

                     Parameters

                            • A (Mat) -- Sparse matrix, can be None.

                            • U (Mat) -- Dense rectangular matrices.

                            • V (Mat) -- Dense rectangular matrices.

                            • c (Vec) -- Vector containing the diagonal of C, can be None.

                     ReturntypeSelf

                     Notes

                     The matrix A + UCVᵀ is never actually formed.

                     C is a diagonal matrix (represented as a vector) of order k,  where  k  is  the  number  of
                     columns of both U and V.

                     If A is None then the new object behaves like a low-rank matrix UCVᵀ.

                     Use the same matrix for V and U (or V=None) for a symmetric low-rank correction, A + UCUᵀ.

                     If  c  is  None then the low-rank correction is just U*Vᵀ. If a sequential c vector is used
                     for a parallel matrix, PETSc assumes that the values of the  vector  are  consistently  set
                     across processors.

                     SEEALSO:MATLRC, MatCreateLRCSourcecodeatpetsc4py/PETSc/Mat.pyx:1288createNest(mats,isrows=None,iscols=None,comm=None)
                     Create a Type.NEST matrix containing multiple submatrices.

                     Collective.

                     Parameters

                            • mats  (Sequence[Sequence[Mat]])  --  Iterable  of  matrix  block  rows  with  size
                              len(isrows).   Each  matrix  block  row  must  be  of  size  len(iscols).    Empty
                              submatrices can be set with None.

                            • isrows  (Sequence[IS]|None) -- Index set for each nested row block, defaults to
                              contiguous ordering.

                            • iscols (Sequence[IS]|None) -- Index set for each nested column  block,  defaults
                              to contiguous ordering.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:MatCreateNest, MATNESTSourcecodeatpetsc4py/PETSc/Mat.pyx:1360createNormal(mat)
                     Create a Type.NORMAL matrix representing AᵀA.

                     Collective.

                     Parametersmat (Mat) -- The (possibly rectangular) matrix A.

                     ReturntypeSelf

                     Notes

                     The product AᵀA is never actually formed. Instead A and Aᵀ are used during mult and various
                     other matrix operations.

                     SEEALSO:MATNORMAL, MatCreateNormalSourcecodeatpetsc4py/PETSc/Mat.pyx:1188createNormalHermitian(mat)
                     Create a Type.NORMALHERMITIAN matrix representing (A*)ᵀA.

                     Collective.

                     Parametersmat (Mat) -- The (possibly rectangular) matrix A.

                     ReturntypeSelf

                     Notes

                     The product (A*)ᵀA is never actually formed.

                     SEEALSO:createHermitianTranspose, MATNORMAL, MATNORMALHERMITIAN, MatCreateNormalHermitianSourcecodeatpetsc4py/PETSc/Mat.pyx:1238createPython(size,context=None,comm=None)
                     Create a Type.PYTHON matrix.

                     Collective.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • context  (Any)  --  An  instance  of  the  Python  class implementing the required
                              methods.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PETScPythonmatrixtype, setType, setPythonContext, Type.PYTHONSourcecodeatpetsc4py/PETSc/Mat.pyx:1617createSBAIJ(size,bsize,nnz=None,csr=None,comm=None)
                     Create a sparse Type.SBAIJ matrix in symmetric block format.

                     Collective.

                     To preallocate the matrix the user can either pass nnz or csr describing the  sparsity.  If
                     neither  is  set  then  preallocation  will  not  occur.  Consult the PETScmanual for more
                     information.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • bsize (MatBlockSizeSpec) -- Matrix block size.

                            • nnz (NNZSpec|None) -- Optional upper-triangular (including  diagonal)  non-zeros
                              preallocation pattern for block rows.

                            • csr  (CSRIndicesSpec|None)  --  Optional  block-compressed  sparse  row layout
                              information.  If provided, it takes precedence on nnz.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:createAIJ, createBAIJ, MatCreateSBAIJSourcecodeatpetsc4py/PETSc/Mat.pyx:782createScatter(scatter,comm=None)
                     Create a Type.SCATTER matrix from a vector scatter.

                     Collective.

                     Parameters

                            • scatter (Scatter) -- Vector scatter.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:MATSCATTER, MatCreateScatterSourcecodeatpetsc4py/PETSc/Mat.pyx:1164createSchurComplement(A00,Ap00,A01,A10,A11=None)
                     Create a Type.SCHURCOMPLEMENT matrix.

                     Collective.

                     Parameters

                            • A00 (Mat) -- the upper-left block of the original matrix A = [A00 A01; A10 A11].

                            • Ap00 (Mat) -- preconditioning matrix for use in ksp(A00,Ap00) to  approximate  the
                              action of A00^{-1}.

                            • A01 (Mat) -- the upper-right block of the original matrix A = [A00 A01; A10 A11].

                            • A10 (Mat) -- the lower-left block of the original matrix A = [A00 A01; A10 A11].

                            • A11  (Mat|None)  -- Optional lower-right block of the original matrix A = [A00
                              A01; A10 A11].

                     ReturntypeSelfSEEALSO:MatCreateSchurComplementSourcecodeatpetsc4py/PETSc/Mat.pyx:3969createSubMatrices(isrows,iscols=None,submats=None)
                     Return several sequential submatrices.

                     Collective.

                     Parameters

                            • isrows (IS|Sequence[IS]) -- Row index sets.

                            • iscols (IS|Sequence[IS]) -- Column index sets. If None, iscols=isrows.

                            • submats (Mat|Sequence[Mat]) -- Optional  resultant  matrices.   When  None,  new
                              matrices are created, and MAT_INITIAL_MATRIX is used.  When not None, the matrices
                              are reused with MAT_REUSE_MATRIX.

                     ReturntypeSequence[Mat]

                     SEEALSO:MatCreateSubMatricesSourcecodeatpetsc4py/PETSc/Mat.pyx:3912createSubMatrix(isrow,iscol=None,submat=None)
                     Return a submatrix.

                     Collective.

                     Parameters

                            • isrow (IS) -- Row index set.

                            • iscol (IS|None) -- Column index set. If None, iscol=isrow.

                            • submat  (Mat|None)  --  Optional resultant matrix.  When None, a new matrix is
                              created, and MAT_INITIAL_MATRIX is used.  When not None, the matrix is reused with
                              MAT_REUSE_MATRIX.

                     ReturntypeMatSEEALSO:MatCreateSubMatrixSourcecodeatpetsc4py/PETSc/Mat.pyx:3882createSubMatrixVirtual(A,isrow,iscol=None)
                     Create a Type.SUBMATRIX matrix that acts as a submatrix.

                     Collective.

                     Parameters

                            • A (Mat) -- Matrix to extract submatrix from.

                            • isrow (IS) -- Rows present in the submatrix.

                            • iscol (IS|None) -- Columns present in the submatrix, defaults to isrow.

                     ReturntypeSelfSEEALSO:MatCreateSubMatrixVirtualSourcecodeatpetsc4py/PETSc/Mat.pyx:1335createTranspose(mat)
                     Create a Type.TRANSPOSE matrix that behaves like Aᵀ.

                     Collective.

                     Parametersmat (Mat) -- Matrix A to represent the transpose of.

                     ReturntypeSelf

                     Notes

                     The transpose is never actually  formed.  Instead  multTranspose  is  called  whenever  the
                     matrix-vector product is computed.

                     SEEALSO:createNormal, MatCreateTransposeSourcecodeatpetsc4py/PETSc/Mat.pyx:1213createVecLeft()
                     Return a left vector, a vector that the matrix vector product can be stored in.

                     Collective.

                     SEEALSO:createVecs, createVecRight, MatCreateVecsSourcecodeatpetsc4py/PETSc/Mat.pyx:3438ReturntypeVeccreateVecRight()
                     Return a right vector, a vector that the matrix can be multiplied against.

                     Collective.

                     SEEALSO:createVecs, createVecLeft, MatCreateVecsSourcecodeatpetsc4py/PETSc/Mat.pyx:3424ReturntypeVeccreateVecs(side=None)
                     Return vectors that can be used in matrix vector products.

                     Collective.

                     Parametersside (Literal['r','R','right','Right','RIGHT','l','L','left','Left','LEFT']|None)  --  If None returns a 2-tuple of vectors (right,left).  Otherwise it just
                            return a left or right vector.

                     ReturntypeVec | tuple[Vec, Vec]

                     Notes

                     right vectors are vectors in the column space of the matrix.  left vectors are  vectors  in
                     the row space of the matrix.

                     SEEALSO:createVecLeft, createVecRight, MatCreateVecsSourcecodeatpetsc4py/PETSc/Mat.pyx:3385destroy()
                     Destroy the matrix.

                     Collective.

                     SEEALSO:create, MatDestroySourcecodeatpetsc4py/PETSc/Mat.pyx:475ReturntypeSelfdiagonalScale(L=None,R=None)
                     Perform left and/or right diagonal scaling of the matrix.

                     Collective.

                     Parameters

                            • L (Vec|None) -- Optional left scaling vector.

                            • R (Vec|None) -- Optional right scaling vector.

                     ReturntypeNoneSEEALSO:MatDiagonalScaleSourcecodeatpetsc4py/PETSc/Mat.pyx:3577duplicate(copy=False)
                     Return a clone of the matrix.

                     Collective.

                     Parameterscopy (bool) -- If True, it also copies the values.

                     ReturntypeMatSEEALSO:MatDuplicateSourcecodeatpetsc4py/PETSc/Mat.pyx:2004equal(mat)
                     Return the result of matrix comparison.

                     Collective.

                     SEEALSO:MatEqualSourcecodeatpetsc4py/PETSc/Mat.pyx:2259Parametersmat (Mat)

                     ReturntypeboolfactorCholesky(isperm,options=None)
                     Perform an in-place Cholesky factorization.

                     Collective.

                     Parameters

                            • isperm (IS) -- The row and column permutations.

                            • options  (dict[str,Any]|None)  --  An optional dictionary of options for the
                              factorization. These include fill, the expected fill as a ratio  of  the  original
                              fill.

                     ReturntypeNoneSEEALSO:factorLU, MatCholeskyFactorSourcecodeatpetsc4py/PETSc/Mat.pyx:4684factorICC(isperm,options=None)
                     Perform an in-place an incomplete Cholesky factorization.

                     Collective.

                     Parameters

                            • isperm (IS) -- The row and column permutations

                            • options  (dict[str,Any]|None)  --  An optional dictionary of options for the
                              factorization. These include fill, the expected fill as a ratio  of  the  original
                              fill.

                     ReturntypeNoneSEEALSO:factorILU, MatICCFactorSourcecodeatpetsc4py/PETSc/Mat.pyx:4717factorILU(isrow,iscol,options=None)
                     Perform an in-place ILU factorization.

                     Collective.

                     Parameters

                            • isrow (IS) -- The row permutation.

                            • iscol (IS) -- The column permutation.

                            • options  (dict[str,Any]|None)  --  An optional dictionary of options for the
                              factorization. These include levels, the number  of  levels  of  fill,  fill,  the
                              expected  fill  as  a  ratio  of the original fill, and dtcol, the pivot tolerance
                              where 0 indicates no pivot and 1 indicates full column pivoting.

                     ReturntypeNoneSEEALSO:MatILUFactorSourcecodeatpetsc4py/PETSc/Mat.pyx:4650factorLU(isrow,iscol,options=None)
                     Perform an in-place LU factorization.

                     Collective.

                     Parameters

                            • isrow (IS) -- The row permutation.

                            • iscol (IS) -- The column permutation.

                            • options (dict[str,Any]|None) -- An  optional  dictionary  of  options  for  the
                              factorization.  These  include  fill, the expected fill as a ratio of the original
                              fill and dtcol, the pivot tolerance where 0 indicates no  pivot  and  1  indicates
                              full column pivoting.

                     ReturntypeNoneSEEALSO:MatLUFactorSourcecodeatpetsc4py/PETSc/Mat.pyx:4612factorNumericCholesky(mat,options=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:4713Parametersmat (Mat)

                     ReturntypeNonefactorNumericLU(mat,options=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:4646Parametersmat (Mat)

                     ReturntypeNonefactorSymbolicCholesky(isperm,options=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:4709Parametersisperm (IS)

                     ReturntypeNonefactorSymbolicICC(isperm,options=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:4742Parametersisperm (IS)

                     ReturntypeNonefactorSymbolicILU(isrow,iscol,options=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:4680Parameters

                            • isrow (IS)

                            • iscol (IS)

                     ReturntypeNonefactorSymbolicLU(mat,isrow,iscol,options=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:4642Parameters

                            • mat (Mat)

                            • isrow (IS)

                            • iscol (IS)

                     ReturntypeNonefindZeroRows()
                     Return the index set of empty rows.

                     Collective.

                     SEEALSO:MatFindZeroRowsSourcecodeatpetsc4py/PETSc/Mat.pyx:3371ReturntypeISfixISLocalEmpty(fix=True)
                     Compress out zero local rows from the local matrices.

                     Collective.

                     Parametersfix  (bool)  -- When True, new local matrices and local to global maps are generated
                            during the final assembly process.

                     ReturntypeNoneSEEALSO:MatISFixLocalEmptySourcecodeatpetsc4py/PETSc/Mat.pyx:4817getBlockSize()
                     Return the matrix block size.

                     Not collective.

                     SEEALSO:getBlockSize, MatGetBlockSizeSourcecodeatpetsc4py/PETSc/Mat.pyx:1874ReturntypeintgetBlockSizes()
                     Return the row and column block sizes.

                     Not collective.

                     SEEALSO:getBlockSize, MatGetBlockSizesSourcecodeatpetsc4py/PETSc/Mat.pyx:1888Returntypetuple[int, int]

              getColumnIJ(symmetric=False,compressed=False)
                     Return the CSC representation of the local sparsity pattern.

                     Collective.

                     Parameters

                            • symmetric (bool) -- If True, return the symmetrized graph.

                            • compressed (bool) -- If True, return the compressed graph.

                     Returntypetuple[ArrayInt, ArrayInt]

                     SEEALSO:MatGetRowIJSourcecodeatpetsc4py/PETSc/Mat.pyx:2518getColumnVector(column,result=None)
                     Return the columnᵗʰ column vector of the matrix.

                     Collective.

                     Parameters

                            • column (int) -- Column index.

                            • result (Vec|None) -- Optional vector to store the result.

                     ReturntypeVecSEEALSO:MatGetColumnVectorSourcecodeatpetsc4py/PETSc/Mat.pyx:3458getDM()
                     Return the DM defining the data layout of the matrix.

                     Not collective.

                     SEEALSO:MatGetDMSourcecodeatpetsc4py/PETSc/Mat.pyx:5570ReturntypeDMgetDenseArray(readonly=False)
                     Return the array where the data is stored.

                     Not collective.

                     Parametersreadonly (bool) -- Enable to obtain a read only array.

                     ReturntypeArrayScalarSEEALSO:MatDenseGetArrayRead, MatDenseGetArraySourcecodeatpetsc4py/PETSc/Mat.pyx:5375getDenseColumnVec(i,mode='rw')
                     Return the iᵗʰ column vector of the dense matrix.

                     Collective.

                     Parameters

                            • i (int) -- The column index to access.

                            • mode (AccessModeSpec) -- The access type of the returned array

                     ReturntypeVecSEEALSO:restoreDenseColumnVec,      MatDenseGetColumnVec,      MatDenseGetColumnVecRead,       ‐
                        MatDenseGetColumnVecWriteSourcecodeatpetsc4py/PETSc/Mat.pyx:5428getDenseLDA()
                     Return the leading dimension of the array used by the dense matrix.

                     Not collective.

                     SEEALSO:MatDenseGetLDASourcecodeatpetsc4py/PETSc/Mat.pyx:5361ReturntypeintgetDenseLocalMatrix()
                     Return the local part of the dense matrix.

                     Not collective.

                     SEEALSO:MatDenseGetLocalMatrixSourcecodeatpetsc4py/PETSc/Mat.pyx:5413ReturntypeMatgetDiagonal(result=None)
                     Return the diagonal of the matrix.

                     Collective.

                     Parametersresult (Vec|None) -- Optional vector to store the result.

                     ReturntypeVecSEEALSO:setDiagonal, MatGetDiagonalSourcecodeatpetsc4py/PETSc/Mat.pyx:3513getDiagonalBlock()
                     Return the part of the matrix associated with the on-process coupling.

                     Not collective.

                     SEEALSO:MatGetDiagonalBlockSourcecodeatpetsc4py/PETSc/Mat.pyx:3854ReturntypeMatgetISAllowRepeated()
                     Get the flag for repeated entries in the local to global map.

                     Not collective.

                     SEEALSO:setISAllowRepeated, MatISGetAllowRepeatedSourcecodeatpetsc4py/PETSc/Mat.pyx:4803ReturntypeboolgetISLocalMat()
                     Return the local matrix stored inside a Type.IS matrix.

                     Not collective.

                     SEEALSO:MatISGetLocalMatSourcecodeatpetsc4py/PETSc/Mat.pyx:4836ReturntypeMatgetInertia()
                     Return the inertia from a factored matrix.

                     Collective.

                     The matrix must have been factored by calling factorCholesky.

                     Returns

                            • n (int) -- The number of negative eigenvalues.

                            • z (int) -- The number of zero eigenvalues.

                            • p (int) -- The number of positive eigenvalues.

                     Returntypetuple[int, int, int]

                     SEEALSO:MatGetInertiaSourcecodeatpetsc4py/PETSc/Mat.pyx:4746getInfo(info=None)
                     Return summary information.

                     Collective.

                     Parametersinfo (InfoType) -- If None, it uses InfoType.GLOBAL_SUM.

                     Returntypedict[str, float]

                     SEEALSO:MatInfo, MatGetInfoSourcecodeatpetsc4py/PETSc/Mat.pyx:1984getLGMap()
                     Return the local-to-global mappings.

                     Not collective.

                     SEEALSO:setLGMap, MatGetLocalToGlobalMappingSourcecodeatpetsc4py/PETSc/Mat.pyx:2784Returntypetuple[LGMap, LGMap]

              getLRCMats()
                     Return the constituents of a Type.LRC matrix.

                     Not collective.

                     Returns

                            • A (Mat) -- The A matrix.

                            • U (Mat) -- The first dense rectangular matrix.

                            • c (Vec) -- The sequential vector containing the diagonal of C.

                            • V (Mat) -- The second dense rectangular matrix.

                     Returntypetuple[Mat, Mat, Vec, Mat]

                     SEEALSO:MatLRCGetMatsSourcecodeatpetsc4py/PETSc/Mat.pyx:4918getLocalSize()
                     Return the local number of rows and columns.

                     Not collective.

                     SEEALSO:getSize, MatGetLocalSizeSourcecodeatpetsc4py/PETSc/Mat.pyx:1844Returntypetuple[int, int]

              getLocalSubMatrix(isrow,iscol,submat=None)
                     Return a reference to a submatrix specified in local numbering.

                     Collective.

                     Parameters

                            • isrow (IS) -- Row index set.

                            • iscol (IS) -- Column index set.

                            • submat  (Mat|None)  --  Optional resultant matrix.  When None, a new matrix is
                              created.  When not None, the matrix is first destroyed and then recreated.

                     ReturntypeMatSEEALSO:restoreLocalSubMatrix, MatGetLocalSubMatrixSourcecodeatpetsc4py/PETSc/Mat.pyx:4024getMumpsCntl(icntl)
                     Return the MUMPS parameter, CNTL[icntl].

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, MatMumpsGetCntlSourcecodeatpetsc4py/PETSc/Mat.pyx:5096Parametersicntl (int)

                     ReturntypefloatgetMumpsIcntl(icntl)
                     Return the MUMPS parameter, ICNTL[icntl].

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, MatMumpsGetIcntlSourcecodeatpetsc4py/PETSc/Mat.pyx:5060Parametersicntl (int)

                     ReturntypeintgetMumpsInfo(icntl)
                     Return the MUMPS parameter, INFO[icntl].

                     Logically collective.

                     Parametersicntl (int) -- The index of the MUMPS INFO array.

                     ReturntypeintSEEALSO:MatMumpsGetInfoSourcecodeatpetsc4py/PETSc/Mat.pyx:5111getMumpsInfog(icntl)
                     Return the MUMPS parameter, INFOG[icntl].

                     Logically collective.

                     Parametersicntl (int) -- The index of the MUMPS INFOG array.

                     ReturntypeintSEEALSO:MatMumpsGetInfogSourcecodeatpetsc4py/PETSc/Mat.pyx:5131getMumpsRinfo(icntl)
                     Return the MUMPS parameter, RINFO[icntl].

                     Logically collective.

                     Parametersicntl (int) -- The index of the MUMPS RINFO array.

                     ReturntypefloatSEEALSO:MatMumpsGetRinfoSourcecodeatpetsc4py/PETSc/Mat.pyx:5151getMumpsRinfog(icntl)
                     Return the MUMPS parameter, RINFOG[icntl].

                     Logically collective.

                     Parametersicntl (int) -- The index of the MUMPS RINFOG array.

                     ReturntypefloatSEEALSO:MatMumpsGetRinfogSourcecodeatpetsc4py/PETSc/Mat.pyx:5171getNearNullSpace()
                     Return the near-nullspace.

                     Not collective.

                     SEEALSO:getNullSpace, setNearNullSpace, MatSetNearNullSpaceSourcecodeatpetsc4py/PETSc/Mat.pyx:3686ReturntypeNullSpacegetNestISs()
                     Return the index sets representing the row and column spaces.

                     Not collective.

                     SEEALSO:MatNestGetISsSourcecodeatpetsc4py/PETSc/Mat.pyx:5502Returntypetuple[list[IS], list[IS]]

              getNestLocalISs()
                     Return the local index sets representing the row and column spaces.

                     Not collective.

                     SEEALSO:MatNestGetLocalISsSourcecodeatpetsc4py/PETSc/Mat.pyx:5523Returntypetuple[list[IS], list[IS]]

              getNestSize()
                     Return the number of rows and columns of the matrix.

                     Not collective.

                     SEEALSO:MatNestGetSizeSourcecodeatpetsc4py/PETSc/Mat.pyx:5488Returntypetuple[int, int]

              getNestSubMatrix(i,j)
                     Return a single submatrix.

                     Not collective.

                     Parameters

                            • i (int) -- The first index of the matrix within the nesting.

                            • j (int) -- The second index of the matrix within the nesting.

                     ReturntypeMatSEEALSO:MatNestGetSubMatSourcecodeatpetsc4py/PETSc/Mat.pyx:5544getNullSpace()
                     Return the nullspace.

                     Not collective.

                     SEEALSO:setNullSpace, MatGetNullSpaceSourcecodeatpetsc4py/PETSc/Mat.pyx:3632ReturntypeNullSpacegetOption(option)
                     Return the option value.

                     Not collective.

                     SEEALSO:setOption, MatGetOptionSourcecodeatpetsc4py/PETSc/Mat.pyx:1802Parametersoption (Option)

                     ReturntypeboolgetOptionsPrefix()
                     Return the prefix used for searching for options in the database.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, MatGetOptionsPrefixSourcecodeatpetsc4py/PETSc/Mat.pyx:1737ReturntypestrgetOrdering(ord_type)
                     Return a reordering for a matrix to improve a LU factorization.

                     Collective.

                     Parametersord_type (OrderingType) -- The type of reordering.

                     Returns

                            • rp (IS) -- The row permutation indices.

                            • cp (IS) -- The column permutation indices.

                     Returntypetuple[IS, IS]

                     SEEALSO:MatGetOrderingSourcecodeatpetsc4py/PETSc/Mat.pyx:4556getOwnershipIS()
                     Return the ranges of rows and columns owned by each process as index sets.

                     Not collective.

                     SEEALSO:getOwnershipRanges, getOwnershipRangesColumn, MatGetOwnershipISSourcecodeatpetsc4py/PETSc/Mat.pyx:1969Returntypetuple[IS, IS]

              getOwnershipRange()
                     Return the locally owned range of rows.

                     Not collective.

                     SEEALSO:getOwnershipRanges, getOwnershipRangeColumn, MatGetOwnershipRangeSourcecodeatpetsc4py/PETSc/Mat.pyx:1902Returntypetuple[int, int]

              getOwnershipRangeColumn()
                     Return the locally owned range of columns.

                     Not collective.

                     SEEALSO:getOwnershipRangesColumn, getOwnershipRange, MatGetOwnershipRangeColumnSourcecodeatpetsc4py/PETSc/Mat.pyx:1936Returntypetuple[int, int]

              getOwnershipRanges()
                     Return the range of rows owned by each process.

                     Not collective.

                     The returned array is the result of exclusive scan of the local sizes.

                     SEEALSO:getOwnershipRange, MatGetOwnershipRangesSourcecodeatpetsc4py/PETSc/Mat.pyx:1916ReturntypeArrayIntgetOwnershipRangesColumn()
                     Return the range of columns owned by each process.

                     Not collective.

                     SEEALSO:getOwnershipRangeColumn, MatGetOwnershipRangesColumnSourcecodeatpetsc4py/PETSc/Mat.pyx:1951ReturntypeArrayIntgetPythonContext()
                     Return the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonmatrixtype, setPythonContextSourcecodeatpetsc4py/PETSc/Mat.pyx:1671ReturntypeAnygetPythonType()
                     Return the fully qualified Python name of the class used by the matrix.

                     Not collective.

                     SEEALSO:PETScPythonmatrixtype, setPythonContext, setPythonType, MatPythonGetTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:1706ReturntypestrgetRedundantMatrix(nsubcomm,subcomm=None,out=None)
                     Return redundant matrices on subcommunicators.

                     Collective.

                     Parameters

                            • nsubcomm (int) -- The number of subcommunicators.

                            • subcomm (Comm|None) -- Communicator split or None for the null communicator.

                            • out (Mat|None) -- Optional  resultant  matrix.   When  None,  a  new  matrix  is
                              created, and MAT_INITIAL_MATRIX is used.  When not None, the matrix is reused with
                              MAT_REUSE_MATRIX.

                     ReturntypeMatSEEALSO:MatCreateRedundantMatrixSourcecodeatpetsc4py/PETSc/Mat.pyx:3483getRow(row)
                     Return the column indices and values for the requested row.

                     Not collective.

                     SEEALSO:MatGetRowSourcecodeatpetsc4py/PETSc/Mat.pyx:2467Parametersrow (int)

                     Returntypetuple[ArrayInt, ArrayScalar]

              getRowIJ(symmetric=False,compressed=False)
                     Return the CSR representation of the local sparsity pattern.

                     Collective.

                     Parameters

                            • symmetric (bool) -- If True, return the symmetrized graph.

                            • compressed (bool) -- If True, return the compressed graph.

                     Returntypetuple[ArrayInt, ArrayInt]

                     SEEALSO:MatGetRowIJSourcecodeatpetsc4py/PETSc/Mat.pyx:2487getRowSum(result=None)
                     Return the row-sum vector.

                     Collective.

                     Parametersresult (Vec|None) -- Optional vector to store the result.

                     ReturntypeVecSEEALSO:MatGetRowSumSourcecodeatpetsc4py/PETSc/Mat.pyx:3535getSchurComplementSubMatrices()
                     Return Schur complement sub-matrices.

                     Collective.

                     SEEALSO:MatSchurComplementGetSubMatricesSourcecodeatpetsc4py/PETSc/Mat.pyx:4003Returntypetuple[Mat, Mat, Mat, Mat, Mat]

              getSize()
                     Return the global number of rows and columns.

                     Not collective.

                     SEEALSO:getLocalSize, getSizes, MatGetSizeSourcecodeatpetsc4py/PETSc/Mat.pyx:1830Returntypetuple[int, int]

              getSizes()
                     Return the tuple of matrix layouts.

                     Not collective.

                     SEEALSO:getLocalSize, getSizeSourcecodeatpetsc4py/PETSc/Mat.pyx:1858Returntypetuple[LayoutSizeSpec, LayoutSizeSpec]

              getTransposeNullSpace()
                     Return the transpose nullspace.

                     Not collective.

                     SEEALSO:getNullSpace, setTransposeNullSpace, MatGetTransposeNullSpaceSourcecodeatpetsc4py/PETSc/Mat.pyx:3659ReturntypeNullSpacegetType()
                     Return the type of the matrix.

                     Not collective.

                     SEEALSO:setType, Type, MatGetTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:1816ReturntypestrgetValue(row,col)
                     Return the value in the (row, col) position.

                     Not collective.

                     SEEALSO:MatGetValuesSourcecodeatpetsc4py/PETSc/Mat.pyx:2392ReturntypeScalargetValues(rows,cols,values=None)
                     Return the values in the zip(rows,cols) positions.

                     Not collective.

                     Parameters

                            • rows (Sequence[int]) -- Row indices.

                            • cols (Sequence[int]) -- Column indices.

                            • values (ArrayScalar) -- Optional array where to store the values.

                     ReturntypeArrayScalarSEEALSO:MatGetValuesSourcecodeatpetsc4py/PETSc/Mat.pyx:2408getValuesCSR()
                     Return the CSR representation of the local part of the matrix.

                     Not collective.

                     SEEALSO:MatGetRowSourcecodeatpetsc4py/PETSc/Mat.pyx:2429Returntypetuple[ArrayInt, ArrayInt, ArrayScalar]

              getVecType()
                     Return the vector type used by the matrix.

                     Not collective.

                     SEEALSO:setVecType, MatGetVecTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:658ReturntypestrhermitianTranspose(out=None)
                     Return the transposed Hermitian matrix.

                     Collective.

                     Parametersout  (Mat|None)  --  Optional  return  matrix. If None, inplace transposition is
                            performed.  Otherwise, the matrix is reused.

                     ReturntypeMatSEEALSO:MatHermitianTransposeSourcecodeatpetsc4py/PETSc/Mat.pyx:2142imagPart(out=None)
                     Return the imaginary part of the matrix.

                     Collective.

                     Parametersout (Mat|None) -- Optional return matrix. If  None,  the  operation  is  performed
                            in-place.  Otherwise, the operation is performed on out.

                     ReturntypeMatSEEALSO:realPart, conjugate, MatImaginaryPartSourcecodeatpetsc4py/PETSc/Mat.pyx:2192increaseOverlap(iset,overlap=1)
                     Increase the overlap of a index set.

                     Collective.

                     SEEALSO:MatIncreaseOverlapSourcecodeatpetsc4py/PETSc/Mat.pyx:3869Parameters

                            • iset (IS)

                            • overlap (int)

                     ReturntypeNoneinvertBlockDiagonal()
                     Return the inverse of the block-diagonal entries.

                     Collective.

                     SEEALSO:MatInvertBlockDiagonalSourcecodeatpetsc4py/PETSc/Mat.pyx:3599ReturntypeArrayScalarisAssembled()
                     The boolean flag indicating if the matrix is assembled.

                     Not collective.

                     SEEALSO:assemble, MatAssembledSourcecodeatpetsc4py/PETSc/Mat.pyx:3357ReturntypeboolisHermitian(tol=0)
                     Return the boolean indicating if the matrix is Hermitian.

                     Collective.

                     Parameterstol (float) -- Tolerance for comparison.

                     ReturntypeboolSEEALSO:MatIsHermitianSourcecodeatpetsc4py/PETSc/Mat.pyx:2331isHermitianKnown()
                     Return the 2-tuple indicating if the matrix is known to be Hermitian.

                     Not collective.

                     SEEALSO:MatIsHermitianKnownSourcecodeatpetsc4py/PETSc/Mat.pyx:2351Returntypetuple[bool, bool]

              isStructurallySymmetric()
                     Return the boolean indicating if the matrix is structurally symmetric.

                     Not collective.

                     SEEALSO:MatIsStructurallySymmetricSourcecodeatpetsc4py/PETSc/Mat.pyx:2366ReturntypeboolisSymmetric(tol=0)
                     Return the boolean indicating if the matrix is symmetric.

                     Collective.

                     Parameterstol (float) -- Tolerance for comparison.

                     ReturntypeboolSEEALSO:MatIsSymmetricSourcecodeatpetsc4py/PETSc/Mat.pyx:2296isSymmetricKnown()
                     Return the 2-tuple indicating if the matrix is known to be symmetric.

                     Not collective.

                     SEEALSO:MatIsSymmetricKnownSourcecodeatpetsc4py/PETSc/Mat.pyx:2316Returntypetuple[bool, bool]

              isTranspose(mat=None,tol=0)
                     Return the result of matrix comparison with transposition.

                     Collective.

                     Parameters

                            • mat (Mat|None) -- Matrix to compare against. Uses self if None.

                            • tol (float) -- Tolerance for comparison.

                     ReturntypeboolSEEALSO:MatIsTransposeSourcecodeatpetsc4py/PETSc/Mat.pyx:2273kron(mat,result=None)
                     Compute C, the Kronecker product of A and B.

                     Collective.

                     Parameters

                            • mat (Mat) -- The right hand matrix B.

                            • result  (Mat|None) -- The optional resultant matrix. When None, a new matrix is
                              created, and MAT_INITIAL_MATRIX is used. When it is not None, the matrix is reused
                              with MAT_REUSE_MATRIX.

                     Returnsresult -- The resultant matrix C, the Kronecker product of A and B.

                     ReturntypeMatSEEALSO:MatSeqAIJKron, MatReuseSourcecodeatpetsc4py/PETSc/Mat.pyx:4485load(viewer)
                     Load a matrix.

                     Collective.

                     SEEALSO:MatLoadSourcecodeatpetsc4py/PETSc/Mat.pyx:2053Parametersviewer (Viewer)

                     ReturntypeSelfmatMatMult(B,C,result=None,fill=None)
                     Perform matrix-matrix-matrix multiplication D=ABC.

                     Neighborwise collective.

                     Parameters

                            • B (Mat) -- The middle matrix B.

                            • C (Mat) -- The right hand matrix C.

                            • result (Mat|None) -- The optional resultant matrix D. When None, a new matrix is
                              created, and MAT_INITIAL_MATRIX is used. When D is not None, the matrix is  reused
                              with MAT_REUSE_MATRIX.

                            • fill (float|None) -- Expected fill as ratio of nnz(C)/nnz(A), use None if you do
                              not have a good estimate. If the result is a dense matrix this is irrelevant.

                     Returnsresult -- The resultant product matrix D.

                     ReturntypeMatSEEALSO:MatMatMatMult, MatReuseSourcecodeatpetsc4py/PETSc/Mat.pyx:4440matMult(mat,result=None,fill=None)
                     Perform matrix-matrix multiplication C=AB.

                     Neighborwise collective.

                     Parameters

                            • mat (Mat) -- The right hand matrix B.

                            • result (Mat|None) -- The optional resultant matrix C. When None, a new matrix is
                              created,  and MAT_INITIAL_MATRIX is used. When C is not None, the matrix is reused
                              with MAT_REUSE_MATRIX.

                            • fill (float|None) -- Expected fill as ratio of nnz(C)/(nnz(A) + nnz(B)),  use  ‐
                              None  if  you do not have a good estimate. If the result is a dense matrix this is
                              irrelevant.

                     Returnsresult -- The resultant product matrix C.

                     ReturntypeMat

                     Notes

                     To determine the correct fill value, run with -info and search for the string "Fill  ratio"
                     to see the value actually needed.

                     SEEALSO:MatMatMult, MatReuseSourcecodeatpetsc4py/PETSc/Mat.pyx:4201matSolve(B,X)
                     Solve AX=B, given a factored matrix A.

                     Neighborwise collective.

                     Parameters

                            • B  (Mat) -- The right-hand side matrix of type Type.DENSE. Can be of type Type.AIJ
                              if using MUMPS.

                            • X (Mat) -- The output solution matrix, must be different than B.

                     ReturntypeNoneSEEALSO:KSP.create, MatMatSolveSourcecodeatpetsc4py/PETSc/Mat.pyx:5321matTransposeMult(mat,result=None,fill=None)
                     Perform matrix-matrix multiplication C=ABᵀ.

                     Neighborwise collective.

                     Parameters

                            • mat (Mat) -- The right hand matrix B.

                            • result (Mat|None) -- The optional resultant matrix C. When None, a new matrix is
                              created, and MAT_INITIAL_MATRIX is used. When C is not None, the matrix is  reused
                              with MAT_REUSE_MATRIX.

                            • fill  (float|None) -- Expected fill as ratio of nnz(C)/(nnz(A) + nnz(B)), use ‐
                              None if you do not have a good estimate. If the result is a dense matrix  this  is
                              irrelevant.

                     Returnsresult -- The resultant product matrix C.

                     ReturntypeMat

                     Notes

                     To  determine the correct fill value, run with -info and search for the string "Fill ratio"
                     to see the value actually needed.

                     SEEALSO:MatMatTransposeMult, MatReuseSourcecodeatpetsc4py/PETSc/Mat.pyx:4248mult(x,y)
                     Perform the matrix vector product y = A @ x.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector.

                            • y (Vec) -- The output vector.

                     ReturntypeNoneSEEALSO:MatMultSourcecodeatpetsc4py/PETSc/Mat.pyx:3703multAdd(x,v,y)
                     Perform the matrix vector product with addition y = A @ x + v.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector for the matrix-vector product.

                            • v (Vec) -- The input vector to be added to.

                            • y (Vec) -- The output vector.

                     ReturntypeNoneSEEALSO:MatMultAddSourcecodeatpetsc4py/PETSc/Mat.pyx:3722multHermitian(x,y)
                     Perform the Hermitian matrix vector product y = A^H @ x.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector for the Hermitian matrix-vector product.

                            • y (Vec) -- The output vector.

                     ReturntypeNoneSEEALSO:MatMultHermitianTransposeSourcecodeatpetsc4py/PETSc/Mat.pyx:3783multHermitianAdd(x,v,y)
                     Perform the Hermitian matrix vector product with addition y = A^H @ x + v.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector for the Hermitian matrix-vector product.

                            • v (Vec) -- The input vector to be added to.

                            • y (Vec) -- The output vector.

                     ReturntypeNoneSEEALSO:MatMultHermitianTransposeAddSourcecodeatpetsc4py/PETSc/Mat.pyx:3802multTranspose(x,y)
                     Perform the transposed matrix vector product y = A^T @ x.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector.

                            • y (Vec) -- The output vector.

                     ReturntypeNoneSEEALSO:MatMultTransposeSourcecodeatpetsc4py/PETSc/Mat.pyx:3743multTransposeAdd(x,v,y)
                     Perform the transposed matrix vector product with addition y = A^T @ x + v.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector for the transposed matrix-vector product.

                            • v (Vec) -- The input vector to be added to.

                            • y (Vec) -- The output vector.

                     ReturntypeNoneSEEALSO:MatMultTransposeAddSourcecodeatpetsc4py/PETSc/Mat.pyx:3762norm(norm_type=None)
                     Compute the requested matrix norm.

                     Collective.

                     A 2-tuple is returned if NormType.NORM_1_AND_2 is specified.

                     SEEALSO:MatNorm, NormTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:4073Parametersnorm_type (NormTypeSpec)

                     Returntypefloat | tuple[float, float]

              permute(row,col)
                     Return the permuted matrix.

                     Collective.

                     Parameters

                            • row (IS) -- Row permutation.

                            • col (IS) -- Column permutation.

                     ReturntypeMatSEEALSO:MatPermuteSourcecodeatpetsc4py/PETSc/Mat.pyx:2238preallocatorPreallocate(A,fill=True)
                     Preallocate memory for a matrix using a preallocator matrix.

                     Collective.

                     The current matrix (self) must be of type Type.PREALLOCATOR.

                     Parameters

                            • A (Mat) -- The matrix to be preallocated.

                            • fill (bool) -- Flag indicating whether or not  to  insert  zeros  into  the  newly
                              allocated matrix, defaults to True.

                     ReturntypeNoneSEEALSO:MatPreallocatorPreallocateSourcecodeatpetsc4py/PETSc/Mat.pyx:933ptap(P,result=None,fill=None)
                     Creates the matrix product C = PᵀAP.

                     Neighborwise collective.

                     Parameters

                            • P (Mat) -- The matrix P.

                            • result (Mat|None) -- The optional resultant matrix C. When None, a new matrix is
                              created,  and MAT_INITIAL_MATRIX is used. When C is not None, the matrix is reused
                              with MAT_REUSE_MATRIX.

                            • fill (float|None) -- Expected fill as ratio of nnz(C)/(nnz(A) + nnz(P)),  use  ‐
                              None  if  you do not have a good estimate. If the result is a dense matrix this is
                              irrelevant.

                     Returnsresult -- The resultant product matrix C.

                     ReturntypeMat

                     Notes

                     To determine the correct fill value, run with -info and search for the string "Fill  ratio"
                     to see the value actually needed.

                     An  alternative  approach  to  this function is to use MatProductCreate and set the desired
                     options before the computation is done.

                     SEEALSO:MatPtAP, MatReuseSourcecodeatpetsc4py/PETSc/Mat.pyx:4342rart(R,result=None,fill=None)
                     Create the matrix product C = RARᵀ.

                     Neighborwise collective.

                     Parameters

                            • R (Mat) -- The projection matrix.

                            • result (Mat|None) -- The optional resultant matrix C. When None, a new matrix is
                              created, and MAT_INITIAL_MATRIX is used. When C is not None, the matrix is  reused
                              with MAT_REUSE_MATRIX.

                            • fill (float|None) -- Expected fill as ratio of nnz(C)/nnz(A), use None if you do
                              not have a good estimate. If the result is a dense matrix this is irrelevant.

                     Returnsresult -- The resultant product matrix C.

                     ReturntypeMat

                     Notes

                     To  determine the correct fill value, run with -info and search for the string "Fill ratio"
                     to see the value actually needed.

                     SEEALSO:MatRARt, MatReuseSourcecodeatpetsc4py/PETSc/Mat.pyx:4393realPart(out=None)
                     Return the real part of the matrix.

                     Collective.

                     Parametersout (Mat|None) -- Optional return matrix. If  None,  the  operation  is  performed
                            in-place.  Otherwise, the operation is performed on out.

                     ReturntypeMatSEEALSO:imagPart, conjugate, MatRealPartSourcecodeatpetsc4py/PETSc/Mat.pyx:2169reorderForNonzeroDiagonal(isrow,iscol,atol=0)
                     Change a matrix ordering to remove zeros from the diagonal.

                     Collective.

                     Parameters

                            • isrow (IS) -- The row reordering.

                            • iscol (IS) -- The column reordering.

                            • atol  (float)  -- The absolute tolerance. Values along the diagonal whose absolute
                              value are smaller than this tolerance are moved off the diagonal.

                     ReturntypeNoneSEEALSO:getOrdering, MatReorderForNonzeroDiagonalSourcecodeatpetsc4py/PETSc/Mat.pyx:4584restoreDenseColumnVec(i,mode='rw')
                     Restore the iᵗʰ column vector of the dense matrix.

                     Collective.

                     Parameters

                            • i (int) -- The column index to be restored.

                            • mode (AccessModeSpec) -- The access type of the restored array

                     ReturntypeNoneSEEALSO:getDenseColumnVec,     MatDenseRestoreColumnVec,     MatDenseRestoreColumnVecRead,     ‐
                        MatDenseRestoreColumnVecWriteSourcecodeatpetsc4py/PETSc/Mat.pyx:5460restoreISLocalMat(local)
                     Restore the local matrix obtained with getISLocalMat.

                     Not collective.

                     Parameterslocal (Mat) -- The local matrix.

                     ReturntypeNoneSEEALSO:MatISRestoreLocalMatSourcecodeatpetsc4py/PETSc/Mat.pyx:4851restoreLocalSubMatrix(isrow,iscol,submat)
                     Restore a reference to a submatrix obtained with getLocalSubMatrix.

                     Collective.

                     Parameters

                            • isrow (IS) -- Row index set.

                            • iscol (IS) -- Column index set.

                            • submat (Mat) -- The submatrix.

                     ReturntypeNoneSEEALSO:getLocalSubMatrix, MatRestoreLocalSubMatrixSourcecodeatpetsc4py/PETSc/Mat.pyx:4050retrieveValues()
                     Retrieve a copy of the matrix values previously stored with storeValues.

                     Collective.

                     SEEALSO:storeValues, MatRetrieveValuesSourcecodeatpetsc4py/PETSc/Mat.pyx:3290ReturntypeNonescale(alpha)
                     Scale the matrix.

                     Collective.

                     SEEALSO:MatScaleSourcecodeatpetsc4py/PETSc/Mat.pyx:4095Parametersalpha (Scalar)

                     ReturntypeNonesetBlockSize(bsize)
                     Set the matrix block size (same for rows and columns).

                     Logically collective.

                     Parametersbsize (int) -- Block size.

                     ReturntypeNoneSEEALSO:setBlockSizes, setSizes, MatSetBlockSizeSourcecodeatpetsc4py/PETSc/Mat.pyx:586setBlockSizes(row_bsize,col_bsize)
                     Set the row and column block sizes.

                     Logically collective.

                     Parameters

                            • row_bsize (int) -- Row block size.

                            • col_bsize (int) -- Column block size.

                     ReturntypeNoneSEEALSO:setBlockSize, setSizes, MatSetBlockSizesSourcecodeatpetsc4py/PETSc/Mat.pyx:604setDM(dm)
                     Set the DM defining the data layout of the matrix.

                     Not collective.

                     Parametersdm (DM) -- The DM.

                     ReturntypeNoneSEEALSO:MatSetDMSourcecodeatpetsc4py/PETSc/Mat.pyx:5587setDenseLDA(lda)
                     Set the leading dimension of the array used by the dense matrix.

                     Not collective.

                     Parameterslda (int) -- The leading dimension.

                     ReturntypeNoneSEEALSO:MatDenseSetLDASourcecodeatpetsc4py/PETSc/Mat.pyx:5343setDiagonal(diag,addv=None)
                     Set the diagonal values of the matrix.

                     Collective.

                     Parameters

                            • diag (Vec) -- Vector storing diagonal values.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:getDiagonal, MatDiagonalSetSourcecodeatpetsc4py/PETSc/Mat.pyx:3557setFromOptions()
                     Configure the matrix from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, MatSetFromOptionsSourcecodeatpetsc4py/PETSc/Mat.pyx:1765ReturntypeNonesetISAllowRepeated(allow=True)
                     Allow repeated entries in the local to global map.

                     Logically collective.

                     Parametersallow (bool) -- When True, local dofs are allowed to map to the same global dof.

                     ReturntypeNoneSEEALSO:getISAllowRepeated, MatISSetAllowRepeatedSourcecodeatpetsc4py/PETSc/Mat.pyx:4785setISLocalMat(local)
                     Set the local matrix stored inside a Type.IS.

                     Not collective.

                     Parameterslocal (Mat) -- The local matrix.

                     ReturntypeNoneSEEALSO:MatISSetLocalMatSourcecodeatpetsc4py/PETSc/Mat.pyx:4868setISPreallocation(nnz,onnz)
                     Preallocate memory for a Type.IS parallel matrix.

                     Collective.

                     Parameters

                            • nnz  (Sequence[int])  --  The  sequence  whose length corresponds to the number of
                              local rows and values which represent the number of nonzeros in the  various  rows
                              of the diagonal of the local submatrix.

                            • onnz  (Sequence[int])  --  The  sequence whose length corresponds to the number of
                              local rows and values which represent the number of nonzeros in the  various  rows
                              of the off-diagonal of the local submatrix.

                     ReturntypeSelfSEEALSO:MatISSetPreallocationSourcecodeatpetsc4py/PETSc/Mat.pyx:4885setLGMap(rmap,cmap=None)
                     Set the local-to-global mappings.

                     Collective.

                     Parameters

                            • rmap (LGMap) -- Row mapping.

                            • cmap (LGMap|None) -- Column mapping. If None, cmap=rmap.

                     ReturntypeNoneSEEALSO:getLGMap, MatSetLocalToGlobalMappingSourcecodeatpetsc4py/PETSc/Mat.pyx:2764setLRCMats(A,U,c=None,V=None)
                     Set the constituents of a Type.LRC matrix.

                     Logically collective.

                     Parameters

                            • A (Mat) -- The A matrix, or None to omit A.

                            • U (Mat) -- The first dense rectangular matrix.

                            • c  (Vec)  --  The  sequential vector containing the diagonal of C, or None for all
                              ones.

                            • V (Mat) -- The second dense rectangular matrix, or None for a copy of U.

                     ReturntypeNoneSEEALSO:MatLRCSetMatsSourcecodeatpetsc4py/PETSc/Mat.pyx:4950setMumpsCntl(icntl,val)
                     Set a MUMPS parameter, CNTL[icntl]=val.

                     Logically collective.

                     Parameters

                            • icntl (int) -- The index of the MUMPS parameter array.

                            • val (float) -- The value to set.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, MatMumpsSetCntlSourcecodeatpetsc4py/PETSc/Mat.pyx:5075setMumpsIcntl(icntl,ival)
                     Set a MUMPS parameter, ICNTL[icntl]=ival.

                     Logically collective.

                     Parameters

                            • icntl (int) -- The index of the MUMPS parameter array.

                            • ival (int) -- The value to set.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, MatMumpsSetIcntlSourcecodeatpetsc4py/PETSc/Mat.pyx:5039setNearNullSpace(nsp)
                     Set the near-nullspace.

                     Collective.

                     SEEALSO:setNullSpace, getNearNullSpace, MatSetNearNullSpaceSourcecodeatpetsc4py/PETSc/Mat.pyx:3674Parametersnsp (NullSpace)

                     ReturntypeNonesetNestVecType(vec_type)
                     Set the vector type for a Type.NEST matrix.

                     Collective.

                     Parametersvec_type (Type|str) -- Vector type used when creating vectors with createVecs.

                     ReturntypeNoneSEEALSO:getVecType, MatNestSetVecTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:672setNullSpace(nsp)
                     Set the nullspace.

                     Collective.

                     SEEALSO:getNullSpace, MatSetNullSpaceSourcecodeatpetsc4py/PETSc/Mat.pyx:3620Parametersnsp (NullSpace)

                     ReturntypeNonesetOption(option,flag)
                     Set option.

                     Collective.

                     SEEALSO:getOption, MatSetOptionSourcecodeatpetsc4py/PETSc/Mat.pyx:1790Parameters

                            • option (Option)

                            • flag (bool)

                     ReturntypeNonesetOptionsPrefix(prefix=None)
                     Set the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, getOptionsPrefix, MatSetOptionsPrefixSourcecodeatpetsc4py/PETSc/Mat.pyx:1723Parametersprefix (str|None)

                     ReturntypeNonesetPreallocationCSR(csr)
                     Preallocate memory for the matrix with a CSR layout.

                     Collective.

                     Correct preallocation can result in a dramatic reduction in matrix assembly time.

                     Parameterscsr (CSRIndicesSpec) -- Local matrix data in compressed sparse row layout format.

                     ReturntypeSelf

                     Notes

                     Must use the block-compressed form with Type.BAIJ and Type.SBAIJ.

                     SEEALSO:setPreallocationNNZ, createAIJ, createBAIJ, createSBAIJ, MatSeqAIJSetPreallocationCSR, ‐
                        MatMPIAIJSetPreallocationCSR,              MatSeqBAIJSetPreallocationCSR,              ‐
                        MatMPIBAIJSetPreallocationCSR,             MatSeqSBAIJSetPreallocationCSR,             ‐
                        MatMPISBAIJSetPreallocationCSRSourcecodeatpetsc4py/PETSc/Mat.pyx:899setPreallocationDense(array)
                     Set the array used for storing matrix elements for a dense matrix.

                     Collective.

                     Parametersarray (Sequence[Scalar]) -- Array that will be used to store matrix data.

                     ReturntypeSelfSEEALSO:MatSeqDenseSetPreallocation, MatMPIDenseSetPreallocationSourcecodeatpetsc4py/PETSc/Mat.pyx:1140setPreallocationNNZ(nnz)
                     Preallocate memory for the matrix with a non-zero pattern.

                     Collective.

                     Correct preallocation can result in a dramatic reduction in matrix assembly time.

                     Parametersnnz (NNZSpec) -- The number of non-zeros per  row  for  the  local  portion  of  the
                            matrix, or a 2-tuple for the on-process and off-process part of the matrix.

                     ReturntypeSelfSEEALSO:setPreallocationCSR, createAIJ, MatSeqAIJSetPreallocation, MatMPIAIJSetPreallocationSourcecodeatpetsc4py/PETSc/Mat.pyx:873setPythonContext(context)
                     Set the instance of the class implementing the required Python methods.

                     Logically collective.

                     Notes

                     In  order  to use the matrix, Mat.setUp must be called after having set the context. Pass ‐
                     None to reset the matrix to its initial state.

                     SEEALSO:PETScPythonmatrixtype, getPythonContext, setPythonTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:1654Parameterscontext (Any)

                     ReturntypeNonesetPythonType(py_type)
                     Set the fully qualified Python name of the class to be used.

                     Collective.

                     Notes

                     In order to use the matrix, Mat.setUp must be called after having set the type.

                     SEEALSO:PETScPythonmatrixtype, setPythonContext, getPythonType, MatPythonSetTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:1686Parameterspy_type (str)

                     ReturntypeNonesetRandom(random=None)
                     Set random values in the matrix.

                     Collective.

                     Parametersrandom (Random|None) -- The  random  number  generator  object  or  None  for  the
                            default.

                     ReturntypeNoneSEEALSO:MatSetRandomSourcecodeatpetsc4py/PETSc/Mat.pyx:4134setSizes(size,bsize=None)
                     Set the local, global and block sizes.

                     Collective.

                     Parameters

                            • size (MatSizeSpec) -- Matrix size.

                            • bsize  (MatBlockSizeSpec|None) -- Matrix block size. If None, a block size of 1
                              is set.

                     ReturntypeNone

                     Examples

                     Create a Mat with n rows and columns and the same local and global sizes.

                     >>> mat = PETSc.Mat().create()
                     >>> mat.setFromOptions()
                     >>> mat.setSizes(n)

                     Create a Mat with nr rows, nc columns and the same local and global sizes.

                     >>> mat = PETSc.Mat().create()
                     >>> mat.setFromOptions()
                     >>> mat.setSizes([nr, nc])

                     Create a Mat with nrl local rows, nrg  global  rows,  ncl  local  columns  and  ncg  global
                     columns.

                     >>> mat = PETSc.Mat().create()
                     >>> mat.setFromOptions()
                     >>> mat.setSizes([[nrl, nrg], [ncl, ncg]])

                     SEEALSO:setBlockSize, setBlockSizes, MatSetSizes, MatSetBlockSize, MatSetBlockSizesSourcecodeatpetsc4py/PETSc/Mat.pyx:533setStencil(dims,starts=None,dof=1)
                     Set matrix stencil.

                     Not collective.

                     SEEALSO:MatSetStencilSourcecodeatpetsc4py/PETSc/Mat.pyx:3022Parameters

                            • dims (DimsSpec)

                            • starts (DimsSpec|None)

                            • dof (int)

                     ReturntypeNonesetTransposeNullSpace(nsp)
                     Set the transpose nullspace.

                     Collective.

                     SEEALSO:setNullSpace, getTransposeNullSpace, MatSetTransposeNullSpaceSourcecodeatpetsc4py/PETSc/Mat.pyx:3647Parametersnsp (NullSpace)

                     ReturntypeNonesetTransposePrecursor(out)
                     Set transpose precursor.

                     Logically collective.

                     SEEALSO:MatTransposeSetPrecursorSourcecodeatpetsc4py/PETSc/Mat.pyx:2130Parametersout (Mat)

                     ReturntypeNonesetType(mat_type)
                     Set the matrix type.

                     Collective.

                     Parametersmat_type (Type|str) -- The matrix type.

                     ReturntypeNoneSEEALSO:create, getType, MatSetTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:514setUnfactored()
                     Set a factored matrix to be treated as unfactored.

                     Logically collective.

                     SEEALSO:MatSetUnfactoredSourcecodeatpetsc4py/PETSc/Mat.pyx:4771ReturntypeNonesetUp()
                     Set up the internal data structures for using the matrix.

                     Collective.

                     SEEALSO:MatSetUpSourcecodeatpetsc4py/PETSc/Mat.pyx:1777ReturntypeSelfsetValue(row,col,value,addv=None)
                     Set a value to the (row,col) entry of the matrix.

                     Not collective.

                     Parameters

                            • row (int) -- Row index.

                            • col (int) -- Column index.

                            • value (Scalar) -- The scalar value.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesSourcecodeatpetsc4py/PETSc/Mat.pyx:2548setValueBlockedStagStencil(row,col,value,addv=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:3106ReturntypeNonesetValueBlockedStencil(row,col,value,addv=None)
                     Set a block of values to row and col stencil.

                     Not collective.

                     Parameters

                            • row (Stencil) -- Row stencil.

                            • col (Stencil) -- Column stencil.

                            • value (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesBlockedStencilSourcecodeatpetsc4py/PETSc/Mat.pyx:3076setValueLocal(row,col,value,addv=None)
                     Set a value to the (row,col) entry of the matrix in local ordering.

                     Not collective.

                     Parameters

                            • row (int) -- Local row index.

                            • col (int) -- Local column index.

                            • value (Scalar) -- The scalar value.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesLocalSourcecodeatpetsc4py/PETSc/Mat.pyx:2801setValueStagStencil(row,col,value,addv=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:3072ReturntypeNonesetValueStencil(row,col,value,addv=None)
                     Set a value to row and col stencil.

                     Not collective.

                     Parameters

                            • row (Stencil) -- Row stencil.

                            • col (Stencil) -- Column stencil.

                            • value (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesStencilSourcecodeatpetsc4py/PETSc/Mat.pyx:3042setValues(rows,cols,values,addv=None)
                     Set values to the rows ⊗ cols entries of the matrix.

                     Not collective.

                     Parameters

                            • rows (Sequence[int]) -- Row indices.

                            • cols (Sequence[int]) -- Column indices.

                            • values  (Sequence[Scalar])  --  The  scalar  values. A sequence of length at least
                              len(rows)*len(cols).

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesSourcecodeatpetsc4py/PETSc/Mat.pyx:2580setValuesBlocked(rows,cols,values,addv=None)
                     Set values to the rows ⊗ col block entries of the matrix.

                     Not collective.

                     Parameters

                            • rows (Sequence[int]) -- Block row indices.

                            • cols (Sequence[int]) -- Block column indices.

                            • values (Sequence[Scalar]) -- The scalar values. A  sequence  of  length  at  least
                              len(rows)*len(cols)*bs*bs, where bs is the block size of the matrix.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesBlockedSourcecodeatpetsc4py/PETSc/Mat.pyx:2671setValuesBlockedCSR(I,J,V,addv=None)
                     Set values stored in block CSR format.

                     Not collective.

                     Parameters

                            • I (Sequence[int]) -- Block row pointers.

                            • J (Sequence[int]) -- Block column indices.

                            • V (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesBlockedSourcecodeatpetsc4py/PETSc/Mat.pyx:2736setValuesBlockedIJV(I,J,V,addv=None,rowmap=None)
                     Set a subset of values stored in block CSR format.

                     Not collective.

                     Parameters

                            • I (Sequence[int]) -- Block row pointers.

                            • J (Sequence[int]) -- Block column indices.

                            • V (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                            • rowmap (Sequence[int]) -- Optional iterable indicating which block row to insert.

                     ReturntypeNoneSEEALSO:MatSetValuesBlockedSourcecodeatpetsc4py/PETSc/Mat.pyx:2705setValuesBlockedLocal(rows,cols,values,addv=None)
                     Set values to the rows ⊗ col block entries of the matrix in local ordering.

                     Not collective.

                     Parameters

                            • rows (Sequence[int]) -- Local block row indices.

                            • cols (Sequence[int]) -- Local block column indices.

                            • values  (Sequence[Scalar])  --  The  scalar  values. A sequence of length at least
                              len(rows)*len(cols)*bs*bs, where bs is the block size of the matrix.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesBlockedLocalSourcecodeatpetsc4py/PETSc/Mat.pyx:2925setValuesBlockedLocalCSR(I,J,V,addv=None)
                     Set values stored in block CSR format.

                     Not collective.

                     Parameters

                            • I (Sequence[int]) -- Block row pointers.

                            • J (Sequence[int]) -- Local block column indices.

                            • V (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesBlockedLocalSourcecodeatpetsc4py/PETSc/Mat.pyx:2990setValuesBlockedLocalIJV(I,J,V,addv=None,rowmap=None)
                     Set a subset of values stored in block CSR format.

                     Not collective.

                     Parameters

                            • I (Sequence[int]) -- Block row pointers.

                            • J (Sequence[int]) -- Local block column indices.

                            • V (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                            • rowmap (Sequence[int]) -- Optional iterable indicating which block row to insert.

                     ReturntypeNoneSEEALSO:MatSetValuesBlockedLocalSourcecodeatpetsc4py/PETSc/Mat.pyx:2959setValuesBlockedLocalRCV(R,C,V,addv=None)
                     Undocumented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:2955ReturntypeNonesetValuesBlockedRCV(R,C,V,addv=None)
                     Undocumented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:2701ReturntypeNonesetValuesCSR(I,J,V,addv=None)
                     Set values stored in CSR format.

                     Not collective.

                     Parameters

                            • I (Sequence[int]) -- Row pointers.

                            • J (Sequence[int]) -- Column indices.

                            • V (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesSourcecodeatpetsc4py/PETSc/Mat.pyx:2643setValuesIJV(I,J,V,addv=None,rowmap=None)
                     Set a subset of values stored in CSR format.

                     Not collective.

                     Parameters

                            • I (Sequence[int]) -- Row pointers.

                            • J (Sequence[int]) -- Column indices.

                            • V (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                            • rowmap (Sequence[int]) -- Optional iterable indicating which row to insert.

                     ReturntypeNoneSEEALSO:MatSetValuesSourcecodeatpetsc4py/PETSc/Mat.pyx:2612setValuesLocal(rows,cols,values,addv=None)
                     Set values to the rows ⊗ col entries of the matrix in local ordering.

                     Not collective.

                     Parameters

                            • rows (Sequence[int]) -- Local row indices.

                            • cols (Sequence[int]) -- Local column indices.

                            • values (Sequence[Scalar]) -- The scalar values. A  sequence  of  length  at  least
                              len(rows)*len(cols).

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesLocalSourcecodeatpetsc4py/PETSc/Mat.pyx:2834setValuesLocalCSR(I,J,V,addv=None)
                     Set values stored in CSR format.

                     Not collective.

                     Parameters

                            • I (Sequence[int]) -- Row pointers.

                            • J (Sequence[int]) -- Local column indices.

                            • V (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:MatSetValuesLocalSourcecodeatpetsc4py/PETSc/Mat.pyx:2897setValuesLocalIJV(I,J,V,addv=None,rowmap=None)
                     Set a subset of values stored in CSR format.

                     Not collective.

                     Parameters

                            • I (Sequence[int]) -- Row pointers.

                            • J (Sequence[int]) -- Local column indices.

                            • V (Sequence[Scalar]) -- The scalar values.

                            • addv (InsertModeSpec) -- Insertion mode.

                            • rowmap (Sequence[int]) -- Optional iterable indicating which row to insert.

                     ReturntypeNoneSEEALSO:MatSetValuesLocalSourcecodeatpetsc4py/PETSc/Mat.pyx:2866setValuesLocalRCV(R,C,V,addv=None)
                     Undocumented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:2862ReturntypeNonesetValuesRCV(R,C,V,addv=None)
                     Undocumented.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:2608ReturntypeNonesetVariableBlockSizes(blocks)
                     Set diagonal point-blocks of the matrix.

                     Not collective.

                     SEEALSO:setBlockSize, MatSetVariableBlockSizesSourcecodeatpetsc4py/PETSc/Mat.pyx:625Parametersblocks (Sequence[int])

                     ReturntypeNonesetVecType(vec_type)
                     Set the vector type.

                     Collective.

                     Parametersvec_type (Type|str) -- Vector type used when creating vectors with createVecs.

                     ReturntypeNoneSEEALSO:getVecType, MatSetVecTypeSourcecodeatpetsc4py/PETSc/Mat.pyx:639shift(alpha)
                     Shift the matrix.

                     Collective.

                     SEEALSO:MatShiftSourcecodeatpetsc4py/PETSc/Mat.pyx:4108Parametersalpha (Scalar)

                     ReturntypeNonesolve(b,x)
                     Solve Ax=b, given a factored matrix.

                     Neighborwise collective.

                     The  vectors  b  and  x cannot be the same.  Most users should employ the KSP interface for
                     linear solvers instead of working directly with matrix algebra routines.

                     Parameters

                            • b (Vec) -- The right-hand side vector.

                            • x (Vec) -- The output solution vector, must be different than b.

                     ReturntypeNoneSEEALSO:KSP.create, solveTranspose, MatSolveSourcecodeatpetsc4py/PETSc/Mat.pyx:5231solveAdd(b,y,x)
                     Solve x=y+A⁻¹b, given a factored matrix.

                     Neighborwise collective.

                     The vectors b and x cannot be the same.

                     Parameters

                            • b (Vec) -- The right-hand side vector.

                            • y (Vec) -- The vector to be added

                            • x (Vec) -- The output solution vector, must be different than b.

                     ReturntypeNoneSEEALSO:KSP.create, MatSolve, MatSolveAddSourcecodeatpetsc4py/PETSc/Mat.pyx:5275solveBackward(b,x)
                     Solve Ux=b, given a factored matrix A=LU.

                     Neighborwise collective.

                     Parameters

                            • b (Vec) -- The right-hand side vector.

                            • x (Vec) -- The output solution vector.

                     ReturntypeNoneSEEALSO:MatBackwardSolveSourcecodeatpetsc4py/PETSc/Mat.pyx:5212solveForward(b,x)
                     Solve Lx = b, given a factored matrix A = LU.

                     Neighborwise collective.

                     Parameters

                            • b (Vec) -- The right-hand side vector.

                            • x (Vec) -- The output solution vector.

                     ReturntypeNoneSEEALSO:MatForwardSolveSourcecodeatpetsc4py/PETSc/Mat.pyx:5193solveTranspose(b,x)
                     Solve Aᵀx=b, given a factored matrix.

                     Neighborwise collective.

                     The vectors b and x cannot be the same.

                     Parameters

                            • b (Vec) -- The right-hand side vector.

                            • x (Vec) -- The output solution vector, must be different than b.

                     ReturntypeNoneSEEALSO:KSP.create, MatSolve, MatSolveTransposeSourcecodeatpetsc4py/PETSc/Mat.pyx:5254solveTransposeAdd(b,y,x)
                     Solve x=y+A⁻ᵀb, given a factored matrix.

                     Neighborwise collective.

                     The vectors b and x cannot be the same.

                     Parameters

                            • b (Vec) -- The right-hand side vector.

                            • y (Vec) -- The vector to be added

                            • x (Vec) -- The output solution vector, must be different than b.

                     ReturntypeNoneSEEALSO:KSP.create, MatSolve, MatSolveTransposeAddSourcecodeatpetsc4py/PETSc/Mat.pyx:5298storeValues()
                     Stash a copy of the matrix values.

                     Collective.

                     SEEALSO:retrieveValues, MatStoreValuesSourcecodeatpetsc4py/PETSc/Mat.pyx:3278ReturntypeNonetoDLPack(mode='rw')
                     Return a DLPack PyCapsule wrapping the vector data.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5675Parametersmode (AccessModeSpec)

                     ReturntypeAnytranspose(out=None)
                     Return the transposed matrix.

                     Collective.

                     Parametersout (Mat|None) -- Optional  return  matrix.  If  None,  inplace  transposition  is
                            performed.  Otherwise, the matrix is reused.

                     ReturntypeMatSEEALSO:MatTransposeSourcecodeatpetsc4py/PETSc/Mat.pyx:2103transposeMatMult(mat,result=None,fill=None)
                     Perform matrix-matrix multiplication C=AᵀB.

                     Neighborwise collective.

                     Parameters

                            • mat (Mat) -- The right hand matrix B.

                            • result (Mat|None) -- The optional resultant matrix C. When None, a new matrix is
                              created,  and MAT_INITIAL_MATRIX is used. When C is not None, the matrix is reused
                              with MAT_REUSE_MATRIX.

                            • fill (float|None) -- Expected fill as ratio of nnz(C)/(nnz(A) + nnz(B)),  use  ‐
                              None  if  you do not have a good estimate. If the result is a dense matrix this is
                              irrelevant.

                     Returnsresult -- The resultant product matrix C.

                     ReturntypeMat

                     Notes

                     To determine the correct fill value, run with -info and search for the string "Fill  ratio"
                     to see the value actually needed.

                     SEEALSO:MatTransposeMatMult, MatReuseSourcecodeatpetsc4py/PETSc/Mat.pyx:4295view(viewer=None)
                     View the matrix.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNone

                     Notes

                     Viewers  with  type  Viewer.Type.ASCII  are  only  recommended  for small matrices on small
                     numbers of processes. Larger matrices should use a binary format like Viewer.Type.BINARY.

                     SEEALSO:load, Viewer, MatViewSourcecodeatpetsc4py/PETSc/Mat.pyx:450zeroEntries()
                     Zero the entries of the matrix.

                     Collective.

                     SEEALSO:MatZeroEntriesSourcecodeatpetsc4py/PETSc/Mat.pyx:2380ReturntypeNonezeroRows(rows,diag=1,x=None,b=None)
                     Zero selected rows of the matrix.

                     Collective.

                     Parameters

                            • rows (IS|Sequence[int]) -- Row indices to be zeroed.

                            • diag (Scalar) -- Scalar value to be inserted into the diagonal.

                            • x (Vec|None) -- Optional solution vector to be modified for zeroed rows.

                            • b (Vec|None) -- Optional right-hand side vector to  be  modified.   It  will  be
                              adjusted with provided solution entries.

                     ReturntypeNoneSEEALSO:zeroRowsLocal, MatZeroRows, MatZeroRowsISSourcecodeatpetsc4py/PETSc/Mat.pyx:3110zeroRowsColumns(rows,diag=1,x=None,b=None)
                     Zero selected rows and columns of the matrix.

                     Collective.

                     Parameters

                            • rows (IS|Sequence[int]) -- Row/column indices to be zeroed.

                            • diag (Scalar) -- Scalar value to be inserted into the diagonal.

                            • x (Vec|None) -- Optional solution vector to be modified for zeroed rows.

                            • b  (Vec|None)  --  Optional right-hand side vector to be modified.  It will be
                              adjusted with provided solution entries.

                     ReturntypeNoneSEEALSO:zeroRowsColumnsLocal, zeroRows, MatZeroRowsColumns, MatZeroRowsColumnsISSourcecodeatpetsc4py/PETSc/Mat.pyx:3176zeroRowsColumnsLocal(rows,diag=1,x=None,b=None)
                     Zero selected rows and columns of the matrix in local ordering.

                     Collective.

                     Parameters

                            • rows (IS|Sequence[int]) -- Local row/column indices to be zeroed.

                            • diag (Scalar) -- Scalar value to be inserted into the diagonal.

                            • x (Vec|None) -- Optional solution vector to be modified for zeroed rows.

                            • b (Vec|None) -- Optional right-hand side vector to  be  modified.   It  will  be
                              adjusted with provided solution entries.

                     ReturntypeNoneSEEALSO:zeroRowsLocal, zeroRowsColumns, MatZeroRowsColumnsLocal, MatZeroRowsColumnsLocalISSourcecodeatpetsc4py/PETSc/Mat.pyx:3210zeroRowsColumnsStencil(rows,diag=1,x=None,b=None)
                     Zero selected rows and columns of the matrix.

                     Collective.

                     Parameters

                            • rows (Sequence[Stencil]) -- Iterable of stencil rows and columns.

                            • diag (Scalar) -- Scalar value to be inserted into the diagonal.

                            • x (Vec|None) -- Optional solution vector to be modified for zeroed rows.

                            • b  (Vec|None)  --  Optional right-hand side vector to be modified.  It will be
                              adjusted with provided solution entries.

                     ReturntypeNoneSEEALSO:zeroRowsLocal, zeroRowsColumns, MatZeroRowsColumnsStencilSourcecodeatpetsc4py/PETSc/Mat.pyx:3244zeroRowsLocal(rows,diag=1,x=None,b=None)
                     Zero selected rows of the matrix in local ordering.

                     Collective.

                     Parameters

                            • rows (IS|Sequence[int]) -- Local row indices to be zeroed.

                            • diag (Scalar) -- Scalar value to be inserted into the diagonal.

                            • x (Vec|None) -- Optional solution vector to be modified for zeroed rows.

                            • b (Vec|None) -- Optional right-hand side vector to  be  modified.   It  will  be
                              adjusted with provided solution entries.

                     ReturntypeNoneSEEALSO:zeroRows, MatZeroRowsLocal, MatZeroRowsLocalISSourcecodeatpetsc4py/PETSc/Mat.pyx:3143

              Attributes Documentation

              assembled
                     The boolean flag indicating if the matrix is assembled.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5650block_size
                     Matrix block size.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5628block_sizes
                     Matrix row and column block sizes.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5633hermitian
                     The boolean flag indicating if the matrix is Hermitian.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5658local_size
                     Matrix local size.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5623owner_range
                     Matrix local row range.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5638owner_ranges
                     Matrix row ranges.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5643size   Matrix global size.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5618sizes  Matrix local and global sizes.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5610structsymm
                     The boolean flag indicating if the matrix is structurally symmetric.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5662symmetric
                     The boolean flag indicating if the matrix is symmetric.

                     Sourcecodeatpetsc4py/PETSc/Mat.pyx:5654petsc4py.PETSc.MatPartitioningclasspetsc4py.PETSc.MatPartitioning
              Bases: Object

              Object for managing the partitioning of a matrix or graph.

              Enumerations
                                             ┌──────┬─────────────────────────┐
                                             │ Type │ The partitioning types. │
                                             └──────┴─────────────────────────┘

   petsc4py.PETSc.MatPartitioning.Typeclasspetsc4py.PETSc.MatPartitioning.Type
                     Bases: object

                     The partitioning types.

                     Attributes Summary
                                  ┌──────────────────────┬───────────────────────────────────────┐
                                  │ PARTITIONINGAVERAGE  │ Object  PARTITIONINGAVERAGE of type ‐ │
                                  │                      │ str                                   │
                                  ├──────────────────────┼───────────────────────────────────────┤
                                  │ PARTITIONINGCHACO    │ Object PARTITIONINGCHACO of type str  │
                                  ├──────────────────────┼───────────────────────────────────────┤
                                  │ PARTITIONINGCURRENT  │ Object PARTITIONINGCURRENT of type  ‐ │
                                  │                      │ str                                   │
                                  ├──────────────────────┼───────────────────────────────────────┤
                                  │ PARTITIONINGHIERARCH │ Object PARTITIONINGHIERARCH of type ‐ │
                                  │                      │ str                                   │
                                  ├──────────────────────┼───────────────────────────────────────┤
                                  │ PARTITIONINGPARMETIS │ Object PARTITIONINGPARMETIS of type ‐ │
                                  │                      │ str                                   │
                                  ├──────────────────────┼───────────────────────────────────────┤
                                  │ PARTITIONINGPARTY    │ Object PARTITIONINGPARTY of type str  │
                                  ├──────────────────────┼───────────────────────────────────────┤
                                  │ PARTITIONINGPTSCOTCH │ Object PARTITIONINGPTSCOTCH of type ‐ │
                                  │                      │ str                                   │
                                  ├──────────────────────┼───────────────────────────────────────┤
                                  │ PARTITIONINGSQUARE   │ Object PARTITIONINGSQUARE of type str │
                                  └──────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     PARTITIONINGAVERAGE:str=PARTITIONINGAVERAGE
                            Object PARTITIONINGAVERAGE of type strPARTITIONINGCHACO:str=PARTITIONINGCHACO
                            Object PARTITIONINGCHACO of type strPARTITIONINGCURRENT:str=PARTITIONINGCURRENT
                            Object PARTITIONINGCURRENT of type strPARTITIONINGHIERARCH:str=PARTITIONINGHIERARCH
                            Object PARTITIONINGHIERARCH of type strPARTITIONINGPARMETIS:str=PARTITIONINGPARMETIS
                            Object PARTITIONINGPARMETIS of type strPARTITIONINGPARTY:str=PARTITIONINGPARTY
                            Object PARTITIONINGPARTY of type strPARTITIONINGPTSCOTCH:str=PARTITIONINGPTSCOTCH
                            Object PARTITIONINGPTSCOTCH of type strPARTITIONINGSQUARE:str=PARTITIONINGSQUARE
                            Object PARTITIONINGSQUARE of type str

              Methods Summary
                          ┌───────────────────────────────┬───────────────────────────────────────┐
                          │ apply(partitioning)           │ Return  a  partitioning for the graph │
                          │                               │ represented by a sparse matrix.       │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ create([comm])                │ Create a partitioning context.        │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ destroy()                     │ Destroy the partitioning context.     │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ getType()                     │ Return the partitioning method.       │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ setAdjacency(adj)             │ Set the adjacency graph  (matrix)  of │
                          │                               │ the thing to be partitioned.          │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ setFromOptions()              │ Set  parameters  in  the  partitioner │
                          │                               │ from the options database.            │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ setType(matpartitioning_type) │ Set the type of  the  partitioner  to │
                          │                               │ use.                                  │
                          ├───────────────────────────────┼───────────────────────────────────────┤
                          │ view([viewer])                │ View the partitioning data structure. │
                          └───────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              apply(partitioning)
                     Return a partitioning for the graph represented by a sparse matrix.

                     Collective.

                     For each local node this tells the processor number that that node is assigned to.

                     SEEALSO:MatPartitioningApplySourcecodeatpetsc4py/PETSc/MatPartitioning.pyx:144Parameterspartitioning (IS)

                     ReturntypeNonecreate(comm=None)
                     Create a partitioning context.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:destroy, MatPartitioningCreateSourcecodeatpetsc4py/PETSc/MatPartitioning.pyx:62destroy()
                     Destroy the partitioning context.

                     Collective.

                     SEEALSO:create, MatPartitioningDestroySourcecodeatpetsc4py/PETSc/MatPartitioning.pyx:49ReturntypeSelfgetType()
                     Return the partitioning method.

                     Not collective.

                     SEEALSO:setType, MatPartitioningGetTypeSourcecodeatpetsc4py/PETSc/MatPartitioning.pyx:100ReturntypestrsetAdjacency(adj)
                     Set the adjacency graph (matrix) of the thing to be partitioned.

                     Collective.

                     Parametersadj  (Mat)  --  The  adjacency  matrix,  this  can  be  any Mat.Type but the natural
                            representation is Mat.Type.MPIADJ.

                     ReturntypeNoneSEEALSO:MatPartitioningSetAdjacencySourcecodeatpetsc4py/PETSc/MatPartitioning.pyx:126setFromOptions()
                     Set parameters in the partitioner from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, MatPartitioningSetFromOptionsSourcecodeatpetsc4py/PETSc/MatPartitioning.pyx:114ReturntypeNonesetType(matpartitioning_type)
                     Set the type of the partitioner to use.

                     Collective.

                     Parametersmatpartitioning_type (Type|str) -- The partitioner type.

                     ReturntypeNoneSEEALSO:getType, MatPartitioningSetTypeSourcecodeatpetsc4py/PETSc/MatPartitioning.pyx:81view(viewer=None)
                     View the partitioning data structure.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the graph.

                     ReturntypeNoneSEEALSO:MatPartitioningViewSourcecodeatpetsc4py/PETSc/MatPartitioning.pyx:29petsc4py.PETSc.NormTypeclasspetsc4py.PETSc.NormType
              Bases: object

              Norm type.

              Commonly used norm types:

              N1     The one norm.

              N2     The two norm.

              FROBENIUS
                     The Frobenius norm.

              INFINITY
                     The infinity norm.

              SEEALSO:NormType

              Attributes Summary
                                  ┌────────────────┬─────────────────────────────────────┐
                                  │ FRB            │ Constant FRB of type int            │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ FROBENIUS      │ Constant FROBENIUS of type int      │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ INF            │ Constant INF of type int            │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ INFINITY       │ Constant INFINITY of type int       │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ MAX            │ Constant MAX of type int            │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ N1             │ Constant N1 of type int             │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ N12            │ Constant N12 of type int            │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ N2             │ Constant N2 of type int             │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ NORM_1         │ Constant NORM_1 of type int         │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ NORM_1_AND_2   │ Constant NORM_1_AND_2 of type int   │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ NORM_2         │ Constant NORM_2 of type int         │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ NORM_FROBENIUS │ Constant NORM_FROBENIUS of type int │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ NORM_INFINITY  │ Constant NORM_INFINITY of type int  │
                                  ├────────────────┼─────────────────────────────────────┤
                                  │ NORM_MAX       │ Constant NORM_MAX of type int       │
                                  └────────────────┴─────────────────────────────────────┘

              Attributes Documentation

              FRB:int=FRB
                     Constant FRB of type intFROBENIUS:int=FROBENIUS
                     Constant FROBENIUS of type intINF:int=INF
                     Constant INF of type intINFINITY:int=INFINITY
                     Constant INFINITY of type intMAX:int=MAX
                     Constant MAX of type intN1:int=N1
                     Constant N1 of type intN12:int=N12
                     Constant N12 of type intN2:int=N2
                     Constant N2 of type intNORM_1:int=NORM_1
                     Constant NORM_1 of type intNORM_1_AND_2:int=NORM_1_AND_2
                     Constant NORM_1_AND_2 of type intNORM_2:int=NORM_2
                     Constant NORM_2 of type intNORM_FROBENIUS:int=NORM_FROBENIUS
                     Constant NORM_FROBENIUS of type intNORM_INFINITY:int=NORM_INFINITY
                     Constant NORM_INFINITY of type intNORM_MAX:int=NORM_MAX
                     Constant NORM_MAX of type intpetsc4py.PETSc.NullSpaceclasspetsc4py.PETSc.NullSpace
              Bases: Object

              Nullspace object.

              SEEALSO:MatNullSpace

              Methods Summary
                      ┌──────────────────────────────────────┬───────────────────────────────────────┐
                      │ create([constant, vectors, comm])    │ Create the null space.                │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ createRigidBody(coords)              │ Create   rigid   body   modes    from │
                      │                                      │ coordinates.                          │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                            │ Destroy the null space.               │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFunction()                        │ Return  the  callback  to  remove the │
                      │                                      │ nullspace.                            │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getVecs()                            │ Return the vectors defining the  null │
                      │                                      │ space.                                │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ hasConstant()                        │ Return   whether   the   null   space │
                      │                                      │ contains the constant.                │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ remove(vec)                          │ Remove all components of a null space │
                      │                                      │ from a vector.                        │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFunction(function[, args, kargs]) │ Set  the  callback  to   remove   the │
                      │                                      │ nullspace.                            │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ test(mat)                            │ Return  if  the claimed null space is │
                      │                                      │ valid for a matrix.                   │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                       │ View the null space.                  │
                      └──────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(constant=False,vectors=(),comm=None)
                     Create the null space.

                     Collective.

                     Parameters

                            • constant (bool) -- A flag to indicate the null space contains the constant vector.

                            • vectors (Sequence[Vec]) -- The sequence of vectors that span the null space.

                            • comm -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:destroy, MatNullSpaceCreateSourcecodeatpetsc4py/PETSc/Mat.pyx:5799createRigidBody(coords)
                     Create rigid body modes from coordinates.

                     Collective.

                     Parameterscoords (Vec) -- The block coordinates of each node.  Requires the block size to have
                            been set.

                     ReturntypeSelfSEEALSO:MatNullSpaceCreateRigidBodySourcecodeatpetsc4py/PETSc/Mat.pyx:5835destroy()
                     Destroy the null space.

                     Collective.

                     SEEALSO:create, MatNullSpaceDestroySourcecodeatpetsc4py/PETSc/Mat.pyx:5786ReturntypeSelfgetFunction()
                     Return the callback to remove the nullspace.

                     Not collective.

                     SEEALSO:setFunctionSourcecodeatpetsc4py/PETSc/Mat.pyx:5926ReturntypeMatNullFunctiongetVecs()
                     Return the vectors defining the null space.

                     Not collective.

                     SEEALSO:MatNullSpaceGetVecsSourcecodeatpetsc4py/PETSc/Mat.pyx:5904Returntypelist[Vec]

              hasConstant()
                     Return whether the null space contains the constant.

                     Not collective.

                     SEEALSO:MatNullSpaceGetVecsSourcecodeatpetsc4py/PETSc/Mat.pyx:5890Returntypeboolremove(vec)
                     Remove all components of a null space from a vector.

                     Collective.

                     Parametersvec (Vec) -- The vector from which the null space is removed.

                     ReturntypeNoneSEEALSO:MatNullSpaceRemoveSourcecodeatpetsc4py/PETSc/Mat.pyx:5940setFunction(function,args=None,kargs=None)
                     Set the callback to remove the nullspace.

                     Logically collective.

                     Parameters

                            • function (MatNullFunction) -- The callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getFunction, MatNullSpaceSetFunctionSourcecodeatpetsc4py/PETSc/Mat.pyx:5856test(mat)
                     Return if the claimed null space is valid for a matrix.

                     Collective.

                     Parametersmat (Mat) -- The matrix to check.

                     ReturntypeboolSEEALSO:MatNullSpaceTestSourcecodeatpetsc4py/PETSc/Mat.pyx:5957view(viewer=None)
                     View the null space.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:Viewer, MatNullSpaceViewSourcecodeatpetsc4py/PETSc/Mat.pyx:5767petsc4py.PETSc.Objectclasspetsc4py.PETSc.Object
              Bases: object

              Base class wrapping a PETSc object.

              SEEALSO:PetscObject

              Methods Summary
                        ┌──────────────────────────────────┬───────────────────────────────────────┐
                        │ appendOptionsPrefix(prefix)      │ Append  to  the   prefix   used   for │
                        │                                  │ searching    for   options   in   the │
                        │                                  │ database.                             │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ compose(name, obj)               │ Associate a PETSc object using a  key │
                        │                                  │ string.                               │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ decRef()                         │ Decrement the object reference count. │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ destroy()                        │ Destroy the object.                   │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ destroyOptionsHandlers()         │ Clear all the option handlers.        │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getAttr(name)                    │ Return  the attribute associated with │
                        │                                  │ a given name.                         │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getClassId()                     │ Return the class  identifier  of  the │
                        │                                  │ object.                               │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getClassName()                   │ Return the class name of the object.  │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getComm()                        │ Return   the   communicator   of  the │
                        │                                  │ object.                               │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getDict()                        │ Return the dictionary of attributes.  │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getId()                          │ Return the unique identifier  of  the │
                        │                                  │ object.                               │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getName()                        │ Return the name of the object.        │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getOptionsPrefix()               │ Return  the prefix used for searching │
                        │                                  │ for options in the database.          │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getRefCount()                    │ Return the  reference  count  of  the │
                        │                                  │ object.                               │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getTabLevel()                    │ Return the PETSc object tab level.    │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ getType()                        │ Return the object type name.          │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ incRef()                         │ Increment the object reference count. │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ incrementTabLevel(tab[, parent]) │ Increment the PETSc object tab level. │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ query(name)                      │ Query for the PETSc object associated │
                        │                                  │ with a key string.                    │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ setAttr(name, attr)              │ Set  an the attribute associated with │
                        │                                  │ a given name.                         │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ setFromOptions()                 │ Configure the object from the options │
                        │                                  │ database.                             │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ setName(name)                    │ Associate a name to the object.       │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ setOptionsHandler(handler)       │ Set the callback for processing extra │
                        │                                  │ options.                              │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ setOptionsPrefix(prefix)         │ Set the prefix used for searching for │
                        │                                  │ options in the database.              │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ setTabLevel(level)               │ Set the PETSc object tab level.       │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ stateGet()                       │ Return the PETSc object state.        │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ stateIncrease()                  │ Increment the PETSc object state.     │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ stateSet(state)                  │ Set the PETSc object state.           │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ view([viewer])                   │ Display the object.                   │
                        ├──────────────────────────────────┼───────────────────────────────────────┤
                        │ viewFromOptions(name[, objpre])  │ View  the  object  via  command  line │
                        │                                  │ options.                              │
                        └──────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                          ┌──────────┬────────────────────────────┐
                                          │ classid  │ The class identifier.      │
                                          ├──────────┼────────────────────────────┤
                                          │ comm     │ The object communicator.   │
                                          ├──────────┼────────────────────────────┤
                                          │ fortran  │ Fortran handle.            │
                                          ├──────────┼────────────────────────────┤
                                          │ handle   │ Handle for ctypes support. │
                                          ├──────────┼────────────────────────────┤
                                          │ id       │ The object identifier.     │
                                          ├──────────┼────────────────────────────┤
                                          │ klass    │ The class name.            │
                                          ├──────────┼────────────────────────────┤
                                          │ name     │ The object name.           │
                                          ├──────────┼────────────────────────────┤
                                          │ prefix   │ Options prefix.            │
                                          ├──────────┼────────────────────────────┤
                                          │ refcount │ Reference count.           │
                                          ├──────────┼────────────────────────────┤
                                          │ type     │ Object type.               │
                                          └──────────┴────────────────────────────┘

              Methods Documentation

              appendOptionsPrefix(prefix)
                     Append to the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, PetscObjectAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/Object.pyx:138Parametersprefix (str|None)

                     ReturntypeNonecompose(name,obj)
                     Associate a PETSc object using a key string.

                     Logically collective.

                     Parameters

                            • name (str|None) -- The string identifying the object to be composed.

                            • obj (Object) -- The object to be composed.

                     ReturntypeNoneSEEALSO:query, PetscObjectComposeSourcecodeatpetsc4py/PETSc/Object.pyx:329decRef()
                     Decrement the object reference count.

                     Logically collective.

                     SEEALSO:getRefCount, PetscObjectDereferenceSourcecodeatpetsc4py/PETSc/Object.pyx:389Returntypeintdestroy()
                     Destroy the object.

                     Collective.

                     SEEALSO:PetscObjectDestroySourcecodeatpetsc4py/PETSc/Object.pyx:81ReturntypeSelfdestroyOptionsHandlers()
                     Clear all the option handlers.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsHandler, PetscObjectDestroyOptionsHandlersSourcecodeatpetsc4py/PETSc/Object.pyx:213ReturntypeNonegetAttr(name)
                     Return the attribute associated with a given name.

                     Not collective.

                     SEEALSO:setAttr, getDictSourcecodeatpetsc4py/PETSc/Object.pyx:408Parametersname (str)

                     ReturntypeobjectgetClassId()
                     Return the class identifier of the object.

                     Not collective.

                     SEEALSO:PetscObjectGetClassIdSourcecodeatpetsc4py/PETSc/Object.pyx:270ReturntypeintgetClassName()
                     Return the class name of the object.

                     Not collective.

                     SEEALSO:PetscObjectGetClassNameSourcecodeatpetsc4py/PETSc/Object.pyx:284ReturntypestrgetComm()
                     Return the communicator of the object.

                     Not collective.

                     SEEALSO:PetscObjectGetCommSourcecodeatpetsc4py/PETSc/Object.pyx:228ReturntypeCommgetDict()
                     Return the dictionary of attributes.

                     Not collective.

                     SEEALSO:setAttr, getAttrSourcecodeatpetsc4py/PETSc/Object.pyx:436ReturntypedictgetId()
                     Return the unique identifier of the object.

                     Not collective.

                     SEEALSO:PetscObjectGetIdSourcecodeatpetsc4py/PETSc/Object.pyx:313ReturntypeintgetName()
                     Return the name of the object.

                     Not collective.

                     SEEALSO:PetscObjectGetNameSourcecodeatpetsc4py/PETSc/Object.pyx:242ReturntypestrgetOptionsPrefix()
                     Return the prefix used for searching for options in the database.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, PetscObjectGetOptionsPrefixSourcecodeatpetsc4py/PETSc/Object.pyx:124ReturntypestrgetRefCount()
                     Return the reference count of the object.

                     Not collective.

                     SEEALSO:PetscObjectGetReferenceSourcecodeatpetsc4py/PETSc/Object.pyx:298ReturntypeintgetTabLevel()
                     Return the PETSc object tab level.

                     Not collective.

                     SEEALSO:setTabLevel, incrementTabLevel, PetscObjectGetTabLevelSourcecodeatpetsc4py/PETSc/Object.pyx:518ReturntypeNonegetType()
                     Return the object type name.

                     Not collective.

                     SEEALSO:PetscObjectGetTypeSourcecodeatpetsc4py/PETSc/Object.pyx:94ReturntypestrincRef()
                     Increment the object reference count.

                     Logically collective.

                     SEEALSO:getRefCount, PetscObjectReferenceSourcecodeatpetsc4py/PETSc/Object.pyx:372ReturntypeintincrementTabLevel(tab,parent=None)
                     Increment the PETSc object tab level.

                     Logically collective.

                     SEEALSO:setTabLevel, getTabLevel, PetscObjectIncrementTabLevelSourcecodeatpetsc4py/PETSc/Object.pyx:491Parameters

                            • tab (int)

                            • parent (Object|None)

                     ReturntypeNonequery(name)
                     Query for the PETSc object associated with a key string.

                     Not collective.

                     SEEALSO:compose, PetscObjectQuerySourcecodeatpetsc4py/PETSc/Object.pyx:352Parametersname (str)

                     ReturntypeObjectsetAttr(name,attr)
                     Set an the attribute associated with a given name.

                     Not collective.

                     SEEALSO:getAttr, getDictSourcecodeatpetsc4py/PETSc/Object.pyx:422Parameters

                            • name (str)

                            • attr (object)

                     ReturntypeNonesetFromOptions()
                     Configure the object from the options database.

                     Collective.

                     Classes  that  do  not  implement  setFromOptions  use  this  method that, in turn, calls ‐
                     PetscObjectSetFromOptions.

                     SEEALSO:WorkingwithPETScoptions, PetscObjectSetFromOptionsSourcecodeatpetsc4py/PETSc/Object.pyx:152ReturntypeNonesetName(name)
                     Associate a name to the object.

                     Not collective.

                     SEEALSO:PetscObjectSetNameSourcecodeatpetsc4py/PETSc/Object.pyx:256Parametersname (str|None)

                     ReturntypeNonesetOptionsHandler(handler)
                     Set the callback for processing extra options.

                     Logically collective.

                     Parametershandler (PetscOptionsHandlerFunction|None) -- The callback function, called at the
                            end of a setFromOptions invocation for the given class.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions,    Mat.setFromOptions,    KSP.setFromOptions,     ‐
                        PetscObjectAddOptionsHandlerSourcecodeatpetsc4py/PETSc/Object.pyx:190setOptionsPrefix(prefix)
                     Set the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, getOptionsPrefix, PetscObjectSetOptionsPrefixSourcecodeatpetsc4py/PETSc/Object.pyx:110Parametersprefix (str|None)

                     ReturntypeNonesetTabLevel(level)
                     Set the PETSc object tab level.

                     Logically collective.

                     SEEALSO:incrementTabLevel, getTabLevel, PetscObjectSetTabLevelSourcecodeatpetsc4py/PETSc/Object.pyx:505Parameterslevel (int)

                     ReturntypeNonestateGet()
                     Return the PETSc object state.

                     Not collective.

                     SEEALSO:stateSet, stateIncrease, PetscObjectStateGetSourcecodeatpetsc4py/PETSc/Object.pyx:462ReturntypeintstateIncrease()
                     Increment the PETSc object state.

                     Logically collective.

                     SEEALSO:stateGet, stateSet, PetscObjectStateIncreaseSourcecodeatpetsc4py/PETSc/Object.pyx:450ReturntypeNonestateSet(state)
                     Set the PETSc object state.

                     Logically collective.

                     SEEALSO:stateIncrease, stateGet, PetscObjectStateSetSourcecodeatpetsc4py/PETSc/Object.pyx:476Parametersstate (int)

                     ReturntypeNoneview(viewer=None)
                     Display the object.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:PetscObjectViewSourcecodeatpetsc4py/PETSc/Object.pyx:62viewFromOptions(name,objpre=None)
                     View the object via command line options.

                     Collective.

                     Parameters

                            • name (str) -- The command line option.

                            • objpre (Object|None) -- Optional object that provides prefix.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, PetscObjectViewFromOptionsSourcecodeatpetsc4py/PETSc/Object.pyx:167

              Attributes Documentation

              classid
                     The class identifier.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:563comm   The object communicator.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:550fortran
                     Fortran handle.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:593handle Handle for ctypes support.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:585id     The object identifier.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:568klass  The class name.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:573name   The object name.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:555prefix Options prefix.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:542refcount
                     Reference count.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:578type   Object type.

                     Sourcecodeatpetsc4py/PETSc/Object.pyx:534petsc4py.PETSc.Optionsclasspetsc4py.PETSc.Options
              Bases: object

              The options database object.

              A dictionary-like object to store and operate with command line options.

              Parametersprefix (str, optional) -- Optional string to prepend to all the options.

              Examples

              Create an option database and operate with it.

              >>> from petsc4py import PETSc
              >>> opts = PETSc.Options()
              >>> opts['a'] = 1 # insert the command-line option '-a 1'
              >>> if 'a' in opts: # if the option is present
              >>>     val = opts['a'] # return the option value as 'str'
              >>> a_int = opts.getInt('a') # return the option value as 'int'
              >>> a_bool = opts.getBool('a') # return the option value as 'bool'

              Read command line and use default values.

              >>> from petsc4py import PETSc
              >>> opts = PETSc.Options()
              >>> b_float = opts.getReal('b', 1) # return the value or 1.0 if not present

              Read command line options prepended with a prefix.

              >>> from petsc4py import PETSc
              >>> opts = PETSc.Options('prefix_')
              >>> opts.getString('b', 'some_default_string') # read -prefix_b xxx

              SEEALSO:WorkingwithPETScoptions

              Methods Summary
                         ┌─────────────────────────────────┬───────────────────────────────────────┐
                         │ clear()                         │ Clear an options database.            │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ create()                        │ Create an options database.           │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ delValue(name)                  │ Delete an option from the database.   │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ destroy()                       │ Destroy an options database.          │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getAll()                        │ Return  all  the  options  and  their │
                         │                                 │ values.                               │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getBool(name[, default])        │ Return the boolean  value  associated │
                         │                                 │ with the option.                      │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getBoolArray(name[, default])   │ Return  the boolean values associated │
                         │                                 │ with the option.                      │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getInt(name[, default])         │ Return the integer  value  associated │
                         │                                 │ with the option.                      │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getIntArray(name[, default])    │ Return  the  integer array associated │
                         │                                 │ with the option.                      │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getReal(name[, default])        │ Return the real value associated with │
                         │                                 │ the option.                           │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getRealArray(name[, default])   │ Return the real array associated with │
                         │                                 │ the option.                           │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getScalar(name[, default])      │ Return the  scalar  value  associated │
                         │                                 │ with the option.                      │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getScalarArray(name[, default]) │ Return  the  scalar  array associated │
                         │                                 │ with the option.                      │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ getString(name[, default])      │ Return the string associated with the │
                         │                                 │ option.                               │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ hasName(name)                   │ Return the boolean indicating if  the │
                         │                                 │ option is in the database.            │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ insertString(string)            │ Insert   a   string  in  the  options │
                         │                                 │ database.                             │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ prefixPop()                     │ Pop  a   prefix   for   the   options │
                         │                                 │ database.                             │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ prefixPush(prefix)              │ Push   a   prefix   for  the  options │
                         │                                 │ database.                             │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ setValue(name, value)           │ Set a value for an option.            │
                         ├─────────────────────────────────┼───────────────────────────────────────┤
                         │ view([viewer])                  │ View the options database.            │
                         └─────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                              ┌────────┬─────────────────────┐
                                              │ prefix │ Prefix for options. │
                                              └────────┴─────────────────────┘

              Methods Documentation

              clear()
                     Clear an options database.

                     Sourcecodeatpetsc4py/PETSc/Options.pyx:91ReturntypeSelfcreate()
                     Create an options database.

                     Sourcecodeatpetsc4py/PETSc/Options.pyx:79ReturntypeSelfdelValue(name)
                     Delete an option from the database.

                     Logically collective.

                     SEEALSO:setValue, PetscOptionsClearValueSourcecodeatpetsc4py/PETSc/Options.pyx:195Parametersname (str)

                     ReturntypeNonedestroy()
                     Destroy an options database.

                     Sourcecodeatpetsc4py/PETSc/Options.pyx:85ReturntypeSelfgetAll()
                     Return all the options and their values.

                     Not collective.

                     SEEALSO:PetscOptionsGetAllSourcecodeatpetsc4py/PETSc/Options.pyx:414Returntypedict[str, str]

              getBool(name,default=None)
                     Return the boolean value associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default -- The default value.  If None, it raises a KeyError if the option is  not
                              found.

                     ReturntypeboolSEEALSO:getBoolArray, PetscOptionsGetBoolSourcecodeatpetsc4py/PETSc/Options.pyx:218getBoolArray(name,default=None)
                     Return the boolean values associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default  -- The default value.  If None, it raises a KeyError if the option is not
                              found.

                     ReturntypeArrayBoolSEEALSO:getBool, PetscOptionsGetBoolArraySourcecodeatpetsc4py/PETSc/Options.pyx:238getInt(name,default=None)
                     Return the integer value associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default -- The default value.  If None, it raises a KeyError if the option is  not
                              found.

                     ReturntypeintSEEALSO:getIntArray, PetscOptionsGetIntSourcecodeatpetsc4py/PETSc/Options.pyx:258getIntArray(name,default=None)
                     Return the integer array associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default  -- The default value.  If None, it raises a KeyError if the option is not
                              found.

                     ReturntypeArrayIntSEEALSO:getInt, PetscOptionsGetIntArraySourcecodeatpetsc4py/PETSc/Options.pyx:278getReal(name,default=None)
                     Return the real value associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default -- The default value.  If None, it raises a KeyError if the option is  not
                              found.

                     ReturntypefloatSEEALSO:getRealArray, PetscOptionsGetRealSourcecodeatpetsc4py/PETSc/Options.pyx:298getRealArray(name,default=None)
                     Return the real array associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default  -- The default value.  If None, it raises a KeyError if the option is not
                              found.

                     ReturntypeArrayRealSEEALSO:getReal, PetscOptionsGetRealArraySourcecodeatpetsc4py/PETSc/Options.pyx:318getScalar(name,default=None)
                     Return the scalar value associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default -- The default value.  If None, it raises a KeyError if the option is  not
                              found.

                     ReturntypeScalarSEEALSO:getScalarArray, PetscOptionsGetScalarSourcecodeatpetsc4py/PETSc/Options.pyx:338getScalarArray(name,default=None)
                     Return the scalar array associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default  -- The default value.  If None, it raises a KeyError if the option is not
                              found.

                     ReturntypeArrayScalarSEEALSO:getScalar, PetscOptionsGetScalarArraySourcecodeatpetsc4py/PETSc/Options.pyx:358getString(name,default=None)
                     Return the string associated with the option.

                     Not collective.

                     Parameters

                            • name (str) -- The option name.

                            • default -- The default value.  If None, it raises a KeyError if the option is  not
                              found.

                     ReturntypestrSEEALSO:PetscOptionsGetStringSourcecodeatpetsc4py/PETSc/Options.pyx:378hasName(name)
                     Return the boolean indicating if the option is in the database.

                     Sourcecodeatpetsc4py/PETSc/Options.pyx:144Parametersname (str)

                     ReturntypeboolinsertString(string)
                     Insert a string in the options database.

                     Logically collective.

                     SEEALSO:PetscOptionsInsertStringSourcecodeatpetsc4py/PETSc/Options.pyx:400Parametersstring (str)

                     ReturntypeNoneprefixPop()
                     Pop a prefix for the options database.

                     Logically collective.

                     SEEALSO:prefixPush, PetscOptionsPrefixPopSourcecodeatpetsc4py/PETSc/Options.pyx:131ReturntypeNoneprefixPush(prefix)
                     Push a prefix for the options database.

                     Logically collective.

                     SEEALSO:prefixPop, PetscOptionsPrefixPushSourcecodeatpetsc4py/PETSc/Options.pyx:116Parametersprefix (str|Options|Object|None)

                     ReturntypeNonesetValue(name,value)
                     Set a value for an option.

                     Logically collective.

                     Parameters

                            • name (str) -- The string identifying the option.

                            • value  (bool|int|float|Scalar|Sequence[bool]|Sequence[int]|Sequence[‐
                              float]|Sequence[Scalar]|str) -- The option value.

                     ReturntypeNoneSEEALSO:delValue, PetscOptionsSetValueSourcecodeatpetsc4py/PETSc/Options.pyx:153view(viewer=None)
                     View the options database.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:Viewer, PetscOptionsViewSourcecodeatpetsc4py/PETSc/Options.pyx:97

              Attributes Documentation

              prefix Prefix for options.

                     Sourcecodeatpetsc4py/PETSc/Options.pyx:67petsc4py.PETSc.PCclasspetsc4py.PETSc.PC
              Bases: Object

              Preconditioners.

              PC is described in the PETScmanual.  Calling the PC with a vector as an argument will  apply  the
              preconditioner as shown in the example below.

              Examples

              >>> from petsc4py import PETSc
              >>> v = PETSc.Vec().createWithArray([1, 2])
              >>> m = PETSc.Mat().createDense(2, array=[[1, 0], [0, 1]])
              >>> pc = PETSc.PC().create()
              >>> pc.setOperators(m)
              >>> u = pc(v) # u is created internally
              >>> pc.apply(v, u) # u can also be passed as second argument

              SEEALSO:PC

              Enumerations
                            ┌───────────────────────────┬───────────────────────────────────────┐
                            │ ASMType                   │ The ASM subtype.                      │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ CompositeType             │ The composite type.                   │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ DeflationSpaceType        │ The deflation space subtype.          │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ FailedReason              │ The  reason  the  preconditioner  has │
                            │                           │ failed.                               │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ FieldSplitSchurFactType   │ The field split  Schur  factorization │
                            │                           │ type.                                 │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ FieldSplitSchurPreType    │ The field split Schur subtype.        │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ GAMGType                  │ The GAMG subtype.                     │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ GASMType                  │ The GASM subtype.                     │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ HPDDMCoarseCorrectionType │ The HPDDM coarse correction type.     │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ MGCycleType               │ The MG cycle type.                    │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ MGType                    │ The MG subtype.                       │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ PatchConstructType        │ The patch construction type.          │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ Side                      │ The     manner     in    which    the │
                            │                           │ preconditioner is applied.            │
                            ├───────────────────────────┼───────────────────────────────────────┤
                            │ Type                      │ The preconditioner method.            │
                            └───────────────────────────┴───────────────────────────────────────┘

   petsc4py.PETSc.PC.ASMTypeclasspetsc4py.PETSc.PC.ASMType
                     Bases: object

                     The ASM subtype.

                     Attributes Summary
                                         ┌─────────────┬──────────────────────────────────┐
                                         │ BASIC       │ Constant BASIC of type int       │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ INTERPOLATE │ Constant INTERPOLATE of type int │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ NONE        │ Constant NONE of type int        │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ RESTRICT    │ Constant RESTRICT of type int    │
                                         └─────────────┴──────────────────────────────────┘

                     Attributes Documentation

                     BASIC:int=BASIC
                            Constant BASIC of type intINTERPOLATE:int=INTERPOLATE
                            Constant INTERPOLATE of type intNONE:int=NONE
                            Constant NONE of type intRESTRICT:int=RESTRICT
                            Constant RESTRICT of type intpetsc4py.PETSc.PC.CompositeTypeclasspetsc4py.PETSc.PC.CompositeType
                     Bases: object

                     The composite type.

                     Attributes Summary
                                ┌──────────────────────────┬───────────────────────────────────────┐
                                │ ADDITIVE                 │ Constant ADDITIVE of type int         │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ MULTIPLICATIVE           │ Constant MULTIPLICATIVE of type int   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ SCHUR                    │ Constant SCHUR of type int            │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ SPECIAL                  │ Constant SPECIAL of type int          │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ SYMMETRIC_MULTIPLICATIVE │ Constant SYMMETRIC_MULTIPLICATIVE  of │
                                │                          │ type int                              │
                                └──────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     ADDITIVE:int=ADDITIVE
                            Constant ADDITIVE of type intMULTIPLICATIVE:int=MULTIPLICATIVE
                            Constant MULTIPLICATIVE of type intSCHUR:int=SCHUR
                            Constant SCHUR of type intSPECIAL:int=SPECIAL
                            Constant SPECIAL of type intSYMMETRIC_MULTIPLICATIVE:int=SYMMETRIC_MULTIPLICATIVE
                            Constant SYMMETRIC_MULTIPLICATIVE of type intpetsc4py.PETSc.PC.DeflationSpaceTypeclasspetsc4py.PETSc.PC.DeflationSpaceType
                     Bases: object

                     The deflation space subtype.

                     Attributes Summary
                                         ┌─────────────┬──────────────────────────────────┐
                                         │ AGGREGATION │ Constant AGGREGATION of type int │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ BIORTH22    │ Constant BIORTH22 of type int    │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ DB16        │ Constant DB16 of type int        │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ DB2         │ Constant DB2 of type int         │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ DB4         │ Constant DB4 of type int         │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ DB8         │ Constant DB8 of type int         │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ HAAR        │ Constant HAAR of type int        │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ MEYER       │ Constant MEYER of type int       │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ USER        │ Constant USER of type int        │
                                         └─────────────┴──────────────────────────────────┘

                     Attributes Documentation

                     AGGREGATION:int=AGGREGATION
                            Constant AGGREGATION of type intBIORTH22:int=BIORTH22
                            Constant BIORTH22 of type intDB16:int=DB16
                            Constant DB16 of type intDB2:int=DB2
                            Constant DB2 of type intDB4:int=DB4
                            Constant DB4 of type intDB8:int=DB8
                            Constant DB8 of type intHAAR:int=HAAR
                            Constant HAAR of type intMEYER:int=MEYER
                            Constant MEYER of type intUSER:int=USER
                            Constant USER of type intpetsc4py.PETSc.PC.FailedReasonclasspetsc4py.PETSc.PC.FailedReason
                     Bases: object

                     The reason the preconditioner has failed.

                     Attributes Summary
                                ┌──────────────────────────┬───────────────────────────────────────┐
                                │ FACTOR_NUMERIC_ZEROPIVOT │ Constant  FACTOR_NUMERIC_ZEROPIVOT of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ FACTOR_OTHER             │ Constant FACTOR_OTHER of type int     │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ FACTOR_OUTMEMORY         │ Constant FACTOR_OUTMEMORY of type int │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ FACTOR_STRUCT_ZEROPIVOT  │ Constant  FACTOR_STRUCT_ZEROPIVOT  of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ NOERROR                  │ Constant NOERROR of type int          │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ SETUP_ERROR              │ Constant SETUP_ERROR of type int      │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ SUBPC_ERROR              │ Constant SUBPC_ERROR of type int      │
                                └──────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     FACTOR_NUMERIC_ZEROPIVOT:int=FACTOR_NUMERIC_ZEROPIVOT
                            Constant FACTOR_NUMERIC_ZEROPIVOT of type intFACTOR_OTHER:int=FACTOR_OTHER
                            Constant FACTOR_OTHER of type intFACTOR_OUTMEMORY:int=FACTOR_OUTMEMORY
                            Constant FACTOR_OUTMEMORY of type intFACTOR_STRUCT_ZEROPIVOT:int=FACTOR_STRUCT_ZEROPIVOT
                            Constant FACTOR_STRUCT_ZEROPIVOT of type intNOERROR:int=NOERROR
                            Constant NOERROR of type intSETUP_ERROR:int=SETUP_ERROR
                            Constant SETUP_ERROR of type intSUBPC_ERROR:int=SUBPC_ERROR
                            Constant SUBPC_ERROR of type intpetsc4py.PETSc.PC.FieldSplitSchurFactTypeclasspetsc4py.PETSc.PC.FieldSplitSchurFactType
                     Bases: object

                     The field split Schur factorization type.

                     Attributes Summary
                                               ┌───────┬────────────────────────────┐
                                               │ DIAG  │ Constant DIAG of type int  │
                                               ├───────┼────────────────────────────┤
                                               │ FULL  │ Constant FULL of type int  │
                                               ├───────┼────────────────────────────┤
                                               │ LOWER │ Constant LOWER of type int │
                                               ├───────┼────────────────────────────┤
                                               │ UPPER │ Constant UPPER of type int │
                                               └───────┴────────────────────────────┘

                     Attributes Documentation

                     DIAG:int=DIAG
                            Constant DIAG of type intFULL:int=FULL
                            Constant FULL of type intLOWER:int=LOWER
                            Constant LOWER of type intUPPER:int=UPPER
                            Constant UPPER of type intpetsc4py.PETSc.PC.FieldSplitSchurPreTypeclasspetsc4py.PETSc.PC.FieldSplitSchurPreType
                     Bases: object

                     The field split Schur subtype.

                     Attributes Summary
                                               ┌───────┬────────────────────────────┐
                                               │ A11   │ Constant A11 of type int   │
                                               ├───────┼────────────────────────────┤
                                               │ FULL  │ Constant FULL of type int  │
                                               ├───────┼────────────────────────────┤
                                               │ SELF  │ Constant SELF of type int  │
                                               ├───────┼────────────────────────────┤
                                               │ SELFP │ Constant SELFP of type int │
                                               ├───────┼────────────────────────────┤
                                               │ USER  │ Constant USER of type int  │
                                               └───────┴────────────────────────────┘

                     Attributes Documentation

                     A11:int=A11
                            Constant A11 of type intFULL:int=FULL
                            Constant FULL of type intSELF:int=SELF
                            Constant SELF of type intSELFP:int=SELFP
                            Constant SELFP of type intUSER:int=USER
                            Constant USER of type intpetsc4py.PETSc.PC.GAMGTypeclasspetsc4py.PETSc.PC.GAMGType
                     Bases: object

                     The GAMG subtype.

                     Attributes Summary
                                            ┌───────────┬──────────────────────────────┐
                                            │ AGG       │ Object AGG of type str       │
                                            ├───────────┼──────────────────────────────┤
                                            │ CLASSICAL │ Object CLASSICAL of type str │
                                            ├───────────┼──────────────────────────────┤
                                            │ GEO       │ Object GEO of type str       │
                                            └───────────┴──────────────────────────────┘

                     Attributes Documentation

                     AGG:str=AGG
                            Object AGG of type strCLASSICAL:str=CLASSICAL
                            Object CLASSICAL of type strGEO:str=GEO
                            Object GEO of type strpetsc4py.PETSc.PC.GASMTypeclasspetsc4py.PETSc.PC.GASMType
                     Bases: object

                     The GASM subtype.

                     Attributes Summary
                                         ┌─────────────┬──────────────────────────────────┐
                                         │ BASIC       │ Constant BASIC of type int       │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ INTERPOLATE │ Constant INTERPOLATE of type int │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ NONE        │ Constant NONE of type int        │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ RESTRICT    │ Constant RESTRICT of type int    │
                                         └─────────────┴──────────────────────────────────┘

                     Attributes Documentation

                     BASIC:int=BASIC
                            Constant BASIC of type intINTERPOLATE:int=INTERPOLATE
                            Constant INTERPOLATE of type intNONE:int=NONE
                            Constant NONE of type intRESTRICT:int=RESTRICT
                            Constant RESTRICT of type intpetsc4py.PETSc.PC.HPDDMCoarseCorrectionTypeclasspetsc4py.PETSc.PC.HPDDMCoarseCorrectionType
                     Bases: object

                     The HPDDM coarse correction type.

                     Attributes Summary
                                            ┌──────────┬───────────────────────────────┐
                                            │ ADDITIVE │ Constant ADDITIVE of type int │
                                            ├──────────┼───────────────────────────────┤
                                            │ BALANCED │ Constant BALANCED of type int │
                                            ├──────────┼───────────────────────────────┤
                                            │ DEFLATED │ Constant DEFLATED of type int │
                                            ├──────────┼───────────────────────────────┤
                                            │ NONE     │ Constant NONE of type int     │
                                            └──────────┴───────────────────────────────┘

                     Attributes Documentation

                     ADDITIVE:int=ADDITIVE
                            Constant ADDITIVE of type intBALANCED:int=BALANCED
                            Constant BALANCED of type intDEFLATED:int=DEFLATED
                            Constant DEFLATED of type intNONE:int=NONE
                            Constant NONE of type intpetsc4py.PETSc.PC.MGCycleTypeclasspetsc4py.PETSc.PC.MGCycleType
                     Bases: object

                     The MG cycle type.

                     Attributes Summary
                                                   ┌───┬────────────────────────┐
                                                   │ V │ Constant V of type int │
                                                   ├───┼────────────────────────┤
                                                   │ W │ Constant W of type int │
                                                   └───┴────────────────────────┘

                     Attributes Documentation

                     V:int=V
                            Constant V of type intW:int=W
                            Constant W of type intpetsc4py.PETSc.PC.MGTypeclasspetsc4py.PETSc.PC.MGType
                     Bases: object

                     The MG subtype.

                     Attributes Summary
                                      ┌────────────────┬─────────────────────────────────────┐
                                      │ ADDITIVE       │ Constant ADDITIVE of type int       │
                                      ├────────────────┼─────────────────────────────────────┤
                                      │ FULL           │ Constant FULL of type int           │
                                      ├────────────────┼─────────────────────────────────────┤
                                      │ KASKADE        │ Constant KASKADE of type int        │
                                      ├────────────────┼─────────────────────────────────────┤
                                      │ MULTIPLICATIVE │ Constant MULTIPLICATIVE of type int │
                                      └────────────────┴─────────────────────────────────────┘

                     Attributes Documentation

                     ADDITIVE:int=ADDITIVE
                            Constant ADDITIVE of type intFULL:int=FULL
                            Constant FULL of type intKASKADE:int=KASKADE
                            Constant KASKADE of type intMULTIPLICATIVE:int=MULTIPLICATIVE
                            Constant MULTIPLICATIVE of type intpetsc4py.PETSc.PC.PatchConstructTypeclasspetsc4py.PETSc.PC.PatchConstructType
                     Bases: object

                     The patch construction type.

                     Attributes Summary
                                           ┌───────────┬────────────────────────────────┐
                                           │ PARDECOMP │ Constant PARDECOMP of type int │
                                           ├───────────┼────────────────────────────────┤
                                           │ PYTHON    │ Constant PYTHON of type int    │
                                           ├───────────┼────────────────────────────────┤
                                           │ STAR      │ Constant STAR of type int      │
                                           ├───────────┼────────────────────────────────┤
                                           │ USER      │ Constant USER of type int      │
                                           ├───────────┼────────────────────────────────┤
                                           │ VANKA     │ Constant VANKA of type int     │
                                           └───────────┴────────────────────────────────┘

                     Attributes Documentation

                     PARDECOMP:int=PARDECOMP
                            Constant PARDECOMP of type intPYTHON:int=PYTHON
                            Constant PYTHON of type intSTAR:int=STAR
                            Constant STAR of type intUSER:int=USER
                            Constant USER of type intVANKA:int=VANKA
                            Constant VANKA of type intpetsc4py.PETSc.PC.Sideclasspetsc4py.PETSc.PC.Side
                     Bases: object

                     The manner in which the preconditioner is applied.

                     Attributes Summary
                                           ┌───────────┬────────────────────────────────┐
                                           │ L         │ Constant L of type int         │
                                           ├───────────┼────────────────────────────────┤
                                           │ LEFT      │ Constant LEFT of type int      │
                                           ├───────────┼────────────────────────────────┤
                                           │ R         │ Constant R of type int         │
                                           ├───────────┼────────────────────────────────┤
                                           │ RIGHT     │ Constant RIGHT of type int     │
                                           ├───────────┼────────────────────────────────┤
                                           │ S         │ Constant S of type int         │
                                           ├───────────┼────────────────────────────────┤
                                           │ SYMMETRIC │ Constant SYMMETRIC of type int │
                                           └───────────┴────────────────────────────────┘

                     Attributes Documentation

                     L:int=L
                            Constant L of type intLEFT:int=LEFT
                            Constant LEFT of type intR:int=R
                            Constant R of type intRIGHT:int=RIGHT
                            Constant RIGHT of type intS:int=S
                            Constant S of type intSYMMETRIC:int=SYMMETRIC
                            Constant SYMMETRIC of type intpetsc4py.PETSc.PC.Typeclasspetsc4py.PETSc.PC.Type
                     Bases: object

                     The preconditioner method.

                     Attributes Summary
                                   ┌────────────────────┬───────────────────────────────────────┐
                                   │ ASM                │ Object ASM of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ BDDC               │ Object BDDC of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ BFBT               │ Object BFBT of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ BJACOBI            │ Object BJACOBI of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ CHOLESKY           │ Object CHOLESKY of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ CHOWILUVIENNACL    │ Object CHOWILUVIENNACL of type str    │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ COMPOSITE          │ Object COMPOSITE of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ CP                 │ Object CP of type str                 │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DEFLATION          │ Object DEFLATION of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ EISENSTAT          │ Object EISENSTAT of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ EXOTIC             │ Object EXOTIC of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ FIELDSPLIT         │ Object FIELDSPLIT of type str         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ GALERKIN           │ Object GALERKIN of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ GAMG               │ Object GAMG of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ GASM               │ Object GASM of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ H2OPUS             │ Object H2OPUS of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HMG                │ Object HMG of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HPDDM              │ Object HPDDM of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HYPRE              │ Object HYPRE of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ICC                │ Object ICC of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ILU                │ Object ILU of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ JACOBI             │ Object JACOBI of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ KACZMARZ           │ Object KACZMARZ of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ KSP                │ Object KSP of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LMVM               │ Object LMVM of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LSC                │ Object LSC of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LU                 │ Object LU of type str                 │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MAT                │ Object MAT of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ MG                 │ Object MG of type str                 │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ML                 │ Object ML of type str                 │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ NN                 │ Object NN of type str                 │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ NONE               │ Object NONE of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ PARMS              │ Object PARMS of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ PATCH              │ Object PATCH of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ PBJACOBI           │ Object PBJACOBI of type str           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ PFMG               │ Object PFMG of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ PYTHON             │ Object PYTHON of type str             │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ QR                 │ Object QR of type str                 │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ REDISTRIBUTE       │ Object REDISTRIBUTE of type str       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ REDUNDANT          │ Object REDUNDANT of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ROWSCALINGVIENNACL │ Object ROWSCALINGVIENNACL of type str │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SAVIENNACL         │ Object SAVIENNACL of type str         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SHELL              │ Object SHELL of type str              │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SOR                │ Object SOR of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SPAI               │ Object SPAI of type str               │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SVD                │ Object SVD of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ SYSPFMG            │ Object SYSPFMG of type str            │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ TELESCOPE          │ Object TELESCOPE of type str          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ TFS                │ Object TFS of type str                │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ VPBJACOBI          │ Object VPBJACOBI of type str          │
                                   └────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     ASM:str=ASM
                            Object ASM of type strBDDC:str=BDDC
                            Object BDDC of type strBFBT:str=BFBT
                            Object BFBT of type strBJACOBI:str=BJACOBI
                            Object BJACOBI of type strCHOLESKY:str=CHOLESKY
                            Object CHOLESKY of type strCHOWILUVIENNACL:str=CHOWILUVIENNACL
                            Object CHOWILUVIENNACL of type strCOMPOSITE:str=COMPOSITE
                            Object COMPOSITE of type strCP:str=CP
                            Object CP of type strDEFLATION:str=DEFLATION
                            Object DEFLATION of type strEISENSTAT:str=EISENSTAT
                            Object EISENSTAT of type strEXOTIC:str=EXOTIC
                            Object EXOTIC of type strFIELDSPLIT:str=FIELDSPLIT
                            Object FIELDSPLIT of type strGALERKIN:str=GALERKIN
                            Object GALERKIN of type strGAMG:str=GAMG
                            Object GAMG of type strGASM:str=GASM
                            Object GASM of type strH2OPUS:str=H2OPUS
                            Object H2OPUS of type strHMG:str=HMG
                            Object HMG of type strHPDDM:str=HPDDM
                            Object HPDDM of type strHYPRE:str=HYPRE
                            Object HYPRE of type strICC:str=ICC
                            Object ICC of type strILU:str=ILU
                            Object ILU of type strJACOBI:str=JACOBI
                            Object JACOBI of type strKACZMARZ:str=KACZMARZ
                            Object KACZMARZ of type strKSP:str=KSP
                            Object KSP of type strLMVM:str=LMVM
                            Object LMVM of type strLSC:str=LSC
                            Object LSC of type strLU:str=LU
                            Object LU of type strMAT:str=MAT
                            Object MAT of type strMG:str=MG
                            Object MG of type strML:str=ML
                            Object ML of type strNN:str=NN
                            Object NN of type strNONE:str=NONE
                            Object NONE of type strPARMS:str=PARMS
                            Object PARMS of type strPATCH:str=PATCH
                            Object PATCH of type strPBJACOBI:str=PBJACOBI
                            Object PBJACOBI of type strPFMG:str=PFMG
                            Object PFMG of type strPYTHON:str=PYTHON
                            Object PYTHON of type strQR:str=QR
                            Object QR of type strREDISTRIBUTE:str=REDISTRIBUTE
                            Object REDISTRIBUTE of type strREDUNDANT:str=REDUNDANT
                            Object REDUNDANT of type strROWSCALINGVIENNACL:str=ROWSCALINGVIENNACL
                            Object ROWSCALINGVIENNACL of type strSAVIENNACL:str=SAVIENNACL
                            Object SAVIENNACL of type strSHELL:str=SHELL
                            Object SHELL of type strSOR:str=SOR
                            Object SOR of type strSPAI:str=SPAI
                            Object SPAI of type strSVD:str=SVD
                            Object SVD of type strSYSPFMG:str=SYSPFMG
                            Object SYSPFMG of type strTELESCOPE:str=TELESCOPE
                            Object TELESCOPE of type strTFS:str=TFS
                            Object TFS of type strVPBJACOBI:str=VPBJACOBI
                            Object VPBJACOBI of type str

              Methods Summary
                 ┌─────────────────────────────────────────────────┬───────────────────────────────────────┐
                 │ addCompositePCType(pc_type)                     │ Add  a  PC  of  the given type to the │
                 │                                                 │ composite PC.                         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ appendOptionsPrefix(prefix)                     │ Append to the prefix used for all the │
                 │                                                 │ PC options.                           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ apply(x, y)                                     │ Apply the PC to a vector.             │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ applySymmetricLeft(x, y)                        │ Apply the left part of a symmetric PC │
                 │                                                 │ to a vector.                          │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ applySymmetricRight(x, y)                       │ Apply the right part of  a  symmetric │
                 │                                                 │ PC to a vector.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ applyTranspose(x, y)                            │ Apply  the  transpose  of the PC to a │
                 │                                                 │ vector.                               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ create([comm])                                  │ Create an empty PC.                   │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ createPython([context, comm])                   │ Create  a  preconditioner  of  Python │
                 │                                                 │ type.                                 │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ destroy()                                       │ Destroy  the PC that was created with │
                 │                                                 │ create.                               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getASMSubKSP()                                  │ Return the local KSP object  for  all │
                 │                                                 │ blocks on this process.               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getCompositePC(n)                               │ Return  a  component of the composite │
                 │                                                 │ PC.                                   │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getDM()                                         │ Return the DM associated with the PC. │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getDeflationCoarseKSP()                         │ Return the coarse problem KSP.        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getDeflationPC()                                │ Return the additional preconditioner. │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getFactorMatrix()                               │ Return the factored matrix.           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getFactorSolverType()                           │ Return the  solver  package  used  to │
                 │                                                 │ perform the factorization.            │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getFailedReason()                               │ Return the reason the PC terminated.  │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getFieldSplitSchurGetSubKSP()                   │ Return   the   KSP   for   the  Schur │
                 │                                                 │ complement based splits.              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getFieldSplitSubIS(splitname)                   │ Return the IS associated with a given │
                 │                                                 │ name.                                 │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getFieldSplitSubKSP()                           │ Return the KSP for all splits.        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getHPDDMCoarseCorrectionType()                  │ Return the coarse correction type.    │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getHPDDMComplexities()                          │ Compute   the   grid   and   operator │
                 │                                                 │ complexities.                         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getHPDDMSTShareSubKSP()                         │ Return  true  if  the KSP in SLEPc ST │
                 │                                                 │ and the subdomain solver is shared.   │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getHYPREType()                                  │ Return the Type.HYPRE type.           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getKSP()                                        │ Return the KSP if the PC is Type.KSP. │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGCoarseSolve()                              │ Return the KSP  used  on  the  coarse │
                 │                                                 │ grid.                                 │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGInterpolation(level)                       │ Return the interpolation operator for │
                 │                                                 │ the given level.                      │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGLevels()                                   │ Return the number of MG levels.       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGRScale(level)                              │ Return  the pointwise scaling for the │
                 │                                                 │ restriction  operator  on  the  given │
                 │                                                 │ level.                                │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGRestriction(level)                         │ Return  the  restriction operator for │
                 │                                                 │ the given level.                      │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGSmoother(level)                            │ Return  the  KSP  to  be  used  as  a │
                 │                                                 │ smoother.                             │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGSmootherDown(level)                        │ Return  the  KSP  to  be  used  as  a │
                 │                                                 │ smoother    before    coarse     grid │
                 │                                                 │ correction.                           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGSmootherUp(level)                          │ Return  the  KSP  to  be  used  as  a │
                 │                                                 │ smoother    after     coarse     grid │
                 │                                                 │ correction.                           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getMGType()                                     │ Return the form of multigrid.         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getOperators()                                  │ Return the matrices associated with a │
                 │                                                 │ linear system.                        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getOptionsPrefix()                              │ Return the prefix used for all the PC │
                 │                                                 │ options.                              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getPatchSubKSP()                                │ Return  the  local KSP object for all │
                 │                                                 │ blocks on this process.               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getPythonContext()                              │ Return  the  instance  of  the  class │
                 │                                                 │ implementing   the   required  Python │
                 │                                                 │ methods.                              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getPythonType()                                 │ Return  the  fully  qualified  Python │
                 │                                                 │ name   of   the  class  used  by  the │
                 │                                                 │ preconditioner.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getType()                                       │ Return the preconditioner type.       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ getUseAmat()                                    │ Return the flag to indicate if PC  is │
                 │                                                 │ applied to A or P.                    │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ matApply(x, y)                                  │ Apply  the  PC to many vectors stored │
                 │                                                 │ as Mat.Type.DENSE.                    │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ reset()                                         │ Reset the PC, removing any  allocated │
                 │                                                 │ vectors and matrices.                 │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setASMLocalSubdomains(nsd[,   is_sub,           │ Set the local subdomains.             │
                 │ is_local])                                      │                                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setASMOverlap(overlap)                          │ Set the overlap  between  a  pair  of │
                 │                                                 │ subdomains.                           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setASMSortIndices(dosort)                       │ Set to sort subdomain indices.        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setASMTotalSubdomains(nsd[,   is_sub,           │ Set the subdomains for all processes. │
                 │ is_local])                                      │                                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setASMType(asmtype)                             │ Set  the  type  of  restriction   and │
                 │                                                 │ interpolation.                        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCChangeOfBasisMat(T[,                     │ Set  a  user  defined change of basis │
                 │ interior])                                      │ for degrees of freedom.               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCCoarseningRatio(cratio)                  │ Set the coarsening ratio used in  the │
                 │                                                 │ multilevel version.                   │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCDirichletBoundaries(bndr)                │ Set   the   IS   defining   Dirichlet │
                 │                                                 │ boundaries for the global problem.    │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCDirichletBoundariesLocal(bndr)           │ Set   the   IS   defining   Dirichlet │
                 │                                                 │ boundaries in local ordering.         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCDiscreteGradient(G[,    order,           │ Set the discrete gradient.            │
                 │ field, ...])                                    │                                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCDivergenceMat(div[,     trans,           │ Set  the linear operator representing │
                 │ l2l])                                           │ ∫ div(u)•p dx.                        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCDofsSplitting(isfields)                  │ Set the index set(s) defining  fields │
                 │                                                 │ of the global matrix.                 │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCDofsSplittingLocal(isfields)             │ Set  the index set(s) defining fields │
                 │                                                 │ of the local subdomain matrix.        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCLevels(levels)                           │ Set the maximum number of  additional │
                 │                                                 │ levels allowed.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCLocalAdjacency(csr)                      │ Provide  a  custom connectivity graph │
                 │                                                 │ for local dofs.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCNeumannBoundaries(bndr)                  │ Set   the   IS    defining    Neumann │
                 │                                                 │ boundaries for the global problem.    │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCNeumannBoundariesLocal(bndr)             │ Set    the    IS   defining   Neumann │
                 │                                                 │ boundaries in local ordering.         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCPrimalVerticesIS(primv)                  │ Set additional  user  defined  primal │
                 │                                                 │ vertices.                             │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setBDDCPrimalVerticesLocalIS(primv)             │ Set  additional  user  defined primal │
                 │                                                 │ vertices.                             │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setCompositeType(ctype)                         │ Set    the    type    of    composite │
                 │                                                 │ preconditioner.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setCoordinates(coordinates)                     │ Set  the coordinates for the nodes on │
                 │                                                 │ the local process.                    │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDM(dm)                                       │ Set the DM that may be used  by  some │
                 │                                                 │ preconditioners.                      │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDeflationCoarseMat(mat)                      │ Set the coarse problem matrix.        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDeflationCorrectionFactor(fact)              │ Set  the  coarse  problem  correction │
                 │                                                 │ factor.                               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDeflationInitOnly(flg)                       │ Set    to    only     perform     the │
                 │                                                 │ initialization.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDeflationLevels(levels)                      │ Set  the  maximum  level of deflation │
                 │                                                 │ nesting.                              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDeflationProjectionNullSpaceMat(mat)         │ Set the projection null space matrix. │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDeflationReductionFactor(red)                │ Set  the  reduction  factor  for  the │
                 │                                                 │ preconditioner.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDeflationSpace(W, transpose)                 │ Set the deflation space matrix or its │
                 │                                                 │ (Hermitian) transpose.                │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setDeflationSpaceToCompute(space_type,          │ Set the deflation space type.         │
                 │ size)                                           │                                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFactorLevels(levels)                         │ Set the number of levels of fill.     │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFactorOrdering([ord_type,    nzdiag,         │ Set   options    for    the    matrix │
                 │ reuse])                                         │ factorization reordering.             │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFactorPivot([zeropivot, inblocks])           │ Set  options for matrix factorization │
                 │                                                 │ pivoting.                             │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFactorSetUpSolverType()                      │ Set up the factorization solver.      │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFactorShift([shift_type, amount])            │ Set  options  for  shifting  diagonal │
                 │                                                 │ entries of a matrix.                  │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFactorSolverType(solver)                     │ Set   the   solver  package  used  to │
                 │                                                 │ perform the factorization.            │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFailedReason(reason)                         │ Set the reason the PC terminated.     │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFieldSplitFields(bsize, *fields)             │ Sets  the  elements  for  the   field │
                 │                                                 │ split.                                │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFieldSplitIS(*fields)                        │ Set  the elements for the field split │
                 │                                                 │ by IS.                                │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFieldSplitSchurFactType(ctype)               │ Set the  type  of  approximate  block │
                 │                                                 │ factorization.                        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFieldSplitSchurPreType(ptype[, pre])         │ Set  from  what  operator  the  PC is │
                 │                                                 │ constructed.                          │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFieldSplitType(ctype)                        │ Set the  type  of  composition  of  a │
                 │                                                 │ field split preconditioner.           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setFromOptions()                                │ Set  various  PC parameters from user │
                 │                                                 │ options.                              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setGAMGLevels(levels)                           │ Set the maximum number of levels.     │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setGAMGSmooths(smooths)                         │ Set the  number  of  smoothing  steps │
                 │                                                 │ used on all levels.                   │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setGAMGType(gamgtype)                           │ Set the type of algorithm.            │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setGASMOverlap(overlap)                         │ Set  the  overlap  between  a pair of │
                 │                                                 │ subdomains.                           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setGASMType(gasmtype)                           │ Set  the  type  of  restriction   and │
                 │                                                 │ interpolation.                        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHPDDMAuxiliaryMat(uis, uaux)                 │ Set  the auxiliary matrix used by the │
                 │                                                 │ preconditioner.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHPDDMCoarseCorrectionType(correction_type)   │ Set the coarse correction type.       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHPDDMDeflationMat(uis, U)                    │ Set  the  deflation  space  used   to │
                 │                                                 │ assemble a coarse operator.           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHPDDMHasNeumannMat(has)                      │ Set  to  indicate that the Mat passed │
                 │                                                 │ to  the  PC  is  the  local   Neumann │
                 │                                                 │ matrix.                               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHPDDMRHSMat(B)                               │ Set the right-hand side matrix of the │
                 │                                                 │ preconditioner.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHYPREAMSSetInteriorNodes(interior)           │ Set  the  list of interior nodes to a │
                 │                                                 │ zero conductivity region.             │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHYPREDiscreteCurl(mat)                       │ Set the discrete curl matrix.         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHYPREDiscreteGradient(mat)                   │ Set the discrete gradient matrix.     │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHYPRESetAlphaPoissonMatrix(mat)              │ Set the vector Poisson matrix.        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHYPRESetBetaPoissonMatrix([mat])             │ Set the Posson matrix.                │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHYPRESetEdgeConstantVectors(ozz,     zoz[,   │ Set   the   representation   of   the │
                 │ zzo])                                           │ constant vector fields  in  the  edge │
                 │                                                 │ element basis.                        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHYPRESetInterpolations(dim[,   RT_Pi_Full,   │ Set the interpolation matrices.       │
                 │ ...])                                           │                                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setHYPREType(hypretype)                         │ Set the Type.HYPRE type.              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGCycleType(cycle_type)                      │ Set the type of cycles.               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGCycleTypeOnLevel(level, cycle_type)        │ Set the type of cycle  on  the  given │
                 │                                                 │ level.                                │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGInterpolation(level, mat)                  │ Set  the  interpolation  operator for │
                 │                                                 │ the given level.                      │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGLevels(levels)                             │ Set the number of MG levels.          │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGR(level, r)                                │ Set the vector where the residual  is │
                 │                                                 │ stored.                               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGRScale(level, rscale)                      │ Set  the  pointwise  scaling  for the │
                 │                                                 │ restriction  operator  on  the  given │
                 │                                                 │ level.                                │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGRestriction(level, mat)                    │ Set  the restriction operator for the │
                 │                                                 │ given level.                          │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGRhs(level, rhs)                            │ Set the vector where  the  right-hand │
                 │                                                 │ side is stored.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGType(mgtype)                               │ Set the form of multigrid.            │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setMGX(level, x)                                │ Set  the vector where the solution is │
                 │                                                 │ stored.                               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setOperators([A, P])                            │ Set the matrices associated with  the │
                 │                                                 │ linear system.                        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setOptionsPrefix(prefix)                        │ Set  the  prefix  used for all the PC │
                 │                                                 │ options.                              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPatchCellNumbering(sec)                      │ Set the cell numbering.               │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPatchComputeFunction(function[,      args,   │ Set compute operator callbacks.       │
                 │ kargs])                                         │                                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPatchComputeFunctionInteriorFacets(function) │ Set compute operator callbacks.       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPatchComputeOperator(operator[,        args, │ Set compute operator callbacks.       │
                 │ kargs])                                         │                                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPatchComputeOperatorInteriorFacets(operator) │ Set compute operator callbacks.       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPatchConstructType(typ[,   operator,   args, │ Set compute operator callbacks.       │
                 │ ...])                                           │                                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPatchDiscretisationInfo(dms, bs, ...)        │ Set discretisation info.              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPythonContext(context)                       │ Set   the   instance   of  the  class │
                 │                                                 │ implementing  the   required   Python │
                 │                                                 │ methods.                              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setPythonType(py_type)                          │ Set  the  fully qualified Python name │
                 │                                                 │ of the class to be used.              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setReusePreconditioner(flag)                    │ Set to indicate the preconditioner is │
                 │                                                 │ to be reused.                         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setSPAIBlockSize(n)                             │ Set   the   block   size    of    the │
                 │                                                 │ preconditioner.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setSPAICacheSize(size)                          │ Set the cache size.                   │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setSPAIEpsilon(val)                             │ Set    the    tolerance    for    the │
                 │                                                 │ preconditioner.                       │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setSPAIMax(maxval)                              │ Set the size of  working  buffers  in │
                 │                                                 │ the preconditioner.                   │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setSPAIMaxNew(maxval)                           │ Set   the   maximum   number  of  new │
                 │                                                 │ non-zero candidates per step.         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setSPAINBSteps(nbsteps)                         │ Set the maximum number of improvement │
                 │                                                 │ steps per row.                        │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setSPAISp(sym)                                  │ Set to specify a  symmetric  sparsity │
                 │                                                 │ pattern.                              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setSPAIVerbose(level)                           │ Set the verbosity level.              │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setType(pc_type)                                │ Set the preconditioner type.          │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setUp()                                         │ Set  up  the internal data structures │
                 │                                                 │ for the PC.                           │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setUpOnBlocks()                                 │ Set up the PC for each block.         │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ setUseAmat(flag)                                │ Set to indicate to apply PC to A  and │
                 │                                                 │ not P.                                │
                 ├─────────────────────────────────────────────────┼───────────────────────────────────────┤
                 │ view([viewer])                                  │ View the PC object.                   │
                 └─────────────────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              addCompositePCType(pc_type)
                     Add a PC of the given type to the composite PC.

                     Collective.

                     Parameterspc_type (Type|str) -- The type of the preconditioner to add.

                     ReturntypeNoneSEEALSO:PCCompositeAddPCTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1665appendOptionsPrefix(prefix)
                     Append to the prefix used for all the PC options.

                     Logically collective.

                     Parametersprefix (str|None) -- The prefix to append to the current prefix.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, PCAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/PC.pyx:355apply(x,y)
                     Apply the PC to a vector.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector.

                            • y (Vec) -- The output vector, cannot be the same as x.

                     ReturntypeNoneSEEALSO:PCApplySourcecodeatpetsc4py/PETSc/PC.pyx:581applySymmetricLeft(x,y)
                     Apply the left part of a symmetric PC to a vector.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector.

                            • y (Vec) -- The output vector, cannot be the same as x.

                     ReturntypeNoneSEEALSO:PCApplySymmetricLeftSourcecodeatpetsc4py/PETSc/PC.pyx:641applySymmetricRight(x,y)
                     Apply the right part of a symmetric PC to a vector.

                     Collective.

                     Parameters

                            • x (Vec) -- The input vector.

                            • y (Vec) -- The output vector, cannot be the same as x.

                     ReturntypeNoneSEEALSO:PCApplySymmetricRightSourcecodeatpetsc4py/PETSc/PC.pyx:660applyTranspose(x,y)
                     Apply the transpose of the PC to a vector.

                     Collective.

                     For complex numbers this applies the non-Hermitian transpose.

                     Parameters

                            • x (Vec) -- The input vector.

                            • y (Vec) -- The output vector, cannot be the same as x.

                     ReturntypeNoneSEEALSO:PCApplySourcecodeatpetsc4py/PETSc/PC.pyx:619create(comm=None)
                     Create an empty PC.

                     Collective.

                     The default preconditioner for sparse matrices is ILU or ICC with 0 fill on one process and
                     block Jacobi (BJACOBI) with ILU or ICC in parallel. For dense matrices it is always None.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:destroy, PCCreateSourcecodeatpetsc4py/PETSc/PC.pyx:264createPython(context=None,comm=None)
                     Create a preconditioner of Python type.

                     Collective.

                     Parameters

                            • context  (Any)  --  An  instance  of  the  Python  class implementing the required
                              methods.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PETScPythonpreconditionertype, setType, setPythonContext, PC.Type.PYTHONSourcecodeatpetsc4py/PETSc/PC.pyx:742destroy()
                     Destroy the PC that was created with create.

                     Collective.

                     SEEALSO:PCDestroySourcecodeatpetsc4py/PETSc/PC.pyx:250ReturntypeSelfgetASMSubKSP()
                     Return the local KSP object for all blocks on this process.

                     Not collective.

                     SEEALSO:PCASMGetSubKSPSourcecodeatpetsc4py/PETSc/PC.pyx:946Returntypelist[KSP]

              getCompositePC(n)
                     Return a component of the composite PC.

                     Not collective.

                     Parametersn (int) -- The index of the PC in the composition.

                     ReturntypeNoneSEEALSO:PCCompositeGetPCSourcecodeatpetsc4py/PETSc/PC.pyx:1644getDM()
                     Return the DM associated with the PC.

                     Not collective.

                     SEEALSO:PCGetDMSourcecodeatpetsc4py/PETSc/PC.pyx:681ReturntypeDMgetDeflationCoarseKSP()
                     Return the coarse problem KSP.

                     Not collective.

                     SEEALSO:PCDeflationGetCoarseKSPSourcecodeatpetsc4py/PETSc/PC.pyx:2910ReturntypeKSPgetDeflationPC()
                     Return the additional preconditioner.

                     Not collective.

                     SEEALSO:PCDeflationGetPCSourcecodeatpetsc4py/PETSc/PC.pyx:2925ReturntypePCgetFactorMatrix()
                     Return the factored matrix.

                     Not collective.

                     SEEALSO:PCFactorGetMatrixSourcecodeatpetsc4py/PETSc/PC.pyx:1434ReturntypeMatgetFactorSolverType()
                     Return the solver package used to perform the factorization.

                     Not collective.

                     SEEALSO:PCFactorGetMatSolverTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1290ReturntypestrgetFailedReason()
                     Return the reason the PC terminated.

                     Not collective.

                     After a call to KSPCheckDot() or KSPCheckNorm() inside a KSPSolve(), or  after  a  call  to
                     PCReduceFailedReason() this is the maximum reason over all ranks in the PC communicator and
                     hence logically collective.  Otherwise it is the local value.

                     SEEALSO:PCGetFailedReasonSourcecodeatpetsc4py/PETSc/PC.pyx:520ReturntypeFailedReasongetFieldSplitSchurGetSubKSP()
                     Return the KSP for the Schur complement based splits.

                     Not collective.

                     SEEALSO:PCFieldSplitSchurGetSubKSP, PCFieldSplitGetSubKSPSourcecodeatpetsc4py/PETSc/PC.pyx:1545Returntypelist[KSP]

              getFieldSplitSubIS(splitname)
                     Return the IS associated with a given name.

                     Not collective.

                     SEEALSO:PCFieldSplitGetISSourcecodeatpetsc4py/PETSc/PC.pyx:1565Parameterssplitname (str)

                     ReturntypeISgetFieldSplitSubKSP()
                     Return the KSP for all splits.

                     Not collective.

                     SEEALSO:PCFieldSplitGetSubKSPSourcecodeatpetsc4py/PETSc/PC.pyx:1525Returntypelist[KSP]

              getHPDDMCoarseCorrectionType()
                     Return the coarse correction type.

                     Not collective.

                     SEEALSO:PCHPDDMGetCoarseCorrectionTypeSourcecodeatpetsc4py/PETSc/PC.pyx:2562ReturntypeHPDDMCoarseCorrectionTypegetHPDDMComplexities()
                     Compute the grid and operator complexities.

                     Collective.

                     SEEALSO:PCHPDDMGetComplexitiesSourcecodeatpetsc4py/PETSc/PC.pyx:2512Returntypetuple[float, float]

              getHPDDMSTShareSubKSP()
                     Return true if the KSP in SLEPc ST and the subdomain solver is shared.

                     Not collective.

                     SEEALSO:PCHPDDMGetSTShareSubKSPSourcecodeatpetsc4py/PETSc/PC.pyx:2576ReturntypeboolgetHYPREType()
                     Return the Type.HYPRE type.

                     Not collective.

                     SEEALSO:PCHYPREGetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1076ReturntypestrgetKSP()
                     Return the KSP if the PC is Type.KSP.

                     Not collective.

                     SEEALSO:PCKSPGetKSPSourcecodeatpetsc4py/PETSc/PC.pyx:1686ReturntypeKSPgetMGCoarseSolve()
                     Return the KSP used on the coarse grid.

                     Not collective.

                     SEEALSO:PCMGGetCoarseSolveSourcecodeatpetsc4py/PETSc/PC.pyx:1762ReturntypeKSPgetMGInterpolation(level)
                     Return the interpolation operator for the given level.

                     Logically collective.

                     Parameterslevel (int) -- The level where interpolation is defined from level-1 to level.

                     ReturntypeMatSEEALSO:PCMGGetInterpolationSourcecodeatpetsc4py/PETSc/PC.pyx:1797getMGLevels()
                     Return the number of MG levels.

                     Not collective.

                     SEEALSO:PCMGGetLevelsSourcecodeatpetsc4py/PETSc/PC.pyx:1730ReturntypeintgetMGRScale(level)
                     Return the pointwise scaling for the restriction operator on the given level.

                     Logically collective.

                     Parameterslevel (int) -- The level where restriction is defined from level to level-1.

                     ReturntypeVecSEEALSO:PCMGGetRScaleSourcecodeatpetsc4py/PETSc/PC.pyx:1879getMGRestriction(level)
                     Return the restriction operator for the given level.

                     Logically collective.

                     Parameterslevel (int) -- The level where restriction is defined from level to level-1.

                     ReturntypeMatSEEALSO:PCMGGetRestrictionSourcecodeatpetsc4py/PETSc/PC.pyx:1838getMGSmoother(level)
                     Return the KSP to be used as a smoother.

                     Not collective.

                     Parameterslevel (int) -- The level of the smoother.

                     ReturntypeKSPSEEALSO:getMGSmootherDown, getMGSmootherUp, PCMGGetSmootherSourcecodeatpetsc4py/PETSc/PC.pyx:1900getMGSmootherDown(level)
                     Return the KSP to be used as a smoother before coarse grid correction.

                     Not collective.

                     Parameterslevel (int) -- The level of the smoother.

                     ReturntypeKSPSEEALSO:getMGSmoother, getMGSmootherUp, PCMGGetSmootherDownSourcecodeatpetsc4py/PETSc/PC.pyx:1921getMGSmootherUp(level)
                     Return the KSP to be used as a smoother after coarse grid correction.

                     Not collective.

                     Parameterslevel (int) -- The level of the smoother.

                     ReturntypeKSPSEEALSO:getMGSmootherDown, getMGSmoother, PCMGGetSmootherUpSourcecodeatpetsc4py/PETSc/PC.pyx:1942getMGType()
                     Return the form of multigrid.

                     Logically collective.

                     SEEALSO:PCMGGetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1703ReturntypeMGTypegetOperators()
                     Return the matrices associated with a linear system.

                     Not collective.

                     SEEALSO:setOperators, PCGetOperatorsSourcecodeatpetsc4py/PETSc/PC.pyx:416Returntypetuple[Mat, Mat]

              getOptionsPrefix()
                     Return the prefix used for all the PC options.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, PCGetOptionsPrefixSourcecodeatpetsc4py/PETSc/PC.pyx:341ReturntypestrgetPatchSubKSP()
                     Return the local KSP object for all blocks on this process.

                     Not collective.

                     Sourcecodeatpetsc4py/PETSc/PC.pyx:2372Returntypelist[KSP]

              getPythonContext()
                     Return the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonpreconditionertype, setPythonContextSourcecodeatpetsc4py/PETSc/PC.pyx:779ReturntypeAnygetPythonType()
                     Return the fully qualified Python name of the class used by the preconditioner.

                     Not collective.

                     SEEALSO:PETScPythonpreconditionertype, setPythonContext, setPythonType, PCPythonGetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:808ReturntypestrgetType()
                     Return the preconditioner type.

                     Not collective.

                     SEEALSO:setType, PCGetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:308ReturntypestrgetUseAmat()
                     Return the flag to indicate if PC is applied to A or P.

                     Logically collective.

                     Returnsflag -- True if A is used and False if P.

                     ReturntypeboolSEEALSO:setUseAmat, PCGetUseAmatSourcecodeatpetsc4py/PETSc/PC.pyx:458matApply(x,y)
                     Apply the PC to many vectors stored as Mat.Type.DENSE.

                     Collective.

                     Parameters

                            • x (Mat) -- The input matrix.

                            • y (Mat) -- The output matrix, cannot be the same as x.

                     ReturntypeNoneSEEALSO:PCMatApply, PCApplySourcecodeatpetsc4py/PETSc/PC.pyx:600reset()
                     Reset the PC, removing any allocated vectors and matrices.

                     Collective.

                     SEEALSO:PCResetSourcecodeatpetsc4py/PETSc/PC.pyx:553ReturntypeNonesetASMLocalSubdomains(nsd,is_sub=None,is_local=None)
                     Set the local subdomains.

                     Collective.

                     Parameters

                            • nsd (int) -- The number of subdomains for this process.

                            • is_sub (Sequence[IS]|None) -- Defines the subdomains for this process or None to
                              determine internally.

                            • is_local  (Sequence[IS]|None)  -- Defines the local part of the subdomains for
                              this process, only used for PC.ASMType.RESTRICT.

                     ReturntypeNoneSEEALSO:setASMTotalSubdomains, PCASMSetLocalSubdomainsSourcecodeatpetsc4py/PETSc/PC.pyx:860setASMOverlap(overlap)
                     Set the overlap between a pair of subdomains.

                     Logically collective.

                     Parametersoverlap (int) -- The amount of overlap between subdomains.

                     ReturntypeNoneSEEALSO:PCASMSetOverlapSourcecodeatpetsc4py/PETSc/PC.pyx:842setASMSortIndices(dosort)
                     Set to sort subdomain indices.

                     Logically collective.

                     Parametersdosort (bool) -- Set to True to sort indices

                     ReturntypeNoneSEEALSO:PCASMSetSortIndicesSourcecodeatpetsc4py/PETSc/PC.pyx:961setASMTotalSubdomains(nsd,is_sub=None,is_local=None)
                     Set the subdomains for all processes.

                     Collective.

                     Parameters

                            • nsd (int) -- The number of subdomains for all processes.

                            • is_sub (Sequence[IS]|None) -- Defines the subdomains for all processes  or  None
                              to determine internally.

                            • is_local  (Sequence[IS]|None)  -- Defines the local part of the subdomains for
                              this process, only used for PC.ASMType.RESTRICT.

                     ReturntypeNoneSEEALSO:setASMLocalSubdomains, PCASMSetTotalSubdomainsSourcecodeatpetsc4py/PETSc/PC.pyx:903setASMType(asmtype)
                     Set the type of restriction and interpolation.

                     Logically collective.

                     Parametersasmtype (ASMType) -- The type of ASM you wish to use.

                     ReturntypeNoneSEEALSO:PCASMSetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:824setBDDCChangeOfBasisMat(T,interior=False)
                     Set a user defined change of basis for degrees of freedom.

                     Collective.

                     Parameters

                            • T (Mat) -- The matrix representing the change of basis.

                            • interior (bool) -- Enable to indicate the change of basis affects interior degrees
                              of freedom.

                     ReturntypeNoneSEEALSO:PCBDDCSetChangeOfBasisMatSourcecodeatpetsc4py/PETSc/PC.pyx:2165setBDDCCoarseningRatio(cratio)
                     Set the coarsening ratio used in the multilevel version.

                     Logically collective.

                     Parameterscratio (int) -- The coarsening ratio at the coarse level

                     ReturntypeNoneSEEALSO:PCBDDCSetCoarseningRatioSourcecodeatpetsc4py/PETSc/PC.pyx:2220setBDDCDirichletBoundaries(bndr)
                     Set the IS defining Dirichlet boundaries for the global problem.

                     Collective.

                     Parametersbndr (IS) -- The parallel IS defining Dirichlet boundaries.

                     ReturntypeNoneSEEALSO:PCBDDCSetDirichletBoundariesSourcecodeatpetsc4py/PETSc/PC.pyx:2256setBDDCDirichletBoundariesLocal(bndr)
                     Set the IS defining Dirichlet boundaries in local ordering.

                     Collective.

                     Parametersbndr (IS) -- The parallel IS defining Dirichlet boundaries in local ordering.

                     ReturntypeNoneSEEALSO:setBDDCDirichletBoundaries, PCBDDCSetDirichletBoundariesLocalSourcecodeatpetsc4py/PETSc/PC.pyx:2273setBDDCDiscreteGradient(G,order=1,field=1,gord=True,conforming=True)
                     Set the discrete gradient.

                     Collective.

                     Parameters

                            • G (Mat) -- The discrete gradient matrix in Mat.Type.AIJ format.

                            • order (int) -- The order of the Nedelec space.

                            • field (int) -- The field number of the Nedelec degrees of  freedom.  This  is  not
                              used if no fields have been specified.

                            • gord (bool) -- Enable to use global ordering in the rows of G.

                            • conforming (bool) -- Enable if the mesh is conforming.

                     ReturntypeNoneSEEALSO:PCBDDCSetDiscreteGradientSourcecodeatpetsc4py/PETSc/PC.pyx:2129setBDDCDivergenceMat(div,trans=False,l2l=None)
                     Set the linear operator representing ∫ div(u)•p dx.

                     Collective.

                     Parameters

                            • div (Mat) -- The matrix in Mat.Type.IS format.

                            • trans  (bool)  --  If  True,  the  pressure/velocity  is  in  the trial/test space
                              respectively. If False the pressure/velocity is in the test/trial space.

                            • l2l (IS|None) -- Optional IS describing the local to local map for velocities.

                     ReturntypeNoneSEEALSO:PCBDDCSetDivergenceMatSourcecodeatpetsc4py/PETSc/PC.pyx:2103setBDDCDofsSplitting(isfields)
                     Set the index set(s) defining fields of the global matrix.

                     Collective.

                     Parametersisfields (IS|Sequence[IS]) -- The sequence of IS describing the fields  in  global
                            ordering.

                     ReturntypeNoneSEEALSO:PCBDDCSetDofsSplittingSourcecodeatpetsc4py/PETSc/PC.pyx:2324setBDDCDofsSplittingLocal(isfields)
                     Set the index set(s) defining fields of the local subdomain matrix.

                     Collective.

                     Not all nodes need to be listed. Unlisted nodes will belong to the complement field.

                     Parametersisfields  (IS|Sequence[IS]) -- The sequence of IS describing the fields in local
                            ordering.

                     ReturntypeNoneSEEALSO:PCBDDCSetDofsSplittingLocalSourcecodeatpetsc4py/PETSc/PC.pyx:2346setBDDCLevels(levels)
                     Set the maximum number of additional levels allowed.

                     Logically collective.

                     Parameterslevels (int) -- The maximum number of levels.

                     ReturntypeNoneSEEALSO:PCBDDCSetLevelsSourcecodeatpetsc4py/PETSc/PC.pyx:2238setBDDCLocalAdjacency(csr)
                     Provide a custom connectivity graph for local dofs.

                     Not collective.

                     Parameterscsr (CSRIndicesSpec) -- Compressed sparse row layout information.

                     ReturntypeNoneSEEALSO:PCBDDCSetLocalAdjacencyGraphSourcecodeatpetsc4py/PETSc/PC.pyx:2073setBDDCNeumannBoundaries(bndr)
                     Set the IS defining Neumann boundaries for the global problem.

                     Collective.

                     Parametersbndr (IS) -- The parallel IS defining Neumann boundaries.

                     ReturntypeNoneSEEALSO:PCBDDCSetNeumannBoundariesSourcecodeatpetsc4py/PETSc/PC.pyx:2290setBDDCNeumannBoundariesLocal(bndr)
                     Set the IS defining Neumann boundaries in local ordering.

                     Collective.

                     Parametersbndr (IS) -- The parallel IS defining Neumann boundaries in local ordering.

                     ReturntypeNoneSEEALSO:setBDDCNeumannBoundaries, PCBDDCSetNeumannBoundariesLocalSourcecodeatpetsc4py/PETSc/PC.pyx:2307setBDDCPrimalVerticesIS(primv)
                     Set additional user defined primal vertices.

                     Collective.

                     Parametersprimv (IS) -- The IS of primal vertices in global numbering.

                     ReturntypeNoneSEEALSO:PCBDDCSetPrimalVerticesISSourcecodeatpetsc4py/PETSc/PC.pyx:2186setBDDCPrimalVerticesLocalIS(primv)
                     Set additional user defined primal vertices.

                     Collective.

                     Parametersprimv (IS) -- The IS of primal vertices in local numbering.

                     ReturntypeNoneSEEALSO:PCBDDCSetPrimalVerticesLocalISSourcecodeatpetsc4py/PETSc/PC.pyx:2203setCompositeType(ctype)
                     Set the type of composite preconditioner.

                     Logically collective.

                     Parametersctype (CompositeType) -- The type of composition.

                     ReturntypeNoneSEEALSO:PCCompositeSetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1626setCoordinates(coordinates)
                     Set the coordinates for the nodes on the local process.

                     Collective.

                     Parameterscoordinates (Sequence[Sequence[float]]) -- The two dimensional coordinate array.

                     ReturntypeNoneSEEALSO:PCSetCoordinatesSourcecodeatpetsc4py/PETSc/PC.pyx:715setDM(dm)
                     Set the DM that may be used by some preconditioners.

                     Logically collective.

                     Parametersdm (DM) -- The DM object.

                     ReturntypeNoneSEEALSO:PCSetDMSourcecodeatpetsc4py/PETSc/PC.pyx:698setDeflationCoarseMat(mat)
                     Set the coarse problem matrix.

                     Collective.

                     Parametersmat (Mat) -- The coarse problem matrix.

                     ReturntypeNoneSEEALSO:PCDeflationSetCoarseMatSourcecodeatpetsc4py/PETSc/PC.pyx:2893setDeflationCorrectionFactor(fact)
                     Set the coarse problem correction factor.

                     Logically collective.

                     Parametersfact (float) -- The correction factor.

                     ReturntypeNoneSEEALSO:PCDeflationSetCorrectionFactorSourcecodeatpetsc4py/PETSc/PC.pyx:2816setDeflationInitOnly(flg)
                     Set to only perform the initialization.

                     Logically collective.

                     Sets initial guess to the solution on the deflation space but does not apply the  deflation
                     preconditioner. The additional preconditioner is still applied.

                     Parametersflg (bool) -- Enable to only initialize the preconditioner.

                     ReturntypeNoneSEEALSO:PCDeflationSetInitOnlySourcecodeatpetsc4py/PETSc/PC.pyx:2758setDeflationLevels(levels)
                     Set the maximum level of deflation nesting.

                     Logically collective.

                     Parameterslevels (int) -- The maximum deflation level.

                     ReturntypeNoneSEEALSO:PCDeflationSetLevelsSourcecodeatpetsc4py/PETSc/PC.pyx:2780setDeflationProjectionNullSpaceMat(mat)
                     Set the projection null space matrix.

                     Collective.

                     Parametersmat (Mat) -- The projection null space matrix.

                     ReturntypeNoneSEEALSO:PCDeflationSetProjectionNullSpaceMatSourcecodeatpetsc4py/PETSc/PC.pyx:2876setDeflationReductionFactor(red)
                     Set the reduction factor for the preconditioner.

                     Logically collective.

                     Parametersred (int) -- The reduction factor or DEFAULT.

                     ReturntypeNoneSEEALSO:PCDeflationSetReductionFactorSourcecodeatpetsc4py/PETSc/PC.pyx:2798setDeflationSpace(W,transpose)
                     Set the deflation space matrix or its (Hermitian) transpose.

                     Logically collective.

                     Parameters

                            • W (Mat) -- The deflation matrix.

                            • transpose  (bool)  --  Enable  to  indicate that W is an explicit transpose of the
                              deflation matrix.

                     ReturntypeNoneSEEALSO:PCDeflationSetSpaceSourcecodeatpetsc4py/PETSc/PC.pyx:2855setDeflationSpaceToCompute(space_type,size)
                     Set the deflation space type.

                     Logically collective.

                     Parameters

                            • space_type (DeflationSpaceType) -- The deflation space type.

                            • size (int) -- The size of the space to compute

                     ReturntypeNoneSEEALSO:PCDeflationSetSpaceToComputeSourcecodeatpetsc4py/PETSc/PC.pyx:2834setFactorLevels(levels)
                     Set the number of levels of fill.

                     Logically collective.

                     Parameterslevels (int) -- The number of levels to fill.

                     ReturntypeNoneSEEALSO:PCFactorSetLevelsSourcecodeatpetsc4py/PETSc/PC.pyx:1416setFactorOrdering(ord_type=None,nzdiag=None,reuse=None)
                     Set options for the matrix factorization reordering.

                     Logically collective.

                     Parameters

                            • ord_type (str|None) -- The  name  of  the  matrix  ordering  or  None  to  leave
                              unchanged.

                            • nzdiag  (float|None) -- Threshold to consider diagonal entries in the matrix as
                              zero.

                            • reuse (bool|None) -- Enable to reuse the ordering of a factored matrix.

                     ReturntypeNoneSEEALSO:PCFactorSetMatOrderingType, PCFactorReorderForNonzeroDiagonal, PCFactorSetReuseOrderingSourcecodeatpetsc4py/PETSc/PC.pyx:1320setFactorPivot(zeropivot=None,inblocks=None)
                     Set options for matrix factorization pivoting.

                     Logically collective.

                     Parameters

                            • zeropivot (float|None) -- The size at which smaller pivots are treated as zero.

                            • inblocks (bool|None) -- Enable to allow pivoting while factoring in blocks.

                     ReturntypeNoneSEEALSO:PCFactorSetZeroPivot, PCFactorSetPivotInBlocksSourcecodeatpetsc4py/PETSc/PC.pyx:1357setFactorSetUpSolverType()
                     Set up the factorization solver.

                     Collective.

                     This can be called after KSP.setOperators or PC.setOperators,  causes  MatGetFactor  to  be
                     called so then one may set the options for that particular factorization object.

                     SEEALSO:WorkingwithPETScoptions, PCFactorSetUpMatSolverTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1304ReturntypeNonesetFactorShift(shift_type=None,amount=None)
                     Set options for shifting diagonal entries of a matrix.

                     Logically collective.

                     Parameters

                            • shift_type  (FactorShiftType|None)  --  The  type  of  shift, or None to leave
                              unchanged.

                            • amount (float|None) --  The  amount  of  shift.  Specify  DEFAULT  to  determine
                              internally or None to leave unchanged.

                     ReturntypeNoneSEEALSO:PCFactorSetShiftType, PCFactorSetShiftAmountSourcecodeatpetsc4py/PETSc/PC.pyx:1386setFactorSolverType(solver)
                     Set the solver package used to perform the factorization.

                     Logically collective.

                     Parameterssolver (SolverType|str) -- The solver package used to factorize.

                     ReturntypeNoneSEEALSO:PCFactorSetMatSolverTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1271setFailedReason(reason)
                     Set the reason the PC terminated.

                     Logically collective.

                     Parametersreason (FailedReason|str) -- the reason the PC terminated

                     ReturntypeNoneSEEALSO:PCSetFailedReasonSourcecodeatpetsc4py/PETSc/PC.pyx:502setFieldSplitFields(bsize,*fields)
                     Sets the elements for the field split.

                     Collective.

                     Parameters

                            • bsize (int) -- The block size

                            • fields  (Tuple[str,Sequence[int]])  -- A sequence of tuples containing the split
                              name and a sequence of integers that define the elements in the split.

                     ReturntypeNoneSEEALSO:PCFieldSplitSetBlockSize, PCFieldSplitSetFieldsSourcecodeatpetsc4py/PETSc/PC.pyx:1495setFieldSplitIS(*fields)
                     Set the elements for the field split by IS.

                     Logically collective.

                     Solve options for this split will be available under the prefix -fieldsplit_SPLITNAME_*.

                     Parametersfields (Tuple[str,IS]) -- A sequence of tuples containing the split name and the IS
                            that defines the elements in the split.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, PCFieldSplitSetISSourcecodeatpetsc4py/PETSc/PC.pyx:1469setFieldSplitSchurFactType(ctype)
                     Set the type of approximate block factorization.

                     Collective.

                     Parametersctype (FieldSplitSchurFactType) -- The type indicating which blocks to retain.

                     ReturntypeNoneSEEALSO:PCFieldSplitSetSchurFactTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1581setFieldSplitSchurPreType(ptype,pre=None)
                     Set from what operator the PC is constructed.

                     Collective.

                     Parameters

                            • ptype (FieldSplitSchurPreType) -- The type of matrix to  use  for  preconditioning
                              the Schur complement.

                            • pre (Mat|None) -- The optional matrix to use for preconditioning.

                     ReturntypeNoneSEEALSO:PCFieldSplitSetSchurPreSourcecodeatpetsc4py/PETSc/PC.pyx:1599setFieldSplitType(ctype)
                     Set the type of composition of a field split preconditioner.

                     Collective.

                     Parametersctype (CompositeType) -- The type of composition.

                     ReturntypeNoneSEEALSO:PCFieldSplitSetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1451setFromOptions()
                     Set various PC parameters from user options.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, PCSetFromOptionsSourcecodeatpetsc4py/PETSc/PC.pyx:374ReturntypeNonesetGAMGLevels(levels)
                     Set the maximum number of levels.

                     Not collective.

                     Parameterslevels (int) -- The maximum number of levels to use.

                     ReturntypeNoneSEEALSO:PCGAMGSetNlevelsSourcecodeatpetsc4py/PETSc/PC.pyx:1038setGAMGSmooths(smooths)
                     Set the number of smoothing steps used on all levels.

                     Logically collective.

                     Parameterssmooths (int) -- The maximum number of smooths.

                     ReturntypeNoneSEEALSO:PCGAMGSetNSmoothsSourcecodeatpetsc4py/PETSc/PC.pyx:1056setGAMGType(gamgtype)
                     Set the type of algorithm.

                     Collective.

                     Parametersgamgtype (GAMGType|str) -- The type of GAMGReturntypeNoneSEEALSO:PCGAMGSetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1019setGASMOverlap(overlap)
                     Set the overlap between a pair of subdomains.

                     Logically collective.

                     Parametersoverlap (int) -- The amount of overlap between subdomains.

                     ReturntypeNoneSEEALSO:PCGASMSetOverlapSourcecodeatpetsc4py/PETSc/PC.pyx:999setGASMType(gasmtype)
                     Set the type of restriction and interpolation.

                     Logically collective.

                     Parametersgasmtype (GASMType) -- The type of GASM.

                     ReturntypeNoneSEEALSO:PCGASMSetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:981setHPDDMAuxiliaryMat(uis,uaux)
                     Set the auxiliary matrix used by the preconditioner.

                     Logically collective.

                     Parameters

                            • uis (IS) -- The IS of the local auxiliary matrix

                            • uaux (Mat) -- The auxiliary sequential matrix

                     ReturntypeNoneSEEALSO:PCHPDDMSetAuxiliaryMatSourcecodeatpetsc4py/PETSc/PC.pyx:2476setHPDDMCoarseCorrectionType(correction_type)
                     Set the coarse correction type.

                     Collective.

                     Parameterscorrection_type  (HPDDMCoarseCorrectionType)  --  The  type  of coarse correction to
                            apply.

                     ReturntypeNoneSEEALSO:PCHPDDMSetCoarseCorrectionTypeSourcecodeatpetsc4py/PETSc/PC.pyx:2544setHPDDMDeflationMat(uis,U)
                     Set the deflation space used to assemble a coarse operator.

                     Logically collective.

                     Parameters

                            • uis (IS) -- The IS of the local deflation matrix.

                            • U (Mat) -- The deflation sequential matrix of type Mat.Type.DENSE.

                     ReturntypeNoneSEEALSO:PCHPDDMSetDeflationMatSourcecodeatpetsc4py/PETSc/PC.pyx:2590setHPDDMHasNeumannMat(has)
                     Set to indicate that the Mat passed to the PC is the local Neumann matrix.

                     Logically collective.

                     Parametershas (bool) -- Enable to indicate the matrix is the local Neumann matrix.

                     ReturntypeNoneSEEALSO:PCHPDDMHasNeumannMatSourcecodeatpetsc4py/PETSc/PC.pyx:2526setHPDDMRHSMat(B)
                     Set the right-hand side matrix of the preconditioner.

                     Logically collective.

                     ParametersB (Mat) -- The right-hand side sequential matrix.

                     ReturntypeNoneSEEALSO:PCHPDDMSetRHSMatSourcecodeatpetsc4py/PETSc/PC.pyx:2495setHYPREAMSSetInteriorNodes(interior)
                     Set the list of interior nodes to a zero conductivity region.

                     Collective.

                     Parametersinterior (Vec) -- A vector where a value of 1.0 indicates an interior node.

                     ReturntypeNoneSEEALSO:PCHYPREAMSSetInteriorNodesSourcecodeatpetsc4py/PETSc/PC.pyx:1252setHYPREDiscreteCurl(mat)
                     Set the discrete curl matrix.

                     Collective.

                     Parametersmat (Mat) -- The discrete curl.

                     ReturntypeNoneSEEALSO:PCHYPRESetDiscreteCurlSourcecodeatpetsc4py/PETSc/PC.pyx:1110setHYPREDiscreteGradient(mat)
                     Set the discrete gradient matrix.

                     Collective.

                     Parametersmat (Mat) -- The discrete gradient.

                     ReturntypeNoneSEEALSO:PCHYPRESetDiscreteGradientSourcecodeatpetsc4py/PETSc/PC.pyx:1127setHYPRESetAlphaPoissonMatrix(mat)
                     Set the vector Poisson matrix.

                     Collective.

                     Parametersmat (Mat) -- The vector Poisson matrix.

                     ReturntypeNoneSEEALSO:PCHYPRESetAlphaPoissonMatrixSourcecodeatpetsc4py/PETSc/PC.pyx:1144setHYPRESetBetaPoissonMatrix(mat=None)
                     Set the Posson matrix.

                     Collective.

                     Parametersmat (Mat|None) -- The Poisson matrix or None to turn off.

                     ReturntypeNoneSEEALSO:PCHYPRESetBetaPoissonMatrixSourcecodeatpetsc4py/PETSc/PC.pyx:1161setHYPRESetEdgeConstantVectors(ozz,zoz,zzo=None)
                     Set the representation of the constant vector fields in the edge element basis.

                     Collective.

                     Parameters

                            • ozz (Vec) -- A vector representing [1,0,0] or [1,0] in 2D.

                            • zoz (Vec) -- A vector representing [0,1,0] or [0,1] in 2D.

                            • zzo (Vec|None) -- A vector representing [0,0,1] or None in 2D.

                     ReturntypeNoneSEEALSO:PCHYPRESetEdgeConstantVectorsSourcecodeatpetsc4py/PETSc/PC.pyx:1228setHYPRESetInterpolations(dim,RT_Pi_Full=None,RT_Pi=None,ND_Pi_Full=None,ND_Pi=None)
                     Set the interpolation matrices.

                     Collective.

                     Parameters

                            • dim (int) -- The dimension of the problem.

                            • RT_Pi_Full (Mat|None) -- The Raviart-Thomas  interpolation  matrix  or  None  to
                              omit.

                            • RT_Pi -- The xyz components of the Raviart-Thomas interpolation matrix, or None to
                              omit.

                            • ND_Pi_Full (Mat|None) -- The Nedelec interpolation matrix or None to omit.

                            • ND_Pi -- The xyz components of the Nedelec interpolation matrix, or None to omit.

                     ReturntypeNoneSEEALSO:PCHYPRESetInterpolationsSourcecodeatpetsc4py/PETSc/PC.pyx:1180setHYPREType(hypretype)
                     Set the Type.HYPRE type.

                     Collective.

                     Parametershypretype  (str)  --  The  name  of the type, one of "euclid", "pilut", "parasails",
                            "boomeramg", "ams", "ads"ReturntypeNoneSEEALSO:PCHYPRESetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1090setMGCycleType(cycle_type)
                     Set the type of cycles.

                     Logically collective.

                     Parameterscycle_type (MGCycleType) -- The type of multigrid cycles to use.

                     ReturntypeNoneSEEALSO:setMGCycleTypeOnLevel, PCMGSetCycleTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1963setMGCycleTypeOnLevel(level,cycle_type)
                     Set the type of cycle on the given level.

                     Logically collective.

                     Parameters

                            • level (int) -- The level on which to set the cycle type.

                            • cycle_type (MGCycleType) -- The type of multigrid cycles to use.

                     ReturntypeNoneSEEALSO:setMGCycleType, PCMGSetCycleTypeOnLevelSourcecodeatpetsc4py/PETSc/PC.pyx:1981setMGInterpolation(level,mat)
                     Set the interpolation operator for the given level.

                     Logically collective.

                     Parameters

                            • level -- The level where interpolation is defined from level-1 to level.

                            • mat (Mat) -- The interpolation operator

                     ReturntypeNoneSEEALSO:PCMGSetInterpolationSourcecodeatpetsc4py/PETSc/PC.pyx:1777setMGLevels(levels)
                     Set the number of MG levels.

                     Logically collective.

                     Parameterslevels (int) -- The number of levels

                     ReturntypeNoneSEEALSO:PCMGSetLevelsSourcecodeatpetsc4py/PETSc/PC.pyx:1744setMGR(level,r)
                     Set the vector where the residual is stored.

                     Logically collective.

                     If not provided, one will be set internally. Will be cleaned up in destroy.

                     Parameters

                            • level (int) -- The level on which to set the residual.

                            • r (Vec) -- The vector where the residual is stored.

                     ReturntypeNoneSEEALSO:PCMGSetRSourcecodeatpetsc4py/PETSc/PC.pyx:2048setMGRScale(level,rscale)
                     Set the pointwise scaling for the restriction operator on the given level.

                     Logically collective.

                     Parameters

                            • level (int) -- The level where restriction is defined from level to level-1.

                            • rscale (Vec) -- The scaling vector.

                     ReturntypeNoneSEEALSO:PCMGSetRScaleSourcecodeatpetsc4py/PETSc/PC.pyx:1859setMGRestriction(level,mat)
                     Set the restriction operator for the given level.

                     Logically collective.

                     Parameters

                            • level (int) -- The level where restriction is defined from level to level-1.

                            • mat (Mat) -- The restriction operator

                     ReturntypeNoneSEEALSO:PCMGSetRestrictionSourcecodeatpetsc4py/PETSc/PC.pyx:1818setMGRhs(level,rhs)
                     Set the vector where the right-hand side is stored.

                     Logically collective.

                     If not provided, one will be set internally. Will be cleaned up in destroy.

                     Parameters

                            • level (int) -- The level on which to set the right-hand side.

                            • rhs (Vec) -- The vector where the right-hand side is stored.

                     ReturntypeNoneSEEALSO:PCMGSetRhsSourcecodeatpetsc4py/PETSc/PC.pyx:2002setMGType(mgtype)
                     Set the form of multigrid.

                     Logically collective.

                     SEEALSO:PCMGSetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:1717Parametersmgtype (MGType)

                     ReturntypeNonesetMGX(level,x)
                     Set the vector where the solution is stored.

                     Logically collective.

                     If not provided, one will be set internally. Will be cleaned up in destroy.

                     Parameters

                            • level (int) -- The level on which to set the solution.

                            • x (Vec) -- The vector where the solution is stored.

                     ReturntypeNoneSEEALSO:PCMGSetXSourcecodeatpetsc4py/PETSc/PC.pyx:2025setOperators(A=None,P=None)
                     Set the matrices associated with the linear system.

                     Logically collective.

                     Passing None for A or P removes the matrix that is currently used. PETSc does not reset the
                     matrix entries of either A or P to zero after  a  linear  solve;  the  user  is  completely
                     responsible for matrix assembly. See Mat.zeroEntries to zero all elements of a matrix.

                     Parameters

                            • A (Mat|None) -- the matrix which defines the linear system

                            • P  (Mat|None)  --  the  matrix  to be used in constructing the preconditioner,
                              usually the same as AReturntypeNoneSEEALSO:PCSetOperatorsSourcecodeatpetsc4py/PETSc/PC.pyx:386setOptionsPrefix(prefix)
                     Set the prefix used for all the PC options.

                     Logically collective.

                     Parametersprefix (str|None) -- The prefix to prepend to all option names.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, PCSetOptionsPrefixSourcecodeatpetsc4py/PETSc/PC.pyx:322setPatchCellNumbering(sec)
                     Set the cell numbering.

                     Sourcecodeatpetsc4py/PETSc/PC.pyx:2383Parameterssec (Section)

                     ReturntypeNonesetPatchComputeFunction(function,args=None,kargs=None)
                     Set compute operator callbacks.

                     Sourcecodeatpetsc4py/PETSc/PC.pyx:2444ReturntypeNonesetPatchComputeFunctionInteriorFacets(function,args=None,kargs=None)
                     Set compute operator callbacks.

                     Sourcecodeatpetsc4py/PETSc/PC.pyx:2452ReturntypeNonesetPatchComputeOperator(operator,args=None,kargs=None)
                     Set compute operator callbacks.

                     Sourcecodeatpetsc4py/PETSc/PC.pyx:2428ReturntypeNonesetPatchComputeOperatorInteriorFacets(operator,args=None,kargs=None)
                     Set compute operator callbacks.

                     Sourcecodeatpetsc4py/PETSc/PC.pyx:2436ReturntypeNonesetPatchConstructType(typ,operator=None,args=None,kargs=None)
                     Set compute operator callbacks.

                     Sourcecodeatpetsc4py/PETSc/PC.pyx:2460ReturntypeNonesetPatchDiscretisationInfo(dms,bs,cellNodeMaps,subspaceOffsets,ghostBcNodes,globalBcNodes)
                     Set discretisation info.

                     Sourcecodeatpetsc4py/PETSc/PC.pyx:2387ReturntypeNonesetPythonContext(context)
                     Set the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonpreconditionertype, getPythonContextSourcecodeatpetsc4py/PETSc/PC.pyx:767Parameterscontext (Any)

                     ReturntypeNonesetPythonType(py_type)
                     Set the fully qualified Python name of the class to be used.

                     Collective.

                     SEEALSO:PETScPythonpreconditionertype, setPythonContext, getPythonType, PCPythonSetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:794Parameterspy_type (str)

                     ReturntypeNonesetReusePreconditioner(flag)
                     Set to indicate the preconditioner is to be reused.

                     Logically collective.

                     Normally if the A matrix inside a PC changes, the PC  automatically  updates  itself  using
                     information from the changed matrix. Enable this option prevents this.

                     Parametersflag  (bool) -- Set to True to use the reuse the current preconditioner and False to
                            recompute on changes to the matrix.

                     ReturntypeNoneSEEALSO:setOperators, PCSetReusePreconditionerSourcecodeatpetsc4py/PETSc/PC.pyx:477setSPAIBlockSize(n)
                     Set the block size of the preconditioner.

                     Logically collective.

                     Parametersn (int) -- The block size, defaults to 1.

                     ReturntypeNoneSEEALSO:PCSPAISetBlockSizeSourcecodeatpetsc4py/PETSc/PC.pyx:2684setSPAICacheSize(size)
                     Set the cache size.

                     Logically collective.

                     Parameterssize (int) -- The size of the cache, defaults to 5.

                     ReturntypeNoneSEEALSO:PCSPAISetCacheSizeSourcecodeatpetsc4py/PETSc/PC.pyx:2702setSPAIEpsilon(val)
                     Set the tolerance for the preconditioner.

                     Logically collective.

                     Parametersval (float) -- The tolerance, defaults to 0.4.

                     ReturntypeNoneSEEALSO:PCSPAISetEpsilonSourcecodeatpetsc4py/PETSc/PC.pyx:2611setSPAIMax(maxval)
                     Set the size of working buffers in the preconditioner.

                     Logically collective.

                     Parametersmaxval (int) -- Number of entries in the work arrays to be  allocated,  defaults  to
                            5000.

                     ReturntypeNoneSEEALSO:PCSPAISetMaxSourcecodeatpetsc4py/PETSc/PC.pyx:2647setSPAIMaxNew(maxval)
                     Set the maximum number of new non-zero candidates per step.

                     Logically collective.

                     Parametersmaxval (int) -- Number of entries allowed, defaults to 5.

                     ReturntypeNoneSEEALSO:PCSPAISetMaxNewSourcecodeatpetsc4py/PETSc/PC.pyx:2666setSPAINBSteps(nbsteps)
                     Set the maximum number of improvement steps per row.

                     Logically collective.

                     Parametersnbsteps (int) -- The number of steps, defaults to 5.

                     ReturntypeNoneSEEALSO:PCSPAISetNBStepsSourcecodeatpetsc4py/PETSc/PC.pyx:2629setSPAISp(sym)
                     Set to specify a symmetric sparsity pattern.

                     Logically collective.

                     Parameterssym (int) -- Enable to indicate the matrix is symmetric.

                     ReturntypeNoneSEEALSO:PCSPAISetSpSourcecodeatpetsc4py/PETSc/PC.pyx:2738setSPAIVerbose(level)
                     Set the verbosity level.

                     Logically collective.

                     Parameterslevel (int) -- The level of verbosity, defaults to 1.

                     ReturntypeNoneSEEALSO:PCSPAISetVerboseSourcecodeatpetsc4py/PETSc/PC.pyx:2720setType(pc_type)
                     Set the preconditioner type.

                     Collective.

                     Parameterspc_type (Type|str) -- The preconditioner type.

                     ReturntypeNoneSEEALSO:WorkingwithPETScoptions, getType, TSSetTypeSourcecodeatpetsc4py/PETSc/PC.pyx:289setUp()
                     Set up the internal data structures for the PC.

                     Collective.

                     SEEALSO:PCSetUpSourcecodeatpetsc4py/PETSc/PC.pyx:541ReturntypeNonesetUpOnBlocks()
                     Set up the PC for each block.

                     Collective.

                     For  nested preconditioners such as BJACOBI, setUp is not called on each sub-KSP when setUp
                     is called on the outer PC. This routine ensures it is called.

                     SEEALSO:setUp, PCSetUpOnBlocksSourcecodeatpetsc4py/PETSc/PC.pyx:565ReturntypeNonesetUseAmat(flag)
                     Set to indicate to apply PC to A and not P.

                     Logically collective.

                     Sets a flag to indicate that when the preconditioner needs to apply (part of) the  operator
                     during  the  preconditioning  process,  it  applies  to  A  provided  to TS.setRHSJacobian,
                     TS.setIJacobian, SNES.setJacobian, KSP.setOperators or PC.setOperators not the P.

                     Parametersflag (bool) -- Set True to use A and False to use P.

                     ReturntypeNoneSEEALSO:setOperators, PCSetUseAmatSourcecodeatpetsc4py/PETSc/PC.pyx:432view(viewer=None)
                     View the PC object.

                     Collective.

                     Parametersviewer (Viewer|None) -- The visualization context.

                     ReturntypeNoneSEEALSO:PCViewSourcecodeatpetsc4py/PETSc/PC.pyx:231petsc4py.PETSc.Partitionerclasspetsc4py.PETSc.Partitioner
              Bases: Object

              A graph partitioner.

              Enumerations
                                              ┌──────┬────────────────────────┐
                                              │ Type │ The partitioner types. │
                                              └──────┴────────────────────────┘

   petsc4py.PETSc.Partitioner.Typeclasspetsc4py.PETSc.Partitioner.Type
                     Bases: object

                     The partitioner types.

                     Attributes Summary
                                      ┌─────────────────┬────────────────────────────────────┐
                                      │ CHACO           │ Object CHACO of type str           │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ GATHER          │ Object GATHER of type str          │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ MATPARTITIONING │ Object MATPARTITIONING of type str │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ PARMETIS        │ Object PARMETIS of type str        │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ PTSCOTCH        │ Object PTSCOTCH of type str        │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ SHELL           │ Object SHELL of type str           │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ SIMPLE          │ Object SIMPLE of type str          │
                                      └─────────────────┴────────────────────────────────────┘

                     Attributes Documentation

                     CHACO:str=CHACO
                            Object CHACO of type strGATHER:str=GATHER
                            Object GATHER of type strMATPARTITIONING:str=MATPARTITIONING
                            Object MATPARTITIONING of type strPARMETIS:str=PARMETIS
                            Object PARMETIS of type strPTSCOTCH:str=PTSCOTCH
                            Object PTSCOTCH of type strSHELL:str=SHELL
                            Object SHELL of type strSIMPLE:str=SIMPLE
                            Object SIMPLE of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ create([comm])                        │ Create an empty partitioner object.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the partitioner object.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the partitioner type.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reset()                               │ Reset   data   structures   of    the │
                      │                                       │ partitioner.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Set  parameters  in  the  partitioner │
                      │                                       │ from the options database.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setShellPartition(numProcs[,   sizes, │ Set a custom partition for a mesh.    │
                      │ points])                              │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(part_type)                    │ Build   a   particular  type  of  the │
                      │                                       │ partitioner.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Construct  data  structures  for  the │
                      │                                       │ partitioner.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View the partitioner.                 │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Create an empty partitioner object.

                     Collective.

                     The type can be set with setType.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:setType, PetscPartitionerCreateSourcecodeatpetsc4py/PETSc/Partitioner.pyx:57destroy()
                     Destroy the partitioner object.

                     Collective.

                     SEEALSO:PetscPartitionerDestroySourcecodeatpetsc4py/PETSc/Partitioner.pyx:44ReturntypeSelfgetType()
                     Return the partitioner type.

                     Not collective.

                     SEEALSO:setType, PetscPartitionerGetTypeSourcecodeatpetsc4py/PETSc/Partitioner.pyx:99ReturntypeTypereset()
                     Reset data structures of the partitioner.

                     Collective.

                     SEEALSO:PetscPartitionerResetSourcecodeatpetsc4py/PETSc/Partitioner.pyx:137ReturntypeNonesetFromOptions()
                     Set parameters in the partitioner from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, PetscPartitionerSetFromOptionsSourcecodeatpetsc4py/PETSc/Partitioner.pyx:113ReturntypeNonesetShellPartition(numProcs,sizes=None,points=None)
                     Set a custom partition for a mesh.

                     Collective.

                     Parameters

                            • sizes (Sequence[int]|None) -- The number of points in each partition.

                            • points  (Sequence[int]|None)  -- A permutation of the points that groups those
                              assigned to each partition in order (i.e., partition 0 first,  partition  1  next,
                              etc.).

                            • numProcs (int)

                     ReturntypeNoneSEEALSO:PetscPartitionerShellSetPartitionSourcecodeatpetsc4py/PETSc/Partitioner.pyx:149setType(part_type)
                     Build a particular type of the partitioner.

                     Collective.

                     Parameterspart_type (Type|str) -- The kind of partitioner.

                     ReturntypeNoneSEEALSO:getType, PetscPartitionerSetTypeSourcecodeatpetsc4py/PETSc/Partitioner.pyx:80setUp()
                     Construct data structures for the partitioner.

                     Collective.

                     SEEALSO:PetscPartitionerSetUpSourcecodeatpetsc4py/PETSc/Partitioner.pyx:125ReturntypeNoneview(viewer=None)
                     View the partitioner.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the graph.

                     ReturntypeNoneSEEALSO:PetscPartitionerViewSourcecodeatpetsc4py/PETSc/Partitioner.pyx:25petsc4py.PETSc.Quadclasspetsc4py.PETSc.Quad
              Bases: Object

              Quadrature rule for integration.

              Methods Summary
                              ┌──────────────────────┬───────────────────────────────────────┐
                              │ create([comm])       │ Create a Quad object.                 │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ destroy()            │ Destroy the Quad object.              │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ duplicate()          │ Create   a  deep  copy  of  the  Quad │
                              │                      │ object.                               │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ getData()            │ Return the data defining the Quad.    │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ getNumComponents()   │ Return the number of  components  for │
                              │                      │ functions to be integrated.           │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ getOrder()           │ Return the order of the method in the │
                              │                      │ Quad.                                 │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ setNumComponents(nc) │ Return  the  number of components for │
                              │                      │ functions to be integrated.           │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ setOrder(order)      │ Set the order of the  method  in  the │
                              │                      │ Quad.                                 │
                              ├──────────────────────┼───────────────────────────────────────┤
                              │ view([viewer])       │ View a Quad object.                   │
                              └──────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Create a Quad object.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PetscQuadratureCreateSourcecodeatpetsc4py/PETSc/DT.pyx:28destroy()
                     Destroy the Quad object.

                     Collective.

                     SEEALSO:PetscQuadratureDestroySourcecodeatpetsc4py/PETSc/DT.pyx:63ReturntypeSelfduplicate()
                     Create a deep copy of the Quad object.

                     Collective.

                     SEEALSO:PetscQuadratureDuplicateSourcecodeatpetsc4py/PETSc/DT.pyx:49ReturntypeQuadgetData()
                     Return the data defining the Quad.

                     Not collective.

                     Returns

                            • points (ArrayReal) -- The coordinates of the quadrature points.

                            • weights (ArrayReal) -- The quadrature weights.

                     Returntypetuple(ArrayReal, ArrayReal)

                     SEEALSO:PetscQuadratureGetDataSourcecodeatpetsc4py/PETSc/DT.pyx:76getNumComponents()
                     Return the number of components for functions to be integrated.

                     Not collective.

                     SEEALSO:setNumComponents, PetscQuadratureGetNumComponentsSourcecodeatpetsc4py/PETSc/DT.pyx:104ReturntypeintgetOrder()
                     Return the order of the method in the Quad.

                     Not collective.

                     SEEALSO:setOrder, PetscQuadratureGetOrderSourcecodeatpetsc4py/PETSc/DT.pyx:136ReturntypeintsetNumComponents(nc)
                     Return the number of components for functions to be integrated.

                     Not collective.

                     Parametersnc (int) -- The number of components.

                     ReturntypeNoneSEEALSO:getNumComponents, PetscQuadratureSetNumComponentsSourcecodeatpetsc4py/PETSc/DT.pyx:118setOrder(order)
                     Set the order of the method in the Quad.

                     Not collective.

                     Parametersorder  (int) -- The order of the quadrature, i.e. the highest degree polynomial that
                            is exactly integrated.

                     ReturntypeNoneSEEALSO:getOrder, PetscQuadratureSetOrderSourcecodeatpetsc4py/PETSc/DT.pyx:150view(viewer=None)
                     View a Quad object.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the graph.

                     ReturntypeNoneSEEALSO:PetscQuadratureViewSourcecodeatpetsc4py/PETSc/DT.pyx:9petsc4py.PETSc.Randomclasspetsc4py.PETSc.Random
              Bases: Object

              The random number generator object.

              SEEALSO:PetscRandom

              Enumerations
                                        ┌──────┬───────────────────────────────────┐
                                        │ Type │ The random number generator type. │
                                        └──────┴───────────────────────────────────┘

   petsc4py.PETSc.Random.Typeclasspetsc4py.PETSc.Random.Type
                     Bases: object

                     The random number generator type.

                     Attributes Summary
                                            ┌───────────┬──────────────────────────────┐
                                            │ RAND      │ Object RAND of type str      │
                                            ├───────────┼──────────────────────────────┤
                                            │ RAND48    │ Object RAND48 of type str    │
                                            ├───────────┼──────────────────────────────┤
                                            │ RANDER48  │ Object RANDER48 of type str  │
                                            ├───────────┼──────────────────────────────┤
                                            │ RANDOM123 │ Object RANDOM123 of type str │
                                            ├───────────┼──────────────────────────────┤
                                            │ SPRNG     │ Object SPRNG of type str     │
                                            └───────────┴──────────────────────────────┘

                     Attributes Documentation

                     RAND:str=RAND
                            Object RAND of type strRAND48:str=RAND48
                            Object RAND48 of type strRANDER48:str=RANDER48
                            Object RANDER48 of type strRANDOM123:str=RANDOM123
                            Object RANDOM123 of type strSPRNG:str=SPRNG
                            Object SPRNG of type str

              Methods Summary
                              ┌───────────────────────┬───────────────────────────────────────┐
                              │ create([comm])        │ Create  a  random  number   generator │
                              │                       │ object.                               │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ destroy()             │ Destroy  the  random number generator │
                              │                       │ object.                               │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ getInterval()         │ Return the  interval  containing  the │
                              │                       │ random numbers generated.             │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ getSeed()             │ Return  the  random  number generator │
                              │                       │ seed.                                 │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ getType()             │ Return the type of the random  number │
                              │                       │ generator object.                     │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ getValue()            │ Generate a scalar random number.      │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ getValueReal()        │ Generate a real random number.        │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ setFromOptions()      │ Configure the random number generator │
                              │                       │ from the options database.            │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ setInterval(interval) │ Set the interval of the random number │
                              │                       │ generator.                            │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ setSeed([seed])       │ Set   the   seed   of  random  number │
                              │                       │ generator.                            │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ setType(rnd_type)     │ Set the type  of  the  random  number │
                              │                       │ generator object.                     │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ view([viewer])        │ View   a   random   number  generator │
                              │                       │ object.                               │
                              └───────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                    ┌──────────┬───────────────────────────────────────┐
                                    │ interval │ The interval of the generated  random │
                                    │          │ numbers.                              │
                                    ├──────────┼───────────────────────────────────────┤
                                    │ seed     │ The   seed   of   the  random  number │
                                    │          │ generator.                            │
                                    └──────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Create a random number generator object.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:Sys.getDefaultComm, PetscRandomCreateSourcecodeatpetsc4py/PETSc/Random.pyx:74destroy()
                     Destroy the random number generator object.

                     Collective.

                     SEEALSO:PetscRandomDestroySourcecodeatpetsc4py/PETSc/Random.pyx:61ReturntypeSelfgetInterval()
                     Return the interval containing the random numbers generated.

                     Not collective.

                     SEEALSO:setInterval, PetscRandomGetIntervalSourcecodeatpetsc4py/PETSc/Random.pyx:199Returntypetuple[Scalar, Scalar]

              getSeed()
                     Return the random number generator seed.

                     Not collective.

                     SEEALSO:setSeed, PetscRandomGetSeedSourcecodeatpetsc4py/PETSc/Random.pyx:166ReturntypeintgetType()
                     Return the type of the random number generator object.

                     Not collective.

                     SEEALSO:setType, PetscRandomGetTypeSourcecodeatpetsc4py/PETSc/Random.pyx:112ReturntypestrgetValue()
                     Generate a scalar random number.

                     Not collective.

                     SEEALSO:PetscRandomGetValueSourcecodeatpetsc4py/PETSc/Random.pyx:138ReturntypeScalargetValueReal()
                     Generate a real random number.

                     Not collective.

                     SEEALSO:PetscRandomGetValueRealSourcecodeatpetsc4py/PETSc/Random.pyx:152ReturntypefloatsetFromOptions()
                     Configure the random number generator from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, PetscRandomSetFromOptionsSourcecodeatpetsc4py/PETSc/Random.pyx:126ReturntypeNonesetInterval(interval)
                     Set the interval of the random number generator.

                     Not collective.

                     SEEALSO:getInterval, PetscRandomSetIntervalSourcecodeatpetsc4py/PETSc/Random.pyx:214Parametersinterval (tuple[Scalar,Scalar])

                     ReturntypeNonesetSeed(seed=None)
                     Set the seed of random number generator.

                     Not collective.

                     Parametersseed (int|None) -- The value for the seed. If None, it only seeds the generator.

                     ReturntypeNoneSEEALSO:getSeed, PetscRandomSetSeed, PetscRandomSeedSourcecodeatpetsc4py/PETSc/Random.pyx:180setType(rnd_type)
                     Set the type of the random number generator object.

                     Collective.

                     Parametersrnd_type (Type|str) -- The type of the generator.

                     ReturntypeNoneSEEALSO:getType, PetscRandomSetTypeSourcecodeatpetsc4py/PETSc/Random.pyx:93view(viewer=None)
                     View a random number generator object.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:PetscRandomViewSourcecodeatpetsc4py/PETSc/Random.pyx:41

              Attributes Documentation

              interval
                     The interval of the generated random numbers.

                     Sourcecodeatpetsc4py/PETSc/Random.pyx:241seed   The seed of the random number generator.

                     Sourcecodeatpetsc4py/PETSc/Random.pyx:233petsc4py.PETSc.SFclasspetsc4py.PETSc.SF
              Bases: Object

              Star Forest object for communication.

              SF is used for setting up and managing the communication of certain  entries  of  arrays  and  Vec
              between MPI processes.

              Enumerations
                                              ┌──────┬────────────────────────┐
                                              │ Type │ The star forest types. │
                                              └──────┴────────────────────────┘

   petsc4py.PETSc.SF.Typeclasspetsc4py.PETSc.SF.Type
                     Bases: object

                     The star forest types.

                     Attributes Summary
                                           ┌────────────┬───────────────────────────────┐
                                           │ ALLGATHER  │ Object ALLGATHER of type str  │
                                           ├────────────┼───────────────────────────────┤
                                           │ ALLGATHERV │ Object ALLGATHERV of type str │
                                           ├────────────┼───────────────────────────────┤
                                           │ ALLTOALL   │ Object ALLTOALL of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ BASIC      │ Object BASIC of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ GATHER     │ Object GATHER of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ GATHERV    │ Object GATHERV of type str    │
                                           ├────────────┼───────────────────────────────┤
                                           │ NEIGHBOR   │ Object NEIGHBOR of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ WINDOW     │ Object WINDOW of type str     │
                                           └────────────┴───────────────────────────────┘

                     Attributes Documentation

                     ALLGATHER:str=ALLGATHER
                            Object ALLGATHER of type strALLGATHERV:str=ALLGATHERV
                            Object ALLGATHERV of type strALLTOALL:str=ALLTOALL
                            Object ALLTOALL of type strBASIC:str=BASIC
                            Object BASIC of type strGATHER:str=GATHER
                            Object GATHER of type strGATHERV:str=GATHERV
                            Object GATHERV of type strNEIGHBOR:str=NEIGHBOR
                            Object NEIGHBOR of type strWINDOW:str=WINDOW
                            Object WINDOW of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ bcastBegin(unit,  rootdata, leafdata, │ Begin pointwise broadcast.            │
                      │ op)                                   │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ bcastEnd(unit,  rootdata,   leafdata, │ End  a  broadcast  & reduce operation │
                      │ op)                                   │ started with bcastBegin.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ compose(sf)                           │ Compose a new SF.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeDegree()                       │ Compute and return the degree of each │
                      │                                       │ root vertex.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create a  star  forest  communication │
                      │                                       │ context.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createEmbeddedLeafSF(selected)        │ Remove   edges   from   all  but  the │
                      │                                       │ selected leaves.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createEmbeddedRootSF(selected)        │ Remove  edges  from   all   but   the │
                      │                                       │ selected roots.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createInverse()                       │ Create the inverse map.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSectionSF(rootSection,          │ Create an expanded SF of DOFs.        │
                      │ remoteOffsets, ...)                   │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the star forest.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ distributeSection(rootSection[,       │ Create a new, reorganized Section.    │
                      │ leafSection])                         │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ fetchAndOpBegin(unit,       rootdata, │ Begin fetch and update operation.     │
                      │ leafdata, ...)                        │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ fetchAndOpEnd(unit,         rootdata, │ End  operation  started in a matching │
                      │ leafdata, ...)                        │ call to fetchAndOpBegin.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ gatherBegin(unit,           leafdata, │ Begin  pointwise gather of all leaves │
                      │ multirootdata)                        │ into multi-roots.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ gatherEnd(unit,             leafdata, │ End gather operation that was started │
                      │ multirootdata)                        │ with gatherBegin.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getGraph()                            │ Return star forest graph.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMulti()                            │ Return   the  inner  SF  implementing │
                      │                                       │ gathers and scatters.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the  type  name  of  the  star │
                      │                                       │ forest.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reduceBegin(unit, leafdata, rootdata, │ Begin   reduction  of  leafdata  into │
                      │ op)                                   │ rootdata.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reduceEnd(unit,  leafdata,  rootdata, │ End  a  reduction  operation  started │
                      │ op)                                   │ with reduceBegin.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reset()                               │ Reset a star forest so that different │
                      │                                       │ sizes or neighbors can be used.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ scatterBegin(unit,     multirootdata, │ Begin pointwise scatter operation.    │
                      │ leafdata)                             │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ scatterEnd(unit,       multirootdata, │ End  scatter   operation   that   was │
                      │ leafdata)                             │ started with scatterBegin.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Set   options   using   the   options │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setGraph(nroots, local, remote)       │ Set star forest graph.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRankOrder(flag)                    │ Sort  multi-points  for  gathers  and │
                      │                                       │ scatters by rank order.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(sf_type)                      │ Set the type of the star forest.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Set up communication structures.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View a star forest.                   │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              bcastBegin(unit,rootdata,leafdata,op)
                     Begin pointwise broadcast.

                     Collective.

                     Root  values  are  reduced  to  leaf  values.  This call has to be concluded with a call to
                     bcastEnd.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • rootdata (ndarray) -- Buffer to broadcast.

                            • leafdata (ndarray) -- Buffer to be reduced with values from each leaf's respective
                              root.

                            • op (Op) -- MPI reduction operation.

                     ReturntypeNoneSEEALSO:bcastEnd, PetscSFBcastBeginSourcecodeatpetsc4py/PETSc/SF.pyx:434bcastEnd(unit,rootdata,leafdata,op)
                     End a broadcast & reduce operation started with bcastBegin.

                     Collective.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • rootdata (ndarray) -- Buffer to broadcast.

                            • leafdata (ndarray) -- Buffer to be reduced with values from each leaf's respective
                              root.

                            • op (Op) -- MPI reduction operation.

                     ReturntypeNoneSEEALSO:bcastBegin, PetscSFBcastEndSourcecodeatpetsc4py/PETSc/SF.pyx:463compose(sf)
                     Compose a new SF.

                     Collective.

                     Puts the sf under this object in a top (roots) down (leaves) view.

                     Parameterssf (SF) -- SF to put under this object.

                     ReturntypeSFSEEALSO:PetscSFComposeSourcecodeatpetsc4py/PETSc/SF.pyx:413computeDegree()
                     Compute and return the degree of each root vertex.

                     Collective.

                     SEEALSO:PetscSFComputeDegreeBegin, PetscSFComputeDegreeEndSourcecodeatpetsc4py/PETSc/SF.pyx:279ReturntypeArrayIntcreate(comm=None)
                     Create a star forest communication context.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PetscSFCreateSourcecodeatpetsc4py/PETSc/SF.pyx:63createEmbeddedLeafSF(selected)
                     Remove edges from all but the selected leaves.

                     Collective.

                     Does not remap indices.

                     Parametersselected (Sequence[int]) -- Indices of the selected roots on this process.

                     ReturntypeSFSEEALSO:PetscSFCreateEmbeddedLeafSFSourcecodeatpetsc4py/PETSc/SF.pyx:321createEmbeddedRootSF(selected)
                     Remove edges from all but the selected roots.

                     Collective.

                     Does not remap indices.

                     Parametersselected (Sequence[int]) -- Indices of the selected roots on this process.

                     ReturntypeSFSEEALSO:PetscSFCreateEmbeddedRootSFSourcecodeatpetsc4py/PETSc/SF.pyx:297createInverse()
                     Create the inverse map.

                     Collective.

                     Create the inverse map given a PetscSF in which all vertices have degree 1.

                     SEEALSO:PetscSFCreateInverseSFSourcecodeatpetsc4py/PETSc/SF.pyx:262ReturntypeSFcreateSectionSF(rootSection,remoteOffsets,leafSection)
                     Create an expanded SF of DOFs.

                     Collective.

                     Assumes the input SF relates points.

                     Parameters

                            • rootSection (Section) -- Data layout of remote points for outgoing data  (this  is
                              usually the serial section).

                            • remoteOffsets (Sequence[int]|None) -- Offsets for point data on remote processes
                              (these are offsets from the root section), or None.

                            • leafSection  (Section)  --  Data layout of local points for incoming data (this is
                              the distributed section).

                     ReturntypeSFSEEALSO:PetscSFCreateSectionSFSourcecodeatpetsc4py/PETSc/SF.pyx:345destroy()
                     Destroy the star forest.

                     Collective.

                     SEEALSO:PetscSFDestroySourcecodeatpetsc4py/PETSc/SF.pyx:50ReturntypeSelfdistributeSection(rootSection,leafSection=None)
                     Create a new, reorganized Section.

                     Collective.

                     Moves from the root to the leaves of the SF.

                     Parameters

                            • rootSection (Section) -- Section defined on root space.

                            • leafSection (Section|None) -- Section defined on the leaf space.

                     Returntypetuple[ArrayInt, Section]

                     SEEALSO:PetscSFDistributeSectionSourcecodeatpetsc4py/PETSc/SF.pyx:378fetchAndOpBegin(unit,rootdata,leafdata,leafupdate,op)
                     Begin fetch and update operation.

                     Collective.

                     This operation fetches values from root and updates atomically  by  applying  an  operation
                     using the leaf value.

                     This call has to be completed with fetchAndOpEnd.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • rootdata  (ndarray)  --  Root  values  to be updated, input state is seen by first
                              process to perform an update.

                            • leafdata (ndarray) -- Leaf values to use in reduction.

                            • leafupdate (ndarray) -- State at each leaf's respective root immediately prior  to
                              my atomic update.

                            • op (Op) -- MPI reduction operation.

                     ReturntypeNoneSEEALSO:fetchAndOpEnd, PetscSFFetchAndOpBeginSourcecodeatpetsc4py/PETSc/SF.pyx:642fetchAndOpEnd(unit,rootdata,leafdata,leafupdate,op)
                     End operation started in a matching call to fetchAndOpBegin.

                     Collective.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • rootdata  (ndarray)  --  Root  values  to be updated, input state is seen by first
                              process to perform an update.

                            • leafdata (ndarray) -- Leaf values to use in reduction.

                            • leafupdate (ndarray) -- State at each leaf's respective root immediately prior  to
                              my atomic update.

                            • op (Op) -- MPI reduction operation.

                     ReturntypeNoneSEEALSO:fetchAndOpBegin, PetscSFFetchAndOpEndSourcecodeatpetsc4py/PETSc/SF.pyx:678gatherBegin(unit,leafdata,multirootdata)
                     Begin pointwise gather of all leaves into multi-roots.

                     Collective.

                     This call has to be completed with gatherEnd.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • leafdata (ndarray) -- Leaf data to gather to roots.

                            • multirootdata (ndarray) -- Root buffer to gather into, amount of space per root is
                              equal to its degree.

                     ReturntypeNoneSEEALSO:gatherEnd, PetscSFGatherBeginSourcecodeatpetsc4py/PETSc/SF.pyx:592gatherEnd(unit,leafdata,multirootdata)
                     End gather operation that was started with gatherBegin.

                     Collective.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • leafdata (ndarray) -- Leaf data to gather to roots.

                            • multirootdata (ndarray) -- Root buffer to gather into, amount of space per root is
                              equal to its degree.

                     ReturntypeNoneSEEALSO:gatherBegin, PetscSFGatherEndSourcecodeatpetsc4py/PETSc/SF.pyx:618getGraph()
                     Return star forest graph.

                     Not collective.

                     The number of leaves can be determined from the size of ilocal.

                     Returns

                            • nroots (int) -- Number of root vertices on the current process (these are possible
                              targets for other process to attach leaves).

                            • ilocal (ArrayInt) -- Locations of leaves in leafdata buffers.

                            • iremote  (ArrayInt)  --  Remote  locations  of  root vertices for each leaf on the
                              current process.

                     Returntypetuple[int, ArrayInt, ArrayInt]

                     SEEALSO:PetscSFGetGraphSourcecodeatpetsc4py/PETSc/SF.pyx:155getMulti()
                     Return the inner SF implementing gathers and scatters.

                     Collective.

                     SEEALSO:PetscSFGetMultiSFSourcecodeatpetsc4py/PETSc/SF.pyx:247ReturntypeSFgetType()
                     Return the type name of the star forest.

                     Collective.

                     SEEALSO:PetscSFGetTypeSourcecodeatpetsc4py/PETSc/SF.pyx:103ReturntypestrreduceBegin(unit,leafdata,rootdata,op)
                     Begin reduction of leafdata into rootdata.

                     Collective.

                     This call has to be completed with call to reduceEnd.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • leafdata (ndarray) -- Values to reduce.

                            • rootdata (ndarray) -- Result of reduction of values from all leaves of each root.

                            • op (Op) -- MPI reduction operation.

                     ReturntypeNoneSEEALSO:reduceEnd, PetscSFReduceBeginSourcecodeatpetsc4py/PETSc/SF.pyx:489reduceEnd(unit,leafdata,rootdata,op)
                     End a reduction operation started with reduceBegin.

                     Collective.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • leafdata (ndarray) -- Values to reduce.

                            • rootdata (ndarray) -- Result of reduction of values from all leaves of each root.

                            • op (Op) -- MPI reduction operation.

                     ReturntypeNoneSEEALSO:reduceBegin, PetscSFReduceEndSourcecodeatpetsc4py/PETSc/SF.pyx:517reset()
                     Reset a star forest so that different sizes or neighbors can be used.

                     Collective.

                     SEEALSO:PetscSFResetSourcecodeatpetsc4py/PETSc/SF.pyx:141ReturntypeNonescatterBegin(unit,multirootdata,leafdata)
                     Begin pointwise scatter operation.

                     Collective.

                     Operation is from multi-roots to leaves.  This call has to be completed with scatterEnd.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • multirootdata (ndarray) -- Root buffer to send to each leaf, one unit of data  per
                              leaf.

                            • leafdata  (ndarray)  --  Leaf  data  to  be  updated  with personal data from each
                              respective root.

                     ReturntypeNoneSEEALSO:scatterEnd, PetscSFScatterBeginSourcecodeatpetsc4py/PETSc/SF.pyx:543scatterEnd(unit,multirootdata,leafdata)
                     End scatter operation that was started with scatterBegin.

                     Collective.

                     Parameters

                            • unit (Datatype) -- MPI datatype.

                            • multirootdata (ndarray) -- Root buffer to send to each leaf, one unit of data  per
                              leaf.

                            • leafdata  (ndarray)  --  Leaf  data  to  be  updated  with personal data from each
                              respective root.

                     ReturntypeNoneSEEALSO:scatterBegin, PetscSFScatterEndSourcecodeatpetsc4py/PETSc/SF.pyx:569setFromOptions()
                     Set options using the options database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, PetscSFSetFromOptionsSourcecodeatpetsc4py/PETSc/SF.pyx:117ReturntypeNonesetGraph(nroots,local,remote)
                     Set star forest graph.

                     Collective.

                     The number of leaves argument can be determined from the size of local and/or remote.

                     Parameters

                            • nroots (int) -- Number of root vertices on the current process (these are possible
                              targets for other process to attach leaves).

                            • local (Sequence[int]) -- Locations of leaves in leafdata buffers,  pass  None  for
                              contiguous storage.

                            • remote  (Sequence[int])  -- Remote locations of root vertices for each leaf on the
                              current process. Should be 2*nleaves long as (rank, index) pairs.

                     ReturntypeNoneSEEALSO:PetscSFSetGraphSourcecodeatpetsc4py/PETSc/SF.pyx:190setRankOrder(flag)
                     Sort multi-points for gathers and scatters by rank order.

                     Logically collective.

                     Parametersflag (bool) -- True to sort, False to skip sorting.

                     ReturntypeNoneSEEALSO:PetscSFSetRankOrderSourcecodeatpetsc4py/PETSc/SF.pyx:229setType(sf_type)
                     Set the type of the star forest.

                     Collective.

                     Parameterssf_type (Type|str) -- The star forest type.

                     ReturntypeNoneSEEALSO:PetscSFSetTypeSourcecodeatpetsc4py/PETSc/SF.pyx:84setUp()
                     Set up communication structures.

                     Collective.

                     SEEALSO:PetscSFSetUpSourcecodeatpetsc4py/PETSc/SF.pyx:129ReturntypeNoneview(viewer=None)
                     View a star forest.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the graph.

                     ReturntypeNoneSEEALSO:PetscSFViewSourcecodeatpetsc4py/PETSc/SF.pyx:31petsc4py.PETSc.SNESclasspetsc4py.PETSc.SNES
              Bases: Object

              Nonlinear equations solver.

              SNES is described in the PETScmanual.

              SEEALSO:SNES

              Enumerations
                                    ┌─────────────────┬─────────────────────────────────┐
                                    │ ConvergedReason │ SNES solver termination reason. │
                                    ├─────────────────┼─────────────────────────────────┤
                                    │ NormSchedule    │ SNES norm schedule.             │
                                    ├─────────────────┼─────────────────────────────────┤
                                    │ Type            │ SNES solver type.               │
                                    └─────────────────┴─────────────────────────────────┘

   petsc4py.PETSc.SNES.ConvergedReasonclasspetsc4py.PETSc.SNES.ConvergedReason
                     Bases: object

                     SNES solver termination reason.

                     SEEALSO:SNESGetConvergedReason

                     Attributes Summary
                                ┌──────────────────────────┬───────────────────────────────────────┐
                                │ CONVERGED_FNORM_ABS      │ Constant CONVERGED_FNORM_ABS of  type │
                                │                          │ int                                   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ CONVERGED_FNORM_RELATIVE │ Constant  CONVERGED_FNORM_RELATIVE of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ CONVERGED_ITERATING      │ Constant CONVERGED_ITERATING of  type │
                                │                          │ int                                   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ CONVERGED_ITS            │ Constant CONVERGED_ITS of type int    │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ CONVERGED_SNORM_RELATIVE │ Constant  CONVERGED_SNORM_RELATIVE of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_DTOL            │ Constant DIVERGED_DTOL of type int    │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_FNORM_NAN       │ Constant DIVERGED_FNORM_NAN of type ‐ │
                                │                          │ int                                   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_FUNCTION_COUNT  │ Constant  DIVERGED_FUNCTION_COUNT  of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_FUNCTION_DOMAIN │ Constant  DIVERGED_FUNCTION_DOMAIN of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_INNER           │ Constant DIVERGED_INNER of type int   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_JACOBIAN_DOMAIN │ Constant DIVERGED_JACOBIAN_DOMAIN  of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_LINEAR_SOLVE    │ Constant   DIVERGED_LINEAR_SOLVE   of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_LINE_SEARCH     │ Constant DIVERGED_LINE_SEARCH of type │
                                │                          │ int                                   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_LOCAL_MIN       │ Constant DIVERGED_LOCAL_MIN of type ‐ │
                                │                          │ int                                   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_MAX_IT          │ Constant DIVERGED_MAX_IT of type int  │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_TR_DELTA        │ Constant DIVERGED_TR_DELTA of type  ‐ │
                                │                          │ int                                   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ ITERATING                │ Constant ITERATING of type int        │
                                └──────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     CONVERGED_FNORM_ABS:int=CONVERGED_FNORM_ABS
                            Constant CONVERGED_FNORM_ABS of type intCONVERGED_FNORM_RELATIVE:int=CONVERGED_FNORM_RELATIVE
                            Constant CONVERGED_FNORM_RELATIVE of type intCONVERGED_ITERATING:int=CONVERGED_ITERATING
                            Constant CONVERGED_ITERATING of type intCONVERGED_ITS:int=CONVERGED_ITS
                            Constant CONVERGED_ITS of type intCONVERGED_SNORM_RELATIVE:int=CONVERGED_SNORM_RELATIVE
                            Constant CONVERGED_SNORM_RELATIVE of type intDIVERGED_DTOL:int=DIVERGED_DTOL
                            Constant DIVERGED_DTOL of type intDIVERGED_FNORM_NAN:int=DIVERGED_FNORM_NAN
                            Constant DIVERGED_FNORM_NAN of type intDIVERGED_FUNCTION_COUNT:int=DIVERGED_FUNCTION_COUNT
                            Constant DIVERGED_FUNCTION_COUNT of type intDIVERGED_FUNCTION_DOMAIN:int=DIVERGED_FUNCTION_DOMAIN
                            Constant DIVERGED_FUNCTION_DOMAIN of type intDIVERGED_INNER:int=DIVERGED_INNER
                            Constant DIVERGED_INNER of type intDIVERGED_JACOBIAN_DOMAIN:int=DIVERGED_JACOBIAN_DOMAIN
                            Constant DIVERGED_JACOBIAN_DOMAIN of type intDIVERGED_LINEAR_SOLVE:int=DIVERGED_LINEAR_SOLVE
                            Constant DIVERGED_LINEAR_SOLVE of type intDIVERGED_LINE_SEARCH:int=DIVERGED_LINE_SEARCH
                            Constant DIVERGED_LINE_SEARCH of type intDIVERGED_LOCAL_MIN:int=DIVERGED_LOCAL_MIN
                            Constant DIVERGED_LOCAL_MIN of type intDIVERGED_MAX_IT:int=DIVERGED_MAX_IT
                            Constant DIVERGED_MAX_IT of type intDIVERGED_TR_DELTA:int=DIVERGED_TR_DELTA
                            Constant DIVERGED_TR_DELTA of type intITERATING:int=ITERATING
                            Constant ITERATING of type intpetsc4py.PETSc.SNES.NormScheduleclasspetsc4py.PETSc.SNES.NormSchedule
                     Bases: object

                     SNES norm schedule.

                     SEEALSO:SNESNormSchedule

                     Attributes Summary
                                ┌─────────────────────────┬───────────────────────────────────────┐
                                │ ALWAYS                  │ Constant ALWAYS of type int           │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ DEFAULT                 │ Constant DEFAULT of type int          │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ FINAL_ONLY              │ Constant FINAL_ONLY of type int       │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ INITIAL_FINAL_ONLY      │ Constant INITIAL_FINAL_ONLY of type ‐ │
                                │                         │ int                                   │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ INITIAL_ONLY            │ Constant INITIAL_ONLY of type int     │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ NONE                    │ Constant NONE of type int             │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ NORM_ALWAYS             │ Constant NORM_ALWAYS of type int      │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ NORM_DEFAULT            │ Constant NORM_DEFAULT of type int     │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ NORM_FINAL_ONLY         │ Constant NORM_FINAL_ONLY of type int  │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ NORM_INITIAL_FINAL_ONLY │ Constant  NORM_INITIAL_FINAL_ONLY  of │
                                │                         │ type int                              │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ NORM_INITIAL_ONLY       │ Constant NORM_INITIAL_ONLY of type  ‐ │
                                │                         │ int                                   │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ NORM_NONE               │ Constant NORM_NONE of type int        │
                                └─────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     ALWAYS:int=ALWAYS
                            Constant ALWAYS of type intDEFAULT:int=DEFAULT
                            Constant DEFAULT of type intFINAL_ONLY:int=FINAL_ONLY
                            Constant FINAL_ONLY of type intINITIAL_FINAL_ONLY:int=INITIAL_FINAL_ONLY
                            Constant INITIAL_FINAL_ONLY of type intINITIAL_ONLY:int=INITIAL_ONLY
                            Constant INITIAL_ONLY of type intNONE:int=NONE
                            Constant NONE of type intNORM_ALWAYS:int=NORM_ALWAYS
                            Constant NORM_ALWAYS of type intNORM_DEFAULT:int=NORM_DEFAULT
                            Constant NORM_DEFAULT of type intNORM_FINAL_ONLY:int=NORM_FINAL_ONLY
                            Constant NORM_FINAL_ONLY of type intNORM_INITIAL_FINAL_ONLY:int=NORM_INITIAL_FINAL_ONLY
                            Constant NORM_INITIAL_FINAL_ONLY of type intNORM_INITIAL_ONLY:int=NORM_INITIAL_ONLY
                            Constant NORM_INITIAL_ONLY of type intNORM_NONE:int=NORM_NONE
                            Constant NORM_NONE of type intpetsc4py.PETSc.SNES.Typeclasspetsc4py.PETSc.SNES.Type
                     Bases: object

                     SNES solver type.

                     SEEALSO:SNESType

                     Attributes Summary
                                     ┌──────────────────┬─────────────────────────────────────┐
                                     │ ANDERSON         │ Object ANDERSON of type str         │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ ASPIN            │ Object ASPIN of type str            │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ COMPOSITE        │ Object COMPOSITE of type str        │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ FAS              │ Object FAS of type str              │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ KSPONLY          │ Object KSPONLY of type str          │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ KSPTRANSPOSEONLY │ Object KSPTRANSPOSEONLY of type str │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ MS               │ Object MS of type str               │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ NASM             │ Object NASM of type str             │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ NCG              │ Object NCG of type str              │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ NEWTONLS         │ Object NEWTONLS of type str         │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ NEWTONTR         │ Object NEWTONTR of type str         │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ NGMRES           │ Object NGMRES of type str           │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ NGS              │ Object NGS of type str              │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ NRICHARDSON      │ Object NRICHARDSON of type str      │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ PATCH            │ Object PATCH of type str            │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ PYTHON           │ Object PYTHON of type str           │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ QN               │ Object QN of type str               │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ SHELL            │ Object SHELL of type str            │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ VINEWTONRSLS     │ Object VINEWTONRSLS of type str     │
                                     ├──────────────────┼─────────────────────────────────────┤
                                     │ VINEWTONSSLS     │ Object VINEWTONSSLS of type str     │
                                     └──────────────────┴─────────────────────────────────────┘

                     Attributes Documentation

                     ANDERSON:str=ANDERSON
                            Object ANDERSON of type strASPIN:str=ASPIN
                            Object ASPIN of type strCOMPOSITE:str=COMPOSITE
                            Object COMPOSITE of type strFAS:str=FAS
                            Object FAS of type strKSPONLY:str=KSPONLY
                            Object KSPONLY of type strKSPTRANSPOSEONLY:str=KSPTRANSPOSEONLY
                            Object KSPTRANSPOSEONLY of type strMS:str=MS
                            Object MS of type strNASM:str=NASM
                            Object NASM of type strNCG:str=NCG
                            Object NCG of type strNEWTONLS:str=NEWTONLS
                            Object NEWTONLS of type strNEWTONTR:str=NEWTONTR
                            Object NEWTONTR of type strNGMRES:str=NGMRES
                            Object NGMRES of type strNGS:str=NGS
                            Object NGS of type strNRICHARDSON:str=NRICHARDSON
                            Object NRICHARDSON of type strPATCH:str=PATCH
                            Object PATCH of type strPYTHON:str=PYTHON
                            Object PYTHON of type strQN:str=QN
                            Object QN of type strSHELL:str=SHELL
                            Object SHELL of type strVINEWTONRSLS:str=VINEWTONRSLS
                            Object VINEWTONRSLS of type strVINEWTONSSLS:str=VINEWTONSSLS
                            Object VINEWTONSSLS of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ appendOptionsPrefix(prefix)           │ Append   to   the   prefix  used  for │
                      │                                       │ searching   for   options   in    the │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ callConvergenceTest(its,       xnorm, │ Compute the convergence test.         │
                      │ ynorm, fnorm)                         │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeFunction(x, f)                 │ Compute the function.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeJacobian(x, J[, P])            │ Compute the Jacobian.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeNGS(x[, b])                    │ Compute  a   nonlinear   Gauss-Seidel │
                      │                                       │ step.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeObjective(x)                   │ Compute  the  value  of the objective │
                      │                                       │ function.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ converged(its, xnorm, ynorm, fnorm)   │ Compute  the  convergence  test   and │
                      │                                       │ update the solver converged reason.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create a SNES solver.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createPython([context, comm])         │ Create  a  nonlinear solver of Python │
                      │                                       │ type.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the solver.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getApplicationContext()               │ Return the application context.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCompositeNumber()                  │ Return the number of solvers  in  the │
                      │                                       │ composite.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCompositeSNES(n)                   │ Return   the   n-th   solver  in  the │
                      │                                       │ composite.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConvergedReason()                  │ Return the termination flag.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConvergenceHistory()               │ Return the convergence history.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConvergenceTest()                  │ Return  the  callback  to   used   as │
                      │                                       │ convergence test.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDM()                               │ Return  the  DM  associated  with the │
                      │                                       │ solver.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDivergenceTolerance()              │ Get    the    divergence    tolerance │
                      │                                       │ parameter  used  in  the  convergence │
                      │                                       │ tests.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getErrorIfNotConverged()              │ Return the flag indicating  error  on │
                      │                                       │ divergence.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASCoarseSolve()                   │ Return  the SNES used at the coarsest │
                      │                                       │ level of the FAS hierarchy.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASCycleSNES(level)                │ Return the SNES  corresponding  to  a │
                      │                                       │ particular    level    of   the   FAS │
                      │                                       │ hierarchy.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASInjection(level)                │ Return the  Mat  used  to  apply  the │
                      │                                       │ injection from level-1 to level.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASInterpolation(level)            │ Return  the  Mat  used  to  apply the │
                      │                                       │ interpolation from level-1 to level.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASLevels()                        │ Return the number of levels used.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASRestriction(level)              │ Return the  Mat  used  to  apply  the │
                      │                                       │ restriction from level-1 to level.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASSmoother(level)                 │ Return  the  smoother used at a given │
                      │                                       │ level of the FAS hierarchy.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASSmootherDown(level)             │ Return the  downsmoother  used  at  a │
                      │                                       │ given level of the FAS hierarchy.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFASSmootherUp(level)               │ Return the upsmoother used at a given │
                      │                                       │ level of the FAS hierarchy.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFunction()                         │ Return  the  callback  to compute the │
                      │                                       │ nonlinear function.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFunctionEvaluations()              │ Return the current number of function │
                      │                                       │ evaluations.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFunctionNorm()                     │ Return the function norm.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getInitialGuess()                     │ Return the callback  to  compute  the │
                      │                                       │ initial guess.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getIterationNumber()                  │ Return the current iteration number.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getJacobian()                         │ Return  the  matrices used to compute │
                      │                                       │ the Jacobian and the callback tuple.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getKSP()                              │ Return the linear solver used by  the │
                      │                                       │ nonlinear solver.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getKSPFailures()                      │ Return  the  current number of linear │
                      │                                       │ solve failures.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLinearSolveIterations()            │ Return the  total  number  of  linear │
                      │                                       │ iterations.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMaxFunctionEvaluations()           │ Return  the maximum allowed number of │
                      │                                       │ function evaluations.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMaxKSPFailures()                   │ Return the maximum allowed number  of │
                      │                                       │ linear solve failures.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMaxStepFailures()                  │ Return  the maximum allowed number of │
                      │                                       │ step failures.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMonitor()                          │ Return the callback used  to  monitor │
                      │                                       │ solver convergence.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNASMNumber()                       │ Return the number of solvers in NASM. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNASMSNES(n)                        │ Return the n-th solver in NASM.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNGS()                              │ Return   the  nonlinear  Gauss-Seidel │
                      │                                       │ callback tuple.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNPC()                              │ Return the  nonlinear  preconditioner │
                      │                                       │ associated with the solver.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNPCSide()                          │ Return  the nonlinear preconditioning │
                      │                                       │ side.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNormSchedule()                     │ Return the norm schedule.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getObjective()                        │ Return the objective callback tuple.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOptionsPrefix()                    │ Return the prefix used for  searching │
                      │                                       │ for options in the database.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getParamsEW()                         │ Get  the  parameters of the Eisenstat │
                      │                                       │ and Walker trick.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPythonContext()                    │ Return  the  instance  of  the  class │
                      │                                       │ implementing   the   required  Python │
                      │                                       │ methods.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPythonType()                       │ Return  the  fully  qualified  Python │
                      │                                       │ name of the class used by the solver. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRhs()                              │ Return   the   vector   holding   the │
                      │                                       │ right-hand side.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSolution()                         │ Return   the   vector   holding   the │
                      │                                       │ solution.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSolutionUpdate()                   │ Return   the   vector   holding   the │
                      │                                       │ solution update.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStepFailures()                     │ Return the  current  number  of  step │
                      │                                       │ failures.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTRTolerances()                     │ Return  the tolerance parameters used │
                      │                                       │ for the trust region.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTRUpdateParameters()               │ Return the update parameters used for │
                      │                                       │ the trust region.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTolerances()                       │ Return the tolerance parameters  used │
                      │                                       │ in the solver convergence tests.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the type of the solver.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getUpdate()                           │ Return  the  callback  to compute the │
                      │                                       │ update at the beginning of each step. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getUseEW()                            │ Return the  flag  indicating  if  the │
                      │                                       │ solver   uses   the  Eisenstat-Walker │
                      │                                       │ trick.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getUseFD()                            │ Return true if the solver uses  color │
                      │                                       │ finite-differencing for the Jacobian. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getUseKSP()                           │ Return  the  flag  indicating  if the │
                      │                                       │ solver uses a linear solver.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getUseMF()                            │ Return the  flag  indicating  if  the │
                      │                                       │ solver        uses        matrix-free │
                      │                                       │ finite-differencing.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getVIInactiveSet()                    │ Return the index set for the inactive │
                      │                                       │ set.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ hasNPC()                              │ Return a boolean  indicating  whether │
                      │                                       │ the    solver    has    a   nonlinear │
                      │                                       │ preconditioner.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ logConvergenceHistory(norm[,          │ Log   residual   norm   and    linear │
                      │ linear_its])                          │ iterations.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ monitor(its, rnorm)                   │ Monitor the solver.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ monitorCancel()                       │ Cancel   all   the  monitors  of  the │
                      │                                       │ solver.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reset()                               │ Reset the solver.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setApplicationContext(appctx)         │ Set the application context.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConvergedReason(reason)            │ Set the termination flag.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConvergenceHistory([length,        │ Set the convergence history.          │
                      │ reset])                               │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConvergenceTest(converged[,  args, │ Set    the   callback   to   use   as │
                      │ kargs])                               │ convergence test.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDM(dm)                             │ Associate a DM with the solver.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDivergenceTolerance(dtol)          │ Set    the    divergence    tolerance │
                      │                                       │ parameter  used  in  the  convergence │
                      │                                       │ tests.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setErrorIfNotConverged(flag)          │ Immediately generate an error if  the │
                      │                                       │ solver has not converged.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFASInjection(level, mat)           │ Set  the  Mat to be used to apply the │
                      │                                       │ injection from level-1 to level.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFASInterpolation(level, mat)       │ Set the Mat to be used to  apply  the │
                      │                                       │ interpolation from level-1 to level.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFASLevels(levels[, comms])         │ Set  the number of levels to use with │
                      │                                       │ FAS.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFASRScale(level, vec)              │ Set  the  scaling   factor   of   the │
                      │                                       │ restriction  operator  from  level to │
                      │                                       │ level-1.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFASRestriction(level, mat)         │ Set the Mat to be used to  apply  the │
                      │                                       │ restriction from level-1 to level.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setForceIteration(force)              │ Force  solve  to  take  at  least one │
                      │                                       │ iteration.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Configure the solver from the options │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFunction(function[,    f,    args, │ Set   the  callback  to  compute  the │
                      │ kargs])                               │ nonlinear function.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFunctionNorm(norm)                 │ Set the function norm value.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setInitialGuess(initialguess[,  args, │ Set   the  callback  to  compute  the │
                      │ kargs])                               │ initial guess.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setIterationNumber(its)               │ Set the current iteration number.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setJacobian(jacobian[,  J,  P,  args, │ Set   the  callback  to  compute  the │
                      │ kargs])                               │ Jacobian.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setKSP(ksp)                           │ Set the linear solver  that  will  be │
                      │                                       │ used by the nonlinear solver.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLineSearchPreCheck(precheck[,      │ Set  the callback that will be called │
                      │ args, kargs])                         │ before applying the linesearch.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMaxFunctionEvaluations(max_funcs)  │ Set the  maximum  allowed  number  of │
                      │                                       │ function evaluations.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMaxKSPFailures(max_fails)          │ Set  the  maximum  allowed  number of │
                      │                                       │ linear solve failures.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMaxStepFailures(max_fails)         │ Set the  maximum  allowed  number  of │
                      │                                       │ step failures.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMonitor(monitor[, args, kargs])    │ Set  the  callback  used  to  monitor │
                      │                                       │ solver convergence.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNGS(ngs[, args, kargs])            │ Set the callback to compute nonlinear │
                      │                                       │ Gauss-Seidel.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNPC(snes)                          │ Set the nonlinear preconditioner.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNPCSide(side)                      │ Set  the  nonlinear   preconditioning │
                      │                                       │ side.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNormSchedule(normsched)            │ Set the norm schedule.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setObjective(objective[,        args, │ Set  the  callback  to  compute   the │
                      │ kargs])                               │ objective function.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOptionsPrefix(prefix)              │ Set the prefix used for searching for │
                      │                                       │ options in the database.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setParamsEW([version,         rtol_0, │ Set the parameters for the  Eisenstat │
                      │ rtol_max, ...])                       │ and Walker trick.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPatchCellNumbering(sec)            │ Set cell patch numbering.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPatchComputeFunction(function[,    │ Set patch compute function.           │
                      │ args, kargs])                         │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPatchComputeOperator(operator[,    │ Set patch compute operator.           │
                      │ args, kargs])                         │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPatchConstructType(typ[, operator, │ Set patch construct type.             │
                      │ args, ...])                           │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPatchDiscretisationInfo(dms,   bs, │ Set patch discretisation information. │
                      │ ...)                                  │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPythonContext(context)             │ Set  the  instance   of   the   class │
                      │                                       │ implementing   the   required  Python │
                      │                                       │ methods.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPythonType(py_type)                │ Set the fully qualified  Python  name │
                      │                                       │ of the class to be used.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setResetCounters([reset])             │ Set the flag to reset the counters.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSolution(vec)                      │ Set  the  vector  used  to  store the │
                      │                                       │ solution.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTRTolerances([delta_min,           │ Set the tolerance parameters used for │
                      │ delta_max, delta_0])                  │ the trust region.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTRUpdateParameters([eta1,    eta2, │ Set  the  update  parameters used for │
                      │ eta3, t1, t2])                        │ the trust region.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTolerances([rtol,   atol,    stol, │ Set  the tolerance parameters used in │
                      │ max_it])                              │ the solver convergence tests.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(snes_type)                    │ Set the type of the solver.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Set up the internal  data  structures │
                      │                                       │ for using the solver.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUpMatrices()                       │ Ensures  that  matrices are available │
                      │                                       │ for Newton-like methods.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUpdate(update[, args, kargs])      │ Set the callback to compute update at │
                      │                                       │ the beginning of each step.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUseEW([flag])                      │ Tell   the   solver   to   use    the │
                      │                                       │ Eisenstat-Walker trick.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUseFD([flag])                      │ Set  the boolean flag to use coloring │
                      │                                       │ finite-differencing   for    Jacobian │
                      │                                       │ assembly.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUseKSP([flag])                     │ Set  the  boolean  flag indicating to │
                      │                                       │ use a linear solver.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUseMF([flag])                      │ Set the boolean  flag  indicating  to │
                      │                                       │ use matrix-free finite-differencing.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setVariableBounds(xl, xu)             │ Set   the  vector  for  the  variable │
                      │                                       │ bounds.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solve([b, x])                         │ Solve the nonlinear equations.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View the solver.                      │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                  ┌──────────────┬───────────────────────────────────────┐
                                  │ appctx       │ Application context.                  │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ atol         │ Absolute residual tolerance.          │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ dm           │ DM.                                   │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ history      │ Convergence history.                  │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ is_converged │ Boolean indicating if the solver  has │
                                  │              │ converged.                            │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ is_diverged  │ Boolean  indicating if the solver has │
                                  │              │ failed.                               │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ is_iterating │ Boolean indicating if the solver  has │
                                  │              │ not converged yet.                    │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ its          │ Number of iterations.                 │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ ksp          │ Linear solver.                        │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ max_funcs    │ Maximum     number     of    function │
                                  │              │ evaluations.                          │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ max_it       │ Maximum number of iterations.         │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ norm         │ Function norm.                        │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ npc          │ Nonlinear preconditioner.             │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ reason       │ Converged reason.                     │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ rtol         │ Relative residual tolerance.          │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ stol         │ Solution update tolerance.            │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ use_ew       │ Use the Eisenstat-Walker trick.       │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ use_fd       │ Boolean indicating if the solver uses │
                                  │              │ coloring finite-differencing.         │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ use_ksp      │ Boolean indicating if the solver uses │
                                  │              │ a linear solver.                      │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ use_mf       │ Boolean indicating if the solver uses │
                                  │              │ matrix-free finite-differencing.      │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ vec_rhs      │ Right-hand side vector.               │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ vec_sol      │ Solution vector.                      │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ vec_upd      │ Update vector.                        │
                                  └──────────────┴───────────────────────────────────────┘

              Methods Documentation

              appendOptionsPrefix(prefix)
                     Append to the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, SNESAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/SNES.pyx:227Parametersprefix (str|None)

                     ReturntypeNonecallConvergenceTest(its,xnorm,ynorm,fnorm)
                     Compute the convergence test.

                     Collective.

                     Parameters

                            • its (int) -- Iteration number.

                            • xnorm (float) -- Solution norm.

                            • ynorm (float) -- Update norm.

                            • fnorm (float) -- Function norm.

                     ReturntypeConvergedReasonSEEALSO:setConvergenceTest, getConvergenceTestSourcecodeatpetsc4py/PETSc/SNES.pyx:1326computeFunction(x,f)
                     Compute the function.

                     Collective.

                     Parameters

                            • x (Vec) -- The input state vector.

                            • f (Vec) -- The output vector.

                     ReturntypeNoneSEEALSO:setFunction, SNESComputeFunctionSourcecodeatpetsc4py/PETSc/SNES.pyx:1027computeJacobian(x,J,P=None)
                     Compute the Jacobian.

                     Collective.

                     Parameters

                            • x (Vec) -- The input state vector.

                            • J (Mat) -- The output Jacobian matrix.

                            • P (Mat|None) -- The output Jacobian matrix used to construct the preconditioner.

                     ReturntypeNoneSEEALSO:setJacobian, SNESComputeJacobianSourcecodeatpetsc4py/PETSc/SNES.pyx:1046computeNGS(x,b=None)
                     Compute a nonlinear Gauss-Seidel step.

                     Collective.

                     Parameters

                            • x (Vec) -- The input/output state vector.

                            • b (Vec|None) -- The input right-hand side vector.

                     ReturntypeNoneSEEALSO:setNGS, getNGS, SNESComputeNGSSourcecodeatpetsc4py/PETSc/SNES.pyx:1133computeObjective(x)
                     Compute the value of the objective function.

                     Collective.

                     Parametersx (Vec) -- The input state vector.

                     ReturntypefloatSEEALSO:setObjective, SNESComputeObjectiveSourcecodeatpetsc4py/PETSc/SNES.pyx:1069converged(its,xnorm,ynorm,fnorm)
                     Compute the convergence test and update the solver converged reason.

                     Collective.

                     Parameters

                            • its (int) -- Iteration number.

                            • xnorm (float) -- Solution norm.

                            • ynorm (float) -- Update norm.

                            • fnorm (float) -- Function norm.

                     ReturntypeNoneSEEALSO:setConvergenceTest, getConvergenceTest, SNESConvergedSourcecodeatpetsc4py/PETSc/SNES.pyx:1356create(comm=None)
                     Create a SNES solver.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:Sys.getDefaultComm, SNESCreateSourcecodeatpetsc4py/PETSc/SNES.pyx:145createPython(context=None,comm=None)
                     Create a nonlinear solver of Python type.

                     Collective.

                     Parameters

                            • context (Any) -- An  instance  of  the  Python  class  implementing  the  required
                              methods.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PETScPythonnonlinearsolvertype(TODO), setType, setPythonContext, Type.PYTHONSourcecodeatpetsc4py/PETSc/SNES.pyx:2179destroy()
                     Destroy the solver.

                     Collective.

                     SEEALSO:SNESDestroySourcecodeatpetsc4py/PETSc/SNES.pyx:132ReturntypeSelfgetApplicationContext()
                     Return the application context.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:264ReturntypeAnygetCompositeNumber()
                     Return the number of solvers in the composite.

                     Not collective.

                     SEEALSO:getCompositeSNES, SNESCompositeGetNumber, SNESCOMPOSITESourcecodeatpetsc4py/PETSc/SNES.pyx:2280ReturntypeintgetCompositeSNES(n)
                     Return the n-th solver in the composite.

                     Not collective.

                     SEEALSO:getCompositeNumber, SNESCompositeGetSNES, SNESCOMPOSITESourcecodeatpetsc4py/PETSc/SNES.pyx:2263Parametersn (int)

                     ReturntypeSNESgetConvergedReason()
                     Return the termination flag.

                     Not collective.

                     SEEALSO:setConvergedReason, SNESGetConvergedReasonSourcecodeatpetsc4py/PETSc/SNES.pyx:1739ReturntypeConvergedReasongetConvergenceHistory()
                     Return the convergence history.

                     Not collective.

                     SEEALSO:SNESGetConvergenceHistorySourcecodeatpetsc4py/PETSc/SNES.pyx:1407Returntypetuple[ArrayReal, ArrayInt]

              getConvergenceTest()
                     Return the callback to used as convergence test.

                     Not collective.

                     SEEALSO:setConvergenceTest, callConvergenceTestSourcecodeatpetsc4py/PETSc/SNES.pyx:1314ReturntypeSNESConvergedFunctiongetDM()
                     Return the DM associated with the solver.

                     Not collective.

                     SEEALSO:setDM, SNESGetDMSourcecodeatpetsc4py/PETSc/SNES.pyx:279ReturntypeDMgetDivergenceTolerance()
                     Get the divergence tolerance parameter used in the convergence tests.

                     Not collective.

                     SEEALSO:setDivergenceTolerance, getTolerances, SNESGetDivergenceToleranceSourcecodeatpetsc4py/PETSc/SNES.pyx:1239ReturntypefloatgetErrorIfNotConverged()
                     Return the flag indicating error on divergence.

                     Not collective.

                     SEEALSO:setErrorIfNotConverged, SNESGetErrorIfNotConvergedSourcecodeatpetsc4py/PETSc/SNES.pyx:1766ReturntypeboolgetFASCoarseSolve()
                     Return the SNES used at the coarsest level of the FAS hierarchy.

                     Not collective.

                     SEEALSO:getFASSmoother, SNESFASGetCoarseSolve, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:594ReturntypeSNESgetFASCycleSNES(level)
                     Return the SNES corresponding to a particular level of the FAS hierarchy.

                     Not collective.

                     SEEALSO:setFASLevels, getFASCoarseSolve, getFASSmoother, SNESFASGetCycleSNES, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:577Parameterslevel (int)

                     ReturntypeSNESgetFASInjection(level)
                     Return the Mat used to apply the injection from level-1 to level.

                     Not collective.

                     SEEALSO:setFASInjection, SNESFASGetInjection, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:500Parameterslevel (int)

                     ReturntypeMatgetFASInterpolation(level)
                     Return the Mat used to apply the interpolation from level-1 to level.

                     Not collective.

                     SEEALSO:setFASInterpolation, SNESFASGetInterpolation, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:440Parameterslevel (int)

                     ReturntypeMatgetFASLevels()
                     Return the number of levels used.

                     Not collective.

                     SEEALSO:setFASLevels, SNESFASGetLevels, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:563ReturntypeintgetFASRestriction(level)
                     Return the Mat used to apply the restriction from level-1 to level.

                     Not collective.

                     SEEALSO:setFASRestriction, SNESFASGetRestriction, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:470Parameterslevel (int)

                     ReturntypeMatgetFASSmoother(level)
                     Return the smoother used at a given level of the FAS hierarchy.

                     Not collective.

                     SEEALSO:setFASLevels,     getFASCoarseSolve,     getFASSmootherDown,     getFASSmootherUp,     ‐
                        SNESFASGetSmoother, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:609Parameterslevel (int)

                     ReturntypeSNESgetFASSmootherDown(level)
                     Return the downsmoother used at a given level of the FAS hierarchy.

                     Not collective.

                     SEEALSO:setFASLevels,      getFASCoarseSolve,      getFASSmoother,      getFASSmootherUp,      ‐
                        SNESFASGetSmootherDown, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:626Parameterslevel (int)

                     ReturntypeSNESgetFASSmootherUp(level)
                     Return the upsmoother used at a given level of the FAS hierarchy.

                     Not collective.

                     SEEALSO:setFASLevels,      getFASCoarseSolve,      getFASSmoother,     getFASSmootherDown,     ‐
                        SNESFASGetSmootherUp, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:643Parameterslevel (int)

                     ReturntypeSNESgetFunction()
                     Return the callback to compute the nonlinear function.

                     Not collective.

                     SEEALSO:setFunction, SNESGetFunctionSourcecodeatpetsc4py/PETSc/SNES.pyx:843ReturntypeSNESFunctiongetFunctionEvaluations()
                     Return the current number of function evaluations.

                     Not collective.

                     SEEALSO:setMaxFunctionEvaluations, SNESGetNumberFunctionEvalsSourcecodeatpetsc4py/PETSc/SNES.pyx:1560ReturntypeintgetFunctionNorm()
                     Return the function norm.

                     Not collective.

                     SEEALSO:setFunctionNorm, SNESGetFunctionNormSourcecodeatpetsc4py/PETSc/SNES.pyx:1837ReturntypefloatgetInitialGuess()
                     Return the callback to compute the initial guess.

                     Not collective.

                     SEEALSO:setInitialGuessSourcecodeatpetsc4py/PETSc/SNES.pyx:796ReturntypeSNESGuessFunctiongetIterationNumber()
                     Return the current iteration number.

                     Not collective.

                     SEEALSO:setIterationNumber, SNESGetIterationNumberSourcecodeatpetsc4py/PETSc/SNES.pyx:1795ReturntypeintgetJacobian()
                     Return the matrices used to compute the Jacobian and the callback tuple.

                     Not collective.

                     Returns

                            • J (Mat) -- The matrix to store the Jacobian.

                            • P (Mat) -- The matrix to construct the preconditioner.

                            • callback (SNESJacobianFunction) -- callback, positional and keyword arguments.

                     Returntypetuple[Mat, Mat, SNESJacobianFunction]

                     SEEALSO:setJacobian, SNESGetJacobianSourcecodeatpetsc4py/PETSc/SNES.pyx:955getKSP()
                     Return the linear solver used by the nonlinear solver.

                     Not collective.

                     SEEALSO:setKSP, SNESGetKSPSourcecodeatpetsc4py/PETSc/SNES.pyx:1936ReturntypeKSPgetKSPFailures()
                     Return the current number of linear solve failures.

                     Not collective.

                     SEEALSO:getMaxKSPFailures, SNESGetLinearSolveFailuresSourcecodeatpetsc4py/PETSc/SNES.pyx:1642ReturntypeintgetLinearSolveIterations()
                     Return the total number of linear iterations.

                     Not collective.

                     SEEALSO:SNESGetLinearSolveIterationsSourcecodeatpetsc4py/PETSc/SNES.pyx:1851ReturntypeintgetMaxFunctionEvaluations()
                     Return the maximum allowed number of function evaluations.

                     Not collective.

                     SEEALSO:setMaxFunctionEvaluations, SNESSetTolerancesSourcecodeatpetsc4py/PETSc/SNES.pyx:1544ReturntypeintgetMaxKSPFailures()
                     Return the maximum allowed number of linear solve failures.

                     Not collective.

                     SEEALSO:setMaxKSPFailures, SNESGetMaxLinearSolveFailuresSourcecodeatpetsc4py/PETSc/SNES.pyx:1628ReturntypeintgetMaxStepFailures()
                     Return the maximum allowed number of step failures.

                     Not collective.

                     SEEALSO:setMaxStepFailures, SNESGetMaxNonlinearStepFailuresSourcecodeatpetsc4py/PETSc/SNES.pyx:1587ReturntypeintgetMonitor()
                     Return the callback used to monitor solver convergence.

                     Not collective.

                     SEEALSO:setMonitorSourcecodeatpetsc4py/PETSc/SNES.pyx:1479Returntypelist[tuple[SNESMonitorFunction, tuple[Any, ...], dict[str, Any]]]

              getNASMNumber()
                     Return the number of solvers in NASM.

                     Not collective.

                     SEEALSO:getNASMSNES, SNESNASMGetNumber, SNESNASMSourcecodeatpetsc4py/PETSc/SNES.pyx:2312ReturntypeintgetNASMSNES(n)
                     Return the n-th solver in NASM.

                     Not collective.

                     SEEALSO:getNASMNumber, SNESNASMGetSNES, SNESNASMSourcecodeatpetsc4py/PETSc/SNES.pyx:2296Parametersn (int)

                     ReturntypeSNESgetNGS()
                     Return the nonlinear Gauss-Seidel callback tuple.

                     Not collective.

                     SEEALSO:setNGS, computeNGSSourcecodeatpetsc4py/PETSc/SNES.pyx:1119ReturntypeSNESNGSFunctiongetNPC()
                     Return the nonlinear preconditioner associated with the solver.

                     Not collective.

                     SEEALSO:setNPC, hasNPC, setNPCSide, getNPCSide, SNESGetNPCSourcecodeatpetsc4py/PETSc/SNES.pyx:662ReturntypeSNESgetNPCSide()
                     Return the nonlinear preconditioning side.

                     Not collective.

                     SEEALSO:setNPC, getNPC, hasNPC, setNPCSide, SNESGetNPCSideSourcecodeatpetsc4py/PETSc/SNES.pyx:715ReturntypeSidegetNormSchedule()
                     Return the norm schedule.

                     Not collective.

                     SEEALSO:setNormSchedule, SNESGetNormScheduleSourcecodeatpetsc4py/PETSc/SNES.pyx:1265ReturntypeNormSchedulegetObjective()
                     Return the objective callback tuple.

                     Not collective.

                     SEEALSO:setObjectiveSourcecodeatpetsc4py/PETSc/SNES.pyx:1013ReturntypeSNESObjFunctiongetOptionsPrefix()
                     Return the prefix used for searching for options in the database.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, SNESGetOptionsPrefixSourcecodeatpetsc4py/PETSc/SNES.pyx:213ReturntypestrgetParamsEW()
                     Get the parameters of the Eisenstat and Walker trick.

                     Not collective.

                     SEEALSO:setUseEW, setParamsEW, SNESKSPGetParametersEWSourcecodeatpetsc4py/PETSc/SNES.pyx:2040Returntypedict[str, int | float]

              getPythonContext()
                     Return the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonnonlinearsolvertype(TODO), setPythonContextSourcecodeatpetsc4py/PETSc/SNES.pyx:2216ReturntypeAnygetPythonType()
                     Return the fully qualified Python name of the class used by the solver.

                     Not collective.

                     SEEALSO:PETScPythonnonlinearsolvertype(TODO),   setPythonContext,   setPythonType,   ‐
                        SNESPythonGetTypeSourcecodeatpetsc4py/PETSc/SNES.pyx:2246ReturntypestrgetRhs()
                     Return the vector holding the right-hand side.

                     Not collective.

                     SEEALSO:SNESGetRhsSourcecodeatpetsc4py/PETSc/SNES.pyx:1865ReturntypeVecgetSolution()
                     Return the vector holding the solution.

                     Not collective.

                     SEEALSO:setSolution, SNESGetSolutionSourcecodeatpetsc4py/PETSc/SNES.pyx:1880ReturntypeVecgetSolutionUpdate()
                     Return the vector holding the solution update.

                     Not collective.

                     SEEALSO:SNESGetSolutionUpdateSourcecodeatpetsc4py/PETSc/SNES.pyx:1907ReturntypeVecgetStepFailures()
                     Return the current number of step failures.

                     Not collective.

                     SEEALSO:getMaxStepFailures, SNESGetNonlinearStepFailuresSourcecodeatpetsc4py/PETSc/SNES.pyx:1601ReturntypeintgetTRTolerances()
                     Return the tolerance parameters used for the trust region.

                     Not collective.

                     Returns

                            • delta_min (float) -- The minimum allowed trust region size.

                            • delta_max (float) -- The maximum allowed trust region size.

                            • delta_0 (float) -- The initial trust region size.

                     Returntypetuple[float, float, float]

                     SEEALSO:setTRTolerances, getTRUpdateParameters, SNESNewtonTRGetTolerancesSourcecodeatpetsc4py/PETSc/SNES.pyx:337getTRUpdateParameters()
                     Return the update parameters used for the trust region.

                     Not collective.

                     Returns

                            • eta1 (float) -- The step acceptance tolerance.

                            • eta2 (float) -- The shrinking tolerance.

                            • eta3 (float) -- The enlarging tolerance.

                            • t1 (float) -- The shrinking factor.

                            • t2 (float) -- The enlarging factor.

                     Returntypetuple[float, float, float, float, float]

                     SEEALSO:setTRUpdateParameters, getTRTolerances, SNESNewtonTRGetUpdateParametersSourcecodeatpetsc4py/PETSc/SNES.pyx:396getTolerances()
                     Return the tolerance parameters used in the solver convergence tests.

                     Not collective.

                     Returns

                            • rtol (float) -- The relative norm of the residual.

                            • atol (float) -- The absolute norm of the residual.

                            • stol (float) -- The absolute norm of the step.

                            • max_it (int) -- The maximum allowed number of iterations.

                     Returntypetuple[float, float, float, int]

                     SEEALSO:setTolerances, SNESGetTolerancesSourcecodeatpetsc4py/PETSc/SNES.pyx:1195getType()
                     Return the type of the solver.

                     Not collective.

                     SEEALSO:setType, SNESGetTypeSourcecodeatpetsc4py/PETSc/SNES.pyx:185ReturntypestrgetUpdate()
                     Return the callback to compute the update at the beginning of each step.

                     Not collective.

                     SEEALSO:setUpdateSourcecodeatpetsc4py/PETSc/SNES.pyx:904ReturntypeSNESUpdateFunctiongetUseEW()
                     Return the flag indicating if the solver uses the Eisenstat-Walker trick.

                     Not collective.

                     SEEALSO:setUseEW, setParamsEW, SNESKSPGetUseEWSourcecodeatpetsc4py/PETSc/SNES.pyx:1974ReturntypeboolgetUseFD()
                     Return true if the solver uses color finite-differencing for the Jacobian.

                     Not collective.

                     SEEALSO:setUseFDSourcecodeatpetsc4py/PETSc/SNES.pyx:2134ReturntypeFalsegetUseKSP()
                     Return the flag indicating if the solver uses a linear solver.

                     Not collective.

                     SEEALSO:setUseKSPSourcecodeatpetsc4py/PETSc/SNES.pyx:2078ReturntypeboolgetUseMF()
                     Return the flag indicating if the solver uses matrix-free finite-differencing.

                     Not collective.

                     SEEALSO:setUseMFSourcecodeatpetsc4py/PETSc/SNES.pyx:2107ReturntypeboolgetVIInactiveSet()
                     Return the index set for the inactive set.

                     Not collective.

                     SEEALSO:SNESVIGetInactiveSetSourcecodeatpetsc4py/PETSc/SNES.pyx:2162ReturntypeIShasNPC()
                     Return a boolean indicating whether the solver has a nonlinear preconditioner.

                     Not collective.

                     SEEALSO:setNPC, getNPC, setNPCSide, getNPCSide, SNESHasNPCSourcecodeatpetsc4py/PETSc/SNES.pyx:677ReturntypeboollogConvergenceHistory(norm,linear_its=0)
                     Log residual norm and linear iterations.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:1425Parameters

                            • norm (float)

                            • linear_its (int)

                     ReturntypeNonemonitor(its,rnorm)
                     Monitor the solver.

                     Collective.

                     Parameters

                            • its -- Current number of iterations.

                            • rnorm -- Current value of the residual norm.

                     ReturntypeNoneSEEALSO:setMonitor, SNESMonitorSourcecodeatpetsc4py/PETSc/SNES.pyx:1506monitorCancel()
                     Cancel all the monitors of the solver.

                     Logically collective.

                     SEEALSO:setMonitor, SNESMonitorCancelSourcecodeatpetsc4py/PETSc/SNES.pyx:1491ReturntypeNonereset()
                     Reset the solver.

                     Collective.

                     SEEALSO:SNESResetSourcecodeatpetsc4py/PETSc/SNES.pyx:1691ReturntypeNonesetApplicationContext(appctx)
                     Set the application context.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:255Parametersappctx (Any)

                     ReturntypeNonesetConvergedReason(reason)
                     Set the termination flag.

                     Collective.

                     SEEALSO:getConvergedReason, SNESSetConvergedReasonSourcecodeatpetsc4py/PETSc/SNES.pyx:1726Parametersreason (ConvergedReason)

                     ReturntypeNonesetConvergenceHistory(length=None,reset=False)
                     Set the convergence history.

                     Logically collective.

                     SEEALSO:SNESSetConvergenceHistorySourcecodeatpetsc4py/PETSc/SNES.pyx:1383ReturntypeNonesetConvergenceTest(converged,args=None,kargs=None)
                     Set the callback to use as convergence test.

                     Logically collective.

                     Parameters

                            • converged  (SNESConvergedFunction|Literal['skip','default']) -- The convergence
                              testing callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getConvergenceTest, callConvergenceTest, SNESSetConvergenceTestSourcecodeatpetsc4py/PETSc/SNES.pyx:1279setDM(dm)
                     Associate a DM with the solver.

                     Not collective.

                     SEEALSO:getDM, SNESSetDMSourcecodeatpetsc4py/PETSc/SNES.pyx:296Parametersdm (DM)

                     ReturntypeNonesetDivergenceTolerance(dtol)
                     Set the divergence tolerance parameter used in the convergence tests.

                     Logically collective.

                     Parametersdtol (float) -- The divergence tolerance.

                     ReturntypeNoneSEEALSO:getDivergenceTolerance, setTolerances, SNESSetDivergenceToleranceSourcecodeatpetsc4py/PETSc/SNES.pyx:1222setErrorIfNotConverged(flag)
                     Immediately generate an error if the solver has not converged.

                     Collective.

                     SEEALSO:getErrorIfNotConverged, SNESSetErrorIfNotConvergedSourcecodeatpetsc4py/PETSc/SNES.pyx:1753Parametersflag (bool)

                     ReturntypeNonesetFASInjection(level,mat)
                     Set the Mat to be used to apply the injection from level-1 to level.

                     Collective.

                     SEEALSO:getFASInjection, setFASInterpolation, setFASRestriction, SNESFASSetInjection, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:486Parameters

                            • level (int)

                            • mat (Mat)

                     ReturntypeNonesetFASInterpolation(level,mat)
                     Set the Mat to be used to apply the interpolation from level-1 to level.

                     Collective.

                     SEEALSO:getFASInterpolation,  setFASRestriction,  setFASInjection,  SNESFASSetInterpolation,   ‐
                        SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:426Parameters

                            • level (int)

                            • mat (Mat)

                     ReturntypeNonesetFASLevels(levels,comms=None)
                     Set the number of levels to use with FAS.

                     Collective.

                     Parameters

                            • levels (int) -- The number of levels

                            • comms  (Sequence[Comm]) -- An optional sequence of communicators of length LoggingLevels, or None for the default communicator Sys.getDefaultComm.

                     ReturntypeNoneSEEALSO:getFASLevels, SNESFASSetLevels, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:529setFASRScale(level,vec)
                     Set the scaling factor of the restriction operator from level to level-1.

                     Collective.

                     SEEALSO:setFASRestriction, SNESFASSetRScale, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:516Parameters

                            • level (int)

                            • vec (Vec)

                     ReturntypeNonesetFASRestriction(level,mat)
                     Set the Mat to be used to apply the restriction from level-1 to level.

                     Collective.

                     SEEALSO:setFASRScale,     getFASRestriction,     setFASInterpolation,     setFASInjection,     ‐
                        SNESFASSetRestriction, SNESFASSourcecodeatpetsc4py/PETSc/SNES.pyx:456Parameters

                            • level (int)

                            • mat (Mat)

                     ReturntypeNonesetForceIteration(force)
                     Force solve to take at least one iteration.

                     Collective.

                     SEEALSO:SNESSetForceIterationSourcecodeatpetsc4py/PETSc/SNES.pyx:1809Parametersforce (bool)

                     ReturntypeNonesetFromOptions()
                     Configure the solver from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, SNESSetFromOptionsSourcecodeatpetsc4py/PETSc/SNES.pyx:241ReturntypeNonesetFunction(function,f=None,args=None,kargs=None)
                     Set the callback to compute the nonlinear function.

                     Logically collective.

                     Parameters

                            • function (SNESFunction|None) -- The callback.

                            • f (Vec|None) -- An optional vector to store the result.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getFunction, SNESSetFunctionSourcecodeatpetsc4py/PETSc/SNES.pyx:808setFunctionNorm(norm)
                     Set the function norm value.

                     Collective.

                     This is only of use to implementers of custom SNES types.

                     SEEALSO:getFunctionNorm, SNESSetFunctionNormSourcecodeatpetsc4py/PETSc/SNES.pyx:1822Parametersnorm (float)

                     ReturntypeNonesetInitialGuess(initialguess,args=None,kargs=None)
                     Set the callback to compute the initial guess.

                     Logically collective.

                     Parameters

                            • initialguess (SNESGuessFunction|None) -- The callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getInitialGuess, SNESSetComputeInitialGuessSourcecodeatpetsc4py/PETSc/SNES.pyx:765setIterationNumber(its)
                     Set the current iteration number.

                     Collective.

                     This is only of use to implementers of custom SNES types.

                     SEEALSO:getIterationNumber, SNESSetIterationNumberSourcecodeatpetsc4py/PETSc/SNES.pyx:1780Parametersits (int)

                     ReturntypeNonesetJacobian(jacobian,J=None,P=None,args=None,kargs=None)
                     Set the callback to compute the Jacobian.

                     Logically collective.

                     Parameters

                            • jacobian (SNESJacobianFunction|None) -- The Jacobian callback.

                            • J (Mat|None) -- The matrix to store the Jacobian.

                            • P (Mat|None) -- The matrix to construct the preconditioner.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getJacobian, SNESSetJacobianSourcecodeatpetsc4py/PETSc/SNES.pyx:916setKSP(ksp)
                     Set the linear solver that will be used by the nonlinear solver.

                     Logically collective.

                     SEEALSO:getKSP, SNESSetKSPSourcecodeatpetsc4py/PETSc/SNES.pyx:1924Parametersksp (KSP)

                     ReturntypeNonesetLineSearchPreCheck(precheck,args=None,kargs=None)
                     Set the callback that will be called before applying the linesearch.

                     Logically collective.

                     Parameters

                            • precheck (SNESLSPreFunction|None) -- The callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:SNESLineSearchSetPreCheckSourcecodeatpetsc4py/PETSc/SNES.pyx:731setMaxFunctionEvaluations(max_funcs)
                     Set the maximum allowed number of function evaluations.

                     Collective.

                     SEEALSO:getMaxFunctionEvaluations, SNESSetTolerancesSourcecodeatpetsc4py/PETSc/SNES.pyx:1529Parametersmax_funcs (int)

                     ReturntypeNonesetMaxKSPFailures(max_fails)
                     Set the maximum allowed number of linear solve failures.

                     Collective.

                     SEEALSO:getMaxKSPFailures, SNESSetMaxLinearSolveFailuresSourcecodeatpetsc4py/PETSc/SNES.pyx:1615Parametersmax_fails (int)

                     ReturntypeNonesetMaxStepFailures(max_fails)
                     Set the maximum allowed number of step failures.

                     Collective.

                     SEEALSO:getMaxStepFailures, SNESSetMaxNonlinearStepFailuresSourcecodeatpetsc4py/PETSc/SNES.pyx:1574Parametersmax_fails (int)

                     ReturntypeNonesetMonitor(monitor,args=None,kargs=None)
                     Set the callback used to monitor solver convergence.

                     Logically collective.

                     Parameters

                            • monitor (SNESMonitorFunction|None) -- The callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getMonitor, SNESMonitorSetSourcecodeatpetsc4py/PETSc/SNES.pyx:1446setNGS(ngs,args=None,kargs=None)
                     Set the callback to compute nonlinear Gauss-Seidel.

                     Logically collective.

                     Parameters

                            • ngs (SNESNGSFunction|None) -- The nonlinear Gauss-Seidel callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getNGS, computeNGS, SNESSetNGSSourcecodeatpetsc4py/PETSc/SNES.pyx:1088setNPC(snes)
                     Set the nonlinear preconditioner.

                     Logically collective.

                     SEEALSO:getNPC, hasNPC, setNPCSide, getNPCSide, SNESSetNPCSourcecodeatpetsc4py/PETSc/SNES.pyx:691Parameterssnes (SNES)

                     ReturntypeNonesetNPCSide(side)
                     Set the nonlinear preconditioning side.

                     Collective.

                     SEEALSO:setNPC, getNPC, hasNPC, getNPCSide, SNESSetNPCSideSourcecodeatpetsc4py/PETSc/SNES.pyx:703Parametersside (Side)

                     ReturntypeNonesetNormSchedule(normsched)
                     Set the norm schedule.

                     Collective.

                     SEEALSO:getNormSchedule, SNESSetNormScheduleSourcecodeatpetsc4py/PETSc/SNES.pyx:1253Parametersnormsched (NormSchedule)

                     ReturntypeNonesetObjective(objective,args=None,kargs=None)
                     Set the callback to compute the objective function.

                     Logically collective.

                     Parameters

                            • objective (SNESObjFunction|None) -- The Jacobian callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getObjective, SNESSetObjectiveSourcecodeatpetsc4py/PETSc/SNES.pyx:982setOptionsPrefix(prefix)
                     Set the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, SNESSetOptionsPrefixSourcecodeatpetsc4py/PETSc/SNES.pyx:199Parametersprefix (str|None)

                     ReturntypeNonesetParamsEW(version=None,rtol_0=None,rtol_max=None,gamma=None,alpha=None,alpha2=None,threshold=None)
                     Set the parameters for the Eisenstat and Walker trick.

                     Logically collective.

                     Parameters

                            • version (int) -- The version of the algorithm. Defaults to CURRENT.

                            • rtol_0 (float) -- The initial relative residual norm. Defaults to CURRENT.

                            • rtol_max (float) -- The maximum relative residual norm. Defaults to CURRENT.

                            • gamma (float) -- Parameter. Defaults to CURRENT.

                            • alpha (float) -- Parameter. Defaults to CURRENT.

                            • alpha2 (float) -- Parameter. Defaults to CURRENT.

                            • threshold (float) -- Parameter. Defaults to CURRENT.

                     ReturntypeNoneSEEALSO:setUseEW, getParamsEW, SNESKSPSetParametersEWSourcecodeatpetsc4py/PETSc/SNES.pyx:1988setPatchCellNumbering(sec)
                     Set cell patch numbering.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2328Parameterssec (Section)

                     ReturntypeNonesetPatchComputeFunction(function,args=None,kargs=None)
                     Set patch compute function.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2381ReturntypeNonesetPatchComputeOperator(operator,args=None,kargs=None)
                     Set patch compute operator.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2373ReturntypeNonesetPatchConstructType(typ,operator=None,args=None,kargs=None)
                     Set patch construct type.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2389ReturntypeNonesetPatchDiscretisationInfo(dms,bs,cellNodeMaps,subspaceOffsets,ghostBcNodes,globalBcNodes)
                     Set patch discretisation information.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2332ReturntypeNonesetPythonContext(context)
                     Set the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonnonlinearsolvertype(TODO), getPythonContextSourcecodeatpetsc4py/PETSc/SNES.pyx:2204Parameterscontext (Any)

                     ReturntypeNonesetPythonType(py_type)
                     Set the fully qualified Python name of the class to be used.

                     Collective.

                     SEEALSO:PETScPythonnonlinearsolvertype(TODO),  setPythonContext,  getPythonType,  ‐
                        SNESPythonSetTypeSourcecodeatpetsc4py/PETSc/SNES.pyx:2231Parameterspy_type (str)

                     ReturntypeNonesetResetCounters(reset=True)
                     Set the flag to reset the counters.

                     Collective.

                     SEEALSO:SNESSetCountersResetSourcecodeatpetsc4py/PETSc/SNES.pyx:1431Parametersreset (bool)

                     ReturntypeNonesetSolution(vec)
                     Set the vector used to store the solution.

                     Collective.

                     SEEALSO:getSolution, SNESSetSolutionSourcecodeatpetsc4py/PETSc/SNES.pyx:1895Parametersvec (Vec)

                     ReturntypeNonesetTRTolerances(delta_min=None,delta_max=None,delta_0=None)
                     Set the tolerance parameters used for the trust region.

                     Logically collective.

                     Parameters

                            • delta_min (float) -- The minimum allowed trust region size. Defaults to CURRENT.

                            • delta_max (float) -- The maximum allowed trust region size. Defaults to CURRENT.

                            • delta_0 (float) -- The initial trust region size. Defaults to CURRENT.

                     ReturntypeNoneSEEALSO:getTRTolerances, setTRUpdateParameters, SNESNewtonTRSetTolerancesSourcecodeatpetsc4py/PETSc/SNES.pyx:310setTRUpdateParameters(eta1=None,eta2=None,eta3=None,t1=None,t2=None)
                     Set the update parameters used for the trust region.

                     Logically collective.

                     Parameters

                            • eta1 (float) -- The step acceptance tolerance. Defaults to CURRENT.

                            • eta2 (float) -- The shrinking tolerance. Defaults to CURRENT.

                            • eta3 (float) -- The enlarging tolerance. Defaults to CURRENT.

                            • t1 (float) -- The shrinking factor. Defaults to CURRENT.

                            • t2 (float) -- The enlarging factor. Defaults to CURRENT.

                     ReturntypeNoneSEEALSO:setTRTolerances, getTRUpdateParameters, SNESNewtonTRSetUpdateParametersSourcecodeatpetsc4py/PETSc/SNES.pyx:361setTolerances(rtol=None,atol=None,stol=None,max_it=None)
                     Set the tolerance parameters used in the solver convergence tests.

                     Logically collective.

                     Parameters

                            • rtol (float) -- The relative norm of the residual, or DETERMINE to use  the  value
                              when the object's type was set. Defaults to CURRENT.

                            • atol  (float)  -- The absolute norm of the residual, or DETERMINE to use the value
                              when the object's type was set. Defaults to CURRENT.

                            • stol (float) -- The absolute norm of the step, or DETERMINE to use the value  when
                              the object's type was set. Defaults to CURRENT.

                            • max_it  (int) -- The maximum allowed number of iterations, or DETERMINE to use the
                              value when the object's type was set. Defaults to CURRENT. Use UNLIMITED  to  have
                              no maximum.

                     ReturntypeNoneSEEALSO:getTolerances, SNESSetTolerancesSourcecodeatpetsc4py/PETSc/SNES.pyx:1156setType(snes_type)
                     Set the type of the solver.

                     Logically collective.

                     Parameterssnes_type (Type|str) -- The type of the solver.

                     ReturntypeNoneSEEALSO:getType, SNESSetTypeSourcecodeatpetsc4py/PETSc/SNES.pyx:166setUp()
                     Set up the internal data structures for using the solver.

                     Collective.

                     SEEALSO:SNESSetUpSourcecodeatpetsc4py/PETSc/SNES.pyx:1665ReturntypeNonesetUpMatrices()
                     Ensures that matrices are available for Newton-like methods.

                     Collective.

                     This is only of use to implementers of custom SNES types.

                     SEEALSO:setUp, SNESSetUpMatricesSourcecodeatpetsc4py/PETSc/SNES.pyx:1677ReturntypeNonesetUpdate(update,args=None,kargs=None)
                     Set the callback to compute update at the beginning of each step.

                     Logically collective.

                     Parameters

                            • update (SNESUpdateFunction|None) -- The callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getUpdate, SNESSetUpdateSourcecodeatpetsc4py/PETSc/SNES.pyx:873setUseEW(flag=True,*targs,**kargs)
                     Tell the solver to use the Eisenstat-Walker trick.

                     Logically collective.

                     Parameters

                            • flag (bool) -- Whether or not to use the Eisenstat-Walker trick.

                            • *targs (Any) -- Positional arguments for setParamsEW.

                            • **kargs (Any) -- Keyword arguments for setParamsEW.

                     ReturntypeNoneSEEALSO:getUseEW, setParamsEW, SNESKSPSetUseEWSourcecodeatpetsc4py/PETSc/SNES.pyx:1951setUseFD(flag=True)
                     Set the boolean flag to use coloring finite-differencing for Jacobian assembly.

                     Logically collective.

                     SEEALSO:getUseFDSourcecodeatpetsc4py/PETSc/SNES.pyx:2121ReturntypeNonesetUseKSP(flag=True)
                     Set the boolean flag indicating to use a linear solver.

                     Logically collective.

                     SEEALSO:getUseKSPSourcecodeatpetsc4py/PETSc/SNES.pyx:2065ReturntypeNonesetUseMF(flag=True)
                     Set the boolean flag indicating to use matrix-free finite-differencing.

                     Logically collective.

                     SEEALSO:getUseMFSourcecodeatpetsc4py/PETSc/SNES.pyx:2094ReturntypeNonesetVariableBounds(xl,xu)
                     Set the vector for the variable bounds.

                     Collective.

                     SEEALSO:SNESVISetVariableBoundsSourcecodeatpetsc4py/PETSc/SNES.pyx:2150Parameters

                            • xl (Vec)

                            • xu (Vec)

                     ReturntypeNonesolve(b=None,x=None)
                     Solve the nonlinear equations.

                     Collective.

                     Parameters

                            • b (Vec|None) -- The affine right-hand side or None to use zero.

                            • x (Vec|None) -- The starting vector or None to use the vector stored internally.

                     ReturntypeNoneSEEALSO:setSolution, getSolution, SNESSolveSourcecodeatpetsc4py/PETSc/SNES.pyx:1703view(viewer=None)
                     View the solver.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:SNESViewSourcecodeatpetsc4py/PETSc/SNES.pyx:113

              Attributes Documentation

              appctx Application context.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2405atol   Absolute residual tolerance.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2486dmDM.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2415history
                     Convergence history.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2538is_converged
                     Boolean indicating if the solver has converged.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2558is_diverged
                     Boolean indicating if the solver has failed.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2563is_iterating
                     Boolean indicating if the solver has not converged yet.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2553its    Number of iterations.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2522ksp    Linear solver.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2452max_funcs
                     Maximum number of function evaluations.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2512max_it Maximum number of iterations.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2502norm   Function norm.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2530npc    Nonlinear preconditioner.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2425reason Converged reason.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2545rtol   Relative residual tolerance.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2478stol   Solution update tolerance.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2494use_ew Use the Eisenstat-Walker trick.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2468use_fd Boolean indicating if the solver uses coloring finite-differencing.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2578use_ksp
                     Boolean indicating if the solver uses a linear solver.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2460use_mf Boolean indicating if the solver uses matrix-free finite-differencing.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2570vec_rhs
                     Right-hand side vector.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2445vec_sol
                     Solution vector.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2435vec_upd
                     Update vector.

                     Sourcecodeatpetsc4py/PETSc/SNES.pyx:2440petsc4py.PETSc.Scatterclasspetsc4py.PETSc.Scatter
              Bases: Object

              Scatter object.

              The  object  used  to  perform  data  movement between vectors.  Scatter is described in the PETScmanual.

              SEEALSO:Vec, SF, VecScatter

              Enumerations
                                                  ┌──────┬───────────────┐
                                                  │ Mode │ Scatter mode. │
                                                  ├──────┼───────────────┤
                                                  │ Type │ Scatter type. │
                                                  └──────┴───────────────┘

   petsc4py.PETSc.Scatter.Modeclasspetsc4py.PETSc.Scatter.Mode
                     Bases: object

                     Scatter mode.

                     Most commonly used scatter modes are:

                     FORWARD
                            Scatter values in the forward direction.

                     REVERSE
                            Scatter values in the reverse direction.

                     SEEALSO:Scatter.create, Scatter.begin, Scatter.end, ScatterMode

                     Attributes Summary
                                 ┌───────────────────────┬───────────────────────────────────────┐
                                 │ FORWARD               │ Constant FORWARD of type int          │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ FORWARD_LOCAL         │ Constant FORWARD_LOCAL of type int    │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ REVERSE               │ Constant REVERSE of type int          │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ REVERSE_LOCAL         │ Constant REVERSE_LOCAL of type int    │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ SCATTER_FORWARD       │ Constant SCATTER_FORWARD of type int  │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ SCATTER_FORWARD_LOCAL │ Constant   SCATTER_FORWARD_LOCAL   of │
                                 │                       │ type int                              │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ SCATTER_REVERSE       │ Constant SCATTER_REVERSE of type int  │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ SCATTER_REVERSE_LOCAL │ Constant   SCATTER_REVERSE_LOCAL   of │
                                 │                       │ type int                              │
                                 └───────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     FORWARD:int=FORWARD
                            Constant FORWARD of type intFORWARD_LOCAL:int=FORWARD_LOCAL
                            Constant FORWARD_LOCAL of type intREVERSE:int=REVERSE
                            Constant REVERSE of type intREVERSE_LOCAL:int=REVERSE_LOCAL
                            Constant REVERSE_LOCAL of type intSCATTER_FORWARD:int=SCATTER_FORWARD
                            Constant SCATTER_FORWARD of type intSCATTER_FORWARD_LOCAL:int=SCATTER_FORWARD_LOCAL
                            Constant SCATTER_FORWARD_LOCAL of type intSCATTER_REVERSE:int=SCATTER_REVERSE
                            Constant SCATTER_REVERSE of type intSCATTER_REVERSE_LOCAL:int=SCATTER_REVERSE_LOCAL
                            Constant SCATTER_REVERSE_LOCAL of type intpetsc4py.PETSc.Scatter.Typeclasspetsc4py.PETSc.Scatter.Type
                     Bases: object

                     Scatter type.

                     SEEALSO:VecScatterType

                     Attributes Summary
                                           ┌────────────┬───────────────────────────────┐
                                           │ ALLGATHER  │ Object ALLGATHER of type str  │
                                           ├────────────┼───────────────────────────────┤
                                           │ ALLGATHERV │ Object ALLGATHERV of type str │
                                           ├────────────┼───────────────────────────────┤
                                           │ ALLTOALL   │ Object ALLTOALL of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ BASIC      │ Object BASIC of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ GATHER     │ Object GATHER of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ GATHERV    │ Object GATHERV of type str    │
                                           ├────────────┼───────────────────────────────┤
                                           │ NEIGHBOR   │ Object NEIGHBOR of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ WINDOW     │ Object WINDOW of type str     │
                                           └────────────┴───────────────────────────────┘

                     Attributes Documentation

                     ALLGATHER:str=ALLGATHER
                            Object ALLGATHER of type strALLGATHERV:str=ALLGATHERV
                            Object ALLGATHERV of type strALLTOALL:str=ALLTOALL
                            Object ALLTOALL of type strBASIC:str=BASIC
                            Object BASIC of type strGATHER:str=GATHER
                            Object GATHER of type strGATHERV:str=GATHERV
                            Object GATHERV of type strNEIGHBOR:str=NEIGHBOR
                            Object NEIGHBOR of type strWINDOW:str=WINDOW
                            Object WINDOW of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ begin(vec_from, vec_to[, addv, mode]) │ Begin a generalized scatter from  one │
                      │                                       │ vector into another.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ copy()                                │ Return a copy of the scatter.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create(vec_from,   is_from,   vec_to, │ Create a scatter object.              │
                      │ is_to)                                │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the scatter.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ end(vec_from, vec_to[, addv, mode])   │ Complete a generalized  scatter  from │
                      │                                       │ one vector into another.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the type of the scatter.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ scatter(vec_from,    vec_to[,   addv, │ Perform a  generalized  scatter  from │
                      │ mode])                                │ one vector into another.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Configure   the   scatter   from  the │
                      │                                       │ options database.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(scatter_type)                 │ Set the type of the scatter.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Set up the internal  data  structures │
                      │                                       │ for using the scatter.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ toAll(vec)                            │ Create  a scatter that communicates a │
                      │                                       │ vector to all sharing processes.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ toZero(vec)                           │ Create a scatter that communicates  a │
                      │                                       │ vector to rank zero.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View the scatter.                     │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              begin(vec_from,vec_to,addv=None,mode=None)
                     Begin a generalized scatter from one vector into another.

                     Collective.

                     This  call  has  to  be  concluded  with  a  call  to  end.   For additional details on the
                     Parameters, see scatter.

                     SEEALSO:create, end, VecScatterBeginSourcecodeatpetsc4py/PETSc/Scatter.pyx:262Parameters

                            • vec_from (Vec)

                            • vec_to (Vec)

                            • addv (InsertModeSpec)

                            • mode (ScatterModeSpec)

                     ReturntypeNonecopy() Return a copy of the scatter.

                     Sourcecodeatpetsc4py/PETSc/Scatter.pyx:199ReturntypeScattercreate(vec_from,is_from,vec_to,is_to)
                     Create a scatter object.

                     Collective.

                     Parameters

                            • vec_from (Vec) -- Representative vector from which to scatter the data.

                            • is_from (IS) -- Indices of vec_from to scatter. If None, use all indices.

                            • vec_to (Vec) -- Representative vector to which scatter the data.

                            • is_to (IS) -- Indices of vec_to where to receive. If None, use all indices.

                     ReturntypeSelf

                     Examples

                     The scatter object can be used to repeatedly  perform  data  movement.   It  is  the  PETSc
                     equivalent of NumPy-like indexing and slicing, with support for parallel communications:

                     >>> revmode = PETSc.Scatter.Mode.REVERSE
                     >>> v1 = PETSc.Vec().createWithArray([1, 2, 3])
                     >>> v2 = PETSc.Vec().createWithArray([0, 0, 0])
                     >>> sct = PETSc.Scatter().create(v1,None,v2,None)
                     >>> sct.scatter(v1,v2) # v2[:] = v1[:]
                     >>> sct.scatter(v2,v1,mode=revmode) # v1[:] = v2[:]

                     >>> revmode = PETSc.Scatter.Mode.REVERSE
                     >>> v1 = PETSc.Vec().createWithArray([1, 2, 3, 4])
                     >>> v2 = PETSc.Vec().createWithArray([0, 0])
                     >>> is1 = PETSc.IS().createStride(2, 3, -2)
                     >>> sct = PETSc.Scatter().create(v1,is1,v2,None)
                     >>> sct.scatter(v1,v2) # v2[:] = v1[3:0:-2]
                     >>> sct.scatter(v2,v1,mode=revmode) # v1[3:0:-2] = v2[:]

                     SEEALSO:IS, VecScatterCreateSourcecodeatpetsc4py/PETSc/Scatter.pyx:90destroy()
                     Destroy the scatter.

                     Collective.

                     SEEALSO:VecScatterDestroySourcecodeatpetsc4py/PETSc/Scatter.pyx:77ReturntypeSelfend(vec_from,vec_to,addv=None,mode=None)
                     Complete a generalized scatter from one vector into another.

                     Collective.

                     This call has to be preceded by a call to begin.  For additional details on the Parameters,
                     see scatter.

                     SEEALSO:create, begin, VecScatterEndSourcecodeatpetsc4py/PETSc/Scatter.pyx:285Parameters

                            • vec_from (Vec)

                            • vec_to (Vec)

                            • addv (InsertModeSpec)

                            • mode (ScatterModeSpec)

                     ReturntypeNonegetType()
                     Return the type of the scatter.

                     Not collective.

                     SEEALSO:setType, VecScatterGetTypeSourcecodeatpetsc4py/PETSc/Scatter.pyx:160Returntypestrscatter(vec_from,vec_to,addv=None,mode=None)
                     Perform a generalized scatter from one vector into another.

                     Collective.

                     Parameters

                            • vec_from (Vec) -- The source vector.

                            • vec_to (Vec) -- The destination vector.

                            • addv (InsertModeSpec) -- Insertion mode.

                            • mode (ScatterModeSpec) -- Scatter mode.

                     ReturntypeNoneSEEALSO:create, begin, end, VecScatterBegin, VecScatterEndSourcecodeatpetsc4py/PETSc/Scatter.pyx:308setFromOptions()
                     Configure the scatter from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, VecScatterSetFromOptionsSourcecodeatpetsc4py/PETSc/Scatter.pyx:174ReturntypeNonesetType(scatter_type)
                     Set the type of the scatter.

                     Logically collective.

                     SEEALSO:getType, VecScatterSetTypeSourcecodeatpetsc4py/PETSc/Scatter.pyx:146Parametersscatter_type (Type|str)

                     ReturntypeNonesetUp()
                     Set up the internal data structures for using the scatter.

                     Collective.

                     SEEALSO:VecScatterSetUpSourcecodeatpetsc4py/PETSc/Scatter.pyx:186ReturntypeSelfclassmethodtoAll(vec)
                     Create a scatter that communicates a vector to all sharing processes.

                     Collective.

                     Parametersvec (Vec) -- The vector to scatter from.

                     Returntypetuple[Scatter, Vec]

                     Notes

                     The  created  scatter  will  have the same communicator of vec.  The method also returns an
                     output vector of appropriate size to contain the result of the operation.

                     SEEALSO:toZero, VecScatterCreateToAllSourcecodeatpetsc4py/PETSc/Scatter.pyx:205classmethodtoZero(vec)
                     Create a scatter that communicates a vector to rank zero.

                     Collective.

                     Parametersvec (Vec) -- The vector to scatter from.

                     Returntypetuple[Scatter, Vec]

                     Notes

                     The created scatter will have the same communicator of vec.  The  method  also  returns  an
                     output vector of appropriate size to contain the result of the operation.

                     SEEALSO:toAll, VecScatterCreateToZeroSourcecodeatpetsc4py/PETSc/Scatter.pyx:233view(viewer=None)
                     View the scatter.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:VecScatterViewSourcecodeatpetsc4py/PETSc/Scatter.pyx:58petsc4py.PETSc.ScatterModeclasspetsc4py.PETSc.ScatterMode
              Bases: object

              Scatter mode.

              Most commonly used scatter modes are:

              FORWARD
                     Scatter values in the forward direction.

              REVERSE
                     Scatter values in the reverse direction.

              SEEALSO:Scatter.create, Scatter.begin, Scatter.end, ScatterMode

              Attributes Summary
                              ┌───────────────────────┬───────────────────────────────────────┐
                              │ FORWARD               │ Constant FORWARD of type int          │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ FORWARD_LOCAL         │ Constant FORWARD_LOCAL of type int    │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ REVERSE               │ Constant REVERSE of type int          │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ REVERSE_LOCAL         │ Constant REVERSE_LOCAL of type int    │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ SCATTER_FORWARD       │ Constant SCATTER_FORWARD of type int  │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ SCATTER_FORWARD_LOCAL │ Constant   SCATTER_FORWARD_LOCAL   of │
                              │                       │ type int                              │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ SCATTER_REVERSE       │ Constant SCATTER_REVERSE of type int  │
                              ├───────────────────────┼───────────────────────────────────────┤
                              │ SCATTER_REVERSE_LOCAL │ Constant   SCATTER_REVERSE_LOCAL   of │
                              │                       │ type int                              │
                              └───────────────────────┴───────────────────────────────────────┘

              Attributes Documentation

              FORWARD:int=FORWARD
                     Constant FORWARD of type intFORWARD_LOCAL:int=FORWARD_LOCAL
                     Constant FORWARD_LOCAL of type intREVERSE:int=REVERSE
                     Constant REVERSE of type intREVERSE_LOCAL:int=REVERSE_LOCAL
                     Constant REVERSE_LOCAL of type intSCATTER_FORWARD:int=SCATTER_FORWARD
                     Constant SCATTER_FORWARD of type intSCATTER_FORWARD_LOCAL:int=SCATTER_FORWARD_LOCAL
                     Constant SCATTER_FORWARD_LOCAL of type intSCATTER_REVERSE:int=SCATTER_REVERSE
                     Constant SCATTER_REVERSE of type intSCATTER_REVERSE_LOCAL:int=SCATTER_REVERSE_LOCAL
                     Constant SCATTER_REVERSE_LOCAL of type intpetsc4py.PETSc.Sectionclasspetsc4py.PETSc.Section
              Bases: Object

              Mapping from integers in a range to unstructured set of integers.

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ addConstraintDof(point, numDof)       │ Increment  the  number of constrained │
                      │                                       │ DOFs for a given point.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ addDof(point, numDof)                 │ Add   numDof   degrees   of   freedom │
                      │                                       │ associated with a given point.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ addFieldConstraintDof(point,   field, │ Add numDof  constrained  DOFs  for  a │
                      │ numDof)                               │ given field on a point.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ addFieldDof(point, field, numDof)     │ Add  numDof  DOFs  associated  with a │
                      │                                       │ field on a given point.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clone()                               │ Return a copy of the section.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Allocate a section and  set  the  map │
                      │                                       │ contents to the default.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createGlobalSection(sf)               │ Create   a   section  describing  the │
                      │                                       │ global field layout.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy a section.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getChart()                            │ Return  the  range  in  which  points │
                      │                                       │ (indices) lie for this section.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConstrainedStorageSize()           │ Return  the  size  capable of holding │
                      │                                       │ all unconstrained DOFs in a section.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConstraintDof(point)               │ Return the number of constrained DOFs │
                      │                                       │ associated with a given point.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConstraintIndices(point)           │ Return the point DOFs  numbers  which │
                      │                                       │ are constrained for a given point.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDof(point)                         │ Return   the  number  of  degrees  of │
                      │                                       │ freedom for a given point.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFieldComponents(field)             │ Return the number of field components │
                      │                                       │ for the given field.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFieldConstraintDof(point, field)   │ Return the number of constrained DOFs │
                      │                                       │ for a given field on a point.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFieldConstraintIndices(point,      │ Return the field DOFs numbers, in [0, │
                      │ field)                                │ DOFs), which are constrained.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFieldDof(point, field)             │ Return the number of DOFs  associated │
                      │                                       │ with a field on a given point.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFieldName(field)                   │ Return  the  name  of  a field in the │
                      │                                       │ section.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFieldOffset(point, field)          │ Return the offset for the field  DOFs │
                      │                                       │ on the given point.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMaxDof()                           │ Return the maximum number of DOFs for │
                      │                                       │ any point in the section.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumFields()                        │ Return  the  number  of  fields  in a │
                      │                                       │ section.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOffset(point)                      │ Return  the  offset  for   the   DOFs │
                      │                                       │ associated with the given point.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOffsetRange()                      │ Return  the  full  range  of offsets, │
                      │                                       │ [start, end), for a section.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPermutation()                      │ Return the permutation that  was  set │
                      │                                       │ with setPermutation.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStorageSize()                      │ Return  the  size  capable of holding │
                      │                                       │ all the DOFs defined in a section.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reset()                               │ Free all section data.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setChart(pStart, pEnd)                │ Set  the  range   in   which   points │
                      │                                       │ (indices) lie for this section.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConstraintDof(point, numDof)       │ Set  the  number  of constrained DOFs │
                      │                                       │ associated with a given point.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConstraintIndices(point, indices)  │ Set the point DOFs  numbers,  in  [0, │
                      │                                       │ DOFs), which are constrained.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDof(point, numDof)                 │ Set  the number of degrees of freedom │
                      │                                       │ associated with a given point.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFieldComponents(field, numComp)    │ Set the number  of  field  components │
                      │                                       │ for the given field.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFieldConstraintDof(point,   field, │ Set the number  of  constrained  DOFs │
                      │ numDof)                               │ for a given field on a point.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFieldConstraintIndices(point,      │ Set  the  field  DOFs numbers, in [0, │
                      │ field, indices)                       │ DOFs), which are constrained.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFieldDof(point, field, numDof)     │ Set the  number  of  DOFs  associated │
                      │                                       │ with a field on a given point.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFieldName(field, fieldName)        │ Set  the  name  of  a  field  in  the │
                      │                                       │ section.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFieldOffset(point, field, offset)  │ Set the offset for the  DOFs  on  the │
                      │                                       │ given field at a point.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNumFields(numFields)               │ Set   the   number  of  fields  in  a │
                      │                                       │ section.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOffset(point, offset)              │ Set   the   offset   for   the   DOFs │
                      │                                       │ associated with the given point.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPermutation(perm)                  │ Set  the  permutation  for [0, pEnd - │
                      │                                       │ pStart).                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Calculate offsets.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View the section.                     │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              addConstraintDof(point,numDof)
                     Increment the number of constrained DOFs for a given point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • numDof (int) -- The number of additional DOFs which are fixed by constraints.

                     ReturntypeNoneSEEALSO:setConstraintDof, getConstraintDof, PetscSectionAddConstraintDofSourcecodeatpetsc4py/PETSc/Section.pyx:485addDof(point,numDof)
                     Add numDof degrees of freedom associated with a given point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • numDof (int) -- The number of additional DOFs.

                     ReturntypeNoneSEEALSO:setDof, getDof, PetscSectionAddDofSourcecodeatpetsc4py/PETSc/Section.pyx:354addFieldConstraintDof(point,field,numDof)
                     Add numDof constrained DOFs for a given field on a point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field.

                            • numDof (int) -- The number of additional DOFs which are fixed by constraints.

                     ReturntypeNoneSEEALSO:setFieldConstraintDof, getFieldConstraintDof, PetscSectionAddFieldConstraintDofSourcecodeatpetsc4py/PETSc/Section.pyx:557addFieldDof(point,field,numDof)
                     Add numDof DOFs associated with a field on a given point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field.

                            • numDof (int) -- The number of additional DOFs.

                     ReturntypeNoneSEEALSO:setFieldDof, getFieldDof, PetscSectionAddFieldDofSourcecodeatpetsc4py/PETSc/Section.pyx:421clone()
                     Return a copy of the section.

                     Collective.

                     The copy is shallow, if possible.

                     SEEALSO:PetscSectionCloneSourcecodeatpetsc4py/PETSc/Section.pyx:80ReturntypeSectioncreate(comm=None)
                     Allocate a section and set the map contents to the default.

                     Collective.

                     Typical calling sequence: - create - setNumFields - setChart - setDof - setUp - getOffset -
                     destroy

                     The Section object and  methods  are  intended  to  be  used  in  the  PETSc  Vec  and  Mat
                     implementations. The indices returned by the Section are appropriate for the kind of Vec it
                     is associated with. For example, if the vector being indexed is a local vector, we call the
                     section  a  local  section.  If  the  section  indexes a global vector, we call it a global
                     section. For parallel vectors, like global vectors, we use  negative  indices  to  indicate
                     DOFs owned by other processes.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PetscSectionCreateSourcecodeatpetsc4py/PETSc/Section.pyx:42createGlobalSection(sf)
                     Create a section describing the global field layout.

                     Collective.

                     The  section describes the global field layout using the local section and an SF describing
                     the section point overlap.

                     If we have a set of local sections defining the layout of a set of local vectors, and  also
                     an  SF  to  determine which section points are shared and the ownership, we can calculate a
                     global section defining the parallel data layout, and the associated global vector.

                     This gives negative sizes and offsets to points not owned by this process.

                     includeConstraints and localOffsets parameters of the C API are always set to False.

                     Parameterssf (SF) -- The SF describing the parallel layout of the section points  (leaves  are
                            unowned local points).

                     ReturntypeSectionSEEALSO:PetscSectionCreateGlobalSectionSourcecodeatpetsc4py/PETSc/Section.pyx:846destroy()
                     Destroy a section.

                     Not collective.

                     SEEALSO:PetscSectionDestroySourcecodeatpetsc4py/PETSc/Section.pyx:29ReturntypeSelfgetChart()
                     Return the range in which points (indices) lie for this section.

                     Not collective.

                     The range is [pStart, pEnd), i.e., from the first point to one past the last point.

                     SEEALSO:PetscSectionGetChartSourcecodeatpetsc4py/PETSc/Section.pyx:238Returntypetuple[int, int]

              getConstrainedStorageSize()
                     Return the size capable of holding all unconstrained DOFs in a section.

                     Not collective.

                     SEEALSO:getStorageSize, PetscSectionGetConstrainedStorageSizeSourcecodeatpetsc4py/PETSc/Section.pyx:720ReturntypeintgetConstraintDof(point)
                     Return the number of constrained DOFs associated with a given point.

                     Not collective.

                     Parameterspoint (int) -- The point.

                     ReturntypeintSEEALSO:setConstraintDof, PetscSectionGetConstraintDofSourcecodeatpetsc4py/PETSc/Section.pyx:445getConstraintIndices(point)
                     Return the point DOFs numbers which are constrained for a given point.

                     Not collective.

                     The range is in [0, DOFs).

                     Parameterspoint (int) -- The point.

                     ReturntypeArrayIntSEEALSO:setConstraintIndices, PetscSectionGetConstraintIndicesSourcecodeatpetsc4py/PETSc/Section.pyx:586getDof(point)
                     Return the number of degrees of freedom for a given point.

                     Not collective.

                     In a global section, this value will be negative for points not owned by this process.

                     Parameterspoint (int) -- The point.

                     ReturntypeintSEEALSO:setDof, addDof, PetscSectionGetDofSourcecodeatpetsc4py/PETSc/Section.pyx:311getFieldComponents(field)
                     Return the number of field components for the given field.

                     Not collective.

                     Parametersfield (int) -- The field number.

                     ReturntypeintSEEALSO:setFieldComponents, PetscSectionGetFieldComponentsSourcecodeatpetsc4py/PETSc/Section.pyx:198getFieldConstraintDof(point,field)
                     Return the number of constrained DOFs for a given field on a point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field.

                     ReturntypeintSEEALSO:setFieldConstraintDof, PetscSectionGetFieldConstraintDofSourcecodeatpetsc4py/PETSc/Section.pyx:506getFieldConstraintIndices(point,field)
                     Return the field DOFs numbers, in [0, DOFs), which are constrained.

                     Not collective.

                     The constrained DOFs are sorted in ascending order.

                     Parameters

                            • field (int) -- The field number.

                            • point (int) -- The point.

                     ReturntypeArrayIntSEEALSO:setFieldConstraintIndices, PetscSectionGetFieldConstraintIndicesSourcecodeatpetsc4py/PETSc/Section.pyx:634getFieldDof(point,field)
                     Return the number of DOFs associated with a field on a given point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field.

                     ReturntypeintSEEALSO:setFieldDof, PetscSectionGetFieldDofSourcecodeatpetsc4py/PETSc/Section.pyx:375getFieldName(field)
                     Return the name of a field in the section.

                     Not collective.

                     Parametersfield (int) -- The field number.

                     ReturntypestrSEEALSO:setFieldName, PetscSectionGetFieldNameSourcecodeatpetsc4py/PETSc/Section.pyx:156getFieldOffset(point,field)
                     Return the offset for the field DOFs on the given point.

                     Not collective.

                     In a global section, this offset will be negative for points not owned by this process.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field.

                     ReturntypeintSEEALSO:setFieldOffset, PetscSectionGetFieldOffsetSourcecodeatpetsc4py/PETSc/Section.pyx:779getMaxDof()
                     Return the maximum number of DOFs for any point in the section.

                     Not collective.

                     SEEALSO:PetscSectionGetMaxDofSourcecodeatpetsc4py/PETSc/Section.pyx:692ReturntypeintgetNumFields()
                     Return the number of fields in a section.

                     Not collective.

                     Returns 0 if no fields were defined.

                     SEEALSO:setNumFields, PetscSectionGetNumFieldsSourcecodeatpetsc4py/PETSc/Section.pyx:122ReturntypeintgetOffset(point)
                     Return the offset for the DOFs associated with the given point.

                     Not collective.

                     In a global section, this offset will be negative for points not owned by this process.

                     Parameterspoint (int) -- The point.

                     ReturntypeintSEEALSO:setOffset, PetscSectionGetOffsetSourcecodeatpetsc4py/PETSc/Section.pyx:734getOffsetRange()
                     Return the full range of offsets, [start, end), for a section.

                     Not collective.

                     SEEALSO:PetscSectionGetOffsetRangeSourcecodeatpetsc4py/PETSc/Section.pyx:831Returntypetuple[int, int]

              getPermutation()
                     Return the permutation that was set with setPermutation.

                     Not collective.

                     SEEALSO:setPermutation, PetscSectionGetPermutationSourcecodeatpetsc4py/PETSc/Section.pyx:279ReturntypeISgetStorageSize()
                     Return the size capable of holding all the DOFs defined in a section.

                     Not collective.

                     SEEALSO:getConstrainedStorageSize, PetscSectionGetStorageSizeSourcecodeatpetsc4py/PETSc/Section.pyx:706Returntypeintreset()
                     Free all section data.

                     Not collective.

                     SEEALSO:PetscSectionResetSourcecodeatpetsc4py/PETSc/Section.pyx:110ReturntypeNonesetChart(pStart,pEnd)
                     Set the range in which points (indices) lie for this section.

                     Not collective.

                     The range is [pStart, pEnd), i.e., from the first point to one past the last point.

                     Parameters

                            • pStart (int) -- The first point.

                            • pEnd (int) -- One past the last point.

                     ReturntypeNoneSEEALSO:PetscSectionSetChartSourcecodeatpetsc4py/PETSc/Section.pyx:255setConstraintDof(point,numDof)
                     Set the number of constrained DOFs associated with a given point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • numDof (int) -- The number of DOFs which are fixed by constraints.

                     ReturntypeNoneSEEALSO:getConstraintDof, addConstraintDof, PetscSectionSetConstraintDofSourcecodeatpetsc4py/PETSc/Section.pyx:464setConstraintIndices(point,indices)
                     Set the point DOFs numbers, in [0, DOFs), which are constrained.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • indices (Sequence[int]) -- The constrained DOFs.

                     ReturntypeNoneSEEALSO:getConstraintIndices, PetscSectionSetConstraintIndicesSourcecodeatpetsc4py/PETSc/Section.pyx:610setDof(point,numDof)
                     Set the number of degrees of freedom associated with a given point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • numDof (int) -- The number of DOFs.

                     ReturntypeNoneSEEALSO:getDof, addDof, PetscSectionSetDofSourcecodeatpetsc4py/PETSc/Section.pyx:333setFieldComponents(field,numComp)
                     Set the number of field components for the given field.

                     Not collective.

                     Parameters

                            • field (int) -- The field number.

                            • numComp (int) -- The number of field components.

                     ReturntypeNoneSEEALSO:getFieldComponents, PetscSectionSetFieldComponentsSourcecodeatpetsc4py/PETSc/Section.pyx:217setFieldConstraintDof(point,field,numDof)
                     Set the number of constrained DOFs for a given field on a point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field.

                            • numDof (int) -- The number of DOFs which are fixed by constraints.

                     ReturntypeNoneSEEALSO:getFieldConstraintDof, addFieldConstraintDof, PetscSectionSetFieldConstraintDofSourcecodeatpetsc4py/PETSc/Section.pyx:528setFieldConstraintIndices(point,field,indices)
                     Set the field DOFs numbers, in [0, DOFs), which are constrained.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field number.

                            • indices (Sequence[int]) -- The constrained DOFs.

                     ReturntypeNoneSEEALSO:getFieldConstraintIndices, PetscSectionSetFieldConstraintIndicesSourcecodeatpetsc4py/PETSc/Section.pyx:661setFieldDof(point,field,numDof)
                     Set the number of DOFs associated with a field on a given point.

                     Not collective.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field.

                            • numDof (int) -- The number of DOFs.

                     ReturntypeNoneSEEALSO:getFieldDof, addFieldDof, PetscSectionSetFieldDofSourcecodeatpetsc4py/PETSc/Section.pyx:397setFieldName(field,fieldName)
                     Set the name of a field in the section.

                     Not collective.

                     Parameters

                            • field (int) -- The field number.

                            • fieldName (str) -- The field name.

                     ReturntypeNoneSEEALSO:getFieldName, PetscSectionSetFieldNameSourcecodeatpetsc4py/PETSc/Section.pyx:176setFieldOffset(point,field,offset)
                     Set the offset for the DOFs on the given field at a point.

                     Not collective.

                     The user usually does not call this function, but uses setUp.

                     Parameters

                            • point (int) -- The point.

                            • field (int) -- The field.

                            • offset (int) -- The offset.

                     ReturntypeNoneSEEALSO:getFieldOffset, PetscSectionSetFieldOffsetSourcecodeatpetsc4py/PETSc/Section.pyx:805setNumFields(numFields)
                     Set the number of fields in a section.

                     Not collective.

                     ParametersnumFields (int) -- The number of fields.

                     ReturntypeNoneSEEALSO:getNumFields, PetscSectionSetNumFieldsSourcecodeatpetsc4py/PETSc/Section.pyx:138setOffset(point,offset)
                     Set the offset for the DOFs associated with the given point.

                     Not collective.

                     The user usually does not call this function, but uses setUp.

                     Parameters

                            • point (int) -- The point.

                            • offset (int) -- The offset.

                     ReturntypeNoneSEEALSO:getOffset, PetscSectionSetOffsetSourcecodeatpetsc4py/PETSc/Section.pyx:756setPermutation(perm)
                     Set the permutation for [0, pEnd - pStart).

                     Not collective.

                     Parametersperm (IS) -- The permutation of points.

                     ReturntypeNoneSEEALSO:getPermutation, PetscSectionSetPermutationSourcecodeatpetsc4py/PETSc/Section.pyx:294setUp()
                     Calculate offsets.

                     Not collective.

                     Offsets are based on the number of degrees of freedom for each point.

                     SEEALSO:PetscSectionSetUpSourcecodeatpetsc4py/PETSc/Section.pyx:96ReturntypeNoneview(viewer=None)
                     View the section.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the section.

                     ReturntypeNoneSEEALSO:PetscSectionViewSourcecodeatpetsc4py/PETSc/Section.pyx:10petsc4py.PETSc.Spaceclasspetsc4py.PETSc.Space
              Bases: Object

              Function space object.

              Enumerations
                                            ┌──────┬───────────────────────────┐
                                            │ Type │ The function space types. │
                                            └──────┴───────────────────────────┘

   petsc4py.PETSc.Space.Typeclasspetsc4py.PETSc.Space.Type
                     Bases: object

                     The function space types.

                     Attributes Summary
                                           ┌────────────┬───────────────────────────────┐
                                           │ POINT      │ Object POINT of type str      │
                                           ├────────────┼───────────────────────────────┤
                                           │ POLYNOMIAL │ Object POLYNOMIAL of type str │
                                           ├────────────┼───────────────────────────────┤
                                           │ PTRIMMED   │ Object PTRIMMED of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ SUBSPACE   │ Object SUBSPACE of type str   │
                                           ├────────────┼───────────────────────────────┤
                                           │ SUM        │ Object SUM of type str        │
                                           ├────────────┼───────────────────────────────┤
                                           │ TENSOR     │ Object TENSOR of type str     │
                                           ├────────────┼───────────────────────────────┤
                                           │ WXY        │ Object WXY of type str        │
                                           └────────────┴───────────────────────────────┘

                     Attributes Documentation

                     POINT:str=POINT
                            Object POINT of type strPOLYNOMIAL:str=POLYNOMIAL
                            Object POLYNOMIAL of type strPTRIMMED:str=PTRIMMED
                            Object PTRIMMED of type strSUBSPACE:str=SUBSPACE
                            Object SUBSPACE of type strSUM:str=SUM
                            Object SUM of type strTENSOR:str=TENSOR
                            Object TENSOR of type strWXY:str=WXY
                            Object WXY of type str

              Methods Summary
                      ┌──────────────────────────────────────┬───────────────────────────────────────┐
                      │ create([comm])                       │ Create an empty Space object.         │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                            │ Destroy the Space object.             │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDegree()                          │ Return  the  polynomial  degrees that │
                      │                                      │ characterize this space.              │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDimension()                       │ Return the number of basis vectors.   │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumComponents()                   │ Return the number of  components  for │
                      │                                      │ this space.                           │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumVariables()                    │ Return  the  number  of variables for │
                      │                                      │ this space.                           │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPTrimmedFormDegree()              │ Return the form degree of the trimmed │
                      │                                      │ polynomials.                          │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPointPoints()                     │ Return the evaluation points for  the │
                      │                                      │ space as the points of a quad.        │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPolynomialTensor()                │ Return  whether a function space is a │
                      │                                      │ space of tensor polynomials.          │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSumConcatenate()                  │ Return the concatenate flag for  this │
                      │                                      │ space.                                │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSumNumSubspaces()                 │ Return  the  number  of spaces in the │
                      │                                      │ sum.                                  │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSumSubspace(s)                    │ Return a space in the sum.            │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTensorNumSubspaces()              │ Return the number of  spaces  in  the │
                      │                                      │ tensor product.                       │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTensorSubspace(s)                 │ Return a space in the tensor product. │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                            │ Return the type of the space object.  │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDegree(degree, maxDegree)         │ Set  the  degree of approximation for │
                      │                                      │ this space.                           │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                     │ Set  parameters  in  Space  from  the │
                      │                                      │ options database.                     │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNumComponents(nc)                 │ Set the number of components for this │
                      │                                      │ space.                                │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNumVariables(n)                   │ Set  the number of variables for this │
                      │                                      │ space.                                │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPTrimmedFormDegree(formDegree)    │ Set the form degree  of  the  trimmed │
                      │                                      │ polynomials.                          │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPointPoints(quad)                 │ Set  the  evaluation  points  for the │
                      │                                      │ space to be based on a quad.          │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPolynomialTensor(tensor)          │ Set whether a  function  space  is  a │
                      │                                      │ space of tensor polynomials.          │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSumConcatenate(concatenate)       │ Set  the  concatenate  flag  for this │
                      │                                      │ space.                                │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSumNumSubspaces(numSumSpaces)     │ Set the number of spaces in the sum.  │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSumSubspace(s, subsp)             │ Set a space in the sum.               │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTensorNumSubspaces(numTensSpaces) │ Set  the  number  of  spaces  in  the │
                      │                                      │ tensor product.                       │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTensorSubspace(s, subsp)          │ Set a space in the tensor product.    │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(space_type)                  │ Build a particular type of space.     │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                              │ Construct  data  structures  for  the │
                      │                                      │ Space.                                │
                      ├──────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                       │ View a Space.                         │
                      └──────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(comm=None)
                     Create an empty Space object.

                     Collective.

                     The type can then be set with setType.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PetscSpaceCreateSourcecodeatpetsc4py/PETSc/Space.pyx:36destroy()
                     Destroy the Space object.

                     Collective.

                     SEEALSO:PetscSpaceDestroySourcecodeatpetsc4py/PETSc/Space.pyx:59ReturntypeSelfgetDegree()
                     Return the polynomial degrees that characterize this space.

                     Not collective.

                     Returns

                            • minDegree (int) -- The degree of the largest polynomial  space  contained  in  the
                              space.

                            • maxDegree  (int)  --  The  degree  of the smallest polynomial space containing the
                              space.

                     Returntypetuple[int, int]

                     SEEALSO:setDegree, PetscSpaceGetDegreeSourcecodeatpetsc4py/PETSc/Space.pyx:117getDimension()
                     Return the number of basis vectors.

                     Not collective.

                     SEEALSO:PetscSpaceGetDimensionSourcecodeatpetsc4py/PETSc/Space.pyx:103ReturntypeintgetNumComponents()
                     Return the number of components for this space.

                     Not collective.

                     SEEALSO:setNumComponents, PetscSpaceGetNumComponentsSourcecodeatpetsc4py/PETSc/Space.pyx:195ReturntypeintgetNumVariables()
                     Return the number of variables for this space.

                     Not collective.

                     SEEALSO:setNumVariables, PetscSpaceGetNumVariablesSourcecodeatpetsc4py/PETSc/Space.pyx:163ReturntypeintgetPTrimmedFormDegree()
                     Return the form degree of the trimmed polynomials.

                     Not collective.

                     SEEALSO:setPTrimmedFormDegree, PetscSpacePTrimmedGetFormDegreeSourcecodeatpetsc4py/PETSc/Space.pyx:546ReturntypeintgetPointPoints()
                     Return the evaluation points for the space as the points of a quad.

                     Logically collective.

                     SEEALSO:setPointPoints, PetscSpacePointGetPointsSourcecodeatpetsc4py/PETSc/Space.pyx:513ReturntypeQuadgetPolynomialTensor()
                     Return whether a function space is a space of tensor polynomials.

                     Not collective.

                     Return True if a function space is a space of tensor polynomials (the space is  spanned  by
                     polynomials  whose  degree  in  each variable is bounded by the given order), as opposed to
                     polynomials (the space is spanned  by  polynomials  whose  total  degree—summing  over  all
                     variables is bounded by the given order).

                     SEEALSO:setPolynomialTensor, PetscSpacePolynomialGetTensorSourcecodeatpetsc4py/PETSc/Space.pyx:448ReturntypeboolgetSumConcatenate()
                     Return the concatenate flag for this space.

                     Not collective.

                     A  concatenated sum space will have the number of components equal to the sum of the number
                     of components of all subspaces.  A non-concatenated, or direct sum space will have the same
                     number of components as its subspaces.

                     SEEALSO:setSumConcatenate, PetscSpaceSumGetConcatenateSourcecodeatpetsc4py/PETSc/Space.pyx:261ReturntypeboolgetSumNumSubspaces()
                     Return the number of spaces in the sum.

                     Not collective.

                     SEEALSO:setSumNumSubspaces, PetscSpaceSumGetNumSubspacesSourcecodeatpetsc4py/PETSc/Space.pyx:304ReturntypeintgetSumSubspace(s)
                     Return a space in the sum.

                     Not collective.

                     Parameterss (int) -- The space number.

                     ReturntypeSpaceSEEALSO:setSumSubspace, PetscSpaceSumGetSubspaceSourcecodeatpetsc4py/PETSc/Space.pyx:318getTensorNumSubspaces()
                     Return the number of spaces in the tensor product.

                     Not collective.

                     SEEALSO:setTensorNumSubspaces, PetscSpaceTensorGetNumSubspacesSourcecodeatpetsc4py/PETSc/Space.pyx:376ReturntypeintgetTensorSubspace(s)
                     Return a space in the tensor product.

                     Not collective.

                     Parameterss (int) -- The space number.

                     ReturntypeSpaceSEEALSO:setTensorSubspace, PetscSpaceTensorGetSubspaceSourcecodeatpetsc4py/PETSc/Space.pyx:410getType()
                     Return the type of the space object.

                     Not collective.

                     SEEALSO:setType, PetscSpaceGetTypeSourcecodeatpetsc4py/PETSc/Space.pyx:227ReturntypestrsetDegree(degree,maxDegree)
                     Set the degree of approximation for this space.

                     Logically collective.

                     One of degree and maxDegree can be None.

                     Parameters

                            • degree (int|None) -- The degree of the largest polynomial space contained in the
                              space.

                            • maxDegree (int|None) -- The degree of the largest  polynomial  space  containing
                              the space.

                     ReturntypeNoneSEEALSO:getDegree, PetscSpaceSetDegreeSourcecodeatpetsc4py/PETSc/Space.pyx:138setFromOptions()
                     Set parameters in Space from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, PetscSpaceSetFromOptionsSourcecodeatpetsc4py/PETSc/Space.pyx:91ReturntypeNonesetNumComponents(nc)
                     Set the number of components for this space.

                     Logically collective.

                     Parametersnc (int) -- The number of components.

                     ReturntypeNoneSEEALSO:getNumComponents, PetscSpaceSetNumComponentsSourcecodeatpetsc4py/PETSc/Space.pyx:209setNumVariables(n)
                     Set the number of variables for this space.

                     Logically collective.

                     Parametersn (int) -- The number of variables (x, y, z etc.).

                     ReturntypeNoneSEEALSO:getNumVariables, PetscSpaceSetNumVariablesSourcecodeatpetsc4py/PETSc/Space.pyx:177setPTrimmedFormDegree(formDegree)
                     Set the form degree of the trimmed polynomials.

                     Logically collective.

                     ParametersformDegree (int) -- The form degree.

                     ReturntypeNoneSEEALSO:getPTrimmedFormDegree, PetscSpacePTrimmedSetFormDegreeSourcecodeatpetsc4py/PETSc/Space.pyx:528setPointPoints(quad)
                     Set the evaluation points for the space to be based on a quad.

                     Logically collective.

                     Sets the evaluation points for the space to coincide with the points of a quadrature rule.

                     Parametersquad (Quad) -- The Quad defining the points.

                     ReturntypeNoneSEEALSO:getPointPoints, PetscSpacePointSetPointsSourcecodeatpetsc4py/PETSc/Space.pyx:493setPolynomialTensor(tensor)
                     Set whether a function space is a space of tensor polynomials.

                     Logically collective.

                     Set  to  True  for  a  function  space which is a space of tensor polynomials (the space is
                     spanned by polynomials whose degree in each variable is bounded by  the  given  order),  as
                     opposed to polynomials (the space is spanned by polynomials whose total degree—summing over
                     all variables is bounded by the given order).

                     Parameterstensor (bool) -- True for a tensor polynomial space, False for a polynomial space.

                     ReturntypeNoneSEEALSO:getPolynomialTensor, PetscSpacePolynomialSetTensorSourcecodeatpetsc4py/PETSc/Space.pyx:468setSumConcatenate(concatenate)
                     Set the concatenate flag for this space.

                     Logically collective.

                     A  concatenated sum space will have the number of components equal to the sum of the number
                     of components of all subspaces.  A non-concatenated, or direct sum space will have the same
                     number of components as its subspaces.

                     Parametersconcatenate (bool) -- True if subspaces are concatenated components, False if direct
                            summands.

                     ReturntypeNoneSEEALSO:getSumConcatenate, PetscSpaceSumSetConcatenateSourcecodeatpetsc4py/PETSc/Space.pyx:280setSumNumSubspaces(numSumSpaces)
                     Set the number of spaces in the sum.

                     Logically collective.

                     ParametersnumSumSpaces (int) -- The number of spaces.

                     ReturntypeNoneSEEALSO:getSumNumSubspaces, PetscSpaceSumSetNumSubspacesSourcecodeatpetsc4py/PETSc/Space.pyx:358setSumSubspace(s,subsp)
                     Set a space in the sum.

                     Logically collective.

                     Parameters

                            • s (int) -- The space number.

                            • subsp (Space) -- The number of spaces.

                     ReturntypeNoneSEEALSO:getSumSubspace, PetscSpaceSumSetSubspaceSourcecodeatpetsc4py/PETSc/Space.pyx:338setTensorNumSubspaces(numTensSpaces)
                     Set the number of spaces in the tensor product.

                     Logically collective.

                     ParametersnumTensSpaces (int) -- The number of spaces.

                     ReturntypeNoneSEEALSO:getTensorNumSubspaces, PetscSpaceTensorSetNumSubspacesSourcecodeatpetsc4py/PETSc/Space.pyx:430setTensorSubspace(s,subsp)
                     Set a space in the tensor product.

                     Logically collective.

                     Parameters

                            • s (int) -- The space number.

                            • subsp (Space) -- The number of spaces.

                     ReturntypeNoneSEEALSO:getTensorSubspace, PetscSpaceTensorSetSubspaceSourcecodeatpetsc4py/PETSc/Space.pyx:390setType(space_type)
                     Build a particular type of space.

                     Collective.

                     Parametersspace_type (Type|str) -- The kind of space.

                     Returntype
                            Self

                     SEEALSO:getType, PetscSpaceSetTypeSourcecodeatpetsc4py/PETSc/Space.pyx:241setUp()
                     Construct data structures for the Space.

                     Collective.

                     SEEALSO:PetscSpaceSetUpSourcecodeatpetsc4py/PETSc/Space.pyx:24ReturntypeNoneview(viewer=None)
                     View a Space.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer to display the Space.

                     ReturntypeNoneSEEALSO:PetscSpaceViewSourcecodeatpetsc4py/PETSc/Space.pyx:72petsc4py.PETSc.Sysclasspetsc4py.PETSc.Sys
              Bases: object

              System utilities.

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ Print(*args[, sep, end, comm])        │ Print output from the first processor │
                      │                                       │ of a communicator.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDefaultComm()                      │ Get the default MPI communicator used │
                      │                                       │ to create PETSc objects.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getVersion([devel, date, author])     │ Return PETSc version information.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getVersionInfo()                      │ Return PETSc version information.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ hasExternalPackage(package)           │ Return whether PETSc has support  for │
                      │                                       │ external package.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ infoAllow(flag[, filename, mode])     │ Enables   or   disables   PETSc  info │
                      │                                       │ messages.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isFinalized()                         │ Return   whether   PETSc   has   been │
                      │                                       │ finalized.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isInitialized()                       │ Return   whether   PETSc   has   been │
                      │                                       │ initialized.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ popErrorHandler()                     │ Remove the current error handler.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ popSignalHandler()                    │ Remove the current signal handler.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pushErrorHandler(errhandler)          │ Set the current error handler.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ registerCitation(citation)            │ Register BibTeX citation.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDefaultComm(comm)                  │ Set the default MPI communicator used │
                      │                                       │ to create PETSc objects.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ sleep([seconds])                      │ Sleep some number of seconds.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ splitOwnership(size[, bsize, comm])   │ Given  a  global  (or   local)   size │
                      │                                       │ determines a local (or global) size.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ syncFlush([comm])                     │ Flush  output from previous syncPrint │
                      │                                       │ calls.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ syncPrint(*args[,  sep,  end,  flush, │ Print    synchronized   output   from │
                      │ comm])                                │ several processors of a communicator. │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              classmethodPrint(*args,sep='',end='\n',comm=None,**kwargs)
                     Print output from the first processor of a communicator.

                     Collective.

                     Parameters

                            • *args (Any) -- Positional arguments.

                            • sep (str) -- String inserted between values, by default a space.

                            • end (str) -- String appended after the last value, by default a newline.

                            • comm (Comm|None) -- MPI communicator, defaults to getDefaultComm.

                            • **kwargs (Any) -- Keyword arguments.

                     ReturntypeNoneSEEALSO:PetscPrintfSourcecodeatpetsc4py/PETSc/Sys.pyx:155classmethodgetDefaultComm()
                     Get the default MPI communicator used to create PETSc objects.

                     Not collective.

                     SEEALSO:setDefaultCommSourcecodeatpetsc4py/PETSc/Sys.pyx:116ReturntypeCommclassmethodgetVersion(devel=False,date=False,author=False)
                     Return PETSc version information.

                     Not collective.

                     Parameters

                            • devel (bool) -- Additionally, return whether using an in-development version.

                            • date (bool) -- Additionally, return date information.

                            • author (bool) -- Additionally, return author information.

                     Returns

                            • major (int) -- Major version number.

                            • minor (int) -- Minor version number.

                            • micro (int) -- Micro (or patch) version number.

                     Returntypetuple[int, int, int]

                     SEEALSO:PetscGetVersion, PetscGetVersionNumberSourcecodeatpetsc4py/PETSc/Sys.pyx:7classmethodgetVersionInfo()
                     Return PETSc version information.

                     Not collective.

                     Returnsinfo -- Dictionary with version information.

                     ReturntypedictSEEALSO:PetscGetVersion, PetscGetVersionNumberSourcecodeatpetsc4py/PETSc/Sys.pyx:62classmethodhasExternalPackage(package)
                     Return whether PETSc has support for external package.

                     Not collective.

                     Parameterspackage (str) -- The external package name.

                     ReturntypeboolSEEALSO:PetscHasExternalPackageSourcecodeatpetsc4py/PETSc/Sys.pyx:449classmethodinfoAllow(flag,filename=None,mode='w')
                     Enables or disables PETSc info messages.

                     Not collective.

                     Parameters

                            • flag (bool) -- Whether to enable info messages.

                            • filename (str|None) -- Name of a file where to dump output.

                            • mode (str) -- Write mode for file, by default "w".

                     ReturntypeNoneSEEALSO:PetscInfoAllow, PetscInfoSetFileSourcecodeatpetsc4py/PETSc/Sys.pyx:392classmethodisFinalized()
                     Return whether PETSc has been finalized.

                     Not collective.

                     SEEALSO:isInitializedSourcecodeatpetsc4py/PETSc/Sys.pyx:101ReturntypeboolclassmethodisInitialized()
                     Return whether PETSc has been initialized.

                     Not collective.

                     SEEALSO:isFinalizedSourcecodeatpetsc4py/PETSc/Sys.pyx:88ReturntypeboolclassmethodpopErrorHandler()
                     Remove the current error handler.

                     Logically collective.

                     SEEALSO:PetscPopErrorHandlerSourcecodeatpetsc4py/PETSc/Sys.pyx:366ReturntypeNoneclassmethodpopSignalHandler()
                     Remove the current signal handler.

                     Logically collective.

                     SEEALSO:PetscPopSignalHandlerSourcecodeatpetsc4py/PETSc/Sys.pyx:379ReturntypeNoneclassmethodpushErrorHandler(errhandler)
                     Set the current error handler.

                     Logically collective.

                     Parameterserrhandler (str) -- The name of the error handler.

                     ReturntypeNoneSEEALSO:PetscPushErrorHandlerSourcecodeatpetsc4py/PETSc/Sys.pyx:331classmethodregisterCitation(citation)
                     Register BibTeX citation.

                     Not collective.

                     Parameterscitation (str) -- The BibTex citation entry to register.

                     ReturntypeNoneSEEALSO:PetscCitationsRegisterSourcecodeatpetsc4py/PETSc/Sys.pyx:426classmethodsetDefaultComm(comm)
                     Set the default MPI communicator used to create PETSc objects.

                     Logically collective.

                     Parameterscomm (Comm|None) -- MPI communicator. If set to None, uses COMM_WORLD.

                     ReturntypeNoneSEEALSO:getDefaultCommSourcecodeatpetsc4py/PETSc/Sys.pyx:131classmethodsleep(seconds=1.0)
                     Sleep some number of seconds.

                     Not collective.

                     Parametersseconds (float) -- Time to sleep in seconds.

                     ReturntypeNoneSEEALSO:PetscSleepSourcecodeatpetsc4py/PETSc/Sys.pyx:310classmethodsplitOwnership(size,bsize=None,comm=None)
                     Given a global (or local) size determines a local (or global) size.

                     Collective.

                     Parameters

                            • size (int|tuple[int,int]) -- Global size N or 2-tuple (n,N)  with  local  and
                              global sizes. Either of n or N (but not both) can be None.

                            • bsize (int|None) -- Block size, defaults to 1.

                            • comm (Comm|None) -- MPI communicator, defaults to getDefaultComm.

                     Returns

                            • n (int) -- The local size.

                            • N (int) -- The global size.

                     Returntypetuple[int, int]

                     Notes

                     The  size  argument  corresponds  to the full size of the vector. That is, an array with 10
                     blocks and a block size of 3 will have a size of 30, not 10.

                     SEEALSO:PetscSplitOwnershipSourcecodeatpetsc4py/PETSc/Sys.pyx:261classmethodsyncFlush(comm=None)
                     Flush output from previous syncPrint calls.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to getDefaultComm.

                     ReturntypeNoneSEEALSO:PetscSynchronizedPrintf, PetscSynchronizedFlushSourcecodeatpetsc4py/PETSc/Sys.pyx:240classmethodsyncPrint(*args,sep='',end='\n',flush=False,comm=None,**kwargs)
                     Print synchronized output from several processors of a communicator.

                     Not collective.

                     Parameters

                            • *args (Any) -- Positional arguments.

                            • sep (str) -- String inserted between values, by default a space.

                            • end (str) -- String appended after the last value, by default a newline.

                            • flush (bool) -- Whether to flush output with syncFlush.

                            • comm (Comm|None) -- MPI communicator, defaults to getDefaultComm.

                            • **kwargs (Any) -- Keyword arguments.

                     ReturntypeNoneSEEALSO:PetscSynchronizedPrintf, PetscSynchronizedFlushSourcecodeatpetsc4py/PETSc/Sys.pyx:197petsc4py.PETSc.TAOclasspetsc4py.PETSc.TAO
              Bases: Object

              Optimization solver.

              TAO is described in the PETScmanual.

              SEEALSO:Tao

              Enumerations
                                 ┌─────────────────┬───────────────────────────────────────┐
                                 │ BNCGType        │ TAO   Bound   Constrained   Conjugate │
                                 │                 │ Gradient (BNCG) Update Type.          │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ ConvergedReason │ TAO solver termination reason.        │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ Type            │ TAO solver type.                      │
                                 └─────────────────┴───────────────────────────────────────┘

   petsc4py.PETSc.TAO.BNCGTypeclasspetsc4py.PETSc.TAO.BNCGType
                     Bases: object

                     TAO Bound Constrained Conjugate Gradient (BNCG) Update Type.

                     Attributes Summary
                                           ┌───────────┬────────────────────────────────┐
                                           │ DK        │ Constant DK of type int        │
                                           ├───────────┼────────────────────────────────┤
                                           │ DY        │ Constant DY of type int        │
                                           ├───────────┼────────────────────────────────┤
                                           │ FR        │ Constant FR of type int        │
                                           ├───────────┼────────────────────────────────┤
                                           │ GD        │ Constant GD of type int        │
                                           ├───────────┼────────────────────────────────┤
                                           │ HS        │ Constant HS of type int        │
                                           ├───────────┼────────────────────────────────┤
                                           │ HZ        │ Constant HZ of type int        │
                                           ├───────────┼────────────────────────────────┤
                                           │ KD        │ Constant KD of type int        │
                                           ├───────────┼────────────────────────────────┤
                                           │ PCGD      │ Constant PCGD of type int      │
                                           ├───────────┼────────────────────────────────┤
                                           │ PRP       │ Constant PRP of type int       │
                                           ├───────────┼────────────────────────────────┤
                                           │ PRP_PLUS  │ Constant PRP_PLUS of type int  │
                                           ├───────────┼────────────────────────────────┤
                                           │ SSML_BFGS │ Constant SSML_BFGS of type int │
                                           ├───────────┼────────────────────────────────┤
                                           │ SSML_BRDN │ Constant SSML_BRDN of type int │
                                           ├───────────┼────────────────────────────────┤
                                           │ SSML_DFP  │ Constant SSML_DFP of type int  │
                                           └───────────┴────────────────────────────────┘

                     Attributes Documentation

                     DK:int=DK
                            Constant DK of type intDY:int=DY
                            Constant DY of type intFR:int=FR
                            Constant FR of type intGD:int=GD
                            Constant GD of type intHS:int=HS
                            Constant HS of type intHZ:int=HZ
                            Constant HZ of type intKD:int=KD
                            Constant KD of type intPCGD:int=PCGD
                            Constant PCGD of type intPRP:int=PRP
                            Constant PRP of type intPRP_PLUS:int=PRP_PLUS
                            Constant PRP_PLUS of type intSSML_BFGS:int=SSML_BFGS
                            Constant SSML_BFGS of type intSSML_BRDN:int=SSML_BRDN
                            Constant SSML_BRDN of type intSSML_DFP:int=SSML_DFP
                            Constant SSML_DFP of type intpetsc4py.PETSc.TAO.ConvergedReasonclasspetsc4py.PETSc.TAO.ConvergedReason
                     Bases: object

                     TAO solver termination reason.

                     SEEALSO:TaoConvergedReason

                     Attributes Summary
                                 ┌───────────────────────┬───────────────────────────────────────┐
                                 │ CONTINUE_ITERATING    │ Constant CONTINUE_ITERATING of type ‐ │
                                 │                       │ int                                   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ CONVERGED_GATOL       │ Constant CONVERGED_GATOL of type int  │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ CONVERGED_GRTOL       │ Constant CONVERGED_GRTOL of type int  │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ CONVERGED_GTTOL       │ Constant CONVERGED_GTTOL of type int  │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ CONVERGED_ITERATING   │ Constant  CONVERGED_ITERATING of type │
                                 │                       │ int                                   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ CONVERGED_MINF        │ Constant CONVERGED_MINF of type int   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ CONVERGED_STEPTOL     │ Constant CONVERGED_STEPTOL of type  ‐ │
                                 │                       │ int                                   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ CONVERGED_USER        │ Constant CONVERGED_USER of type int   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ DIVERGED_LS_FAILURE   │ Constant  DIVERGED_LS_FAILURE of type │
                                 │                       │ int                                   │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ DIVERGED_MAXFCN       │ Constant DIVERGED_MAXFCN of type int  │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ DIVERGED_MAXITS       │ Constant DIVERGED_MAXITS of type int  │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ DIVERGED_NAN          │ Constant DIVERGED_NAN of type int     │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ DIVERGED_TR_REDUCTION │ Constant   DIVERGED_TR_REDUCTION   of │
                                 │                       │ type int                              │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ DIVERGED_USER         │ Constant DIVERGED_USER of type int    │
                                 ├───────────────────────┼───────────────────────────────────────┤
                                 │ ITERATING             │ Constant ITERATING of type int        │
                                 └───────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     CONTINUE_ITERATING:int=CONTINUE_ITERATING
                            Constant CONTINUE_ITERATING of type intCONVERGED_GATOL:int=CONVERGED_GATOL
                            Constant CONVERGED_GATOL of type intCONVERGED_GRTOL:int=CONVERGED_GRTOL
                            Constant CONVERGED_GRTOL of type intCONVERGED_GTTOL:int=CONVERGED_GTTOL
                            Constant CONVERGED_GTTOL of type intCONVERGED_ITERATING:int=CONVERGED_ITERATING
                            Constant CONVERGED_ITERATING of type intCONVERGED_MINF:int=CONVERGED_MINF
                            Constant CONVERGED_MINF of type intCONVERGED_STEPTOL:int=CONVERGED_STEPTOL
                            Constant CONVERGED_STEPTOL of type intCONVERGED_USER:int=CONVERGED_USER
                            Constant CONVERGED_USER of type intDIVERGED_LS_FAILURE:int=DIVERGED_LS_FAILURE
                            Constant DIVERGED_LS_FAILURE of type intDIVERGED_MAXFCN:int=DIVERGED_MAXFCN
                            Constant DIVERGED_MAXFCN of type intDIVERGED_MAXITS:int=DIVERGED_MAXITS
                            Constant DIVERGED_MAXITS of type intDIVERGED_NAN:int=DIVERGED_NAN
                            Constant DIVERGED_NAN of type intDIVERGED_TR_REDUCTION:int=DIVERGED_TR_REDUCTION
                            Constant DIVERGED_TR_REDUCTION of type intDIVERGED_USER:int=DIVERGED_USER
                            Constant DIVERGED_USER of type intITERATING:int=ITERATING
                            Constant ITERATING of type intpetsc4py.PETSc.TAO.Typeclasspetsc4py.PETSc.TAO.Type
                     Bases: object

                     TAO solver type.

                     SEEALSO:TaoType

                     Attributes Summary
                                             ┌──────────┬─────────────────────────────┐
                                             │ ADMM     │ Object ADMM of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ ALMM     │ Object ALMM of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ ASFLS    │ Object ASFLS of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ ASILS    │ Object ASILS of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ BLMVM    │ Object BLMVM of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ BMRM     │ Object BMRM of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ BNCG     │ Object BNCG of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ BNLS     │ Object BNLS of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ BNTL     │ Object BNTL of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ BNTR     │ Object BNTR of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ BQNKLS   │ Object BQNKLS of type str   │
                                             ├──────────┼─────────────────────────────┤
                                             │ BQNKTL   │ Object BQNKTL of type str   │
                                             ├──────────┼─────────────────────────────┤
                                             │ BQNKTR   │ Object BQNKTR of type str   │
                                             ├──────────┼─────────────────────────────┤
                                             │ BQNLS    │ Object BQNLS of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ BQPIP    │ Object BQPIP of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ BRGN     │ Object BRGN of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ CG       │ Object CG of type str       │
                                             ├──────────┼─────────────────────────────┤
                                             │ GPCG     │ Object GPCG of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ IPM      │ Object IPM of type str      │
                                             ├──────────┼─────────────────────────────┤
                                             │ LCL      │ Object LCL of type str      │
                                             ├──────────┼─────────────────────────────┤
                                             │ LMVM     │ Object LMVM of type str     │
                                             ├──────────┼─────────────────────────────┤
                                             │ NLS      │ Object NLS of type str      │
                                             ├──────────┼─────────────────────────────┤
                                             │ NM       │ Object NM of type str       │
                                             ├──────────┼─────────────────────────────┤
                                             │ NTL      │ Object NTL of type str      │
                                             ├──────────┼─────────────────────────────┤
                                             │ NTR      │ Object NTR of type str      │
                                             ├──────────┼─────────────────────────────┤
                                             │ OWLQN    │ Object OWLQN of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ PDIPM    │ Object PDIPM of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ POUNDERS │ Object POUNDERS of type str │
                                             ├──────────┼─────────────────────────────┤
                                             │ PYTHON   │ Object PYTHON of type str   │
                                             ├──────────┼─────────────────────────────┤
                                             │ SHELL    │ Object SHELL of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ SSFLS    │ Object SSFLS of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ SSILS    │ Object SSILS of type str    │
                                             ├──────────┼─────────────────────────────┤
                                             │ TRON     │ Object TRON of type str     │
                                             └──────────┴─────────────────────────────┘

                     Attributes Documentation

                     ADMM:str=ADMM
                            Object ADMM of type strALMM:str=ALMM
                            Object ALMM of type strASFLS:str=ASFLS
                            Object ASFLS of type strASILS:str=ASILS
                            Object ASILS of type strBLMVM:str=BLMVM
                            Object BLMVM of type strBMRM:str=BMRM
                            Object BMRM of type strBNCG:str=BNCG
                            Object BNCG of type strBNLS:str=BNLS
                            Object BNLS of type strBNTL:str=BNTL
                            Object BNTL of type strBNTR:str=BNTR
                            Object BNTR of type strBQNKLS:str=BQNKLS
                            Object BQNKLS of type strBQNKTL:str=BQNKTL
                            Object BQNKTL of type strBQNKTR:str=BQNKTR
                            Object BQNKTR of type strBQNLS:str=BQNLS
                            Object BQNLS of type strBQPIP:str=BQPIP
                            Object BQPIP of type strBRGN:str=BRGN
                            Object BRGN of type strCG:str=CG
                            Object CG of type strGPCG:str=GPCG
                            Object GPCG of type strIPM:str=IPM
                            Object IPM of type strLCL:str=LCL
                            Object LCL of type strLMVM:str=LMVM
                            Object LMVM of type strNLS:str=NLS
                            Object NLS of type strNM:str=NM
                            Object NM of type strNTL:str=NTL
                            Object NTL of type strNTR:str=NTR
                            Object NTR of type strOWLQN:str=OWLQN
                            Object OWLQN of type strPDIPM:str=PDIPM
                            Object PDIPM of type strPOUNDERS:str=POUNDERS
                            Object POUNDERS of type strPYTHON:str=PYTHON
                            Object PYTHON of type strSHELL:str=SHELL
                            Object SHELL of type strSSFLS:str=SSFLS
                            Object SSFLS of type strSSILS:str=SSILS
                            Object SSILS of type strTRON:str=TRON
                            Object TRON of type str

              Methods Summary
                  ┌──────────────────────────────────────────────┬───────────────────────────────────────┐
                  │ appendOptionsPrefix(prefix)                  │ Append   to   the   prefix  used  for │
                  │                                              │ searching   for   options   in    the │
                  │                                              │ database.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ cancelMonitor()                              │ Cancel   all   the  monitors  of  the │
                  │                                              │ solver.                               │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeConstraints(x, c)                     │ Compute the vector  corresponding  to │
                  │                                              │ the constraints.                      │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeDualVariables(xl, xu)                 │ Compute      the     dual     vectors │
                  │                                              │ corresponding to variables' bounds.   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeGradient(x, g)                        │ Compute the gradient of the objective │
                  │                                              │ function.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeHessian(x, H[, P])                    │ Compute the Hessian of the  objective │
                  │                                              │ function.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeJacobian(x, J[, P])                   │ Compute the Jacobian.                 │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeObjective(x)                          │ Compute  the  value  of the objective │
                  │                                              │ function.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeObjectiveGradient(x, g)               │ Compute the gradient of the objective │
                  │                                              │ function and its value.               │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeResidual(x, f)                        │ Compute the residual.                 │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ computeVariableBounds(xl, xu)                │ Compute the vectors corresponding  to │
                  │                                              │ variables' bounds.                    │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ create([comm])                               │ Create a TAO solver.                  │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ createPython([context, comm])                │ Create   an  optimization  solver  of │
                  │                                              │ Python type.                          │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ destroy()                                    │ Destroy the solver.                   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getAppCtx()                                  │ Return the application context.       │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getBNCGType()                                │ Return the type of the BNCG solver.   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getBRGNDampingVector()                       │ Return the damping vector.            │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getBRGNSubsolver()                           │ Return the subsolver inside the  BRGN │
                  │                                              │ solver.                               │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getConstraintTolerances()                    │ Return   the   constraints  tolerance │
                  │                                              │ parameters used  in  the  convergence │
                  │                                              │ tests.                                │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getConvergedReason()                         │ Return the termination flag.          │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getConvergenceTest()                         │ Return  the callback used to test for │
                  │                                              │ solver convergence.                   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getGradient()                                │ Return the vector used to  store  the │
                  │                                              │ gradient and the evaluation callback. │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getGradientNorm()                            │ Return  the  matrix  used  to compute │
                  │                                              │ inner products.                       │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getHessian()                                 │ Return the matrices used to store the │
                  │                                              │ Hessian and the evaluation callback.  │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getIterationNumber()                         │ Return the current iteration number.  │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getKSP()                                     │ Return the linear solver used by  the │
                  │                                              │ nonlinear solver.                     │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getLMVMH0()                                  │ Return  the  initial  Hessian for the │
                  │                                              │ quasi-Newton approximation.           │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getLMVMH0KSP()                               │ Return the KSP for the inverse of the │
                  │                                              │ initial Hessian approximation.        │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getLineSearch()                              │ Return the TAO Line Search object.    │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getMaximumFunctionEvaluations()              │ Return   the   maximum   number    of │
                  │                                              │ objective   evaluations   within  the │
                  │                                              │ solver.                               │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getMaximumIterations()                       │ Return the maximum number  of  solver │
                  │                                              │ iterations.                           │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getMonitor()                                 │ Return  the  callback used to monitor │
                  │                                              │ solver convergence.                   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getObjectiveAndGradient()                    │ Return the vector used to  store  the │
                  │                                              │ gradient and the evaluation callback. │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getObjectiveValue()                          │ Return   the  current  value  of  the │
                  │                                              │ objective function.                   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getOptionsPrefix()                           │ Return the prefix used for  searching │
                  │                                              │ for options in the database.          │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getPythonContext()                           │ Return  the  instance  of  the  class │
                  │                                              │ implementing  the   required   Python │
                  │                                              │ methods.                              │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getPythonType()                              │ Return  the  fully  qualified  Python │
                  │                                              │ name of the class used by the solver. │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getSolution()                                │ Return   the   vector   holding   the │
                  │                                              │ solution.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getSolutionNorm()                            │ Return  the  objective function value │
                  │                                              │ and  the  norms   of   gradient   and │
                  │                                              │ constraints.                          │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getSolutionStatus()                          │ Return the solution status.           │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getTolerances()                              │ Return  the tolerance parameters used │
                  │                                              │ in the solver convergence tests.      │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getType()                                    │ Return the type of the solver.        │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getUpdate()                                  │ Return the callback  to  compute  the │
                  │                                              │ update.                               │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ getVariableBounds()                          │ Return  the  upper  and  lower bounds │
                  │                                              │ vectors.                              │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ monitor([its, f, res, cnorm, step])          │ Monitor the solver.                   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setAppCtx(appctx)                            │ Set the application context.          │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setBNCGType(cg_type)                         │ Set the type of the BNCG solver.      │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setBRGNDictionaryMatrix(D)                   │ Set the dictionary matrix.            │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setBRGNRegularizerHessian(hessian[,          │ Set  the  callback  to  compute   the │
                  │ H, ...])                                     │ regularizer Hessian.                  │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setBRGNRegularizerObjectiveGradient(objgrad) │ Set   the  callback  to  compute  the │
                  │                                              │ regularizer objective and gradient.   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setBRGNRegularizerWeight(weight)             │ Set the regularizer weight.           │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setBRGNSmoothL1Epsilon(epsilon)              │ Set the smooth L1 epsilon.            │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setConstraintTolerances([catol, crtol])      │ Set   the    constraints    tolerance │
                  │                                              │ parameters   used   in   the   solver │
                  │                                              │ convergence tests.                    │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setConstraints(constraints[,    C,     args, │ Set    the    callback   to   compute │
                  │ kargs])                                      │ constraints.                          │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setConvergedReason(reason)                   │ Set the termination flag.             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setConvergenceTest(converged[, args, kargs]) │ Set the callback  used  to  test  for │
                  │                                              │ solver convergence.                   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setEqualityConstraints(equality_constraints, │ Set equality constraints callback.    │
                  │ c)                                           │                                       │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setFromOptions()                             │ Configure the solver from the options │
                  │                                              │ database.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setGradient(gradient[, g, args, kargs])      │ Set the gradient evaluation callback. │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setGradientNorm(mat)                         │ Set  the matrix used to compute inner │
                  │                                              │ products.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setHessian(hessian[, H, P, args, kargs])     │ Set  the  callback  to  compute   the │
                  │                                              │ Hessian matrix.                       │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setInitialTrustRegionRadius(radius)          │ Set the initial trust region radius.  │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setIterationNumber(its)                      │ Set the current iteration number.     │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setJacobian(jacobian[, J, P, args, kargs])   │ Set   the  callback  to  compute  the │
                  │                                              │ Jacobian.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setJacobianDesign(jacobian_design[, J, ...]) │ Set Jacobian design callback.         │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setJacobianEquality(jacobian_equality[,   J, │ Set   Jacobian  equality  constraints │
                  │ ...])                                        │ callback.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setJacobianResidual(jacobian[, J,  P,  args, │ Set   the  callback  to  compute  the │
                  │ ...])                                        │ least-squares residual Jacobian.      │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setJacobianState(jacobian_state[, J,  P,  I, │ Set Jacobian state callback.          │
                  │ ...])                                        │                                       │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setLMVMH0(mat)                               │ Set   the  initial  Hessian  for  the │
                  │                                              │ quasi-Newton approximation.           │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setMaximumFunctionEvaluations(mit)           │ Set the maximum number  of  objective │
                  │                                              │ evaluations within the solver.        │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setMaximumIterations(mit)                    │ Set  the  maximum  number  of  solver │
                  │                                              │ iterations.                           │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setMonitor(monitor[, args, kargs])           │ Set  the  callback  used  to  monitor │
                  │                                              │ solver convergence.                   │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setObjective(objective[, args, kargs])       │ Set the objective function evaluation │
                  │                                              │ callback.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setObjectiveGradient(objgrad[,    g,   args, │ Set  the   objective   function   and │
                  │ kargs])                                      │ gradient evaluation callback.         │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setOptionsPrefix(prefix)                     │ Set the prefix used for searching for │
                  │                                              │ options in the database.              │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setPythonContext(context)                    │ Set   the   instance   of  the  class │
                  │                                              │ implementing  the   required   Python │
                  │                                              │ methods.                              │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setPythonType(py_type)                       │ Set  the  fully qualified Python name │
                  │                                              │ of the class to be used.              │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setResidual(residual, R[, args, kargs])      │ Set the residual evaluation  callback │
                  │                                              │ for least-squares applications.       │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setSolution(x)                               │ Set  the  vector  used  to  store the │
                  │                                              │ solution.                             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setStateDesignIS([state, design])            │ Set the index sets  indicating  state │
                  │                                              │ and design variables.                 │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setTolerances([gatol, grtol, gttol])         │ Set  the tolerance parameters used in │
                  │                                              │ the solver convergence tests.         │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setType(tao_type)                            │ Set the type of the solver.           │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setUp()                                      │ Set up the internal  data  structures │
                  │                                              │ for using the solver.                 │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setUpdate(update[, args, kargs])             │ Set the callback to compute update at │
                  │                                              │ each optimization step.               │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ setVariableBounds(varbounds[, args, kargs])  │ Set  the  upper  and lower bounds for │
                  │                                              │ the optimization problem.             │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ solve([x])                                   │ Solve the optimization problem.       │
                  ├──────────────────────────────────────────────┼───────────────────────────────────────┤
                  │ view([viewer])                               │ View the solver.                      │
                  └──────────────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                    ┌───────────┬───────────────────────────────────────┐
                                    │ appctx    │ Application context.                  │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ cnorm     │ Constraints norm.                     │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ converged │ Boolean indicating if the solver  has │
                                    │           │ converged.                            │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ ctol      │ Broken.                               │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ diverged  │ Boolean  indicating if the solver has │
                                    │           │ failed.                               │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ ftol      │ Broken.                               │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ function  │ Objective value.                      │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ gnorm     │ Gradient norm.                        │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ gradient  │ Gradient vector.                      │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ gtol      │ Broken.                               │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ iterating │ Boolean indicating if the solver  has │
                                    │           │ not converged yet.                    │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ its       │ Number of iterations.                 │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ ksp       │ Linear solver.                        │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ objective │ Objective value.                      │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ reason    │ Converged reason.                     │
                                    ├───────────┼───────────────────────────────────────┤
                                    │ solution  │ Solution vector.                      │
                                    └───────────┴───────────────────────────────────────┘

              Methods Documentation

              appendOptionsPrefix(prefix)
                     Append to the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, TaoAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/TAO.pyx:213Parametersprefix (str|None)

                     ReturntypeNonecancelMonitor()
                     Cancel all the monitors of the solver.

                     Logically collective.

                     SEEALSO:setMonitor, TaoMonitorCancelSourcecodeatpetsc4py/PETSc/TAO.pyx:1220ReturntypeNonecomputeConstraints(x,c)
                     Compute the vector corresponding to the constraints.

                     Collective.

                     Parameters

                            • x (Vec) -- The parameter vector.

                            • c (Vec) -- The output constraints vector.

                     ReturntypeNoneSEEALSO:setVariableBounds, TaoComputeVariableBoundsSourcecodeatpetsc4py/PETSc/TAO.pyx:887computeDualVariables(xl,xu)
                     Compute the dual vectors corresponding to variables' bounds.

                     Collective.

                     SEEALSO:TaoComputeDualVariablesSourcecodeatpetsc4py/PETSc/TAO.pyx:851Parameters

                            • xl (Vec)

                            • xu (Vec)

                     ReturntypeNonecomputeGradient(x,g)
                     Compute the gradient of the objective function.

                     Collective.

                     Parameters

                            • x (Vec) -- The parameter vector.

                            • g (Vec) -- The output gradient vector.

                     ReturntypeNoneSEEALSO:setGradient, TaoComputeGradientSourcecodeatpetsc4py/PETSc/TAO.pyx:810computeHessian(x,H,P=None)
                     Compute the Hessian of the objective function.

                     Collective.

                     Parameters

                            • x (Vec) -- The parameter vector.

                            • H (Mat) -- The output Hessian matrix.

                            • P (Mat|None) -- The output Hessian matrix used to construct the preconditioner.

                     ReturntypeNoneSEEALSO:setHessian, TaoComputeHessianSourcecodeatpetsc4py/PETSc/TAO.pyx:906computeJacobian(x,J,P=None)
                     Compute the Jacobian.

                     Collective.

                     Parameters

                            • x (Vec) -- The parameter vector.

                            • J (Mat) -- The output Jacobian matrix.

                            • P (Mat|None) -- The output Jacobian matrix used to construct the preconditioner.

                     ReturntypeNoneSEEALSO:setJacobian, TaoComputeJacobianSourcecodeatpetsc4py/PETSc/TAO.pyx:929computeObjective(x)
                     Compute the value of the objective function.

                     Collective.

                     Parametersx (Vec) -- The parameter vector.

                     ReturntypefloatSEEALSO:setObjective, TaoComputeObjectiveSourcecodeatpetsc4py/PETSc/TAO.pyx:772computeObjectiveGradient(x,g)
                     Compute the gradient of the objective function and its value.

                     Collective.

                     Parameters

                            • x (Vec) -- The parameter vector.

                            • g (Vec) -- The output gradient vector.

                     ReturntypefloatSEEALSO:setObjectiveGradient, setGradient, setObjective, TaoComputeObjectiveAndGradientSourcecodeatpetsc4py/PETSc/TAO.pyx:829computeResidual(x,f)
                     Compute the residual.

                     Collective.

                     Parameters

                            • x (Vec) -- The parameter vector.

                            • f (Vec) -- The output vector.

                     ReturntypeNoneSEEALSO:setResidual, TaoComputeResidualSourcecodeatpetsc4py/PETSc/TAO.pyx:791computeVariableBounds(xl,xu)
                     Compute the vectors corresponding to variables' bounds.

                     Collective.

                     SEEALSO:setVariableBounds, TaoComputeVariableBoundsSourcecodeatpetsc4py/PETSc/TAO.pyx:863Parameters

                            • xl (Vec)

                            • xu (Vec)

                     ReturntypeNonecreate(comm=None)
                     Create a TAO solver.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:Sys.getDefaultComm, TaoCreateSourcecodeatpetsc4py/PETSc/TAO.pyx:145createPython(context=None,comm=None)
                     Create an optimization solver of Python type.

                     Collective.

                     Parameters

                            • context  (Any)  --  An  instance  of  the  Python  class implementing the required
                              methods.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PETScPythonoptimizationsolvertype(TODO), setType, setPythonContext, Type.PYTHONSourcecodeatpetsc4py/PETSc/TAO.pyx:1662destroy()
                     Destroy the solver.

                     Collective.

                     SEEALSO:TaoDestroySourcecodeatpetsc4py/PETSc/TAO.pyx:132ReturntypeSelfgetAppCtx()
                     Return the application context.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:286ReturntypeAnygetBNCGType()
                     Return the type of the BNCG solver.

                     Not collective.

                     SEEALSO:setBNCGType, TaoBNCGGetTypeSourcecodeatpetsc4py/PETSc/TAO.pyx:1416ReturntypeBNCGTypegetBRGNDampingVector()
                     Return the damping vector.

                     Not collective.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1647ReturntypeVecgetBRGNSubsolver()
                     Return the subsolver inside the BRGN solver.

                     Not collective.

                     SEEALSO:TaoBRGNGetSubsolverSourcecodeatpetsc4py/PETSc/TAO.pyx:1564ReturntypeTAOgetConstraintTolerances()
                     Return the constraints tolerance parameters used in the convergence tests.

                     Not collective.

                     Returns

                            • catol (float) -- The absolute norm of the constraints.

                            • crtol (float) -- The relative norm of the constraints.

                     Returntypetuple[float, float]

                     SEEALSO:setConstraintTolerances, TaoGetConstraintTolerancesSourcecodeatpetsc4py/PETSc/TAO.pyx:1091getConvergedReason()
                     Return the termination flag.

                     Not collective.

                     SEEALSO:setConvergedReason, TaoGetConvergedReasonSourcecodeatpetsc4py/PETSc/TAO.pyx:1165ReturntypeConvergedReasongetConvergenceTest()
                     Return the callback used to test for solver convergence.

                     Not collective.

                     SEEALSO:setConvergenceTestSourcecodeatpetsc4py/PETSc/TAO.pyx:1140Returntypetuple[TAOConvergedFunction, tuple[Any, ...], dict[str, Any]]

              getGradient()
                     Return the vector used to store the gradient and the evaluation callback.

                     Not collective.

                     SEEALSO:setGradient, setHessian, TaoGetGradientSourcecodeatpetsc4py/PETSc/TAO.pyx:416Returntypetuple[Vec, TAOGradientFunction]

              getGradientNorm()
                     Return the matrix used to compute inner products.

                     Not collective.

                     SEEALSO:setGradientNorm, TaoGetGradientNormSourcecodeatpetsc4py/PETSc/TAO.pyx:1331ReturntypeMatgetHessian()
                     Return the matrices used to store the Hessian and the evaluation callback.

                     Not collective.

                     SEEALSO:setHessian, TaoGetHessianSourcecodeatpetsc4py/PETSc/TAO.pyx:578Returntypetuple[Mat, Mat, TAOHessianFunction]

              getIterationNumber()
                     Return the current iteration number.

                     Not collective.

                     SEEALSO:setIterationNumber, TaoGetIterationNumberSourcecodeatpetsc4py/PETSc/TAO.pyx:1443ReturntypeintgetKSP()
                     Return the linear solver used by the nonlinear solver.

                     Not collective.

                     SEEALSO:TaoGetKSPSourcecodeatpetsc4py/PETSc/TAO.pyx:1547ReturntypeKSPgetLMVMH0()
                     Return the initial Hessian for the quasi-Newton approximation.

                     Not collective.

                     SEEALSO:setLMVMH0, TaoLMVMGetH0Sourcecodeatpetsc4py/PETSc/TAO.pyx:1358ReturntypeMatgetLMVMH0KSP()
                     Return the KSP for the inverse of the initial Hessian approximation.

                     Not collective.

                     SEEALSO:setLMVMH0, TaoLMVMGetH0KSPSourcecodeatpetsc4py/PETSc/TAO.pyx:1373ReturntypeKSPgetLineSearch()
                     Return the TAO Line Search object.

                     Not collective.

                     SEEALSO:TaoGetLineSearchSourcecodeatpetsc4py/PETSc/TAO.pyx:1744ReturntypeTAOLineSearchgetMaximumFunctionEvaluations()
                     Return the maximum number of objective evaluations within the solver.

                     Not collective.

                     SEEALSO:setMaximumFunctionEvaluations, TaoGetMaximumFunctionEvaluationsSourcecodeatpetsc4py/PETSc/TAO.pyx:1051ReturntypeintgetMaximumIterations()
                     Return the maximum number of solver iterations.

                     Not collective.

                     SEEALSO:setMaximumIterations, TaoGetMaximumIterationsSourcecodeatpetsc4py/PETSc/TAO.pyx:1024ReturntypeintgetMonitor()
                     Return the callback used to monitor solver convergence.

                     Not collective.

                     SEEALSO:setMonitorSourcecodeatpetsc4py/PETSc/TAO.pyx:1208Returntypelist[tuple[TAOMonitorFunction, tuple[Any, ...], dict[str, Any]]]

              getObjectiveAndGradient()
                     Return the vector used to store the gradient and the evaluation callback.

                     Not collective.

                     SEEALSO:setObjectiveGradient, TaoGetObjectiveAndGradientSourcecodeatpetsc4py/PETSc/TAO.pyx:462Returntypetuple[Vec, TAOObjectiveGradientFunction]

              getObjectiveValue()
                     Return the current value of the objective function.

                     Not collective.

                     SEEALSO:setObjective, TaoGetSolutionStatusSourcecodeatpetsc4py/PETSc/TAO.pyx:1457ReturntypefloatgetOptionsPrefix()
                     Return the prefix used for searching for options in the database.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, TaoGetOptionsPrefixSourcecodeatpetsc4py/PETSc/TAO.pyx:227ReturntypestrgetPythonContext()
                     Return the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonoptimizationsolvertype(TODO), setPythonContextSourcecodeatpetsc4py/PETSc/TAO.pyx:1699ReturntypeAnygetPythonType()
                     Return the fully qualified Python name of the class used by the solver.

                     Not collective.

                     SEEALSO:PETScPythonoptimizationsolvertype(TODO),  setPythonContext,  setPythonType,  ‐
                        TaoPythonGetTypeSourcecodeatpetsc4py/PETSc/TAO.pyx:1729ReturntypestrgetSolution()
                     Return the vector holding the solution.

                     Not collective.

                     SEEALSO:setSolution, TaoGetSolutionSourcecodeatpetsc4py/PETSc/TAO.pyx:1304ReturntypeVecgetSolutionNorm()
                     Return the objective function value and the norms of gradient and constraints.

                     Not collective.

                     Returns

                            • f (float) -- Current value of the objective function.

                            • res (float) -- Current value of the residual norm.

                            • cnorm (float) -- Current value of the constrains norm.

                     Returntypetuple[float, float, float]

                     SEEALSO:getSolutionStatus, TaoGetSolutionStatusSourcecodeatpetsc4py/PETSc/TAO.pyx:1487getSolutionStatus()
                     Return the solution status.

                     Not collective.

                     Returns

                            • its (int) -- Current number of iterations.

                            • f (float) -- Current value of the objective function.

                            • res (float) -- Current value of the residual norm.

                            • cnorm (float) -- Current value of the constrains norm.

                            • step (float) -- Current value of the step.

                            • reason (ConvergedReason) -- Current value of converged reason.

                     Returntypetuple[int, float, float, float, float, ConvergedReason]

                     SEEALSO:TaoGetSolutionStatusSourcecodeatpetsc4py/PETSc/TAO.pyx:1512getTolerances()
                     Return the tolerance parameters used in the solver convergence tests.

                     Not collective.

                     Returns

                            • gatol (float) -- The absolute norm of the gradient.

                            • grtol (float) -- The relative norm of the gradient.

                            • gttol  (float)  --  The  relative norm of the gradient with respect to the initial
                              norm of the gradient.

                     Returntypetuple[float, float, float]

                     SEEALSO:setTolerances, TaoGetTolerancesSourcecodeatpetsc4py/PETSc/TAO.pyx:987getType()
                     Return the type of the solver.

                     Not collective.

                     SEEALSO:setType, TaoGetTypeSourcecodeatpetsc4py/PETSc/TAO.pyx:185ReturntypestrgetUpdate()
                     Return the callback to compute the update.

                     Not collective.

                     SEEALSO:setUpdateSourcecodeatpetsc4py/PETSc/TAO.pyx:758Returntypetuple[TAOUpdateFunction, tuple[Any, ...], dict[str, Any]]

              getVariableBounds()
                     Return the upper and lower bounds vectors.

                     Not collective.

                     SEEALSO:setVariableBounds, TaoGetVariableBoundsSourcecodeatpetsc4py/PETSc/TAO.pyx:1388Returntypetuple[Vec, Vec]

              monitor(its=None,f=None,res=None,cnorm=None,step=None)
                     Monitor the solver.

                     Collective.

                     This function should be called without arguments, unless users want to  modify  the  values
                     internally stored by the solver.

                     Parameters

                            • its  (int)  --  Current  number  of  iterations  or  None  to use the value stored
                              internally by the solver.

                            • f (float) -- Current value of the objective function or  None  to  use  the  value
                              stored internally by the solver.

                            • res  (float) -- Current value of the residual norm or None to use the value stored
                              internally by the solver.

                            • cnorm (float) -- Current value of the constrains norm or None  to  use  the  value
                              stored internally by the solver.

                            • step  (float)  --  Current  value  of  the  step  or  None to use the value stored
                              internally by the solver.

                     ReturntypeNoneSEEALSO:setMonitor, TaoMonitorSourcecodeatpetsc4py/PETSc/TAO.pyx:1234setAppCtx(appctx)
                     Set the application context.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:282Parametersappctx (Any)

                     ReturntypeNonesetBNCGType(cg_type)
                     Set the type of the BNCG solver.

                     Collective.

                     SEEALSO:getBNCGType, TaoBNCGSetTypeSourcecodeatpetsc4py/PETSc/TAO.pyx:1403Parameterscg_type (BNCGType)

                     ReturntypeNonesetBRGNDictionaryMatrix(D)
                     Set the dictionary matrix.

                     Collective.

                     SEEALSO:TaoBRGNSetDictionaryMatrixSourcecodeatpetsc4py/PETSc/TAO.pyx:1635ParametersD (Mat)

                     ReturntypeNonesetBRGNRegularizerHessian(hessian,H=None,args=None,kargs=None)
                     Set the callback to compute the regularizer Hessian.

                     Logically collective.

                     SEEALSO:TaoBRGNSetRegularizerHessianRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:1595Parameters

                            • H (Mat|None)

                            • args (tuple[Any,...]|None)

                            • kargs (dict[str,Any]|None)

                     ReturntypeNonesetBRGNRegularizerObjectiveGradient(objgrad,args=None,kargs=None)
                     Set the callback to compute the regularizer objective and gradient.

                     Logically collective.

                     SEEALSO:TaoBRGNSetRegularizerObjectiveAndGradientRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:1579Parameters

                            • args (tuple[Any,...]|None)

                            • kargs (dict[str,Any]|None)

                     ReturntypeNonesetBRGNRegularizerWeight(weight)
                     Set the regularizer weight.

                     Collective.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1613Parametersweight (float)

                     ReturntypeNonesetBRGNSmoothL1Epsilon(epsilon)
                     Set the smooth L1 epsilon.

                     Collective.

                     SEEALSO:TaoBRGNSetL1SmoothEpsilonSourcecodeatpetsc4py/PETSc/TAO.pyx:1622Parametersepsilon (float)

                     ReturntypeNonesetConstraintTolerances(catol=None,crtol=None)
                     Set the constraints tolerance parameters used in the solver convergence tests.

                     Collective.

                     Parameters

                            • catol (float) -- The absolute norm of the constraints, or  DETERMINE  to  use  the
                              value when the object's type was set. Defaults to CURRENT.

                            • crtol  (float)  --  The  relative norm of the constraints, or DETERMINE to use the
                              value when the object's type was set. Defaults to CURRENT.

                     ReturntypeNoneSEEALSO:getConstraintTolerances, TaoSetConstraintTolerancesSourcecodeatpetsc4py/PETSc/TAO.pyx:1065setConstraints(constraints,C=None,args=None,kargs=None)
                     Set the callback to compute constraints.

                     Logically collective.

                     Parameters

                            • constraints (TAOConstraintsFunction) -- The callback.

                            • C (Vec|None) -- The vector to hold the constraints.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:TaoSetConstraintsRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:514setConvergedReason(reason)
                     Set the termination flag.

                     Collective.

                     SEEALSO:getConvergedReason, TaoSetConvergedReasonSourcecodeatpetsc4py/PETSc/TAO.pyx:1152Parametersreason (ConvergedReason)

                     ReturntypeNonesetConvergenceTest(converged,args=None,kargs=None)
                     Set the callback used to test for solver convergence.

                     Logically collective.

                     Parameters

                            • converged (TAOConvergedFunction|None) -- The callback. If  None,  reset  to  the
                              default convergence test.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getConvergenceTest, TaoSetConvergenceTestSourcecodeatpetsc4py/PETSc/TAO.pyx:1112setEqualityConstraints(equality_constraints,c,args=None,kargs=None)
                     Set equality constraints callback.

                     Logically collective.

                     SEEALSO:TaoSetEqualityConstraintsRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:689Parameters

                            • c (Vec)

                            • args (tuple[Any,...]|None)

                            • kargs (dict[str,Any]|None)

                     ReturntypeNonesetFromOptions()
                     Configure the solver from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, TaoSetFromOptionsSourcecodeatpetsc4py/PETSc/TAO.pyx:241ReturntypeNonesetGradient(gradient,g=None,args=None,kargs=None)
                     Set the gradient evaluation callback.

                     Logically collective.

                     Parameters

                            • gradient (TAOGradientFunction) -- The gradient callback.

                            • g (Vec|None) -- The vector to store the gradient.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:setObjective, setObjectiveGradient, setHessian, TaoSetGradientSourcecodeatpetsc4py/PETSc/TAO.pyx:387setGradientNorm(mat)
                     Set the matrix used to compute inner products.

                     Collective.

                     SEEALSO:getGradientNorm, TaoSetGradientNormSourcecodeatpetsc4py/PETSc/TAO.pyx:1319Parametersmat (Mat)

                     ReturntypeNonesetHessian(hessian,H=None,P=None,args=None,kargs=None)
                     Set the callback to compute the Hessian matrix.

                     Logically collective.

                     Parameters

                            • hessian (TAOHessianFunction) -- The Hessian callback.

                            • H (Mat|None) -- The matrix to store the Hessian.

                            • P (Mat|None) -- The matrix to construct the preconditioner.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getHessian, setObjective, setObjectiveGradient, setGradient, TaoSetHessianSourcecodeatpetsc4py/PETSc/TAO.pyx:543setInitialTrustRegionRadius(radius)
                     Set the initial trust region radius.

                     Collective.

                     SEEALSO:TaoSetInitialTrustRegionRadiusSourcecodeatpetsc4py/PETSc/TAO.pyx:267Parametersradius (float)

                     ReturntypeNonesetIterationNumber(its)
                     Set the current iteration number.

                     Collective.

                     SEEALSO:getIterationNumber, TaoSetIterationNumberSourcecodeatpetsc4py/PETSc/TAO.pyx:1430Parametersits (int)

                     ReturntypeNonesetJacobian(jacobian,J=None,P=None,args=None,kargs=None)
                     Set the callback to compute the Jacobian.

                     Logically collective.

                     Parameters

                            • jacobian (TAOJacobianFunction) -- The Jacobian callback.

                            • J (Mat|None) -- The matrix to store the Jacobian.

                            • P (Mat|None) -- The matrix to construct the preconditioner.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:TaoSetJacobianRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:596setJacobianDesign(jacobian_design,J=None,args=None,kargs=None)
                     Set Jacobian design callback.

                     Logically collective.

                     SEEALSO:TaoSetJacobianDesignRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:669Parameters

                            • J (Mat|None)

                            • args (tuple[Any,...]|None)

                            • kargs (dict[str,Any]|None)

                     ReturntypeNonesetJacobianEquality(jacobian_equality,J=None,P=None,args=None,kargs=None)
                     Set Jacobian equality constraints callback.

                     Logically collective.

                     SEEALSO:TaoSetJacobianEqualityRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:707Parameters

                            • J (Mat|None)

                            • P (Mat|None)

                            • args (tuple[Any,...]|None)

                            • kargs (dict[str,Any]|None)

                     ReturntypeNonesetJacobianResidual(jacobian,J=None,P=None,args=None,kargs=None)
                     Set the callback to compute the least-squares residual Jacobian.

                     Logically collective.

                     Parameters

                            • jacobian (TAOJacobianResidualFunction) -- The Jacobian callback.

                            • J (Mat|None) -- The matrix to store the Jacobian.

                            • P (Mat|None) -- The matrix to construct the preconditioner.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:setResidual, TaoSetJacobianResidualRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:354setJacobianState(jacobian_state,J=None,P=None,I=None,args=None,kargs=None)
                     Set Jacobian state callback.

                     Logically collective.

                     SEEALSO:TaoSetJacobianStateRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:645Parameters

                            • J (Mat|None)

                            • P (Mat|None)

                            • I (Mat|None)

                            • args (tuple[Any,...]|None)

                            • kargs (dict[str,Any]|None)

                     ReturntypeNonesetLMVMH0(mat)
                     Set the initial Hessian for the quasi-Newton approximation.

                     Collective.

                     SEEALSO:getLMVMH0, TaoLMVMSetH0Sourcecodeatpetsc4py/PETSc/TAO.pyx:1346Parametersmat (Mat)

                     ReturntypeNonesetMaximumFunctionEvaluations(mit)
                     Set the maximum number of objective evaluations within the solver.

                     Collective.

                     SEEALSO:setMaximumIterations, TaoSetMaximumFunctionEvaluationsSourcecodeatpetsc4py/PETSc/TAO.pyx:1038Parametersmit (int)

                     ReturntypeNonesetMaximumIterations(mit)
                     Set the maximum number of solver iterations.

                     Collective.

                     SEEALSO:setTolerances, TaoSetMaximumIterationsSourcecodeatpetsc4py/PETSc/TAO.pyx:1011Parametersmit (int)

                     ReturntypefloatsetMonitor(monitor,args=None,kargs=None)
                     Set the callback used to monitor solver convergence.

                     Logically collective.

                     Parameters

                            • monitor (TAOMonitorFunction) -- The callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getMonitor, TaoMonitorSetSourcecodeatpetsc4py/PETSc/TAO.pyx:1179setObjective(objective,args=None,kargs=None)
                     Set the objective function evaluation callback.

                     Logically collective.

                     Parameters

                            • objective (TAOObjectiveFunction) -- The objective function callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:setGradient, setObjectiveGradient, TaoSetObjectiveSourcecodeatpetsc4py/PETSc/TAO.pyx:302setObjectiveGradient(objgrad,g=None,args=None,kargs=None)
                     Set the objective function and gradient evaluation callback.

                     Logically collective.

                     Parameters

                            • objgrad  (TAOObjectiveGradientFunction)  --  The  objective  function and gradient
                              callback.

                            • g (Vec|None) -- The vector to store the gradient.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:setObjective,      setGradient,       setHessian,       getObjectiveAndGradient,       ‐
                        TaoSetObjectiveAndGradientSourcecodeatpetsc4py/PETSc/TAO.pyx:432setOptionsPrefix(prefix)
                     Set the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, TaoSetOptionsPrefixSourcecodeatpetsc4py/PETSc/TAO.pyx:199Parametersprefix (str|None)

                     ReturntypeNonesetPythonContext(context)
                     Set the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonoptimizationsolvertype(TODO), getPythonContextSourcecodeatpetsc4py/PETSc/TAO.pyx:1687Parameterscontext (Any)

                     ReturntypeNonesetPythonType(py_type)
                     Set the fully qualified Python name of the class to be used.

                     Collective.

                     SEEALSO:PETScPythonoptimizationsolvertype(TODO),  setPythonContext,  getPythonType,  ‐
                        TaoPythonSetTypeSourcecodeatpetsc4py/PETSc/TAO.pyx:1714Parameterspy_type (str)

                     ReturntypeNonesetResidual(residual,R,args=None,kargs=None)
                     Set the residual evaluation callback for least-squares applications.

                     Logically collective.

                     Parameters

                            • residual (TAOResidualFunction) -- The residual callback.

                            • R (Vec) -- The vector to store the residual.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:setJacobianResidual, TaoSetResidualRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:327setSolution(x)
                     Set the vector used to store the solution.

                     Collective.

                     SEEALSO:getSolution, TaoSetSolutionSourcecodeatpetsc4py/PETSc/TAO.pyx:290Parametersx (Vec)

                     ReturntypeNonesetStateDesignIS(state=None,design=None)
                     Set the index sets indicating state and design variables.

                     Collective.

                     SEEALSO:TaoSetStateDesignISSourcecodeatpetsc4py/PETSc/TAO.pyx:630Parameters

                            • state (IS|None)

                            • design (IS|None)

                     ReturntypeNonesetTolerances(gatol=None,grtol=None,gttol=None)
                     Set the tolerance parameters used in the solver convergence tests.

                     Collective.

                     Parameters

                            • gatol (float) -- The absolute norm of the gradient, or DETERMINE to use the  value
                              when the object's type was set.  Defaults to CURRENT.

                            • grtol  (float)  --  The  relative norm of the gradient with respect to the initial
                              norm of the objective, or DETERMINE to use the value when the  object's  type  was
                              set. Defaults to CURRENT.

                            • gttol  (float)  --  The  relative norm of the gradient with respect to the initial
                              norm of the gradient, or DETERMINE to use the value when  the  object's  type  was
                              set. Defaults to CURRENT.

                     ReturntypeNoneSEEALSO:getTolerances, TaoSetTolerancesSourcecodeatpetsc4py/PETSc/TAO.pyx:954setType(tao_type)
                     Set the type of the solver.

                     Logically collective.

                     Parameterstao_type (Type|str) -- The type of the solver.

                     ReturntypeNoneSEEALSO:getType, TaoSetTypeSourcecodeatpetsc4py/PETSc/TAO.pyx:166setUp()
                     Set up the internal data structures for using the solver.

                     Collective.

                     SEEALSO:TaoSetUpSourcecodeatpetsc4py/PETSc/TAO.pyx:253ReturntypeNonesetUpdate(update,args=None,kargs=None)
                     Set the callback to compute update at each optimization step.

                     Logically collective.

                     Parameters

                            • update (TAOUpdateFunction) -- The update callback or None to reset it.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:getUpdate, TaoSetUpdateSourcecodeatpetsc4py/PETSc/TAO.pyx:729setVariableBounds(varbounds,args=None,kargs=None)
                     Set the upper and lower bounds for the optimization problem.

                     Logically collective.

                     Parameters

                            • varbounds  (tuple[Vec,Vec]|TAOVariableBoundsFunction) -- Either a tuple of Vec
                              or a TAOVariableBoundsFunction callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:TaoSetVariableBounds, TaoSetVariableBoundsRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:478solve(x=None)
                     Solve the optimization problem.

                     Collective.

                     Parametersx (Vec|None) -- The starting vector or None to use the vector stored internally.

                     ReturntypeNoneSEEALSO:setSolution, getSolution, TaoSolveSourcecodeatpetsc4py/PETSc/TAO.pyx:1285view(viewer=None)
                     View the solver.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:TaoViewSourcecodeatpetsc4py/PETSc/TAO.pyx:113

              Attributes Documentation

              appctx Application context.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1765cnorm  Constraints norm.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1834converged
                     Boolean indicating if the solver has converged.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1871ctol   Broken.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1809diverged
                     Boolean indicating if the solver has failed.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1876ftol   Broken.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1783function
                     Objective value.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1849gnorm  Gradient norm.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1829gradient
                     Gradient vector.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1854gtol   Broken.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1796iterating
                     Boolean indicating if the solver has not converged yet.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1866its    Number of iterations.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1824ksp    Linear solver.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1775objective
                     Objective value.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1844reason Converged reason.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1861solution
                     Solution vector.

                     Sourcecodeatpetsc4py/PETSc/TAO.pyx:1839petsc4py.PETSc.TAOLineSearchclasspetsc4py.PETSc.TAOLineSearch
              Bases: Object

              TAO Line Search.

              Enumerations
                                 ┌─────────────────┬──────────────────────────────────────┐
                                 │ ConvergedReason │ TAO Line Search Termination Reasons. │
                                 ├─────────────────┼──────────────────────────────────────┤
                                 │ Type            │ TAO Line Search Types.               │
                                 └─────────────────┴──────────────────────────────────────┘

   petsc4py.PETSc.TAOLineSearch.ConvergedReasonclasspetsc4py.PETSc.TAOLineSearch.ConvergedReason
                     Bases: object

                     TAO Line Search Termination Reasons.

                     Attributes Summary
                                  ┌─────────────────────┬───────────────────────────────────────┐
                                  │ CONTINUE_SEARCH     │ Constant CONTINUE_SEARCH of type int  │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ FAILED_ASCENT       │ Constant FAILED_ASCENT of type int    │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ FAILED_BADPARAMETER │ Constant FAILED_BADPARAMETER of  type │
                                  │                     │ int                                   │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ FAILED_INFORNAN     │ Constant FAILED_INFORNAN of type int  │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ HALTED_LOWERBOUND   │ Constant  HALTED_LOWERBOUND of type ‐ │
                                  │                     │ int                                   │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ HALTED_MAXFCN       │ Constant HALTED_MAXFCN of type int    │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ HALTED_OTHER        │ Constant HALTED_OTHER of type int     │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ HALTED_RTOL         │ Constant HALTED_RTOL of type int      │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ HALTED_UPPERBOUND   │ Constant HALTED_UPPERBOUND of type  ‐ │
                                  │                     │ int                                   │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ HALTED_USER         │ Constant HALTED_USER of type int      │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ SUCCESS             │ Constant SUCCESS of type int          │
                                  ├─────────────────────┼───────────────────────────────────────┤
                                  │ SUCCESS_USER        │ Constant SUCCESS_USER of type int     │
                                  └─────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     CONTINUE_SEARCH:int=CONTINUE_SEARCH
                            Constant CONTINUE_SEARCH of type intFAILED_ASCENT:int=FAILED_ASCENT
                            Constant FAILED_ASCENT of type intFAILED_BADPARAMETER:int=FAILED_BADPARAMETER
                            Constant FAILED_BADPARAMETER of type intFAILED_INFORNAN:int=FAILED_INFORNAN
                            Constant FAILED_INFORNAN of type intHALTED_LOWERBOUND:int=HALTED_LOWERBOUND
                            Constant HALTED_LOWERBOUND of type intHALTED_MAXFCN:int=HALTED_MAXFCN
                            Constant HALTED_MAXFCN of type intHALTED_OTHER:int=HALTED_OTHER
                            Constant HALTED_OTHER of type intHALTED_RTOL:int=HALTED_RTOL
                            Constant HALTED_RTOL of type intHALTED_UPPERBOUND:int=HALTED_UPPERBOUND
                            Constant HALTED_UPPERBOUND of type intHALTED_USER:int=HALTED_USER
                            Constant HALTED_USER of type intSUCCESS:int=SUCCESS
                            Constant SUCCESS of type intSUCCESS_USER:int=SUCCESS_USER
                            Constant SUCCESS_USER of type intpetsc4py.PETSc.TAOLineSearch.Typeclasspetsc4py.PETSc.TAOLineSearch.Type
                     Bases: object

                     TAO Line Search Types.

                     Attributes Summary
                                          ┌─────────────┬────────────────────────────────┐
                                          │ ARMIJO      │ Object ARMIJO of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ GPCG        │ Object GPCG of type str        │
                                          ├─────────────┼────────────────────────────────┤
                                          │ IPM         │ Object IPM of type str         │
                                          ├─────────────┼────────────────────────────────┤
                                          │ MORETHUENTE │ Object MORETHUENTE of type str │
                                          ├─────────────┼────────────────────────────────┤
                                          │ OWARMIJO    │ Object OWARMIJO of type str    │
                                          ├─────────────┼────────────────────────────────┤
                                          │ UNIT        │ Object UNIT of type str        │
                                          └─────────────┴────────────────────────────────┘

                     Attributes Documentation

                     ARMIJO:str=ARMIJO
                            Object ARMIJO of type strGPCG:str=GPCG
                            Object GPCG of type strIPM:str=IPM
                            Object IPM of type strMORETHUENTE:str=MORETHUENTE
                            Object MORETHUENTE of type strOWARMIJO:str=OWARMIJO
                            Object OWARMIJO of type strUNIT:str=UNIT
                            Object UNIT of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ apply(x, g, s)                        │ Performs  a  line-search  in  a given │
                      │                                       │ step direction.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create a TAO linesearch.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the linesearch object.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOptionsPrefix()                    │ Return the prefix used for  searching │
                      │                                       │ for options in the database.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the type of the linesearch.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Configure  the  linesearch  from  the │
                      │                                       │ options database.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setGradient(gradient[, args, kargs])  │ Set the gradient evaluation callback. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setObjective(objective[,        args, │ Set the objective function evaluation │
                      │ kargs])                               │ callback.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setObjectiveGradient(objgrad[,  args, │ Set  the   objective   function   and │
                      │ kargs])                               │ gradient evaluation callback.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOptionsPrefix([prefix])            │ Set the prefix used for searching for │
                      │                                       │ options in the database.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(ls_type)                      │ Set the type of the linesearch.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Set  up  the internal data structures │
                      │                                       │ for using the linesearch.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ useTAORoutine(tao)                    │ Use  the   objective   and   gradient │
                      │                                       │ evaluation  routines  from  the given │
                      │                                       │ Tao object.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ View the linesearch object.           │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              apply(x,g,s)
                     Performs a line-search in a given step direction.

                     Collective.

                     SEEALSO:TaoLineSearchApplySourcecodeatpetsc4py/PETSc/TAO.pyx:2161Parameters

                            • x (Vec)

                            • g (Vec)

                            • s (Vec)

                     Returntypetuple[float, float, str]

              create(comm=None)
                     Create a TAO linesearch.

                     Collective.

                     Parameterscomm -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:Sys.getDefaultComm, TaoLineSearchCreateSourcecodeatpetsc4py/PETSc/TAO.pyx:1964destroy()
                     Destroy the linesearch object.

                     Collective.

                     SEEALSO:TaoLineSearchDestroySourcecodeatpetsc4py/PETSc/TAO.pyx:1951ReturntypeSelfgetOptionsPrefix()
                     Return the prefix used for searching for options in the database.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, TaoLineSearchGetOptionsPrefixSourcecodeatpetsc4py/PETSc/TAO.pyx:2056ReturntypestrgetType()
                     Return the type of the linesearch.

                     Not collective.

                     SEEALSO:setType, TaoLineSearchGetTypeSourcecodeatpetsc4py/PETSc/TAO.pyx:2004ReturntypestrsetFromOptions()
                     Configure the linesearch from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, TaoLineSearchSetFromOptionsSourcecodeatpetsc4py/PETSc/TAO.pyx:2018ReturntypeNonesetGradient(gradient,args=None,kargs=None)
                     Set the gradient evaluation callback.

                     Logically collective.

                     Parameters

                            • gradient (TAOLSGradientFunction) -- The gradient callback.

                            • g -- The vector to store the gradient.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:setObjective, setObjectiveGradient, setHessian, TaoLineSearchSetGradientRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:2095setObjective(objective,args=None,kargs=None)
                     Set the objective function evaluation callback.

                     Logically collective.

                     Parameters

                            • objective (TAOLSObjectiveFunction) -- The objective function callback.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:setGradient, setObjectiveGradient, TaoLineSearchSetObjectiveRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:2070setObjectiveGradient(objgrad,args=None,kargs=None)
                     Set the objective function and gradient evaluation callback.

                     Logically collective.

                     Parameters

                            • objgrad (TAOLSObjectiveGradientFunction) -- The objective  function  and  gradient
                              callback.

                            • g -- The vector to store the gradient.

                            • args (tuple[Any,...]|None) -- Positional arguments for the callback.

                            • kargs (dict[str,Any]|None) -- Keyword arguments for the callback.

                     ReturntypeNoneSEEALSO:setObjective,       setGradient,       setHessian,       getObjectiveAndGradient,      ‐
                        TaoLineSearchSetObjectiveAndGradientRoutineSourcecodeatpetsc4py/PETSc/TAO.pyx:2122setOptionsPrefix(prefix=None)
                     Set the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, TaoLineSearchSetOptionsPrefixSourcecodeatpetsc4py/PETSc/TAO.pyx:2042Parametersprefix (str|None)

                     ReturntypeNonesetType(ls_type)
                     Set the type of the linesearch.

                     Logically collective.

                     Parametersls_type (Type|str) -- The type of the solver.

                     ReturntypeNoneSEEALSO:getType, TaoLineSearchSetTypeSourcecodeatpetsc4py/PETSc/TAO.pyx:1985setUp()
                     Set up the internal data structures for using the linesearch.

                     Collective.

                     SEEALSO:TaoLineSearchSetUpSourcecodeatpetsc4py/PETSc/TAO.pyx:2030ReturntypeNoneuseTAORoutine(tao)
                     Use the objective and gradient evaluation routines from the given Tao object.

                     Logically collective.

                     SEEALSO:TaoLineSearchUseTaoRoutinesSourcecodeatpetsc4py/PETSc/TAO.pyx:2149Parameterstao (TAO)

                     ReturntypeNoneview(viewer=None)
                     View the linesearch object.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:TaoLineSearchViewSourcecodeatpetsc4py/PETSc/TAO.pyx:1932petsc4py.PETSc.TSclasspetsc4py.PETSc.TS
              Bases: Object

              ODE integrator.

              TS is described in the PETScmanual.

              SEEALSO:TS

              Enumerations
                                 ┌─────────────────┬───────────────────────────────────────┐
                                 │ ARKIMEXType     │ The ARKIMEX subtype.                  │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ ConvergedReason │ The   reason   the   time   step   is │
                                 │                 │ converging.                           │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ DIRKType        │ The DIRK subtype.                     │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ EquationType    │ Distinguishes among types of explicit │
                                 │                 │ and implicit equations.               │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ ExactFinalTime  │ The method for ending time stepping.  │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ ProblemType     │ Distinguishes  linear  and  nonlinear │
                                 │                 │ problems.                             │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ RKType          │ The RK subtype.                       │
                                 ├─────────────────┼───────────────────────────────────────┤
                                 │ Type            │ The time stepping method.             │
                                 └─────────────────┴───────────────────────────────────────┘

   petsc4py.PETSc.TS.ARKIMEXTypeclasspetsc4py.PETSc.TS.ARKIMEXType
                     Bases: object

                     The ARKIMEX subtype.

                     Attributes Summary
                                        ┌───────────────┬──────────────────────────────────┐
                                        │ ARKIMEX1BEE   │ Object ARKIMEX1BEE of type str   │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEX2C     │ Object ARKIMEX2C of type str     │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEX2D     │ Object ARKIMEX2D of type str     │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEX2E     │ Object ARKIMEX2E of type str     │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEX3      │ Object ARKIMEX3 of type str      │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEX4      │ Object ARKIMEX4 of type str      │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEX5      │ Object ARKIMEX5 of type str      │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEXA2     │ Object ARKIMEXA2 of type str     │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEXARS122 │ Object ARKIMEXARS122 of type str │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEXARS443 │ Object ARKIMEXARS443 of type str │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEXBPR3   │ Object ARKIMEXBPR3 of type str   │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEXL2     │ Object ARKIMEXL2 of type str     │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ ARKIMEXPRSSP2 │ Object ARKIMEXPRSSP2 of type str │
                                        └───────────────┴──────────────────────────────────┘

                     Attributes Documentation

                     ARKIMEX1BEE:str=ARKIMEX1BEE
                            Object ARKIMEX1BEE of type strARKIMEX2C:str=ARKIMEX2C
                            Object ARKIMEX2C of type strARKIMEX2D:str=ARKIMEX2D
                            Object ARKIMEX2D of type strARKIMEX2E:str=ARKIMEX2E
                            Object ARKIMEX2E of type strARKIMEX3:str=ARKIMEX3
                            Object ARKIMEX3 of type strARKIMEX4:str=ARKIMEX4
                            Object ARKIMEX4 of type strARKIMEX5:str=ARKIMEX5
                            Object ARKIMEX5 of type strARKIMEXA2:str=ARKIMEXA2
                            Object ARKIMEXA2 of type strARKIMEXARS122:str=ARKIMEXARS122
                            Object ARKIMEXARS122 of type strARKIMEXARS443:str=ARKIMEXARS443
                            Object ARKIMEXARS443 of type strARKIMEXBPR3:str=ARKIMEXBPR3
                            Object ARKIMEXBPR3 of type strARKIMEXL2:str=ARKIMEXL2
                            Object ARKIMEXL2 of type strARKIMEXPRSSP2:str=ARKIMEXPRSSP2
                            Object ARKIMEXPRSSP2 of type strpetsc4py.PETSc.TS.ConvergedReasonclasspetsc4py.PETSc.TS.ConvergedReason
                     Bases: object

                     The reason the time step is converging.

                     Attributes Summary
                                ┌──────────────────────────┬───────────────────────────────────────┐
                                │ CONVERGED_EVENT          │ Constant CONVERGED_EVENT of type int  │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ CONVERGED_ITERATING      │ Constant CONVERGED_ITERATING of  type │
                                │                          │ int                                   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ CONVERGED_ITS            │ Constant CONVERGED_ITS of type int    │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ CONVERGED_TIME           │ Constant CONVERGED_TIME of type int   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ CONVERGED_USER           │ Constant CONVERGED_USER of type int   │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_NONLINEAR_SOLVE │ Constant  DIVERGED_NONLINEAR_SOLVE of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ DIVERGED_STEP_REJECTED   │ Constant  DIVERGED_STEP_REJECTED   of │
                                │                          │ type int                              │
                                ├──────────────────────────┼───────────────────────────────────────┤
                                │ ITERATING                │ Constant ITERATING of type int        │
                                └──────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     CONVERGED_EVENT:int=CONVERGED_EVENT
                            Constant CONVERGED_EVENT of type intCONVERGED_ITERATING:int=CONVERGED_ITERATING
                            Constant CONVERGED_ITERATING of type intCONVERGED_ITS:int=CONVERGED_ITS
                            Constant CONVERGED_ITS of type intCONVERGED_TIME:int=CONVERGED_TIME
                            Constant CONVERGED_TIME of type intCONVERGED_USER:int=CONVERGED_USER
                            Constant CONVERGED_USER of type intDIVERGED_NONLINEAR_SOLVE:int=DIVERGED_NONLINEAR_SOLVE
                            Constant DIVERGED_NONLINEAR_SOLVE of type intDIVERGED_STEP_REJECTED:int=DIVERGED_STEP_REJECTED
                            Constant DIVERGED_STEP_REJECTED of type intITERATING:int=ITERATING
                            Constant ITERATING of type intpetsc4py.PETSc.TS.DIRKTypeclasspetsc4py.PETSc.TS.DIRKType
                     Bases: object

                     The DIRK subtype.

                     Attributes Summary
                                        ┌───────────────┬──────────────────────────────────┐
                                        │ DIRK657A      │ Object DIRK657A of type str      │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRK658A      │ Object DIRK658A of type str      │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRK7510SAL   │ Object DIRK7510SAL of type str   │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRK759A      │ Object DIRK759A of type str      │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRK8614A     │ Object DIRK8614A of type str     │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRK8616SAL   │ Object DIRK8616SAL of type str   │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKES122SAL  │ Object DIRKES122SAL of type str  │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKES213SAL  │ Object DIRKES213SAL of type str  │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKES324SAL  │ Object DIRKES324SAL of type str  │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKES325SAL  │ Object DIRKES325SAL of type str  │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKES648SA   │ Object DIRKES648SA of type str   │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKES7510SA  │ Object DIRKES7510SA of type str  │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKES8516SAL │ Object DIRKES8516SAL of type str │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKS212      │ Object DIRKS212 of type str      │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKS659A     │ Object DIRKS659A of type str     │
                                        ├───────────────┼──────────────────────────────────┤
                                        │ DIRKS7511SAL  │ Object DIRKS7511SAL of type str  │
                                        └───────────────┴──────────────────────────────────┘

                     Attributes Documentation

                     DIRK657A:str=DIRK657A
                            Object DIRK657A of type strDIRK658A:str=DIRK658A
                            Object DIRK658A of type strDIRK7510SAL:str=DIRK7510SAL
                            Object DIRK7510SAL of type strDIRK759A:str=DIRK759A
                            Object DIRK759A of type strDIRK8614A:str=DIRK8614A
                            Object DIRK8614A of type strDIRK8616SAL:str=DIRK8616SAL
                            Object DIRK8616SAL of type strDIRKES122SAL:str=DIRKES122SAL
                            Object DIRKES122SAL of type strDIRKES213SAL:str=DIRKES213SAL
                            Object DIRKES213SAL of type strDIRKES324SAL:str=DIRKES324SAL
                            Object DIRKES324SAL of type strDIRKES325SAL:str=DIRKES325SAL
                            Object DIRKES325SAL of type strDIRKES648SA:str=DIRKES648SA
                            Object DIRKES648SA of type strDIRKES7510SA:str=DIRKES7510SA
                            Object DIRKES7510SA of type strDIRKES8516SAL:str=DIRKES8516SAL
                            Object DIRKES8516SAL of type strDIRKS212:str=DIRKS212
                            Object DIRKS212 of type strDIRKS659A:str=DIRKS659A
                            Object DIRKS659A of type strDIRKS7511SAL:str=DIRKS7511SAL
                            Object DIRKS7511SAL of type strpetsc4py.PETSc.TS.EquationTypeclasspetsc4py.PETSc.TS.EquationType
                     Bases: object

                     Distinguishes among types of explicit and implicit equations.

                     Attributes Summary
                               ┌───────────────────────────┬───────────────────────────────────────┐
                               │ DAE_IMPLICIT_INDEX1       │ Constant  DAE_IMPLICIT_INDEX1 of type │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DAE_IMPLICIT_INDEX2       │ Constant DAE_IMPLICIT_INDEX2 of  type │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DAE_IMPLICIT_INDEX3       │ Constant  DAE_IMPLICIT_INDEX3 of type │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DAE_IMPLICIT_INDEXHI      │ Constant DAE_IMPLICIT_INDEXHI of type │
                               │                           │ int                                   │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DAE_SEMI_EXPLICIT_INDEX1  │ Constant DAE_SEMI_EXPLICIT_INDEX1  of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DAE_SEMI_EXPLICIT_INDEX2  │ Constant  DAE_SEMI_EXPLICIT_INDEX2 of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DAE_SEMI_EXPLICIT_INDEX3  │ Constant DAE_SEMI_EXPLICIT_INDEX3  of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ DAE_SEMI_EXPLICIT_INDEXHI │ Constant DAE_SEMI_EXPLICIT_INDEXHI of │
                               │                           │ type int                              │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ EXPLICIT                  │ Constant EXPLICIT of type int         │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ IMPLICIT                  │ Constant IMPLICIT of type int         │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ ODE_EXPLICIT              │ Constant ODE_EXPLICIT of type int     │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ ODE_IMPLICIT              │ Constant ODE_IMPLICIT of type int     │
                               ├───────────────────────────┼───────────────────────────────────────┤
                               │ UNSPECIFIED               │ Constant UNSPECIFIED of type int      │
                               └───────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     DAE_IMPLICIT_INDEX1:int=DAE_IMPLICIT_INDEX1
                            Constant DAE_IMPLICIT_INDEX1 of type intDAE_IMPLICIT_INDEX2:int=DAE_IMPLICIT_INDEX2
                            Constant DAE_IMPLICIT_INDEX2 of type intDAE_IMPLICIT_INDEX3:int=DAE_IMPLICIT_INDEX3
                            Constant DAE_IMPLICIT_INDEX3 of type intDAE_IMPLICIT_INDEXHI:int=DAE_IMPLICIT_INDEXHI
                            Constant DAE_IMPLICIT_INDEXHI of type intDAE_SEMI_EXPLICIT_INDEX1:int=DAE_SEMI_EXPLICIT_INDEX1
                            Constant DAE_SEMI_EXPLICIT_INDEX1 of type intDAE_SEMI_EXPLICIT_INDEX2:int=DAE_SEMI_EXPLICIT_INDEX2
                            Constant DAE_SEMI_EXPLICIT_INDEX2 of type intDAE_SEMI_EXPLICIT_INDEX3:int=DAE_SEMI_EXPLICIT_INDEX3
                            Constant DAE_SEMI_EXPLICIT_INDEX3 of type intDAE_SEMI_EXPLICIT_INDEXHI:int=DAE_SEMI_EXPLICIT_INDEXHI
                            Constant DAE_SEMI_EXPLICIT_INDEXHI of type intEXPLICIT:int=EXPLICIT
                            Constant EXPLICIT of type intIMPLICIT:int=IMPLICIT
                            Constant IMPLICIT of type intODE_EXPLICIT:int=ODE_EXPLICIT
                            Constant ODE_EXPLICIT of type intODE_IMPLICIT:int=ODE_IMPLICIT
                            Constant ODE_IMPLICIT of type intUNSPECIFIED:int=UNSPECIFIED
                            Constant UNSPECIFIED of type intpetsc4py.PETSc.TS.ExactFinalTimeclasspetsc4py.PETSc.TS.ExactFinalTime
                     Bases: object

                     The method for ending time stepping.

                     Attributes Summary
                                         ┌─────────────┬──────────────────────────────────┐
                                         │ INTERPOLATE │ Constant INTERPOLATE of type int │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ MATCHSTEP   │ Constant MATCHSTEP of type int   │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ STEPOVER    │ Constant STEPOVER of type int    │
                                         ├─────────────┼──────────────────────────────────┤
                                         │ UNSPECIFIED │ Constant UNSPECIFIED of type int │
                                         └─────────────┴──────────────────────────────────┘

                     Attributes Documentation

                     INTERPOLATE:int=INTERPOLATE
                            Constant INTERPOLATE of type intMATCHSTEP:int=MATCHSTEP
                            Constant MATCHSTEP of type intSTEPOVER:int=STEPOVER
                            Constant STEPOVER of type intUNSPECIFIED:int=UNSPECIFIED
                            Constant UNSPECIFIED of type intpetsc4py.PETSc.TS.ProblemTypeclasspetsc4py.PETSc.TS.ProblemType
                     Bases: object

                     Distinguishes linear and nonlinear problems.

                     Attributes Summary
                                           ┌───────────┬────────────────────────────────┐
                                           │ LINEAR    │ Constant LINEAR of type int    │
                                           ├───────────┼────────────────────────────────┤
                                           │ NONLINEAR │ Constant NONLINEAR of type int │
                                           └───────────┴────────────────────────────────┘

                     Attributes Documentation

                     LINEAR:int=LINEAR
                            Constant LINEAR of type intNONLINEAR:int=NONLINEAR
                            Constant NONLINEAR of type intpetsc4py.PETSc.TS.RKTypeclasspetsc4py.PETSc.TS.RKType
                     Bases: object

                     The RK subtype.

                     Attributes Summary
                                                ┌───────┬──────────────────────────┐
                                                │ RK1FE │ Object RK1FE of type str │
                                                ├───────┼──────────────────────────┤
                                                │ RK2A  │ Object RK2A of type str  │
                                                ├───────┼──────────────────────────┤
                                                │ RK2B  │ Object RK2B of type str  │
                                                ├───────┼──────────────────────────┤
                                                │ RK3   │ Object RK3 of type str   │
                                                ├───────┼──────────────────────────┤
                                                │ RK3BS │ Object RK3BS of type str │
                                                ├───────┼──────────────────────────┤
                                                │ RK4   │ Object RK4 of type str   │
                                                ├───────┼──────────────────────────┤
                                                │ RK5BS │ Object RK5BS of type str │
                                                ├───────┼──────────────────────────┤
                                                │ RK5DP │ Object RK5DP of type str │
                                                ├───────┼──────────────────────────┤
                                                │ RK5F  │ Object RK5F of type str  │
                                                ├───────┼──────────────────────────┤
                                                │ RK6VR │ Object RK6VR of type str │
                                                ├───────┼──────────────────────────┤
                                                │ RK7VR │ Object RK7VR of type str │
                                                ├───────┼──────────────────────────┤
                                                │ RK8VR │ Object RK8VR of type str │
                                                └───────┴──────────────────────────┘

                     Attributes Documentation

                     RK1FE:str=RK1FE
                            Object RK1FE of type strRK2A:str=RK2A
                            Object RK2A of type strRK2B:str=RK2B
                            Object RK2B of type strRK3:str=RK3
                            Object RK3 of type strRK3BS:str=RK3BS
                            Object RK3BS of type strRK4:str=RK4
                            Object RK4 of type strRK5BS:str=RK5BS
                            Object RK5BS of type strRK5DP:str=RK5DP
                            Object RK5DP of type strRK5F:str=RK5F
                            Object RK5F of type strRK6VR:str=RK6VR
                            Object RK6VR of type strRK7VR:str=RK7VR
                            Object RK7VR of type strRK8VR:str=RK8VR
                            Object RK8VR of type strpetsc4py.PETSc.TS.Typeclasspetsc4py.PETSc.TS.Type
                     Bases: object

                     The time stepping method.

                     Attributes Summary
                                      ┌─────────────────┬────────────────────────────────────┐
                                      │ ALPHA           │ Object ALPHA of type str           │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ ALPHA2          │ Object ALPHA2 of type str          │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ ARKIMEX         │ Object ARKIMEX of type str         │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ BASICSYMPLECTIC │ Object BASICSYMPLECTIC of type str │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ BDF             │ Object BDF of type str             │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ BE              │ Object BE of type str              │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ BEULER          │ Object BEULER of type str          │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ CN              │ Object CN of type str              │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ CRANK_NICOLSON  │ Object CRANK_NICOLSON of type str  │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ DIRK            │ Object DIRK of type str            │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ DISCGRAD        │ Object DISCGRAD of type str        │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ EIMEX           │ Object EIMEX of type str           │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ EULER           │ Object EULER of type str           │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ FE              │ Object FE of type str              │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ GLEE            │ Object GLEE of type str            │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ GLLE            │ Object GLLE of type str            │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ MIMEX           │ Object MIMEX of type str           │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ MPRK            │ Object MPRK of type str            │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ PSEUDO          │ Object PSEUDO of type str          │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ PYTHON          │ Object PYTHON of type str          │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ RADAU5          │ Object RADAU5 of type str          │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ RK              │ Object RK of type str              │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ ROSW            │ Object ROSW of type str            │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ RUNGE_KUTTA     │ Object RUNGE_KUTTA of type str     │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ SSP             │ Object SSP of type str             │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ SUNDIALS        │ Object SUNDIALS of type str        │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ TH              │ Object TH of type str              │
                                      ├─────────────────┼────────────────────────────────────┤
                                      │ THETA           │ Object THETA of type str           │
                                      └─────────────────┴────────────────────────────────────┘

                     Attributes Documentation

                     ALPHA:str=ALPHA
                            Object ALPHA of type strALPHA2:str=ALPHA2
                            Object ALPHA2 of type strARKIMEX:str=ARKIMEX
                            Object ARKIMEX of type strBASICSYMPLECTIC:str=BASICSYMPLECTIC
                            Object BASICSYMPLECTIC of type strBDF:str=BDF
                            Object BDF of type strBE:str=BE
                            Object BE of type strBEULER:str=BEULER
                            Object BEULER of type strCN:str=CN
                            Object CN of type strCRANK_NICOLSON:str=CRANK_NICOLSON
                            Object CRANK_NICOLSON of type strDIRK:str=DIRK
                            Object DIRK of type strDISCGRAD:str=DISCGRAD
                            Object DISCGRAD of type strEIMEX:str=EIMEX
                            Object EIMEX of type strEULER:str=EULER
                            Object EULER of type strFE:str=FE
                            Object FE of type strGLEE:str=GLEE
                            Object GLEE of type strGLLE:str=GLLE
                            Object GLLE of type strMIMEX:str=MIMEX
                            Object MIMEX of type strMPRK:str=MPRK
                            Object MPRK of type strPSEUDO:str=PSEUDO
                            Object PSEUDO of type strPYTHON:str=PYTHON
                            Object PYTHON of type strRADAU5:str=RADAU5
                            Object RADAU5 of type strRK:str=RK
                            Object RK of type strROSW:str=ROSW
                            Object ROSW of type strRUNGE_KUTTA:str=RUNGE_KUTTA
                            Object RUNGE_KUTTA of type strSSP:str=SSP
                            Object SSP of type strSUNDIALS:str=SUNDIALS
                            Object SUNDIALS of type strTH:str=TH
                            Object TH of type strTHETA:str=THETA
                            Object THETA of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ adjointReset()                        │ Reset  a  TS,  removing any allocated │
                      │                                       │ vectors and matrices.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ adjointSetSteps(adjoint_steps)        │ Set the number of steps  the  adjoint │
                      │                                       │ solver should take backward in time.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ adjointSetUp()                        │ Set  up  the internal data structures │
                      │                                       │ for  the  later  use  of  an  adjoint │
                      │                                       │ solver.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ adjointSolve()                        │ Solve  the  discrete  adjoint problem │
                      │                                       │ for an ODE/DAE.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ adjointStep()                         │ Step one time step  backward  in  the │
                      │                                       │ adjoint run.                          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ appendOptionsPrefix(prefix)           │ Append to the prefix used for all the │
                      │                                       │ TS options.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clone()                               │ Return  a  shallow  clone  of  the TS │
                      │                                       │ object.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeI2Function(t,     x,     xdot, │ Evaluate the DAE residual in implicit │
                      │ xdotdot, f)                           │ form.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeI2Jacobian(t,     x,     xdot, │ Evaluate the Jacobian of the DAE.     │
                      │ xdotdot, v, a, J)                     │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeIFunction(t,  x,   xdot,   f[, │ Evaluate  the DAE residual written in │
                      │ imex])                                │ implicit form.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeIJacobian(t, x, xdot,  a,  J[, │ Evaluate the Jacobian of the DAE.     │
                      │ P, imex])                             │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeIJacobianP(t,  x, xdot, a, J[, │ Evaluate the Jacobian with respect to │
                      │ imex])                                │ parameters.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeRHSFunction(t, x, f)           │ Evaluate    the    right-hand    side │
                      │                                       │ function.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeRHSFunctionLinear(t, x, f)     │ Evaluate  the right-hand side via the │
                      │                                       │ user-provided Jacobian.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeRHSJacobian(t, x, J[, P])      │ Compute the Jacobian matrix that  has │
                      │                                       │ been set with setRHSJacobian.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeRHSJacobianConstant(t,  x, J[, │ Reuse    a    Jacobian    that     is │
                      │ P])                                   │ time-independent.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ computeRHSJacobianP(t, x, J)          │ Run    the   user-defined   JacobianP │
                      │                                       │ function.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create an empty TS.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createPython([context, comm])         │ Create an integrator of Python type.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createQuadratureTS([forward])         │ Create  a  sub  TS   that   evaluates │
                      │                                       │ integrals over time.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy  the TS that was created with │
                      │                                       │ create.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getARKIMEXType()                      │ Return the Type.ARKIMEX scheme.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getAlphaParams()                      │ Return the algorithmic parameters for │
                      │                                       │ Type.ALPHA.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getAppCtx()                           │ Return the application context.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getConvergedReason()                  │ Return the reason  the  TS  step  was │
                      │                                       │ stopped.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCostGradients()                    │ Return the cost gradients.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCostIntegral()                     │ Return  a  vector  of  values  of the │
                      │                                       │ integral term in the cost functions.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDIRKType()                         │ Return the Type.DIRK scheme.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDM()                               │ Return the DM associated with the TS. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getEquationType()                     │ Get the type of the equation that  TS │
                      │                                       │ is solving.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getI2Function()                       │ Return  the vector and function which │
                      │                                       │ computes the residual.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getI2Jacobian()                       │ Return  the  matrices  and   function │
                      │                                       │ which computes the Jacobian.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getIFunction()                        │ Return  the vector and function which │
                      │                                       │ computes the implicit residual.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getIJacobian()                        │ Return  the  matrices  and   function │
                      │                                       │ which computes the implicit Jacobian. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getKSP()                              │ Return  the  KSP  associated with the │
                      │                                       │ TS.                                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getKSPIterations()                    │ Return the  total  number  of  linear │
                      │                                       │ iterations used by the TS.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMaxSteps()                         │ Return the maximum number of steps to │
                      │                                       │ use.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMaxTime()                          │ Return the maximum (final) time.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getMonitor()                          │ Return the monitor.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNumEvents()                        │ Return the number of events.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOptionsPrefix()                    │ Return the prefix used for all the TS │
                      │                                       │ options.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPostStep()                         │ Return the poststep function.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPreStep()                          │ Return the prestep function.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPrevTime()                         │ Return   the  starting  time  of  the │
                      │                                       │ previously completed step.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getProblemType()                      │ Return the  type  of  problem  to  be │
                      │                                       │ solved.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPythonContext()                    │ Return  the  instance  of  the  class │
                      │                                       │ implementing  the   required   Python │
                      │                                       │ methods.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getPythonType()                       │ Return  the  fully  qualified  Python │
                      │                                       │ name of the class used by the solver. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getQuadratureTS()                     │ Return  the  sub  TS  that  evaluates │
                      │                                       │ integrals over time.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRHSFunction()                      │ Return  the  vector  where the rhs is │
                      │                                       │ stored  and  the  function  used   to │
                      │                                       │ compute it.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRHSJacobian()                      │ Return  the Jacobian and the function │
                      │                                       │ used to compute them.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getRKType()                           │ Return the Type.RK scheme.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSNES()                             │ Return the SNES associated  with  the │
                      │                                       │ TS.                                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSNESFailures()                     │ Return  the  total  number  of failed │
                      │                                       │ SNES solves in the TS.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSNESIterations()                   │ Return the total number of  nonlinear │
                      │                                       │ iterations used by the TS.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSolution()                         │ Return  the  solution  at the present │
                      │                                       │ timestep.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSolution2()                        │ Return   the   solution   and    time │
                      │                                       │ derivative at the present timestep.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSolveTime()                        │ Return  the  time  after  a  call  to │
                      │                                       │ solve.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStepLimits()                       │ Return  the   minimum   and   maximum │
                      │                                       │ allowed time step sizes.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStepNumber()                       │ Return   the  number  of  time  steps │
                      │                                       │ completed.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getStepRejections()                   │ Return the total number  of  rejected │
                      │                                       │ steps.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTheta()                            │ Return  the  abscissa of the stage in │
                      │                                       │ (0,1] for Type.THETA.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getThetaEndpoint()                    │ Return whether the endpoint  variable │
                      │                                       │ of Type.THETA is used.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTime()                             │ Return  the time of the most recently │
                      │                                       │ completed step.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTimeSpan()                         │ Return the time span.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTimeSpanSolutions()                │ Return the solutions at the times  in │
                      │                                       │ the time span.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTimeStep()                         │ Return  the  duration  of the current │
                      │                                       │ timestep.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getTolerances()                       │ Return  the  tolerances   for   local │
                      │                                       │ truncation error.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the TS type.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ interpolate(t, u)                     │ Interpolate  the  solution to a given │
                      │                                       │ time.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ load(viewer)                          │ Load a TS that  has  been  stored  in │
                      │                                       │ binary with view.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ monitor(step, time[, u])              │ Monitor the solve.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ monitorCancel()                       │ Clear all the monitors that have been │
                      │                                       │ set.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ removeTrajectory()                    │ Remove  the  internal  TS  trajectory │
                      │                                       │ object.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reset()                               │ Reset the TS, removing any  allocated │
                      │                                       │ vectors and matrices.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restartStep()                         │ Flag  the  solver to restart the next │
                      │                                       │ step.                                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ rollBack()                            │ Roll back one time step.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setARKIMEXFastSlowSplit(flag)         │ Use ARKIMEX for solving  a  fast-slow │
                      │                                       │ system.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setARKIMEXFullyImplicit(flag)         │ Solve  both  parts  of  the  equation │
                      │                                       │ implicitly.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setARKIMEXType(ts_type)               │ Set the type of Type.ARKIMEX scheme.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setAlphaParams([alpha_m,     alpha_f, │ Set  the  algorithmic  parameters for │
                      │ gamma])                               │ Type.ALPHA.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setAlphaRadius(radius)                │ Set   the   spectral    radius    for │
                      │                                       │ Type.ALPHA.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setAppCtx(appctx)                     │ Set the application context.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setConvergedReason(reason)            │ Set   the  reason  for  handling  the │
                      │                                       │ convergence of solve.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setCostGradients(vl[, vm])            │ Set the cost gradients.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDIRKType(ts_type)                  │ Set the type of Type.DIRK scheme.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDM(dm)                             │ Set the DM that may be used  by  some │
                      │                                       │ nonlinear solvers or preconditioners. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setEquationType(eqtype)               │ Set  the type of the equation that TS │
                      │                                       │ is solving.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setErrorIfStepFails([flag])           │ Immediately   error   is   no    step │
                      │                                       │ succeeds.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setEventHandler(direction, terminate, │ Set  a  function  used  for detecting │
                      │ indicator)                            │ events.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setEventTolerances([tol, vtol])       │ Set   tolerances   for   event   zero │
                      │                                       │ crossings when using event handler.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setExactFinalTime(option)             │ Set  method  of  computing  the final │
                      │                                       │ time step.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Set various TS parameters  from  user │
                      │                                       │ options.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setI2Function(function[,   f,   args, │ Set the function to compute  the  2nd │
                      │ kargs])                               │ order DAE.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setI2Jacobian(jacobian[,  J, P, args, │ Set  the  function  to  compute   the │
                      │ kargs])                               │ Jacobian of the 2nd order DAE.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setIFunction(function[,    f,   args, │ Set the function representing the DAE │
                      │ kargs])                               │ to be solved.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setIJacobian(jacobian[, J,  P,  args, │ Set   the  function  to  compute  the │
                      │ kargs])                               │ Jacobian.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setIJacobianP(jacobian[,   J,   args, │ Set  the  function  that computes the │
                      │ kargs])                               │ Jacobian.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMaxSNESFailures(n)                 │ Set the maximum number of SNES solves │
                      │                                       │ failures allowed.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMaxStepRejections(n)               │ Set  the  maximum  number   of   step │
                      │                                       │ rejections before a time step fails.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMaxSteps(max_steps)                │ Set  the  maximum  number of steps to │
                      │                                       │ use.                                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMaxTime(max_time)                  │ Set the maximum (final) time.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMonitor(monitor[, args, kargs])    │ Set an additional monitor to the TS.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOptionsPrefix(prefix)              │ Set the prefix used for  all  the  TS │
                      │                                       │ options.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPostStep(poststep[, args, kargs])  │ Set  a  function  to be called at the │
                      │                                       │ end of each time step.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPreStep(prestep[, args, kargs])    │ Set a function to be  called  at  the │
                      │                                       │ beginning of each time step.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setProblemType(ptype)                 │ Set the type of problem to be solved. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPythonContext(context)             │ Set   the   instance   of  the  class │
                      │                                       │ implementing  the   required   Python │
                      │                                       │ methods.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setPythonType(py_type)                │ Set  the  fully qualified Python name │
                      │                                       │ of the class to be used.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRHSFunction(function[,  f,   args, │ Set  the  routine  for evaluating the │
                      │ kargs])                               │ function G in U_t=G(t,u).          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRHSJacobian(jacobian[, J, P, args, │ Set  the  function  to  compute   the │
                      │ kargs])                               │ Jacobian of G in U_t=G(U,t).       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRHSJacobianP(jacobianp[,  A, args, │ Set the function  that  computes  the │
                      │ kargs])                               │ Jacobian    with   respect   to   the │
                      │                                       │ parameters.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRHSSplitIFunction(splitname,       │ Set the split implicit functions.     │
                      │ function[, ...])                      │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRHSSplitIJacobian(splitname,       │ Set  the  Jacobian  for   the   split │
                      │ jacobian[, ...])                      │ implicit function.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRHSSplitIS(splitname, iss)         │ Set  the  index set for the specified │
                      │                                       │ split.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRHSSplitRHSFunction(splitname,     │ Set   the    split    right-hand-side │
                      │ function)                             │ functions.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRKType(ts_type)                    │ Set   the  type  of  the  Runge-Kutta │
                      │                                       │ scheme.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSaveTrajectory()                   │ Enable  to  save  solutions   as   an │
                      │                                       │ internal TS trajectory.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSolution(u)                        │ Set the initial solution vector.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSolution2(u, v)                    │ Set the initial solution and its time │
                      │                                       │ derivative.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStepLimits(hmin, hmax)             │ Set  the  minimum and maximum allowed │
                      │                                       │ step sizes.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setStepNumber(step_number)            │ Set the number of steps completed.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTheta(theta)                       │ Set the abscissa of the stage in  (0, │
                      │                                       │ 1] for Type.THETA.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setThetaEndpoint([flag])              │ Set  to  use  the endpoint variant of │
                      │                                       │ Type.THETA.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTime(t)                            │ Set the time.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTimeSpan(tspan)                    │ Set the time span.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTimeStep(time_step)                │ Set the duration of the timestep.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setTolerances([rtol, atol])           │ Set tolerances for  local  truncation │
                      │                                       │ error    when   using   an   adaptive │
                      │                                       │ controller.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(ts_type)                      │ Set the method to be used as  the  TS │
                      │                                       │ solver.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Set  up  the internal data structures │
                      │                                       │ for the TS.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ solve([u])                            │ Step   the   requested   number    of │
                      │                                       │ timesteps.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ step()                                │ Take one step.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ Print the TS object.                  │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                  ┌───────────────┬──────────────────────────────────────┐
                                  │ appctx        │ Application context.                 │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ atol          │ The absolute tolerance.              │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ converged     │ Indicates the TS has converged.      │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ diverged      │ Indicates the TS has stopped.        │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ dm            │ The DM.                              │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ equation_type │ The equation type.                   │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ iterating     │ Indicates the TS is still iterating. │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ ksp           │ The KSP.                             │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ max_steps     │ The maximum number of steps.         │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ max_time      │ The maximum time.                    │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ problem_type  │ The problem type.                    │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ reason        │ The converged reason.                │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ rtol          │ The relative tolerance.              │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ snes          │ The SNES.                            │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ step_number   │ The current step number.             │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ time          │ The current time.                    │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ time_step     │ The current time step size.          │
                                  ├───────────────┼──────────────────────────────────────┤
                                  │ vec_sol       │ The solution vector.                 │
                                  └───────────────┴──────────────────────────────────────┘

              Methods Documentation

              adjointReset()
                     Reset a TS, removing any allocated vectors and matrices.

                     Collective.

                     SEEALSO:TSAdjointResetSourcecodeatpetsc4py/PETSc/TS.pyx:2849ReturntypeNoneadjointSetSteps(adjoint_steps)
                     Set the number of steps the adjoint solver should take backward in time.

                     Logically collective.

                     Parametersadjoint_steps (int) -- The number of steps to take.

                     ReturntypeNoneSEEALSO:TSAdjointSetStepsSourcecodeatpetsc4py/PETSc/TS.pyx:2795adjointSetUp()
                     Set up the internal data structures for the later use of an adjoint solver.

                     Collective.

                     SEEALSO:TSAdjointSetUpSourcecodeatpetsc4py/PETSc/TS.pyx:2813ReturntypeNoneadjointSolve()
                     Solve the discrete adjoint problem for an ODE/DAE.

                     Collective.

                     SEEALSO:TSAdjointSolveSourcecodeatpetsc4py/PETSc/TS.pyx:2825ReturntypeNoneadjointStep()
                     Step one time step backward in the adjoint run.

                     Collective.

                     SEEALSO:TSAdjointStepSourcecodeatpetsc4py/PETSc/TS.pyx:2837ReturntypeNoneappendOptionsPrefix(prefix)
                     Append to the prefix used for all the TS options.

                     Logically collective.

                     Parametersprefix (str|None) -- The prefix to append to the current prefix.

                     ReturntypeNone

                     Notes

                     A hyphen must not be given at the beginning of the prefix name.

                     SEEALSO:WorkingwithPETScoptions, TSAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/TS.pyx:539clone()
                     Return a shallow clone of the TS object.

                     Collective.

                     SEEALSO:TSCloneSourcecodeatpetsc4py/PETSc/TS.pyx:243ReturntypeTScomputeI2Function(t,x,xdot,xdotdot,f)
                     Evaluate the DAE residual in implicit form.

                     Collective.

                     Parameters

                            • t (float) -- The current time.

                            • x (Vec) -- The state vector.

                            • xdot (Vec) -- The time derivative of the state vector.

                            • xdotdot (Vec) -- The second time derivative of the state vector.

                            • f (Vec) -- The vector into which the residual is stored.

                     ReturntypeNoneSEEALSO:TSComputeI2FunctionSourcecodeatpetsc4py/PETSc/TS.pyx:1142computeI2Jacobian(t,x,xdot,xdotdot,v,a,J,P=None)
                     Evaluate the Jacobian of the DAE.

                     Collective.

                     If F(t,U,V,A)=0 is the DAE, the required Jacobian is dF/dU+vdF/dV+adF/dA.

                     Parameters

                            • t (float) -- The current time.

                            • x (Vec) -- The state vector.

                            • xdot (Vec) -- The time derivative of the state vector.

                            • xdotdot (Vec) -- The second time derivative of the state vector.

                            • v (float) -- The shift to apply to the first derivative.

                            • a (float) -- The shift to apply to the second derivative.

                            • J (Mat) -- The matrix into which the Jacobian is computed.

                            • P (Mat|None) -- The optional matrix to use for building a preconditioner matrix.

                     ReturntypeNoneSEEALSO:TSComputeI2JacobianSourcecodeatpetsc4py/PETSc/TS.pyx:1169computeIFunction(t,x,xdot,f,imex=False)
                     Evaluate the DAE residual written in implicit form.

                     Collective.

                     Parameters

                            • t (float) -- The current time.

                            • x (Vec) -- The state vector.

                            • xdot (Vec) -- The time derivative of the state vector.

                            • f (Vec) -- The vector into which the residual is stored.

                            • imex (bool) -- A flag which indicates if the RHS should be kept separate.

                     ReturntypeNoneSEEALSO:TSComputeIFunctionSourcecodeatpetsc4py/PETSc/TS.pyx:927computeIJacobian(t,x,xdot,a,J,P=None,imex=False)
                     Evaluate the Jacobian of the DAE.

                     Collective.

                     If F(t,U,Udot)=0 is the DAE, the required Jacobian is dF/dU+shift*dF/dUdotParameters

                            • t (float) -- The current time.

                            • x (Vec) -- The state vector.

                            • xdot (Vec) -- The time derivative of the state vector.

                            • a (float) -- The shift to apply

                            • J (Mat) -- The matrix into which the Jacobian is computed.

                            • P (Mat|None) -- The optional matrix to use for building a preconditioner matrix.

                            • imex (bool) -- A flag which indicates if the RHS should be kept separate.

                     ReturntypeNoneSEEALSO:TSComputeIJacobianSourcecodeatpetsc4py/PETSc/TS.pyx:957computeIJacobianP(t,x,xdot,a,J,imex=False)
                     Evaluate the Jacobian with respect to parameters.

                     Collective.

                     Parameters

                            • t (float) -- The current time.

                            • x (Vec) -- The state vector.

                            • xdot (Vec) -- The time derivative of the state vector.

                            • a (float) -- The shift to apply

                            • J (Mat) -- The matrix into which the Jacobian is computed.

                            • imex (bool) -- A flag which indicates if the RHS should be kept separate.

                     ReturntypeNoneSEEALSO:TSComputeIJacobianPSourcecodeatpetsc4py/PETSc/TS.pyx:997computeRHSFunction(t,x,f)
                     Evaluate the right-hand side function.

                     Collective.

                     Parameters

                            • t (float) -- The time at which to evaluate the RHS.

                            • x (Vec) -- The state vector.

                            • f (Vec) -- The Vec into which the RHS is computed.

                     ReturntypeNoneSEEALSO:TSComputeRHSFunctionSourcecodeatpetsc4py/PETSc/TS.pyx:674computeRHSFunctionLinear(t,x,f)
                     Evaluate the right-hand side via the user-provided Jacobian.

                     Collective.

                     Parameters

                            • t (float) -- The time at which to evaluate the RHS.

                            • x (Vec) -- The state vector.

                            • f (Vec) -- The Vec into which the RHS is computed.

                     ReturntypeNoneSEEALSO:TSComputeRHSFunctionLinearSourcecodeatpetsc4py/PETSc/TS.pyx:696computeRHSJacobian(t,x,J,P=None)
                     Compute the Jacobian matrix that has been set with setRHSJacobian.

                     Collective.

                     Parameters

                            • t (float) -- The time at which to evaluate the Jacobian.

                            • x (Vec) -- The state vector.

                            • J (Mat) -- The matrix into which the Jacobian is computed.

                            • P (Mat|None) -- The optional matrix to use for building a preconditioner matrix.

                     ReturntypeNoneSEEALSO:TSComputeRHSJacobianSourcecodeatpetsc4py/PETSc/TS.pyx:718computeRHSJacobianConstant(t,x,J,P=None)
                     Reuse a Jacobian that is time-independent.

                     Collective.

                     Parameters

                            • t (float) -- The time at which to evaluate the Jacobian.

                            • x (Vec) -- The state vector.

                            • J (Mat) -- A pointer to the stored Jacobian.

                            • P (Mat|None) -- An optional pointer to the preconditioner matrix.

                     ReturntypeNoneSEEALSO:TSComputeRHSJacobianConstantSourcecodeatpetsc4py/PETSc/TS.pyx:744computeRHSJacobianP(t,x,J)
                     Run the user-defined JacobianP function.

                     Collective.

                     Parameters

                            • t (float) -- The time at which to compute the Jacobian.

                            • x (Vec) -- The solution at which to compute the Jacobian.

                            • J (Mat) -- The output Jacobian matrix.

                     ReturntypeNoneSEEALSO:TSComputeRHSJacobianPSourcecodeatpetsc4py/PETSc/TS.pyx:2773create(comm=None)
                     Create an empty TS.

                     Collective.

                     The problem type can then be set with setProblemType and the type of solver can then be set
                     with setType.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:TSCreateSourcecodeatpetsc4py/PETSc/TS.pyx:219createPython(context=None,comm=None)
                     Create an integrator of Python type.

                     Collective.

                     Parameters

                            • context  (Any)  --  An  instance  of  the  Python  class implementing the required
                              methods.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:PETScPythonode-integratortype(TODO), setType, setPythonContext, Type.PYTHONSourcecodeatpetsc4py/PETSc/TS.pyx:2863createQuadratureTS(forward=True)
                     Create a sub TS that evaluates integrals over time.

                     Collective.

                     Parametersforward (bool) -- Enable to evaluate forward in time.

                     ReturntypeTSSEEALSO:TSCreateQuadratureTSSourcecodeatpetsc4py/PETSc/TS.pyx:2692destroy()
                     Destroy the TS that was created with create.

                     Collective.

                     SEEALSO:TSDestroySourcecodeatpetsc4py/PETSc/TS.pyx:206ReturntypeSelfgetARKIMEXType()
                     Return the Type.ARKIMEX scheme.

                     Not collective.

                     SEEALSO:TSARKIMEXGetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:389ReturntypestrgetAlphaParams()
                     Return the algorithmic parameters for Type.ALPHA.

                     Not collective.

                     SEEALSO:TSAlphaGetParamsSourcecodeatpetsc4py/PETSc/TS.pyx:3070Returntypetuple[float, float, float]

              getAppCtx()
                     Return the application context.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:589ReturntypeAnygetConvergedReason()
                     Return the reason the TS step was stopped.

                     Not collective.

                     Can only be called once solve is complete.

                     SEEALSO:TSGetConvergedReasonSourcecodeatpetsc4py/PETSc/TS.pyx:2090ReturntypeConvergedReasongetCostGradients()
                     Return the cost gradients.

                     Not collective.

                     SEEALSO:setCostGradients, TSGetCostGradientsSourcecodeatpetsc4py/PETSc/TS.pyx:2634Returntypetuple[list[Vec], list[Vec]]

              getCostIntegral()
                     Return a vector of values of the integral term in the cost functions.

                     Not collective.

                     SEEALSO:TSGetCostIntegralSourcecodeatpetsc4py/PETSc/TS.pyx:2573ReturntypeVecgetDIRKType()
                     Return the Type.DIRK scheme.

                     Not collective.

                     SEEALSO:setDIRKType, TSDIRKGetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:426ReturntypestrgetDM()
                     Return the DM associated with the TS.

                     Not collective.

                     Only valid if nonlinear solvers or preconditioners are used which use the DM.

                     SEEALSO:TSGetDMSourcecodeatpetsc4py/PETSc/TS.pyx:1589ReturntypeDMgetEquationType()
                     Get the type of the equation that TS is solving.

                     Not collective.

                     SEEALSO:TSGetEquationTypeSourcecodeatpetsc4py/PETSc/TS.pyx:488ReturntypeEquationTypegetI2Function()
                     Return the vector and function which computes the residual.

                     Not collective.

                     SEEALSO:TSGetI2FunctionSourcecodeatpetsc4py/PETSc/TS.pyx:1218Returntypetuple[Vec, TSI2Function]

              getI2Jacobian()
                     Return the matrices and function which computes the Jacobian.

                     Not collective.

                     SEEALSO:TSGetI2JacobianSourcecodeatpetsc4py/PETSc/TS.pyx:1234Returntypetuple[Mat, Mat, TSI2Jacobian]

              getIFunction()
                     Return the vector and function which computes the implicit residual.

                     Not collective.

                     SEEALSO:TSGetIFunctionSourcecodeatpetsc4py/PETSc/TS.pyx:1031Returntypetuple[Vec, TSIFunction]

              getIJacobian()
                     Return the matrices and function which computes the implicit Jacobian.

                     Not collective.

                     SEEALSO:TSGetIJacobianSourcecodeatpetsc4py/PETSc/TS.pyx:1047Returntypetuple[Mat, Mat, TSIJacobian]

              getKSP()
                     Return the KSP associated with the TS.

                     Not collective.

                     SEEALSO:TSGetKSPSourcecodeatpetsc4py/PETSc/TS.pyx:1572ReturntypeKSPgetKSPIterations()
                     Return the total number of linear iterations used by the TS.

                     Not collective.

                     This counter is reset to zero for each successive call to solve.

                     SEEALSO:TSGetKSPIterationsSourcecodeatpetsc4py/PETSc/TS.pyx:1857ReturntypeintgetMaxSteps()
                     Return the maximum number of steps to use.

                     Not collective.

                     SEEALSO:TSGetMaxStepsSourcecodeatpetsc4py/PETSc/TS.pyx:1826ReturntypeintgetMaxTime()
                     Return the maximum (final) time.

                     Not collective.

                     Defaults to 5.

                     SEEALSO:TSGetMaxTimeSourcecodeatpetsc4py/PETSc/TS.pyx:1790ReturntypefloatgetMonitor()
                     Return the monitor.

                     Not collective.

                     SEEALSO:setMonitorSourcecodeatpetsc4py/PETSc/TS.pyx:2142Returntypelist[tuple[TSMonitorFunction, tuple[Any, ...], dict[str, Any]]]

              getNumEvents()
                     Return the number of events.

                     Logically collective.

                     SEEALSO:TSGetNumEventsSourcecodeatpetsc4py/PETSc/TS.pyx:2289ReturntypeintgetOptionsPrefix()
                     Return the prefix used for all the TS options.

                     Not collective.

                     SEEALSO:TSGetOptionsPrefixSourcecodeatpetsc4py/PETSc/TS.pyx:525ReturntypestrgetPostStep()
                     Return the poststep function.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:2382Returntypetuple[TSPostStepFunction, tuple[Any, ...] | None, dict[str, Any] | None]

              getPreStep()
                     Return the prestep function.

                     Not collective.

                     SEEALSO:setPreStepSourcecodeatpetsc4py/PETSc/TS.pyx:2338Returntypetuple[TSPreStepFunction, tuple[Any, ...] | None, dict[str, Any] | None]

              getPrevTime()
                     Return the starting time of the previously completed step.

                     Not collective.

                     SEEALSO:TSGetPrevTimeSourcecodeatpetsc4py/PETSc/TS.pyx:1664ReturntypefloatgetProblemType()
                     Return the type of problem to be solved.

                     Not collective.

                     SEEALSO:TSGetProblemTypeSourcecodeatpetsc4py/PETSc/TS.pyx:457ReturntypeProblemTypegetPythonContext()
                     Return the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonode-integratortype(TODO), setPythonContextSourcecodeatpetsc4py/PETSc/TS.pyx:2900ReturntypeAnygetPythonType()
                     Return the fully qualified Python name of the class used by the solver.

                     Not collective.

                     SEEALSO:PETScPythonode-integratortype(TODO),   setPythonContext,   setPythonType,   ‐
                        TSPythonGetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:2929ReturntypestrgetQuadratureTS()
                     Return the sub TS that evaluates integrals over time.

                     Not collective.

                     Returns

                            • forward (bool) -- True if evaluating the integral forward in time

                            • qts (TS) -- The sub TSReturntypetuple[bool, TS]

                     SEEALSO:TSGetQuadratureTSSourcecodeatpetsc4py/PETSc/TS.pyx:2713getRHSFunction()
                     Return the vector where the rhs is stored and the function used to compute it.

                     Not collective.

                     SEEALSO:TSGetRHSFunctionSourcecodeatpetsc4py/PETSc/TS.pyx:770Returntypetuple[Vec, TSRHSFunction]

              getRHSJacobian()
                     Return the Jacobian and the function used to compute them.

                     Not collective.

                     SEEALSO:TSGetRHSJacobianSourcecodeatpetsc4py/PETSc/TS.pyx:786Returntypetuple[Mat, Mat, TSRHSJacobian]

              getRKType()
                     Return the Type.RK scheme.

                     Not collective.

                     SEEALSO:TSRKGetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:375ReturntypestrgetSNES()
                     Return the SNES associated with the TS.

                     Not collective.

                     SEEALSO:TSGetSNESSourcecodeatpetsc4py/PETSc/TS.pyx:1557ReturntypeSNESgetSNESFailures()
                     Return the total number of failed SNES solves in the TS.

                     Not collective.

                     This counter is reset to zero for each successive call to solve.

                     SEEALSO:TSGetSNESFailuresSourcecodeatpetsc4py/PETSc/TS.pyx:1931ReturntypeintgetSNESIterations()
                     Return the total number of nonlinear iterations used by the TS.

                     Not collective.

                     This counter is reset to zero for each successive call to solve.

                     SEEALSO:TSGetSNESIterationsSourcecodeatpetsc4py/PETSc/TS.pyx:1840ReturntypeintgetSolution()
                     Return the solution at the present timestep.

                     Not collective.

                     It  is  valid  to call this routine inside the function that you are evaluating in order to
                     move to the new timestep. This vector is  not  changed  until  the  solution  at  the  next
                     timestep has been calculated.

                     SEEALSO:TSGetSolutionSourcecodeatpetsc4py/PETSc/TS.pyx:1428ReturntypeVecgetSolution2()
                     Return the solution and time derivative at the present timestep.

                     Not collective.

                     It  is  valid  to call this routine inside the function that you are evaluating in order to
                     move to the new timestep. These vectors are not changed until  the  solution  at  the  next
                     timestep has been calculated.

                     SEEALSO:TS2GetSolutionSourcecodeatpetsc4py/PETSc/TS.pyx:1466Returntypetuple[Vec, Vec]

              getSolveTime()
                     Return the time after a call to solve.

                     Not collective.

                     This time corresponds to the final time set with setMaxTime.

                     SEEALSO:TSGetSolveTimeSourcecodeatpetsc4py/PETSc/TS.pyx:1678ReturntypefloatgetStepLimits()
                     Return the minimum and maximum allowed time step sizes.

                     Not collective.

                     SEEALSO:TSAdaptGetStepLimitsSourcecodeatpetsc4py/PETSc/TS.pyx:2523Returntypetuple[float, float]

              getStepNumber()
                     Return the number of time steps completed.

                     Not collective.

                     SEEALSO:TSGetStepNumberSourcecodeatpetsc4py/PETSc/TS.pyx:1754ReturntypeintgetStepRejections()
                     Return the total number of rejected steps.

                     Not collective.

                     This counter is reset to zero for each successive call to solve.

                     SEEALSO:TSGetStepRejectionsSourcecodeatpetsc4py/PETSc/TS.pyx:1896ReturntypeintgetTheta()
                     Return the abscissa of the stage in (0,1] for Type.THETA.

                     Not collective.

                     SEEALSO:TSThetaGetThetaSourcecodeatpetsc4py/PETSc/TS.pyx:2967ReturntypefloatgetThetaEndpoint()
                     Return whether the endpoint variable of Type.THETA is used.

                     Not collective.

                     SEEALSO:TSThetaGetEndpointSourcecodeatpetsc4py/PETSc/TS.pyx:2999ReturntypeboolgetTime()
                     Return the time of the most recently completed step.

                     Not collective.

                     When  called  during time step evaluation (e.g. during residual evaluation or via hooks set
                     using setPreStep or setPostStep), the time returned is at the start of the step.

                     SEEALSO:TSGetTimeSourcecodeatpetsc4py/PETSc/TS.pyx:1646ReturntypefloatgetTimeSpan()
                     Return the time span.

                     Not collective.

                     SEEALSO:TSGetTimeSpanSourcecodeatpetsc4py/PETSc/TS.pyx:1521ReturntypeArrayRealgetTimeSpanSolutions()
                     Return the solutions at the times in the time span.

                     Not collective.

                     SEEALSO:setTimeSpan, TSGetTimeSpanSolutionsSourcecodeatpetsc4py/PETSc/TS.pyx:1537Returntypelist[Vec]

              getTimeStep()
                     Return the duration of the current timestep.

                     Not collective.

                     SEEALSO:TSGetTimeStepSourcecodeatpetsc4py/PETSc/TS.pyx:1713ReturntypefloatgetTolerances()
                     Return the tolerances for local truncation error.

                     Logically collective.

                     Returns

                            • rtol (float) -- the relative tolerance

                            • atol (float) -- the absolute tolerance

                     Returntypetuple[float, float]

                     SEEALSO:TSGetTolerancesSourcecodeatpetsc4py/PETSc/TS.pyx:2013getType()
                     Return the TS type.

                     Not collective.

                     SEEALSO:TSGetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:361Returntypestrinterpolate(t,u)
                     Interpolate the solution to a given time.

                     Collective.

                     Parameters

                            • t (float) -- The time to interpolate.

                            • u (Vec) -- The state vector to interpolate.

                     ReturntypeNoneSEEALSO:TSInterpolateSourcecodeatpetsc4py/PETSc/TS.pyx:2480load(viewer)
                     Load a TS that has been stored in binary with view.

                     Collective.

                     Parametersviewer (Viewer) -- The visualization context.

                     ReturntypeNoneSEEALSO:TSLoadSourcecodeatpetsc4py/PETSc/TS.pyx:189monitor(step,time,u=None)
                     Monitor the solve.

                     Collective.

                     Parameters

                            • step (int) -- The step number that has just completed.

                            • time (float) -- The model time of the state.

                            • u (Vec|None) -- The state at the current model time.

                     ReturntypeNoneSEEALSO:TSMonitorSourcecodeatpetsc4py/PETSc/TS.pyx:2169monitorCancel()
                     Clear all the monitors that have been set.

                     Logically collective.

                     SEEALSO:TSMonitorCancelSourcecodeatpetsc4py/PETSc/TS.pyx:2154ReturntypeNoneremoveTrajectory()
                     Remove the internal TS trajectory object.

                     Collective.

                     SEEALSO:TSRemoveTrajectorySourcecodeatpetsc4py/PETSc/TS.pyx:2561ReturntypeNonereset()
                     Reset the TS, removing any allocated vectors and matrices.

                     Collective.

                     SEEALSO:TSResetSourcecodeatpetsc4py/PETSc/TS.pyx:2398ReturntypeNonerestartStep()
                     Flag the solver to restart the next step.

                     Collective.

                     Multistep methods like TSBDF or Runge-Kutta methods with FSAL property  require  restarting
                     the  solver  in  the event of discontinuities. These discontinuities may be introduced as a
                     consequence of explicitly modifications to the solution vector  (which  PETSc  attempts  to
                     detect  and  handle)  or  problem coefficients (which PETSc is not able to detect). For the
                     sake of correctness and maximum safety, users are expected  to  call  TSRestart()  whenever
                     they introduce discontinuities in callback routines (e.g. prestep and poststep routines, or
                     implicit/rhs function routines with discontinuous source terms).

                     SEEALSO:TSRestartStepSourcecodeatpetsc4py/PETSc/TS.pyx:2426ReturntypeNonerollBack()
                     Roll back one time step.

                     Collective.

                     SEEALSO:TSRollBackSourcecodeatpetsc4py/PETSc/TS.pyx:2449ReturntypeNonesetARKIMEXFastSlowSplit(flag)
                     Use ARKIMEX for solving a fast-slow system.

                     Logically collective.

                     Parametersflag (bool) -- Set to True for fast-slow partitioned systems.

                     ReturntypeNoneSEEALSO:TSARKIMEXSetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:344setARKIMEXFullyImplicit(flag)
                     Solve both parts of the equation implicitly.

                     Logically collective.

                     Parametersflag (bool) -- Set to True for fully implicit.

                     ReturntypeNoneSEEALSO:TSARKIMEXSetFullyImplicitSourcecodeatpetsc4py/PETSc/TS.pyx:326setARKIMEXType(ts_type)
                     Set the type of Type.ARKIMEX scheme.

                     Logically collective.

                     Parametersts_type (ARKIMEXType|str) -- The type of Type.ARKIMEX scheme.

                     ReturntypeNone

                     Notes

                     -ts_arkimex_type sets scheme type from the commandline.

                     SEEALSO:TSARKIMEXSetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:303setAlphaParams(alpha_m=None,alpha_f=None,gamma=None)
                     Set the algorithmic parameters for Type.ALPHA.

                     Logically collective.

                     Users should call setAlphaRadius.

                     Parameters

                            • alpha_m (float|None) -- Parameter, leave None  to keep current value.

                            • alpha_f (float|None) -- Parameter, leave None  to keep current value.

                            • gamma (float|None) -- Parameter, leave None  to keep current value.

                     ReturntypeNoneSEEALSO:TSAlphaSetParamsSourcecodeatpetsc4py/PETSc/TS.pyx:3037setAlphaRadius(radius)
                     Set the spectral radius for Type.ALPHA.

                     Logically collective.

                     Parametersradius (float) -- the spectral radius

                     ReturntypeNone

                     Notes

                     -ts_alpha_radius can be used to set this from the commandline.

                     SEEALSO:TSAlphaSetRadiusSourcecodeatpetsc4py/PETSc/TS.pyx:3015setAppCtx(appctx)
                     Set the application context.

                     Not collective.

                     Parametersappctx (Any) -- The application context.

                     ReturntypeNoneSourcecodeatpetsc4py/PETSc/TS.pyx:576setConvergedReason(reason)
                     Set the reason for handling the convergence of solve.

                     Logically collective.

                     Can only be called when solve is active and reason must contain common value.

                     Parametersreason (ConvergedReason) -- The reason for convergence.

                     ReturntypeNoneSEEALSO:TSSetConvergedReasonSourcecodeatpetsc4py/PETSc/TS.pyx:2069setCostGradients(vl,vm=None)
                     Set the cost gradients.

                     Logically collective.

                     Parameters

                            • vl (Vec|Sequence[Vec]|None) -- gradients with respect to the initial condition
                              variables,  the  dimension and parallel layout of these vectors is the same as the
                              ODE solution vector

                            • vm (Vec|Sequence[Vec]|None) -- gradients with respect to the  parameters,  the
                              number of entries in these vectors is the same as the number of parameters

                     ReturntypeNoneSEEALSO:TSSetCostGradientsSourcecodeatpetsc4py/PETSc/TS.pyx:2588setDIRKType(ts_type)
                     Set the type of Type.DIRK scheme.

                     Logically collective.

                     Parametersts_type (DIRKType|str) -- The type of Type.DIRK scheme.

                     ReturntypeNone

                     Notes

                     -ts_dirk_type sets scheme type from the commandline.

                     SEEALSO:TSDIRKSetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:403setDM(dm)
                     Set the DM that may be used by some nonlinear solvers or preconditioners.

                     Logically collective.

                     Parametersdm (DM) -- The DM object.

                     ReturntypeNoneSEEALSO:TSSetDMSourcecodeatpetsc4py/PETSc/TS.pyx:1609setEquationType(eqtype)
                     Set the type of the equation that TS is solving.

                     Logically collective.

                     Parameterseqtype (EquationType) -- The type of equation.

                     ReturntypeNoneSEEALSO:TSSetEquationTypeSourcecodeatpetsc4py/PETSc/TS.pyx:471setErrorIfStepFails(flag=True)
                     Immediately error is no step succeeds.

                     Not collective.

                     Parametersflag (bool) -- Enable to error if no step succeeds.

                     ReturntypeNone

                     Notes

                     -ts_error_if_step_fails to enable from the commandline.

                     SEEALSO:TSSetErrorIfStepFailsSourcecodeatpetsc4py/PETSc/TS.pyx:1948setEventHandler(direction,terminate,indicator,postevent=None,args=None,kargs=None)
                     Set a function used for detecting events.

                     Logically collective.

                     Parameters

                            • direction  (Sequence[int])  --  Direction  of zero crossing to be detected {-1, 0,
                              +1}.

                            • terminate (Sequence[bool]) -- Flags for each event to indicate stepping should  be
                              terminated.

                            • indicator   (TSIndicatorFunction|None)   --   Function   for   defining  the
                              indicator-functions marking the events

                            • postevent (TSPostEventFunction) -- Function to execute after the event

                            • args (tuple[Any,...]|None) -- Additional positional arguments for indicator.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for indicator.

                     ReturntypeNoneSEEALSO:TSSetEventHandlerSourcecodeatpetsc4py/PETSc/TS.pyx:2198setEventTolerances(tol=None,vtol=None)
                     Set tolerances for event zero crossings when using event handler.

                     Logically collective.

                     setEventHandler must have already been called.

                     Parameters

                            • tol (float) -- The scalar tolerance or None to leave at the current value

                            • vtol (Sequence[float]) -- A sequence of scalar tolerance for each event.  Used  in
                              preference to tol if present. Set to None to leave at the current value.

                     ReturntypeNone

                     Notes

                     -ts_event_tol can be used to set values from the commandline.

                     SEEALSO:TSSetEventTolerancesSourcecodeatpetsc4py/PETSc/TS.pyx:2253setExactFinalTime(option)
                     Set method of computing the final time step.

                     Logically collective.

                     Parametersoption (ExactFinalTime) -- The exact final time option

                     ReturntypeNone

                     Notes

                     -ts_exact_final_time may be used to specify from the commandline.

                     SEEALSO:TSSetExactFinalTimeSourcecodeatpetsc4py/PETSc/TS.pyx:2047setFromOptions()
                     Set various TS parameters from user options.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, TSSetFromOptionsSourcecodeatpetsc4py/PETSc/TS.pyx:562ReturntypeNonesetI2Function(function,f=None,args=None,kargs=None)
                     Set the function to compute the 2nd order DAE.

                     Logically collective.

                     Parameters

                            • function (TSI2Function|None) -- The right-hand side function.

                            • f (Vec|None) -- The vector to store values or None to be created internally.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for function.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for function.

                     ReturntypeNoneSEEALSO:TSSetI2FunctionSourcecodeatpetsc4py/PETSc/TS.pyx:1063setI2Jacobian(jacobian,J=None,P=None,args=None,kargs=None)
                     Set the function to compute the Jacobian of the 2nd order DAE.

                     Logically collective.

                     Parameters

                            • jacobian (TSI2Jacobian|None) -- The function which computes the Jacobian.

                            • J (Mat|None) -- The matrix into which the Jacobian is computed.

                            • P (Mat|None) -- The optional matrix to use for building a preconditioner matrix.

                            • args -- Additional positional arguments for jacobian.

                            • kargs -- Additional keyword arguments for jacobian.

                     ReturntypeNoneSEEALSO:TSSetI2JacobianSourcecodeatpetsc4py/PETSc/TS.pyx:1100setIFunction(function,f=None,args=None,kargs=None)
                     Set the function representing the DAE to be solved.

                     Logically collective.

                     Parameters

                            • function (TSIFunction|None) -- The right-hand side function.

                            • f (Vec|None) -- The vector to store values or None to be created internally.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for function.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for function.

                     ReturntypeNoneSEEALSO:TSSetIFunctionSourcecodeatpetsc4py/PETSc/TS.pyx:804setIJacobian(jacobian,J=None,P=None,args=None,kargs=None)
                     Set the function to compute the Jacobian.

                     Logically collective.

                     Set the function to compute the matrix dF/dU+a*dF/dU_t where F(t,U,U_t) is the function
                     provided with setIFunction.

                     Parameters

                            • jacobian (TSIJacobian|None) -- The function which computes the Jacobian.

                            • J (Mat|None) -- The matrix into which the Jacobian is computed.

                            • P (Mat|None) -- The optional matrix to use for building a preconditioner matrix.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for jacobian.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for jacobian.

                     ReturntypeNoneSEEALSO:TSSetIJacobianSourcecodeatpetsc4py/PETSc/TS.pyx:841setIJacobianP(jacobian,J=None,args=None,kargs=None)
                     Set the function that computes the Jacobian.

                     Logically collective.

                     Set  the  function  that  computes the Jacobian of F with respect to the parameters P where
                     F(Udot,U,t)=G(U,P,t), as well as the location to store the matrix.

                     Parameters

                            • jacobian -- The function which computes the Jacobian.

                            • J (Mat|None) -- The matrix into which the Jacobian is computed.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for jacobian.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for jacobian.

                     ReturntypeNoneSEEALSO:TSSetIJacobianPSourcecodeatpetsc4py/PETSc/TS.pyx:886setMaxSNESFailures(n)
                     Set the maximum number of SNES solves failures allowed.

                     Not collective.

                     Parametersn (int) -- The maximum number of failed nonlinear solver, use -1 for unlimited.

                     ReturntypeNoneSEEALSO:TSSetMaxSNESFailuresSourcecodeatpetsc4py/PETSc/TS.pyx:1913setMaxStepRejections(n)
                     Set the maximum number of step rejections before a time step fails.

                     Not collective.

                     Parametersn (int) -- The maximum number of rejected steps, use -1 for unlimited.

                     ReturntypeNone

                     Notes

                     -ts_max_reject can be used to set this from the commandline

                     SEEALSO:TSSetMaxStepRejectionsSourcecodeatpetsc4py/PETSc/TS.pyx:1874setMaxSteps(max_steps)
                     Set the maximum number of steps to use.

                     Logically collective.

                     Defaults to 5000.

                     Parametersmax_steps (int) -- The maximum number of steps to use.

                     ReturntypeNoneSEEALSO:TSSetMaxStepsSourcecodeatpetsc4py/PETSc/TS.pyx:1806setMaxTime(max_time)
                     Set the maximum (final) time.

                     Logically collective.

                     Parametersmax_time (float) -- the final time

                     ReturntypeNone

                     Notes

                     -ts_max_time sets the max time from the commandline

                     SEEALSO:TSSetMaxTimeSourcecodeatpetsc4py/PETSc/TS.pyx:1768setMonitor(monitor,args=None,kargs=None)
                     Set an additional monitor to the TS.

                     Logically collective.

                     Parameters

                            • monitor (TSMonitorFunction|None) -- The custom monitor function.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for monitor.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for monitor.

                     ReturntypeNoneSEEALSO:TSMonitorSetSourcecodeatpetsc4py/PETSc/TS.pyx:2108setOptionsPrefix(prefix)
                     Set the prefix used for all the TS options.

                     Logically collective.

                     Parametersprefix (str|None) -- The prefix to prepend to all option names.

                     ReturntypeNone

                     Notes

                     A hyphen must not be given at the beginning of the prefix name.

                     SEEALSO:WorkingwithPETScoptions, TSSetOptionsPrefixSourcecodeatpetsc4py/PETSc/TS.pyx:502setPostStep(poststep,args=None,kargs=None)
                     Set a function to be called at the end of each time step.

                     Logically collective.

                     Parameters

                            • poststep (TSPostStepFunction|None) -- The function to be called at  the  end  of
                              each step.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for poststep.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for poststep.

                     ReturntypeNoneSEEALSO:TSSetPostStepSourcecodeatpetsc4py/PETSc/TS.pyx:2350setPreStep(prestep,args=None,kargs=None)
                     Set a function to be called at the beginning of each time step.

                     Logically collective.

                     Parameters

                            • prestep  (TSPreStepFunction|None) -- The function to be called at the beginning
                              of each step.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for prestep.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for prestep.

                     ReturntypeNoneSEEALSO:TSSetPreStepSourcecodeatpetsc4py/PETSc/TS.pyx:2305setProblemType(ptype)
                     Set the type of problem to be solved.

                     Logically collective.

                     Parametersptype (ProblemType) -- The type of problem of the forms.

                     ReturntypeNoneSEEALSO:TSSetProblemTypeSourcecodeatpetsc4py/PETSc/TS.pyx:440setPythonContext(context)
                     Set the instance of the class implementing the required Python methods.

                     Not collective.

                     SEEALSO:PETScPythonode-integratortype(TODO), getPythonContextSourcecodeatpetsc4py/PETSc/TS.pyx:2888Parameterscontext (Any)

                     ReturntypeNonesetPythonType(py_type)
                     Set the fully qualified Python name of the class to be used.

                     Collective.

                     SEEALSO:PETScPythonode-integratortype(TODO),   setPythonContext,   getPythonType,   ‐
                        TSPythonSetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:2915Parameterspy_type (str)

                     ReturntypeNonesetRHSFunction(function,f=None,args=None,kargs=None)
                     Set the routine for evaluating the function G in U_t=G(t,u).

                     Logically collective.

                     Parameters

                            • function (TSRHSFunction|None) -- The right-hand side function.

                            • f (Vec|None) -- The vector into which the right-hand side is computed.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for function.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for function.

                     ReturntypeNoneSEEALSO:TSSetRHSFunctionSourcecodeatpetsc4py/PETSc/TS.pyx:595setRHSJacobian(jacobian,J=None,P=None,args=None,kargs=None)
                     Set the function to compute the Jacobian of G in U_t=G(U,t).

                     Logically collective.

                     Parameters

                            • jacobian (TSRHSJacobian|None) -- The right-hand side function.

                            • J (Mat|None) -- The matrix into which the jacobian is computed.

                            • P (Mat|None) -- The matrix into which the preconditioner is computed.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for jacobian.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for jacobian.

                     ReturntypeNoneSEEALSO:TSSetRHSJacobianSourcecodeatpetsc4py/PETSc/TS.pyx:632setRHSJacobianP(jacobianp,A=None,args=None,kargs=None)
                     Set the function that computes the Jacobian with respect to the parameters.

                     Logically collective.

                     Parameters

                            • jacobianp (TSRHSJacobianP|None) -- The user-defined function.

                            • A (Mat|None) -- The matrix into which the Jacobian will be computed.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for jacobianp.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for jacobianp.

                     ReturntypeNoneSEEALSO:TSSetRHSJacobianPSourcecodeatpetsc4py/PETSc/TS.pyx:2655setRHSSplitIFunction(splitname,function,r=None,args=None,kargs=None)
                     Set the split implicit functions.

                     Logically collective.

                     Parameters

                            • splitname (str) -- Name of the split.

                            • function (TSIFunction) -- The implicit function evaluation routine.

                            • r (Vec|None) -- Vector to hold the residual.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for function.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for function.

                     ReturntypeNoneSEEALSO:TSRHSSplitSetIFunctionSourcecodeatpetsc4py/PETSc/TS.pyx:1316setRHSSplitIJacobian(splitname,jacobian,J=None,P=None,args=None,kargs=None)
                     Set the Jacobian for the split implicit function.

                     Logically collective.

                     Parameters

                            • splitname (str) -- Name of the split.

                            • jacobian (TSRHSJacobian) -- The Jacobian evaluation routine.

                            • J (Mat|None) -- Matrix to store Jacobian entries computed by jacobian.

                            • P (Mat|None) -- Matrix used to compute preconditioner (usually the same as J).

                            • args (tuple[Any,...]|None) -- Additional positional arguments for jacobian.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for jacobian.

                     ReturntypeNoneSEEALSO:TSRHSSplitSetIJacobianSourcecodeatpetsc4py/PETSc/TS.pyx:1360setRHSSplitIS(splitname,iss)
                     Set the index set for the specified split.

                     Logically collective.

                     Parameters

                            • splitname (str) -- Name of this split, if None the number of the split is used.

                            • iss (IS) -- The index set for part of the solution vector.

                     ReturntypeNoneSEEALSO:TSRHSSplitSetISSourcecodeatpetsc4py/PETSc/TS.pyx:1251setRHSSplitRHSFunction(splitname,function,r=None,args=None,kargs=None)
                     Set the split right-hand-side functions.

                     Logically collective.

                     Parameters

                            • splitname (str) -- Name of the split.

                            • function (TSRHSFunction) -- The RHS function evaluation routine.

                            • r (Vec|None) -- Vector to hold the residual.

                            • args (tuple[Any,...]|None) -- Additional positional arguments for function.

                            • kargs (dict[str,Any]|None) -- Additional keyword arguments for function.

                     ReturntypeNoneSEEALSO:TSRHSSplitSetRHSFunctionSourcecodeatpetsc4py/PETSc/TS.pyx:1272setRKType(ts_type)
                     Set the type of the Runge-Kutta scheme.

                     Logically collective.

                     Parametersts_type (RKType|str) -- The type of scheme.

                     ReturntypeNone

                     Notes

                     -ts_rk_type sets scheme type from the commandline.

                     SEEALSO:TSRKSetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:280setSaveTrajectory()
                     Enable to save solutions as an internal TS trajectory.

                     Collective.

                     This routine should be called after all TS options have been set.

                     Notes

                     -ts_save_trajectory can be used to save a trajectory to a file.

                     SEEALSO:TSSetSaveTrajectorySourcecodeatpetsc4py/PETSc/TS.pyx:2542ReturntypeNonesetSolution(u)
                     Set the initial solution vector.

                     Logically collective.

                     Parametersu (Vec) -- The solution vector.

                     ReturntypeNoneSEEALSO:TSSetSolutionSourcecodeatpetsc4py/PETSc/TS.pyx:1411setSolution2(u,v)
                     Set the initial solution and its time derivative.

                     Logically collective.

                     Parameters

                            • u (Vec) -- The solution vector.

                            • v (Vec) -- The time derivative vector.

                     ReturntypeNoneSEEALSO:TS2SetSolutionSourcecodeatpetsc4py/PETSc/TS.pyx:1447setStepLimits(hmin,hmax)
                     Set the minimum and maximum allowed step sizes.

                     Logically collective.

                     Parameters

                            • hmin (float) -- the minimum step size

                            • hmax (float) -- the maximum step size

                     ReturntypeNoneSEEALSO:TSAdaptSetStepLimitsSourcecodeatpetsc4py/PETSc/TS.pyx:2500setStepNumber(step_number)
                     Set the number of steps completed.

                     Logically collective.

                     For  most  uses  of  the TS solvers the user need not explicitly call setStepNumber, as the
                     step counter is appropriately updated in solve/step/rollBack. Power  users  may  call  this
                     routine  to  reinitialize timestepping by setting the step counter to zero (and time to the
                     initial time) to solve a similar problem with different initial conditions  or  parameters.
                     It  may  also  be used to continue timestepping from a previously interrupted run in such a
                     way that TS monitors will be called with a initial nonzero step counter.

                     Parametersstep_number (int) -- the number of steps completed

                     ReturntypeNoneSEEALSO:TSSetStepNumberSourcecodeatpetsc4py/PETSc/TS.pyx:1727setTheta(theta)
                     Set the abscissa of the stage in (0,1] for Type.THETA.

                     Logically collective.

                     Parameterstheta (float) -- stage abscissa

                     ReturntypeNone

                     Notes

                     -ts_theta_theta can be used to set a value from the commandline.

                     SEEALSO:TSThetaSetThetaSourcecodeatpetsc4py/PETSc/TS.pyx:2945setThetaEndpoint(flag=True)
                     Set to use the endpoint variant of Type.THETA.

                     Logically collective.

                     Parametersflag -- Enable to use the endpoint variant.

                     ReturntypeNoneSEEALSO:TSThetaSetEndpointSourcecodeatpetsc4py/PETSc/TS.pyx:2981setTime(t)
                     Set the time.

                     Logically collective.

                     Parameterst (float) -- The time.

                     ReturntypeNoneSEEALSO:TSSetTimeSourcecodeatpetsc4py/PETSc/TS.pyx:1628setTimeSpan(tspan)
                     Set the time span.

                     Collective.

                     The solution will be computed and stored for each time requested in  the  span.  The  times
                     must  be  all  increasing  and  correspond to the intermediate points for time integration.
                     ExactFinalTime.MATCHSTEP must be used to make the last time step in each sub-interval match
                     the intermediate points specified. The intermediate solutions are saved in a  vector  array
                     that can be accessed with getTimeSpanSolutions.

                     Parameterstspan (Sequence[float]) -- The sequence of time points.

                     ReturntypeNone

                     Notes

                     -ts_time_span<t0,...,tf> sets the time span from the commandline

                     SEEALSO:TSSetTimeSpanSourcecodeatpetsc4py/PETSc/TS.pyx:1489setTimeStep(time_step)
                     Set the duration of the timestep.

                     Logically collective.

                     Parameterstime_step (float) -- the duration of the timestep

                     ReturntypeNoneSEEALSO:TSSetTimeStepSourcecodeatpetsc4py/PETSc/TS.pyx:1695setTolerances(rtol=None,atol=None)
                     Set tolerances for local truncation error when using an adaptive controller.

                     Logically collective.

                     Parameters

                            • rtol  (float)  --  The  relative  tolerance,  DETERMINE  to use the value when the
                              object's type was set, or None to leave the current value.

                            • atol (float) -- The absolute tolerance,  DETERMINE  to  use  the  value  when  the
                              object's type was set, or None to leave the current value.

                     ReturntypeNone

                     Notes

                     -ts_rtol and -ts_atol may be used to set values from the commandline.

                     SEEALSO:TSSetTolerancesSourcecodeatpetsc4py/PETSc/TS.pyx:1970setType(ts_type)
                     Set the method to be used as the TS solver.

                     Collective.

                     Parametersts_type (Type|str) -- The solver type.

                     ReturntypeNone

                     Notes

                     -ts_type sets the method from the commandline

                     SEEALSO:TSSetTypeSourcecodeatpetsc4py/PETSc/TS.pyx:257setUp()
                     Set up the internal data structures for the TS.

                     Collective.

                     SEEALSO:TSSetUpSourcecodeatpetsc4py/PETSc/TS.pyx:2386ReturntypeNonesolve(u=None)
                     Step the requested number of timesteps.

                     Collective.

                     Parametersu (Vec|None) -- The solution vector. Can be None.

                     ReturntypeNoneSEEALSO:TSSolveSourcecodeatpetsc4py/PETSc/TS.pyx:2461step() Take one step.

                     Collective.

                     The  preferred  interface  for  the TS solvers is solve. If you need to execute code at the
                     beginning or ending of each step, use setPreStep and setPostStep respectively.

                     SEEALSO:TSStepSourcecodeatpetsc4py/PETSc/TS.pyx:2410ReturntypeNoneview(viewer=None)
                     Print the TS object.

                     Collective.

                     Parametersviewer (Viewer|None) -- The visualization context.

                     ReturntypeNone

                     Notes

                     -ts_view calls TSView at the end of TSStep

                     SEEALSO:TSViewSourcecodeatpetsc4py/PETSc/TS.pyx:166

              Attributes Documentation

              appctx Application context.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3086atol   The absolute tolerance.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3189converged
                     Indicates the TS has converged.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3210diverged
                     Indicates the TS has stopped.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3215dm     The DM.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3096equation_type
                     The equation type.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3114iterating
                     Indicates the TS is still iterating.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3205ksp    The KSP.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3127max_steps
                     The maximum number of steps.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3171max_time
                     The maximum time.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3163problem_type
                     The problem type.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3106reason The converged reason.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3197rtol   The relative tolerance.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3181snes   The SNES.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3122step_number
                     The current step number.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3155time   The current time.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3139time_step
                     The current time step size.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3147vec_sol
                     The solution vector.

                     Sourcecodeatpetsc4py/PETSc/TS.pyx:3132petsc4py.PETSc.Vecclasspetsc4py.PETSc.Vec
              Bases: Object

              A vector object.

              SEEALSO:Vec

              Enumerations
                                            ┌────────┬─────────────────────────┐
                                            │ Option │ Vector assembly option. │
                                            ├────────┼─────────────────────────┤
                                            │ Type   │ The vector type.        │
                                            └────────┴─────────────────────────┘

   petsc4py.PETSc.Vec.Optionclasspetsc4py.PETSc.Vec.Option
                     Bases: object

                     Vector assembly option.

                     Attributes Summary
                                ┌─────────────────────────┬───────────────────────────────────────┐
                                │ IGNORE_NEGATIVE_INDICES │ Constant  IGNORE_NEGATIVE_INDICES  of │
                                │                         │ type int                              │
                                ├─────────────────────────┼───────────────────────────────────────┤
                                │ IGNORE_OFF_PROC_ENTRIES │ Constant  IGNORE_OFF_PROC_ENTRIES  of │
                                │                         │ type int                              │
                                └─────────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     IGNORE_NEGATIVE_INDICES:int=IGNORE_NEGATIVE_INDICES
                            Constant IGNORE_NEGATIVE_INDICES of type intIGNORE_OFF_PROC_ENTRIES:int=IGNORE_OFF_PROC_ENTRIES
                            Constant IGNORE_OFF_PROC_ENTRIES of type intpetsc4py.PETSc.Vec.Typeclasspetsc4py.PETSc.Vec.Type
                     Bases: object

                     The vector type.

                     Attributes Summary
                                          ┌─────────────┬────────────────────────────────┐
                                          │ CUDA        │ Object CUDA of type str        │
                                          ├─────────────┼────────────────────────────────┤
                                          │ HIP         │ Object HIP of type str         │
                                          ├─────────────┼────────────────────────────────┤
                                          │ KOKKOS      │ Object KOKKOS of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ MPI         │ Object MPI of type str         │
                                          ├─────────────┼────────────────────────────────┤
                                          │ MPICUDA     │ Object MPICUDA of type str     │
                                          ├─────────────┼────────────────────────────────┤
                                          │ MPIHIP      │ Object MPIHIP of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ MPIKOKKOS   │ Object MPIKOKKOS of type str   │
                                          ├─────────────┼────────────────────────────────┤
                                          │ MPIVIENNACL │ Object MPIVIENNACL of type str │
                                          ├─────────────┼────────────────────────────────┤
                                          │ NEST        │ Object NEST of type str        │
                                          ├─────────────┼────────────────────────────────┤
                                          │ SEQ         │ Object SEQ of type str         │
                                          ├─────────────┼────────────────────────────────┤
                                          │ SEQCUDA     │ Object SEQCUDA of type str     │
                                          ├─────────────┼────────────────────────────────┤
                                          │ SEQHIP      │ Object SEQHIP of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ SEQKOKKOS   │ Object SEQKOKKOS of type str   │
                                          ├─────────────┼────────────────────────────────┤
                                          │ SEQVIENNACL │ Object SEQVIENNACL of type str │
                                          ├─────────────┼────────────────────────────────┤
                                          │ SHARED      │ Object SHARED of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ STANDARD    │ Object STANDARD of type str    │
                                          ├─────────────┼────────────────────────────────┤
                                          │ VIENNACL    │ Object VIENNACL of type str    │
                                          └─────────────┴────────────────────────────────┘

                     Attributes Documentation

                     CUDA:str=CUDA
                            Object CUDA of type strHIP:str=HIP
                            Object HIP of type strKOKKOS:str=KOKKOS
                            Object KOKKOS of type strMPI:str=MPI
                            Object MPI of type strMPICUDA:str=MPICUDA
                            Object MPICUDA of type strMPIHIP:str=MPIHIP
                            Object MPIHIP of type strMPIKOKKOS:str=MPIKOKKOS
                            Object MPIKOKKOS of type strMPIVIENNACL:str=MPIVIENNACL
                            Object MPIVIENNACL of type strNEST:str=NEST
                            Object NEST of type strSEQ:str=SEQ
                            Object SEQ of type strSEQCUDA:str=SEQCUDA
                            Object SEQCUDA of type strSEQHIP:str=SEQHIP
                            Object SEQHIP of type strSEQKOKKOS:str=SEQKOKKOS
                            Object SEQKOKKOS of type strSEQVIENNACL:str=SEQVIENNACL
                            Object SEQVIENNACL of type strSHARED:str=SHARED
                            Object SHARED of type strSTANDARD:str=STANDARD
                            Object STANDARD of type strVIENNACL:str=VIENNACL
                            Object VIENNACL of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ abs()                                 │ Replace each entry (xₙ) in the vector │
                      │                                       │ by abs|xₙ|.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ appendOptionsPrefix(prefix)           │ Append  to  the   prefix   used   for │
                      │                                       │ searching    for   options   in   the │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ assemble()                            │ Assemble the vector.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ assemblyBegin()                       │ Begin  an  assembling  stage  of  the │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ assemblyEnd()                         │ Finish the assembling stage initiated │
                      │                                       │ with assemblyBegin.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ attachDLPackInfo([vec, dltensor])     │ Attach    tensor   information   from │
                      │                                       │ another vector or DLPack tensor.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ axpby(alpha, beta, x)                 │ Compute and store y = ɑ·x + β·y.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ axpy(alpha, x)                        │ Compute and store y = ɑ·x + y.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ aypx(alpha, x)                        │ Compute and store y = x + ɑ·y.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ bindToCPU(flg)                        │ Bind vector operations  execution  on │
                      │                                       │ the CPU.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ boundToCPU()                          │ Return  whether  the  vector has been │
                      │                                       │ bound to the CPU.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ chop(tol)                             │ Set all vector entries less than some │
                      │                                       │ absolute tolerance to zero.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clearDLPackInfo()                     │ Clear tensor information.             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ concatenate(vecs)                     │ Concatenate  vectors  into  a  single │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ conjugate()                           │ Conjugate the vector.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ copy([result])                        │ Return a copy of the vector.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create a vector object.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createCUDAWithArrays([cpuarray,       │ Create   a   Type.CUDA   vector  with │
                      │ cudahandle, ...])                     │ optional arrays.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createGhost(ghosts,   size[,   bsize, │ Create  a  parallel vector with ghost │
                      │ comm])                                │ padding on each processor.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createGhostWithArray(ghosts,  array[, │ Create  a  parallel vector with ghost │
                      │ size, ...])                           │ padding and provided arrays.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createHIPWithArrays([cpuarray,        │ Create   a   Type.HIP   vector   with │
                      │ hiphandle, ...])                      │ optional arrays.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createLocalVector()                   │ Create a local vector.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createMPI(size[, bsize, comm])        │ Create a parallel Type.MPI vector.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createNest(vecs[, isets, comm])       │ Create  a Type.NEST vector containing │
                      │                                       │ multiple nested subvectors.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createSeq(size[, bsize, comm])        │ Create a sequential Type.SEQ vector.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createShared(size[, bsize, comm])     │ Create a Type.SHARED vector that uses │
                      │                                       │ shared memory.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createViennaCLWithArrays([cpuarray,   │ Create a  Type.VIENNACL  vector  with │
                      │ ...])                                 │ optional arrays.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createWithArray(array[,  size, bsize, │ Create  a  vector  using  a  provided │
                      │ comm])                                │ array.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createWithDLPack(dltensor[,     size, │ Create a  vector  wrapping  a  DLPack │
                      │ bsize, comm])                         │ object, sharing the same memory.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the vector.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ dot(vec)                              │ Return the dot product with vec.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ dotBegin(vec)                         │ Begin computing the dot product.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ dotEnd(vec)                           │ Finish   computing  the  dot  product │
                      │                                       │ initiated with dotBegin.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ dotNorm2(vec)                         │ Return the dot product with  vec  and │
                      │                                       │ its squared norm.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ duplicate([array])                    │ Create  a  new  vector  with the same │
                      │                                       │ type, optionally with data.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ equal(vec)                            │ Return whether the vector is equal to │
                      │                                       │ another.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ exp()                                 │ Replace each entry (xₙ) in the vector │
                      │                                       │ by exp(xₙ).                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getArray([readonly])                  │ Return local portion of the vector as │
                      │                                       │ an ndarray.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBlockSize()                        │ Return the block size of the vector.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getBuffer([readonly])                 │ Return a buffered view of  the  local │
                      │                                       │ portion of the vector.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCLContextHandle()                  │ Return  the OpenCL context associated │
                      │                                       │ with the vector.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCLMemHandle([mode])                │ Return the OpenCL  buffer  associated │
                      │                                       │ with the vector.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCLQueueHandle()                    │ Return   the   OpenCL  command  queue │
                      │                                       │ associated with the vector.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getCUDAHandle([mode])                 │ Return  a  pointer  to   the   device │
                      │                                       │ buffer.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getDM()                               │ Return   the  DM  associated  to  the │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getGhostIS()                          │ Return ghosting indices  of  a  ghost │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getHIPHandle([mode])                  │ Return   a   pointer  to  the  device │
                      │                                       │ buffer.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLGMap()                            │ Return the local-to-global mapping.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalSize()                        │ Return the local size of the vector.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getLocalVector(lvec[, readonly])      │ Maps the local portion of the  vector │
                      │                                       │ into a local vector.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getNestSubVecs()                      │ Return  all  the vectors contained in │
                      │                                       │ the nested vector.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOffloadMask()                      │ Return the offloading status  of  the │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOptionsPrefix()                    │ Return  the prefix used for searching │
                      │                                       │ for options in the database.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipRange()                   │ Return the  locally  owned  range  of │
                      │                                       │ indices (start,end).                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getOwnershipRanges()                  │ Return  the range of indices owned by │
                      │                                       │ each process.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSize()                             │ Return the global size of the vector. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSizes()                            │ Return the vector sizes.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSubVector(iset[, subvec])          │ Return   a   subvector   from   given │
                      │                                       │ indices.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the type of the vector.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getValue(index)                       │ Return   a   single  value  from  the │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getValues(indices[, values])          │ Return values from certain  locations │
                      │                                       │ in the vector.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getValuesStagStencil(indices[,        │ Not implemented.                      │
                      │ values])                              │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ ghostUpdate([addv, mode])             │ Update ghosted vector entries.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ ghostUpdateBegin([addv, mode])        │ Begin    updating    ghosted   vector │
                      │                                       │ entries.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ ghostUpdateEnd([addv, mode])          │ Finish   updating   ghosted    vector │
                      │                                       │ entries         initiated        with │
                      │                                       │ ghostUpdateBegin.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isaxpy(idx, alpha, x)                 │ Add a scaled reduced-space vector  to │
                      │                                       │ a subset of the vector.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ isset(idx, alpha)                     │ Set  specific  elements of the vector │
                      │                                       │ to the same value.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ load(viewer)                          │ Load a vector.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ localForm()                           │ Return a context manager for  viewing │
                      │                                       │ ghost vectors in local form.          │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ log()                                 │ Replace  each  entry in the vector by │
                      │                                       │ its natural logarithm.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ mDot(vecs[, out])                     │ Compute  Xᴴ·y  with  X  an  array  of │
                      │                                       │ vectors.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ mDotBegin(vecs, out)                  │ Starts  a  split  phase  multiple dot │
                      │                                       │ product computation.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ mDotEnd(vecs, out)                    │ Ends  a  split  phase  multiple   dot │
                      │                                       │ product computation.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ max()                                 │ Return  the vector entry with maximum │
                      │                                       │ real part and its location.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ maxPointwiseDivide(vec)               │ Return    the    maximum    of    the │
                      │                                       │ component-wise     absolute     value │
                      │                                       │ division.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ maxpy(alphas, vecs)                   │ Compute and store y = Σₙ(ɑₙ·Xₙ)  +  y │
                      │                                       │ with X an array of vectors.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ min()                                 │ Return  the vector entry with minimum │
                      │                                       │ real part and its location.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ mtDot(vecs[, out])                    │ Compute  Xᵀ·y  with  X  an  array  of │
                      │                                       │ vectors.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ mtDotBegin(vecs, out)                 │ Starts   a   split   phase  transpose │
                      │                                       │ multiple dot product computation.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ mtDotEnd(vecs, out)                   │ Ends a split phase transpose multiple │
                      │                                       │ dot product computation.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ norm([norm_type])                     │ Compute the vector norm.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ normBegin([norm_type])                │ Begin computing the vector norm.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ normEnd([norm_type])                  │ Finish  computations  initiated  with │
                      │                                       │ normBegin.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ normalize()                           │ Normalize the vector by its 2-norm.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ permute(order[, invert])              │ Permute  the  vector  in-place with a │
                      │                                       │ provided ordering.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ placeArray(array)                     │ Set the local portion of  the  vector │
                      │                                       │ to a provided array.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pointwiseDivide(x, y)                 │ Compute  and store the component-wise │
                      │                                       │ division of two vectors.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pointwiseMax(x, y)                    │ Compute and store the  component-wise │
                      │                                       │ maximum of two vectors.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pointwiseMaxAbs(x, y)                 │ Compute  and store the component-wise │
                      │                                       │ maximum absolute values.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pointwiseMin(x, y)                    │ Compute and store the  component-wise │
                      │                                       │ minimum of two vectors.               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pointwiseMult(x, y)                   │ Compute  and store the component-wise │
                      │                                       │ multiplication of two vectors.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ reciprocal()                          │ Replace each entry in the  vector  by │
                      │                                       │ its reciprocal.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ resetArray([force])                   │ Reset  the  vector to use its default │
                      │                                       │ array.                                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreCLMemHandle()                  │ Restore  a  pointer  to  the   OpenCL │
                      │                                       │ buffer obtained with getCLMemHandle.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreCUDAHandle(handle[, mode])     │ Restore   a  pointer  to  the  device │
                      │                                       │ buffer obtained with getCUDAHandle.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreHIPHandle(handle[, mode])      │ Restore  a  pointer  to  the   device │
                      │                                       │ buffer obtained with getHIPHandle.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreLocalVector(lvec[, readonly])  │ Unmap  a  local  access obtained with │
                      │                                       │ getLocalVector.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreSubVector(iset, subvec)        │ Restore a subvector  extracted  using │
                      │                                       │ getSubVector.                         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ scale(alpha)                          │ Scale all entries of the vector.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ set(alpha)                            │ Set  all  components of the vector to │
                      │                                       │ the same value.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setArray(array)                       │ Set values for the local  portion  of │
                      │                                       │ the vector.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setBlockSize(bsize)                   │ Set the block size of the vector.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDM(dm)                             │ Associate a DM to the vector.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFromOptions()                      │ Configure the vector from the options │
                      │                                       │ database.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setLGMap(lgmap)                       │ Set the local-to-global mapping.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setMPIGhost(ghosts)                   │ Set  the  ghost  points for a ghosted │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setNestSubVecs(sx[, idxm])            │ Set   the   component   vectors    at │
                      │                                       │ specified   indices   in  the  nested │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOption(option, flag)               │ Set option.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setOptionsPrefix(prefix)              │ Set the prefix used for searching for │
                      │                                       │ options in the database.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setRandom([random])                   │ Set all components of the  vector  to │
                      │                                       │ random numbers.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setSizes(size[, bsize])               │ Set the local and global sizes of the │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(vec_type)                     │ Set the vector type.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setUp()                               │ Set  up  the internal data structures │
                      │                                       │ for using the vector.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValue(index, value[, addv])        │ Insert or add a single value  in  the │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValueLocal(index, value[, addv])   │ Insert  or  add a single value in the │
                      │                                       │ vector using a local numbering.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValues(indices, values[, addv])    │ Insert or add multiple values in  the │
                      │                                       │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlocked(indices,    values[, │ Insert or add blocks of values in the │
                      │ addv])                                │ vector.                               │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesBlockedLocal(indices,        │ Insert or add blocks of values in the │
                      │ values[, addv])                       │ vector with a local numbering.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesLocal(indices,      values[, │ Insert  or add multiple values in the │
                      │ addv])                                │ vector with a local numbering.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setValuesStagStencil(indices,         │ Not implemented.                      │
                      │ values[, addv])                       │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ shift(alpha)                          │ Shift all entries in the vector.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ sqrtabs()                             │ Replace each entry (xₙ) in the vector │
                      │                                       │ by √|xₙ|.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ strideGather(field, vec[, addv])      │ Insert  component   values   into   a │
                      │                                       │ single-component vector.              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ strideMax(field)                      │ Return  the  maximum  of entries in a │
                      │                                       │ subvector.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ strideMin(field)                      │ Return the minimum of  entries  in  a │
                      │                                       │ subvector.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ strideNorm(field[, norm_type])        │ Return  the  norm  of  entries  in  a │
                      │                                       │ subvector.                            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ strideScale(field, alpha)             │ Scale a component of the vector.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ strideScatter(field, vec[, addv])     │ Scatter entries into a  component  of │
                      │                                       │ another vector.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ strideSum(field)                      │ Sum subvector entries.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ sum()                                 │ Return  the sum of all the entries of │
                      │                                       │ the vector.                           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ swap(vec)                             │ Swap the content of two vectors.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ tDot(vec)                             │ Return  the  indefinite  dot  product │
                      │                                       │ with vec.                             │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ tDotBegin(vec)                        │ Begin  computing  the  indefinite dot │
                      │                                       │ product.                              │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ tDotEnd(vec)                          │ Finish computing the  indefinite  dot │
                      │                                       │ product initiated with tDotBegin.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ toDLPack([mode])                      │ Return  a  DLPack  PyCapsule wrapping │
                      │                                       │ the vector data.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([viewer])                        │ Display the vector.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ waxpy(alpha, x, y)                    │ Compute and store w = ɑ·x + y.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ zeroEntries()                         │ Set all  entries  in  the  vector  to │
                      │                                       │ zero.                                 │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Attributes Summary
                                  ┌──────────────┬───────────────────────────────────────┐
                                  │ array        │ Alias for array_w.                    │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ array_r      │ Read-only   ndarray   containing  the │
                                  │              │ local portion of the vector.          │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ array_w      │ Writeable  ndarray   containing   the │
                                  │              │ local portion of the vector.          │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ block_size   │ The block size.                       │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ buffer       │ Alias for buffer_w.                   │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ buffer_r     │ Read-only  buffered view of the local │
                                  │              │ portion of the vector.                │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ buffer_w     │ Writeable buffered view of the  local │
                                  │              │ portion of the vector.                │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ local_size   │ The local vector size.                │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ owner_range  │ The locally owned range of indices in │
                                  │              │ the form [low,high).                 │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ owner_ranges │ The  range  of  indices owned by each │
                                  │              │ process.                              │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ size         │ The global vector size.               │
                                  ├──────────────┼───────────────────────────────────────┤
                                  │ sizes        │ The local and global vector sizes.    │
                                  └──────────────┴───────────────────────────────────────┘

              Methods Documentation

              abs()  Replace each entry (xₙ) in the vector by abs|xₙ|.

                     Logically collective.

                     SEEALSO:VecAbsSourcecodeatpetsc4py/PETSc/Vec.pyx:2293ReturntypeNoneappendOptionsPrefix(prefix)
                     Append to the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, VecAppendOptionsPrefixSourcecodeatpetsc4py/PETSc/Vec.pyx:1028Parametersprefix (str|None)

                     ReturntypeNoneassemble()
                     Assemble the vector.

                     Collective.

                     SEEALSO:assemblyBegin, assemblyEndSourcecodeatpetsc4py/PETSc/Vec.pyx:3047ReturntypeNoneassemblyBegin()
                     Begin an assembling stage of the vector.

                     Collective.

                     SEEALSO:assemblyEnd, VecAssemblyBeginSourcecodeatpetsc4py/PETSc/Vec.pyx:3023ReturntypeNoneassemblyEnd()
                     Finish the assembling stage initiated with assemblyBegin.

                     Collective.

                     SEEALSO:assemblyBegin, VecAssemblyEndSourcecodeatpetsc4py/PETSc/Vec.pyx:3035ReturntypeNoneattachDLPackInfo(vec=None,dltensor=None)
                     Attach tensor information from another vector or DLPack tensor.

                     Logically collective.

                     This tensor information is required when converting a Vec to a DLPack object.

                     Parameters

                            • vec (Vec|None) -- Vector with attached tensor  information.  This  is  typically
                              created by calling createWithDLPack.

                            • dltensor -- DLPack tensor. This will only be used if vec is None.

                     ReturntypeSelf

                     Notes

                     This operation does not copy any data from vec or dltensor.

                     SEEALSO:clearDLPackInfo, createWithDLPackSourcecodeatpetsc4py/PETSc/Vec.pyx:643axpby(alpha,beta,x)
                     Compute and store y = ɑ·x + β·y.

                     Logically collective.

                     Parameters

                            • alpha (Scalar) -- First scale factor.

                            • beta (Scalar) -- Second scale factor.

                            • x (Vec) -- Input vector, must not be the current vector.

                     ReturntypeNoneSEEALSO:axpy, aypx, waxpy, VecAXPBYSourcecodeatpetsc4py/PETSc/Vec.pyx:2524axpy(alpha,x)
                     Compute and store y = ɑ·x + y.

                     Logically collective.

                     Parameters

                            • alpha (Scalar) -- Scale factor.

                            • x (Vec) -- Input vector.

                     ReturntypeNoneSEEALSO:isaxpy, VecAXPYSourcecodeatpetsc4py/PETSc/Vec.pyx:2460aypx(alpha,x)
                     Compute and store y = x + ɑ·y.

                     Logically collective.

                     Parameters

                            • alpha (Scalar) -- Scale factor.

                            • x (Vec) -- Input vector, must not be the current vector.

                     ReturntypeNoneSEEALSO:axpy, axpby, VecAYPXSourcecodeatpetsc4py/PETSc/Vec.pyx:2504bindToCPU(flg)
                     Bind vector operations execution on the CPU.

                     Logically collective.

                     SEEALSO:boundToCPU, VecBindToCPUSourcecodeatpetsc4py/PETSc/Vec.pyx:1396Parametersflg (bool)

                     ReturntypeNoneboundToCPU()
                     Return whether the vector has been bound to the CPU.

                     Not collective.

                     SEEALSO:bindToCPU, VecBoundToCPUSourcecodeatpetsc4py/PETSc/Vec.pyx:1409Returntypeboolchop(tol)
                     Set all vector entries less than some absolute tolerance to zero.

                     Collective.

                     Parameterstol (float) -- The absolute tolerance below which entries are set to zero.

                     ReturntypeNoneSEEALSO:VecFilterSourcecodeatpetsc4py/PETSc/Vec.pyx:1732clearDLPackInfo()
                     Clear tensor information.

                     Logically collective.

                     SEEALSO:attachDLPackInfo, createWithDLPackSourcecodeatpetsc4py/PETSc/Vec.pyx:705ReturntypeSelfclassmethodconcatenate(vecs)
                     Concatenate vectors into a single vector.

                     Collective.

                     Parametersvecs (Sequence[Vec]) -- The vectors to be concatenated.

                     Returns

                            • vector_out (Vec) -- The concatenated vector.

                            • indices_list  (list  of  IS)  --  A  list  of  index  sets  corresponding  to  the
                              concatenated components.

                     Returntypetuple[Vec, list[IS]]

                     SEEALSO:VecConcatenateSourcecodeatpetsc4py/PETSc/Vec.pyx:3536conjugate()
                     Conjugate the vector.

                     Logically collective.

                     SEEALSO:VecConjugateSourcecodeatpetsc4py/PETSc/Vec.pyx:2305ReturntypeNonecopy(result=None)
                     Return a copy of the vector.

                     Logically collective.

                     This operation copies vector entries to the new vector.

                     Parametersresult (Vec|None) -- Target vector for the copy. If None  then  a  new  vector  is
                            created internally.

                     ReturntypeVecSEEALSO:duplicate, VecCopySourcecodeatpetsc4py/PETSc/Vec.pyx:1707create(comm=None)
                     Create a vector object.

                     Collective.

                     After creation the vector type can then be set with setType.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:destroy, VecCreateSourcecodeatpetsc4py/PETSc/Vec.pyx:176createCUDAWithArrays(cpuarray=None,cudahandle=None,size=None,bsize=None,comm=None)
                     Create a Type.CUDA vector with optional arrays.

                     Collective.

                     Parameters

                            • cpuarray  (Sequence[Scalar]|None) -- Host array. Will be lazily allocated if not
                              provided.

                            • cudahandle (Any|None) -- Address of  the  array  on  the  GPU.  Will  be  lazily
                              allocated if not provided.

                            • size (LayoutSizeSpec|None) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:VecCreateSeqCUDAWithArrays, VecCreateMPICUDAWithArraysSourcecodeatpetsc4py/PETSc/Vec.pyx:370createGhost(ghosts,size,bsize=None,comm=None)
                     Create a parallel vector with ghost padding on each processor.

                     Collective.

                     Parameters

                            • ghosts (Sequence[int]) -- Global indices of ghost points.

                            • size (LayoutSizeSpec) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:createGhostWithArray, VecCreateGhost, VecCreateGhostBlockSourcecodeatpetsc4py/PETSc/Vec.pyx:819createGhostWithArray(ghosts,array,size=None,bsize=None,comm=None)
                     Create a parallel vector with ghost padding and provided arrays.

                     Collective.

                     Parameters

                            • ghosts (Sequence[int]) -- Global indices of ghost points.

                            • array  (Sequence[Scalar]) -- Array to store the vector values. Must be at least as
                              large as the local size of the vector (including ghost points).

                            • size (LayoutSizeSpec|None) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:createGhost, VecCreateGhostWithArray, VecCreateGhostBlockWithArraySourcecodeatpetsc4py/PETSc/Vec.pyx:861createHIPWithArrays(cpuarray=None,hiphandle=None,size=None,bsize=None,comm=None)
                     Create a Type.HIP vector with optional arrays.

                     Collective.

                     Parameters

                            • cpuarray (Sequence[Scalar]|None) -- Host array. Will be lazily allocated if  not
                              provided.

                            • hiphandle  (Any|None)  --  Address  of  the  array  on the GPU. Will be lazily
                              allocated if not provided.

                            • size (LayoutSizeSpec|None) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:VecCreateSeqHIPWithArrays, VecCreateMPIHIPWithArraysSourcecodeatpetsc4py/PETSc/Vec.pyx:428createLocalVector()
                     Create a local vector.

                     Not collective.

                     Returns
                            The local vector.

                     ReturntypeVecSEEALSO:getLocalVector, VecCreateLocalVectorSourcecodeatpetsc4py/PETSc/Vec.pyx:1204createMPI(size,bsize=None,comm=None)
                     Create a parallel Type.MPI vector.

                     Collective.

                     Parameters

                            • size (LayoutSizeSpec) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:createSeq, VecCreateMPISourcecodeatpetsc4py/PETSc/Vec.pyx:283createNest(vecs,isets=None,comm=None)
                     Create a Type.NEST vector containing multiple nested subvectors.

                     Collective.

                     Parameters

                            • vecs (Sequence[Vec]) -- Iterable of subvectors.

                            • isets (Sequence[IS])  --  Iterable  of  index  sets  for  each  nested  subvector.
                              Defaults to contiguous ordering.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:VecCreateNestSourcecodeatpetsc4py/PETSc/Vec.pyx:952createSeq(size,bsize=None,comm=None)
                     Create a sequential Type.SEQ vector.

                     Collective.

                     Parameters

                            • size (LayoutSizeSpec) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to COMM_SELF.

                     ReturntypeSelfSEEALSO:createMPI, VecCreateSeqSourcecodeatpetsc4py/PETSc/Vec.pyx:247createShared(size,bsize=None,comm=None)
                     Create a Type.SHARED vector that uses shared memory.

                     Collective.

                     Parameters

                            • size (LayoutSizeSpec) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:VecCreateSharedSourcecodeatpetsc4py/PETSc/Vec.pyx:918createViennaCLWithArrays(cpuarray=None,viennaclvechandle=None,size=None,bsize=None,comm=None)
                     Create a Type.VIENNACL vector with optional arrays.

                     Collective.

                     Parameters

                            • cpuarray  (Sequence[Scalar]|None) -- Host array. Will be lazily allocated if not
                              provided.

                            • viennaclvechandle (Any|None) -- Address of the array on the GPU. Will be  lazily
                              allocated if not provided.

                            • size (LayoutSizeSpec|None) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:VecCreateSeqViennaCLWithArrays, VecCreateMPIViennaCLWithArraysSourcecodeatpetsc4py/PETSc/Vec.pyx:486createWithArray(array,size=None,bsize=None,comm=None)
                     Create a vector using a provided array.

                     Collective.

                     This  method  will  create  either  a  Type.SEQ  or  Type.MPI  depending on the size of the
                     communicator.

                     Parameters

                            • array (Sequence[Scalar]) -- Array to store the vector values. Must be at least  as
                              large as the local size of the vector.

                            • size (LayoutSizeSpec|None) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:VecCreateSeqWithArray, VecCreateMPIWithArraySourcecodeatpetsc4py/PETSc/Vec.pyx:319createWithDLPack(dltensor,size=None,bsize=None,comm=None)
                     Create a vector wrapping a DLPack object, sharing the same memory.

                     Collective.

                     This  operation  does not modify the storage of the original tensor and should be used with
                     contiguous tensors only. If the tensor is stored in row-major order (e.g. PyTorch tensors),
                     the resulting vector will look like an unrolled tensor using row-major order.

                     The resulting vector type will be one of Type.SEQ,  Type.MPI,  Type.SEQCUDA,  Type.MPICUDA,
                     Type.SEQHIP or Type.MPIHIP depending on the type of dltensor and the number of processes in
                     the communicator.

                     Parameters

                            • dltensor -- Either an object with a __dlpack__ method or a DLPack tensor object.

                            • size (LayoutSizeSpec|None) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:545destroy()
                     Destroy the vector.

                     Collective.

                     SEEALSO:create, VecDestroySourcecodeatpetsc4py/PETSc/Vec.pyx:163ReturntypeSelfdot(vec)
                     Return the dot product with vec.

                     Collective.

                     For  complex  numbers  this computes yᴴ·x with self as x, vec as y and where yᴴ denotes the
                     conjugate transpose of y.

                     Use tDot for the indefinite form yᵀ·x where yᵀ denotes the transpose of y.

                     Parametersvec (Vec) -- Vector to compute the dot product with.

                     ReturntypeScalarSEEALSO:dotBegin, dotEnd, tDot, VecDotSourcecodeatpetsc4py/PETSc/Vec.pyx:1787dotBegin(vec)
                     Begin computing the dot product.

                     Collective.

                     This should be paired with a call to dotEnd.

                     Parametersvec (Vec) -- Vector to compute the dot product with.

                     ReturntypeNoneSEEALSO:dotEnd, dot, VecDotBeginSourcecodeatpetsc4py/PETSc/Vec.pyx:1812dotEnd(vec)
                     Finish computing the dot product initiated with dotBegin.

                     Collective.

                     SEEALSO:dotBegin, dot, VecDotEndSourcecodeatpetsc4py/PETSc/Vec.pyx:1832Parametersvec (Vec)

                     ReturntypeScalardotNorm2(vec)
                     Return the dot product with vec and its squared norm.

                     Collective.

                     SEEALSO:dot, norm, VecDotNorm2Sourcecodeatpetsc4py/PETSc/Vec.pyx:2151Parametersvec (Vec)

                     Returntypetuple[Scalar, float]

              duplicate(array=None)
                     Create a new vector with the same type, optionally with data.

                     Collective.

                     Parametersarray (Sequence[Scalar]|None) -- Optional values to store in the new vector.

                     ReturntypeVecSEEALSO:copy, VecDuplicateSourcecodeatpetsc4py/PETSc/Vec.pyx:1682equal(vec)
                     Return whether the vector is equal to another.

                     Collective.

                     Parametersvec (Vec) -- Vector to compare with.

                     ReturntypeboolSEEALSO:VecEqualSourcecodeatpetsc4py/PETSc/Vec.pyx:1768exp()  Replace each entry (xₙ) in the vector by exp(xₙ).

                     Logically collective.

                     SEEALSO:log, VecExpSourcecodeatpetsc4py/PETSc/Vec.pyx:2257ReturntypeNonegetArray(readonly=False)
                     Return local portion of the vector as an ndarray.

                     Logically collective.

                     Parametersreadonly (bool) -- Request read-only access.

                     ReturntypeArrayScalarSEEALSO:setArray, getBufferSourcecodeatpetsc4py/PETSc/Vec.pyx:1313getBlockSize()
                     Return the block size of the vector.

                     Not collective.

                     SEEALSO:VecGetBlockSizeSourcecodeatpetsc4py/PETSc/Vec.pyx:1149ReturntypeintgetBuffer(readonly=False)
                     Return a buffered view of the local portion of the vector.

                     Logically collective.

                     Parametersreadonly (bool) -- Request read-only access.

                     ReturnsBufferobject wrapping the local portion of the vector data. This can be used either
                            as a context manager providing access as a numpy array or can  be  passed  to  array
                            constructors accepting buffered objects such as numpy.asarray.

                     Returntypetyping.Any

                     Examples

                     Accessing the data with a context manager:

                     >>> vec = PETSc.Vec().createWithArray([1, 2, 3])
                     >>> with vec.getBuffer() as arr:
                     ...     arr
                     array([1., 2., 3.])

                     Converting the buffer to an ndarray:

                     >>> buf = PETSc.Vec().createWithArray([1, 2, 3]).getBuffer()
                     >>> np.asarray(buf)
                     array([1., 2., 3.])

                     SEEALSO:getArraySourcecodeatpetsc4py/PETSc/Vec.pyx:1270getCLContextHandle()
                     Return the OpenCL context associated with the vector.

                     Not collective.

                     Returns
                            Pointer   to  underlying  CL  context.  This  can  be  used  with  pyopencl  through
                            pyopencl.Context.from_int_ptr.

                     ReturntypeintSEEALSO:getCLQueueHandle, VecViennaCLGetCLContextSourcecodeatpetsc4py/PETSc/Vec.pyx:1593getCLMemHandle(mode='rw')
                     Return the OpenCL buffer associated with the vector.

                     Not collective.

                     Returns
                            Pointer  to  the  device  buffer.  This  can   be   used   with   pyopencl   through
                            pyopencl.Context.from_int_ptr.

                     ReturntypeintParametersmode (AccessModeSpec)

                     Notes

                     This  method  may incur a host-to-device copy if the device data is out of date and mode is
                     "r" or "rw".

                     SEEALSO:restoreCLMemHandle,        VecViennaCLGetCLMem,        VecViennaCLGetCLMemRead,        ‐
                        VecViennaCLGetCLMemWriteSourcecodeatpetsc4py/PETSc/Vec.pyx:1633getCLQueueHandle()
                     Return the OpenCL command queue associated with the vector.

                     Not collective.

                     Returns
                            Pointer  to  underlying  CL  command  queue.  This can be used with pyopencl through
                            pyopencl.Context.from_int_ptr.

                     ReturntypeintSEEALSO:getCLContextHandle, VecViennaCLGetCLQueueSourcecodeatpetsc4py/PETSc/Vec.pyx:1613getCUDAHandle(mode='rw')
                     Return a pointer to the device buffer.

                     Not collective.

                     The returned pointer should be released using restoreCUDAHandle with the same access mode.

                     Returns
                            CUDA device pointer.

                     Returntypetyping.AnyParametersmode (AccessModeSpec)

                     Notes

                     This method may incur a host-to-device copy if the device data is out of date and  mode  is
                     "r" or "rw".

                     SEEALSO:restoreCUDAHandle, VecCUDAGetArray, VecCUDAGetArrayRead, VecCUDAGetArrayWriteSourcecodeatpetsc4py/PETSc/Vec.pyx:1423getDM()
                     Return the DM associated to the vector.

                     Not collective.

                     SEEALSO:setDM, VecGetDMSourcecodeatpetsc4py/PETSc/Vec.pyx:3519ReturntypeDMgetGhostIS()
                     Return ghosting indices of a ghost vector.

                     Collective.

                     Returns
                            Indices of ghosts.

                     ReturntypeISSEEALSO:VecGhostGetGhostISSourcecodeatpetsc4py/PETSc/Vec.pyx:3385getHIPHandle(mode='rw')
                     Return a pointer to the device buffer.

                     Not collective.

                     The returned pointer should be released using restoreHIPHandle with the same access mode.

                     Returns
                            HIP device pointer.

                     Returntypetyping.AnyParametersmode (AccessModeSpec)

                     Notes

                     This  method  may incur a host-to-device copy if the device data is out of date and mode is
                     "r" or "rw".

                     SEEALSO:restoreHIPHandle, VecHIPGetArray, VecHIPGetArrayRead, VecHIPGetArrayWriteSourcecodeatpetsc4py/PETSc/Vec.pyx:1495getLGMap()
                     Return the local-to-global mapping.

                     Not collective.

                     SEEALSO:setLGMap, VecGetLocalToGlobalMappingSourcecodeatpetsc4py/PETSc/Vec.pyx:2899ReturntypeLGMapgetLocalSize()
                     Return the local size of the vector.

                     Not collective.

                     SEEALSO:setSizes, getSize, VecGetLocalSizeSourcecodeatpetsc4py/PETSc/Vec.pyx:1107ReturntypeintgetLocalVector(lvec,readonly=False)
                     Maps the local portion of the vector into a local vector.

                     Logically collective.

                     Parameters

                            • lvec (Vec) -- The local vector obtained from createLocalVector.

                            • readonly (bool) -- Request read-only access.

                     ReturntypeNoneSEEALSO:createLocalVector, restoreLocalVector, VecGetLocalVectorRead, VecGetLocalVectorSourcecodeatpetsc4py/PETSc/Vec.pyx:1223getNestSubVecs()
                     Return all the vectors contained in the nested vector.

                     Not collective.

                     SEEALSO:setNestSubVecs, VecNestGetSubVecsSourcecodeatpetsc4py/PETSc/Vec.pyx:3451Returntypelist[Vec]

              getOffloadMask()
                     Return the offloading status of the vector.

                     Not collective.

                     Common return values include:

                     • 1: PETSC_OFFLOAD_CPU - CPU has valid entries

                     • 2: PETSC_OFFLOAD_GPU - GPU has valid entries

                     • 3: PETSC_OFFLOAD_BOTH - CPU and GPU are in sync

                     Returns
                            Enum value from PetscOffloadMask describing the offloading status.

                     ReturntypeintSEEALSO:VecGetOffloadMask, PetscOffloadMaskSourcecodeatpetsc4py/PETSc/Vec.pyx:1567getOptionsPrefix()
                     Return the prefix used for searching for options in the database.

                     Not collective.

                     SEEALSO:WorkingwithPETScoptions, setOptionsPrefix, VecGetOptionsPrefixSourcecodeatpetsc4py/PETSc/Vec.pyx:1014ReturntypestrgetOwnershipRange()
                     Return the locally owned range of indices (start,end).

                     Not collective.

                     Returns

                            • start (int) -- The first local element.

                            • end (int) -- One more than the last local element.

                     Returntypetuple[int, int]

                     SEEALSO:getOwnershipRanges, VecGetOwnershipRangeSourcecodeatpetsc4py/PETSc/Vec.pyx:1163getOwnershipRanges()
                     Return the range of indices owned by each process.

                     Not collective.

                     The returned array is the result of exclusive scan of the local sizes.

                     SEEALSO:getOwnershipRange, VecGetOwnershipRangesSourcecodeatpetsc4py/PETSc/Vec.pyx:1184ReturntypeArrayIntgetSize()
                     Return the global size of the vector.

                     Not collective.

                     SEEALSO:setSizes, getLocalSize, VecGetSizeSourcecodeatpetsc4py/PETSc/Vec.pyx:1093ReturntypeintgetSizes()
                     Return the vector sizes.

                     Not collective.

                     SEEALSO:getSize, getLocalSize, VecGetLocalSize, VecGetSizeSourcecodeatpetsc4py/PETSc/Vec.pyx:1121ReturntypeLayoutSizeSpecgetSubVector(iset,subvec=None)
                     Return a subvector from given indices.

                     Collective.

                     Once finished with the subvector it should be returned with restoreSubVector.

                     Parameters

                            • iset (IS) -- Index set describing which indices to extract into the subvector.

                            • subvec (Vec|None) -- Subvector to copy entries into. If None then a new Vec will
                              be created.

                     ReturntypeVecSEEALSO:restoreSubVector, VecGetSubVectorSourcecodeatpetsc4py/PETSc/Vec.pyx:3406getType()
                     Return the type of the vector.

                     Not collective.

                     SEEALSO:setType, VecGetTypeSourcecodeatpetsc4py/PETSc/Vec.pyx:1079ReturntypestrgetValue(index)
                     Return a single value from the vector.

                     Not collective.

                     Only values locally stored may be accessed.

                     Parametersindex (int) -- Location of the value to read.

                     ReturntypeScalarSEEALSO:getValues, VecGetValuesSourcecodeatpetsc4py/PETSc/Vec.pyx:2720getValues(indices,values=None)
                     Return values from certain locations in the vector.

                     Not collective.

                     Only values locally stored may be accessed.

                     Parameters

                            • indices (Sequence[int]) -- Locations of the values to read.

                            • values (Sequence[Scalar]|None) -- Location to store the collected values. If not
                              provided then a new array will be allocated.

                     ReturntypeArrayScalarSEEALSO:getValue, setValues, VecGetValuesSourcecodeatpetsc4py/PETSc/Vec.pyx:2742getValuesStagStencil(indices,values=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:2767ReturntypeNoneghostUpdate(addv=None,mode=None)
                     Update ghosted vector entries.

                     Neighborwise collective.

                     Parameters

                            • addv (InsertModeSpec) -- Insertion mode.

                            • mode (ScatterModeSpec) -- Scatter mode.

                     ReturntypeNone

                     Examples

                     To accumulate ghost region values onto owning processes:

                     >>> vec.ghostUpdate(InsertMode.ADD_VALUES, ScatterMode.REVERSE)

                     Update ghost regions:

                     >>> vec.ghostUpdate(InsertMode.INSERT_VALUES, ScatterMode.FORWARD)

                     SEEALSO:ghostUpdateBegin, ghostUpdateEndSourcecodeatpetsc4py/PETSc/Vec.pyx:3331ghostUpdateBegin(addv=None,mode=None)
                     Begin updating ghosted vector entries.

                     Neighborwise collective.

                     SEEALSO:ghostUpdateEnd, ghostUpdate, createGhost, VecGhostUpdateBeginSourcecodeatpetsc4py/PETSc/Vec.pyx:3297Parameters

                            • addv (InsertModeSpec)

                            • mode (ScatterModeSpec)

                     ReturntypeNoneghostUpdateEnd(addv=None,mode=None)
                     Finish updating ghosted vector entries initiated with ghostUpdateBegin.

                     Neighborwise collective.

                     SEEALSO:ghostUpdateBegin, ghostUpdate, createGhost, VecGhostUpdateEndSourcecodeatpetsc4py/PETSc/Vec.pyx:3314Parameters

                            • addv (InsertModeSpec)

                            • mode (ScatterModeSpec)

                     ReturntypeNoneisaxpy(idx,alpha,x)
                     Add a scaled reduced-space vector to a subset of the vector.

                     Logically collective.

                     This is equivalent to y[idx[i]]+=alpha*x[i].

                     Parameters

                            • idx (IS) -- Index set for the reduced space. Negative indices are skipped.

                            • alpha (Scalar) -- Scale factor.

                            • x (Vec) -- Reduced-space vector.

                     ReturntypeNoneSEEALSO:axpy, aypx, axpby, VecISAXPYSourcecodeatpetsc4py/PETSc/Vec.pyx:2480isset(idx,alpha)
                     Set specific elements of the vector to the same value.

                     Not collective.

                     Parameters

                            • idx (IS) -- Index set specifying the vector entries to set.

                            • alpha (Scalar) -- Value to set the selected entries to.

                     ReturntypeNoneSEEALSO:set, zeroEntries, VecISSetSourcecodeatpetsc4py/PETSc/Vec.pyx:2383load(viewer)
                     Load a vector.

                     Collective.

                     SEEALSO:view, VecLoadSourcecodeatpetsc4py/PETSc/Vec.pyx:1750Parametersviewer (Viewer)

                     ReturntypeSelflocalForm()
                     Return a context manager for viewing ghost vectors in local form.

                     Logically collective.

                     Returns
                            Context manager yielding the vector in local (ghosted) form.

                     Returntypetyping.Any

                     Notes

                     This operation does not perform a copy. To obtain up-to-date ghost values  ghostUpdateBegin
                     and ghostUpdateEnd must be called first.

                     Non-ghost    values    can   be   found   at   values[0:nlocal]   and   ghost   values   at
                     values[nlocal:nlocal+nghost].

                     Examples

                     >>> with vec.localForm() as lf:
                     ...     # compute with lf

                     SEEALSO:createGhost,     ghostUpdateBegin,     ghostUpdateEnd,      VecGhostGetLocalForm,      ‐
                        VecGhostRestoreLocalFormSourcecodeatpetsc4py/PETSc/Vec.pyx:3264log()  Replace each entry in the vector by its natural logarithm.

                     Logically collective.

                     SEEALSO:exp, VecLogSourcecodeatpetsc4py/PETSc/Vec.pyx:2269ReturntypeNonemDot(vecs,out=None)
                     Compute Xᴴ·y with X an array of vectors.

                     Collective.

                     Parameters

                            • vecs (Sequence[Vec]) -- Array of vectors.

                            • out (ArrayScalar|None) -- Optional placeholder for the result.

                     ReturntypeArrayScalarSEEALSO:dot, tDot, mDotBegin, mDotEnd, VecMDotSourcecodeatpetsc4py/PETSc/Vec.pyx:1902mDotBegin(vecs,out)
                     Starts a split phase multiple dot product computation.

                     Collective.

                     Parameters

                            • vecs (Sequence[Vec]) -- Array of vectors.

                            • out (ArrayScalar) -- Placeholder for the result.

                     ReturntypeNoneSEEALSO:mDot, mDotEnd, VecMDotBeginSourcecodeatpetsc4py/PETSc/Vec.pyx:1935mDotEnd(vecs,out)
                     Ends a split phase multiple dot product computation.

                     Collective.

                     Parameters

                            • vecs (Sequence[Vec]) -- Array of vectors.

                            • out (ArrayScalar) -- Placeholder for the result.

                     ReturntypeArrayScalarSEEALSO:mDot, mDotBegin, VecMDotEndSourcecodeatpetsc4py/PETSc/Vec.pyx:1965max()  Return the vector entry with maximum real part and its location.

                     Collective.

                     Returns

                            • p  (int) -- Location of the maximum value. If multiple entries exist with the same
                              value then the smallest index will be returned.

                            • val (Scalar) -- Minimum value.

                     Returntypetuple[int, float]

                     SEEALSO:min, VecMaxSourcecodeatpetsc4py/PETSc/Vec.pyx:2203maxPointwiseDivide(vec)
                     Return the maximum of the component-wise absolute value division.

                     Logically collective.

                     Equivalent to result=max_iabs(x[i]/y[i]).

                     Parameters

                            • x -- Numerator vector.

                            • y -- Denominator vector.

                            • vec (Vec)

                     ReturntypefloatSEEALSO:pointwiseMin, pointwiseMax, pointwiseMaxAbs, VecMaxPointwiseDivideSourcecodeatpetsc4py/PETSc/Vec.pyx:2696maxpy(alphas,vecs)
                     Compute and store y = Σₙ(ɑₙ·Xₙ) + y with X an array of vectors.

                     Logically collective.

                     Equivalent to y[:]=alphas[i]*vecs[i,:]+y[:].

                     Parameters

                            • alphas (Sequence[Scalar]) -- Array of scale factors, one for each vector in vecs.

                            • vecs (Sequence[Vec]) -- Array of vectors.

                     ReturntypeNoneSEEALSO:axpy, aypx, axpby, waxpy, VecMAXPYSourcecodeatpetsc4py/PETSc/Vec.pyx:2569min()  Return the vector entry with minimum real part and its location.

                     Collective.

                     Returns

                            • p (int) -- Location of the minimum value. If multiple entries exist with the  same
                              value then the smallest index will be returned.

                            • val (Scalar) -- Minimum value.

                     Returntypetuple[int, float]

                     SEEALSO:max, VecMinSourcecodeatpetsc4py/PETSc/Vec.pyx:2180mtDot(vecs,out=None)
                     Compute Xᵀ·y with X an array of vectors.

                     Collective.

                     Parameters

                            • vecs (Sequence[Vec]) -- Array of vectors.

                            • out (ArrayScalar|None) -- Optional placeholder for the result.

                     ReturntypeArrayScalarSEEALSO:tDot, mDot, mtDotBegin, mtDotEnd, VecMTDotSourcecodeatpetsc4py/PETSc/Vec.pyx:1996mtDotBegin(vecs,out)
                     Starts a split phase transpose multiple dot product computation.

                     Collective.

                     Parameters

                            • vecs (Sequence[Vec]) -- Array of vectors.

                            • out (ArrayScalar) -- Placeholder for the result.

                     ReturntypeNoneSEEALSO:mtDot, mtDotEnd, VecMTDotBeginSourcecodeatpetsc4py/PETSc/Vec.pyx:2029mtDotEnd(vecs,out)
                     Ends a split phase transpose multiple dot product computation.

                     Collective.

                     Parameters

                            • vecs (Sequence[Vec]) -- Array of vectors.

                            • out (ArrayScalar) -- Placeholder for the result.

                     ReturntypeArrayScalarSEEALSO:mtDot, mtDotBegin, VecMTDotEndSourcecodeatpetsc4py/PETSc/Vec.pyx:2059norm(norm_type=None)
                     Compute the vector norm.

                     Collective.

                     A 2-tuple is returned if NormType.NORM_1_AND_2 is specified.

                     SEEALSO:VecNorm, NormTypeSourcecodeatpetsc4py/PETSc/Vec.pyx:2090Parametersnorm_type (NormTypeSpec)

                     Returntypefloat | tuple[float, float]

              normBegin(norm_type=None)
                     Begin computing the vector norm.

                     Collective.

                     This should be paired with a call to normEnd.

                     SEEALSO:normEnd, norm, VecNormBeginSourcecodeatpetsc4py/PETSc/Vec.pyx:2112Parametersnorm_type (NormTypeSpec)

                     ReturntypeNonenormEnd(norm_type=None)
                     Finish computations initiated with normBegin.

                     Collective.

                     SEEALSO:normBegin, norm, VecNormEndSourcecodeatpetsc4py/PETSc/Vec.pyx:2131Parametersnorm_type (NormTypeSpec)

                     Returntypefloat | tuple[float, float]

              normalize()
                     Normalize the vector by its 2-norm.

                     Collective.

                     Returns
                            The vector norm before normalization.

                     ReturntypefloatSEEALSO:norm, VecNormalizeSourcecodeatpetsc4py/PETSc/Vec.pyx:2226permute(order,invert=False)
                     Permute the vector in-place with a provided ordering.

                     Collective.

                     Parameters

                            • order (IS) -- Ordering for the permutation.

                            • invert (bool) -- Whether to invert the permutation.

                     ReturntypeNoneSEEALSO:VecPermuteSourcecodeatpetsc4py/PETSc/Vec.pyx:2337placeArray(array)
                     Set the local portion of the vector to a provided array.

                     Not collective.

                     SEEALSO:resetArray, setArray, VecPlaceArraySourcecodeatpetsc4py/PETSc/Vec.pyx:1345Parametersarray (Sequence[Scalar])

                     ReturntypeNonepointwiseDivide(x,y)
                     Compute and store the component-wise division of two vectors.

                     Logically collective.

                     Equivalent to w[i]=x[i]/y[i].

                     Parameters

                            • x (Vec) -- Numerator vector.

                            • y (Vec) -- Denominator vector.

                     ReturntypeNoneSEEALSO:pointwiseMult, VecPointwiseDivideSourcecodeatpetsc4py/PETSc/Vec.pyx:2618pointwiseMax(x,y)
                     Compute and store the component-wise maximum of two vectors.

                     Logically collective.

                     Equivalent to w[i]=max(x[i],y[i]).

                     Parameters

                            • x (Vec) -- Input vectors to find the component-wise maxima.

                            • y (Vec) -- Input vectors to find the component-wise maxima.

                     ReturntypeNoneSEEALSO:pointwiseMin, pointwiseMaxAbs, VecPointwiseMaxSourcecodeatpetsc4py/PETSc/Vec.pyx:2658pointwiseMaxAbs(x,y)
                     Compute and store the component-wise maximum absolute values.

                     Logically collective.

                     Equivalent to w[i]=max(abs(x[i]),abs(y[i])).

                     Parameters

                            • x (Vec) -- Input vectors to find the component-wise maxima.

                            • y (Vec) -- Input vectors to find the component-wise maxima.

                     ReturntypeNoneSEEALSO:pointwiseMin, pointwiseMax, VecPointwiseMaxAbsSourcecodeatpetsc4py/PETSc/Vec.pyx:2677pointwiseMin(x,y)
                     Compute and store the component-wise minimum of two vectors.

                     Logically collective.

                     Equivalent to w[i]=min(x[i],y[i]).

                     Parameters

                            • x (Vec) -- Input vectors to find the component-wise minima.

                            • y (Vec) -- Input vectors to find the component-wise minima.

                     ReturntypeNoneSEEALSO:pointwiseMax, pointwiseMaxAbs, VecPointwiseMinSourcecodeatpetsc4py/PETSc/Vec.pyx:2639pointwiseMult(x,y)
                     Compute and store the component-wise multiplication of two vectors.

                     Logically collective.

                     Equivalent to w[i]=x[i]*y[i].

                     Parameters

                            • x (Vec) -- Input vectors to multiply component-wise.

                            • y (Vec) -- Input vectors to multiply component-wise.

                     ReturntypeNoneSEEALSO:pointwiseDivide, VecPointwiseMultSourcecodeatpetsc4py/PETSc/Vec.pyx:2599reciprocal()
                     Replace each entry in the vector by its reciprocal.

                     Logically collective.

                     SEEALSO:VecReciprocalSourcecodeatpetsc4py/PETSc/Vec.pyx:2245ReturntypeNoneresetArray(force=False)
                     Reset the vector to use its default array.

                     Not collective.

                     Parametersforce  (bool)  --  Force the calling of VecResetArray even if no user array has been
                            placed with placeArray.

                     Returns
                            The array previously provided by the user with placeArray.  Can be None if force  is
                            True and no array was placed before.

                     ReturntypeArrayScalarSEEALSO:placeArray, VecResetArraySourcecodeatpetsc4py/PETSc/Vec.pyx:1366restoreCLMemHandle()
                     Restore a pointer to the OpenCL buffer obtained with getCLMemHandle.

                     Not collective.

                     SEEALSO:getCLMemHandle, VecViennaCLRestoreCLMemWriteSourcecodeatpetsc4py/PETSc/Vec.pyx:1670ReturntypeNonerestoreCUDAHandle(handle,mode='rw')
                     Restore a pointer to the device buffer obtained with getCUDAHandle.

                     Not collective.

                     Parameters

                            • handle (Any) -- CUDA device pointer.

                            • mode (AccessModeSpec) -- Access mode.

                     ReturntypeNoneSEEALSO:getCUDAHandle, VecCUDARestoreArray, VecCUDARestoreArrayRead, VecCUDARestoreArrayWriteSourcecodeatpetsc4py/PETSc/Vec.pyx:1462restoreHIPHandle(handle,mode='rw')
                     Restore a pointer to the device buffer obtained with getHIPHandle.

                     Not collective.

                     Parameters

                            • handle (Any) -- HIP device pointer.

                            • mode (AccessModeSpec) -- Access mode.

                     ReturntypeNoneSEEALSO:getHIPHandle, VecHIPRestoreArray, VecHIPRestoreArrayRead, VecHIPRestoreArrayWriteSourcecodeatpetsc4py/PETSc/Vec.pyx:1534restoreLocalVector(lvec,readonly=False)
                     Unmap a local access obtained with getLocalVector.

                     Logically collective.

                     Parameters

                            • lvec (Vec) -- The local vector.

                            • readonly (bool) -- Request read-only access.

                     ReturntypeNoneSEEALSO:createLocalVector, getLocalVector, VecRestoreLocalVectorRead, VecRestoreLocalVectorSourcecodeatpetsc4py/PETSc/Vec.pyx:1246restoreSubVector(iset,subvec)
                     Restore a subvector extracted using getSubVector.

                     Collective.

                     Parameters

                            • iset (IS) -- Index set describing the indices represented by the subvector.

                            • subvec (Vec) -- Subvector to be restored.

                     ReturntypeNoneSEEALSO:getSubVector, VecRestoreSubVectorSourcecodeatpetsc4py/PETSc/Vec.pyx:3432scale(alpha)
                     Scale all entries of the vector.

                     Collective.

                     This method sets each entry (xₙ) in the vector to ɑ·xₙ.

                     Parametersalpha (Scalar) -- The scaling factor.

                     ReturntypeNoneSEEALSO:shift, VecScaleSourcecodeatpetsc4py/PETSc/Vec.pyx:2403set(alpha)
                     Set all components of the vector to the same value.

                     Collective.

                     SEEALSO:zeroEntries, isset, VecSetSourcecodeatpetsc4py/PETSc/Vec.pyx:2370Parametersalpha (Scalar)

                     ReturntypeNonesetArray(array)
                     Set values for the local portion of the vector.

                     Logically collective.

                     SEEALSO:placeArraySourcecodeatpetsc4py/PETSc/Vec.pyx:1333Parametersarray (Sequence[Scalar])

                     ReturntypeNonesetBlockSize(bsize)
                     Set the block size of the vector.

                     Logically collective.

                     SEEALSO:VecSetBlockSizeSourcecodeatpetsc4py/PETSc/Vec.pyx:1136Parametersbsize (int)

                     ReturntypeNonesetDM(dm)
                     Associate a DM to the vector.

                     Not collective.

                     SEEALSO:getDM, VecSetDMSourcecodeatpetsc4py/PETSc/Vec.pyx:3507Parametersdm (DM)

                     ReturntypeNonesetFromOptions()
                     Configure the vector from the options database.

                     Collective.

                     SEEALSO:WorkingwithPETScoptions, VecSetFromOptionsSourcecodeatpetsc4py/PETSc/Vec.pyx:1042ReturntypeNonesetLGMap(lgmap)
                     Set the local-to-global mapping.

                     Logically collective.

                     This allows users to insert vector entries using a local numbering with setValuesLocal.

                     SEEALSO:setValues, setValuesLocal, getLGMap, VecSetLocalToGlobalMappingSourcecodeatpetsc4py/PETSc/Vec.pyx:2884Parameterslgmap (LGMap)

                     ReturntypeNonesetMPIGhost(ghosts)
                     Set the ghost points for a ghosted vector.

                     Collective.

                     Parametersghosts (Sequence[int]) -- Global indices of ghost points.

                     ReturntypeNoneSEEALSO:createGhostSourcecodeatpetsc4py/PETSc/Vec.pyx:3366setNestSubVecs(sx,idxm=None)
                     Set the component vectors at specified indices in the nested vector.

                     Not collective.

                     Parameters

                            • sx (Sequence[Vec]) -- Array of component vectors.

                            • idxm  (Sequence[int]|None)  --  Indices  of the component vectors, defaults to
                              range(len(sx)).

                     ReturntypeNoneSEEALSO:getNestSubVecs, VecNestSetSubVecsSourcecodeatpetsc4py/PETSc/Vec.pyx:3473setOption(option,flag)
                     Set option.

                     Collective.

                     SEEALSO:VecSetOptionSourcecodeatpetsc4py/PETSc/Vec.pyx:1067Parameters

                            • option (Option)

                            • flag (bool)

                     ReturntypeNonesetOptionsPrefix(prefix)
                     Set the prefix used for searching for options in the database.

                     Logically collective.

                     SEEALSO:WorkingwithPETScoptions, getOptionsPrefix, VecSetOptionsPrefixSourcecodeatpetsc4py/PETSc/Vec.pyx:1000Parametersprefix (str|None)

                     ReturntypeNonesetRandom(random=None)
                     Set all components of the vector to random numbers.

                     Collective.

                     Parametersrandom (Random|None) -- Random number generator. If None then one will be  created
                            internally.

                     ReturntypeNoneSEEALSO:VecSetRandomSourcecodeatpetsc4py/PETSc/Vec.pyx:2317setSizes(size,bsize=None)
                     Set the local and global sizes of the vector.

                     Collective.

                     Parameters

                            • size (LayoutSizeSpec) -- Vector size.

                            • bsize (int|None) -- Vector block size. If None, bsize=1.

                     ReturntypeNoneSEEALSO:getSizes, VecSetSizesSourcecodeatpetsc4py/PETSc/Vec.pyx:218setType(vec_type)
                     Set the vector type.

                     Collective.

                     Parametersvec_type (Type|str) -- The vector type.

                     ReturntypeNoneSEEALSO:create, getType, VecSetTypeSourcecodeatpetsc4py/PETSc/Vec.pyx:199setUp()
                     Set up the internal data structures for using the vector.

                     Collective.

                     SEEALSO:create, destroy, VecSetUpSourcecodeatpetsc4py/PETSc/Vec.pyx:1054ReturntypeSelfsetValue(index,value,addv=None)
                     Insert or add a single value in the vector.

                     Not collective.

                     Parameters

                            • index (int) -- Location to write to. Negative indices are ignored.

                            • value (Scalar) -- Value to insert at index.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNone

                     Notes

                     The values may be cached so assemblyBegin and assemblyEnd must be called after all calls of
                     this method are completed.

                     Multiple  calls  to  setValue  cannot  be  made  with  different  values  for  addv without
                     intermediate calls to assemblyBegin and assemblyEnd.

                     SEEALSO:setValues, VecSetValuesSourcecodeatpetsc4py/PETSc/Vec.pyx:2771setValueLocal(index,value,addv=None)
                     Insert or add a single value in the vector using a local numbering.

                     Not collective.

                     Parameters

                            • index (int) -- Location to write to.

                            • value (Scalar) -- Value to insert at index.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNone

                     Notes

                     The values may be cached so assemblyBegin and assemblyEnd must be called after all calls of
                     this method are completed.

                     Multiple calls to setValueLocal cannot be made  with  different  values  for  addv  without
                     intermediate calls to assemblyBegin and assemblyEnd.

                     SEEALSO:setValuesLocal, VecSetValuesLocalSourcecodeatpetsc4py/PETSc/Vec.pyx:2914setValues(indices,values,addv=None)
                     Insert or add multiple values in the vector.

                     Not collective.

                     Parameters

                            • indices (Sequence[int]) -- Locations to write to. Negative indices are ignored.

                            • values (Sequence[Scalar]) -- Values to insert at indices.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNone

                     Notes

                     The values may be cached so assemblyBegin and assemblyEnd must be called after all calls of
                     this method are completed.

                     Multiple  calls  to  setValues  cannot  be  made  with  different  values  for addv without
                     intermediate calls to assemblyBegin and assemblyEnd.

                     SEEALSO:setValue, VecSetValuesSourcecodeatpetsc4py/PETSc/Vec.pyx:2808setValuesBlocked(indices,values,addv=None)
                     Insert or add blocks of values in the vector.

                     Not collective.

                     Equivalent to x[bs*indices[i]+j]=y[bs*i+j] for 0<=i<len(indices), 0<=j<bs and  bsblock_size.

                     Parameters

                            • indices  (Sequence[int])  --  Block  indices  to  write  to.  Negative indices are
                              ignored.

                            • values (Sequence[Scalar]) -- Values to  insert  at  indices.  Should  have  length
                              len(indices)*vec.block_size.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNone

                     Notes

                     The values may be cached so assemblyBegin and assemblyEnd must be called after all calls of
                     this method are completed.

                     Multiple  calls  to  setValuesBlocked cannot be made with different values for addv without
                     intermediate calls to assemblyBegin and assemblyEnd.

                     SEEALSO:setValues, VecSetValuesBlockedSourcecodeatpetsc4py/PETSc/Vec.pyx:2842setValuesBlockedLocal(indices,values,addv=None)
                     Insert or add blocks of values in the vector with a local numbering.

                     Not collective.

                     Equivalent to x[bs*indices[i]+j]=y[bs*i+j] for 0<=i<len(indices), 0<=j<bs and  bsblock_size.

                     Parameters

                            • indices (Sequence[int]) -- Local block indices to write to.

                            • values  (Sequence[Scalar])  --  Values  to  insert  at indices. Should have length
                              len(indices)*vec.block_size.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNone

                     Notes

                     The values may be cached so assemblyBegin and assemblyEnd must be called after all calls of
                     this method are completed.

                     Multiple calls to setValuesBlockedLocal cannot be  made  with  different  values  for  addv
                     without intermediate calls to assemblyBegin and assemblyEnd.

                     SEEALSO:setValuesBlocked, setValuesLocal, VecSetValuesBlockedLocalSourcecodeatpetsc4py/PETSc/Vec.pyx:2985setValuesLocal(indices,values,addv=None)
                     Insert or add multiple values in the vector with a local numbering.

                     Not collective.

                     Parameters

                            • indices (Sequence[int]) -- Locations to write to.

                            • values (Sequence[Scalar]) -- Values to insert at indices.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNone

                     Notes

                     The values may be cached so assemblyBegin and assemblyEnd must be called after all calls of
                     this method are completed.

                     Multiple  calls  to  setValuesLocal  cannot  be made with different values for addv without
                     intermediate calls to assemblyBegin and assemblyEnd.

                     SEEALSO:setValues, VecSetValuesLocalSourcecodeatpetsc4py/PETSc/Vec.pyx:2951setValuesStagStencil(indices,values,addv=None)
                     Not implemented.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:2880ReturntypeNoneshift(alpha)
                     Shift all entries in the vector.

                     Collective.

                     This method sets each entry (xₙ) in the vector to xₙ + ɑ.

                     Parametersalpha (Scalar) -- The shift to apply to the vector values.

                     ReturntypeNoneSEEALSO:scale, VecShiftSourcecodeatpetsc4py/PETSc/Vec.pyx:2423sqrtabs()
                     Replace each entry (xₙ) in the vector by √|xₙ|.

                     Logically collective.

                     SEEALSO:VecSqrtAbsSourcecodeatpetsc4py/PETSc/Vec.pyx:2281ReturntypeNonestrideGather(field,vec,addv=None)
                     Insert component values into a single-component vector.

                     Collective.

                     The current vector is expected to be multi-component (block_size greater than  1)  and  the
                     target vector is expected to be single-component.

                     Parameters

                            • field (int) -- Component index. Must be between 0 and vec.block_size.

                            • vec (Vec) -- Single-component vector to be inserted into.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:strideScatter, VecStrideScatterSourcecodeatpetsc4py/PETSc/Vec.pyx:3231strideMax(field)
                     Return the maximum of entries in a subvector.

                     Collective.

                     Equivalent to max(x[field],x[field+bs],x[field+2*bs],...) where bs is block_size.

                     Parametersfield (int) -- Component index. Must be between 0 and vec.block_size.

                     Returns

                            • int -- Location of maximum.

                            • float -- Maximum value.

                     Returntypetuple[int, float]

                     SEEALSO:strideScale, strideSum, strideMin, VecStrideMaxSourcecodeatpetsc4py/PETSc/Vec.pyx:3137strideMin(field)
                     Return the minimum of entries in a subvector.

                     Collective.

                     Equivalent to min(x[field],x[field+bs],x[field+2*bs],...) where bs is block_size.

                     Parametersfield (int) -- Component index. Must be between 0 and vec.block_size.

                     Returns

                            • int -- Location of minimum.

                            • float -- Minimum value.

                     Returntypetuple[int, float]

                     SEEALSO:strideScale, strideSum, strideMax, VecStrideMinSourcecodeatpetsc4py/PETSc/Vec.pyx:3106strideNorm(field,norm_type=None)
                     Return the norm of entries in a subvector.

                     Collective.

                     Equivalent to norm(x[field],x[field+bs],x[field+2*bs],...) where bs is block_size.

                     Parameters

                            • field (int) -- Component index. Must be between 0 and vec.block_size.

                            • norm_type (NormTypeSpec) -- The norm type.

                     Returntypefloat | tuple[float, float]

                     SEEALSO:norm, strideScale, strideSum, VecStrideNormSourcecodeatpetsc4py/PETSc/Vec.pyx:3168strideScale(field,alpha)
                     Scale a component of the vector.

                     Logically collective.

                     Parameters

                            • field (int) -- Component index. Must be between 0 and vec.block_size.

                            • alpha (Scalar) -- Factor to multiple the component entries by.

                     ReturntypeNoneSEEALSO:strideSum, strideMin, strideMax, VecStrideScaleSourcecodeatpetsc4py/PETSc/Vec.pyx:3062strideScatter(field,vec,addv=None)
                     Scatter entries into a component of another vector.

                     Collective.

                     The  current  vector  is  expected  to be single-component (block_size of 1) and the target
                     vector is expected to be multi-component.

                     Parameters

                            • field (int) -- Component index. Must be between 0 and vec.block_size.

                            • vec (Vec) -- Multi-component vector to be scattered into.

                            • addv (InsertModeSpec) -- Insertion mode.

                     ReturntypeNoneSEEALSO:strideGather, VecStrideScatterSourcecodeatpetsc4py/PETSc/Vec.pyx:3200strideSum(field)
                     Sum subvector entries.

                     Collective.

                     Equivalent to sum(x[field],x[field+bs],x[field+2*bs],...) where bs is block_size.

                     Parametersfield (int) -- Component index. Must be between 0 and vec.block_size.

                     ReturntypeScalarSEEALSO:strideScale, strideMin, strideMax, VecStrideSumSourcecodeatpetsc4py/PETSc/Vec.pyx:3083sum()  Return the sum of all the entries of the vector.

                     Collective.

                     SEEALSO:VecSumSourcecodeatpetsc4py/PETSc/Vec.pyx:2166ReturntypeScalarswap(vec)
                     Swap the content of two vectors.

                     Logically collective.

                     Parametersvec (Vec) -- The vector to swap data with.

                     ReturntypeNoneSEEALSO:VecSwapSourcecodeatpetsc4py/PETSc/Vec.pyx:2443tDot(vec)
                     Return the indefinite dot product with vec.

                     Collective.

                     This computes yᵀ·x with self as x, vec as y and where yᵀ denotes the transpose of y.

                     Parametersvec (Vec) -- Vector to compute the indefinite dot product with.

                     ReturntypeScalarSEEALSO:tDotBegin, tDotEnd, dot, VecTDotSourcecodeatpetsc4py/PETSc/Vec.pyx:1846tDotBegin(vec)
                     Begin computing the indefinite dot product.

                     Collective.

                     This should be paired with a call to tDotEnd.

                     Parametersvec (Vec) -- Vector to compute the indefinite dot product with.

                     ReturntypeNoneSEEALSO:tDotEnd, tDot, VecTDotBeginSourcecodeatpetsc4py/PETSc/Vec.pyx:1868tDotEnd(vec)
                     Finish computing the indefinite dot product initiated with tDotBegin.

                     Collective.

                     SEEALSO:tDotBegin, tDot, VecTDotEndSourcecodeatpetsc4py/PETSc/Vec.pyx:1888Parametersvec (Vec)

                     ReturntypeScalartoDLPack(mode='rw')
                     Return a DLPack PyCapsule wrapping the vector data.

                     Collective.

                     Parametersmode (AccessModeSpec) -- Access mode for the vector.

                     Returns
                            Capsule of a DLPack tensor wrapping a Vec.

                     ReturntypePyCapsule

                     Notes

                     It is important that the access mode is respected by the consumer as this is  not  enforced
                     internally.

                     SEEALSO:createWithDLPackSourcecodeatpetsc4py/PETSc/Vec.pyx:726view(viewer=None)
                     Display the vector.

                     Collective.

                     Parametersviewer (Viewer|None) -- A Viewer instance or None for the default viewer.

                     ReturntypeNoneSEEALSO:load, VecViewSourcecodeatpetsc4py/PETSc/Vec.pyx:144waxpy(alpha,x,y)
                     Compute and store w = ɑ·x + y.

                     Logically collective.

                     Parameters

                            • alpha (Scalar) -- Scale factor.

                            • x (Vec) -- First input vector.

                            • y (Vec) -- Second input vector.

                     ReturntypeNoneSEEALSO:axpy, aypx, axpby, maxpy, VecWAXPYSourcecodeatpetsc4py/PETSc/Vec.pyx:2547zeroEntries()
                     Set all entries in the vector to zero.

                     Logically collective.

                     SEEALSO:set, VecZeroEntriesSourcecodeatpetsc4py/PETSc/Vec.pyx:2358ReturntypeNone

              Attributes Documentation

              array  Alias for array_w.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3642array_r
                     Read-only ndarray containing the local portion of the vector.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3632array_w
                     Writeable ndarray containing the local portion of the vector.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3623block_size
                     The block size.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3598buffer Alias for buffer_w.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3637buffer_r
                     Read-only buffered view of the local portion of the vector.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3618buffer_w
                     Writeable buffered view of the local portion of the vector.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3613local_size
                     The local vector size.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3593owner_range
                     The locally owned range of indices in the form [low,high).

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3603owner_ranges
                     The range of indices owned by each process.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3608size   The global vector size.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3588sizes  The local and global vector sizes.

                     Sourcecodeatpetsc4py/PETSc/Vec.pyx:3580petsc4py.PETSc.Viewerclasspetsc4py.PETSc.Viewer
              Bases: Object

              Viewer object.

              Viewer is described in the PETScmanual.

              Viewers  can be called as functions where the argument specified is the PETSc object to be viewed.
              See the example below.

              Examples

              >>> from petsc4py import PETSc
              >>> u = PETSc.Vec().createWithArray([1,2])
              >>> v = PETSc.Viewer()
              >>> v(u)
              Vec Object: 1 MPI process
                type: seq
              1.
              2.

              SEEALSO:PetscViewer

              Enumerations
                                              ┌──────────┬───────────────────┐
                                              │ DrawSize │ Window size.      │
                                              ├──────────┼───────────────────┤
                                              │ FileMode │ Viewer file mode. │
                                              ├──────────┼───────────────────┤
                                              │ Format   │ Viewer format.    │
                                              ├──────────┼───────────────────┤
                                              │ Type     │ Viewer type.      │
                                              └──────────┴───────────────────┘

   petsc4py.PETSc.Viewer.DrawSizeclasspetsc4py.PETSc.Viewer.DrawSize
                     Bases: object

                     Window size.

                     Attributes Summary
                                        ┌──────────────┬───────────────────────────────────┐
                                        │ FULL         │ Constant FULL of type int         │
                                        ├──────────────┼───────────────────────────────────┤
                                        │ FULL_SIZE    │ Constant FULL_SIZE of type int    │
                                        ├──────────────┼───────────────────────────────────┤
                                        │ HALF         │ Constant HALF of type int         │
                                        ├──────────────┼───────────────────────────────────┤
                                        │ HALF_SIZE    │ Constant HALF_SIZE of type int    │
                                        ├──────────────┼───────────────────────────────────┤
                                        │ QUARTER      │ Constant QUARTER of type int      │
                                        ├──────────────┼───────────────────────────────────┤
                                        │ QUARTER_SIZE │ Constant QUARTER_SIZE of type int │
                                        ├──────────────┼───────────────────────────────────┤
                                        │ THIRD        │ Constant THIRD of type int        │
                                        ├──────────────┼───────────────────────────────────┤
                                        │ THIRD_SIZE   │ Constant THIRD_SIZE of type int   │
                                        └──────────────┴───────────────────────────────────┘

                     Attributes Documentation

                     FULL:int=FULL
                            Constant FULL of type intFULL_SIZE:int=FULL_SIZE
                            Constant FULL_SIZE of type intHALF:int=HALF
                            Constant HALF of type intHALF_SIZE:int=HALF_SIZE
                            Constant HALF_SIZE of type intQUARTER:int=QUARTER
                            Constant QUARTER of type intQUARTER_SIZE:int=QUARTER_SIZE
                            Constant QUARTER_SIZE of type intTHIRD:int=THIRD
                            Constant THIRD of type intTHIRD_SIZE:int=THIRD_SIZE
                            Constant THIRD_SIZE of type intpetsc4py.PETSc.Viewer.FileModeclasspetsc4py.PETSc.Viewer.FileMode
                     Bases: object

                     Viewer file mode.

                     Attributes Summary
                                       ┌───────────────┬────────────────────────────────────┐
                                       │ A             │ Constant A of type int             │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ APPEND        │ Constant APPEND of type int        │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ APPEND_UPDATE │ Constant APPEND_UPDATE of type int │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ AU            │ Constant AU of type int            │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ R             │ Constant R of type int             │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ READ          │ Constant READ of type int          │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ U             │ Constant U of type int             │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ UA            │ Constant UA of type int            │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ UPDATE        │ Constant UPDATE of type int        │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ W             │ Constant W of type int             │
                                       ├───────────────┼────────────────────────────────────┤
                                       │ WRITE         │ Constant WRITE of type int         │
                                       └───────────────┴────────────────────────────────────┘

                     Attributes Documentation

                     A:int=A
                            Constant A of type intAPPEND:int=APPEND
                            Constant APPEND of type intAPPEND_UPDATE:int=APPEND_UPDATE
                            Constant APPEND_UPDATE of type intAU:int=AU
                            Constant AU of type intR:int=R
                            Constant R of type intREAD:int=READ
                            Constant READ of type intU:int=U
                            Constant U of type intUA:int=UA
                            Constant UA of type intUPDATE:int=UPDATE
                            Constant UPDATE of type intW:int=W
                            Constant W of type intWRITE:int=WRITE
                            Constant WRITE of type intpetsc4py.PETSc.Viewer.Formatclasspetsc4py.PETSc.Viewer.Format
                     Bases: object

                     Viewer format.

                     Attributes Summary
                                   ┌────────────────────┬───────────────────────────────────────┐
                                   │ ASCII_COMMON       │ Constant ASCII_COMMON of type int     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_CSV          │ Constant ASCII_CSV of type int        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_DENSE        │ Constant ASCII_DENSE of type int      │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_FACTOR_INFO  │ Constant ASCII_FACTOR_INFO of type  ‐ │
                                   │                    │ int                                   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_GLVIS        │ Constant ASCII_GLVIS of type int      │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_IMPL         │ Constant ASCII_IMPL of type int       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_INDEX        │ Constant ASCII_INDEX of type int      │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_INFO         │ Constant ASCII_INFO of type int       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_INFO_DETAIL  │ Constant  ASCII_INFO_DETAIL of type ‐ │
                                   │                    │ int                                   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_LATEX        │ Constant ASCII_LATEX of type int      │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_MATHEMATICA  │ Constant ASCII_MATHEMATICA of type  ‐ │
                                   │                    │ int                                   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_MATLAB       │ Constant ASCII_MATLAB of type int     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_MATRIXMARKET │ Constant ASCII_MATRIXMARKET of type ‐ │
                                   │                    │ int                                   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_PCICE        │ Constant ASCII_PCICE of type int      │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_PYTHON       │ Constant ASCII_PYTHON of type int     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_SYMMODU      │ Constant ASCII_SYMMODU of type int    │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_VTK          │ Constant ASCII_VTK of type int        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_VTK_CELL     │ Constant ASCII_VTK_CELL of type int   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_VTK_COORDS   │ Constant ASCII_VTK_COORDS of type int │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ ASCII_XML          │ Constant ASCII_XML of type int        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ BINARY_MATLAB      │ Constant BINARY_MATLAB of type int    │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DEFAULT            │ Constant DEFAULT of type int          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DRAW_BASIC         │ Constant DRAW_BASIC of type int       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DRAW_CONTOUR       │ Constant DRAW_CONTOUR of type int     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DRAW_LG            │ Constant DRAW_LG of type int          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DRAW_LG_XRANGE     │ Constant DRAW_LG_XRANGE of type int   │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ DRAW_PORTS         │ Constant DRAW_PORTS of type int       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ FAILED             │ Constant FAILED of type int           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HDF5_MAT           │ Constant HDF5_MAT of type int         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HDF5_PETSC         │ Constant HDF5_PETSC of type int       │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HDF5_VIZ           │ Constant HDF5_VIZ of type int         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ HDF5_XDMF          │ Constant HDF5_XDMF of type int        │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ LOAD_BALANCE       │ Constant LOAD_BALANCE of type int     │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ NATIVE             │ Constant NATIVE of type int           │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ NOFORMAT           │ Constant NOFORMAT of type int         │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ VTK_VTR            │ Constant VTK_VTR of type int          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ VTK_VTS            │ Constant VTK_VTS of type int          │
                                   ├────────────────────┼───────────────────────────────────────┤
                                   │ VTK_VTU            │ Constant VTK_VTU of type int          │
                                   └────────────────────┴───────────────────────────────────────┘

                     Attributes Documentation

                     ASCII_COMMON:int=ASCII_COMMON
                            Constant ASCII_COMMON of type intASCII_CSV:int=ASCII_CSV
                            Constant ASCII_CSV of type intASCII_DENSE:int=ASCII_DENSE
                            Constant ASCII_DENSE of type intASCII_FACTOR_INFO:int=ASCII_FACTOR_INFO
                            Constant ASCII_FACTOR_INFO of type intASCII_GLVIS:int=ASCII_GLVIS
                            Constant ASCII_GLVIS of type intASCII_IMPL:int=ASCII_IMPL
                            Constant ASCII_IMPL of type intASCII_INDEX:int=ASCII_INDEX
                            Constant ASCII_INDEX of type intASCII_INFO:int=ASCII_INFO
                            Constant ASCII_INFO of type intASCII_INFO_DETAIL:int=ASCII_INFO_DETAIL
                            Constant ASCII_INFO_DETAIL of type intASCII_LATEX:int=ASCII_LATEX
                            Constant ASCII_LATEX of type intASCII_MATHEMATICA:int=ASCII_MATHEMATICA
                            Constant ASCII_MATHEMATICA of type intASCII_MATLAB:int=ASCII_MATLAB
                            Constant ASCII_MATLAB of type intASCII_MATRIXMARKET:int=ASCII_MATRIXMARKET
                            Constant ASCII_MATRIXMARKET of type intASCII_PCICE:int=ASCII_PCICE
                            Constant ASCII_PCICE of type intASCII_PYTHON:int=ASCII_PYTHON
                            Constant ASCII_PYTHON of type intASCII_SYMMODU:int=ASCII_SYMMODU
                            Constant ASCII_SYMMODU of type intASCII_VTK:int=ASCII_VTK
                            Constant ASCII_VTK of type intASCII_VTK_CELL:int=ASCII_VTK_CELL
                            Constant ASCII_VTK_CELL of type intASCII_VTK_COORDS:int=ASCII_VTK_COORDS
                            Constant ASCII_VTK_COORDS of type intASCII_XML:int=ASCII_XML
                            Constant ASCII_XML of type intBINARY_MATLAB:int=BINARY_MATLAB
                            Constant BINARY_MATLAB of type intDEFAULT:int=DEFAULT
                            Constant DEFAULT of type intDRAW_BASIC:int=DRAW_BASIC
                            Constant DRAW_BASIC of type intDRAW_CONTOUR:int=DRAW_CONTOUR
                            Constant DRAW_CONTOUR of type intDRAW_LG:int=DRAW_LG
                            Constant DRAW_LG of type intDRAW_LG_XRANGE:int=DRAW_LG_XRANGE
                            Constant DRAW_LG_XRANGE of type intDRAW_PORTS:int=DRAW_PORTS
                            Constant DRAW_PORTS of type intFAILED:int=FAILED
                            Constant FAILED of type intHDF5_MAT:int=HDF5_MAT
                            Constant HDF5_MAT of type intHDF5_PETSC:int=HDF5_PETSC
                            Constant HDF5_PETSC of type intHDF5_VIZ:int=HDF5_VIZ
                            Constant HDF5_VIZ of type intHDF5_XDMF:int=HDF5_XDMF
                            Constant HDF5_XDMF of type intLOAD_BALANCE:int=LOAD_BALANCE
                            Constant LOAD_BALANCE of type intNATIVE:int=NATIVE
                            Constant NATIVE of type intNOFORMAT:int=NOFORMAT
                            Constant NOFORMAT of type intVTK_VTR:int=VTK_VTR
                            Constant VTK_VTR of type intVTK_VTS:int=VTK_VTS
                            Constant VTK_VTS of type intVTK_VTU:int=VTK_VTU
                            Constant VTK_VTU of type intpetsc4py.PETSc.Viewer.Typeclasspetsc4py.PETSc.Viewer.Type
                     Bases: object

                     Viewer type.

                     Attributes Summary
                                          ┌─────────────┬────────────────────────────────┐
                                          │ ADIOS       │ Object ADIOS of type str       │
                                          ├─────────────┼────────────────────────────────┤
                                          │ ASCII       │ Object ASCII of type str       │
                                          ├─────────────┼────────────────────────────────┤
                                          │ BINARY      │ Object BINARY of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ DRAW        │ Object DRAW of type str        │
                                          ├─────────────┼────────────────────────────────┤
                                          │ EXODUSII    │ Object EXODUSII of type str    │
                                          ├─────────────┼────────────────────────────────┤
                                          │ GLVIS       │ Object GLVIS of type str       │
                                          ├─────────────┼────────────────────────────────┤
                                          │ HDF5        │ Object HDF5 of type str        │
                                          ├─────────────┼────────────────────────────────┤
                                          │ MATHEMATICA │ Object MATHEMATICA of type str │
                                          ├─────────────┼────────────────────────────────┤
                                          │ MATLAB      │ Object MATLAB of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ SAWS        │ Object SAWS of type str        │
                                          ├─────────────┼────────────────────────────────┤
                                          │ SOCKET      │ Object SOCKET of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ STRING      │ Object STRING of type str      │
                                          ├─────────────┼────────────────────────────────┤
                                          │ VTK         │ Object VTK of type str         │
                                          ├─────────────┼────────────────────────────────┤
                                          │ VU          │ Object VU of type str          │
                                          └─────────────┴────────────────────────────────┘

                     Attributes Documentation

                     ADIOS:str=ADIOS
                            Object ADIOS of type strASCII:str=ASCII
                            Object ASCII of type strBINARY:str=BINARY
                            Object BINARY of type strDRAW:str=DRAW
                            Object DRAW of type strEXODUSII:str=EXODUSII
                            Object EXODUSII of type strGLVIS:str=GLVIS
                            Object GLVIS of type strHDF5:str=HDF5
                            Object HDF5 of type strMATHEMATICA:str=MATHEMATICA
                            Object MATHEMATICA of type strMATLAB:str=MATLAB
                            Object MATLAB of type strSAWS:str=SAWS
                            Object SAWS of type strSOCKET:str=SOCKET
                            Object SOCKET of type strSTRING:str=STRING
                            Object STRING of type strVTK:str=VTK
                            Object VTK of type strVU:str=VU
                            Object VU of type str

              Methods Summary
                      ┌───────────────────────────────────────┬───────────────────────────────────────┐
                      │ ASCII(name[, comm])                   │ Return  an  ASCII  viewer  associated │
                      │                                       │ with the communicator.                │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ BINARY([comm])                        │ Return the default Type.BINARY viewer │
                      │                                       │ associated with the communicator.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ DRAW([comm])                          │ Return the default  Type.DRAW  viewer │
                      │                                       │ associated with the communicator.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ STDERR([comm])                        │ Return   the  standard  error  viewer │
                      │                                       │ associated with the communicator.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ STDOUT([comm])                        │ Return  the  standard  output  viewer │
                      │                                       │ associated with the communicator.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ addASCIITab(tabs)                     │ Increment the ASCII tab level.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ clearDraw()                           │ Reset graphics.                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ create([comm])                        │ Create a viewer.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createASCII(name[, mode, comm])       │ Create a viewer of type Type.ASCII.   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createBinary(name[, mode, comm])      │ Create a viewer of type Type.BINARY.  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createDraw([display, title, position, │ Create a Type.DRAW viewer.            │
                      │ size, ...])                           │                                       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createHDF5(name[, mode, comm])        │ Create a viewer of type Type.HDF5.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createMPIIO(name[, mode, comm])       │ Create  a  viewer of type Type.BINARY │
                      │                                       │ supporting MPI-IO.                    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ createVTK(name[, mode, comm])         │ Create a viewer of type Type.VTK.     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ destroy()                             │ Destroy the viewer.                   │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ flush()                               │ Flush the viewer.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getASCIITab()                         │ Return the ASCII tab level.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFileMode()                         │ Return the file mode.                 │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFileName()                         │ Return file name.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getFormat()                           │ Return the format of the viewer.      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getSubViewer([comm])                  │ Return  a   viewer   defined   on   a │
                      │                                       │ subcommunicator.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ getType()                             │ Return the type of the viewer.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ popASCIISynchronized()                │ Disallow ASCII synchronized calls.    │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ popASCIITab()                         │ Pop  an  additional  tab level pushed │
                      │                                       │ via pushASCIITab.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ popFormat()                           │ Pop format from the viewer.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ printfASCII(msg)                      │ Print a message.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ printfASCIISynchronized(msg)          │ Print a synchronized message.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pushASCIISynchronized()               │ Allow ASCII synchronized calls.       │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pushASCIITab()                        │ Push an additional tab level.         │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ pushFormat(format)                    │ Push format to the viewer.            │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ restoreSubViewer(sub)                 │ Restore  a  viewer   defined   on   a │
                      │                                       │ subcommunicator.                      │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setASCIITab(tabs)                     │ Set ASCII tab level.                  │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setDrawInfo([display,          title, │ Set   window   information   for    a │
                      │ position, size])                      │ Type.DRAW viewer.                     │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFileMode(mode)                     │ Set file mode.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setFileName(name)                     │ Set file name.                        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ setType(vwr_type)                     │ Set the type of the viewer.           │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ subtractASCIITab(tabs)                │ Decrement the ASCII tab level.        │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ useASCIITabs(flag)                    │ Enable/disable the use of ASCII tabs. │
                      ├───────────────────────────────────────┼───────────────────────────────────────┤
                      │ view([obj])                           │ View the viewer.                      │
                      └───────────────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              classmethodASCII(name,comm=None)
                     Return an ASCII viewer associated with the communicator.

                     Collective.

                     Parameters

                            • name (str) -- The filename.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeViewerSourcecodeatpetsc4py/PETSc/Viewer.pyx:580classmethodBINARY(comm=None)
                     Return the default Type.BINARY viewer associated with the communicator.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeViewerSourcecodeatpetsc4py/PETSc/Viewer.pyx:601classmethodDRAW(comm=None)
                     Return the default Type.DRAW viewer associated with the communicator.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeViewerSourcecodeatpetsc4py/PETSc/Viewer.pyx:619classmethodSTDERR(comm=None)
                     Return the standard error viewer associated with the communicator.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeViewerSourcecodeatpetsc4py/PETSc/Viewer.pyx:562classmethodSTDOUT(comm=None)
                     Return the standard output viewer associated with the communicator.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeViewerSourcecodeatpetsc4py/PETSc/Viewer.pyx:544addASCIITab(tabs)
                     Increment the ASCII tab level.

                     Collective.

                     SEEALSO:PetscViewerASCIIAddTabSourcecodeatpetsc4py/PETSc/Viewer.pyx:666Parameterstabs (int)

                     ReturntypeNoneclearDraw()
                     Reset graphics.

                     Not collective.

                     SEEALSO:PetscViewerDrawClearSourcecodeatpetsc4py/PETSc/Viewer.pyx:897ReturntypeNonecreate(comm=None)
                     Create a viewer.

                     Collective.

                     Parameterscomm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:Sys.getDefaultComm, PetscViewerCreateSourcecodeatpetsc4py/PETSc/Viewer.pyx:180createASCII(name,mode=None,comm=None)
                     Create a viewer of type Type.ASCII.

                     Collective.

                     Parameters

                            • name (str) -- The filename associated with the viewer.

                            • mode (FileMode|str|None) -- The mode type.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:create, setType, setFileMode, setFileName, Sys.getDefaultComm, setASCIITab, addASCIITab,
                        subtractASCIITab, getASCIITabSourcecodeatpetsc4py/PETSc/Viewer.pyx:201createBinary(name,mode=None,comm=None)
                     Create a viewer of type Type.BINARY.

                     Collective.

                     Parameters

                            • name (str) -- The filename associated with the viewer.

                            • mode (FileMode|str|None) -- The mode type.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:create, setType, setFileMode, setFileName, Sys.getDefaultCommSourcecodeatpetsc4py/PETSc/Viewer.pyx:239createDraw(display=None,title=None,position=None,size=None,comm=None)
                     Create a Type.DRAW viewer.

                     Collective.

                     Parameters

                            • display (str|None) -- The X display to use or None for the local machine.

                            • title (str|None) -- The window title or None for no title.

                            • position  (tuple[int,int]|None) -- Screen coordinates of the upper left corner,
                              or None for default.

                            • size (tuple[int,int]|int|None) -- Window size or None for default.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:Sys.getDefaultComm, PetscViewerDrawOpenSourcecodeatpetsc4py/PETSc/Viewer.pyx:381createHDF5(name,mode=None,comm=None)
                     Create a viewer of type Type.HDF5.

                     Collective.

                     Parameters

                            • name (str) -- The filename associated with the viewer.

                            • mode (FileMode|str|None) -- The mode type.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:create, setType, setFileMode, setFileName, Sys.getDefaultCommSourcecodeatpetsc4py/PETSc/Viewer.pyx:345createMPIIO(name,mode=None,comm=None)
                     Create a viewer of type Type.BINARY supporting MPI-IO.

                     Collective.

                     Parameters

                            • name (str) -- The filename associated with the viewer.

                            • mode (FileMode|str|None) -- The mode type.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:create, setType, setFileMode, setFileName, Sys.getDefaultCommSourcecodeatpetsc4py/PETSc/Viewer.pyx:272createVTK(name,mode=None,comm=None)
                     Create a viewer of type Type.VTK.

                     Collective.

                     Parameters

                            • name (str) -- The filename associated with the viewer.

                            • mode (FileMode|str|None) -- The mode type.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     Returntype
                            Self

                     SEEALSO:create, setType, setFileMode, setFileName, Sys.getDefaultCommSourcecodeatpetsc4py/PETSc/Viewer.pyx:309destroy()
                     Destroy the viewer.

                     Collective.

                     SEEALSO:PetscViewerDestroySourcecodeatpetsc4py/PETSc/Viewer.pyx:167ReturntypeSelfflush()
                     Flush the viewer.

                     Collective.

                     SEEALSO:PetscViewerFlushSourcecodeatpetsc4py/PETSc/Viewer.pyx:785ReturntypeNonegetASCIITab()
                     Return the ASCII tab level.

                     Not collective.

                     SEEALSO:setASCIITab, PetscViewerASCIIGetTabSourcecodeatpetsc4py/PETSc/Viewer.pyx:652ReturntypeintgetFileMode()
                     Return the file mode.

                     Not collective.

                     SEEALSO:setFileMode, PetscViewerFileGetModeSourcecodeatpetsc4py/PETSc/Viewer.pyx:809ReturntypeFileModegetFileName()
                     Return file name.

                     Not collective.

                     SEEALSO:setFileName, PetscViewerFileGetNameSourcecodeatpetsc4py/PETSc/Viewer.pyx:837ReturntypestrgetFormat()
                     Return the format of the viewer.

                     Not collective.

                     SEEALSO:pushFormat, popFormat, PetscViewerGetFormatSourcecodeatpetsc4py/PETSc/Viewer.pyx:464ReturntypeFormatgetSubViewer(comm=None)
                     Return a viewer defined on a subcommunicator.

                     Collective.

                     Parameterscomm (Comm|None) -- The subcommunicator. If None, uses COMM_SELF.

                     ReturntypeViewer

                     Notes

                     Users must call restoreSubViewer when done.

                     SEEALSO:restoreSubViewer, PetscViewerGetSubViewerSourcecodeatpetsc4py/PETSc/Viewer.pyx:502getType()
                     Return the type of the viewer.

                     Not collective.

                     SEEALSO:setType, PetscViewerGetTypeSourcecodeatpetsc4py/PETSc/Viewer.pyx:450ReturntypestrpopASCIISynchronized()
                     Disallow ASCII synchronized calls.

                     Collective.

                     SEEALSO:printfASCIISynchronized, pushASCIISynchronized, PetscViewerASCIIPopSynchronizedSourcecodeatpetsc4py/PETSc/Viewer.pyx:705ReturntypeNonepopASCIITab()
                     Pop an additional tab level pushed via pushASCIITab.

                     Collective.

                     SEEALSO:pushASCIITab, PetscViewerASCIIPopTabSourcecodeatpetsc4py/PETSc/Viewer.pyx:730ReturntypeNonepopFormat()
                     Pop format from the viewer.

                     Collective.

                     SEEALSO:pushFormat, PetscViewerPopFormatSourcecodeatpetsc4py/PETSc/Viewer.pyx:490ReturntypeNoneprintfASCII(msg)
                     Print a message.

                     Collective.

                     SEEALSO:PetscViewerASCIIPrintfSourcecodeatpetsc4py/PETSc/Viewer.pyx:755Parametersmsg (str)

                     ReturntypeNoneprintfASCIISynchronized(msg)
                     Print a synchronized message.

                     Collective.

                     SEEALSO:pushASCIISynchronized, PetscViewerASCIISynchronizedPrintfSourcecodeatpetsc4py/PETSc/Viewer.pyx:769Parametersmsg (str)

                     ReturntypeNonepushASCIISynchronized()
                     Allow ASCII synchronized calls.

                     Collective.

                     SEEALSO:printfASCIISynchronized, popASCIISynchronized, PetscViewerASCIIPushSynchronizedSourcecodeatpetsc4py/PETSc/Viewer.pyx:692ReturntypeNonepushASCIITab()
                     Push an additional tab level.

                     Collective.

                     SEEALSO:popASCIITab, PetscViewerASCIIPushTabSourcecodeatpetsc4py/PETSc/Viewer.pyx:718ReturntypeNonepushFormat(format)
                     Push format to the viewer.

                     Collective.

                     SEEALSO:popFormat, PetscViewerPushFormatSourcecodeatpetsc4py/PETSc/Viewer.pyx:478Parametersformat (Format)

                     ReturntypeNonerestoreSubViewer(sub)
                     Restore a viewer defined on a subcommunicator.

                     Collective.

                     Parameterssub (Viewer) -- The subviewer obtained from getSubViewer.

                     ReturntypeNoneSEEALSO:getSubViewer, PetscViewerRestoreSubViewerSourcecodeatpetsc4py/PETSc/Viewer.pyx:526setASCIITab(tabs)
                     Set ASCII tab level.

                     Collective.

                     SEEALSO:getASCIITab, PetscViewerASCIISetTabSourcecodeatpetsc4py/PETSc/Viewer.pyx:639Parameterstabs (int)

                     ReturntypeNonesetDrawInfo(display=None,title=None,position=None,size=None)
                     Set window information for a Type.DRAW viewer.

                     Collective.

                     Parameters

                            • display (str|None) -- The X display to use or None for the local machine.

                            • title (str|None) -- The window title or None for no title.

                            • position (tuple[int,int]|None) -- Screen coordinates of the upper left  corner,
                              or None for default.

                            • size (tuple[int,int]|int|None) -- Window size or None for default.

                     ReturntypeNoneSourcecodeatpetsc4py/PETSc/Viewer.pyx:853setFileMode(mode)
                     Set file mode.

                     Collective.

                     SEEALSO:getFileMode, PetscViewerFileSetModeSourcecodeatpetsc4py/PETSc/Viewer.pyx:797Parametersmode (FileMode|str)

                     ReturntypeNonesetFileName(name)
                     Set file name.

                     Collective.

                     SEEALSO:getFileName, PetscViewerFileSetNameSourcecodeatpetsc4py/PETSc/Viewer.pyx:823Parametersname (str)

                     ReturntypeNonesetType(vwr_type)
                     Set the type of the viewer.

                     Logically collective.

                     Parametersvwr_type (Type|str) -- The type of the viewer.

                     ReturntypeNoneSEEALSO:getType, PetscViewerSetTypeSourcecodeatpetsc4py/PETSc/Viewer.pyx:431subtractASCIITab(tabs)
                     Decrement the ASCII tab level.

                     Collective.

                     SEEALSO:PetscViewerASCIISubtractTabSourcecodeatpetsc4py/PETSc/Viewer.pyx:679Parameterstabs (int)

                     ReturntypeNoneuseASCIITabs(flag)
                     Enable/disable the use of ASCII tabs.

                     Collective.

                     SEEALSO:PetscViewerASCIIUseTabsSourcecodeatpetsc4py/PETSc/Viewer.pyx:742Parametersflag (bool)

                     ReturntypeNoneview(obj=None)
                     View the viewer.

                     Collective.

                     Parametersobj  (Viewer|Object|None) -- A Viewer instance or None for the default viewer.
                            If none of the above applies, it assumes obj is an instance of Object and  it  calls
                            the generic view for obj.

                     ReturntypeNone

                     Notes

                     SEEALSO:PetscViewerViewSourcecodeatpetsc4py/PETSc/Viewer.pyx:139petsc4py.PETSc.ViewerHDF5classpetsc4py.PETSc.ViewerHDF5
              Bases: Viewer

              Viewer object for HDF5 file formats.

              Viewer is described in the PETScmanual.

              SEEALSO:Viewer

              Methods Summary
                           ┌────────────────────────────┬───────────────────────────────────────┐
                           │ create(name[, mode, comm]) │ Create a viewer of type Type.HDF5.    │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getGroup()                 │ Return the current group.             │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ getTimestep()              │ Return the current time step.         │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ incrementTimestep()        │ Increment the time step.              │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ popGroup()                 │ Pop the current group from the stack. │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ popTimestepping()          │ Deactivate the timestepping mode.     │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ pushGroup(group)           │ Set the current group.                │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ pushTimestepping()         │ Activate the timestepping mode.       │
                           ├────────────────────────────┼───────────────────────────────────────┤
                           │ setTimestep(timestep)      │ Set the current time step.            │
                           └────────────────────────────┴───────────────────────────────────────┘

              Methods Documentation

              create(name,mode=None,comm=None)
                     Create a viewer of type Type.HDF5.

                     Collective.

                     Parameters

                            • name (str) -- The filename associated with the viewer.

                            • mode (FileMode|str|None) -- The mode type.

                            • comm (Comm|None) -- MPI communicator, defaults to Sys.getDefaultComm.

                     ReturntypeSelfSEEALSO:Viewer.createHDF5Sourcecodeatpetsc4py/PETSc/Viewer.pyx:922getGroup()
                     Return the current group.

                     Not collective.

                     SEEALSO:pushGroup, popGroup, PetscViewerHDF5GetGroupSourcecodeatpetsc4py/PETSc/Viewer.pyx:1049ReturntypestrgetTimestep()
                     Return the current time step.

                     Not collective.

                     SEEALSO:pushTimestepping, setTimestep, incrementTimestep, PetscViewerHDF5GetTimestepSourcecodeatpetsc4py/PETSc/Viewer.pyx:982ReturntypeintincrementTimestep()
                     Increment the time step.

                     Logically collective.

                     SEEALSO:pushTimestepping, setTimestep, getTimestep, PetscViewerHDF5IncrementTimestepSourcecodeatpetsc4py/PETSc/Viewer.pyx:1010ReturntypeNonepopGroup()
                     Pop the current group from the stack.

                     Logically collective.

                     SEEALSO:pushGroup, getGroup, PetscViewerHDF5PopGroupSourcecodeatpetsc4py/PETSc/Viewer.pyx:1037ReturntypeNonepopTimestepping()
                     Deactivate the timestepping mode.

                     Logically collective.

                     SEEALSO:pushTimestepping, PetscViewerHDF5PopTimesteppingSourcecodeatpetsc4py/PETSc/Viewer.pyx:970ReturntypeNonepushGroup(group)
                     Set the current group.

                     Logically collective.

                     SEEALSO:popGroup, getGroup, PetscViewerHDF5PushGroupSourcecodeatpetsc4py/PETSc/Viewer.pyx:1023Parametersgroup (str)

                     ReturntypeNonepushTimestepping()
                     Activate the timestepping mode.

                     Logically collective.

                     SEEALSO:popTimestepping, PetscViewerHDF5PushTimesteppingSourcecodeatpetsc4py/PETSc/Viewer.pyx:958ReturntypeNonesetTimestep(timestep)
                     Set the current time step.

                     Logically collective.

                     SEEALSO:pushTimestepping, getTimestep, incrementTimestep, PetscViewerHDF5SetTimestepSourcecodeatpetsc4py/PETSc/Viewer.pyx:997Parameterstimestep (int)

                     ReturntypeNone

       Exceptions
                                               ┌───────┬──────────────┐
                                               │ Error │ PETSc Error. │
                                               └───────┴──────────────┘

   petsc4py.PETSc.Errorexceptionpetsc4py.PETSc.Error
              PETSc Error.

              ierr   PETSc error code.

                     Typeint

       Functions
                         ┌─────────────────────────┬───────────────────────────────────────┐
                         │ garbage_cleanup([comm]) │ Clean up unused PETSc objects.        │
                         ├─────────────────────────┼───────────────────────────────────────┤
                         │ garbage_view([comm])    │ Print  summary  of  the garbage PETSc │
                         │                         │ objects.                              │
                         └─────────────────────────┴───────────────────────────────────────┘

   petsc4py.PETSc.garbage_cleanuppetsc4py.PETSc.garbage_cleanup(comm=None)
              Clean up unused PETSc objects.

              Collective.

              Notes

              If the communicator comm if not provided or it is None, then COMM_WORLD is used.

              Sourcecodeatpetsc4py/PETSc/cyclicgc.pxi:39Parameterscomm (Comm|None)

              ReturntypeNonepetsc4py.PETSc.garbage_viewpetsc4py.PETSc.garbage_view(comm=None)
              Print summary of the garbage PETSc objects.

              Collective.

              Notes

              Print out garbage summary on each rank of the communicator comm.  If no communicator  is  provided
              then COMM_WORLD is used.

              Sourcecodeatpetsc4py/PETSc/cyclicgc.pxi:63Parameterscomm (Comm|None)

              ReturntypeNone

       Attributes
                                   ┌────────────┬────────────────────────────────┐
                                   │ DECIDE     │ Constant DECIDE of type int    │
                                   ├────────────┼────────────────────────────────┤
                                   │ DEFAULT    │ Constant DEFAULT of type int   │
                                   ├────────────┼────────────────────────────────┤
                                   │ DETERMINE  │ Constant DETERMINE of type int │
                                   ├────────────┼────────────────────────────────┤
                                   │ CURRENT    │ Constant CURRENT of type int   │
                                   ├────────────┼────────────────────────────────┤
                                   │ UNLIMITED  │ Constant UNLIMITED of type int │
                                   ├────────────┼────────────────────────────────┤
                                   │ INFINITY   │ Object INFINITY of type float  │
                                   ├────────────┼────────────────────────────────┤
                                   │ NINFINITY  │ Object NINFINITY of type float │
                                   ├────────────┼────────────────────────────────┤
                                   │ PINFINITY  │ Object PINFINITY of type float │
                                   ├────────────┼────────────────────────────────┤
                                   │ COMM_NULL  │ Object COMM_NULL of type Comm  │
                                   ├────────────┼────────────────────────────────┤
                                   │ COMM_SELF  │ Object COMM_SELF of type Comm  │
                                   ├────────────┼────────────────────────────────┤
                                   │ COMM_WORLD │ Object COMM_WORLD of type Comm │
                                   └────────────┴────────────────────────────────┘

   petsc4py.PETSc.DECIDEpetsc4py.PETSc.DECIDE:int=DECIDE
              Constant DECIDE of type intpetsc4py.PETSc.DEFAULTpetsc4py.PETSc.DEFAULT:int=DEFAULT
              Constant DEFAULT of type intpetsc4py.PETSc.DETERMINEpetsc4py.PETSc.DETERMINE:int=DETERMINE
              Constant DETERMINE of type intpetsc4py.PETSc.CURRENTpetsc4py.PETSc.CURRENT:int=CURRENT
              Constant CURRENT of type intpetsc4py.PETSc.UNLIMITEDpetsc4py.PETSc.UNLIMITED:int=UNLIMITED
              Constant UNLIMITED of type intpetsc4py.PETSc.INFINITYpetsc4py.PETSc.INFINITY:float=INFINITY
              Object INFINITY of type floatpetsc4py.PETSc.NINFINITYpetsc4py.PETSc.NINFINITY:float=NINFINITY
              Object NINFINITY of type floatpetsc4py.PETSc.PINFINITYpetsc4py.PETSc.PINFINITY:float=PINFINITY
              Object PINFINITY of type floatpetsc4py.PETSc.COMM_NULLpetsc4py.PETSc.COMM_NULL:Comm=COMM_NULL
              Object COMM_NULL of type Commpetsc4py.PETSc.COMM_SELFpetsc4py.PETSc.COMM_SELF:Comm=COMM_SELF
              Object COMM_SELF of type Commpetsc4py.PETSc.COMM_WORLDpetsc4py.PETSc.COMM_WORLD:Comm=COMM_WORLD
              Object COMM_WORLD of type Comm