Actual source code: ex20opt_ic.c

1: static char help[] = "Solves a ODE-constrained optimization problem -- finding the optimal initial conditions for the van der Pol equation.\n";

3: /*
4:   Notes:
5:   This code demonstrates how to solve an ODE-constrained optimization problem with TAO, TSAdjoint and TS.
6:   The nonlinear problem is written in an ODE equivalent form.
7:   The objective is to minimize the difference between observation and model prediction by finding optimal values for initial conditions.
8:   The gradient is computed with the discrete adjoint of an implicit method or an explicit method, see ex20adj.c for details.
9: */

11: #include <petsctao.h>
12: #include <petscts.h>

14: typedef struct _n_User *User;
15: struct _n_User {
16:   TS        ts;
17:   PetscReal mu;
18:   PetscReal next_output;

20:   /* Sensitivity analysis support */
21:   PetscInt  steps;
22:   PetscReal ftime;
23:   Mat       A;                    /* Jacobian matrix for ODE */
24:   Mat       Jacp;                 /* JacobianP matrix for ODE*/
25:   Mat       H;                    /* Hessian matrix for optimization */
26:   Vec       U, Lambda[1], Mup[1]; /* first-order adjoint variables */
27:   Vec       Lambda2[2];           /* second-order adjoint variables */
28:   Vec       Ihp1[1];              /* working space for Hessian evaluations */
29:   Vec       Dir;                  /* direction vector */
30:   PetscReal ob[2];                /* observation used by the cost function */
31:   PetscBool implicitform;         /* implicit ODE? */
32: };

35: /* ----------------------- Explicit form of the ODE  -------------------- */

37: static PetscErrorCode RHSFunction(TS ts, PetscReal t, Vec U, Vec F, void *ctx)
38: {
39:   User               user = (User)ctx;
40:   PetscScalar       *f;
41:   const PetscScalar *u;

43:   PetscFunctionBeginUser;
45:   PetscCall(VecGetArray(F, &f));
46:   f[0] = u[1];
47:   f[1] = user->mu * ((1. - u[0] * u[0]) * u[1] - u[0]);
49:   PetscCall(VecRestoreArray(F, &f));
50:   PetscFunctionReturn(PETSC_SUCCESS);
51: }

53: static PetscErrorCode RHSJacobian(TS ts, PetscReal t, Vec U, Mat A, Mat B, void *ctx)
54: {
55:   User               user     = (User)ctx;
56:   PetscReal          mu       = user->mu;
57:   PetscInt           rowcol[] = {0, 1};
58:   PetscScalar        J[2][2];
59:   const PetscScalar *u;

61:   PetscFunctionBeginUser;
63:   J[0][0] = 0;
64:   J[1][0] = -mu * (2.0 * u[1] * u[0] + 1.);
65:   J[0][1] = 1.0;
66:   J[1][1] = mu * (1.0 - u[0] * u[0]);
67:   PetscCall(MatSetValues(A, 2, rowcol, 2, rowcol, &J[0][0], INSERT_VALUES));
68:   PetscCall(MatAssemblyBegin(A, MAT_FINAL_ASSEMBLY));
69:   PetscCall(MatAssemblyEnd(A, MAT_FINAL_ASSEMBLY));
70:   if (A != B) {
71:     PetscCall(MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY));
72:     PetscCall(MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY));
73:   }
75:   PetscFunctionReturn(PETSC_SUCCESS);
76: }

78: static PetscErrorCode RHSHessianProductUU(TS ts, PetscReal t, Vec U, Vec *Vl, Vec Vr, Vec *VHV, void *ctx)
79: {
80:   const PetscScalar *vl, *vr, *u;
81:   PetscScalar       *vhv;
82:   PetscScalar        dJdU[2][2][2] = {{{0}}};
83:   PetscInt           i, j, k;
84:   User               user = (User)ctx;

86:   PetscFunctionBeginUser;
90:   PetscCall(VecGetArray(VHV[0], &vhv));

92:   dJdU[1][0][0] = -2. * user->mu * u[1];
93:   dJdU[1][1][0] = -2. * user->mu * u[0];
94:   dJdU[1][0][1] = -2. * user->mu * u[0];
95:   for (j = 0; j < 2; j++) {
96:     vhv[j] = 0;
97:     for (k = 0; k < 2; k++)
98:       for (i = 0; i < 2; i++) vhv[j] += vl[i] * dJdU[i][j][k] * vr[k];
99:   }
103:   PetscCall(VecRestoreArray(VHV[0], &vhv));
104:   PetscFunctionReturn(PETSC_SUCCESS);
105: }

