SNES

  • basic uniprocessor example Uses Newton's method to solve a two-variable system.
  • basic uniprocessor example

  • basic uniprocessor example Uses Newton-like methods to solve u'' + u^{2} = f.
    This example employs a user-defined monitoring routine.
  • setting a user-defined monitoring routine Uses Newton-like methods to solve u'' + u^{2} = f.
    This example employs a user-defined monitoring routine.
  • setting a user-defined monitoring routine Uses Newton-like methods to solve u'' + u^{2} = f in parallel.
    This example employs a user-defined monitoring routine and optionally a user-defined
    routine to check candidate iterates produced by line search routines. This code also
    demonstrates use of the macro __FUNC__ to define routine names for use in error handling.
  • basic parallel example Uses Newton-like methods to solve u'' + u^{2} = f in parallel.
    This example employs a user-defined monitoring routine and optionally a user-defined
    routine to check candidate iterates produced by line search routines. This code also
    demonstrates use of the macro __FUNC__ to define routine names for use in error handling.
  • sequential Bratu example Solves a nonlinear system on 1 processor with SNES. We
    solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular domain.
    This example also illustrates the use of matrix coloring. Runtime options include:
    -par <parameter>, where <parameter> indicates the problem's nonlinearity
    problem SFI: <parameter> = Bratu parameter (0 <= par <= 6.81)
    -mx <xg>, where <xg> = number of grid points in the x-direction
    -my <yg>, where <yg> = number of grid points in the y-direction
  • sequential Bratu example
    Description: This example solves a nonlinear system on 1 processor with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
  • parallel Bratu example Solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • parallel Bratu example Solves a simple nonlinear system in parallel with SNES.
    The Jacobian for this problem has a null space, this example shows how it can
    be treated with the matrix free code:
    -par <parameter>, where <parameter> indicates the problem's nonlinearity
    problem SFI: <parameter> = Bratu parameter (0 <= par <= 6.81)
    -mx <xg>, where <xg> = number of grid points in the x-direction
    -my <yg>, where <yg> = number of grid points in the y-direction
    -Nx <npx>, where <npx> = number of processors in the x-direction
    -Ny <npy>, where <npy> = number of processors in the y-direction
  • parallel Bratu example Solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 3D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • parallel Bratu example Solves nonlinear PDE system.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • parallel Bratu example Solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • parallel Bratu example
    Program usage: mpirun -np <procs> ex5f [-help] [all PETSc options]

    Description: This example solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • parallel Bratu example
    Description: This example solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • parallel Bratu example Solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • parallel Bratu example Solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, uses SHARED MEMORY to evaluate the user function.
  • solving a system of nonlinear equations (parallel Bratu example); Solves a nonlinear system in parallel with SNES.
    We solve the modified Bratu problem in a 2D rectangular domain,
    using distributed arrays (DAs) to partition the parallel grid.
  • solving a system of nonlinear equations (parallel Bratu example); Solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • different matrices for the Jacobian and preconditioner; Uses Newton-like methods to solve u`` + u^{2} = f. Different
    matrices are used for the Jacobian and the preconditioner. The code also
    demonstrates the use of matrix-free Newton-Krylov methods in conjunction
    with a user-provided preconditioner. Input arguments are:
    -snes_mf : Use matrix-free Newton methods
    -user_precond : Employ a user-defined preconditioner. Used only with
    matrix-free methods in this example.
  • matrix-free methods Uses Newton-like methods to solve u`` + u^{2} = f. Different
    matrices are used for the Jacobian and the preconditioner. The code also
    demonstrates the use of matrix-free Newton-Krylov methods in conjunction
    with a user-provided preconditioner. Input arguments are:
    -snes_mf : Use matrix-free Newton methods
    -user_precond : Employ a user-defined preconditioner. Used only with
    matrix-free methods in this example.
  • user-provided preconditioner; Uses Newton-like methods to solve u`` + u^{2} = f. Different
    matrices are used for the Jacobian and the preconditioner. The code also
    demonstrates the use of matrix-free Newton-Krylov methods in conjunction
    with a user-provided preconditioner. Input arguments are:
    -snes_mf : Use matrix-free Newton methods
    -user_precond : Employ a user-defined preconditioner. Used only with
    matrix-free methods in this example.
  • parallel multicomponent example; Solves a nonlinear system in parallel with SNES.
    We solve the driven cavity problem in a streamfunction-vorticity formulation.
    -mx <xg>, where <xg> = number of grid points in the x-direction
    -my <yg>, where <yg> = number of grid points in the y-direction
    -Nx <npx>, where <npx> = number of processors in the x-direction
    -Ny <npy>, where <npy> = number of processors in the y-direction
  • parallel multicomponent example Solves a nonlinear system in parallel with SNES.

    The 2D driven cavity problem is solved in a velocity-vorticity formulation.
    The flow can be driven with the lid or with bouyancy or both:
    -lidvelocity <lid>, where <lid> = dimensionless velocity of lid
    -grashof <gr>, where <gr> = dimensionless temperature gradient
    -prandtl <pr>, where <pr> = dimensionless thermal/momentum diffusity ratio
    Mesh parameters are:
    -mx <xg>, where <xg> = number of grid points in the x-direction
    -my <yg>, where <yg> = number of grid points in the y-direction
    -printg : print grid information
    Graphics of the contours of (U,V,Omega,T) are available on each grid:
    -contours : draw contour plots of solution
    Parallelism can be invoked based on the DA construct:
    -Nx <npx>, where <npx> = number of processors in the x-direction
    -Ny <npy>, where <npy> = number of processors in the y-direction
  • parallel multicomponent example Solves a nonlinear system in parallel with SNES.

    The 2D driven cavity problem is solved in a velocity-vorticity formulation.
    The flow can be driven with the lid or with bouyancy or both:
    -lidvelocity <lid>, where <lid> = dimensionless velocity of lid
    -grashof <gr>, where <gr> = dimensionless temperature gradient
    -prandtl <pr>, where <pr> = dimensionless thermal/momentum diffusity ratio
    Mesh sequencing is available, starting coarse and recursively doubling:
    -mx <xg>, where <xg> = initial number of grid points in the x-direction
    -my <yg>, where <yg> = initial number of grid points in the y-direction
    -nlevels <nlevels>, where <nlevels> = number of refinement levels
    -printg : print grid information
    Graphics of the contours of (U,V,Omega,T) are available on each grid:
    -contours : draw contour plots of solution
    Parallelism can be invoked based on the DA construct:
    -Nx <npx>, where <npx> = number of processors in the x-direction
    -Ny <npy>, where <npy> = number of processors in the y-direction
  • parallel Bratu example in 3d Solves a nonlinear system in parallel with SNES.
    We solve the Bratu (SFI - solid fuel ignition) problem in a 3D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • solving a system of nonlinear equations (parallel example); This program demonstrates use of the SNES package to solve systems of
    nonlinear equations in parallel, using 2-dimensional distributed arrays.
    A 2-dim simplified Radiative transport test problem is used, with analytic Jacobian.

    Solves the linear systems via multilevel methods

    The command line
    options are:
    -tleft <tl>, where <tl> indicates the left Diriclet BC
    -tright <tr>, where <tr> indicates the right Diriclet BC
    -Mx <xv>, where <xv> = number of coarse control volumes in the x-direction
    -My <yv>, where <yv> = number of coarse control volumes in the y-direction
    -ratio <r>, where <r> = ratio of fine volumes in each coarse in both x,y
    -Nx <npx>, where <npx> = number of processors in the x-direction
    -Ny <npy>, where <npy> = number of processors in the y-direction
  • solving a system of nonlinear equations (parallel example); This program demonstrates use of the SNES package to solve systems of
    nonlinear equations in parallel, using 3-dimensional distributed arrays.
    A 3-dimensional simplified RT test problem is used, with analytic Jacobian.

    Solves the linear systems via multilevel methods

    The command line
    options are:
    -tleft <tl>, where <tl> indicates the left Dirichlet BC
    -tright <tr>, where <tr> indicates the right Dirichlet BC
    -mx <xv>, where <xv> = number of coarse control volumes in the x-direction
    -my <yv>, where <yv> = number of coarse control volumes in the y-direction
    -mz <zv>, where <zv> = number of coarse control volumes in the z-direction
    -nlevels <nl>, where <nl> = number of multigrid levels
    -ratio <r>, where <r> = ratio of fine volumes in each coarse in x,y,z
    -Nx <npx>, where <npx> = number of processors in the x-direction
    -Ny <npy>, where <npy> = number of processors in the y-direction
    -Nz <npz>, where <npz> = number of processors in the z-direction
    -beta <b>, where <b> = beta
    -bm1 <bminus1>, where <bminus1> = beta - 1
    -coef <c>, where <c> = beta / 2
  • solving a system of nonlinear equations Solves nonlinear Radiative Transport PDE with multigrid.
    Uses 2-dimensional distributed arrays.
    A 2-dim simplified Radiative Transport test problem is used, with analytic Jacobian.

    Solves the linear systems via multilevel methods

    The command line
    options are:
    -tleft <tl>, where <tl> indicates the left Diriclet BC
    -tright <tr>, where <tr> indicates the right Diriclet BC
    -mx <xv>, where <xv> = number of coarse control volumes in the x-direction
    -my <yv>, where <yv> = number of coarse control volumes in the y-direction
    -ratio <r>, where <r> = ratio of fine volumes in each coarse in both x,y
  • solving a system of nonlinear equations (parallel multicomponent example); Solves nonlinear driven cavity with multigrid.

    The 2D driven cavity problem is solved in a velocity-vorticity formulation.
    The flow can be driven with the lid or with bouyancy or both:
    -lidvelocity <lid>, where <lid> = dimensionless velocity of lid
    -grashof <gr>, where <gr> = dimensionless temperature gradient
    -prandtl <pr>, where <pr> = dimensionless thermal/momentum diffusity ratio
    Mesh parameters are:
    -mx <xg>, where <xg> = number of grid points in the x-direction
    -my <yg>, where <yg> = number of grid points in the y-direction
    -printg : print grid information
    Graphics of the contours of (U,V,Omega,T) are available on each grid:
    -contours : draw contour plots of solution
    Parallelism can be invoked based on the DA construct:
    -Nx <npx>, where <npx> = number of processors in the x-direction
    -Ny <npy>, where <npy> = number of processors in the y-direction