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