107: /* ----------------------- Implicit form of the ODE  -------------------- */

109: static PetscErrorCode IFunction(TS ts, PetscReal t, Vec U, Vec Udot, Vec F, void *ctx)
110: {
111:   User               user = (User)ctx;
112:   const PetscScalar *u, *udot;
113:   PetscScalar       *f;

115:   PetscFunctionBeginUser;
118:   PetscCall(VecGetArray(F, &f));
119:   f[0] = udot[0] - u[1];
120:   f[1] = udot[1] - user->mu * ((1.0 - u[0] * u[0]) * u[1] - u[0]);
123:   PetscCall(VecRestoreArray(F, &f));
124:   PetscFunctionReturn(PETSC_SUCCESS);
125: }

127: static PetscErrorCode IJacobian(TS ts, PetscReal t, Vec U, Vec Udot, PetscReal a, Mat A, Mat B, void *ctx)
128: {
129:   User               user     = (User)ctx;
130:   PetscInt           rowcol[] = {0, 1};
131:   PetscScalar        J[2][2];
132:   const PetscScalar *u;

134:   PetscFunctionBeginUser;
136:   J[0][0] = a;
137:   J[0][1] = -1.0;
138:   J[1][0] = user->mu * (1.0 + 2.0 * u[0] * u[1]);
139:   J[1][1] = a - user->mu * (1.0 - u[0] * u[0]);
140:   PetscCall(MatSetValues(B, 2, rowcol, 2, rowcol, &J[0][0], INSERT_VALUES));
142:   PetscCall(MatAssemblyBegin(A, MAT_FINAL_ASSEMBLY));
143:   PetscCall(MatAssemblyEnd(A, MAT_FINAL_ASSEMBLY));
144:   if (A != B) {
145:     PetscCall(MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY));
146:     PetscCall(MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY));
147:   }
148:   PetscFunctionReturn(PETSC_SUCCESS);
149: }

151: /* Monitor timesteps and use interpolation to output at integer multiples of 0.1 */
152: static PetscErrorCode Monitor(TS ts, PetscInt step, PetscReal t, Vec U, void *ctx)
153: {
154:   const PetscScalar *u;
155:   PetscReal          tfinal, dt;
156:   User               user = (User)ctx;
157:   Vec                interpolatedU;

159:   PetscFunctionBeginUser;
160:   PetscCall(TSGetTimeStep(ts, &dt));
161:   PetscCall(TSGetMaxTime(ts, &tfinal));

163:   while (user->next_output <= t && user->next_output <= tfinal) {
164:     PetscCall(VecDuplicate(U, &interpolatedU));
165:     PetscCall(TSInterpolate(ts, user->next_output, interpolatedU));
167:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "[%g] %" PetscInt_FMT " TS %g (dt = %g) X %g %g\n", (double)user->next_output, step, (double)t, (double)dt, (double)PetscRealPart(u[0]), (double)PetscRealPart(u[1])));
169:     PetscCall(VecDestroy(&interpolatedU));
170:     user->next_output += 0.1;
171:   }
172:   PetscFunctionReturn(PETSC_SUCCESS);
173: }

