libmesh Finite Element Library

Transcription

1 libmesh Finite Element Library Roy Stogner Derek Gaston 1 Univ. of Texas at Austin 2 Sandia National Laboratories Albuquerque,NM August 22, 2007

2 Outline 1 Introduction 2 Object Models Core Classes BVP Framework 3 System Assembly Basic Example Coupled Variables Essential Boundary Conditions 4 Examples Fluid Dynamics Biology Material Science 5 Summary

3 Goals libmesh is not

4 Goals libmesh is not A physics implementation.

5 Goals libmesh is not A physics implementation. A stand-alone application.

6 Goals libmesh is not A physics implementation. A stand-alone application. libmesh is

7 Goals libmesh is not A physics implementation. A stand-alone application. libmesh is A software library and toolkit.

8 Goals libmesh is not A physics implementation. A stand-alone application. libmesh is A software library and toolkit. Classes and functions for writing parallel adaptive finite element applications.

9 Goals libmesh is not A physics implementation. A stand-alone application. libmesh is A software library and toolkit. Classes and functions for writing parallel adaptive finite element applications. An interface to linear algebra, meshing, partitioning, etc. libraries.

10 For most applications we assume there is a Boundary Value Problem to be approximated in a Finite Element function space M u t = F(u) Ω G(u) = 0 Ω u = u D Ω D N(u) = 0 Ω N u(x, 0) = u 0 (x) δω D δω N Ω

11 Associated to Ω is the Mesh data structure A Mesh is basically a collection of geometric elements and nodes Ω h Ω h := e Ω e

12 Object Oriented Programming

13 Object Oriented Programming Abstract Base Classes define user interfaces.

14 Object Oriented Programming Abstract Base Classes define user interfaces. Concrete Subclasses implement functionality.

15 Object Oriented Programming Abstract Base Classes define user interfaces. Concrete Subclasses implement functionality. One physics code can work with many discretizations.

16 Core Classes Geometric Element Classes DofObject #_nodes: Node ** #_neighbors: Elem ** #_parent: Elem * #_children: Elem ** #_*flag: RefinementState #_p_level: unsigned char #_subdomain_id: unsigned char Elem +n_{faces,sides,vertices,edges,children}(): unsigned int +centroid(): Point +hmin,hmax(): Real NodeElem -_n_systems: unsigned char -_n_vars: unsigned char * -_n_comp: unsigned char ** -_dof_ids: unsigned int ** -_id: unsigned int -_processor_id: unsigned short int Node Edge Face Cell InfQuad InfCell Prism Hex Pyramid Tet Abstract interface gives mesh topology Concrete instantiations of mesh geometry Hides element type from most applications Hex8 Hex20 Hex27

17 Core Classes Finite Element Classes FEBase +phi, dphi, d2phi +quadrature_rule, JxW +reinit(elem) +reinit(elem,side) Lagrange Hierarchic Finite Element object builds data for each Geometric object User only deals with shape function, quadrature data Hermite Monomial

18 Core Classes Core Features Mixed element geometries in unstructured grids Adaptive mesh h refinement with hanging nodes, p refinement Integration w/ PETSc, LASPack, METIS, ParMETIS, Triangle, TetGen Support for UNV, ExodusII, Tecplot, GMV, UCD files Mesh creation, modification utilities

19 Core Classes Degree of Freedom Handling

20 Core Classes Degree of Freedom Handling DofObject subclasses store global Degree of Freedom indices

21 Core Classes Degree of Freedom Handling DofObject subclasses store global Degree of Freedom indices DofMap class assigns indices to a partitioned mesh

22 Core Classes Degree of Freedom Handling DofObject subclasses store global Degree of Freedom indices DofMap class assigns indices to a partitioned mesh FE classes calculate hanging node, periodic constraints

23 Core Classes Degree of Freedom Handling DofObject subclasses store global Degree of Freedom indices DofMap class assigns indices to a partitioned mesh FE classes calculate hanging node, periodic constraints DofMap class applies constraints

