DA

  • using distributed arrays; Solves a nonlinear system in parallel with a user-defined
    Newton method that uses SLES to solve the linearized Newton sytems. This solver
    is a very simplistic inexact Newton method. The intent of this code is to
    demonstrate the repeated solution of linear sytems with the same nonzero pattern.

    This is NOT the recommended approach for solving nonlinear problems with PETSc!
    We urge users to employ the SNES component for solving nonlinear problems whenever
    possible, as it offers many advantages over coding nonlinear solvers independently.

    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.
  • using distributed arrays; 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.
  • using distributed arrays; 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.
  • using distributed arrays; 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
  • using distributed arrays; 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.
  • using distributed arrays; 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.
  • using distributed arrays; 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
  • using distributed arrays; 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.
  • using distributed arrays; 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.
  • using distributed arrays; 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.
  • using distributed arrays;
    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.
  • using distributed arrays;
    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.
  • using distributed arrays; 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.
  • using distributed arrays; 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
  • using distributed arrays; 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
  • using distributed arrays; 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
  • using distributed arrays

    Solves a nonlinear system in parallel with a user-defined
    Newton method that uses SLES to solve the linearized Newton sytems. This solver
    is a very simplistic inexact Newton method. The intent of this code is to
    demonstrate the repeated solution of linear sytems with the same nonzero pattern.

    This is NOT the recommended approach for solving nonlinear problems with PETSc!
    We urge users to employ the SNES component for solving nonlinear problems whenever
    possible, as it offers many advantages over coding nonlinear solvers independently.

    We solve the Bratu (SFI - solid fuel ignition) problem in a 2D rectangular
    domain, using distributed arrays (DAs) to partition the parallel grid.

  • using distributed arrays 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
  • using distributed arrays 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
  • using distributed arrays 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