175: static PetscErrorCode IHessianProductUU(TS ts, PetscReal t, Vec U, Vec *Vl, Vec Vr, Vec *VHV, void *ctx)
176: {
177:   const PetscScalar *vl, *vr, *u;
178:   PetscScalar       *vhv;
179:   PetscScalar        dJdU[2][2][2] = {{{0}}};
180:   PetscInt           i, j, k;
181:   User               user = (User)ctx;

183:   PetscFunctionBeginUser;
187:   PetscCall(VecGetArray(VHV[0], &vhv));
188:   dJdU[1][0][0] = 2. * user->mu * u[1];
189:   dJdU[1][1][0] = 2. * user->mu * u[0];
190:   dJdU[1][0][1] = 2. * user->mu * u[0];
191:   for (j = 0; j < 2; j++) {
192:     vhv[j] = 0;
193:     for (k = 0; k < 2; k++)
194:       for (i = 0; i < 2; i++) vhv[j] += vl[i] * dJdU[i][j][k] * vr[k];
195:   }
199:   PetscCall(VecRestoreArray(VHV[0], &vhv));
200:   PetscFunctionReturn(PETSC_SUCCESS);
201: }

203: /* ------------------ User-defined routines for TAO -------------------------- */

205: static PetscErrorCode FormFunctionGradient(Tao tao, Vec IC, PetscReal *f, Vec G, void *ctx)
206: {
207:   User               user_ptr = (User)ctx;
208:   TS                 ts       = user_ptr->ts;
209:   const PetscScalar *x_ptr;
210:   PetscScalar       *y_ptr;

212:   PetscFunctionBeginUser;
213:   PetscCall(VecCopy(IC, user_ptr->U)); /* set up the initial condition */

215:   PetscCall(TSSetTime(ts, 0.0));
216:   PetscCall(TSSetStepNumber(ts, 0));
217:   PetscCall(TSSetTimeStep(ts, 0.001)); /* can be overwritten by command line options */
218:   PetscCall(TSSetFromOptions(ts));
219:   PetscCall(TSSolve(ts, user_ptr->U));

222:   PetscCall(VecGetArray(user_ptr->Lambda[0], &y_ptr));
223:   *f       = (x_ptr[0] - user_ptr->ob[0]) * (x_ptr[0] - user_ptr->ob[0]) + (x_ptr[1] - user_ptr->ob[1]) * (x_ptr[1] - user_ptr->ob[1]);
224:   y_ptr[0] = 2. * (x_ptr[0] - user_ptr->ob[0]);
225:   y_ptr[1] = 2. * (x_ptr[1] - user_ptr->ob[1]);
226:   PetscCall(VecRestoreArray(user_ptr->Lambda[0], &y_ptr));

231:   PetscCall(VecCopy(user_ptr->Lambda[0], G));
232:   PetscFunctionReturn(PETSC_SUCCESS);
233: }

235: static PetscErrorCode FormHessian(Tao tao, Vec U, Mat H, Mat Hpre, void *ctx)
236: {
237:   User           user_ptr = (User)ctx;
238:   PetscScalar    harr[2];
239:   PetscScalar   *x_ptr;
240:   const PetscInt rows[2] = {0, 1};
241:   PetscInt       col;

243:   PetscFunctionBeginUser;
244:   PetscCall(VecCopy(U, user_ptr->U));
245:   PetscCall(VecGetArray(user_ptr->Dir, &x_ptr));
246:   x_ptr[0] = 1.;
247:   x_ptr[1] = 0.;
248:   PetscCall(VecRestoreArray(user_ptr->Dir, &x_ptr));
250:   col = 0;
251:   PetscCall(MatSetValues(H, 2, rows, 1, &col, harr, INSERT_VALUES));

253:   PetscCall(VecCopy(U, user_ptr->U));
254:   PetscCall(VecGetArray(user_ptr->Dir, &x_ptr));
255:   x_ptr[0] = 0.;
256:   x_ptr[1] = 1.;
257:   PetscCall(VecRestoreArray(user_ptr->Dir, &x_ptr));
259:   col = 1;
260:   PetscCall(MatSetValues(H, 2, rows, 1, &col, harr, INSERT_VALUES));

262:   PetscCall(MatAssemblyBegin(H, MAT_FINAL_ASSEMBLY));
263:   PetscCall(MatAssemblyEnd(H, MAT_FINAL_ASSEMBLY));
264:   if (H != Hpre) {
265:     PetscCall(MatAssemblyBegin(Hpre, MAT_FINAL_ASSEMBLY));
266:     PetscCall(MatAssemblyEnd(Hpre, MAT_FINAL_ASSEMBLY));
267:   }
268:   PetscFunctionReturn(PETSC_SUCCESS);
269: }