24 Core Classes Degree of Freedom Handling DofObject subclasses store global Degree of Freedom indices DofMap class assigns indices to a partitioned mesh FE classes calculate hanging node, periodic constraints DofMap class applies constraints System class handles AMR/C projections

25 Core Classes Generic Constraint Calculations To maintain function space continuity, constrain hanging node Degrees of Freedom coefficients on fine elements in terms of DoFs on coarse neighbors. u F = u C u F i φ F i = j i u C j φ C j A ki u i = B kj u j u i = A 1 ki B kj u j Integrated values (and fluxes, for C 1 continuity) give element-independent matrices: A ki (φ F i, φ F k ) B kj (φ C j, φ C k )

26 Core Classes Generic Projection Calculations Upon element coarsening (or refinement in non-nested spaces): Copy nodal Degree of Freedom coefficients Project edge DoFs, holding nodal DoFs constant Project face DoFs, holding nodes/edges constant Project interior DoFs, holding boundaries constant Advantages / Disadvantages Requires only local solves Consistent in parallel May violate physical conservation laws

27 Core Classes libmesh Parallelization Parallel code

28 Core Classes libmesh Parallelization Parallel code PetscVector, DistributedVector classes for Linear Algebra

29 Core Classes libmesh Parallelization Parallel code PetscVector, DistributedVector classes for Linear Algebra Parallel assembly, error indicators, etc.

30 Core Classes libmesh Parallelization Parallel code PetscVector, DistributedVector classes for Linear Algebra Parallel assembly, error indicators, etc. Mesh partitioning with ParMETIS, etc.

31 Core Classes libmesh Parallelization Parallel code PetscVector, DistributedVector classes for Linear Algebra Parallel assembly, error indicators, etc. Mesh partitioning with ParMETIS, etc. Serial code

32 Core Classes libmesh Parallelization Parallel code PetscVector, DistributedVector classes for Linear Algebra Parallel assembly, error indicators, etc. Mesh partitioning with ParMETIS, etc. Serial code Mesh storage on every node

33 Core Classes libmesh Parallelization Parallel code PetscVector, DistributedVector classes for Linear Algebra Parallel assembly, error indicators, etc. Mesh partitioning with ParMETIS, etc. Serial code Mesh storage on every node DoF renumbering, constraint calculations

34 Core Classes libmesh Parallelization Parallel code PetscVector, DistributedVector classes for Linear Algebra Parallel assembly, error indicators, etc. Mesh partitioning with ParMETIS, etc. Serial code Mesh storage on every node DoF renumbering, constraint calculations Refinement/Coarsening flagging

35 Core Classes libmesh Parallelization Parallel code PetscVector, DistributedVector classes for Linear Algebra Parallel assembly, error indicators, etc. Mesh partitioning with ParMETIS, etc. Serial code Mesh storage on every node DoF renumbering, constraint calculations Refinement/Coarsening flagging Mesh, solution I/O

36 Core Classes ParallelMesh Parallel subclassing of MeshBase Start from unstructured Mesh class Add methods to delete, reconstruct non-semilocal Elem and Node objects Parallelize DofMap methods Parallelize MeshRefinement methods Add parallel or chunked I/O support Add load balancing support Also want parallel BoundaryInfo, BoundaryMesh, Data, Function, Generation, Modification, Smoother, and Tools classes

37 BVP Framework Boundary Value Problem Framework Goals Goals Improved test coverage and reliability Hiding implementation details from user code Rapid prototyping of new formulations Physics-dependent error estimators Methods Object-oriented System and Solver subclasses Factoring common patterns into library code Per-element Numerical Jacobian verification

38 BVP Framework FEM System Classes FEMSystem +elem_solution: DenseVector<Number> +elem_residual: DenseVector<Number> +elem_jacobian: DenseMatrix<Number> #elem_fixed_solution: DenseVector<Number> #*_fe_var: std::vector<febase *> #elem: Elem * +*_time_derivative(request_jacobian) +*_constraint(request_jacobian) +*_postprocess() NavierStokesSystem LaplaceYoungSystem CahnHilliardSystem SurfactantSystem Generalized IBVP representation FEMSystem does all initialization, global assembly User code only needs weighted time derivative residuals ( u, v t i) = F i (u) and/or constraints G i (u, v i ) = 0

