Actual source code: ex8.c

      1: static const char help[] = "1D periodic Finite Volume solver in slope-limiter form with semidiscrete time stepping.\n"
      2:                            "  advection   - Constant coefficient scalar advection\n"
      3:                            "                u_t       + (a*u)_x               = 0\n"
      4:                            "  for this toy problem, we choose different meshsizes for different sub-domains (slow-medium-fast-medium-slow), \n"
      5:                            "  the meshsize ratio between two adjacient sub-domains is controlled with -hratio,\n"
      6:                            "  exact       - Exact Riemann solver which usually needs to perform a Newton iteration to connect\n"
      7:                            "                the states across shocks and rarefactions\n"
      8:                            "  simulation  - use reference solution which is generated by smaller time step size to be true solution,\n"
      9:                            "                also the reference solution should be generated by user and stored in a binary file.\n"
     10:                            "  characteristic - Limit the characteristic variables, this is usually preferred (default)\n"
     11:                            "Several initial conditions can be chosen with -initial N\n\n"
     12:                            "The problem size should be set with -da_grid_x M\n\n";

     14: #include <petscts.h>
     15: #include <petscdm.h>
     16: #include <petscdmda.h>
     17: #include <petscdraw.h>
     18: #include "finitevolume1d.h"

     20: static inline PetscReal RangeMod(PetscReal a, PetscReal xmin, PetscReal xmax)
     21: {
     22:   PetscReal range = xmax - xmin;
     23:   return xmin + PetscFmodReal(range + PetscFmodReal(a, range), range);
     24: }

     26: /* --------------------------------- Advection ----------------------------------- */
     27: typedef struct {
     28:   PetscReal a; /* advective velocity */
     29: } AdvectCtx;

     31: static PetscErrorCode PhysicsRiemann_Advect(void *vctx, PetscInt m, const PetscScalar *uL, const PetscScalar *uR, PetscScalar *flux, PetscReal *maxspeed)
     32: {
     33:   AdvectCtx *ctx = (AdvectCtx *)vctx;
     34:   PetscReal  speed;

     36:   PetscFunctionBeginUser;
     37:   speed     = ctx->a;
     38:   flux[0]   = PetscMax(0, speed) * uL[0] + PetscMin(0, speed) * uR[0];
     39:   *maxspeed = speed;
     40:   PetscFunctionReturn(PETSC_SUCCESS);
     41: }

     43: static PetscErrorCode PhysicsCharacteristic_Advect(void *vctx, PetscInt m, const PetscScalar *u, PetscScalar *X, PetscScalar *Xi, PetscReal *speeds)
     44: {
     45:   AdvectCtx *ctx = (AdvectCtx *)vctx;

     47:   PetscFunctionBeginUser;
     48:   X[0]      = 1.;
     49:   Xi[0]     = 1.;
     50:   speeds[0] = ctx->a;
     51:   PetscFunctionReturn(PETSC_SUCCESS);
     52: }

     54: static PetscErrorCode PhysicsSample_Advect(void *vctx, PetscInt initial, FVBCType bctype, PetscReal xmin, PetscReal xmax, PetscReal t, PetscReal x, PetscReal *u)
     55: {
     56:   AdvectCtx *ctx = (AdvectCtx *)vctx;
     57:   PetscReal  a   = ctx->a, x0;

     59:   PetscFunctionBeginUser;
     60:   switch (bctype) {
     61:   case FVBC_OUTFLOW:
     62:     x0 = x - a * t;
     63:     break;
     64:   case FVBC_PERIODIC:
     65:     x0 = RangeMod(x - a * t, xmin, xmax);
     66:     break;
     67:   default:
     68:     SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_UNKNOWN_TYPE, "unknown BCType");
     69:   }
     70:   switch (initial) {
     71:   case 0:
     72:     u[0] = (x0 < 0) ? 1 : -1;
     73:     break;
     74:   case 1:
     75:     u[0] = (x0 < 0) ? -1 : 1;
     76:     break;
     77:   case 2:
     78:     u[0] = (0 < x0 && x0 < 1) ? 1 : 0;
     79:     break;
     80:   case 3:
     81:     u[0] = PetscSinReal(2 * PETSC_PI * x0);
     82:     break;
     83:   case 4:
     84:     u[0] = PetscAbs(x0);
     85:     break;
     86:   case 5:
     87:     u[0] = (x0 < 0 || x0 > 0.5) ? 0 : PetscSqr(PetscSinReal(2 * PETSC_PI * x0));
     88:     break;
     89:   case 6:
     90:     u[0] = (x0 < 0) ? 0 : ((x0 < 1) ? x0 : ((x0 < 2) ? 2 - x0 : 0));
     91:     break;
     92:   case 7:
     93:     u[0] = PetscPowReal(PetscSinReal(PETSC_PI * x0), 10.0);
     94:     break;
     95:   default:
     96:     SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_UNKNOWN_TYPE, "unknown initial condition");
     97:   }
     98:   PetscFunctionReturn(PETSC_SUCCESS);
     99: }

    101: static PetscErrorCode PhysicsCreate_Advect(FVCtx *ctx)
    102: {
    103:   AdvectCtx *user;

    105:   PetscFunctionBeginUser;
    106:   PetscCall(PetscNew(&user));
    107:   ctx->physics2.sample2         = PhysicsSample_Advect;
    108:   ctx->physics2.riemann2        = PhysicsRiemann_Advect;
    109:   ctx->physics2.characteristic2 = PhysicsCharacteristic_Advect;
    110:   ctx->physics2.destroy         = PhysicsDestroy_SimpleFree;
    111:   ctx->physics2.user            = user;
    112:   ctx->physics2.dof             = 1;
    113:   PetscCall(PetscStrallocpy("u", &ctx->physics2.fieldname[0]));
    114:   user->a = 1;
    115:   PetscOptionsBegin(ctx->comm, ctx->prefix, "Options for advection", "");
    116:   {
    117:     PetscCall(PetscOptionsReal("-physics_advect_a", "Speed", "", user->a, &user->a, NULL));
    118:   }
    119:   PetscOptionsEnd();
    120:   PetscFunctionReturn(PETSC_SUCCESS);
    121: }

    123: PetscErrorCode FVSample_3WaySplit(FVCtx *ctx, DM da, PetscReal time, Vec U)
    124: {
    125:   PetscScalar   *u, *uj, xj, xi;
    126:   PetscInt       i, j, k, dof, xs, xm, Mx;
    127:   const PetscInt N = 200;
    128:   PetscReal      hs, hm, hf;

    130:   PetscFunctionBeginUser;
    131:   PetscCheck(ctx->physics2.sample2, PETSC_COMM_SELF, PETSC_ERR_SUP, "Physics has not provided a sampling function");
    132:   PetscCall(DMDAGetInfo(da, 0, &Mx, 0, 0, 0, 0, 0, &dof, 0, 0, 0, 0, 0));
    133:   PetscCall(DMDAGetCorners(da, &xs, 0, 0, &xm, 0, 0));
    134:   PetscCall(DMDAVecGetArray(da, U, &u));
    135:   PetscCall(PetscMalloc1(dof, &uj));

    137:   hs = (ctx->xmax - ctx->xmin) / 8.0 / ctx->sm;
    138:   hm = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->mf - ctx->sm);
    139:   hf = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->fm - ctx->mf);
    140:   for (i = xs; i < xs + xm; i++) {
    141:     if (i < ctx->sm) {
    142:       xi = ctx->xmin + 0.5 * hs + i * hs;
    143:       /* Integrate over cell i using trapezoid rule with N points. */
    144:       for (k = 0; k < dof; k++) u[i * dof + k] = 0;
    145:       for (j = 0; j < N + 1; j++) {
    146:         xj = xi + hs * (j - N / 2) / (PetscReal)N;
    147:         PetscCall((*ctx->physics2.sample2)(ctx->physics2.user, ctx->initial, ctx->bctype, ctx->xmin, ctx->xmax, time, xj, uj));
    148:         for (k = 0; k < dof; k++) u[i * dof + k] += ((j == 0 || j == N) ? 0.5 : 1.0) * uj[k] / N;
    149:       }
    150:     } else if (i < ctx->mf) {
    151:       xi = ctx->xmin + ctx->sm * hs + 0.5 * hm + (i - ctx->sm) * hm;
    152:       /* Integrate over cell i using trapezoid rule with N points. */
    153:       for (k = 0; k < dof; k++) u[i * dof + k] = 0;
    154:       for (j = 0; j < N + 1; j++) {
    155:         xj = xi + hm * (j - N / 2) / (PetscReal)N;
    156:         PetscCall((*ctx->physics2.sample2)(ctx->physics2.user, ctx->initial, ctx->bctype, ctx->xmin, ctx->xmax, time, xj, uj));
    157:         for (k = 0; k < dof; k++) u[i * dof + k] += ((j == 0 || j == N) ? 0.5 : 1.0) * uj[k] / N;
    158:       }
    159:     } else if (i < ctx->fm) {
    160:       xi = ctx->xmin + ctx->sm * hs + (ctx->mf - ctx->sm) * hm + 0.5 * hf + (i - ctx->mf) * hf;
    161:       /* Integrate over cell i using trapezoid rule with N points. */
    162:       for (k = 0; k < dof; k++) u[i * dof + k] = 0;
    163:       for (j = 0; j < N + 1; j++) {
    164:         xj = xi + hf * (j - N / 2) / (PetscReal)N;
    165:         PetscCall((*ctx->physics2.sample2)(ctx->physics2.user, ctx->initial, ctx->bctype, ctx->xmin, ctx->xmax, time, xj, uj));
    166:         for (k = 0; k < dof; k++) u[i * dof + k] += ((j == 0 || j == N) ? 0.5 : 1.0) * uj[k] / N;
    167:       }
    168:     } else if (i < ctx->ms) {
    169:       xi = ctx->xmin + ctx->sm * hs + (ctx->mf - ctx->sm) * hm + (ctx->fm - ctx->mf) * hf + 0.5 * hm + (i - ctx->fm) * hm;
    170:       /* Integrate over cell i using trapezoid rule with N points. */
    171:       for (k = 0; k < dof; k++) u[i * dof + k] = 0;
    172:       for (j = 0; j < N + 1; j++) {
    173:         xj = xi + hm * (j - N / 2) / (PetscReal)N;
    174:         PetscCall((*ctx->physics2.sample2)(ctx->physics2.user, ctx->initial, ctx->bctype, ctx->xmin, ctx->xmax, time, xj, uj));
    175:         for (k = 0; k < dof; k++) u[i * dof + k] += ((j == 0 || j == N) ? 0.5 : 1.0) * uj[k] / N;
    176:       }
    177:     } else {
    178:       xi = ctx->xmin + ctx->sm * hs + (ctx->mf - ctx->sm) * hm + (ctx->fm - ctx->mf) * hf + (ctx->ms - ctx->fm) * hm + 0.5 * hs + (i - ctx->ms) * hs;
    179:       /* Integrate over cell i using trapezoid rule with N points. */
    180:       for (k = 0; k < dof; k++) u[i * dof + k] = 0;
    181:       for (j = 0; j < N + 1; j++) {
    182:         xj = xi + hs * (j - N / 2) / (PetscReal)N;
    183:         PetscCall((*ctx->physics2.sample2)(ctx->physics2.user, ctx->initial, ctx->bctype, ctx->xmin, ctx->xmax, time, xj, uj));
    184:         for (k = 0; k < dof; k++) u[i * dof + k] += ((j == 0 || j == N) ? 0.5 : 1.0) * uj[k] / N;
    185:       }
    186:     }
    187:   }
    188:   PetscCall(DMDAVecRestoreArray(da, U, &u));
    189:   PetscCall(PetscFree(uj));
    190:   PetscFunctionReturn(PETSC_SUCCESS);
    191: }

    193: static PetscErrorCode SolutionErrorNorms_3WaySplit(FVCtx *ctx, DM da, PetscReal t, Vec X, PetscReal *nrm1)
    194: {
    195:   Vec                Y;
    196:   PetscInt           i, Mx;
    197:   const PetscScalar *ptr_X, *ptr_Y;
    198:   PetscReal          hs, hm, hf;

    200:   PetscFunctionBeginUser;
    201:   PetscCall(VecGetSize(X, &Mx));
    202:   hs = (ctx->xmax - ctx->xmin) / 8.0 / ctx->sm;
    203:   hm = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->mf - ctx->sm);
    204:   hf = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->fm - ctx->mf);
    205:   PetscCall(VecDuplicate(X, &Y));
    206:   PetscCall(FVSample_3WaySplit(ctx, da, t, Y));
    207:   PetscCall(VecGetArrayRead(X, &ptr_X));
    208:   PetscCall(VecGetArrayRead(Y, &ptr_Y));
    209:   for (i = 0; i < Mx; i++) {
    210:     if (i < ctx->sm || i > ctx->ms - 1) *nrm1 += hs * PetscAbs(ptr_X[i] - ptr_Y[i]);
    211:     else if (i < ctx->mf || i > ctx->fm - 1) *nrm1 += hm * PetscAbs(ptr_X[i] - ptr_Y[i]);
    212:     else *nrm1 += hf * PetscAbs(ptr_X[i] - ptr_Y[i]);
    213:   }
    214:   PetscCall(VecRestoreArrayRead(X, &ptr_X));
    215:   PetscCall(VecRestoreArrayRead(Y, &ptr_Y));
    216:   PetscCall(VecDestroy(&Y));
    217:   PetscFunctionReturn(PETSC_SUCCESS);
    218: }

    220: PetscErrorCode FVRHSFunction_3WaySplit(TS ts, PetscReal time, Vec X, Vec F, void *vctx)
    221: {
    222:   FVCtx       *ctx = (FVCtx *)vctx;
    223:   PetscInt     i, j, k, Mx, dof, xs, xm, sm = ctx->sm, mf = ctx->mf, fm = ctx->fm, ms = ctx->ms;
    224:   PetscReal    hxf, hxm, hxs, cfl_idt = 0;
    225:   PetscScalar *x, *f, *slope;
    226:   Vec          Xloc;
    227:   DM           da;

    229:   PetscFunctionBeginUser;
    230:   PetscCall(TSGetDM(ts, &da));
    231:   PetscCall(DMGetLocalVector(da, &Xloc));                                 /* Xloc contains ghost points                                     */
    232:   PetscCall(DMDAGetInfo(da, 0, &Mx, 0, 0, 0, 0, 0, &dof, 0, 0, 0, 0, 0)); /* Mx is the number of center points                              */
    233:   hxs = (ctx->xmax - ctx->xmin) / 8.0 / ctx->sm;
    234:   hxm = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->mf - ctx->sm);
    235:   hxf = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->fm - ctx->mf);
    236:   PetscCall(DMGlobalToLocalBegin(da, X, INSERT_VALUES, Xloc)); /* X is solution vector which does not contain ghost points       */
    237:   PetscCall(DMGlobalToLocalEnd(da, X, INSERT_VALUES, Xloc));

    239:   PetscCall(VecZeroEntries(F)); /* F is the right-hand side function corresponds to center points */

    241:   PetscCall(DMDAVecGetArray(da, Xloc, &x));
    242:   PetscCall(DMDAVecGetArray(da, F, &f));
    243:   PetscCall(DMDAGetArray(da, PETSC_TRUE, &slope)); /* contains ghost points                                           */

    245:   PetscCall(DMDAGetCorners(da, &xs, 0, 0, &xm, 0, 0));

    247:   if (ctx->bctype == FVBC_OUTFLOW) {
    248:     for (i = xs - 2; i < 0; i++) {
    249:       for (j = 0; j < dof; j++) x[i * dof + j] = x[j];
    250:     }
    251:     for (i = Mx; i < xs + xm + 2; i++) {
    252:       for (j = 0; j < dof; j++) x[i * dof + j] = x[(xs + xm - 1) * dof + j];
    253:     }
    254:   }
    255:   for (i = xs - 1; i < xs + xm + 1; i++) {
    256:     struct _LimitInfo info;
    257:     PetscScalar      *cjmpL, *cjmpR;
    258:     /* Determine the right eigenvectors R, where A = R \Lambda R^{-1} */
    259:     PetscCall((*ctx->physics2.characteristic2)(ctx->physics2.user, dof, &x[i * dof], ctx->R, ctx->Rinv, ctx->speeds));
    260:     /* Evaluate jumps across interfaces (i-1, i) and (i, i+1), put in characteristic basis */
    261:     PetscCall(PetscArrayzero(ctx->cjmpLR, 2 * dof));
    262:     cjmpL = &ctx->cjmpLR[0];
    263:     cjmpR = &ctx->cjmpLR[dof];
    264:     for (j = 0; j < dof; j++) {
    265:       PetscScalar jmpL, jmpR;
    266:       jmpL = x[(i + 0) * dof + j] - x[(i - 1) * dof + j];
    267:       jmpR = x[(i + 1) * dof + j] - x[(i + 0) * dof + j];
    268:       for (k = 0; k < dof; k++) {
    269:         cjmpL[k] += ctx->Rinv[k + j * dof] * jmpL;
    270:         cjmpR[k] += ctx->Rinv[k + j * dof] * jmpR;
    271:       }
    272:     }
    273:     /* Apply limiter to the left and right characteristic jumps */
    274:     info.m   = dof;
    275:     info.hxs = hxs;
    276:     info.hxm = hxm;
    277:     info.hxf = hxf;
    278:     (*ctx->limit3)(&info, cjmpL, cjmpR, ctx->sm, ctx->mf, ctx->fm, ctx->ms, i, ctx->cslope);
    279:     for (j = 0; j < dof; j++) {
    280:       PetscScalar tmp = 0;
    281:       for (k = 0; k < dof; k++) tmp += ctx->R[j + k * dof] * ctx->cslope[k];
    282:       slope[i * dof + j] = tmp;
    283:     }
    284:   }

    286:   for (i = xs; i < xs + xm + 1; i++) {
    287:     PetscReal    maxspeed;
    288:     PetscScalar *uL, *uR;
    289:     uL = &ctx->uLR[0];
    290:     uR = &ctx->uLR[dof];
    291:     if (i < sm || i > ms) { /* slow region */
    292:       for (j = 0; j < dof; j++) {
    293:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    294:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    295:       }
    296:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    297:       if (i > xs) {
    298:         for (j = 0; j < dof; j++) f[(i - 1) * dof + j] -= ctx->flux[j] / hxs;
    299:       }
    300:       if (i < xs + xm) {
    301:         for (j = 0; j < dof; j++) f[i * dof + j] += ctx->flux[j] / hxs;
    302:       }
    303:     } else if (i == sm) { /* interface between slow and medium component */
    304:       for (j = 0; j < dof; j++) {
    305:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    306:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    307:       }
    308:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    309:       if (i > xs) {
    310:         for (j = 0; j < dof; j++) f[(i - 1) * dof + j] -= ctx->flux[j] / hxs;
    311:       }
    312:       if (i < xs + xm) {
    313:         for (j = 0; j < dof; j++) f[i * dof + j] += ctx->flux[j] / hxm;
    314:       }
    315:     } else if (i == ms) { /* interface between medium and slow regions */
    316:       for (j = 0; j < dof; j++) {
    317:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    318:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    319:       }
    320:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    321:       if (i > xs) {
    322:         for (j = 0; j < dof; j++) f[(i - 1) * dof + j] -= ctx->flux[j] / hxm;
    323:       }
    324:       if (i < xs + xm) {
    325:         for (j = 0; j < dof; j++) f[i * dof + j] += ctx->flux[j] / hxs;
    326:       }
    327:     } else if (i < mf || i > fm) { /* medium region */
    328:       for (j = 0; j < dof; j++) {
    329:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    330:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    331:       }
    332:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    333:       if (i > xs) {
    334:         for (j = 0; j < dof; j++) f[(i - 1) * dof + j] -= ctx->flux[j] / hxm;
    335:       }
    336:       if (i < xs + xm) {
    337:         for (j = 0; j < dof; j++) f[i * dof + j] += ctx->flux[j] / hxm;
    338:       }
    339:     } else if (i == mf) { /* interface between medium and fast regions */
    340:       for (j = 0; j < dof; j++) {
    341:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    342:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxf / 2;
    343:       }
    344:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    345:       if (i > xs) {
    346:         for (j = 0; j < dof; j++) f[(i - 1) * dof + j] -= ctx->flux[j] / hxm;
    347:       }
    348:       if (i < xs + xm) {
    349:         for (j = 0; j < dof; j++) f[i * dof + j] += ctx->flux[j] / hxf;
    350:       }
    351:     } else if (i == fm) { /* interface between fast and medium regions */
    352:       for (j = 0; j < dof; j++) {
    353:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxf / 2;
    354:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    355:       }
    356:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    357:       if (i > xs) {
    358:         for (j = 0; j < dof; j++) f[(i - 1) * dof + j] -= ctx->flux[j] / hxf;
    359:       }
    360:       if (i < xs + xm) {
    361:         for (j = 0; j < dof; j++) f[i * dof + j] += ctx->flux[j] / hxm;
    362:       }
    363:     } else { /* fast region */
    364:       for (j = 0; j < dof; j++) {
    365:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxf / 2;
    366:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxf / 2;
    367:       }
    368:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    369:       cfl_idt = PetscMax(cfl_idt, PetscAbsScalar(maxspeed / hxs)); /* Max allowable value of 1/Delta t */
    370:       if (i > xs) {
    371:         for (j = 0; j < dof; j++) f[(i - 1) * dof + j] -= ctx->flux[j] / hxf;
    372:       }
    373:       if (i < xs + xm) {
    374:         for (j = 0; j < dof; j++) f[i * dof + j] += ctx->flux[j] / hxf;
    375:       }
    376:     }
    377:   }
    378:   PetscCall(DMDAVecRestoreArray(da, Xloc, &x));
    379:   PetscCall(DMDAVecRestoreArray(da, F, &f));
    380:   PetscCall(DMDARestoreArray(da, PETSC_TRUE, &slope));
    381:   PetscCall(DMRestoreLocalVector(da, &Xloc));
    382:   PetscCallMPI(MPIU_Allreduce(&cfl_idt, &ctx->cfl_idt, 1, MPIU_SCALAR, MPIU_MAX, PetscObjectComm((PetscObject)da)));
    383:   if (0) {
    384:     /* We need to a way to inform the TS of a CFL constraint, this is a debugging fragment */
    385:     PetscReal dt, tnow;
    386:     PetscCall(TSGetTimeStep(ts, &dt));
    387:     PetscCall(TSGetTime(ts, &tnow));
    388:     if (dt > 0.5 / ctx->cfl_idt) PetscCall(PetscPrintf(ctx->comm, "Stability constraint exceeded at t=%g, dt %g > %g\n", (double)tnow, (double)dt, (double)(1 / (2 * ctx->cfl_idt))));
    389:   }
    390:   PetscFunctionReturn(PETSC_SUCCESS);
    391: }

    393: /* --------------------------------- Finite Volume Solver for slow components ----------------------------------- */
    394: PetscErrorCode FVRHSFunctionslow_3WaySplit(TS ts, PetscReal time, Vec X, Vec F, void *vctx)
    395: {
    396:   FVCtx       *ctx = (FVCtx *)vctx;
    397:   PetscInt     i, j, k, Mx, dof, xs, xm, islow = 0, sm = ctx->sm, ms = ctx->ms, lsbwidth = ctx->lsbwidth, rsbwidth = ctx->rsbwidth;
    398:   PetscReal    hxs, hxm, hxf, cfl_idt = 0;
    399:   PetscScalar *x, *f, *slope;
    400:   Vec          Xloc;
    401:   DM           da;

    403:   PetscFunctionBeginUser;
    404:   PetscCall(TSGetDM(ts, &da));
    405:   PetscCall(DMGetLocalVector(da, &Xloc));
    406:   PetscCall(DMDAGetInfo(da, 0, &Mx, 0, 0, 0, 0, 0, &dof, 0, 0, 0, 0, 0));
    407:   hxs = (ctx->xmax - ctx->xmin) / 8.0 / ctx->sm;
    408:   hxm = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->mf - ctx->sm);
    409:   hxf = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->fm - ctx->mf);
    410:   PetscCall(DMGlobalToLocalBegin(da, X, INSERT_VALUES, Xloc));
    411:   PetscCall(DMGlobalToLocalEnd(da, X, INSERT_VALUES, Xloc));
    412:   PetscCall(VecZeroEntries(F));
    413:   PetscCall(DMDAVecGetArray(da, Xloc, &x));
    414:   PetscCall(VecGetArray(F, &f));
    415:   PetscCall(DMDAGetArray(da, PETSC_TRUE, &slope));
    416:   PetscCall(DMDAGetCorners(da, &xs, 0, 0, &xm, 0, 0));

    418:   if (ctx->bctype == FVBC_OUTFLOW) {
    419:     for (i = xs - 2; i < 0; i++) {
    420:       for (j = 0; j < dof; j++) x[i * dof + j] = x[j];
    421:     }
    422:     for (i = Mx; i < xs + xm + 2; i++) {
    423:       for (j = 0; j < dof; j++) x[i * dof + j] = x[(xs + xm - 1) * dof + j];
    424:     }
    425:   }
    426:   for (i = xs - 1; i < xs + xm + 1; i++) {
    427:     struct _LimitInfo info;
    428:     PetscScalar      *cjmpL, *cjmpR;
    429:     if (i < sm - lsbwidth + 1 || i > ms + rsbwidth - 2) { /* slow components and the first and last fast components */
    430:       /* Determine the right eigenvectors R, where A = R \Lambda R^{-1} */
    431:       PetscCall((*ctx->physics2.characteristic2)(ctx->physics2.user, dof, &x[i * dof], ctx->R, ctx->Rinv, ctx->speeds));
    432:       /* Evaluate jumps across interfaces (i-1, i) and (i, i+1), put in characteristic basis */
    433:       PetscCall(PetscArrayzero(ctx->cjmpLR, 2 * dof));
    434:       cjmpL = &ctx->cjmpLR[0];
    435:       cjmpR = &ctx->cjmpLR[dof];
    436:       for (j = 0; j < dof; j++) {
    437:         PetscScalar jmpL, jmpR;
    438:         jmpL = x[(i + 0) * dof + j] - x[(i - 1) * dof + j];
    439:         jmpR = x[(i + 1) * dof + j] - x[(i + 0) * dof + j];
    440:         for (k = 0; k < dof; k++) {
    441:           cjmpL[k] += ctx->Rinv[k + j * dof] * jmpL;
    442:           cjmpR[k] += ctx->Rinv[k + j * dof] * jmpR;
    443:         }
    444:       }
    445:       /* Apply limiter to the left and right characteristic jumps */
    446:       info.m   = dof;
    447:       info.hxs = hxs;
    448:       info.hxm = hxm;
    449:       info.hxf = hxf;
    450:       (*ctx->limit3)(&info, cjmpL, cjmpR, ctx->sm, ctx->mf, ctx->fm, ctx->ms, i, ctx->cslope);
    451:       for (j = 0; j < dof; j++) {
    452:         PetscScalar tmp = 0;
    453:         for (k = 0; k < dof; k++) tmp += ctx->R[j + k * dof] * ctx->cslope[k];
    454:         slope[i * dof + j] = tmp;
    455:       }
    456:     }
    457:   }

    459:   for (i = xs; i < xs + xm + 1; i++) {
    460:     PetscReal    maxspeed;
    461:     PetscScalar *uL, *uR;
    462:     uL = &ctx->uLR[0];
    463:     uR = &ctx->uLR[dof];
    464:     if (i < sm - lsbwidth) { /* slow region */
    465:       for (j = 0; j < dof; j++) {
    466:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    467:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    468:       }
    469:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    470:       cfl_idt = PetscMax(cfl_idt, PetscAbsScalar(maxspeed / hxs)); /* Max allowable value of 1/Delta t */
    471:       if (i > xs) {
    472:         for (j = 0; j < dof; j++) f[(islow - 1) * dof + j] -= ctx->flux[j] / hxs;
    473:       }
    474:       if (i < xs + xm) {
    475:         for (j = 0; j < dof; j++) f[islow * dof + j] += ctx->flux[j] / hxs;
    476:         islow++;
    477:       }
    478:     }
    479:     if (i == sm - lsbwidth) { /* interface between slow and medium regions */
    480:       for (j = 0; j < dof; j++) {
    481:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    482:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    483:       }
    484:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    485:       if (i > xs) {
    486:         for (j = 0; j < dof; j++) f[(islow - 1) * dof + j] -= ctx->flux[j] / hxs;
    487:       }
    488:     }
    489:     if (i == ms + rsbwidth) { /* interface between medium and slow regions */
    490:       for (j = 0; j < dof; j++) {
    491:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    492:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    493:       }
    494:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    495:       if (i < xs + xm) {
    496:         for (j = 0; j < dof; j++) f[islow * dof + j] += ctx->flux[j] / hxs;
    497:         islow++;
    498:       }
    499:     }
    500:     if (i > ms + rsbwidth) { /* slow region */
    501:       for (j = 0; j < dof; j++) {
    502:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    503:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    504:       }
    505:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    506:       cfl_idt = PetscMax(cfl_idt, PetscAbsScalar(maxspeed / hxs)); /* Max allowable value of 1/Delta t */
    507:       if (i > xs) {
    508:         for (j = 0; j < dof; j++) f[(islow - 1) * dof + j] -= ctx->flux[j] / hxs;
    509:       }
    510:       if (i < xs + xm) {
    511:         for (j = 0; j < dof; j++) f[islow * dof + j] += ctx->flux[j] / hxs;
    512:         islow++;
    513:       }
    514:     }
    515:   }
    516:   PetscCall(DMDAVecRestoreArray(da, Xloc, &x));
    517:   PetscCall(VecRestoreArray(F, &f));
    518:   PetscCall(DMDARestoreArray(da, PETSC_TRUE, &slope));
    519:   PetscCall(DMRestoreLocalVector(da, &Xloc));
    520:   PetscCallMPI(MPIU_Allreduce(&cfl_idt, &ctx->cfl_idt, 1, MPIU_SCALAR, MPIU_MAX, PetscObjectComm((PetscObject)da)));
    521:   PetscFunctionReturn(PETSC_SUCCESS);
    522: }

    524: PetscErrorCode FVRHSFunctionslowbuffer_3WaySplit(TS ts, PetscReal time, Vec X, Vec F, void *vctx)
    525: {
    526:   FVCtx       *ctx = (FVCtx *)vctx;
    527:   PetscInt     i, j, k, Mx, dof, xs, xm, islowbuffer = 0, sm = ctx->sm, ms = ctx->ms, lsbwidth = ctx->lsbwidth, rsbwidth = ctx->rsbwidth;
    528:   PetscReal    hxs, hxm, hxf;
    529:   PetscScalar *x, *f, *slope;
    530:   Vec          Xloc;
    531:   DM           da;

    533:   PetscFunctionBeginUser;
    534:   PetscCall(TSGetDM(ts, &da));
    535:   PetscCall(DMGetLocalVector(da, &Xloc));
    536:   PetscCall(DMDAGetInfo(da, 0, &Mx, 0, 0, 0, 0, 0, &dof, 0, 0, 0, 0, 0));
    537:   hxs = (ctx->xmax - ctx->xmin) / 8.0 / ctx->sm;
    538:   hxm = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->mf - ctx->sm);
    539:   hxf = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->fm - ctx->mf);
    540:   PetscCall(DMGlobalToLocalBegin(da, X, INSERT_VALUES, Xloc));
    541:   PetscCall(DMGlobalToLocalEnd(da, X, INSERT_VALUES, Xloc));
    542:   PetscCall(VecZeroEntries(F));
    543:   PetscCall(DMDAVecGetArray(da, Xloc, &x));
    544:   PetscCall(VecGetArray(F, &f));
    545:   PetscCall(DMDAGetArray(da, PETSC_TRUE, &slope));
    546:   PetscCall(DMDAGetCorners(da, &xs, 0, 0, &xm, 0, 0));

    548:   if (ctx->bctype == FVBC_OUTFLOW) {
    549:     for (i = xs - 2; i < 0; i++) {
    550:       for (j = 0; j < dof; j++) x[i * dof + j] = x[j];
    551:     }
    552:     for (i = Mx; i < xs + xm + 2; i++) {
    553:       for (j = 0; j < dof; j++) x[i * dof + j] = x[(xs + xm - 1) * dof + j];
    554:     }
    555:   }
    556:   for (i = xs - 1; i < xs + xm + 1; i++) {
    557:     struct _LimitInfo info;
    558:     PetscScalar      *cjmpL, *cjmpR;
    559:     if ((i > sm - lsbwidth - 2 && i < sm + 1) || (i > ms - 2 && i < ms + rsbwidth + 1)) {
    560:       /* Determine the right eigenvectors R, where A = R \Lambda R^{-1} */
    561:       PetscCall((*ctx->physics2.characteristic2)(ctx->physics2.user, dof, &x[i * dof], ctx->R, ctx->Rinv, ctx->speeds));
    562:       /* Evaluate jumps across interfaces (i-1, i) and (i, i+1), put in characteristic basis */
    563:       PetscCall(PetscArrayzero(ctx->cjmpLR, 2 * dof));
    564:       cjmpL = &ctx->cjmpLR[0];
    565:       cjmpR = &ctx->cjmpLR[dof];
    566:       for (j = 0; j < dof; j++) {
    567:         PetscScalar jmpL, jmpR;
    568:         jmpL = x[(i + 0) * dof + j] - x[(i - 1) * dof + j];
    569:         jmpR = x[(i + 1) * dof + j] - x[(i + 0) * dof + j];
    570:         for (k = 0; k < dof; k++) {
    571:           cjmpL[k] += ctx->Rinv[k + j * dof] * jmpL;
    572:           cjmpR[k] += ctx->Rinv[k + j * dof] * jmpR;
    573:         }
    574:       }
    575:       /* Apply limiter to the left and right characteristic jumps */
    576:       info.m   = dof;
    577:       info.hxs = hxs;
    578:       info.hxm = hxm;
    579:       info.hxf = hxf;
    580:       (*ctx->limit3)(&info, cjmpL, cjmpR, ctx->sm, ctx->mf, ctx->fm, ctx->ms, i, ctx->cslope);
    581:       for (j = 0; j < dof; j++) {
    582:         PetscScalar tmp = 0;
    583:         for (k = 0; k < dof; k++) tmp += ctx->R[j + k * dof] * ctx->cslope[k];
    584:         slope[i * dof + j] = tmp;
    585:       }
    586:     }
    587:   }

    589:   for (i = xs; i < xs + xm + 1; i++) {
    590:     PetscReal    maxspeed;
    591:     PetscScalar *uL, *uR;
    592:     uL = &ctx->uLR[0];
    593:     uR = &ctx->uLR[dof];
    594:     if (i == sm - lsbwidth) {
    595:       for (j = 0; j < dof; j++) {
    596:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    597:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    598:       }
    599:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    600:       if (i < xs + xm) {
    601:         for (j = 0; j < dof; j++) f[islowbuffer * dof + j] += ctx->flux[j] / hxs;
    602:         islowbuffer++;
    603:       }
    604:     }
    605:     if (i > sm - lsbwidth && i < sm) {
    606:       for (j = 0; j < dof; j++) {
    607:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    608:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    609:       }
    610:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    611:       if (i > xs) {
    612:         for (j = 0; j < dof; j++) f[(islowbuffer - 1) * dof + j] -= ctx->flux[j] / hxs;
    613:       }
    614:       if (i < xs + xm) {
    615:         for (j = 0; j < dof; j++) f[islowbuffer * dof + j] += ctx->flux[j] / hxs;
    616:         islowbuffer++;
    617:       }
    618:     }
    619:     if (i == sm) { /* interface between the slow region and the medium region */
    620:       for (j = 0; j < dof; j++) {
    621:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    622:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    623:       }
    624:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    625:       if (i > xs) {
    626:         for (j = 0; j < dof; j++) f[(islowbuffer - 1) * dof + j] -= ctx->flux[j] / hxs;
    627:       }
    628:     }
    629:     if (i == ms) { /* interface between the medium region and the slow region */
    630:       for (j = 0; j < dof; j++) {
    631:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    632:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    633:       }
    634:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    635:       if (i < xs + xm) {
    636:         for (j = 0; j < dof; j++) f[islowbuffer * dof + j] += ctx->flux[j] / hxs;
    637:         islowbuffer++;
    638:       }
    639:     }
    640:     if (i > ms && i < ms + rsbwidth) {
    641:       for (j = 0; j < dof; j++) {
    642:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    643:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    644:       }
    645:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    646:       if (i > xs) {
    647:         for (j = 0; j < dof; j++) f[(islowbuffer - 1) * dof + j] -= ctx->flux[j] / hxs;
    648:       }
    649:       if (i < xs + xm) {
    650:         for (j = 0; j < dof; j++) f[islowbuffer * dof + j] += ctx->flux[j] / hxs;
    651:         islowbuffer++;
    652:       }
    653:     }
    654:     if (i == ms + rsbwidth) {
    655:       for (j = 0; j < dof; j++) {
    656:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    657:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    658:       }
    659:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    660:       if (i > xs) {
    661:         for (j = 0; j < dof; j++) f[(islowbuffer - 1) * dof + j] -= ctx->flux[j] / hxs;
    662:       }
    663:     }
    664:   }
    665:   PetscCall(DMDAVecRestoreArray(da, Xloc, &x));
    666:   PetscCall(VecRestoreArray(F, &f));
    667:   PetscCall(DMDARestoreArray(da, PETSC_TRUE, &slope));
    668:   PetscCall(DMRestoreLocalVector(da, &Xloc));
    669:   PetscFunctionReturn(PETSC_SUCCESS);
    670: }

    672: /* --------------------------------- Finite Volume Solver for medium components ----------------------------------- */
    673: PetscErrorCode FVRHSFunctionmedium_3WaySplit(TS ts, PetscReal time, Vec X, Vec F, void *vctx)
    674: {
    675:   FVCtx       *ctx = (FVCtx *)vctx;
    676:   PetscInt     i, j, k, Mx, dof, xs, xm, imedium = 0, sm = ctx->sm, mf = ctx->mf, fm = ctx->fm, ms = ctx->ms, lmbwidth = ctx->lmbwidth, rmbwidth = ctx->rmbwidth;
    677:   PetscReal    hxs, hxm, hxf;
    678:   PetscScalar *x, *f, *slope;
    679:   Vec          Xloc;
    680:   DM           da;

    682:   PetscFunctionBeginUser;
    683:   PetscCall(TSGetDM(ts, &da));
    684:   PetscCall(DMGetLocalVector(da, &Xloc));
    685:   PetscCall(DMDAGetInfo(da, 0, &Mx, 0, 0, 0, 0, 0, &dof, 0, 0, 0, 0, 0));
    686:   hxs = (ctx->xmax - ctx->xmin) / 8.0 / ctx->sm;
    687:   hxm = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->mf - ctx->sm);
    688:   hxf = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->fm - ctx->mf);
    689:   PetscCall(DMGlobalToLocalBegin(da, X, INSERT_VALUES, Xloc));
    690:   PetscCall(DMGlobalToLocalEnd(da, X, INSERT_VALUES, Xloc));
    691:   PetscCall(VecZeroEntries(F));
    692:   PetscCall(DMDAVecGetArray(da, Xloc, &x));
    693:   PetscCall(VecGetArray(F, &f));
    694:   PetscCall(DMDAGetArray(da, PETSC_TRUE, &slope));
    695:   PetscCall(DMDAGetCorners(da, &xs, 0, 0, &xm, 0, 0));

    697:   if (ctx->bctype == FVBC_OUTFLOW) {
    698:     for (i = xs - 2; i < 0; i++) {
    699:       for (j = 0; j < dof; j++) x[i * dof + j] = x[j];
    700:     }
    701:     for (i = Mx; i < xs + xm + 2; i++) {
    702:       for (j = 0; j < dof; j++) x[i * dof + j] = x[(xs + xm - 1) * dof + j];
    703:     }
    704:   }
    705:   for (i = xs - 1; i < xs + xm + 1; i++) {
    706:     struct _LimitInfo info;
    707:     PetscScalar      *cjmpL, *cjmpR;
    708:     if ((i > sm - 2 && i < mf - lmbwidth + 1) || (i > fm + rmbwidth - 2 && i < ms + 1)) { /* slow components and the first and last fast components */
    709:       /* Determine the right eigenvectors R, where A = R \Lambda R^{-1} */
    710:       PetscCall((*ctx->physics2.characteristic2)(ctx->physics2.user, dof, &x[i * dof], ctx->R, ctx->Rinv, ctx->speeds));
    711:       /* Evaluate jumps across interfaces (i-1, i) and (i, i+1), put in characteristic basis */
    712:       PetscCall(PetscArrayzero(ctx->cjmpLR, 2 * dof));
    713:       cjmpL = &ctx->cjmpLR[0];
    714:       cjmpR = &ctx->cjmpLR[dof];
    715:       for (j = 0; j < dof; j++) {
    716:         PetscScalar jmpL, jmpR;
    717:         jmpL = x[(i + 0) * dof + j] - x[(i - 1) * dof + j];
    718:         jmpR = x[(i + 1) * dof + j] - x[(i + 0) * dof + j];
    719:         for (k = 0; k < dof; k++) {
    720:           cjmpL[k] += ctx->Rinv[k + j * dof] * jmpL;
    721:           cjmpR[k] += ctx->Rinv[k + j * dof] * jmpR;
    722:         }
    723:       }
    724:       /* Apply limiter to the left and right characteristic jumps */
    725:       info.m   = dof;
    726:       info.hxs = hxs;
    727:       info.hxm = hxm;
    728:       info.hxf = hxf;
    729:       (*ctx->limit3)(&info, cjmpL, cjmpR, ctx->sm, ctx->mf, ctx->fm, ctx->ms, i, ctx->cslope);
    730:       for (j = 0; j < dof; j++) {
    731:         PetscScalar tmp = 0;
    732:         for (k = 0; k < dof; k++) tmp += ctx->R[j + k * dof] * ctx->cslope[k];
    733:         slope[i * dof + j] = tmp;
    734:       }
    735:     }
    736:   }

    738:   for (i = xs; i < xs + xm + 1; i++) {
    739:     PetscReal    maxspeed;
    740:     PetscScalar *uL, *uR;
    741:     uL = &ctx->uLR[0];
    742:     uR = &ctx->uLR[dof];
    743:     if (i == sm) { /* interface between slow and medium regions */
    744:       for (j = 0; j < dof; j++) {
    745:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxs / 2;
    746:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    747:       }
    748:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    749:       if (i < xs + xm) {
    750:         for (j = 0; j < dof; j++) f[imedium * dof + j] += ctx->flux[j] / hxm;
    751:         imedium++;
    752:       }
    753:     }
    754:     if (i > sm && i < mf - lmbwidth) { /* medium region */
    755:       for (j = 0; j < dof; j++) {
    756:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    757:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    758:       }
    759:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    760:       if (i > xs) {
    761:         for (j = 0; j < dof; j++) f[(imedium - 1) * dof + j] -= ctx->flux[j] / hxm;
    762:       }
    763:       if (i < xs + xm) {
    764:         for (j = 0; j < dof; j++) f[imedium * dof + j] += ctx->flux[j] / hxm;
    765:         imedium++;
    766:       }
    767:     }
    768:     if (i == mf - lmbwidth) { /* interface between medium and fast regions */
    769:       for (j = 0; j < dof; j++) {
    770:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    771:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    772:       }
    773:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    774:       if (i > xs) {
    775:         for (j = 0; j < dof; j++) f[(imedium - 1) * dof + j] -= ctx->flux[j] / hxm;
    776:       }
    777:     }
    778:     if (i == fm + rmbwidth) { /* interface between fast and medium regions */
    779:       for (j = 0; j < dof; j++) {
    780:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    781:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    782:       }
    783:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    784:       if (i < xs + xm) {
    785:         for (j = 0; j < dof; j++) f[imedium * dof + j] += ctx->flux[j] / hxm;
    786:         imedium++;
    787:       }
    788:     }
    789:     if (i > fm + rmbwidth && i < ms) { /* medium region */
    790:       for (j = 0; j < dof; j++) {
    791:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    792:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    793:       }
    794:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    795:       if (i > xs) {
    796:         for (j = 0; j < dof; j++) f[(imedium - 1) * dof + j] -= ctx->flux[j] / hxm;
    797:       }
    798:       if (i < xs + xm) {
    799:         for (j = 0; j < dof; j++) f[imedium * dof + j] += ctx->flux[j] / hxm;
    800:         imedium++;
    801:       }
    802:     }
    803:     if (i == ms) { /* interface between medium and slow regions */
    804:       for (j = 0; j < dof; j++) {
    805:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    806:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxs / 2;
    807:       }
    808:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    809:       if (i > xs) {
    810:         for (j = 0; j < dof; j++) f[(imedium - 1) * dof + j] -= ctx->flux[j] / hxm;
    811:       }
    812:     }
    813:   }
    814:   PetscCall(DMDAVecRestoreArray(da, Xloc, &x));
    815:   PetscCall(VecRestoreArray(F, &f));
    816:   PetscCall(DMDARestoreArray(da, PETSC_TRUE, &slope));
    817:   PetscCall(DMRestoreLocalVector(da, &Xloc));
    818:   PetscFunctionReturn(PETSC_SUCCESS);
    819: }

    821: PetscErrorCode FVRHSFunctionmediumbuffer_3WaySplit(TS ts, PetscReal time, Vec X, Vec F, void *vctx)
    822: {
    823:   FVCtx       *ctx = (FVCtx *)vctx;
    824:   PetscInt     i, j, k, Mx, dof, xs, xm, imediumbuffer = 0, mf = ctx->mf, fm = ctx->fm, lmbwidth = ctx->lmbwidth, rmbwidth = ctx->rmbwidth;
    825:   PetscReal    hxs, hxm, hxf;
    826:   PetscScalar *x, *f, *slope;
    827:   Vec          Xloc;
    828:   DM           da;

    830:   PetscFunctionBeginUser;
    831:   PetscCall(TSGetDM(ts, &da));
    832:   PetscCall(DMGetLocalVector(da, &Xloc));
    833:   PetscCall(DMDAGetInfo(da, 0, &Mx, 0, 0, 0, 0, 0, &dof, 0, 0, 0, 0, 0));
    834:   hxs = (ctx->xmax - ctx->xmin) / 8.0 / ctx->sm;
    835:   hxm = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->mf - ctx->sm);
    836:   hxf = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->fm - ctx->mf);
    837:   PetscCall(DMGlobalToLocalBegin(da, X, INSERT_VALUES, Xloc));
    838:   PetscCall(DMGlobalToLocalEnd(da, X, INSERT_VALUES, Xloc));
    839:   PetscCall(VecZeroEntries(F));
    840:   PetscCall(DMDAVecGetArray(da, Xloc, &x));
    841:   PetscCall(VecGetArray(F, &f));
    842:   PetscCall(DMDAGetArray(da, PETSC_TRUE, &slope));
    843:   PetscCall(DMDAGetCorners(da, &xs, 0, 0, &xm, 0, 0));

    845:   if (ctx->bctype == FVBC_OUTFLOW) {
    846:     for (i = xs - 2; i < 0; i++) {
    847:       for (j = 0; j < dof; j++) x[i * dof + j] = x[j];
    848:     }
    849:     for (i = Mx; i < xs + xm + 2; i++) {
    850:       for (j = 0; j < dof; j++) x[i * dof + j] = x[(xs + xm - 1) * dof + j];
    851:     }
    852:   }
    853:   for (i = xs - 1; i < xs + xm + 1; i++) {
    854:     struct _LimitInfo info;
    855:     PetscScalar      *cjmpL, *cjmpR;
    856:     if ((i > mf - lmbwidth - 2 && i < mf + 1) || (i > fm - 2 && i < fm + rmbwidth + 1)) {
    857:       /* Determine the right eigenvectors R, where A = R \Lambda R^{-1} */
    858:       PetscCall((*ctx->physics2.characteristic2)(ctx->physics2.user, dof, &x[i * dof], ctx->R, ctx->Rinv, ctx->speeds));
    859:       /* Evaluate jumps across interfaces (i-1, i) and (i, i+1), put in characteristic basis */
    860:       PetscCall(PetscArrayzero(ctx->cjmpLR, 2 * dof));
    861:       cjmpL = &ctx->cjmpLR[0];
    862:       cjmpR = &ctx->cjmpLR[dof];
    863:       for (j = 0; j < dof; j++) {
    864:         PetscScalar jmpL, jmpR;
    865:         jmpL = x[(i + 0) * dof + j] - x[(i - 1) * dof + j];
    866:         jmpR = x[(i + 1) * dof + j] - x[(i + 0) * dof + j];
    867:         for (k = 0; k < dof; k++) {
    868:           cjmpL[k] += ctx->Rinv[k + j * dof] * jmpL;
    869:           cjmpR[k] += ctx->Rinv[k + j * dof] * jmpR;
    870:         }
    871:       }
    872:       /* Apply limiter to the left and right characteristic jumps */
    873:       info.m   = dof;
    874:       info.hxs = hxs;
    875:       info.hxm = hxm;
    876:       info.hxf = hxf;
    877:       (*ctx->limit3)(&info, cjmpL, cjmpR, ctx->sm, ctx->mf, ctx->fm, ctx->ms, i, ctx->cslope);
    878:       for (j = 0; j < dof; j++) {
    879:         PetscScalar tmp = 0;
    880:         for (k = 0; k < dof; k++) tmp += ctx->R[j + k * dof] * ctx->cslope[k];
    881:         slope[i * dof + j] = tmp;
    882:       }
    883:     }
    884:   }

    886:   for (i = xs; i < xs + xm + 1; i++) {
    887:     PetscReal    maxspeed;
    888:     PetscScalar *uL, *uR;
    889:     uL = &ctx->uLR[0];
    890:     uR = &ctx->uLR[dof];
    891:     if (i == mf - lmbwidth) {
    892:       for (j = 0; j < dof; j++) {
    893:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    894:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    895:       }
    896:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    897:       if (i < xs + xm) {
    898:         for (j = 0; j < dof; j++) f[imediumbuffer * dof + j] += ctx->flux[j] / hxm;
    899:         imediumbuffer++;
    900:       }
    901:     }
    902:     if (i > mf - lmbwidth && i < mf) {
    903:       for (j = 0; j < dof; j++) {
    904:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    905:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    906:       }
    907:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    908:       if (i > xs) {
    909:         for (j = 0; j < dof; j++) f[(imediumbuffer - 1) * dof + j] -= ctx->flux[j] / hxm;
    910:       }
    911:       if (i < xs + xm) {
    912:         for (j = 0; j < dof; j++) f[imediumbuffer * dof + j] += ctx->flux[j] / hxm;
    913:         imediumbuffer++;
    914:       }
    915:     }
    916:     if (i == mf) { /* interface between the medium region and the fast region */
    917:       for (j = 0; j < dof; j++) {
    918:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    919:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxf / 2;
    920:       }
    921:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    922:       if (i > xs) {
    923:         for (j = 0; j < dof; j++) f[(imediumbuffer - 1) * dof + j] -= ctx->flux[j] / hxm;
    924:       }
    925:     }
    926:     if (i == fm) { /* interface between the fast region and the medium region */
    927:       for (j = 0; j < dof; j++) {
    928:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxf / 2;
    929:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    930:       }
    931:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    932:       if (i < xs + xm) {
    933:         for (j = 0; j < dof; j++) f[imediumbuffer * dof + j] += ctx->flux[j] / hxm;
    934:         imediumbuffer++;
    935:       }
    936:     }
    937:     if (i > fm && i < fm + rmbwidth) {
    938:       for (j = 0; j < dof; j++) {
    939:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    940:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    941:       }
    942:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    943:       if (i > xs) {
    944:         for (j = 0; j < dof; j++) f[(imediumbuffer - 1) * dof + j] -= ctx->flux[j] / hxm;
    945:       }
    946:       if (i < xs + xm) {
    947:         for (j = 0; j < dof; j++) f[imediumbuffer * dof + j] += ctx->flux[j] / hxm;
    948:         imediumbuffer++;
    949:       }
    950:     }
    951:     if (i == fm + rmbwidth) {
    952:       for (j = 0; j < dof; j++) {
    953:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    954:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    955:       }
    956:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    957:       if (i > xs) {
    958:         for (j = 0; j < dof; j++) f[(imediumbuffer - 1) * dof + j] -= ctx->flux[j] / hxm;
    959:       }
    960:     }
    961:   }
    962:   PetscCall(DMDAVecRestoreArray(da, Xloc, &x));
    963:   PetscCall(VecRestoreArray(F, &f));
    964:   PetscCall(DMDARestoreArray(da, PETSC_TRUE, &slope));
    965:   PetscCall(DMRestoreLocalVector(da, &Xloc));
    966:   PetscFunctionReturn(PETSC_SUCCESS);
    967: }

    969: /* --------------------------------- Finite Volume Solver for fast  parts ----------------------------------- */
    970: PetscErrorCode FVRHSFunctionfast_3WaySplit(TS ts, PetscReal time, Vec X, Vec F, void *vctx)
    971: {
    972:   FVCtx       *ctx = (FVCtx *)vctx;
    973:   PetscInt     i, j, k, Mx, dof, xs, xm, ifast = 0, mf = ctx->mf, fm = ctx->fm;
    974:   PetscReal    hxs, hxm, hxf;
    975:   PetscScalar *x, *f, *slope;
    976:   Vec          Xloc;
    977:   DM           da;

    979:   PetscFunctionBeginUser;
    980:   PetscCall(TSGetDM(ts, &da));
    981:   PetscCall(DMGetLocalVector(da, &Xloc));
    982:   PetscCall(DMDAGetInfo(da, 0, &Mx, 0, 0, 0, 0, 0, &dof, 0, 0, 0, 0, 0));
    983:   hxs = (ctx->xmax - ctx->xmin) / 8.0 / ctx->sm;
    984:   hxm = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->mf - ctx->sm);
    985:   hxf = (ctx->xmax - ctx->xmin) / 4.0 / (ctx->fm - ctx->mf);
    986:   PetscCall(DMGlobalToLocalBegin(da, X, INSERT_VALUES, Xloc));
    987:   PetscCall(DMGlobalToLocalEnd(da, X, INSERT_VALUES, Xloc));
    988:   PetscCall(VecZeroEntries(F));
    989:   PetscCall(DMDAVecGetArray(da, Xloc, &x));
    990:   PetscCall(VecGetArray(F, &f));
    991:   PetscCall(DMDAGetArray(da, PETSC_TRUE, &slope));
    992:   PetscCall(DMDAGetCorners(da, &xs, 0, 0, &xm, 0, 0));

    994:   if (ctx->bctype == FVBC_OUTFLOW) {
    995:     for (i = xs - 2; i < 0; i++) {
    996:       for (j = 0; j < dof; j++) x[i * dof + j] = x[j];
    997:     }
    998:     for (i = Mx; i < xs + xm + 2; i++) {
    999:       for (j = 0; j < dof; j++) x[i * dof + j] = x[(xs + xm - 1) * dof + j];
    1000:     }
    1001:   }
    1002:   for (i = xs - 1; i < xs + xm + 1; i++) { /* fast components and the last slow components before fast components and the first slow component after fast components */
    1003:     struct _LimitInfo info;
    1004:     PetscScalar      *cjmpL, *cjmpR;
    1005:     if (i > mf - 2 && i < fm + 1) {
    1006:       PetscCall((*ctx->physics2.characteristic2)(ctx->physics2.user, dof, &x[i * dof], ctx->R, ctx->Rinv, ctx->speeds));
    1007:       PetscCall(PetscArrayzero(ctx->cjmpLR, 2 * dof));
    1008:       cjmpL = &ctx->cjmpLR[0];
    1009:       cjmpR = &ctx->cjmpLR[dof];
    1010:       for (j = 0; j < dof; j++) {
    1011:         PetscScalar jmpL, jmpR;
    1012:         jmpL = x[(i + 0) * dof + j] - x[(i - 1) * dof + j];
    1013:         jmpR = x[(i + 1) * dof + j] - x[(i + 0) * dof + j];
    1014:         for (k = 0; k < dof; k++) {
    1015:           cjmpL[k] += ctx->Rinv[k + j * dof] * jmpL;
    1016:           cjmpR[k] += ctx->Rinv[k + j * dof] * jmpR;
    1017:         }
    1018:       }
    1019:       /* Apply limiter to the left and right characteristic jumps */
    1020:       info.m   = dof;
    1021:       info.hxs = hxs;
    1022:       info.hxm = hxm;
    1023:       info.hxf = hxf;
    1024:       (*ctx->limit3)(&info, cjmpL, cjmpR, ctx->sm, ctx->mf, ctx->fm, ctx->ms, i, ctx->cslope);
    1025:       for (j = 0; j < dof; j++) {
    1026:         PetscScalar tmp = 0;
    1027:         for (k = 0; k < dof; k++) tmp += ctx->R[j + k * dof] * ctx->cslope[k];
    1028:         slope[i * dof + j] = tmp;
    1029:       }
    1030:     }
    1031:   }

    1033:   for (i = xs; i < xs + xm + 1; i++) {
    1034:     PetscReal    maxspeed;
    1035:     PetscScalar *uL, *uR;
    1036:     uL = &ctx->uLR[0];
    1037:     uR = &ctx->uLR[dof];
    1038:     if (i == mf) { /* interface between medium and fast regions */
    1039:       for (j = 0; j < dof; j++) {
    1040:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxm / 2;
    1041:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxf / 2;
    1042:       }
    1043:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    1044:       if (i < xs + xm) {
    1045:         for (j = 0; j < dof; j++) f[ifast * dof + j] += ctx->flux[j] / hxf;
    1046:         ifast++;
    1047:       }
    1048:     }
    1049:     if (i > mf && i < fm) { /* fast region */
    1050:       for (j = 0; j < dof; j++) {
    1051:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxf / 2;
    1052:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxf / 2;
    1053:       }
    1054:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    1055:       if (i > xs) {
    1056:         for (j = 0; j < dof; j++) f[(ifast - 1) * dof + j] -= ctx->flux[j] / hxf;
    1057:       }
    1058:       if (i < xs + xm) {
    1059:         for (j = 0; j < dof; j++) f[ifast * dof + j] += ctx->flux[j] / hxf;
    1060:         ifast++;
    1061:       }
    1062:     }
    1063:     if (i == fm) { /* interface between fast and medium regions */
    1064:       for (j = 0; j < dof; j++) {
    1065:         uL[j] = x[(i - 1) * dof + j] + slope[(i - 1) * dof + j] * hxf / 2;
    1066:         uR[j] = x[(i - 0) * dof + j] - slope[(i - 0) * dof + j] * hxm / 2;
    1067:       }
    1068:       PetscCall((*ctx->physics2.riemann2)(ctx->physics2.user, dof, uL, uR, ctx->flux, &maxspeed));
    1069:       if (i > xs) {
    1070:         for (j = 0; j < dof; j++) f[(ifast - 1) * dof + j] -= ctx->flux[j] / hxf;
    1071:       }
    1072:     }
    1073:   }
    1074:   PetscCall(DMDAVecRestoreArray(da, Xloc, &x));
    1075:   PetscCall(VecRestoreArray(F, &f));
    1076:   PetscCall(DMDARestoreArray(da, PETSC_TRUE, &slope));
    1077:   PetscCall(DMRestoreLocalVector(da, &Xloc));
    1078:   PetscFunctionReturn(PETSC_SUCCESS);
    1079: }

    1081: int main(int argc, char *argv[])
    1082: {
    1083:   char              lname[256] = "mc", physname[256] = "advect", final_fname[256] = "solution.m";
    1084:   PetscFunctionList limiters = 0, physics = 0;
    1085:   MPI_Comm          comm;
    1086:   TS                ts;
    1087:   DM                da;
    1088:   Vec               X, X0, R;
    1089:   FVCtx             ctx;
    1090:   PetscInt          i, k, dof, xs, xm, Mx, draw = 0, count_slow, count_medium, count_fast, islow = 0, imedium = 0, ifast = 0, *index_slow, *index_medium, *index_fast, islowbuffer = 0, *index_slowbuffer, imediumbuffer = 0, *index_mediumbuffer;
    1091:   PetscBool         view_final = PETSC_FALSE;
    1092:   PetscReal         ptime;

    1094:   PetscFunctionBeginUser;
    1095:   PetscCall(PetscInitialize(&argc, &argv, 0, help));
    1096:   comm = PETSC_COMM_WORLD;
    1097:   PetscCall(PetscMemzero(&ctx, sizeof(ctx)));

    1099:   /* Register limiters to be available on the command line */
    1100:   PetscCall(PetscFunctionListAdd(&limiters, "upwind", Limit3_Upwind));
    1101:   PetscCall(PetscFunctionListAdd(&limiters, "lax-wendroff", Limit3_LaxWendroff));
    1102:   PetscCall(PetscFunctionListAdd(&limiters, "beam-warming", Limit3_BeamWarming));
    1103:   PetscCall(PetscFunctionListAdd(&limiters, "fromm", Limit3_Fromm));
    1104:   PetscCall(PetscFunctionListAdd(&limiters, "minmod", Limit3_Minmod));
    1105:   PetscCall(PetscFunctionListAdd(&limiters, "superbee", Limit3_Superbee));
    1106:   PetscCall(PetscFunctionListAdd(&limiters, "mc", Limit3_MC));
    1107:   PetscCall(PetscFunctionListAdd(&limiters, "koren3", Limit3_Koren3));

    1109:   /* Register physical models to be available on the command line */
    1110:   PetscCall(PetscFunctionListAdd(&physics, "advect", PhysicsCreate_Advect));

    1112:   ctx.comm   = comm;
    1113:   ctx.cfl    = 0.9;
    1114:   ctx.bctype = FVBC_PERIODIC;
    1115:   ctx.xmin   = -1.0;
    1116:   ctx.xmax   = 1.0;
    1117:   PetscOptionsBegin(comm, NULL, "Finite Volume solver options", "");
    1118:   PetscCall(PetscOptionsReal("-xmin", "X min", "", ctx.xmin, &ctx.xmin, NULL));
    1119:   PetscCall(PetscOptionsReal("-xmax", "X max", "", ctx.xmax, &ctx.xmax, NULL));
    1120:   PetscCall(PetscOptionsFList("-limit", "Name of flux imiter to use", "", limiters, lname, lname, sizeof(lname), NULL));
    1121:   PetscCall(PetscOptionsInt("-draw", "Draw solution vector, bitwise OR of (1=initial,2=final,4=final error)", "", draw, &draw, NULL));
    1122:   PetscCall(PetscOptionsString("-view_final", "Write final solution in ASCII MATLAB format to given file name", "", final_fname, final_fname, sizeof(final_fname), &view_final));
    1123:   PetscCall(PetscOptionsInt("-initial", "Initial condition (depends on the physics)", "", ctx.initial, &ctx.initial, NULL));
    1124:   PetscCall(PetscOptionsBool("-exact", "Compare errors with exact solution", "", ctx.exact, &ctx.exact, NULL));
    1125:   PetscCall(PetscOptionsBool("-simulation", "Compare errors with reference solution", "", ctx.simulation, &ctx.simulation, NULL));
    1126:   PetscCall(PetscOptionsReal("-cfl", "CFL number to time step at", "", ctx.cfl, &ctx.cfl, NULL));
    1127:   PetscCall(PetscOptionsEnum("-bc_type", "Boundary condition", "", FVBCTypes, (PetscEnum)ctx.bctype, (PetscEnum *)&ctx.bctype, NULL));
    1128:   PetscCall(PetscOptionsInt("-hratio", "Spacing ratio", "", ctx.hratio, &ctx.hratio, NULL));
    1129:   PetscOptionsEnd();

    1131:   /* Choose the limiter from the list of registered limiters */
    1132:   PetscCall(PetscFunctionListFind(limiters, lname, &ctx.limit3));
    1133:   PetscCheck(ctx.limit3, PETSC_COMM_SELF, PETSC_ERR_ARG_UNKNOWN_TYPE, "Limiter '%s' not found", lname);

    1135:   /* Choose the physics from the list of registered models */
    1136:   {
    1137:     PetscErrorCode (*r)(FVCtx *);
    1138:     PetscCall(PetscFunctionListFind(physics, physname, &r));
    1139:     PetscCheck(r, PETSC_COMM_SELF, PETSC_ERR_ARG_UNKNOWN_TYPE, "Physics '%s' not found", physname);
    1140:     /* Create the physics, will set the number of fields and their names */
    1141:     PetscCall((*r)(&ctx));
    1142:   }

    1144:   /* Create a DMDA to manage the parallel grid */
    1145:   PetscCall(DMDACreate1d(comm, DM_BOUNDARY_PERIODIC, 50, ctx.physics2.dof, 2, NULL, &da));
    1146:   PetscCall(DMSetFromOptions(da));
    1147:   PetscCall(DMSetUp(da));
    1148:   /* Inform the DMDA of the field names provided by the physics. */
    1149:   /* The names will be shown in the title bars when run with -ts_monitor_draw_solution */
    1150:   for (i = 0; i < ctx.physics2.dof; i++) PetscCall(DMDASetFieldName(da, i, ctx.physics2.fieldname[i]));
    1151:   PetscCall(DMDAGetInfo(da, 0, &Mx, 0, 0, 0, 0, 0, &dof, 0, 0, 0, 0, 0));
    1152:   PetscCall(DMDAGetCorners(da, &xs, 0, 0, &xm, 0, 0));

    1154:   /* Set coordinates of cell centers */
    1155:   PetscCall(DMDASetUniformCoordinates(da, ctx.xmin + 0.5 * (ctx.xmax - ctx.xmin) / Mx, ctx.xmax + 0.5 * (ctx.xmax - ctx.xmin) / Mx, 0, 0, 0, 0));

    1157:   /* Allocate work space for the Finite Volume solver (so it doesn't have to be reallocated on each function evaluation) */
    1158:   PetscCall(PetscMalloc4(dof * dof, &ctx.R, dof * dof, &ctx.Rinv, 2 * dof, &ctx.cjmpLR, 1 * dof, &ctx.cslope));
    1159:   PetscCall(PetscMalloc3(2 * dof, &ctx.uLR, dof, &ctx.flux, dof, &ctx.speeds));

    1161:   /* Create a vector to store the solution and to save the initial state */
    1162:   PetscCall(DMCreateGlobalVector(da, &X));
    1163:   PetscCall(VecDuplicate(X, &X0));
    1164:   PetscCall(VecDuplicate(X, &R));

    1166:   /* create index for slow parts and fast parts,
    1167:      count_slow + count_fast = Mx, counts_slow*hs = 0.5, counts_fast*hf = 0.5 */
    1168:   count_slow   = Mx / (1 + ctx.hratio) / (1 + ctx.hratio);
    1169:   count_medium = 2 * ctx.hratio * count_slow;
    1170:   PetscCheck((count_slow % 2) == 0 && (count_medium % 2) == 0, PETSC_COMM_WORLD, PETSC_ERR_USER, "Please adjust grid size Mx (-da_grid_x) and hratio (-hratio) so that Mx/(1+hartio)^2 and Mx*2*hratio/(1+hratio)^2 is even");
    1171:   count_fast = ctx.hratio * ctx.hratio * count_slow;
    1172:   ctx.sm     = count_slow / 2;
    1173:   ctx.mf     = ctx.sm + count_medium / 2;
    1174:   ctx.fm     = ctx.mf + count_fast;
    1175:   ctx.ms     = ctx.fm + count_medium / 2;
    1176:   PetscCall(PetscMalloc1(xm * dof, &index_slow));
    1177:   PetscCall(PetscMalloc1(xm * dof, &index_medium));
    1178:   PetscCall(PetscMalloc1(xm * dof, &index_fast));
    1179:   PetscCall(PetscMalloc1(6 * dof, &index_slowbuffer));
    1180:   PetscCall(PetscMalloc1(6 * dof, &index_mediumbuffer));
    1181:   if (((AdvectCtx *)ctx.physics2.user)->a > 0) {
    1182:     ctx.lsbwidth = 2;
    1183:     ctx.rsbwidth = 4;
    1184:     ctx.lmbwidth = 2;
    1185:     ctx.rmbwidth = 4;
    1186:   } else {
    1187:     ctx.lsbwidth = 4;
    1188:     ctx.rsbwidth = 2;
    1189:     ctx.lmbwidth = 4;
    1190:     ctx.rmbwidth = 2;
    1191:   }

    1193:   for (i = xs; i < xs + xm; i++) {
    1194:     if (i < ctx.sm - ctx.lsbwidth || i > ctx.ms + ctx.rsbwidth - 1)
    1195:       for (k = 0; k < dof; k++) index_slow[islow++] = i * dof + k;
    1196:     else if ((i >= ctx.sm - ctx.lsbwidth && i < ctx.sm) || (i > ctx.ms - 1 && i <= ctx.ms + ctx.rsbwidth - 1))
    1197:       for (k = 0; k < dof; k++) index_slowbuffer[islowbuffer++] = i * dof + k;
    1198:     else if (i < ctx.mf - ctx.lmbwidth || i > ctx.fm + ctx.rmbwidth - 1)
    1199:       for (k = 0; k < dof; k++) index_medium[imedium++] = i * dof + k;
    1200:     else if ((i >= ctx.mf - ctx.lmbwidth && i < ctx.mf) || (i > ctx.fm - 1 && i <= ctx.fm + ctx.rmbwidth - 1))
    1201:       for (k = 0; k < dof; k++) index_mediumbuffer[imediumbuffer++] = i * dof + k;
    1202:     else
    1203:       for (k = 0; k < dof; k++) index_fast[ifast++] = i * dof + k;
    1204:   }
    1205:   PetscCall(ISCreateGeneral(PETSC_COMM_WORLD, islow, index_slow, PETSC_COPY_VALUES, &ctx.iss));
    1206:   PetscCall(ISCreateGeneral(PETSC_COMM_WORLD, imedium, index_medium, PETSC_COPY_VALUES, &ctx.ism));
    1207:   PetscCall(ISCreateGeneral(PETSC_COMM_WORLD, ifast, index_fast, PETSC_COPY_VALUES, &ctx.isf));
    1208:   PetscCall(ISCreateGeneral(PETSC_COMM_WORLD, islowbuffer, index_slowbuffer, PETSC_COPY_VALUES, &ctx.issb));
    1209:   PetscCall(ISCreateGeneral(PETSC_COMM_WORLD, imediumbuffer, index_mediumbuffer, PETSC_COPY_VALUES, &ctx.ismb));

    1211:   /* Create a time-stepping object */
    1212:   PetscCall(TSCreate(comm, &ts));
    1213:   PetscCall(TSSetDM(ts, da));
    1214:   PetscCall(TSSetRHSFunction(ts, R, FVRHSFunction_3WaySplit, &ctx));
    1215:   PetscCall(TSRHSSplitSetIS(ts, "slow", ctx.iss));
    1216:   PetscCall(TSRHSSplitSetIS(ts, "medium", ctx.ism));
    1217:   PetscCall(TSRHSSplitSetIS(ts, "fast", ctx.isf));
    1218:   PetscCall(TSRHSSplitSetIS(ts, "slowbuffer", ctx.issb));
    1219:   PetscCall(TSRHSSplitSetIS(ts, "mediumbuffer", ctx.ismb));
    1220:   PetscCall(TSRHSSplitSetRHSFunction(ts, "slow", NULL, FVRHSFunctionslow_3WaySplit, &ctx));
    1221:   PetscCall(TSRHSSplitSetRHSFunction(ts, "medium", NULL, FVRHSFunctionmedium_3WaySplit, &ctx));
    1222:   PetscCall(TSRHSSplitSetRHSFunction(ts, "fast", NULL, FVRHSFunctionfast_3WaySplit, &ctx));
    1223:   PetscCall(TSRHSSplitSetRHSFunction(ts, "slowbuffer", NULL, FVRHSFunctionslowbuffer_3WaySplit, &ctx));
    1224:   PetscCall(TSRHSSplitSetRHSFunction(ts, "mediumbuffer", NULL, FVRHSFunctionmediumbuffer_3WaySplit, &ctx));

    1226:   PetscCall(TSSetType(ts, TSSSP));
    1227:   /*PetscCall(TSSetType(ts,TSMPRK));*/
    1228:   PetscCall(TSSetMaxTime(ts, 10));
    1229:   PetscCall(TSSetExactFinalTime(ts, TS_EXACTFINALTIME_STEPOVER));

    1231:   /* Compute initial conditions and starting time step */
    1232:   PetscCall(FVSample_3WaySplit(&ctx, da, 0, X0));
    1233:   PetscCall(FVRHSFunction_3WaySplit(ts, 0, X0, X, (void *)&ctx)); /* Initial function evaluation, only used to determine max speed */
    1234:   PetscCall(VecCopy(X0, X));                                      /* The function value was not used so we set X=X0 again */
    1235:   PetscCall(TSSetTimeStep(ts, ctx.cfl / ctx.cfl_idt));
    1236:   PetscCall(TSSetFromOptions(ts)); /* Take runtime options */
    1237:   PetscCall(SolutionStatsView(da, X, PETSC_VIEWER_STDOUT_WORLD));
    1238:   {
    1239:     PetscInt           steps;
    1240:     PetscScalar        mass_initial, mass_final, mass_difference, mass_differenceg;
    1241:     const PetscScalar *ptr_X, *ptr_X0;
    1242:     const PetscReal    hs = (ctx.xmax - ctx.xmin) / 4.0 / count_slow;
    1243:     const PetscReal    hm = (ctx.xmax - ctx.xmin) / 2.0 / count_medium;
    1244:     const PetscReal    hf = (ctx.xmax - ctx.xmin) / 4.0 / count_fast;

    1246:     PetscCall(TSSolve(ts, X));
    1247:     PetscCall(TSGetSolveTime(ts, &ptime));
    1248:     PetscCall(TSGetStepNumber(ts, &steps));
    1249:     /* calculate the total mass at initial time and final time */
    1250:     mass_initial = 0.0;
    1251:     mass_final   = 0.0;
    1252:     PetscCall(DMDAVecGetArrayRead(da, X0, (void *)&ptr_X0));
    1253:     PetscCall(DMDAVecGetArrayRead(da, X, (void *)&ptr_X));
    1254:     for (i = xs; i < xs + xm; i++) {
    1255:       if (i < ctx.sm || i > ctx.ms - 1)
    1256:         for (k = 0; k < dof; k++) {
    1257:           mass_initial = mass_initial + hs * ptr_X0[i * dof + k];
    1258:           mass_final   = mass_final + hs * ptr_X[i * dof + k];
    1259:         }
    1260:       else if (i < ctx.mf || i > ctx.fm - 1)
    1261:         for (k = 0; k < dof; k++) {
    1262:           mass_initial = mass_initial + hm * ptr_X0[i * dof + k];
    1263:           mass_final   = mass_final + hm * ptr_X[i * dof + k];
    1264:         }
    1265:       else {
    1266:         for (k = 0; k < dof; k++) {
    1267:           mass_initial = mass_initial + hf * ptr_X0[i * dof + k];
    1268:           mass_final   = mass_final + hf * ptr_X[i * dof + k];
    1269:         }
    1270:       }
    1271:     }
    1272:     PetscCall(DMDAVecRestoreArrayRead(da, X0, (void *)&ptr_X0));
    1273:     PetscCall(DMDAVecRestoreArrayRead(da, X, (void *)&ptr_X));
    1274:     mass_difference = mass_final - mass_initial;
    1275:     PetscCallMPI(MPIU_Allreduce(&mass_difference, &mass_differenceg, 1, MPIU_SCALAR, MPIU_SUM, comm));
    1276:     PetscCall(PetscPrintf(comm, "Mass difference %g\n", (double)mass_differenceg));
    1277:     PetscCall(PetscPrintf(comm, "Final time %g, steps %" PetscInt_FMT "\n", (double)ptime, steps));
    1278:     PetscCall(PetscPrintf(comm, "Maximum allowable stepsize according to CFL %g\n", (double)(1 / ctx.cfl_idt)));
    1279:     if (ctx.exact) {
    1280:       PetscReal nrm1 = 0;
    1281:       PetscCall(SolutionErrorNorms_3WaySplit(&ctx, da, ptime, X, &nrm1));
    1282:       PetscCall(PetscPrintf(comm, "Error ||x-x_e||_1 %g\n", (double)nrm1));
    1283:     }
    1284:     if (ctx.simulation) {
    1285:       PetscReal          nrm1 = 0;
    1286:       PetscViewer        fd;
    1287:       char               filename[PETSC_MAX_PATH_LEN] = "binaryoutput";
    1288:       Vec                XR;
    1289:       PetscBool          flg;
    1290:       const PetscScalar *ptr_XR;
    1291:       PetscCall(PetscOptionsGetString(NULL, NULL, "-f", filename, sizeof(filename), &flg));
    1292:       PetscCheck(flg, PETSC_COMM_WORLD, PETSC_ERR_USER, "Must indicate binary file with the -f option");
    1293:       PetscCall(PetscViewerBinaryOpen(PETSC_COMM_WORLD, filename, FILE_MODE_READ, &fd));
    1294:       PetscCall(VecDuplicate(X0, &XR));
    1295:       PetscCall(VecLoad(XR, fd));
    1296:       PetscCall(PetscViewerDestroy(&fd));
    1297:       PetscCall(VecGetArrayRead(X, &ptr_X));
    1298:       PetscCall(VecGetArrayRead(XR, &ptr_XR));
    1299:       for (i = xs; i < xs + xm; i++) {
    1300:         if (i < ctx.sm || i > ctx.ms - 1)
    1301:           for (k = 0; k < dof; k++) nrm1 = nrm1 + hs * PetscAbs(ptr_X[i * dof + k] - ptr_XR[i * dof + k]);
    1302:         else if (i < ctx.mf || i < ctx.fm - 1)
    1303:           for (k = 0; k < dof; k++) nrm1 = nrm1 + hm * PetscAbs(ptr_X[i * dof + k] - ptr_XR[i * dof + k]);
    1304:         else
    1305:           for (k = 0; k < dof; k++) nrm1 = nrm1 + hf * PetscAbs(ptr_X[i * dof + k] - ptr_XR[i * dof + k]);
    1306:       }
    1307:       PetscCall(VecRestoreArrayRead(X, &ptr_X));
    1308:       PetscCall(VecRestoreArrayRead(XR, &ptr_XR));
    1309:       PetscCall(PetscPrintf(comm, "Error ||x-x_e||_1 %g\n", (double)nrm1));
    1310:       PetscCall(VecDestroy(&XR));
    1311:     }
    1312:   }

    1314:   PetscCall(SolutionStatsView(da, X, PETSC_VIEWER_STDOUT_WORLD));
    1315:   if (draw & 0x1) PetscCall(VecView(X0, PETSC_VIEWER_DRAW_WORLD));
    1316:   if (draw & 0x2) PetscCall(VecView(X, PETSC_VIEWER_DRAW_WORLD));
    1317:   if (draw & 0x4) {
    1318:     Vec Y;
    1319:     PetscCall(VecDuplicate(X, &Y));
    1320:     PetscCall(FVSample_3WaySplit(&ctx, da, ptime, Y));
    1321:     PetscCall(VecAYPX(Y, -1, X));
    1322:     PetscCall(VecView(Y, PETSC_VIEWER_DRAW_WORLD));
    1323:     PetscCall(VecDestroy(&Y));
    1324:   }

    1326:   if (view_final) {
    1327:     PetscViewer viewer;
    1328:     PetscCall(PetscViewerASCIIOpen(PETSC_COMM_WORLD, final_fname, &viewer));
    1329:     PetscCall(PetscViewerPushFormat(viewer, PETSC_VIEWER_ASCII_MATLAB));
    1330:     PetscCall(VecView(X, viewer));
    1331:     PetscCall(PetscViewerPopFormat(viewer));
    1332:     PetscCall(PetscViewerDestroy(&viewer));
    1333:   }

    1335:   /* Clean up */
    1336:   PetscCall((*ctx.physics2.destroy)(ctx.physics2.user));
    1337:   for (i = 0; i < ctx.physics2.dof; i++) PetscCall(PetscFree(ctx.physics2.fieldname[i]));
    1338:   PetscCall(PetscFree4(ctx.R, ctx.Rinv, ctx.cjmpLR, ctx.cslope));
    1339:   PetscCall(PetscFree3(ctx.uLR, ctx.flux, ctx.speeds));
    1340:   PetscCall(VecDestroy(&X));
    1341:   PetscCall(VecDestroy(&X0));
    1342:   PetscCall(VecDestroy(&R));
    1343:   PetscCall(DMDestroy(&da));
    1344:   PetscCall(TSDestroy(&ts));
    1345:   PetscCall(ISDestroy(&ctx.iss));
    1346:   PetscCall(ISDestroy(&ctx.ism));
    1347:   PetscCall(ISDestroy(&ctx.isf));
    1348:   PetscCall(ISDestroy(&ctx.issb));
    1349:   PetscCall(ISDestroy(&ctx.ismb));
    1350:   PetscCall(PetscFree(index_slow));
    1351:   PetscCall(PetscFree(index_medium));
    1352:   PetscCall(PetscFree(index_fast));
    1353:   PetscCall(PetscFree(index_slowbuffer));
    1354:   PetscCall(PetscFree(index_mediumbuffer));
    1355:   PetscCall(PetscFunctionListDestroy(&limiters));
    1356:   PetscCall(PetscFunctionListDestroy(&physics));
    1357:   PetscCall(PetscFinalize());
    1358:   return 0;
    1359: }

    1361: /*TEST

    1363:     build:
    1364:       requires: !complex
    1365:       depends: finitevolume1d.c

    1367:     test:
    1368:       suffix: 1
    1369:       args: -da_grid_x 90 -initial 7 -xmin -1 -xmax 1 -hratio 2 -limit mc -ts_time_step 0.025 -ts_max_steps 24 -ts_type mprk -ts_mprk_type 2a23 -ts_use_splitrhsfunction 0

    1371:     test:
    1372:       suffix: 2
    1373:       args: -da_grid_x 90 -initial 7 -xmin -1 -xmax 1 -hratio 2 -limit mc -ts_time_step 0.025 -ts_max_steps 24 -ts_type mprk -ts_mprk_type 2a23 -ts_use_splitrhsfunction 1

    1375: TEST*/