271: static PetscErrorCode MatrixFreeHessian(Tao tao, Vec U, Mat H, Mat Hpre, void *ctx)
272: {
273:   User user_ptr = (User)ctx;

275:   PetscFunctionBeginUser;
276:   PetscCall(VecCopy(U, user_ptr->U));
277:   PetscFunctionReturn(PETSC_SUCCESS);
278: }

280: /* ------------ Routines calculating second-order derivatives -------------- */

282: /*
283:   Compute the Hessian-vector product for the cost function using Second-order adjoint
284: */
285: PetscErrorCode Adjoint2(Vec U, PetscScalar arr[], User ctx)
286: {
287:   TS           ts = ctx->ts;
288:   PetscScalar *x_ptr, *y_ptr;
289:   Mat          tlmsen;

291:   PetscFunctionBeginUser;

294:   PetscCall(TSSetTime(ts, 0.0));
295:   PetscCall(TSSetStepNumber(ts, 0));
296:   PetscCall(TSSetTimeStep(ts, 0.001));
297:   PetscCall(TSSetFromOptions(ts));
298:   PetscCall(TSSetCostHessianProducts(ts, 1, ctx->Lambda2, NULL, ctx->Dir));
300:   PetscCall(TSSolve(ts, U));

302:   /* Set terminal conditions for first- and second-order adjonts */
303:   PetscCall(VecGetArray(U, &x_ptr));
304:   PetscCall(VecGetArray(ctx->Lambda[0], &y_ptr));
305:   y_ptr[0] = 2. * (x_ptr[0] - ctx->ob[0]);
306:   y_ptr[1] = 2. * (x_ptr[1] - ctx->ob[1]);
307:   PetscCall(VecRestoreArray(ctx->Lambda[0], &y_ptr));
308:   PetscCall(VecRestoreArray(U, &x_ptr));
309:   PetscCall(TSForwardGetSensitivities(ts, NULL, &tlmsen));
310:   PetscCall(MatDenseGetColumn(tlmsen, 0, &x_ptr));
311:   PetscCall(VecGetArray(ctx->Lambda2[0], &y_ptr));
312:   y_ptr[0] = 2. * x_ptr[0];
313:   y_ptr[1] = 2. * x_ptr[1];
314:   PetscCall(VecRestoreArray(ctx->Lambda2[0], &y_ptr));
315:   PetscCall(MatDenseRestoreColumn(tlmsen, &x_ptr));

318:   if (ctx->implicitform) {
319:     PetscCall(TSSetIHessianProduct(ts, ctx->Ihp1, IHessianProductUU, NULL, NULL, NULL, NULL, NULL, NULL, ctx));
320:   } else {
321:     PetscCall(TSSetRHSHessianProduct(ts, ctx->Ihp1, RHSHessianProductUU, NULL, NULL, NULL, NULL, NULL, NULL, ctx));
322:   }

325:   PetscCall(VecGetArray(ctx->Lambda2[0], &x_ptr));
326:   arr[0] = x_ptr[0];
327:   arr[1] = x_ptr[1];
328:   PetscCall(VecRestoreArray(ctx->Lambda2[0], &x_ptr));

332:   PetscFunctionReturn(PETSC_SUCCESS);
333: }