39 BVP Framework ODE Solver Classes TimeSolver +*_residual(request_jacobian) +solve() +advance_timestep() SteadySolver AdamsMoultonSolver EulerSolver EigenSolver Calls user code on each element Assembles element-by-element time derivatives, constraints, and weighted old solutions

40 BVP Framework Nonlinear Solver Classes LinearSolver NonlinearSolver +*_tolerance +*_max_iterations +solve() ContinuationSolver QuasiNewtonSolver Acquires residuals, jacobians from FEMSystem assembly Handles inner loops, inner solvers and tolerances, convergence tests, etc

41 Basic Example System Assembly For simplicity we will focus on the weighted residual statement arising from the Poisson equation, with Ω N =, (R(u h ), v h ) := Ω h [ uh v h fv h] dx = 0 v h V h

42 Basic Example The element integrals... Ω e [ uh v h fv h] dx

43 Basic Example 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

44 Basic Example 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

45 Basic Example The integrals are performed on a reference element ˆΩ e, transformed via Lagrange basis to the geometric element. x Ω e x(ξ) ξ Ω e

46 Basic Example The integrals are performed on a reference element ˆΩ e, transformed via Lagrange basis to the geometric element. 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

47 Basic Example The integrals are performed on a reference element ˆΩ e, transformed via Lagrange basis to the geometric element. x Ω e x(ξ) ξ Ω e

48 Basic Example The integrals on the reference element are approximated via numerical quadrature.

49 Basic Example The integrals on the reference element are approximated via numerical quadrature. The quadrature rule has N q points ξ q and weights w q.

50 Basic Example 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

51 Basic Example 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 = φ j φ i J dξ ˆΩ e N q q=1 φ j (ξ q ) φ i (ξ q ) J(ξ q ) w q

52 Basic Example At the qth quadrature point, LibMesh can provide variables including: 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 d2phi[i][q] φ i (ξ q ) value of i th shape fn. Hessian xyz[q] x(ξ q ) location of ξ q in physical space normals[q] n(x(ξ q )) normal vector at x on a side

53 Basic Example 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]);

54 Basic Example 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

55 Basic Example 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

56 Basic Example 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

57 Basic Example 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

58 Basic Example 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

59 Basic Example 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

60 Basic Example 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

61 Basic Example 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]);

62 Basic Example 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]);

63 Basic Example 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]);

64 Coupled Variables 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[ ][ ]

65 Coupled Variables 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]

66 Coupled Variables 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][2]

67 Coupled Variables 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[3][2]

68 Coupled Variables 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[].

69 Coupled Variables 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].

70 Coupled Variables 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[2].

71 Coupled Variables 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]);

72 Essential Boundary Conditions 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

73 Essential Boundary Conditions 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

74 Essential Boundary Conditions 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

75 Essential Boundary Conditions 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

76 Essential Boundary Conditions 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

77 Essential Boundary Conditions Cons of this approach :

78 Essential Boundary Conditions Cons of this approach : Works for an interpolary finite element basis but not in general.

79 Essential Boundary Conditions 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.

80 Essential Boundary Conditions 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.

