LibMesh Experience and Usage

Transcription

1 LibMesh Experience and Usage John W. Peterson and Roy H. Stogner Univ. of Texas at Austin September 9, 2008

2 1 Introduction 2 Weighted Residuals 3 Poisson Equation 4 Other Examples 5 Essential BCs 6 Some Extensions

3 1 Introduction 2 Weighted Residuals 3 Poisson Equation 4 Other Examples 5 Essential BCs 6 Some Extensions

4 Library Description Tumor Angiogenesis Compressible RBM NS Petsc Laspack DD LibMesh STL Metis Library Structure Basic libraries are LibMesh s roots Application branches built off the library trunk Mpich

5 A Generic BVP We assume there is a Boundary Value Problem of the form M u t = F(u) Ω G(u) = 0 Ω u = u D Ω D Ω Ω D N(u) = 0 Ω N u(x, 0) = u 0 (x) Ω N

6 A Generic BVP Associated to the problem domain Ω is a LibMesh data structure called a Mesh A Mesh is essentially a collection of finite elements Ω h Ω h := e Ω e

7 A Generic BVP Associated to the problem domain Ω is a LibMesh data structure called a Mesh A Mesh is essentially a collection of finite elements Ω h Ω h := e Ω e LibMesh provides some simple structured mesh generation routines, file inputs, and interfaces to Triangle and TetGen.

8 Non-Trivial Applications LibMesh provides several of the tools necessary to construct these systems, but it is not specifically written to solve any one problem. First, a few of the non-trivial applications which have been built on top of the library.

9 Natural Convection Tetrahedral mesh of pipe geometry. Stream ribbons colored by temperature.

10 Surface-Tension-Driven Flow Adaptive grid solution shown with temperature contours and velocity vectors.

11 Double-Diffusive Convection Solute contours: a plume of warm, low-salinity fluid is convected upward through a porous medium.

12 Tumor Angiogenesis The tumor secretes a chemical which stimulates blood vessel formation.

13 Phase Separation Directed pattern self-assembly in spinodal decomposition of binary mixture

14 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

15 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

16 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

17 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

18 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

19 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

20 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

21 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

22 Compressible Flow Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler. Includes both SUPG and a shock capturing scheme. Original redistribution code written by Larisa Branets. Simultaneous optimization of element shape and size. Directable via user supplied error estimate. Integration work done by Derek Gaston. Combination of redistribution, h refinement. Applicable to other problem classes.

23 Compressible Flow Problem Specification The problem studied is that of an oblique shock generated by a 10 o wedge angle. This problem has an exact solution for density which is a step function. Utilizing libmesh s exact solution capability the exact L 2 error can be solved for. The exact solution is shown below:

24 Compressible Flow Problem Specification The problem studied is that of an oblique shock generated by a 10 o wedge angle. This problem has an exact solution for density which is a step function. Utilizing libmesh s exact solution capability the exact L 2 error can be solved for. The exact solution is shown below:

25 Compressible Flow Problem Specification The problem studied is that of an oblique shock generated by a 10 o wedge angle. This problem has an exact solution for density which is a step function. Utilizing libmesh s exact solution capability the exact L 2 error can be solved for. The exact solution is shown below:

26 Compressible Flow Problem Specification The problem studied is that of an oblique shock generated by a 10 o wedge angle. This problem has an exact solution for density which is a step function. Utilizing libmesh s exact solution capability the exact L 2 error can be solved for. The exact solution is shown below:

27 Compressible Flow Uniformly Refined Solutions For comparison purposes, here is a mesh and a solution after 1 uniform refinement with DOFs. 1 1 r y y x x (a) Mesh after 1 uniform refinement. (b) Solution after 1 uniform refinement.

28 Compressible Flow H-Adapted Solutions A flux jump indicator was employed as the error indcator along with a statistical flagging scheme. Here is a mesh and solution after 2 adaptive refinements containing DOFs: 1 1 r y y x x

29 Compressible Flow H-Adapted Solutions A flux jump indicator was employed as the error indcator along with a statistical flagging scheme. Here is a mesh and solution after 2 adaptive refinements containing DOFs: 1 1 r y y x x

30 Compressible Flow Redistributed Solutions Redistribution utilizing the same flux jump indicator. 1 1 r y y x (g) Mesh, 8 redistribution steps x (h) Solution

