Actual source code: ex77.c
petsc-3.13.6 2020-09-29
Report Typos and Errors

      1: static char help[] = "Nonlinear elasticity problem in 3d with simplicial finite elements.\n\
      2: We solve a nonlinear elasticity problem, modelled as an incompressible Neo-Hookean solid, \n\
      3:  with pressure loading in a rectangular domain, using a parallel unstructured mesh (DMPLEX) to discretize it.\n\n\n";

      5: /*
      6: Nonlinear elasticity problem, which we discretize using the finite
      7: element method on an unstructured mesh. This uses both Dirichlet boundary conditions (fixed faces)
      8: and nonlinear Neumann boundary conditions (pressure loading).
      9: The Lagrangian density (modulo boundary conditions) for this problem is given by
     10: \begin{equation}
     11:   \frac{\mu}{2} (\mathrm{Tr}{C}-3) + J p + \frac{\kappa}{2} (J-1).
     12: \end{equation}

     14: Discretization:

     16: We use PetscFE to generate a tabulation of the finite element basis functions
     17: at quadrature points. We can currently generate an arbitrary order Lagrange
     18: element.

     20: Field Data:

     22:   DMPLEX data is organized by point, and the closure operation just stacks up the
     23: data from each sieve point in the closure. Thus, for a P_2-P_1 Stokes element, we
     24: have

     26:   cl{e} = {f e_0 e_1 e_2 v_0 v_1 v_2}
     27:   x     = [u_{e_0} v_{e_0} u_{e_1} v_{e_1} u_{e_2} v_{e_2} u_{v_0} v_{v_0} p_{v_0} u_{v_1} v_{v_1} p_{v_1} u_{v_2} v_{v_2} p_{v_2}]

     29: The problem here is that we would like to loop over each field separately for
     30: integration. Therefore, the closure visitor in DMPlexVecGetClosure() reorders
     31: the data so that each field is contiguous

     33:   x'    = [u_{e_0} v_{e_0} u_{e_1} v_{e_1} u_{e_2} v_{e_2} u_{v_0} v_{v_0} u_{v_1} v_{v_1} u_{v_2} v_{v_2} p_{v_0} p_{v_1} p_{v_2}]

     35: Likewise, DMPlexVecSetClosure() takes data partitioned by field, and correctly
     36: puts it into the Sieve ordering.

     38: */

     40:  #include <petscdmplex.h>
     41:  #include <petscsnes.h>
     42:  #include <petscds.h>

     44: typedef enum {RUN_FULL, RUN_TEST} RunType;

     46: typedef struct {
     47:   PetscInt      debug;             /* The debugging level */
     48:   RunType       runType;           /* Whether to run tests, or solve the full problem */
     49:   PetscLogEvent createMeshEvent;
     50:   PetscBool     showInitial, showSolution;
     51:   /* Domain and mesh definition */
     52:   PetscInt      dim;               /* The topological mesh dimension */
     53:   PetscBool     interpolate;       /* Generate intermediate mesh elements */
     54:   PetscBool     simplex;           /* Use simplices or tensor product cells */
     55:   PetscReal     refinementLimit;   /* The largest allowable cell volume */
     56:   PetscBool     testPartition;     /* Use a fixed partitioning for testing */
     57:   PetscReal     mu;                /* The shear modulus */
     58:   PetscReal     p_wall;            /* The wall pressure */
     59: } AppCtx;

     61: #if 0
     62: PETSC_STATIC_INLINE void Det2D(PetscReal *detJ, const PetscReal J[])
     63: {
     64:   *detJ = J[0]*J[3] - J[1]*J[2];
     65: }
     66: #endif

     68: PETSC_STATIC_INLINE void Det3D(PetscReal *detJ, const PetscScalar J[])
     69: {
     70:   *detJ = PetscRealPart(J[0*3+0]*(J[1*3+1]*J[2*3+2] - J[1*3+2]*J[2*3+1]) +
     71:                         J[0*3+1]*(J[1*3+2]*J[2*3+0] - J[1*3+0]*J[2*3+2]) +
     72:                         J[0*3+2]*(J[1*3+0]*J[2*3+1] - J[1*3+1]*J[2*3+0]));
     73: }

     75: #if 0
     76: PETSC_STATIC_INLINE void Cof2D(PetscReal C[], const PetscReal A[])
     77: {
     78:   C[0] =  A[3];
     79:   C[1] = -A[2];
     80:   C[2] = -A[1];
     81:   C[3] =  A[0];
     82: }
     83: #endif

     85: PETSC_STATIC_INLINE void Cof3D(PetscReal C[], const PetscScalar A[])
     86: {
     87:   C[0*3+0] = PetscRealPart(A[1*3+1]*A[2*3+2] - A[1*3+2]*A[2*3+1]);
     88:   C[0*3+1] = PetscRealPart(A[1*3+2]*A[2*3+0] - A[1*3+0]*A[2*3+2]);
     89:   C[0*3+2] = PetscRealPart(A[1*3+0]*A[2*3+1] - A[1*3+1]*A[2*3+0]);
     90:   C[1*3+0] = PetscRealPart(A[0*3+2]*A[2*3+1] - A[0*3+1]*A[2*3+2]);
     91:   C[1*3+1] = PetscRealPart(A[0*3+0]*A[2*3+2] - A[0*3+2]*A[2*3+0]);
     92:   C[1*3+2] = PetscRealPart(A[0*3+1]*A[2*3+0] - A[0*3+0]*A[2*3+1]);
     93:   C[2*3+0] = PetscRealPart(A[0*3+1]*A[1*3+2] - A[0*3+2]*A[1*3+1]);
     94:   C[2*3+1] = PetscRealPart(A[0*3+2]*A[1*3+0] - A[0*3+0]*A[1*3+2]);
     95:   C[2*3+2] = PetscRealPart(A[0*3+0]*A[1*3+1] - A[0*3+1]*A[1*3+0]);
     96: }

     98: PetscErrorCode zero_scalar(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx)
     99: {
    100:   u[0] = 0.0;
    101:   return 0;
    102: }

    104: PetscErrorCode zero_vector(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx)
    105: {
    106:   const PetscInt Ncomp = dim;

    108:   PetscInt       comp;
    109:   for (comp = 0; comp < Ncomp; ++comp) u[comp] = 0.0;
    110:   return 0;
    111: }

    113: PetscErrorCode coordinates(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx)
    114: {
    115:   const PetscInt Ncomp = dim;

    117:   PetscInt       comp;
    118:   for (comp = 0; comp < Ncomp; ++comp) u[comp] = x[comp];
    119:   return 0;
    120: }

    122: PetscErrorCode elasticityMaterial(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx)
    123: {
    124:   AppCtx *user = (AppCtx *) ctx;
    125:   u[0] = user->mu;
    126:   return 0;
    127: }

    129: PetscErrorCode wallPressure(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx)
    130: {
    131:   AppCtx *user = (AppCtx *) ctx;
    132:   u[0] = user->p_wall;
    133:   return 0;
    134: }

    136: void f1_u_3d(PetscInt dim, PetscInt Nf, PetscInt NfAux,
    137:           const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[],
    138:           const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[],
    139:           PetscReal t, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar f1[])
    140: {
    141:   const PetscInt  Ncomp = dim;
    142:   const PetscReal mu = PetscRealPart(a[0]), kappa = 3.0;
    143:   PetscReal       cofu_x[9/*Ncomp*dim*/], detu_x, p = PetscRealPart(u[Ncomp]);
    144:   PetscInt        comp, d;

    146:   Cof3D(cofu_x, u_x);
    147:   Det3D(&detu_x, u_x);
    148:   p += kappa * (detu_x - 1.0);

    150:   /* f1 is the first Piola-Kirchhoff tensor */
    151:   for (comp = 0; comp < Ncomp; ++comp) {
    152:     for (d = 0; d < dim; ++d) {
    153:       f1[comp*dim+d] = mu * u_x[comp*dim+d] + p * cofu_x[comp*dim+d];
    154:     }
    155:   }
    156: }

    158: void g3_uu_3d(PetscInt dim, PetscInt Nf, PetscInt NfAux,
    159:           const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[],
    160:           const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[],
    161:           PetscReal t, PetscReal u_tShift, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar g3[])
    162: {
    163:   const PetscInt  Ncomp = dim;
    164:   const PetscReal mu = PetscRealPart(a[0]), kappa = 3.0;
    165:   PetscReal       cofu_x[9/*Ncomp*dim*/], detu_x, pp, pm, p = PetscRealPart(u[Ncomp]);
    166:   PetscInt        compI, compJ, d1, d2;

    168:   Cof3D(cofu_x, u_x);
    169:   Det3D(&detu_x, u_x);
    170:   p += kappa * (detu_x - 1.0);
    171:   pp = p/detu_x + kappa;
    172:   pm = p/detu_x;

    174:   /* g3 is the first elasticity tensor, i.e. A_i^I_j^J = S^{IJ} g_{ij} + C^{KILJ} F^k_K F^l_L g_{kj} g_{li} */
    175:   for (compI = 0; compI < Ncomp; ++compI) {
    176:     for (compJ = 0; compJ < Ncomp; ++compJ) {
    177:       const PetscReal G = (compI == compJ) ? 1.0 : 0.0;

    179:       for (d1 = 0; d1 < dim; ++d1) {
    180:         for (d2 = 0; d2 < dim; ++d2) {
    181:           const PetscReal g = (d1 == d2) ? 1.0 : 0.0;

    183:           g3[((compI*Ncomp+compJ)*dim+d1)*dim+d2] = g * G * mu + pp * cofu_x[compI*dim+d1] * cofu_x[compJ*dim+d2] - pm * cofu_x[compI*dim+d2] * cofu_x[compJ*dim+d1];
    184:         }
    185:       }
    186:     }
    187:   }
    188: }

    190: void f0_bd_u_3d(PetscInt dim, PetscInt Nf, PetscInt NfAux,
    191:     const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[],
    192:     const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[],
    193:     PetscReal t, const PetscReal x[], const PetscReal n[], PetscInt numConstants, const PetscScalar constants[], PetscScalar f0[])
    194: {
    195:   const PetscInt    Ncomp = dim;
    196:   const PetscScalar p = a[aOff[1]];
    197:   PetscReal         cofu_x[9/*Ncomp*dim*/];
    198:   PetscInt          comp, d;

    200:   Cof3D(cofu_x, u_x);
    201:   for (comp = 0; comp < Ncomp; ++comp) {
    202:     for (d = 0, f0[comp] = 0.0; d < dim; ++d) f0[comp] += cofu_x[comp*dim+d] * n[d];
    203:     f0[comp] *= p;
    204:   }
    205: }

    207: void g1_bd_uu_3d(PetscInt dim, PetscInt Nf, PetscInt NfAux,
    208:     const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[],
    209:     const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[],
    210:     PetscReal t, PetscReal u_tShift, const PetscReal x[], const PetscReal n[], PetscInt numConstants, const PetscScalar constants[], PetscScalar g1[])
    211: {
    212:   const PetscInt Ncomp = dim;
    213:   PetscScalar    p = a[aOff[1]];
    214:   PetscReal      cofu_x[9/*Ncomp*dim*/], m[3/*Ncomp*/], detu_x;
    215:   PetscInt       comp, compI, compJ, d;

    217:   Cof3D(cofu_x, u_x);
    218:   Det3D(&detu_x, u_x);
    219:   p /= detu_x;

    221:   for (comp = 0; comp < Ncomp; ++comp) for (d = 0, m[comp] = 0.0; d < dim; ++d) m[comp] += cofu_x[comp*dim+d] * n[d];
    222:   for (compI = 0; compI < Ncomp; ++compI) {
    223:     for (compJ = 0; compJ < Ncomp; ++compJ) {
    224:       for (d = 0; d < dim; ++d) {
    225:         g1[(compI*Ncomp+compJ)*dim+d] = p * (m[compI] * cofu_x[compJ*dim+d] - cofu_x[compI*dim+d] * m[compJ]);
    226:       }
    227:     }
    228:   }
    229: }

    231: void f0_p_3d(PetscInt dim, PetscInt Nf, PetscInt NfAux,
    232:           const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[],
    233:           const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[],
    234:           PetscReal t, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar f0[])
    235: {
    236:   PetscReal detu_x;
    237:   Det3D(&detu_x, u_x);
    238:   f0[0] = detu_x - 1.0;
    239: }

    241: void g1_pu_3d(PetscInt dim, PetscInt Nf, PetscInt NfAux,
    242:            const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[],
    243:            const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[],
    244:            PetscReal t, PetscReal u_tShift, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar g1[])
    245: {
    246:   PetscReal cofu_x[9/*Ncomp*dim*/];
    247:   PetscInt  compI, d;

    249:   Cof3D(cofu_x, u_x);
    250:   for (compI = 0; compI < dim; ++compI)
    251:     for (d = 0; d < dim; ++d) g1[compI*dim+d] = cofu_x[compI*dim+d];
    252: }

    254: void g2_up_3d(PetscInt dim, PetscInt Nf, PetscInt NfAux,
    255:            const PetscInt uOff[], const PetscInt uOff_x[], const PetscScalar u[], const PetscScalar u_t[], const PetscScalar u_x[],
    256:            const PetscInt aOff[], const PetscInt aOff_x[], const PetscScalar a[], const PetscScalar a_t[], const PetscScalar a_x[],
    257:            PetscReal t, PetscReal u_tShift, const PetscReal x[], PetscInt numConstants, const PetscScalar constants[], PetscScalar g2[])
    258: {
    259:   PetscReal cofu_x[9/*Ncomp*dim*/];
    260:   PetscInt  compI, d;

    262:   Cof3D(cofu_x, u_x);
    263:   for (compI = 0; compI < dim; ++compI)
    264:     for (d = 0; d < dim; ++d) g2[compI*dim+d] = cofu_x[compI*dim+d];
    265: }

    267: PetscErrorCode ProcessOptions(MPI_Comm comm, AppCtx *options)
    268: {
    269:   const char    *runTypes[2] = {"full", "test"};
    270:   PetscInt       run;

    274:   options->debug           = 0;
    275:   options->runType         = RUN_FULL;
    276:   options->dim             = 3;
    277:   options->interpolate     = PETSC_FALSE;
    278:   options->simplex         = PETSC_TRUE;
    279:   options->refinementLimit = 0.0;
    280:   options->mu              = 1.0;
    281:   options->p_wall          = 0.4;
    282:   options->testPartition   = PETSC_FALSE;
    283:   options->showInitial     = PETSC_FALSE;
    284:   options->showSolution    = PETSC_TRUE;

    286:   PetscOptionsBegin(comm, "", "Nonlinear elasticity problem options", "DMPLEX");
    287:   PetscOptionsInt("-debug", "The debugging level", "ex77.c", options->debug, &options->debug, NULL);
    288:   run  = options->runType;
    289:   PetscOptionsEList("-run_type", "The run type", "ex77.c", runTypes, 2, runTypes[options->runType], &run, NULL);

    291:   options->runType = (RunType) run;

    293:   PetscOptionsInt("-dim", "The topological mesh dimension", "ex77.c", options->dim, &options->dim, NULL);
    294:   PetscOptionsBool("-interpolate", "Generate intermediate mesh elements", "ex77.c", options->interpolate, &options->interpolate, NULL);
    295:   PetscOptionsBool("-simplex", "Use simplices or tensor product cells", "ex77.c", options->simplex, &options->simplex, NULL);
    296:   PetscOptionsReal("-refinement_limit", "The largest allowable cell volume", "ex77.c", options->refinementLimit, &options->refinementLimit, NULL);
    297:   PetscOptionsBool("-test_partition", "Use a fixed partition for testing", "ex77.c", options->testPartition, &options->testPartition, NULL);
    298:   PetscOptionsReal("-shear_modulus", "The shear modulus", "ex77.c", options->mu, &options->mu, NULL);
    299:   PetscOptionsReal("-wall_pressure", "The wall pressure", "ex77.c", options->p_wall, &options->p_wall, NULL);

    301:   PetscOptionsBool("-show_initial", "Output the initial guess for verification", "ex77.c", options->showInitial, &options->showInitial, NULL);
    302:   PetscOptionsBool("-show_solution", "Output the solution for verification", "ex77.c", options->showSolution, &options->showSolution, NULL);
    303:   PetscOptionsEnd();

    305:   PetscLogEventRegister("CreateMesh", DM_CLASSID, &options->createMeshEvent);
    306:   return(0);
    307: }

    309: PetscErrorCode DMVecViewLocal(DM dm, Vec v, PetscViewer viewer)
    310: {
    311:   Vec            lv;
    312:   PetscInt       p;
    313:   PetscMPIInt    rank, size;

    317:   MPI_Comm_rank(PetscObjectComm((PetscObject)dm), &rank);
    318:   MPI_Comm_size(PetscObjectComm((PetscObject)dm), &size);
    319:   DMGetLocalVector(dm, &lv);
    320:   DMGlobalToLocalBegin(dm, v, INSERT_VALUES, lv);
    321:   DMGlobalToLocalEnd(dm, v, INSERT_VALUES, lv);
    322:   PetscPrintf(PETSC_COMM_WORLD, "Local function\n");
    323:   for (p = 0; p < size; ++p) {
    324:     if (p == rank) {VecView(lv, PETSC_VIEWER_STDOUT_SELF);}
    325:     PetscBarrier((PetscObject) dm);
    326:   }
    327:   DMRestoreLocalVector(dm, &lv);
    328:   return(0);
    329: }

    331: PetscErrorCode CreateMesh(MPI_Comm comm, AppCtx *user, DM *dm)
    332: {
    333:   PetscInt       dim             = user->dim;
    334:   PetscBool      interpolate     = user->interpolate;
    335:   PetscReal      refinementLimit = user->refinementLimit;
    336:   const PetscInt cells[3]        = {3, 3, 3};

    340:   PetscLogEventBegin(user->createMeshEvent,0,0,0,0);
    341:   DMPlexCreateBoxMesh(comm, dim, user->simplex, user->simplex ? NULL : cells, NULL, NULL, NULL, interpolate, dm);
    342:   /* Label the faces (bit of a hack here, until it is properly implemented for simplices) */
    343:   {
    344:     DM              cdm;
    345:     DMLabel         label;
    346:     IS              is;
    347:     PetscInt        d, dim = user->dim, b, f, Nf;
    348:     const PetscInt *faces;
    349:     PetscInt        csize;
    350:     PetscScalar    *coords = NULL;
    351:     PetscSection    cs;
    352:     Vec             coordinates ;

    354:     DMCreateLabel(*dm, "boundary");
    355:     DMGetLabel(*dm, "boundary", &label);
    356:     DMPlexMarkBoundaryFaces(*dm, 1, label);
    357:     DMGetStratumIS(*dm, "boundary", 1,  &is);
    358:     if (is) {
    359:       PetscReal faceCoord;
    360:       PetscInt  v;

    362:       ISGetLocalSize(is, &Nf);
    363:       ISGetIndices(is, &faces);

    365:       DMGetCoordinatesLocal(*dm, &coordinates);
    366:       DMGetCoordinateDM(*dm, &cdm);
    367:       DMGetLocalSection(cdm, &cs);

    369:       /* Check for each boundary face if any component of its centroid is either 0.0 or 1.0 */
    370:       for (f = 0; f < Nf; ++f) {
    371:         DMPlexVecGetClosure(cdm, cs, coordinates, faces[f], &csize, &coords);
    372:         /* Calculate mean coordinate vector */
    373:         for (d = 0; d < dim; ++d) {
    374:           const PetscInt Nv = csize/dim;
    375:           faceCoord = 0.0;
    376:           for (v = 0; v < Nv; ++v) faceCoord += PetscRealPart(coords[v*dim+d]);
    377:           faceCoord /= Nv;
    378:           for (b = 0; b < 2; ++b) {
    379:             if (PetscAbs(faceCoord - b*1.0) < PETSC_SMALL) {
    380:               DMSetLabelValue(*dm, "Faces", faces[f], d*2+b+1);
    381:             }
    382:           }
    383:         }
    384:         DMPlexVecRestoreClosure(cdm, cs, coordinates, faces[f], &csize, &coords);
    385:       }
    386:       ISRestoreIndices(is, &faces);
    387:     }
    388:     ISDestroy(&is);
    389:   }
    390:   {
    391:     DM refinedMesh     = NULL;
    392:     DM distributedMesh = NULL;
    393:     PetscPartitioner part;

    395:     DMPlexGetPartitioner(*dm, &part);

    397:     /* Refine mesh using a volume constraint */
    398:     DMPlexSetRefinementLimit(*dm, refinementLimit);
    399:     if (user->simplex) {DMRefine(*dm, comm, &refinedMesh);}
    400:     if (refinedMesh) {
    401:       DMDestroy(dm);
    402:       *dm  = refinedMesh;
    403:     }
    404:     /* Setup test partitioning */
    405:     if (user->testPartition) {
    406:       PetscInt         triSizes_n2[2]       = {4, 4};
    407:       PetscInt         triPoints_n2[8]      = {3, 5, 6, 7, 0, 1, 2, 4};
    408:       PetscInt         triSizes_n3[3]       = {2, 3, 3};
    409:       PetscInt         triPoints_n3[8]      = {3, 5, 1, 6, 7, 0, 2, 4};
    410:       PetscInt         triSizes_n5[5]       = {1, 2, 2, 1, 2};
    411:       PetscInt         triPoints_n5[8]      = {3, 5, 6, 4, 7, 0, 1, 2};
    412:       PetscInt         triSizes_ref_n2[2]   = {8, 8};
    413:       PetscInt         triPoints_ref_n2[16] = {1, 5, 6, 7, 10, 11, 14, 15, 0, 2, 3, 4, 8, 9, 12, 13};
    414:       PetscInt         triSizes_ref_n3[3]   = {5, 6, 5};
    415:       PetscInt         triPoints_ref_n3[16] = {1, 7, 10, 14, 15, 2, 6, 8, 11, 12, 13, 0, 3, 4, 5, 9};
    416:       PetscInt         triSizes_ref_n5[5]   = {3, 4, 3, 3, 3};
    417:       PetscInt         triPoints_ref_n5[16] = {1, 7, 10, 2, 11, 13, 14, 5, 6, 15, 0, 8, 9, 3, 4, 12};
    418:       PetscInt         tetSizes_n2[2]       = {3, 3};
    419:       PetscInt         tetPoints_n2[6]      = {1, 2, 3, 0, 4, 5};
    420:       const PetscInt  *sizes = NULL;
    421:       const PetscInt  *points = NULL;
    422:       PetscInt         cEnd;
    423:       PetscMPIInt      rank, size;

    425:       MPI_Comm_rank(comm, &rank);
    426:       MPI_Comm_size(comm, &size);
    427:       DMPlexGetHeightStratum(*dm, 0, NULL, &cEnd);
    428:       if (!rank) {
    429:         if (dim == 2 && user->simplex && size == 2 && cEnd == 8) {
    430:            sizes = triSizes_n2; points = triPoints_n2;
    431:         } else if (dim == 2 && user->simplex && size == 3 && cEnd == 8) {
    432:           sizes = triSizes_n3; points = triPoints_n3;
    433:         } else if (dim == 2 && user->simplex && size == 5 && cEnd == 8) {
    434:           sizes = triSizes_n5; points = triPoints_n5;
    435:         } else if (dim == 2 && user->simplex && size == 2 && cEnd == 16) {
    436:            sizes = triSizes_ref_n2; points = triPoints_ref_n2;
    437:         } else if (dim == 2 && user->simplex && size == 3 && cEnd == 16) {
    438:           sizes = triSizes_ref_n3; points = triPoints_ref_n3;
    439:         } else if (dim == 2 && user->simplex && size == 5 && cEnd == 16) {
    440:           sizes = triSizes_ref_n5; points = triPoints_ref_n5;
    441:         } else if (dim == 3 && user->simplex && size == 2 && cEnd == 6) {
    442:           sizes = tetSizes_n2; points = tetPoints_n2;
    443:         } else SETERRQ(comm, PETSC_ERR_ARG_WRONG, "No stored partition matching run parameters");
    444:       }
    445:       PetscPartitionerSetType(part, PETSCPARTITIONERSHELL);
    446:       PetscPartitionerShellSetPartition(part, size, sizes, points);
    447:     } else {
    448:       PetscPartitionerSetFromOptions(part);
    449:     }
    450:     /* Distribute mesh over processes */
    451:     DMPlexDistribute(*dm, 0, NULL, &distributedMesh);
    452:     if (distributedMesh) {
    453:       DMDestroy(dm);
    454:       *dm  = distributedMesh;
    455:     }
    456:   }
    457:   DMSetFromOptions(*dm);
    458:   DMViewFromOptions(*dm, NULL, "-dm_view");

    460:   PetscLogEventEnd(user->createMeshEvent,0,0,0,0);
    461:   return(0);
    462: }

    464: PetscErrorCode SetupProblem(DM dm, PetscInt dim, AppCtx *user)
    465: {
    466:   PetscDS        prob;

    470:   DMGetDS(dm, &prob);
    471:   PetscDSSetResidual(prob, 0, NULL, f1_u_3d);
    472:   PetscDSSetResidual(prob, 1, f0_p_3d, NULL);
    473:   PetscDSSetJacobian(prob, 0, 0, NULL, NULL,  NULL,  g3_uu_3d);
    474:   PetscDSSetJacobian(prob, 0, 1, NULL, NULL,  g2_up_3d, NULL);
    475:   PetscDSSetJacobian(prob, 1, 0, NULL, g1_pu_3d, NULL,  NULL);

    477:   PetscDSSetBdResidual(prob, 0, f0_bd_u_3d, NULL);
    478:   PetscDSSetBdJacobian(prob, 0, 0, NULL, g1_bd_uu_3d, NULL, NULL);

    480:   PetscDSAddBoundary(prob, DM_BC_ESSENTIAL, "fixed", "Faces", 0, 0, NULL, (void (*)(void)) coordinates, 0, NULL, user);
    481:   PetscDSAddBoundary(prob, DM_BC_NATURAL, "pressure", "Faces", 0, 0, NULL, NULL, 0, NULL, user);
    482:   return(0);
    483: }

    485: PetscErrorCode SetupMaterial(DM dm, DM dmAux, AppCtx *user)
    486: {
    487:   PetscErrorCode (*matFuncs[2])(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar u[], void *ctx) = {elasticityMaterial, wallPressure};
    488:   Vec            A;
    489:   void          *ctxs[2];

    493:   ctxs[0] = user; ctxs[1] = user;
    494:   DMCreateLocalVector(dmAux, &A);
    495:   DMProjectFunctionLocal(dmAux, 0.0, matFuncs, ctxs, INSERT_ALL_VALUES, A);
    496:   PetscObjectCompose((PetscObject) dm, "A", (PetscObject) A);
    497:   VecDestroy(&A);
    498:   return(0);
    499: }

    501: PetscErrorCode SetupNearNullSpace(DM dm, AppCtx *user)
    502: {
    503:   /* Set up the near null space (a.k.a. rigid body modes) that will be used by the multigrid preconditioner */
    504:   DM             subdm;
    505:   MatNullSpace   nearNullSpace;
    506:   PetscInt       fields = 0;
    507:   PetscObject    deformation;

    511:   DMCreateSubDM(dm, 1, &fields, NULL, &subdm);
    512:   DMPlexCreateRigidBody(subdm, &nearNullSpace);
    513:   DMGetField(dm, 0, NULL, &deformation);
    514:   PetscObjectCompose(deformation, "nearnullspace", (PetscObject) nearNullSpace);
    515:   DMDestroy(&subdm);
    516:   MatNullSpaceDestroy(&nearNullSpace);
    517:   return(0);
    518: }

    520: static PetscErrorCode SetupAuxDM(DM dm, PetscInt NfAux, PetscFE feAux[], AppCtx *user)
    521: {
    522:   DM             dmAux, coordDM;
    523:   PetscInt       f;

    527:   /* MUST call DMGetCoordinateDM() in order to get p4est setup if present */
    528:   DMGetCoordinateDM(dm, &coordDM);
    529:   if (!feAux) return(0);
    530:   DMClone(dm, &dmAux);
    531:   PetscObjectCompose((PetscObject) dm, "dmAux", (PetscObject) dmAux);
    532:   DMSetCoordinateDM(dmAux, coordDM);
    533:   for (f = 0; f < NfAux; ++f) {DMSetField(dmAux, f, NULL, (PetscObject) feAux[f]);}
    534:   DMCreateDS(dmAux);
    535:   SetupMaterial(dm, dmAux, user);
    536:   DMDestroy(&dmAux);
    537:   return(0);
    538: }

    540: PetscErrorCode SetupDiscretization(DM dm, AppCtx *user)
    541: {
    542:   DM              cdm   = dm;
    543:   const PetscInt  dim   = user->dim;
    544:   const PetscBool simplex = user->simplex;
    545:   PetscFE         fe[2], feAux[2];
    546:   MPI_Comm        comm;
    547:   PetscErrorCode  ierr;

    550:   PetscObjectGetComm((PetscObject) dm, &comm);
    551:   /* Create finite element */
    552:   PetscFECreateDefault(comm, dim, dim, simplex, "def_", PETSC_DEFAULT, &fe[0]);
    553:   PetscObjectSetName((PetscObject) fe[0], "deformation");
    554:   PetscFECreateDefault(comm, dim, 1, simplex, "pres_", PETSC_DEFAULT, &fe[1]);
    555:   PetscFECopyQuadrature(fe[0], fe[1]);

    557:   PetscObjectSetName((PetscObject) fe[1], "pressure");

    559:   PetscFECreateDefault(comm, dim, 1, simplex, "elastMat_", PETSC_DEFAULT, &feAux[0]);
    560:   PetscObjectSetName((PetscObject) feAux[0], "elasticityMaterial");
    561:   PetscFECopyQuadrature(fe[0], feAux[0]);
    562:   /* It is not yet possible to define a field on a submesh (e.g. a boundary), so we will use a normal finite element */
    563:   PetscFECreateDefault(comm, dim, 1, simplex, "wall_pres_", PETSC_DEFAULT, &feAux[1]);
    564:   PetscObjectSetName((PetscObject) feAux[1], "wall_pressure");
    565:   PetscFECopyQuadrature(fe[0], feAux[1]);

    567:   /* Set discretization and boundary conditions for each mesh */
    568:   DMSetField(dm, 0, NULL, (PetscObject) fe[0]);
    569:   DMSetField(dm, 1, NULL, (PetscObject) fe[1]);
    570:   DMCreateDS(dm);
    571:   SetupProblem(dm, dim, user);
    572:   while (cdm) {
    573:     DMCopyDisc(dm, cdm);
    574:     SetupAuxDM(cdm, 2, feAux, user);
    575:     DMGetCoarseDM(cdm, &cdm);
    576:   }
    577:   PetscFEDestroy(&fe[0]);
    578:   PetscFEDestroy(&fe[1]);
    579:   PetscFEDestroy(&feAux[0]);
    580:   PetscFEDestroy(&feAux[1]);
    581:   return(0);
    582: }

    585: int main(int argc, char **argv)
    586: {
    587:   SNES           snes;                 /* nonlinear solver */
    588:   DM             dm;                   /* problem definition */
    589:   Vec            u,r;                  /* solution, residual vectors */
    590:   Mat            A,J;                  /* Jacobian matrix */
    591:   AppCtx         user;                 /* user-defined work context */
    592:   PetscInt       its;                  /* iterations for convergence */

    595:   PetscInitialize(&argc, &argv, NULL,help);if (ierr) return ierr;
    596:   ProcessOptions(PETSC_COMM_WORLD, &user);
    597:   SNESCreate(PETSC_COMM_WORLD, &snes);
    598:   CreateMesh(PETSC_COMM_WORLD, &user, &dm);
    599:   SNESSetDM(snes, dm);
    600:   DMSetApplicationContext(dm, &user);

    602:   SetupDiscretization(dm, &user);
    603:   DMPlexCreateClosureIndex(dm, NULL);
    604:   SetupNearNullSpace(dm, &user);

    606:   DMCreateGlobalVector(dm, &u);
    607:   VecDuplicate(u, &r);

    609:   DMSetMatType(dm,MATAIJ);
    610:   DMCreateMatrix(dm, &J);
    611:   A = J;

    613:   DMPlexSetSNESLocalFEM(dm,&user,&user,&user);
    614:   SNESSetJacobian(snes, A, J, NULL, NULL);

    616:   SNESSetFromOptions(snes);

    618:   {
    619:     PetscErrorCode (*initialGuess[2])(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void* ctx);
    620:     initialGuess[0] = coordinates; initialGuess[1] = zero_scalar;
    621:     DMProjectFunction(dm, 0.0, initialGuess, NULL, INSERT_VALUES, u);
    622:   }
    623:   if (user.showInitial) {DMVecViewLocal(dm, u, PETSC_VIEWER_STDOUT_SELF);}

    625:   if (user.runType == RUN_FULL) {
    626:     if (user.debug) {
    627:       PetscPrintf(PETSC_COMM_WORLD, "Initial guess\n");
    628:       VecView(u, PETSC_VIEWER_STDOUT_WORLD);
    629:     }
    630:     SNESSolve(snes, NULL, u);
    631:     SNESGetIterationNumber(snes, &its);
    632:     PetscPrintf(PETSC_COMM_WORLD, "Number of SNES iterations = %D\n", its);
    633:     if (user.showSolution) {
    634:       PetscPrintf(PETSC_COMM_WORLD, "Solution\n");
    635:       VecChop(u, 3.0e-9);
    636:       VecView(u, PETSC_VIEWER_STDOUT_WORLD);
    637:     }
    638:   } else {
    639:     PetscReal res = 0.0;

    641:     /* Check initial guess */
    642:     PetscPrintf(PETSC_COMM_WORLD, "Initial guess\n");
    643:     VecView(u, PETSC_VIEWER_STDOUT_WORLD);
    644:     /* Check residual */
    645:     SNESComputeFunction(snes, u, r);
    646:     PetscPrintf(PETSC_COMM_WORLD, "Initial Residual\n");
    647:     VecChop(r, 1.0e-10);
    648:     VecView(r, PETSC_VIEWER_STDOUT_WORLD);
    649:     VecNorm(r, NORM_2, &res);
    650:     PetscPrintf(PETSC_COMM_WORLD, "L_2 Residual: %g\n", (double)res);
    651:     /* Check Jacobian */
    652:     {
    653:       Vec b;

    655:       SNESComputeJacobian(snes, u, A, A);
    656:       VecDuplicate(u, &b);
    657:       VecSet(r, 0.0);
    658:       SNESComputeFunction(snes, r, b);
    659:       MatMult(A, u, r);
    660:       VecAXPY(r, 1.0, b);
    661:       VecDestroy(&b);
    662:       PetscPrintf(PETSC_COMM_WORLD, "Au - b = Au + F(0)\n");
    663:       VecChop(r, 1.0e-10);
    664:       VecView(r, PETSC_VIEWER_STDOUT_WORLD);
    665:       VecNorm(r, NORM_2, &res);
    666:       PetscPrintf(PETSC_COMM_WORLD, "Linear L_2 Residual: %g\n", (double)res);
    667:     }
    668:   }
    669:   VecViewFromOptions(u, NULL, "-sol_vec_view");

    671:   if (A != J) {MatDestroy(&A);}
    672:   MatDestroy(&J);
    673:   VecDestroy(&u);
    674:   VecDestroy(&r);
    675:   SNESDestroy(&snes);
    676:   DMDestroy(&dm);
    677:   PetscFinalize();
    678:   return ierr;
    679: }

    681: /*TEST

    683:   build:
    684:     requires: !complex

    686:   test:
    687:     suffix: 0
    688:     requires: ctetgen !single
    689:     args: -run_type full -dim 3 -dm_refine 2 -interpolate 1 -bc_fixed 1 -bc_pressure 2 -wall_pressure 0.4 -def_petscspace_degree 2 -pres_petscspace_degree 1 -elastMat_petscspace_degree 0 -wall_pres_petscspace_degree 0 -snes_rtol 1e-05 -ksp_type fgmres -ksp_rtol 1e-10 -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_factorization_type upper -fieldsplit_deformation_ksp_type preonly -fieldsplit_deformation_pc_type lu -fieldsplit_pressure_ksp_rtol 1e-10 -fieldsplit_pressure_pc_type jacobi -snes_monitor_short -ksp_monitor_short -snes_converged_reason -ksp_converged_reason -show_solution 0

    691:   test:
    692:     suffix: 1
    693:     requires: ctetgen superlu_dist
    694:     nsize: 2
    695:     args: -run_type full -dim 3 -dm_refine 0 -interpolate 1 -test_partition -bc_fixed 1 -bc_pressure 2 -wall_pressure 0.4 -def_petscspace_degree 2 -pres_petscspace_degree 1 -elastMat_petscspace_degree 0 -wall_pres_petscspace_degree 0 -snes_rtol 1e-05 -ksp_type fgmres -ksp_rtol 1e-10 -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_factorization_type upper -fieldsplit_deformation_ksp_type preonly -fieldsplit_deformation_pc_type lu -fieldsplit_pressure_ksp_rtol 1e-10 -fieldsplit_pressure_pc_type jacobi -snes_monitor_short -ksp_monitor_short -snes_converged_reason -ksp_converged_reason -show_solution 0
    696:     timeoutfactor: 2

    698:   test:
    699:     suffix: 2
    700:     requires: ctetgen !single
    701:     args: -run_type full -dim 3 -dm_refine 2 -interpolate 1 -bc_fixed 3,4,5,6 -bc_pressure 2 -wall_pressure 1.0 -def_petscspace_degree 2 -pres_petscspace_degree 1 -elastMat_petscspace_degree 0 -wall_pres_petscspace_degree 0 -snes_rtol 1e-05 -ksp_type fgmres -ksp_rtol 1e-10 -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_factorization_type upper -fieldsplit_deformation_ksp_type preonly -fieldsplit_deformation_pc_type lu -fieldsplit_pressure_ksp_rtol 1e-10 -fieldsplit_pressure_pc_type jacobi -snes_monitor_short -ksp_monitor_short -snes_converged_reason -ksp_converged_reason -show_solution 0

    703:   test:
    704:     requires: ctetgen superlu_dist
    705:     suffix: 4
    706:     nsize: 2
    707:     args: -run_type full -dim 3 -dm_refine 0 -interpolate 1 -test_partition -bc_fixed 1 -bc_pressure 2 -wall_pressure 0.4 -def_petscspace_degree 2 -pres_petscspace_degree 1 -elastMat_petscspace_degree 0 -wall_pres_petscspace_degree 0 -snes_rtol 1e-05 -ksp_type fgmres -ksp_rtol 1e-10 -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_factorization_type upper -fieldsplit_deformation_ksp_type preonly -fieldsplit_deformation_pc_type lu -fieldsplit_pressure_ksp_rtol 1e-10 -fieldsplit_pressure_pc_type jacobi -snes_monitor_short -ksp_monitor_short -snes_converged_reason -ksp_converged_reason -show_solution 0
    708:     output_file: output/ex77_1.out

    710:   test:
    711:     requires: ctetgen !single
    712:     suffix: 3
    713:     args: -run_type full -dim 3 -dm_refine 2 -interpolate 1 -bc_fixed 3,4,5,6 -bc_pressure 2 -wall_pressure 1.0 -def_petscspace_degree 2 -pres_petscspace_degree 1 -elastMat_petscspace_degree 0 -wall_pres_petscspace_degree 0 -snes_rtol 1e-05 -ksp_type fgmres -ksp_rtol 1e-10 -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_factorization_type upper -fieldsplit_deformation_ksp_type preonly -fieldsplit_deformation_pc_type lu -fieldsplit_pressure_ksp_rtol 1e-10 -fieldsplit_pressure_pc_type jacobi -snes_monitor_short -ksp_monitor_short -snes_converged_reason -ksp_converged_reason -show_solution 0
    714:     output_file: output/ex77_2.out

    716:   #TODO: this example deadlocks for me when using ParMETIS
    717:   test:
    718:     requires: ctetgen superlu_dist !single
    719:     suffix: 2_par
    720:     nsize: 4
    721:     args: -run_type full -dim 3 -dm_refine 2 -interpolate 1 -bc_fixed 3,4,5,6 -bc_pressure 2 -wall_pressure 1.0 -def_petscspace_degree 2 -pres_petscspace_degree 1 -elastMat_petscspace_degree 0 -wall_pres_petscspace_degree 0 -snes_rtol 1e-05 -ksp_type fgmres -ksp_rtol 1e-10 -pc_type fieldsplit -pc_fieldsplit_type schur -pc_fieldsplit_schur_factorization_type upper -fieldsplit_deformation_ksp_type preonly -fieldsplit_deformation_pc_type lu -fieldsplit_pressure_ksp_rtol 1e-10 -fieldsplit_pressure_pc_type jacobi -snes_monitor_short -ksp_monitor_short -snes_converged_reason -ksp_converged_reason -show_solution 0 -petscpartitioner_type simple
    722:     output_file: output/ex77_2.out

    724: TEST*/