81 Essential Boundary Conditions A penalty term is added to the standard weighted residual statement (R(u), v) + 1 (u u D )v dx = 0 v V ɛ Ω } D {{} penalty term

82 Essential Boundary Conditions A penalty term is added to the standard weighted residual statement (R(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 ɛ.

83 Essential Boundary Conditions A penalty term is added to the standard weighted residual statement (R(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.

84 Essential Boundary Conditions 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];

85 Essential Boundary Conditions 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];

86 Essential Boundary Conditions 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];

87 Fluid Dynamics Introduction Laplace-Young equation model surface tension effects for enclosed liquids.

88 Fluid Dynamics Introduction Laplace-Young equation model surface tension effects for enclosed liquids. Combining surface tension, gravity and contact the energy functional for Laplace-Young is: 1 + u 2 1 dω + 2 κu2 dω σu ds Ω Ω Ω

89 Fluid Dynamics Introduction Laplace-Young equation model surface tension effects for enclosed liquids. Combining surface tension, gravity and contact the energy functional for Laplace-Young is: 1 + u 2 1 dω + 2 κu2 dω σu ds Ω Where κ is the ratio of surface energy to gravitational energy and u is the height of the liquid. Ω Ω

90 Fluid Dynamics Introduction Laplace-Young equation model surface tension effects for enclosed liquids. Combining surface tension, gravity and contact the energy functional for Laplace-Young is: 1 + u 2 1 dω + 2 κu2 dω σu ds Ω Where κ is the ratio of surface energy to gravitational energy and u is the height of the liquid. Ω While the weak formulation of the stationary condition is given by: ( ) u, ϕ + κ (u, ϕ) 1 + u 2 Ω = σ (1, ϕ) Ω (1) Ω Ω

91 Fluid Dynamics Introduction Laplace-Young equation model surface tension effects for enclosed liquids. Combining surface tension, gravity and contact the energy functional for Laplace-Young is: 1 + u 2 1 dω + 2 κu2 dω σu ds Ω Where κ is the ratio of surface energy to gravitational energy and u is the height of the liquid. Ω While the weak formulation of the stationary condition is given by: ( ) u, ϕ + κ (u, ϕ) 1 + u 2 Ω = σ (1, ϕ) Ω (1) Ω Ω

92 Fluid Dynamics Instead of explicitly finding the Jacobian, we ll use FEMSystem to finite difference the weak form. element constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { Number u = interior_value(0, qp); Gradient grad_u = interior_gradient(0, qp); Number K = 1. / sqrt(1. + (grad_u * grad_u)); for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) += JxW[qp] * ((_kappa * u * phi[i][qp]) + (K * grad_u * dphi[i][qp])); } } side constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) -= JxW[qp] * _gamma * phi[i][qp]; } } 0 1 B u ϕa q1 + u 2 + κ (u, ϕ) Ω σ (1, ϕ) Ω = 0 ϕ V Ω

93 Fluid Dynamics Instead of explicitly finding the Jacobian, we ll use FEMSystem to finite difference the weak form. element constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { Number u = interior_value(0, qp); Gradient grad_u = interior_gradient(0, qp); Number K = 1. / sqrt(1. + (grad_u * grad_u)); for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) += JxW[qp] * ((_kappa * u * phi[i][qp]) + (K * grad_u * dphi[i][qp])); } } side constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) -= JxW[qp] * _gamma * phi[i][qp]; } } 0 1 B u ϕa q1 + u 2 + κ (u, ϕ) Ω σ (1, ϕ) Ω = 0 ϕ V Ω

94 Fluid Dynamics Instead of explicitly finding the Jacobian, we ll use FEMSystem to finite difference the weak form. element constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { Number u = interior_value(0, qp); Gradient grad_u = interior_gradient(0, qp); Number K = 1. / sqrt(1. + (grad_u * grad_u)); for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) += JxW[qp] * ((_kappa * u * phi[i][qp]) + (K * grad_u * dphi[i][qp])); } } side constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) -= JxW[qp] * _gamma * phi[i][qp]; } } 0 1 B u ϕa q1 + u 2 + κ (u, ϕ) Ω σ (1, ϕ) Ω = 0 ϕ V Ω

95 Fluid Dynamics Instead of explicitly finding the Jacobian, we ll use FEMSystem to finite difference the weak form. element constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { Number u = interior_value(0, qp); Gradient grad_u = interior_gradient(0, qp); Number K = 1. / sqrt(1. + (grad_u * grad_u)); for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) += JxW[qp] * ((_kappa * u * phi[i][qp]) + (K * grad_u * dphi[i][qp])); } } side constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) -= JxW[qp] * _gamma * phi[i][qp]; } } 0 1 B u ϕa q1 + u 2 + κ (u, ϕ) Ω σ (1, ϕ) Ω = 0 ϕ V Ω