31 Compressible Flow Redistributed and Adapted Now combining the two, here are the mesh and solution after 2 adaptations beyond the previous redistribution containing DOFs. 1 1 r y y x (i) Mesh, 2 refinements x (j) Solution

32 Compressible Flow Solution Comparison For a better comparison here are 3 of the solutions, each with around DOFs: r r r y y y x (k) Uniform x (l) Adaptive x (m) R + H.

33 2 0 Compressible Flow Error Plot libmesh provides capability for computing error norms against an exact solution. The exact solution is not in H 1 therefore we only obtain the L 2 convergence plot: -1.2 Uniform Adaptivity Redist + Adapt (L Error ) log log 10 D ofs

34 2 0 Compressible Flow Error Plot libmesh provides capability for computing error norms against an exact solution. The exact solution is not in H 1 therefore we only obtain the L 2 convergence plot: -1.2 Uniform Adaptivity Redist + Adapt (L Error ) log log 10 D ofs

35 Outline Introduction Compressible Flow Weighted Residuals Poisson Equation Other Examples Essential BCs Some Extensions Reference

36 1 Introduction 2 Weighted Residuals 3 Poisson Equation 4 Other Examples 5 Essential BCs 6 Some Extensions

37 The point of departure in any FE analysis which uses LibMesh is the weighted residual statement (F(u), v) = 0 v V Or, more precisely, the weighted residual statement associated with the finite-dimensional space V h V (F(u h ), v h ) = 0 v h V h

38 The point of departure in any FE analysis which uses LibMesh is the weighted residual statement (F(u), v) = 0 v V Or, more precisely, the weighted residual statement associated with the finite-dimensional space V h V (F(u h ), v h ) = 0 v h V h

39 Some Examples Poisson Equation u = f Ω

40 Some Examples Poisson Equation u = f Ω Weighted Residual Statement (F(u), v) := [ u v fv] dx Ω + ( u n) v ds Ω N

41 Some Examples Linear Convection-Diffusion k u + b u = f Ω

42 Some Examples Linear Convection-Diffusion k u + b u = f Ω Weighted Residual Statement (F(u), v) := [k u v + (b u)v fv] dx Ω + k ( u n) v ds Ω N

43 Some Examples Stokes Flow p ν u = f u = 0 Ω

44 Some Examples Stokes Flow p ν u = f u = 0 Ω Weighted Residual Statement u := [u, p], v := [v, q] (F(u), v) := [ p ( v) + ν u: v f v Ω + ( u) q] dx + (ν u pi) n v ds Ω N

45 Some Examples To obtain the approximate problem, we simply replace u u h, v v h, and Ω Ω h in the weighted residual statement.

46 1 Introduction 2 Weighted Residuals 3 Poisson Equation 4 Other Examples 5 Essential BCs 6 Some Extensions

47 Weighted Residual Statement For simplicity we start with the weighted residual statement arising from the Poisson equation, with Ω N =, (F(u h ), v h ) := Ω h [ uh v h fv h] dx = 0 v h V h

48 Element Integrals The integral over Ω h... 0 = Ω h [ uh v h fv h] dx v h V h

49 Element Integrals The integral over Ω h... is written as a sum of integrals over the N e finite elements: 0 = = [ uh v h fv h] dx Ω h N e [ uh v h fv h] dx Ω e e=1 v h V h v h V h

50 Finite Element Basis Functions An element integral will have contributions only from the global basis functions corresponding to its nodes. We call these local basis functions φ i, 0 i N s. v h N s Ωe = c i φ i i= Ω e

51 Finite Element Basis Functions An element integral will have contributions only from the global basis functions corresponding to its nodes. We call these local basis functions φ i, 0 i N s. v h N s Ωe = c i φ i i=1 N s v h dx = c i φ i dx Ω e Ω e i= Ω e

52 Element Matrix and Load Vector The element integrals... Ω e [ uh v h fv h] dx

53 Element Matrix and Load Vector The element integrals... Ω e [ uh v h fv h] dx are written in terms of the local φ i basis functions N s j=1 u j φ j φ i dx f φ i dx, i = 1,..., N s Ω e Ω e