335: PetscErrorCode FiniteDiff(Vec U, PetscScalar arr[], User ctx)
336: {
337:   Vec               Up, G, Gp;
338:   const PetscScalar eps = PetscRealConstant(1e-7);
339:   PetscScalar      *u;
340:   Tao               tao = NULL;
341:   PetscReal         f;

343:   PetscFunctionBeginUser;
344:   PetscCall(VecDuplicate(U, &Up));
345:   PetscCall(VecDuplicate(U, &G));
346:   PetscCall(VecDuplicate(U, &Gp));

348:   PetscCall(FormFunctionGradient(tao, U, &f, G, ctx));

350:   PetscCall(VecCopy(U, Up));
351:   PetscCall(VecGetArray(Up, &u));
352:   u[0] += eps;
353:   PetscCall(VecRestoreArray(Up, &u));
354:   PetscCall(FormFunctionGradient(tao, Up, &f, Gp, ctx));
355:   PetscCall(VecAXPY(Gp, -1, G));
356:   PetscCall(VecScale(Gp, 1. / eps));
357:   PetscCall(VecGetArray(Gp, &u));
358:   arr[0] = u[0];
359:   arr[1] = u[1];
360:   PetscCall(VecRestoreArray(Gp, &u));

362:   PetscCall(VecCopy(U, Up));
363:   PetscCall(VecGetArray(Up, &u));
364:   u[1] += eps;
365:   PetscCall(VecRestoreArray(Up, &u));
366:   PetscCall(FormFunctionGradient(tao, Up, &f, Gp, ctx));
367:   PetscCall(VecAXPY(Gp, -1, G));
368:   PetscCall(VecScale(Gp, 1. / eps));
369:   PetscCall(VecGetArray(Gp, &u));
370:   arr[2] = u[0];
371:   arr[3] = u[1];
372:   PetscCall(VecRestoreArray(Gp, &u));

374:   PetscCall(VecDestroy(&G));
375:   PetscCall(VecDestroy(&Gp));
376:   PetscCall(VecDestroy(&Up));
377:   PetscFunctionReturn(PETSC_SUCCESS);
378: }

380: static PetscErrorCode HessianProductMat(Mat mat, Vec svec, Vec y)
381: {
382:   User         user_ptr;
383:   PetscScalar *y_ptr;

385:   PetscFunctionBeginUser;
386:   PetscCall(MatShellGetContext(mat, &user_ptr));
387:   PetscCall(VecCopy(svec, user_ptr->Dir));
388:   PetscCall(VecGetArray(y, &y_ptr));
390:   PetscCall(VecRestoreArray(y, &y_ptr));
391:   PetscFunctionReturn(PETSC_SUCCESS);
392: }