96 Fluid Dynamics Instead of explicitly finding the Jacobian, we ll use FEMSystem to finite difference the weak form. element constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { Number u = interior_value(0, qp); Gradient grad_u = interior_gradient(0, qp); Number K = 1. / sqrt(1. + (grad_u * grad_u)); for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) += JxW[qp] * ((_kappa * u * phi[i][qp]) + (K * grad_u * dphi[i][qp])); } } side constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) -= JxW[qp] * _gamma * phi[i][qp]; } } 0 1 B u ϕa q1 + u 2 + κ (u, ϕ) Ω σ (1, ϕ) Ω = 0 ϕ V Ω

97 Fluid Dynamics Instead of explicitly finding the Jacobian, we ll use FEMSystem to finite difference the weak form. element constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { Number u = interior_value(0, qp); Gradient grad_u = interior_gradient(0, qp); Number K = 1. / sqrt(1. + (grad_u * grad_u)); for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) += JxW[qp] * ((_kappa * u * phi[i][qp]) + (K * grad_u * dphi[i][qp])); } } side constraint() for (unsigned int qp=0; qp!= n_qpoints; qp++) { for (unsigned int i=0; i!= n_u_dofs; i++) { Fu(i) -= JxW[qp] * _gamma * phi[i][qp]; } } 0 1 B u ϕa q1 + u 2 + κ (u, ϕ) Ω σ (1, ϕ) Ω = 0 ϕ V Ω

98 Fluid Dynamics Solution An overkill solution containing 200,000 DOFs. (a) 2D. (b) Contour Elevation.

99 Fluid Dynamics Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh.

100 Fluid Dynamics Compressible Shocked Flow Original compressible flow code written by Ben Kirk utilizing libmesh. Solves both Compressible Navier Stokes and Inviscid Euler.

101 Fluid Dynamics 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.

102 Fluid Dynamics Problem Specification The problem studied is that of an oblique shock generated by a 10 o wedge angle.

103 Fluid Dynamics 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.

104 Fluid Dynamics 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.

105 Fluid Dynamics 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:

106 Fluid Dynamics 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 (c) Mesh after 1 uniform (d) Solution after 1 uni-

107 Fluid Dynamics H-Adapted Solutions A flux jump indicator was employed as the error indcator along with a statistical flagging scheme.

108 Fluid Dynamics 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

109 Fluid Dynamics Redistributed Solutions Redistribution utilizing the same flux jump indicator. 1 1 r y y x x (i) Mesh after 8 redistributions. (j) Solution after 8 redistributions.

110 Fluid Dynamics 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 x

111 Fluid Dynamics Solution Comparison For a better comparison here are 3 of the solutions, each with around DOFs: r r r y y y x x x (m) Uniform. (n) Adaptive. (o) R + H.

112 Fluid Dynamics Error Plot libmesh provides capability for computing error norms against an exact solution.

113 2 0 Fluid Dynamics 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

114 Introduction Fluid Dynamics Object Models System Assembly Examples Summary

115 Fluid Dynamics Natural Convection Tetrahedral mesh of pipe geometry. Stream ribbons colored by temperature.

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

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

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

119 Material Science Free Energy Formulation Cahn-Hilliard systems model phase separation and interface evolution f (c, c) f 0 (c) + f γ ( c) f γ ( c) ɛ2 c c c 2 f 0 (c) NkT (c ln (c) + (1 c) ln (1 c)) + Nωc(1 c) c t = M c ( f 0(c) ɛ 2 c c )

120 Material Science Phase Separation - Spinodal Decomposition Initial Evolution Initial homogeneous blend quenched below critical T Random perturbations anti-diffuse into two phases divided by narrow interfaces Gradual coalescence of single-phase regions Additional physics leads to pattern self-assembly

121 Summary libmesh Development Open Source (LGPL) Leveraging existing libraries Public site, mailing lists, CVS tree, examples, etc. at 18 examples including: Infinite Elements for the wave equation. Helmholtz with complex numbers. Laplace in L-Shaped Domain. Biharmonic Equation. Using SLEPc for an Eigen Problem. Unsteady Navier Stokes. And More!