54 Element Matrix and Load Vector The element integrals... Ω e [ uh v h fv h] dx are written in terms of the local φ i basis functions N s j=1 u j φ j φ i dx f φ i dx, i = 1,..., N s Ω e Ω e This can be expressed naturally in matrix notation as K e U e F e

55 Global Linear System The entries of the element stiffness matrix are the integrals K e ij := φ j φ i dx Ω e

56 Global Linear System The entries of the element stiffness matrix are the integrals K e ij := φ j φ i dx Ω e While for the element right-hand side we have F e i := f φ i dx Ω e

57 Global Linear System The entries of the element stiffness matrix are the integrals K e ij := φ j φ i dx Ω e While for the element right-hand side we have F e i := f φ i dx Ω e The element stiffness matrices and right-hand sides can be assembled to obtain the global system of equations KU = F

58 Reference Element Map The integrals are performed on a reference element ˆΩ e x Ω e (ξ) x ξ Ω e

59 Reference Element Map The integrals are performed on a reference element ˆΩ e x Ω e (ξ) x ξ Ω e The Jacobian of the map x(ξ) is J. F e i = f φ i dx = Ω e f (x(ξ))φ i J dξ ˆΩ e

60 Reference Element Map The integrals are performed on a reference element ˆΩ e x Ω e (ξ) x ξ Ω e Chain rule: = J 1 ξ := ˆ ξ K e ij = φ j φ i dx = Ω e ˆΩ e ˆ ξ φ j ˆ ξ φ i J dξ

61 Element Quadrature The integrals on the reference element are approximated via numerical quadrature.

62 Element Quadrature The integrals on the reference element are approximated via numerical quadrature. The quadrature rule has N q points ξ q and weights w q.

63 Element Quadrature The integrals on the reference element are approximated via numerical quadrature. The quadrature rule has N q points ξ q and weights w q. F e i = f φ i J dξ ˆΩ e N q q=1 f (x(ξ q ))φ i (ξ q ) J(ξ q ) w q

64 Element Quadrature The integrals on the reference element are approximated via numerical quadrature. The quadrature rule has N q points ξ q and weights w q. K e ij = ˆΩ e N q q=1 ˆ ξ φ j ˆ ξ φ i J dξ ˆ ξ φ j (ξ q ) ˆ ξ φ i (ξ q ) J(ξ q ) w q

65 LibMesh Quadrature Point Data LibMesh provides the following variables at each quadrature point q Code Math Description JxW[q] J(ξ q ) w q Jacobian times weight phi[i][q] φ i (ξ q ) value of i th shape fn. dphi[i][q] ˆ ξ φ i (ξ q ) value of i th shape fn. gradient xyz[q] x(ξ q ) location of ξ q in physical space

66 Matrix Assembly Loops The LibMesh representation of the matrix and rhs assembly is similar to the mathematical statements. for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(dphi[j][q]*dphi[i][q]);

67 Matrix Assembly Loops The LibMesh representation of the matrix and rhs assembly is similar to the mathematical statements. for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(dphi[j][q]*dphi[i][q]); N q F e i = f (x(ξ q ))φ i (ξ q ) J(ξ q ) w q q=1

68 Matrix Assembly Loops The LibMesh representation of the matrix and rhs assembly is similar to the mathematical statements. for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(dphi[j][q]*dphi[i][q]); N q F e i = f (x(ξ q ))φ i (ξ q ) J(ξ q ) w q q=1

69 Matrix Assembly Loops The LibMesh representation of the matrix and rhs assembly is similar to the mathematical statements. for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(dphi[j][q]*dphi[i][q]); N q F e i = f (x(ξ q ))φ i (ξ q ) J(ξ q ) w q q=1

70 Matrix Assembly Loops The LibMesh representation of the matrix and rhs assembly is similar to the mathematical statements. for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(dphi[j][q]*dphi[i][q]); N q F e i = f (x(ξ q ))φ i (ξ q ) J(ξ q ) w q q=1

71 Matrix Assembly Loops The LibMesh representation of the matrix and rhs assembly is similar to the mathematical statements. for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(dphi[j][q]*dphi[i][q]); K e ij = N q q=1 ˆ ξ φ j (ξ q ) ˆ ξ φ i (ξ q ) J(ξ q ) w q