394: int main(int argc, char **argv)
395: {
396:   PetscBool      monitor = PETSC_FALSE, mf = PETSC_TRUE;
397:   PetscInt       mode = 0;
398:   PetscMPIInt    size;
399:   struct _n_User user;
400:   Vec            x; /* working vector for TAO */
401:   PetscScalar   *x_ptr, arr[4];
402:   PetscScalar    ic1 = 2.2, ic2 = -0.7; /* initial guess for TAO */
403:   Tao            tao;
404:   KSP            ksp;
405:   PC             pc;

407:   /* Initialize program */
408:   PetscFunctionBeginUser;
409:   PetscCall(PetscInitialize(&argc, &argv, NULL, help));
410:   PetscCallMPI(MPI_Comm_size(PETSC_COMM_WORLD, &size));
411:   PetscCheck(size == 1, PETSC_COMM_WORLD, PETSC_ERR_WRONG_MPI_SIZE, "This is a uniprocessor example only!");

413:   /* Set runtime options */
414:   user.next_output  = 0.0;
415:   user.mu           = 1.0e3;
416:   user.steps        = 0;
417:   user.ftime        = 0.5;
418:   user.implicitform = PETSC_TRUE;

420:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-monitor", &monitor, NULL));
421:   PetscCall(PetscOptionsGetReal(NULL, NULL, "-mu", &user.mu, NULL));
422:   PetscCall(PetscOptionsGetInt(NULL, NULL, "-mode", &mode, NULL));
423:   PetscCall(PetscOptionsGetReal(NULL, NULL, "-ic1", &ic1, NULL));
424:   PetscCall(PetscOptionsGetReal(NULL, NULL, "-ic2", &ic2, NULL));
425:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-my_tao_mf", &mf, NULL)); /* matrix-free hessian for optimization */
426:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-implicitform", &user.implicitform, NULL));

428:   /* Create necessary matrix and vectors, solve same ODE on every process */
429:   PetscCall(MatCreate(PETSC_COMM_WORLD, &user.A));
430:   PetscCall(MatSetSizes(user.A, PETSC_DECIDE, PETSC_DECIDE, 2, 2));
431:   PetscCall(MatSetFromOptions(user.A));
432:   PetscCall(MatSetUp(user.A));
433:   PetscCall(MatCreateVecs(user.A, &user.U, NULL));
434:   PetscCall(MatCreateVecs(user.A, &user.Dir, NULL));
435:   PetscCall(MatCreateVecs(user.A, &user.Lambda[0], NULL));
436:   PetscCall(MatCreateVecs(user.A, &user.Lambda2[0], NULL));
437:   PetscCall(MatCreateVecs(user.A, &user.Ihp1[0], NULL));

439:   /* Create timestepping solver context */
440:   PetscCall(TSCreate(PETSC_COMM_WORLD, &user.ts));
441:   PetscCall(TSSetEquationType(user.ts, TS_EQ_ODE_EXPLICIT)); /* less Jacobian evaluations when adjoint BEuler is used, otherwise no effect */
442:   if (user.implicitform) {
443:     PetscCall(TSSetIFunction(user.ts, NULL, IFunction, &user));
444:     PetscCall(TSSetIJacobian(user.ts, user.A, user.A, IJacobian, &user));
445:     PetscCall(TSSetType(user.ts, TSCN));
446:   } else {
447:     PetscCall(TSSetRHSFunction(user.ts, NULL, RHSFunction, &user));
448:     PetscCall(TSSetRHSJacobian(user.ts, user.A, user.A, RHSJacobian, &user));
449:     PetscCall(TSSetType(user.ts, TSRK));
450:   }
451:   PetscCall(TSSetMaxTime(user.ts, user.ftime));
452:   PetscCall(TSSetExactFinalTime(user.ts, TS_EXACTFINALTIME_MATCHSTEP));

454:   if (monitor) PetscCall(TSMonitorSet(user.ts, Monitor, &user, NULL));

456:   /* Set ODE initial conditions */
457:   PetscCall(VecGetArray(user.U, &x_ptr));
458:   x_ptr[0] = 2.0;
459:   x_ptr[1] = -2.0 / 3.0 + 10.0 / (81.0 * user.mu) - 292.0 / (2187.0 * user.mu * user.mu);
460:   PetscCall(VecRestoreArray(user.U, &x_ptr));

462:   /* Set runtime options */
463:   PetscCall(TSSetFromOptions(user.ts));

465:   /* Obtain the observation */
466:   PetscCall(TSSolve(user.ts, user.U));
467:   PetscCall(VecGetArray(user.U, &x_ptr));
468:   user.ob[0] = x_ptr[0];
469:   user.ob[1] = x_ptr[1];
470:   PetscCall(VecRestoreArray(user.U, &x_ptr));

472:   PetscCall(VecDuplicate(user.U, &x));
473:   PetscCall(VecGetArray(x, &x_ptr));
474:   x_ptr[0] = ic1;
475:   x_ptr[1] = ic2;
476:   PetscCall(VecRestoreArray(x, &x_ptr));

478:   /* Save trajectory of solution so that TSAdjointSolve() may be used */
479:   PetscCall(TSSetSaveTrajectory(user.ts));

481:   /* Compare finite difference and second-order adjoint. */
482:   switch (mode) {
483:   case 2:
484:     PetscCall(FiniteDiff(x, arr, &user));
485:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "\n Finite difference approximation of the Hessian\n"));
486:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "%g %g\n%g %g\n", (double)arr[0], (double)arr[1], (double)arr[2], (double)arr[3]));
487:     break;
488:   case 1: /* Compute the Hessian column by column */
489:     PetscCall(VecCopy(x, user.U));
490:     PetscCall(VecGetArray(user.Dir, &x_ptr));
491:     x_ptr[0] = 1.;
492:     x_ptr[1] = 0.;
493:     PetscCall(VecRestoreArray(user.Dir, &x_ptr));
495:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "\nFirst column of the Hessian\n"));
496:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "%g\n%g\n", (double)arr[0], (double)arr[1]));
497:     PetscCall(VecCopy(x, user.U));
498:     PetscCall(VecGetArray(user.Dir, &x_ptr));
499:     x_ptr[0] = 0.;
500:     x_ptr[1] = 1.;
501:     PetscCall(VecRestoreArray(user.Dir, &x_ptr));
503:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "\nSecond column of the Hessian\n"));
504:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "%g\n%g\n", (double)arr[0], (double)arr[1]));
505:     break;
506:   case 0:
507:     /* Create optimization context and set up */
508:     PetscCall(TaoCreate(PETSC_COMM_WORLD, &tao));
509:     PetscCall(TaoSetType(tao, TAOBLMVM));