72 Matrix Assembly Loops The LibMesh representation of the matrix and rhs assembly is similar to the mathematical statements. for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(dphi[j][q]*dphi[i][q]); K e ij = N q q=1 ˆ ξ φ j (ξ q ) ˆ ξ φ i (ξ q ) J(ξ q ) w q

73 Matrix Assembly Loops The LibMesh representation of the matrix and rhs assembly is similar to the mathematical statements. for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(dphi[j][q]*dphi[i][q]); K e ij = N q q=1 ˆ ξ φ j (ξ q ) ˆ ξ φ i (ξ q ) J(ξ q ) w q

74 1 Introduction 2 Weighted Residuals 3 Poisson Equation 4 Other Examples 5 Essential BCs 6 Some Extensions

75 Convection-Diffusion Equation The matrix assembly routine for the linear convection-diffusion equation, k u + b u = f for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(k*(dphi[j][q]*dphi[i][q]) +(b*dphi[j][q])*phi[i][q]);

76 Convection-Diffusion Equation The matrix assembly routine for the linear convection-diffusion equation, k u + b u = f for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(k*(dphi[j][q]*dphi[i][q]) +(b*dphi[j][q])*phi[i][q]);

77 Convection-Diffusion Equation The matrix assembly routine for the linear convection-diffusion equation, k u + b u = f for (q=0; q<nq; ++q) for (i=0; i<ns; ++i) { Fe(i) += JxW[q]*f(xyz[q])*phi[i][q]; } for (j=0; j<ns; ++j) Ke(i,j) += JxW[q]*(k*(dphi[j][q]*dphi[i][q]) +(b*dphi[j][q])*phi[i][q]);

78 Stokes Flow For multi-variable systems like Stokes flow, p ν u = f u = 0 Ω R 2 The element stiffness matrix concept can extended to include sub-matrices Ku e 1 u 1 Ku e 1 u 2 Ku e 1 p U Ku e 2 u 1 Ku e 2 u 2 Ku e u e 1 F 2 p U e u e 1 Kpu e 1 Kpu e 2 Kpp e u 2 F e Up e u 2 Fp e We have an array of submatrices: Ke[ ][ ]

79 Stokes Flow For multi-variable systems like Stokes flow, p ν u = f u = 0 Ω R 2 The element stiffness matrix concept can extended to include sub-matrices Ku e 1 u 1 Ku e 1 u 2 Ku e 1 p U Ku e 2 u 1 Ku e 2 u 2 Ku e u e 1 F 2 p U e u e 1 Kpu e 1 Kpu e 2 Kpp e u 2 F e Up e u 2 Fp e We have an array of submatrices: Ke[0][0]

80 Stokes Flow For multi-variable systems like Stokes flow, p ν u = f u = 0 Ω R 2 The element stiffness matrix concept can extended to include sub-matrices Ku e 1 u 1 Ku e 1 u 2 Ku e 1 p U Ku e 2 u 1 Ku e 2 u 2 Ku e u e 1 F 2 p U e u e 1 Kpu e 1 Kpu e 2 Kpp e u 2 F e Up e u 2 Fp e We have an array of submatrices: Ke[1][1]

81 Stokes Flow For multi-variable systems like Stokes flow, p ν u = f u = 0 Ω R 2 The element stiffness matrix concept can extended to include sub-matrices Ku e 1 u 1 Ku e 1 u 2 Ku e 1 p U Ku e 2 u 1 Ku e 2 u 2 Ku e u e 1 F 2 p U e u e 1 Kpu e 1 Kpu e 2 Kpp e u 2 F e Up e u 2 Fp e We have an array of submatrices: Ke[2][1]

82 Stokes Flow For multi-variable systems like Stokes flow, p ν u = f u = 0 Ω R 2 The element stiffness matrix concept can extended to include sub-matrices Ku e 1 u 1 Ku e 1 u 2 Ku e 1 p U Ku e 2 u 1 Ku e 2 u 2 Ku e u e 1 F 2 p U e u e 1 Kpu e 1 Kpu e 2 Kpp e u 2 F e Up e u 2 Fp e And an array of right-hand sides: Fe[].

83 Stokes Flow For multi-variable systems like Stokes flow, p ν u = f u = 0 Ω R 2 The element stiffness matrix concept can extended to include sub-matrices Ku e 1 u 1 Ku e 1 u 2 Ku e 1 p U Ku e 2 u 1 Ku e 2 u 2 Ku e u e 1 F 2 p U e u e 1 Kpu e 1 Kpu e 2 Kpp e u 2 F e Up e u 2 Fp e And an array of right-hand sides: Fe[0].

84 Stokes Flow For multi-variable systems like Stokes flow, p ν u = f u = 0 Ω R 2 The element stiffness matrix concept can extended to include sub-matrices Ku e 1 u 1 Ku e 1 u 2 Ku e 1 p U Ku e 2 u 1 Ku e 2 u 2 Ku e u e 1 F 2 p U e u e 1 Kpu e 1 Kpu e 2 Kpp e u 2 F e Up e u 2 Fp e And an array of right-hand sides: Fe[1].

85 Stokes Flow The matrix assembly can proceed in essentially the same way. For the momentum equations: for (q=0; q<nq; ++q) for (d=0; d<2; ++d) for (i=0; i<ns; ++i) { Fe[d](i) += JxW[q]*f(xyz[q],d)*phi[i][q]; } for (j=0; j<ns; ++j) Ke[d][d](i,j) += JxW[q]*nu*(dphi[j][q]*dphi[i][q]);

86 1 Introduction 2 Weighted Residuals 3 Poisson Equation 4 Other Examples 5 Essential BCs 6 Some Extensions

87 Essential Boundary Data Dirichlet boundary conditions can be enforced after the global stiffness matrix K has been assembled This usually involves 1 placing a 1 on the main diagonal of the global stiffness matrix 2 zeroing out the row entries 3 placing the Dirichlet value in the rhs vector 4 subtracting off the column entries from the rhs

88 Essential Boundary Data Dirichlet boundary conditions can be enforced after the global stiffness matrix K has been assembled This usually involves 1 placing a 1 on the main diagonal of the global stiffness matrix 2 zeroing out the row entries 3 placing the Dirichlet value in the rhs vector 4 subtracting off the column entries from the rhs

89 Essential Boundary Data Dirichlet boundary conditions can be enforced after the global stiffness matrix K has been assembled This usually involves 1 placing a 1 on the main diagonal of the global stiffness matrix 2 zeroing out the row entries 3 placing the Dirichlet value in the rhs vector 4 subtracting off the column entries from the rhs

90 Essential Boundary Data Dirichlet boundary conditions can be enforced after the global stiffness matrix K has been assembled This usually involves 1 placing a 1 on the main diagonal of the global stiffness matrix 2 zeroing out the row entries 3 placing the Dirichlet value in the rhs vector 4 subtracting off the column entries from the rhs

91 Essential Boundary Data Dirichlet boundary conditions can be enforced after the global stiffness matrix K has been assembled This usually involves 1 placing a 1 on the main diagonal of the global stiffness matrix 2 zeroing out the row entries 3 placing the Dirichlet value in the rhs vector 4 subtracting off the column entries from the rhs k 11 k 12 k 13. f g 1 k 21 k 22 k 23. k 31 k 32 k 33., f 2 f 3 0 k 22 k k 32 k 33., f 2 k 21 g 1 f 3 k 31 g

92 Essential Boundary Data Cons of this approach : Works for an interpolary finite element basis but not in general. May be inefficient to change individual entries once the global matrix is assembled. Need to enforce boundary conditions for a generic finite element basis at the element stiffness matrix level.

93 Essential Boundary Data Cons of this approach : Works for an interpolary finite element basis but not in general. May be inefficient to change individual entries once the global matrix is assembled. Need to enforce boundary conditions for a generic finite element basis at the element stiffness matrix level.

94 Essential Boundary Data Cons of this approach : Works for an interpolary finite element basis but not in general. May be inefficient to change individual entries once the global matrix is assembled. Need to enforce boundary conditions for a generic finite element basis at the element stiffness matrix level.

95 Essential Boundary Data Cons of this approach : Works for an interpolary finite element basis but not in general. May be inefficient to change individual entries once the global matrix is assembled. Need to enforce boundary conditions for a generic finite element basis at the element stiffness matrix level.