512:     if (mf) {
513:       PetscCall(MatCreateShell(PETSC_COMM_SELF, 2, 2, 2, 2, (void *)&user, &user.H));
514:       PetscCall(MatShellSetOperation(user.H, MATOP_MULT, (void (*)(void))HessianProductMat));
515:       PetscCall(MatSetOption(user.H, MAT_SYMMETRIC, PETSC_TRUE));
516:       PetscCall(TaoSetHessian(tao, user.H, user.H, MatrixFreeHessian, (void *)&user));
517:     } else { /* Create Hessian matrix */
518:       PetscCall(MatCreate(PETSC_COMM_WORLD, &user.H));
519:       PetscCall(MatSetSizes(user.H, PETSC_DECIDE, PETSC_DECIDE, 2, 2));
520:       PetscCall(MatSetUp(user.H));
521:       PetscCall(TaoSetHessian(tao, user.H, user.H, FormHessian, (void *)&user));
522:     }

524:     /* Not use any preconditioner */
525:     PetscCall(TaoGetKSP(tao, &ksp));
526:     if (ksp) {
527:       PetscCall(KSPGetPC(ksp, &pc));
528:       PetscCall(PCSetType(pc, PCNONE));
529:     }

531:     /* Set initial solution guess */
532:     PetscCall(TaoSetSolution(tao, x));
533:     PetscCall(TaoSetFromOptions(tao));
534:     PetscCall(TaoSolve(tao));
535:     PetscCall(TaoDestroy(&tao));
536:     PetscCall(MatDestroy(&user.H));
537:     break;
538:   default:
539:     break;
540:   }

542:   /* Free work space.  All PETSc objects should be destroyed when they are no longer needed. */
543:   PetscCall(MatDestroy(&user.A));
544:   PetscCall(VecDestroy(&user.U));
545:   PetscCall(VecDestroy(&user.Lambda[0]));
546:   PetscCall(VecDestroy(&user.Lambda2[0]));
547:   PetscCall(VecDestroy(&user.Ihp1[0]));
548:   PetscCall(VecDestroy(&user.Dir));
549:   PetscCall(TSDestroy(&user.ts));
550:   PetscCall(VecDestroy(&x));
551:   PetscCall(PetscFinalize());
552:   return 0;
553: }

555: /*TEST
556:     build:
557:       requires: !complex !single

559:     test:
560:       args: -ts_type cn -viewer_binary_skip_info -tao_monitor -tao_view -mu 1000 -ts_dt 0.03125
561:       output_file: output/ex20opt_ic_1.out

563:     test:
564:       suffix: 2
565:       args: -ts_type beuler -viewer_binary_skip_info -tao_monitor -tao_view -mu 100 -ts_dt 0.01 -tao_type bntr -tao_bnk_pc_type none
566:       output_file: output/ex20opt_ic_2.out

568:     test:
569:       suffix: 3
570:       args: -ts_type cn -viewer_binary_skip_info -tao_monitor -tao_view -mu 100 -ts_dt 0.01 -tao_type bntr -tao_bnk_pc_type none
571:       output_file: output/ex20opt_ic_3.out

573:     test:
574:       suffix: 4
575:       args: -implicitform 0 -ts_dt 0.01 -ts_max_steps 2 -ts_rhs_jacobian_test_mult_transpose -mat_shell_test_mult_transpose_view -ts_rhs_jacobian_test_mult -mat_shell_test_mult_view -mode 1 -my_tao_mf
576: TEST*/