96 Penalty Formulation One solution is the penalty boundary formulation A term is added to the standard weighted residual statement (F(u), v) + 1 (u u D )v dx = 0 v V ɛ Ω } D {{} penalty term Here ɛ 1 is chosen so that, in floating point arithmetic, 1 ɛ + 1 = 1 ɛ. This weakly enforces u = u D on the Dirichlet boundary, and works for general finite element bases.

97 Penalty Formulation One solution is the penalty boundary formulation A term is added to the standard weighted residual statement (F(u), v) + 1 (u u D )v dx = 0 v V ɛ Ω } D {{} penalty term Here ɛ 1 is chosen so that, in floating point arithmetic, 1 ɛ + 1 = 1 ɛ. This weakly enforces u = u D on the Dirichlet boundary, and works for general finite element bases.

98 Penalty Formulation One solution is the penalty boundary formulation A term is added to the standard weighted residual statement (F(u), v) + 1 (u u D )v dx = 0 v V ɛ Ω } D {{} penalty term Here ɛ 1 is chosen so that, in floating point arithmetic, 1 ɛ + 1 = 1 ɛ. This weakly enforces u = u D on the Dirichlet boundary, and works for general finite element bases.

99 Penalty Formulation One solution is the penalty boundary formulation A term is added to the standard weighted residual statement (F(u), v) + 1 (u u D )v dx = 0 v V ɛ Ω } D {{} penalty term Here ɛ 1 is chosen so that, in floating point arithmetic, 1 ɛ + 1 = 1 ɛ. This weakly enforces u = u D on the Dirichlet boundary, and works for general finite element bases.

100 Penalty Formulation LibMesh provides: A quadrature rule with Nqf points and JxW f[] A finite element coincident with the boundary face that has shape function values phi f[][] for (qf=0; qf<nqf; ++qf) { for (i=0; i<nf; ++i) { Fe(i) += JxW_f[qf]* penalty*ud(xyz[q])*phi_f[i][qf]; } } for (j=0; j<nf; ++j) Ke(i,j) += JxW_f[qf]* penalty*phi_f[j][qf]*phi_f[i][qf];

101 Penalty Formulation LibMesh provides: A quadrature rule with Nqf points and JxW f[] A finite element coincident with the boundary face that has shape function values phi f[][] for (qf=0; qf<nqf; ++qf) { for (i=0; i<nf; ++i) { Fe(i) += JxW_f[qf]* penalty*ud(xyz[q])*phi_f[i][qf]; } } for (j=0; j<nf; ++j) Ke(i,j) += JxW_f[qf]* penalty*phi_f[j][qf]*phi_f[i][qf];

102 Penalty Formulation LibMesh provides: A quadrature rule with Nqf points and JxW f[] A finite element coincident with the boundary face that has shape function values phi f[][] for (qf=0; qf<nqf; ++qf) { for (i=0; i<nf; ++i) { Fe(i) += JxW_f[qf]* penalty*ud(xyz[q])*phi_f[i][qf]; } } for (j=0; j<nf; ++j) Ke(i,j) += JxW_f[qf]* penalty*phi_f[j][qf]*phi_f[i][qf];

103 1 Introduction 2 Weighted Residuals 3 Poisson Equation 4 Other Examples 5 Essential BCs 6 Some Extensions

104 Time-Dependent Problems For linear problems, we have already seen how the weighted residual statement leads directly to a sparse linear system of equations KU = F

105 Time-Dependent Problems For time-dependent problems, u t = F(u) we also need a way to advance the solution in time, e.g. a θ-method ( ) u n+1 u n, v h = ( F(u θ ), v h) v h V h t u θ := θu n+1 + (1 θ)u n Leads to KU = F at each timestep.

106 Nonlinear Problems For nonlinear problems, typically a sequence of linear problems must be solved, e.g. for Newton s method (F (u k )δu k+1, v) = (F(u k ), v) where F (u k ) is the linearized (Jacobian) operator associated with the PDE. Must solve KU = F (Inexact Newton method) at each iteration step.

107 B. Kirk, J. Peterson, R. Stogner and G. Carey, libmesh: a C++ library for parallel adaptive mesh refinement/coarsening simulations, Engineering with Computers, vol. 22, no. 3 4, p , Public site, mailing lists, SVN tree, examples, etc.: