Actual source code: pdipm.c
1: #include <../src/tao/constrained/impls/ipm/pdipm.h>
3: /*
4: TaoPDIPMEvaluateFunctionsAndJacobians - Evaluate the objective function f, gradient fx, constraints, and all the Jacobians at current vector
6: Collective
8: Input Parameter:
9: + tao - solver context
10: - x - vector at which all objects to be evaluated
12: Level: beginner
14: .seealso: `TaoPDIPMUpdateConstraints()`, `TaoPDIPMSetUpBounds()`
15: */
16: static PetscErrorCode TaoPDIPMEvaluateFunctionsAndJacobians(Tao tao, Vec x)
17: {
18: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
20: PetscFunctionBegin;
21: /* Compute user objective function and gradient */
22: PetscCall(TaoComputeObjectiveAndGradient(tao, x, &pdipm->obj, tao->gradient));
24: /* Equality constraints and Jacobian */
25: if (pdipm->Ng) {
26: PetscCall(TaoComputeEqualityConstraints(tao, x, tao->constraints_equality));
27: PetscCall(TaoComputeJacobianEquality(tao, x, tao->jacobian_equality, tao->jacobian_equality_pre));
28: }
30: /* Inequality constraints and Jacobian */
31: if (pdipm->Nh) {
32: PetscCall(TaoComputeInequalityConstraints(tao, x, tao->constraints_inequality));
33: PetscCall(TaoComputeJacobianInequality(tao, x, tao->jacobian_inequality, tao->jacobian_inequality_pre));
34: }
35: PetscFunctionReturn(PETSC_SUCCESS);
36: }
38: /*
39: TaoPDIPMUpdateConstraints - Update the vectors ce and ci at x
41: Collective
43: Input Parameter:
44: + tao - Tao context
45: - x - vector at which constraints to be evaluated
47: Level: beginner
49: .seealso: `TaoPDIPMEvaluateFunctionsAndJacobians()`
50: */
51: static PetscErrorCode TaoPDIPMUpdateConstraints(Tao tao, Vec x)
52: {
53: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
54: PetscInt i, offset, offset1, k, xstart;
55: PetscScalar *carr;
56: const PetscInt *ubptr, *lbptr, *bxptr, *fxptr;
57: const PetscScalar *xarr, *xuarr, *xlarr, *garr, *harr;
59: PetscFunctionBegin;
60: PetscCall(VecGetOwnershipRange(x, &xstart, NULL));
62: PetscCall(VecGetArrayRead(x, &xarr));
63: PetscCall(VecGetArrayRead(tao->XU, &xuarr));
64: PetscCall(VecGetArrayRead(tao->XL, &xlarr));
66: /* (1) Update ce vector */
67: PetscCall(VecGetArrayWrite(pdipm->ce, &carr));
69: if (pdipm->Ng) {
70: /* (1.a) Inserting updated g(x) */
71: PetscCall(VecGetArrayRead(tao->constraints_equality, &garr));
72: PetscCall(PetscMemcpy(carr, garr, pdipm->ng * sizeof(PetscScalar)));
73: PetscCall(VecRestoreArrayRead(tao->constraints_equality, &garr));
74: }
76: /* (1.b) Update xfixed */
77: if (pdipm->Nxfixed) {
78: offset = pdipm->ng;
79: PetscCall(ISGetIndices(pdipm->isxfixed, &fxptr)); /* global indices in x */
80: for (k = 0; k < pdipm->nxfixed; k++) {
81: i = fxptr[k] - xstart;
82: carr[offset + k] = xarr[i] - xuarr[i];
83: }
84: }
85: PetscCall(VecRestoreArrayWrite(pdipm->ce, &carr));
87: /* (2) Update ci vector */
88: PetscCall(VecGetArrayWrite(pdipm->ci, &carr));
90: if (pdipm->Nh) {
91: /* (2.a) Inserting updated h(x) */
92: PetscCall(VecGetArrayRead(tao->constraints_inequality, &harr));
93: PetscCall(PetscMemcpy(carr, harr, pdipm->nh * sizeof(PetscScalar)));
94: PetscCall(VecRestoreArrayRead(tao->constraints_inequality, &harr));
95: }
97: /* (2.b) Update xub */
98: offset = pdipm->nh;
99: if (pdipm->Nxub) {
100: PetscCall(ISGetIndices(pdipm->isxub, &ubptr));
101: for (k = 0; k < pdipm->nxub; k++) {
102: i = ubptr[k] - xstart;
103: carr[offset + k] = xuarr[i] - xarr[i];
104: }
105: }
107: if (pdipm->Nxlb) {
108: /* (2.c) Update xlb */
109: offset += pdipm->nxub;
110: PetscCall(ISGetIndices(pdipm->isxlb, &lbptr)); /* global indices in x */
111: for (k = 0; k < pdipm->nxlb; k++) {
112: i = lbptr[k] - xstart;
113: carr[offset + k] = xarr[i] - xlarr[i];
114: }
115: }
117: if (pdipm->Nxbox) {
118: /* (2.d) Update xbox */
119: offset += pdipm->nxlb;
120: offset1 = offset + pdipm->nxbox;
121: PetscCall(ISGetIndices(pdipm->isxbox, &bxptr)); /* global indices in x */
122: for (k = 0; k < pdipm->nxbox; k++) {
123: i = bxptr[k] - xstart; /* local indices in x */
124: carr[offset + k] = xuarr[i] - xarr[i];
125: carr[offset1 + k] = xarr[i] - xlarr[i];
126: }
127: }
128: PetscCall(VecRestoreArrayWrite(pdipm->ci, &carr));
130: /* Restoring Vectors */
131: PetscCall(VecRestoreArrayRead(x, &xarr));
132: PetscCall(VecRestoreArrayRead(tao->XU, &xuarr));
133: PetscCall(VecRestoreArrayRead(tao->XL, &xlarr));
134: PetscFunctionReturn(PETSC_SUCCESS);
135: }
137: /*
138: TaoPDIPMSetUpBounds - Create upper and lower bound vectors of x
140: Collective
142: Input Parameter:
143: . tao - holds pdipm and XL & XU
145: Level: beginner
147: .seealso: `TaoPDIPMUpdateConstraints`
148: */
149: static PetscErrorCode TaoPDIPMSetUpBounds(Tao tao)
150: {
151: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
152: const PetscScalar *xl, *xu;
153: PetscInt n, *ixlb, *ixub, *ixfixed, *ixfree, *ixbox, i, low, high, idx;
154: MPI_Comm comm;
155: PetscInt sendbuf[5], recvbuf[5];
157: PetscFunctionBegin;
158: /* Creates upper and lower bounds vectors on x, if not created already */
159: PetscCall(TaoComputeVariableBounds(tao));
161: PetscCall(VecGetLocalSize(tao->XL, &n));
162: PetscCall(PetscMalloc5(n, &ixlb, n, &ixub, n, &ixfree, n, &ixfixed, n, &ixbox));
164: PetscCall(VecGetOwnershipRange(tao->XL, &low, &high));
165: PetscCall(VecGetArrayRead(tao->XL, &xl));
166: PetscCall(VecGetArrayRead(tao->XU, &xu));
167: for (i = 0; i < n; i++) {
168: idx = low + i;
169: if ((PetscRealPart(xl[i]) > PETSC_NINFINITY) && (PetscRealPart(xu[i]) < PETSC_INFINITY)) {
170: if (PetscRealPart(xl[i]) == PetscRealPart(xu[i])) {
171: ixfixed[pdipm->nxfixed++] = idx;
172: } else ixbox[pdipm->nxbox++] = idx;
173: } else {
174: if ((PetscRealPart(xl[i]) > PETSC_NINFINITY) && (PetscRealPart(xu[i]) >= PETSC_INFINITY)) {
175: ixlb[pdipm->nxlb++] = idx;
176: } else if ((PetscRealPart(xl[i]) <= PETSC_NINFINITY) && (PetscRealPart(xu[i]) < PETSC_INFINITY)) {
177: ixub[pdipm->nxlb++] = idx;
178: } else ixfree[pdipm->nxfree++] = idx;
179: }
180: }
181: PetscCall(VecRestoreArrayRead(tao->XL, &xl));
182: PetscCall(VecRestoreArrayRead(tao->XU, &xu));
184: PetscCall(PetscObjectGetComm((PetscObject)tao, &comm));
185: sendbuf[0] = pdipm->nxlb;
186: sendbuf[1] = pdipm->nxub;
187: sendbuf[2] = pdipm->nxfixed;
188: sendbuf[3] = pdipm->nxbox;
189: sendbuf[4] = pdipm->nxfree;
191: PetscCallMPI(MPI_Allreduce(sendbuf, recvbuf, 5, MPIU_INT, MPI_SUM, comm));
192: pdipm->Nxlb = recvbuf[0];
193: pdipm->Nxub = recvbuf[1];
194: pdipm->Nxfixed = recvbuf[2];
195: pdipm->Nxbox = recvbuf[3];
196: pdipm->Nxfree = recvbuf[4];
198: if (pdipm->Nxlb) PetscCall(ISCreateGeneral(comm, pdipm->nxlb, ixlb, PETSC_COPY_VALUES, &pdipm->isxlb));
199: if (pdipm->Nxub) PetscCall(ISCreateGeneral(comm, pdipm->nxub, ixub, PETSC_COPY_VALUES, &pdipm->isxub));
200: if (pdipm->Nxfixed) PetscCall(ISCreateGeneral(comm, pdipm->nxfixed, ixfixed, PETSC_COPY_VALUES, &pdipm->isxfixed));
201: if (pdipm->Nxbox) PetscCall(ISCreateGeneral(comm, pdipm->nxbox, ixbox, PETSC_COPY_VALUES, &pdipm->isxbox));
202: if (pdipm->Nxfree) PetscCall(ISCreateGeneral(comm, pdipm->nxfree, ixfree, PETSC_COPY_VALUES, &pdipm->isxfree));
203: PetscCall(PetscFree5(ixlb, ixub, ixfixed, ixbox, ixfree));
204: PetscFunctionReturn(PETSC_SUCCESS);
205: }
207: /*
208: TaoPDIPMInitializeSolution - Initialize PDIPM solution X = [x; lambdae; lambdai; z].
209: X consists of four subvectors in the order [x; lambdae; lambdai; z]. These
210: four subvectors need to be initialized and its values copied over to X. Instead
211: of copying, we use VecPlace/ResetArray functions to share the memory locations for
212: X and the subvectors
214: Collective
216: Input Parameter:
217: . tao - Tao context
219: Level: beginner
220: */
221: static PetscErrorCode TaoPDIPMInitializeSolution(Tao tao)
222: {
223: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
224: PetscScalar *Xarr, *z, *lambdai;
225: PetscInt i;
226: const PetscScalar *xarr, *h;
228: PetscFunctionBegin;
229: PetscCall(VecGetArrayWrite(pdipm->X, &Xarr));
231: /* Set Initialize X.x = tao->solution */
232: PetscCall(VecGetArrayRead(tao->solution, &xarr));
233: PetscCall(PetscMemcpy(Xarr, xarr, pdipm->nx * sizeof(PetscScalar)));
234: PetscCall(VecRestoreArrayRead(tao->solution, &xarr));
236: /* Initialize X.lambdae = 0.0 */
237: if (pdipm->lambdae) PetscCall(VecSet(pdipm->lambdae, 0.0));
239: /* Initialize X.lambdai = push_init_lambdai, X.z = push_init_slack */
240: if (pdipm->Nci) {
241: PetscCall(VecSet(pdipm->lambdai, pdipm->push_init_lambdai));
242: PetscCall(VecSet(pdipm->z, pdipm->push_init_slack));
244: /* Additional modification for X.lambdai and X.z */
245: PetscCall(VecGetArrayWrite(pdipm->lambdai, &lambdai));
246: PetscCall(VecGetArrayWrite(pdipm->z, &z));
247: if (pdipm->Nh) {
248: PetscCall(VecGetArrayRead(tao->constraints_inequality, &h));
249: for (i = 0; i < pdipm->nh; i++) {
250: if (h[i] < -pdipm->push_init_slack) z[i] = -h[i];
251: if (pdipm->mu / z[i] > pdipm->push_init_lambdai) lambdai[i] = pdipm->mu / z[i];
252: }
253: PetscCall(VecRestoreArrayRead(tao->constraints_inequality, &h));
254: }
255: PetscCall(VecRestoreArrayWrite(pdipm->lambdai, &lambdai));
256: PetscCall(VecRestoreArrayWrite(pdipm->z, &z));
257: }
259: PetscCall(VecRestoreArrayWrite(pdipm->X, &Xarr));
260: PetscFunctionReturn(PETSC_SUCCESS);
261: }
263: /*
264: TaoSNESJacobian_PDIPM - Evaluate the Hessian matrix at X
266: Input Parameter:
267: snes - SNES context
268: X - KKT Vector
269: *ctx - pdipm context
271: Output Parameter:
272: J - Hessian matrix
273: Jpre - Preconditioner
274: */
275: static PetscErrorCode TaoSNESJacobian_PDIPM(SNES snes, Vec X, Mat J, Mat Jpre, void *ctx)
276: {
277: Tao tao = (Tao)ctx;
278: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
279: PetscInt i, row, cols[2], Jrstart, rjstart, nc, j;
280: const PetscInt *aj, *ranges, *Jranges, *rranges, *cranges;
281: const PetscScalar *Xarr, *aa;
282: PetscScalar vals[2];
283: PetscInt proc, nx_all, *nce_all = pdipm->nce_all;
284: MPI_Comm comm;
285: PetscMPIInt rank, size;
287: PetscFunctionBegin;
288: PetscCall(PetscObjectGetComm((PetscObject)snes, &comm));
289: PetscCallMPI(MPI_Comm_rank(comm, &rank));
290: PetscCallMPI(MPI_Comm_rank(comm, &size));
292: PetscCall(MatGetOwnershipRanges(Jpre, &Jranges));
293: PetscCall(MatGetOwnershipRange(Jpre, &Jrstart, NULL));
294: PetscCall(MatGetOwnershipRangesColumn(tao->hessian, &rranges));
295: PetscCall(MatGetOwnershipRangesColumn(tao->hessian, &cranges));
297: PetscCall(VecGetArrayRead(X, &Xarr));
299: /* (1) insert Z and Ci to the 4th block of Jpre -- overwrite existing values */
300: if (pdipm->solve_symmetric_kkt) { /* 1 for eq 17 revised pdipm doc 0 for eq 18 (symmetric KKT) */
301: vals[0] = 1.0;
302: for (i = 0; i < pdipm->nci; i++) {
303: row = Jrstart + pdipm->off_z + i;
304: cols[0] = Jrstart + pdipm->off_lambdai + i;
305: cols[1] = row;
306: vals[1] = Xarr[pdipm->off_lambdai + i] / Xarr[pdipm->off_z + i];
307: PetscCall(MatSetValues(Jpre, 1, &row, 2, cols, vals, INSERT_VALUES));
308: }
309: } else {
310: for (i = 0; i < pdipm->nci; i++) {
311: row = Jrstart + pdipm->off_z + i;
312: cols[0] = Jrstart + pdipm->off_lambdai + i;
313: cols[1] = row;
314: vals[0] = Xarr[pdipm->off_z + i];
315: vals[1] = Xarr[pdipm->off_lambdai + i];
316: PetscCall(MatSetValues(Jpre, 1, &row, 2, cols, vals, INSERT_VALUES));
317: }
318: }
320: /* (2) insert 2nd row block of Jpre: [ grad g, 0, 0, 0] */
321: if (pdipm->Ng) {
322: PetscCall(MatGetOwnershipRange(tao->jacobian_equality, &rjstart, NULL));
323: for (i = 0; i < pdipm->ng; i++) {
324: row = Jrstart + pdipm->off_lambdae + i;
326: PetscCall(MatGetRow(tao->jacobian_equality, i + rjstart, &nc, &aj, &aa));
327: proc = 0;
328: for (j = 0; j < nc; j++) {
329: while (aj[j] >= cranges[proc + 1]) proc++;
330: cols[0] = aj[j] - cranges[proc] + Jranges[proc];
331: PetscCall(MatSetValue(Jpre, row, cols[0], aa[j], INSERT_VALUES));
332: }
333: PetscCall(MatRestoreRow(tao->jacobian_equality, i + rjstart, &nc, &aj, &aa));
334: if (pdipm->kkt_pd) {
335: /* add shift \delta_c */
336: PetscCall(MatSetValue(Jpre, row, row, -pdipm->deltac, INSERT_VALUES));
337: }
338: }
339: }
341: /* (3) insert 3rd row block of Jpre: [ -grad h, 0, deltac, I] */
342: if (pdipm->Nh) {
343: PetscCall(MatGetOwnershipRange(tao->jacobian_inequality, &rjstart, NULL));
344: for (i = 0; i < pdipm->nh; i++) {
345: row = Jrstart + pdipm->off_lambdai + i;
346: PetscCall(MatGetRow(tao->jacobian_inequality, i + rjstart, &nc, &aj, &aa));
347: proc = 0;
348: for (j = 0; j < nc; j++) {
349: while (aj[j] >= cranges[proc + 1]) proc++;
350: cols[0] = aj[j] - cranges[proc] + Jranges[proc];
351: PetscCall(MatSetValue(Jpre, row, cols[0], -aa[j], INSERT_VALUES));
352: }
353: PetscCall(MatRestoreRow(tao->jacobian_inequality, i + rjstart, &nc, &aj, &aa));
354: if (pdipm->kkt_pd) {
355: /* add shift \delta_c */
356: PetscCall(MatSetValue(Jpre, row, row, -pdipm->deltac, INSERT_VALUES));
357: }
358: }
359: }
361: /* (4) insert 1st row block of Jpre: [Wxx, grad g', -grad h', 0] */
362: if (pdipm->Ng) { /* grad g' */
363: PetscCall(MatTranspose(tao->jacobian_equality, MAT_REUSE_MATRIX, &pdipm->jac_equality_trans));
364: }
365: if (pdipm->Nh) { /* grad h' */
366: PetscCall(MatTranspose(tao->jacobian_inequality, MAT_REUSE_MATRIX, &pdipm->jac_inequality_trans));
367: }
369: PetscCall(VecPlaceArray(pdipm->x, Xarr));
370: PetscCall(TaoComputeHessian(tao, pdipm->x, tao->hessian, tao->hessian_pre));
371: PetscCall(VecResetArray(pdipm->x));
373: PetscCall(MatGetOwnershipRange(tao->hessian, &rjstart, NULL));
374: for (i = 0; i < pdipm->nx; i++) {
375: row = Jrstart + i;
377: /* insert Wxx = fxx + ... -- provided by user */
378: PetscCall(MatGetRow(tao->hessian, i + rjstart, &nc, &aj, &aa));
379: proc = 0;
380: for (j = 0; j < nc; j++) {
381: while (aj[j] >= cranges[proc + 1]) proc++;
382: cols[0] = aj[j] - cranges[proc] + Jranges[proc];
383: if (row == cols[0] && pdipm->kkt_pd) {
384: /* add shift deltaw to Wxx component */
385: PetscCall(MatSetValue(Jpre, row, cols[0], aa[j] + pdipm->deltaw, INSERT_VALUES));
386: } else {
387: PetscCall(MatSetValue(Jpre, row, cols[0], aa[j], INSERT_VALUES));
388: }
389: }
390: PetscCall(MatRestoreRow(tao->hessian, i + rjstart, &nc, &aj, &aa));
392: /* insert grad g' */
393: if (pdipm->ng) {
394: PetscCall(MatGetRow(pdipm->jac_equality_trans, i + rjstart, &nc, &aj, &aa));
395: PetscCall(MatGetOwnershipRanges(tao->jacobian_equality, &ranges));
396: proc = 0;
397: for (j = 0; j < nc; j++) {
398: /* find row ownership of */
399: while (aj[j] >= ranges[proc + 1]) proc++;
400: nx_all = rranges[proc + 1] - rranges[proc];
401: cols[0] = aj[j] - ranges[proc] + Jranges[proc] + nx_all;
402: PetscCall(MatSetValue(Jpre, row, cols[0], aa[j], INSERT_VALUES));
403: }
404: PetscCall(MatRestoreRow(pdipm->jac_equality_trans, i + rjstart, &nc, &aj, &aa));
405: }
407: /* insert -grad h' */
408: if (pdipm->nh) {
409: PetscCall(MatGetRow(pdipm->jac_inequality_trans, i + rjstart, &nc, &aj, &aa));
410: PetscCall(MatGetOwnershipRanges(tao->jacobian_inequality, &ranges));
411: proc = 0;
412: for (j = 0; j < nc; j++) {
413: /* find row ownership of */
414: while (aj[j] >= ranges[proc + 1]) proc++;
415: nx_all = rranges[proc + 1] - rranges[proc];
416: cols[0] = aj[j] - ranges[proc] + Jranges[proc] + nx_all + nce_all[proc];
417: PetscCall(MatSetValue(Jpre, row, cols[0], -aa[j], INSERT_VALUES));
418: }
419: PetscCall(MatRestoreRow(pdipm->jac_inequality_trans, i + rjstart, &nc, &aj, &aa));
420: }
421: }
422: PetscCall(VecRestoreArrayRead(X, &Xarr));
424: /* (6) assemble Jpre and J */
425: PetscCall(MatAssemblyBegin(Jpre, MAT_FINAL_ASSEMBLY));
426: PetscCall(MatAssemblyEnd(Jpre, MAT_FINAL_ASSEMBLY));
428: if (J != Jpre) {
429: PetscCall(MatAssemblyBegin(J, MAT_FINAL_ASSEMBLY));
430: PetscCall(MatAssemblyEnd(J, MAT_FINAL_ASSEMBLY));
431: }
432: PetscFunctionReturn(PETSC_SUCCESS);
433: }
435: /*
436: TaoSnesFunction_PDIPM - Evaluate KKT function at X
438: Input Parameter:
439: snes - SNES context
440: X - KKT Vector
441: *ctx - pdipm
443: Output Parameter:
444: F - Updated Lagrangian vector
445: */
446: static PetscErrorCode TaoSNESFunction_PDIPM(SNES snes, Vec X, Vec F, void *ctx)
447: {
448: Tao tao = (Tao)ctx;
449: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
450: PetscScalar *Farr;
451: Vec x, L1;
452: PetscInt i;
453: const PetscScalar *Xarr, *carr, *zarr, *larr;
455: PetscFunctionBegin;
456: PetscCall(VecSet(F, 0.0));
458: PetscCall(VecGetArrayRead(X, &Xarr));
459: PetscCall(VecGetArrayWrite(F, &Farr));
461: /* (0) Evaluate f, fx, gradG, gradH at X.x Note: pdipm->x is not changed below */
462: x = pdipm->x;
463: PetscCall(VecPlaceArray(x, Xarr));
464: PetscCall(TaoPDIPMEvaluateFunctionsAndJacobians(tao, x));
466: /* Update ce, ci, and Jci at X.x */
467: PetscCall(TaoPDIPMUpdateConstraints(tao, x));
468: PetscCall(VecResetArray(x));
470: /* (1) L1 = fx + (gradG'*DE + Jce_xfixed'*lambdae_xfixed) - (gradH'*DI + Jci_xb'*lambdai_xb) */
471: L1 = pdipm->x;
472: PetscCall(VecPlaceArray(L1, Farr)); /* L1 = 0.0 */
473: if (pdipm->Nci) {
474: if (pdipm->Nh) {
475: /* L1 += gradH'*DI. Note: tao->DI is not changed below */
476: PetscCall(VecPlaceArray(tao->DI, Xarr + pdipm->off_lambdai));
477: PetscCall(MatMultTransposeAdd(tao->jacobian_inequality, tao->DI, L1, L1));
478: PetscCall(VecResetArray(tao->DI));
479: }
481: /* L1 += Jci_xb'*lambdai_xb */
482: PetscCall(VecPlaceArray(pdipm->lambdai_xb, Xarr + pdipm->off_lambdai + pdipm->nh));
483: PetscCall(MatMultTransposeAdd(pdipm->Jci_xb, pdipm->lambdai_xb, L1, L1));
484: PetscCall(VecResetArray(pdipm->lambdai_xb));
486: /* L1 = - (gradH'*DI + Jci_xb'*lambdai_xb) */
487: PetscCall(VecScale(L1, -1.0));
488: }
490: /* L1 += fx */
491: PetscCall(VecAXPY(L1, 1.0, tao->gradient));
493: if (pdipm->Nce) {
494: if (pdipm->Ng) {
495: /* L1 += gradG'*DE. Note: tao->DE is not changed below */
496: PetscCall(VecPlaceArray(tao->DE, Xarr + pdipm->off_lambdae));
497: PetscCall(MatMultTransposeAdd(tao->jacobian_equality, tao->DE, L1, L1));
498: PetscCall(VecResetArray(tao->DE));
499: }
500: if (pdipm->Nxfixed) {
501: /* L1 += Jce_xfixed'*lambdae_xfixed */
502: PetscCall(VecPlaceArray(pdipm->lambdae_xfixed, Xarr + pdipm->off_lambdae + pdipm->ng));
503: PetscCall(MatMultTransposeAdd(pdipm->Jce_xfixed, pdipm->lambdae_xfixed, L1, L1));
504: PetscCall(VecResetArray(pdipm->lambdae_xfixed));
505: }
506: }
507: PetscCall(VecResetArray(L1));
509: /* (2) L2 = ce(x) */
510: if (pdipm->Nce) {
511: PetscCall(VecGetArrayRead(pdipm->ce, &carr));
512: for (i = 0; i < pdipm->nce; i++) Farr[pdipm->off_lambdae + i] = carr[i];
513: PetscCall(VecRestoreArrayRead(pdipm->ce, &carr));
514: }
516: if (pdipm->Nci) {
517: if (pdipm->solve_symmetric_kkt) {
518: /* (3) L3 = z - ci(x);
519: (4) L4 = Lambdai * e - mu/z *e */
520: PetscCall(VecGetArrayRead(pdipm->ci, &carr));
521: larr = Xarr + pdipm->off_lambdai;
522: zarr = Xarr + pdipm->off_z;
523: for (i = 0; i < pdipm->nci; i++) {
524: Farr[pdipm->off_lambdai + i] = zarr[i] - carr[i];
525: Farr[pdipm->off_z + i] = larr[i] - pdipm->mu / zarr[i];
526: }
527: PetscCall(VecRestoreArrayRead(pdipm->ci, &carr));
528: } else {
529: /* (3) L3 = z - ci(x);
530: (4) L4 = Z * Lambdai * e - mu * e */
531: PetscCall(VecGetArrayRead(pdipm->ci, &carr));
532: larr = Xarr + pdipm->off_lambdai;
533: zarr = Xarr + pdipm->off_z;
534: for (i = 0; i < pdipm->nci; i++) {
535: Farr[pdipm->off_lambdai + i] = zarr[i] - carr[i];
536: Farr[pdipm->off_z + i] = zarr[i] * larr[i] - pdipm->mu;
537: }
538: PetscCall(VecRestoreArrayRead(pdipm->ci, &carr));
539: }
540: }
542: PetscCall(VecRestoreArrayRead(X, &Xarr));
543: PetscCall(VecRestoreArrayWrite(F, &Farr));
544: PetscFunctionReturn(PETSC_SUCCESS);
545: }
547: /*
548: Evaluate F(X); then update update tao->gnorm0, tao->step = mu,
549: tao->residual = norm2(F_x,F_z) and tao->cnorm = norm2(F_ce,F_ci).
550: */
551: static PetscErrorCode TaoSNESFunction_PDIPM_residual(SNES snes, Vec X, Vec F, void *ctx)
552: {
553: Tao tao = (Tao)ctx;
554: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
555: PetscScalar *Farr, *tmparr;
556: Vec L1;
557: PetscInt i;
558: PetscReal res[2], cnorm[2];
559: const PetscScalar *Xarr = NULL;
561: PetscFunctionBegin;
562: PetscCall(TaoSNESFunction_PDIPM(snes, X, F, (void *)tao));
563: PetscCall(VecGetArrayWrite(F, &Farr));
564: PetscCall(VecGetArrayRead(X, &Xarr));
566: /* compute res[0] = norm2(F_x) */
567: L1 = pdipm->x;
568: PetscCall(VecPlaceArray(L1, Farr));
569: PetscCall(VecNorm(L1, NORM_2, &res[0]));
570: PetscCall(VecResetArray(L1));
572: /* compute res[1] = norm2(F_z), cnorm[1] = norm2(F_ci) */
573: if (pdipm->z) {
574: if (pdipm->solve_symmetric_kkt) {
575: PetscCall(VecPlaceArray(pdipm->z, Farr + pdipm->off_z));
576: if (pdipm->Nci) {
577: PetscCall(VecGetArrayWrite(pdipm->z, &tmparr));
578: for (i = 0; i < pdipm->nci; i++) tmparr[i] *= Xarr[pdipm->off_z + i];
579: PetscCall(VecRestoreArrayWrite(pdipm->z, &tmparr));
580: }
582: PetscCall(VecNorm(pdipm->z, NORM_2, &res[1]));
584: if (pdipm->Nci) {
585: PetscCall(VecGetArrayWrite(pdipm->z, &tmparr));
586: for (i = 0; i < pdipm->nci; i++) tmparr[i] /= Xarr[pdipm->off_z + i];
587: PetscCall(VecRestoreArrayWrite(pdipm->z, &tmparr));
588: }
589: PetscCall(VecResetArray(pdipm->z));
590: } else { /* !solve_symmetric_kkt */
591: PetscCall(VecPlaceArray(pdipm->z, Farr + pdipm->off_z));
592: PetscCall(VecNorm(pdipm->z, NORM_2, &res[1]));
593: PetscCall(VecResetArray(pdipm->z));
594: }
596: PetscCall(VecPlaceArray(pdipm->ci, Farr + pdipm->off_lambdai));
597: PetscCall(VecNorm(pdipm->ci, NORM_2, &cnorm[1]));
598: PetscCall(VecResetArray(pdipm->ci));
599: } else {
600: res[1] = 0.0;
601: cnorm[1] = 0.0;
602: }
604: /* compute cnorm[0] = norm2(F_ce) */
605: if (pdipm->Nce) {
606: PetscCall(VecPlaceArray(pdipm->ce, Farr + pdipm->off_lambdae));
607: PetscCall(VecNorm(pdipm->ce, NORM_2, &cnorm[0]));
608: PetscCall(VecResetArray(pdipm->ce));
609: } else cnorm[0] = 0.0;
611: PetscCall(VecRestoreArrayWrite(F, &Farr));
612: PetscCall(VecRestoreArrayRead(X, &Xarr));
614: tao->gnorm0 = tao->residual;
615: tao->residual = PetscSqrtReal(res[0] * res[0] + res[1] * res[1]);
616: tao->cnorm = PetscSqrtReal(cnorm[0] * cnorm[0] + cnorm[1] * cnorm[1]);
617: tao->step = pdipm->mu;
618: PetscFunctionReturn(PETSC_SUCCESS);
619: }
621: /*
622: KKTAddShifts - Check the inertia of Cholesky factor of KKT matrix.
623: If it does not match the numbers of prime and dual variables, add shifts to the KKT matrix.
624: */
625: static PetscErrorCode KKTAddShifts(Tao tao, SNES snes, Vec X)
626: {
627: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
628: KSP ksp;
629: PC pc;
630: Mat Factor;
631: PetscBool isCHOL;
632: PetscInt nneg, nzero, npos;
634: PetscFunctionBegin;
635: /* Get the inertia of Cholesky factor */
636: PetscCall(SNESGetKSP(snes, &ksp));
637: PetscCall(KSPGetPC(ksp, &pc));
638: PetscCall(PetscObjectTypeCompare((PetscObject)pc, PCCHOLESKY, &isCHOL));
639: if (!isCHOL) PetscFunctionReturn(PETSC_SUCCESS);
641: PetscCall(PCFactorGetMatrix(pc, &Factor));
642: PetscCall(MatGetInertia(Factor, &nneg, &nzero, &npos));
644: if (npos < pdipm->Nx + pdipm->Nci) {
645: pdipm->deltaw = PetscMax(pdipm->lastdeltaw / 3, 1.e-4 * PETSC_MACHINE_EPSILON);
646: PetscCall(PetscInfo(tao, "Test reduced deltaw=%g; previous MatInertia: nneg %" PetscInt_FMT ", nzero %" PetscInt_FMT ", npos %" PetscInt_FMT "(<%" PetscInt_FMT ")\n", (double)pdipm->deltaw, nneg, nzero, npos, pdipm->Nx + pdipm->Nci));
647: PetscCall(TaoSNESJacobian_PDIPM(snes, X, pdipm->K, pdipm->K, tao));
648: PetscCall(PCSetUp(pc));
649: PetscCall(MatGetInertia(Factor, &nneg, &nzero, &npos));
651: if (npos < pdipm->Nx + pdipm->Nci) {
652: pdipm->deltaw = pdipm->lastdeltaw; /* in case reduction update does not help, this prevents that step from impacting increasing update */
653: while (npos < pdipm->Nx + pdipm->Nci && pdipm->deltaw <= 1. / PETSC_SMALL) { /* increase deltaw */
654: PetscCall(PetscInfo(tao, " deltaw=%g fails, MatInertia: nneg %" PetscInt_FMT ", nzero %" PetscInt_FMT ", npos %" PetscInt_FMT "(<%" PetscInt_FMT ")\n", (double)pdipm->deltaw, nneg, nzero, npos, pdipm->Nx + pdipm->Nci));
655: pdipm->deltaw = PetscMin(8 * pdipm->deltaw, PetscPowReal(10, 20));
656: PetscCall(TaoSNESJacobian_PDIPM(snes, X, pdipm->K, pdipm->K, tao));
657: PetscCall(PCSetUp(pc));
658: PetscCall(MatGetInertia(Factor, &nneg, &nzero, &npos));
659: }
661: PetscCheck(pdipm->deltaw < 1. / PETSC_SMALL, PetscObjectComm((PetscObject)tao), PETSC_ERR_CONV_FAILED, "Reached maximum delta w will not converge, try different initial x0");
663: PetscCall(PetscInfo(tao, "Updated deltaw %g\n", (double)pdipm->deltaw));
664: pdipm->lastdeltaw = pdipm->deltaw;
665: pdipm->deltaw = 0.0;
666: }
667: }
669: if (nzero) { /* Jacobian is singular */
670: if (pdipm->deltac == 0.0) {
671: pdipm->deltac = PETSC_SQRT_MACHINE_EPSILON;
672: } else {
673: pdipm->deltac = pdipm->deltac * PetscPowReal(pdipm->mu, .25);
674: }
675: PetscCall(PetscInfo(tao, "Updated deltac=%g, MatInertia: nneg %" PetscInt_FMT ", nzero %" PetscInt_FMT "(!=0), npos %" PetscInt_FMT "\n", (double)pdipm->deltac, nneg, nzero, npos));
676: PetscCall(TaoSNESJacobian_PDIPM(snes, X, pdipm->K, pdipm->K, tao));
677: PetscCall(PCSetUp(pc));
678: PetscCall(MatGetInertia(Factor, &nneg, &nzero, &npos));
679: }
680: PetscFunctionReturn(PETSC_SUCCESS);
681: }
683: /*
684: PCPreSolve_PDIPM -- called between MatFactorNumeric() and MatSolve()
685: */
686: PetscErrorCode PCPreSolve_PDIPM(PC pc, KSP ksp)
687: {
688: Tao tao;
689: TAO_PDIPM *pdipm;
691: PetscFunctionBegin;
692: PetscCall(KSPGetApplicationContext(ksp, &tao));
693: pdipm = (TAO_PDIPM *)tao->data;
694: PetscCall(KKTAddShifts(tao, pdipm->snes, pdipm->X));
695: PetscFunctionReturn(PETSC_SUCCESS);
696: }
698: /*
699: SNESLineSearch_PDIPM - Custom line search used with PDIPM.
701: Collective
703: Notes:
704: This routine employs a simple backtracking line-search to keep
705: the slack variables (z) and inequality constraints Lagrange multipliers
706: (lambdai) positive, i.e., z,lambdai >=0. It does this by calculating scalars
707: alpha_p and alpha_d to keep z,lambdai non-negative. The decision (x), and the
708: slack variables are updated as X = X - alpha_d*dx. The constraint multipliers
709: are updated as Lambdai = Lambdai + alpha_p*dLambdai. The barrier parameter mu
710: is also updated as mu = mu + z'lambdai/Nci
711: */
712: static PetscErrorCode SNESLineSearch_PDIPM(SNESLineSearch linesearch, void *ctx)
713: {
714: Tao tao = (Tao)ctx;
715: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
716: SNES snes;
717: Vec X, F, Y;
718: PetscInt i, iter;
719: PetscReal alpha_p = 1.0, alpha_d = 1.0, alpha[4];
720: PetscScalar *Xarr, *z, *lambdai, dot, *taosolarr;
721: const PetscScalar *dXarr, *dz, *dlambdai;
723: PetscFunctionBegin;
724: PetscCall(SNESLineSearchGetSNES(linesearch, &snes));
725: PetscCall(SNESGetIterationNumber(snes, &iter));
727: PetscCall(SNESLineSearchSetReason(linesearch, SNES_LINESEARCH_SUCCEEDED));
728: PetscCall(SNESLineSearchGetVecs(linesearch, &X, &F, &Y, NULL, NULL));
730: PetscCall(VecGetArrayWrite(X, &Xarr));
731: PetscCall(VecGetArrayRead(Y, &dXarr));
732: z = Xarr + pdipm->off_z;
733: dz = dXarr + pdipm->off_z;
734: for (i = 0; i < pdipm->nci; i++) {
735: if (z[i] - dz[i] < 0.0) alpha_p = PetscMin(alpha_p, 0.9999 * z[i] / dz[i]);
736: }
738: lambdai = Xarr + pdipm->off_lambdai;
739: dlambdai = dXarr + pdipm->off_lambdai;
741: for (i = 0; i < pdipm->nci; i++) {
742: if (lambdai[i] - dlambdai[i] < 0.0) alpha_d = PetscMin(0.9999 * lambdai[i] / dlambdai[i], alpha_d);
743: }
745: alpha[0] = alpha_p;
746: alpha[1] = alpha_d;
747: PetscCall(VecRestoreArrayRead(Y, &dXarr));
748: PetscCall(VecRestoreArrayWrite(X, &Xarr));
750: /* alpha = min(alpha) over all processes */
751: PetscCallMPI(MPI_Allreduce(alpha, alpha + 2, 2, MPIU_REAL, MPIU_MIN, PetscObjectComm((PetscObject)tao)));
753: alpha_p = alpha[2];
754: alpha_d = alpha[3];
756: /* X = X - alpha * Y */
757: PetscCall(VecGetArrayWrite(X, &Xarr));
758: PetscCall(VecGetArrayRead(Y, &dXarr));
759: for (i = 0; i < pdipm->nx; i++) Xarr[i] -= alpha_p * dXarr[i];
760: for (i = 0; i < pdipm->nce; i++) Xarr[i + pdipm->off_lambdae] -= alpha_d * dXarr[i + pdipm->off_lambdae];
762: for (i = 0; i < pdipm->nci; i++) {
763: Xarr[i + pdipm->off_lambdai] -= alpha_d * dXarr[i + pdipm->off_lambdai];
764: Xarr[i + pdipm->off_z] -= alpha_p * dXarr[i + pdipm->off_z];
765: }
766: PetscCall(VecGetArrayWrite(tao->solution, &taosolarr));
767: PetscCall(PetscMemcpy(taosolarr, Xarr, pdipm->nx * sizeof(PetscScalar)));
768: PetscCall(VecRestoreArrayWrite(tao->solution, &taosolarr));
770: PetscCall(VecRestoreArrayWrite(X, &Xarr));
771: PetscCall(VecRestoreArrayRead(Y, &dXarr));
773: /* Update mu = mu_update_factor * dot(z,lambdai)/pdipm->nci at updated X */
774: if (pdipm->z) {
775: PetscCall(VecDot(pdipm->z, pdipm->lambdai, &dot));
776: } else dot = 0.0;
778: /* if (PetscAbsReal(pdipm->gradL) < 0.9*pdipm->mu) */
779: pdipm->mu = pdipm->mu_update_factor * dot / pdipm->Nci;
781: /* Update F; get tao->residual and tao->cnorm */
782: PetscCall(TaoSNESFunction_PDIPM_residual(snes, X, F, (void *)tao));
784: tao->niter++;
785: PetscCall(TaoLogConvergenceHistory(tao, pdipm->obj, tao->residual, tao->cnorm, tao->niter));
786: PetscCall(TaoMonitor(tao, tao->niter, pdipm->obj, tao->residual, tao->cnorm, pdipm->mu));
788: PetscUseTypeMethod(tao, convergencetest, tao->cnvP);
789: if (tao->reason) PetscCall(SNESSetConvergedReason(snes, SNES_CONVERGED_FNORM_ABS));
790: PetscFunctionReturn(PETSC_SUCCESS);
791: }
793: /*
794: TaoSolve_PDIPM
796: Input Parameter:
797: tao - TAO context
799: Output Parameter:
800: tao - TAO context
801: */
802: PetscErrorCode TaoSolve_PDIPM(Tao tao)
803: {
804: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
805: SNESLineSearch linesearch; /* SNESLineSearch context */
806: Vec dummy;
808: PetscFunctionBegin;
809: PetscCheck(tao->constraints_equality || tao->constraints_inequality, PetscObjectComm((PetscObject)tao), PETSC_ERR_ARG_NULL, "Equality and inequality constraints are not set. Either set them or switch to a different algorithm");
811: /* Initialize all variables */
812: PetscCall(TaoPDIPMInitializeSolution(tao));
814: /* Set linesearch */
815: PetscCall(SNESGetLineSearch(pdipm->snes, &linesearch));
816: PetscCall(SNESLineSearchSetType(linesearch, SNESLINESEARCHSHELL));
817: PetscCall(SNESLineSearchShellSetUserFunc(linesearch, SNESLineSearch_PDIPM, tao));
818: PetscCall(SNESLineSearchSetFromOptions(linesearch));
820: tao->reason = TAO_CONTINUE_ITERATING;
822: /* -tao_monitor for iteration 0 and check convergence */
823: PetscCall(VecDuplicate(pdipm->X, &dummy));
824: PetscCall(TaoSNESFunction_PDIPM_residual(pdipm->snes, pdipm->X, dummy, (void *)tao));
826: PetscCall(TaoLogConvergenceHistory(tao, pdipm->obj, tao->residual, tao->cnorm, tao->niter));
827: PetscCall(TaoMonitor(tao, tao->niter, pdipm->obj, tao->residual, tao->cnorm, pdipm->mu));
828: PetscCall(VecDestroy(&dummy));
829: PetscUseTypeMethod(tao, convergencetest, tao->cnvP);
830: if (tao->reason) PetscCall(SNESSetConvergedReason(pdipm->snes, SNES_CONVERGED_FNORM_ABS));
832: while (tao->reason == TAO_CONTINUE_ITERATING) {
833: SNESConvergedReason reason;
834: PetscCall(SNESSolve(pdipm->snes, NULL, pdipm->X));
836: /* Check SNES convergence */
837: PetscCall(SNESGetConvergedReason(pdipm->snes, &reason));
838: if (reason < 0) PetscCall(PetscPrintf(PetscObjectComm((PetscObject)pdipm->snes), "SNES solve did not converged due to reason %s\n", SNESConvergedReasons[reason]));
840: /* Check TAO convergence */
841: PetscCheck(!PetscIsInfOrNanReal(pdipm->obj), PETSC_COMM_SELF, PETSC_ERR_SUP, "User-provided compute function generated Inf or NaN");
842: }
843: PetscFunctionReturn(PETSC_SUCCESS);
844: }
846: /*
847: TaoView_PDIPM - View PDIPM
849: Input Parameter:
850: tao - TAO object
851: viewer - PetscViewer
853: Output:
854: */
855: PetscErrorCode TaoView_PDIPM(Tao tao, PetscViewer viewer)
856: {
857: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
859: PetscFunctionBegin;
860: tao->constrained = PETSC_TRUE;
861: PetscCall(PetscViewerASCIIPushTab(viewer));
862: PetscCall(PetscViewerASCIIPrintf(viewer, "Number of prime=%" PetscInt_FMT ", Number of dual=%" PetscInt_FMT "\n", pdipm->Nx + pdipm->Nci, pdipm->Nce + pdipm->Nci));
863: if (pdipm->kkt_pd) PetscCall(PetscViewerASCIIPrintf(viewer, "KKT shifts deltaw=%g, deltac=%g\n", (double)pdipm->deltaw, (double)pdipm->deltac));
864: PetscCall(PetscViewerASCIIPopTab(viewer));
865: PetscFunctionReturn(PETSC_SUCCESS);
866: }
868: /*
869: TaoSetup_PDIPM - Sets up tao and pdipm
871: Input Parameter:
872: tao - TAO object
874: Output: pdipm - initialized object
875: */
876: PetscErrorCode TaoSetup_PDIPM(Tao tao)
877: {
878: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
879: MPI_Comm comm;
880: PetscMPIInt size;
881: PetscInt row, col, Jcrstart, Jcrend, k, tmp, nc, proc, *nh_all, *ng_all;
882: PetscInt offset, *xa, *xb, i, j, rstart, rend;
883: PetscScalar one = 1.0, neg_one = -1.0;
884: const PetscInt *cols, *rranges, *cranges, *aj, *ranges;
885: const PetscScalar *aa, *Xarr;
886: Mat J;
887: Mat Jce_xfixed_trans, Jci_xb_trans;
888: PetscInt *dnz, *onz, rjstart, nx_all, *nce_all, *Jranges, cols1[2];
890: PetscFunctionBegin;
891: PetscCall(PetscObjectGetComm((PetscObject)tao, &comm));
892: PetscCallMPI(MPI_Comm_size(comm, &size));
894: /* (1) Setup Bounds and create Tao vectors */
895: PetscCall(TaoPDIPMSetUpBounds(tao));
897: if (!tao->gradient) {
898: PetscCall(VecDuplicate(tao->solution, &tao->gradient));
899: PetscCall(VecDuplicate(tao->solution, &tao->stepdirection));
900: }
902: /* (2) Get sizes */
903: /* Size of vector x - This is set by TaoSetSolution */
904: PetscCall(VecGetSize(tao->solution, &pdipm->Nx));
905: PetscCall(VecGetLocalSize(tao->solution, &pdipm->nx));
907: /* Size of equality constraints and vectors */
908: if (tao->constraints_equality) {
909: PetscCall(VecGetSize(tao->constraints_equality, &pdipm->Ng));
910: PetscCall(VecGetLocalSize(tao->constraints_equality, &pdipm->ng));
911: } else {
912: pdipm->ng = pdipm->Ng = 0;
913: }
915: pdipm->nce = pdipm->ng + pdipm->nxfixed;
916: pdipm->Nce = pdipm->Ng + pdipm->Nxfixed;
918: /* Size of inequality constraints and vectors */
919: if (tao->constraints_inequality) {
920: PetscCall(VecGetSize(tao->constraints_inequality, &pdipm->Nh));
921: PetscCall(VecGetLocalSize(tao->constraints_inequality, &pdipm->nh));
922: } else {
923: pdipm->nh = pdipm->Nh = 0;
924: }
926: pdipm->nci = pdipm->nh + pdipm->nxlb + pdipm->nxub + 2 * pdipm->nxbox;
927: pdipm->Nci = pdipm->Nh + pdipm->Nxlb + pdipm->Nxub + 2 * pdipm->Nxbox;
929: /* Full size of the KKT system to be solved */
930: pdipm->n = pdipm->nx + pdipm->nce + 2 * pdipm->nci;
931: pdipm->N = pdipm->Nx + pdipm->Nce + 2 * pdipm->Nci;
933: /* (3) Offsets for subvectors */
934: pdipm->off_lambdae = pdipm->nx;
935: pdipm->off_lambdai = pdipm->off_lambdae + pdipm->nce;
936: pdipm->off_z = pdipm->off_lambdai + pdipm->nci;
938: /* (4) Create vectors and subvectors */
939: /* Ce and Ci vectors */
940: PetscCall(VecCreate(comm, &pdipm->ce));
941: PetscCall(VecSetSizes(pdipm->ce, pdipm->nce, pdipm->Nce));
942: PetscCall(VecSetFromOptions(pdipm->ce));
944: PetscCall(VecCreate(comm, &pdipm->ci));
945: PetscCall(VecSetSizes(pdipm->ci, pdipm->nci, pdipm->Nci));
946: PetscCall(VecSetFromOptions(pdipm->ci));
948: /* X=[x; lambdae; lambdai; z] for the big KKT system */
949: PetscCall(VecCreate(comm, &pdipm->X));
950: PetscCall(VecSetSizes(pdipm->X, pdipm->n, pdipm->N));
951: PetscCall(VecSetFromOptions(pdipm->X));
953: /* Subvectors; they share local arrays with X */
954: PetscCall(VecGetArrayRead(pdipm->X, &Xarr));
955: /* x shares local array with X.x */
956: if (pdipm->Nx) PetscCall(VecCreateMPIWithArray(comm, 1, pdipm->nx, pdipm->Nx, Xarr, &pdipm->x));
958: /* lambdae shares local array with X.lambdae */
959: if (pdipm->Nce) PetscCall(VecCreateMPIWithArray(comm, 1, pdipm->nce, pdipm->Nce, Xarr + pdipm->off_lambdae, &pdipm->lambdae));
961: /* tao->DE shares local array with X.lambdae_g */
962: if (pdipm->Ng) {
963: PetscCall(VecCreateMPIWithArray(comm, 1, pdipm->ng, pdipm->Ng, Xarr + pdipm->off_lambdae, &tao->DE));
965: PetscCall(VecCreate(comm, &pdipm->lambdae_xfixed));
966: PetscCall(VecSetSizes(pdipm->lambdae_xfixed, pdipm->nxfixed, PETSC_DECIDE));
967: PetscCall(VecSetFromOptions(pdipm->lambdae_xfixed));
968: }
970: if (pdipm->Nci) {
971: /* lambdai shares local array with X.lambdai */
972: PetscCall(VecCreateMPIWithArray(comm, 1, pdipm->nci, pdipm->Nci, Xarr + pdipm->off_lambdai, &pdipm->lambdai));
974: /* z for slack variables; it shares local array with X.z */
975: PetscCall(VecCreateMPIWithArray(comm, 1, pdipm->nci, pdipm->Nci, Xarr + pdipm->off_z, &pdipm->z));
976: }
978: /* tao->DI which shares local array with X.lambdai_h */
979: if (pdipm->Nh) PetscCall(VecCreateMPIWithArray(comm, 1, pdipm->nh, pdipm->Nh, Xarr + pdipm->off_lambdai, &tao->DI));
980: PetscCall(VecCreate(comm, &pdipm->lambdai_xb));
981: PetscCall(VecSetSizes(pdipm->lambdai_xb, (pdipm->nci - pdipm->nh), PETSC_DECIDE));
982: PetscCall(VecSetFromOptions(pdipm->lambdai_xb));
984: PetscCall(VecRestoreArrayRead(pdipm->X, &Xarr));
986: /* (5) Create Jacobians Jce_xfixed and Jci */
987: /* (5.1) PDIPM Jacobian of equality bounds cebound(x) = J_nxfixed */
988: if (pdipm->Nxfixed) {
989: /* Create Jce_xfixed */
990: PetscCall(MatCreate(comm, &pdipm->Jce_xfixed));
991: PetscCall(MatSetSizes(pdipm->Jce_xfixed, pdipm->nxfixed, pdipm->nx, PETSC_DECIDE, pdipm->Nx));
992: PetscCall(MatSetFromOptions(pdipm->Jce_xfixed));
993: PetscCall(MatSeqAIJSetPreallocation(pdipm->Jce_xfixed, 1, NULL));
994: PetscCall(MatMPIAIJSetPreallocation(pdipm->Jce_xfixed, 1, NULL, 1, NULL));
996: PetscCall(MatGetOwnershipRange(pdipm->Jce_xfixed, &Jcrstart, &Jcrend));
997: PetscCall(ISGetIndices(pdipm->isxfixed, &cols));
998: k = 0;
999: for (row = Jcrstart; row < Jcrend; row++) {
1000: PetscCall(MatSetValues(pdipm->Jce_xfixed, 1, &row, 1, cols + k, &one, INSERT_VALUES));
1001: k++;
1002: }
1003: PetscCall(ISRestoreIndices(pdipm->isxfixed, &cols));
1004: PetscCall(MatAssemblyBegin(pdipm->Jce_xfixed, MAT_FINAL_ASSEMBLY));
1005: PetscCall(MatAssemblyEnd(pdipm->Jce_xfixed, MAT_FINAL_ASSEMBLY));
1006: }
1008: /* (5.2) PDIPM inequality Jacobian Jci = [tao->jacobian_inequality; ...] */
1009: PetscCall(MatCreate(comm, &pdipm->Jci_xb));
1010: PetscCall(MatSetSizes(pdipm->Jci_xb, pdipm->nci - pdipm->nh, pdipm->nx, PETSC_DECIDE, pdipm->Nx));
1011: PetscCall(MatSetFromOptions(pdipm->Jci_xb));
1012: PetscCall(MatSeqAIJSetPreallocation(pdipm->Jci_xb, 1, NULL));
1013: PetscCall(MatMPIAIJSetPreallocation(pdipm->Jci_xb, 1, NULL, 1, NULL));
1015: PetscCall(MatGetOwnershipRange(pdipm->Jci_xb, &Jcrstart, &Jcrend));
1016: offset = Jcrstart;
1017: if (pdipm->Nxub) {
1018: /* Add xub to Jci_xb */
1019: PetscCall(ISGetIndices(pdipm->isxub, &cols));
1020: k = 0;
1021: for (row = offset; row < offset + pdipm->nxub; row++) {
1022: PetscCall(MatSetValues(pdipm->Jci_xb, 1, &row, 1, cols + k, &neg_one, INSERT_VALUES));
1023: k++;
1024: }
1025: PetscCall(ISRestoreIndices(pdipm->isxub, &cols));
1026: }
1028: if (pdipm->Nxlb) {
1029: /* Add xlb to Jci_xb */
1030: PetscCall(ISGetIndices(pdipm->isxlb, &cols));
1031: k = 0;
1032: offset += pdipm->nxub;
1033: for (row = offset; row < offset + pdipm->nxlb; row++) {
1034: PetscCall(MatSetValues(pdipm->Jci_xb, 1, &row, 1, cols + k, &one, INSERT_VALUES));
1035: k++;
1036: }
1037: PetscCall(ISRestoreIndices(pdipm->isxlb, &cols));
1038: }
1040: /* Add xbox to Jci_xb */
1041: if (pdipm->Nxbox) {
1042: PetscCall(ISGetIndices(pdipm->isxbox, &cols));
1043: k = 0;
1044: offset += pdipm->nxlb;
1045: for (row = offset; row < offset + pdipm->nxbox; row++) {
1046: PetscCall(MatSetValues(pdipm->Jci_xb, 1, &row, 1, cols + k, &neg_one, INSERT_VALUES));
1047: tmp = row + pdipm->nxbox;
1048: PetscCall(MatSetValues(pdipm->Jci_xb, 1, &tmp, 1, cols + k, &one, INSERT_VALUES));
1049: k++;
1050: }
1051: PetscCall(ISRestoreIndices(pdipm->isxbox, &cols));
1052: }
1054: PetscCall(MatAssemblyBegin(pdipm->Jci_xb, MAT_FINAL_ASSEMBLY));
1055: PetscCall(MatAssemblyEnd(pdipm->Jci_xb, MAT_FINAL_ASSEMBLY));
1056: /* PetscCall(MatView(pdipm->Jci_xb,PETSC_VIEWER_STDOUT_WORLD)); */
1058: /* (6) Set up ISs for PC Fieldsplit */
1059: if (pdipm->solve_reduced_kkt) {
1060: PetscCall(PetscMalloc2(pdipm->nx + pdipm->nce, &xa, 2 * pdipm->nci, &xb));
1061: for (i = 0; i < pdipm->nx + pdipm->nce; i++) xa[i] = i;
1062: for (i = 0; i < 2 * pdipm->nci; i++) xb[i] = pdipm->off_lambdai + i;
1064: PetscCall(ISCreateGeneral(comm, pdipm->nx + pdipm->nce, xa, PETSC_OWN_POINTER, &pdipm->is1));
1065: PetscCall(ISCreateGeneral(comm, 2 * pdipm->nci, xb, PETSC_OWN_POINTER, &pdipm->is2));
1066: }
1068: /* (7) Gather offsets from all processes */
1069: PetscCall(PetscMalloc1(size, &pdipm->nce_all));
1071: /* Get rstart of KKT matrix */
1072: PetscCallMPI(MPI_Scan(&pdipm->n, &rstart, 1, MPIU_INT, MPI_SUM, comm));
1073: rstart -= pdipm->n;
1075: PetscCallMPI(MPI_Allgather(&pdipm->nce, 1, MPIU_INT, pdipm->nce_all, 1, MPIU_INT, comm));
1077: PetscCall(PetscMalloc3(size, &ng_all, size, &nh_all, size, &Jranges));
1078: PetscCallMPI(MPI_Allgather(&rstart, 1, MPIU_INT, Jranges, 1, MPIU_INT, comm));
1079: PetscCallMPI(MPI_Allgather(&pdipm->nh, 1, MPIU_INT, nh_all, 1, MPIU_INT, comm));
1080: PetscCallMPI(MPI_Allgather(&pdipm->ng, 1, MPIU_INT, ng_all, 1, MPIU_INT, comm));
1082: PetscCall(MatGetOwnershipRanges(tao->hessian, &rranges));
1083: PetscCall(MatGetOwnershipRangesColumn(tao->hessian, &cranges));
1085: if (pdipm->Ng) {
1086: PetscCall(TaoComputeJacobianEquality(tao, tao->solution, tao->jacobian_equality, tao->jacobian_equality_pre));
1087: PetscCall(MatTranspose(tao->jacobian_equality, MAT_INITIAL_MATRIX, &pdipm->jac_equality_trans));
1088: }
1089: if (pdipm->Nh) {
1090: PetscCall(TaoComputeJacobianInequality(tao, tao->solution, tao->jacobian_inequality, tao->jacobian_inequality_pre));
1091: PetscCall(MatTranspose(tao->jacobian_inequality, MAT_INITIAL_MATRIX, &pdipm->jac_inequality_trans));
1092: }
1094: /* Count dnz,onz for preallocation of KKT matrix */
1095: nce_all = pdipm->nce_all;
1097: if (pdipm->Nxfixed) PetscCall(MatTranspose(pdipm->Jce_xfixed, MAT_INITIAL_MATRIX, &Jce_xfixed_trans));
1098: PetscCall(MatTranspose(pdipm->Jci_xb, MAT_INITIAL_MATRIX, &Jci_xb_trans));
1100: MatPreallocateBegin(comm, pdipm->n, pdipm->n, dnz, onz);
1102: /* 1st row block of KKT matrix: [Wxx; gradCe'; -gradCi'; 0] */
1103: PetscCall(TaoPDIPMEvaluateFunctionsAndJacobians(tao, pdipm->x));
1104: PetscCall(TaoComputeHessian(tao, tao->solution, tao->hessian, tao->hessian_pre));
1106: /* Insert tao->hessian */
1107: PetscCall(MatGetOwnershipRange(tao->hessian, &rjstart, NULL));
1108: for (i = 0; i < pdipm->nx; i++) {
1109: row = rstart + i;
1111: PetscCall(MatGetRow(tao->hessian, i + rjstart, &nc, &aj, NULL));
1112: proc = 0;
1113: for (j = 0; j < nc; j++) {
1114: while (aj[j] >= cranges[proc + 1]) proc++;
1115: col = aj[j] - cranges[proc] + Jranges[proc];
1116: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1117: }
1118: PetscCall(MatRestoreRow(tao->hessian, i + rjstart, &nc, &aj, NULL));
1120: if (pdipm->ng) {
1121: /* Insert grad g' */
1122: PetscCall(MatGetRow(pdipm->jac_equality_trans, i + rjstart, &nc, &aj, NULL));
1123: PetscCall(MatGetOwnershipRanges(tao->jacobian_equality, &ranges));
1124: proc = 0;
1125: for (j = 0; j < nc; j++) {
1126: /* find row ownership of */
1127: while (aj[j] >= ranges[proc + 1]) proc++;
1128: nx_all = rranges[proc + 1] - rranges[proc];
1129: col = aj[j] - ranges[proc] + Jranges[proc] + nx_all;
1130: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1131: }
1132: PetscCall(MatRestoreRow(pdipm->jac_equality_trans, i + rjstart, &nc, &aj, NULL));
1133: }
1135: /* Insert Jce_xfixed^T' */
1136: if (pdipm->nxfixed) {
1137: PetscCall(MatGetRow(Jce_xfixed_trans, i + rjstart, &nc, &aj, NULL));
1138: PetscCall(MatGetOwnershipRanges(pdipm->Jce_xfixed, &ranges));
1139: proc = 0;
1140: for (j = 0; j < nc; j++) {
1141: /* find row ownership of */
1142: while (aj[j] >= ranges[proc + 1]) proc++;
1143: nx_all = rranges[proc + 1] - rranges[proc];
1144: col = aj[j] - ranges[proc] + Jranges[proc] + nx_all + ng_all[proc];
1145: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1146: }
1147: PetscCall(MatRestoreRow(Jce_xfixed_trans, i + rjstart, &nc, &aj, NULL));
1148: }
1150: if (pdipm->nh) {
1151: /* Insert -grad h' */
1152: PetscCall(MatGetRow(pdipm->jac_inequality_trans, i + rjstart, &nc, &aj, NULL));
1153: PetscCall(MatGetOwnershipRanges(tao->jacobian_inequality, &ranges));
1154: proc = 0;
1155: for (j = 0; j < nc; j++) {
1156: /* find row ownership of */
1157: while (aj[j] >= ranges[proc + 1]) proc++;
1158: nx_all = rranges[proc + 1] - rranges[proc];
1159: col = aj[j] - ranges[proc] + Jranges[proc] + nx_all + nce_all[proc];
1160: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1161: }
1162: PetscCall(MatRestoreRow(pdipm->jac_inequality_trans, i + rjstart, &nc, &aj, NULL));
1163: }
1165: /* Insert Jci_xb^T' */
1166: PetscCall(MatGetRow(Jci_xb_trans, i + rjstart, &nc, &aj, NULL));
1167: PetscCall(MatGetOwnershipRanges(pdipm->Jci_xb, &ranges));
1168: proc = 0;
1169: for (j = 0; j < nc; j++) {
1170: /* find row ownership of */
1171: while (aj[j] >= ranges[proc + 1]) proc++;
1172: nx_all = rranges[proc + 1] - rranges[proc];
1173: col = aj[j] - ranges[proc] + Jranges[proc] + nx_all + nce_all[proc] + nh_all[proc];
1174: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1175: }
1176: PetscCall(MatRestoreRow(Jci_xb_trans, i + rjstart, &nc, &aj, NULL));
1177: }
1179: /* 2nd Row block of KKT matrix: [grad Ce, deltac*I, 0, 0] */
1180: if (pdipm->Ng) {
1181: PetscCall(MatGetOwnershipRange(tao->jacobian_equality, &rjstart, NULL));
1182: for (i = 0; i < pdipm->ng; i++) {
1183: row = rstart + pdipm->off_lambdae + i;
1185: PetscCall(MatGetRow(tao->jacobian_equality, i + rjstart, &nc, &aj, NULL));
1186: proc = 0;
1187: for (j = 0; j < nc; j++) {
1188: while (aj[j] >= cranges[proc + 1]) proc++;
1189: col = aj[j] - cranges[proc] + Jranges[proc];
1190: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz)); /* grad g */
1191: }
1192: PetscCall(MatRestoreRow(tao->jacobian_equality, i + rjstart, &nc, &aj, NULL));
1193: }
1194: }
1195: /* Jce_xfixed */
1196: if (pdipm->Nxfixed) {
1197: PetscCall(MatGetOwnershipRange(pdipm->Jce_xfixed, &Jcrstart, NULL));
1198: for (i = 0; i < (pdipm->nce - pdipm->ng); i++) {
1199: row = rstart + pdipm->off_lambdae + pdipm->ng + i;
1201: PetscCall(MatGetRow(pdipm->Jce_xfixed, i + Jcrstart, &nc, &cols, NULL));
1202: PetscCheck(nc == 1, PETSC_COMM_SELF, PETSC_ERR_SUP, "nc != 1");
1204: proc = 0;
1205: j = 0;
1206: while (cols[j] >= cranges[proc + 1]) proc++;
1207: col = cols[j] - cranges[proc] + Jranges[proc];
1208: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1209: PetscCall(MatRestoreRow(pdipm->Jce_xfixed, i + Jcrstart, &nc, &cols, NULL));
1210: }
1211: }
1213: /* 3rd Row block of KKT matrix: [ gradCi, 0, deltac*I, -I] */
1214: if (pdipm->Nh) {
1215: PetscCall(MatGetOwnershipRange(tao->jacobian_inequality, &rjstart, NULL));
1216: for (i = 0; i < pdipm->nh; i++) {
1217: row = rstart + pdipm->off_lambdai + i;
1219: PetscCall(MatGetRow(tao->jacobian_inequality, i + rjstart, &nc, &aj, NULL));
1220: proc = 0;
1221: for (j = 0; j < nc; j++) {
1222: while (aj[j] >= cranges[proc + 1]) proc++;
1223: col = aj[j] - cranges[proc] + Jranges[proc];
1224: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz)); /* grad h */
1225: }
1226: PetscCall(MatRestoreRow(tao->jacobian_inequality, i + rjstart, &nc, &aj, NULL));
1227: }
1228: /* I */
1229: for (i = 0; i < pdipm->nh; i++) {
1230: row = rstart + pdipm->off_lambdai + i;
1231: col = rstart + pdipm->off_z + i;
1232: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1233: }
1234: }
1236: /* Jci_xb */
1237: PetscCall(MatGetOwnershipRange(pdipm->Jci_xb, &Jcrstart, NULL));
1238: for (i = 0; i < (pdipm->nci - pdipm->nh); i++) {
1239: row = rstart + pdipm->off_lambdai + pdipm->nh + i;
1241: PetscCall(MatGetRow(pdipm->Jci_xb, i + Jcrstart, &nc, &cols, NULL));
1242: PetscCheck(nc == 1, PETSC_COMM_SELF, PETSC_ERR_SUP, "nc != 1");
1243: proc = 0;
1244: for (j = 0; j < nc; j++) {
1245: while (cols[j] >= cranges[proc + 1]) proc++;
1246: col = cols[j] - cranges[proc] + Jranges[proc];
1247: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1248: }
1249: PetscCall(MatRestoreRow(pdipm->Jci_xb, i + Jcrstart, &nc, &cols, NULL));
1250: /* I */
1251: col = rstart + pdipm->off_z + pdipm->nh + i;
1252: PetscCall(MatPreallocateSet(row, 1, &col, dnz, onz));
1253: }
1255: /* 4-th Row block of KKT matrix: Z and Ci */
1256: for (i = 0; i < pdipm->nci; i++) {
1257: row = rstart + pdipm->off_z + i;
1258: cols1[0] = rstart + pdipm->off_lambdai + i;
1259: cols1[1] = row;
1260: PetscCall(MatPreallocateSet(row, 2, cols1, dnz, onz));
1261: }
1263: /* diagonal entry */
1264: for (i = 0; i < pdipm->n; i++) dnz[i]++; /* diagonal entry */
1266: /* Create KKT matrix */
1267: PetscCall(MatCreate(comm, &J));
1268: PetscCall(MatSetSizes(J, pdipm->n, pdipm->n, PETSC_DECIDE, PETSC_DECIDE));
1269: PetscCall(MatSetFromOptions(J));
1270: PetscCall(MatSeqAIJSetPreallocation(J, 0, dnz));
1271: PetscCall(MatMPIAIJSetPreallocation(J, 0, dnz, 0, onz));
1272: MatPreallocateEnd(dnz, onz);
1273: pdipm->K = J;
1275: /* (8) Insert constant entries to K */
1276: /* Set 0.0 to diagonal of K, so that the solver does not complain *about missing diagonal value */
1277: PetscCall(MatGetOwnershipRange(J, &rstart, &rend));
1278: for (i = rstart; i < rend; i++) PetscCall(MatSetValue(J, i, i, 0.0, INSERT_VALUES));
1279: /* In case Wxx has no diagonal entries preset set diagonal to deltaw given */
1280: if (pdipm->kkt_pd) {
1281: for (i = 0; i < pdipm->nh; i++) {
1282: row = rstart + i;
1283: PetscCall(MatSetValue(J, row, row, pdipm->deltaw, INSERT_VALUES));
1284: }
1285: }
1287: /* Row block of K: [ grad Ce, 0, 0, 0] */
1288: if (pdipm->Nxfixed) {
1289: PetscCall(MatGetOwnershipRange(pdipm->Jce_xfixed, &Jcrstart, NULL));
1290: for (i = 0; i < (pdipm->nce - pdipm->ng); i++) {
1291: row = rstart + pdipm->off_lambdae + pdipm->ng + i;
1293: PetscCall(MatGetRow(pdipm->Jce_xfixed, i + Jcrstart, &nc, &cols, &aa));
1294: proc = 0;
1295: for (j = 0; j < nc; j++) {
1296: while (cols[j] >= cranges[proc + 1]) proc++;
1297: col = cols[j] - cranges[proc] + Jranges[proc];
1298: PetscCall(MatSetValue(J, row, col, aa[j], INSERT_VALUES)); /* grad Ce */
1299: PetscCall(MatSetValue(J, col, row, aa[j], INSERT_VALUES)); /* grad Ce' */
1300: }
1301: PetscCall(MatRestoreRow(pdipm->Jce_xfixed, i + Jcrstart, &nc, &cols, &aa));
1302: }
1303: }
1305: /* Row block of K: [ -grad Ci, 0, 0, I] */
1306: PetscCall(MatGetOwnershipRange(pdipm->Jci_xb, &Jcrstart, NULL));
1307: for (i = 0; i < pdipm->nci - pdipm->nh; i++) {
1308: row = rstart + pdipm->off_lambdai + pdipm->nh + i;
1310: PetscCall(MatGetRow(pdipm->Jci_xb, i + Jcrstart, &nc, &cols, &aa));
1311: proc = 0;
1312: for (j = 0; j < nc; j++) {
1313: while (cols[j] >= cranges[proc + 1]) proc++;
1314: col = cols[j] - cranges[proc] + Jranges[proc];
1315: PetscCall(MatSetValue(J, col, row, -aa[j], INSERT_VALUES));
1316: PetscCall(MatSetValue(J, row, col, -aa[j], INSERT_VALUES));
1317: }
1318: PetscCall(MatRestoreRow(pdipm->Jci_xb, i + Jcrstart, &nc, &cols, &aa));
1320: col = rstart + pdipm->off_z + pdipm->nh + i;
1321: PetscCall(MatSetValue(J, row, col, 1, INSERT_VALUES));
1322: }
1324: for (i = 0; i < pdipm->nh; i++) {
1325: row = rstart + pdipm->off_lambdai + i;
1326: col = rstart + pdipm->off_z + i;
1327: PetscCall(MatSetValue(J, row, col, 1, INSERT_VALUES));
1328: }
1330: /* Row block of K: [ 0, 0, I, ...] */
1331: for (i = 0; i < pdipm->nci; i++) {
1332: row = rstart + pdipm->off_z + i;
1333: col = rstart + pdipm->off_lambdai + i;
1334: PetscCall(MatSetValue(J, row, col, 1, INSERT_VALUES));
1335: }
1337: if (pdipm->Nxfixed) PetscCall(MatDestroy(&Jce_xfixed_trans));
1338: PetscCall(MatDestroy(&Jci_xb_trans));
1339: PetscCall(PetscFree3(ng_all, nh_all, Jranges));
1341: /* (9) Set up nonlinear solver SNES */
1342: PetscCall(SNESSetFunction(pdipm->snes, NULL, TaoSNESFunction_PDIPM, (void *)tao));
1343: PetscCall(SNESSetJacobian(pdipm->snes, J, J, TaoSNESJacobian_PDIPM, (void *)tao));
1345: if (pdipm->solve_reduced_kkt) {
1346: PC pc;
1347: PetscCall(KSPGetPC(tao->ksp, &pc));
1348: PetscCall(PCSetType(pc, PCFIELDSPLIT));
1349: PetscCall(PCFieldSplitSetType(pc, PC_COMPOSITE_SCHUR));
1350: PetscCall(PCFieldSplitSetIS(pc, "2", pdipm->is2));
1351: PetscCall(PCFieldSplitSetIS(pc, "1", pdipm->is1));
1352: }
1353: PetscCall(SNESSetFromOptions(pdipm->snes));
1355: /* (10) Setup PCPreSolve() for pdipm->solve_symmetric_kkt */
1356: if (pdipm->solve_symmetric_kkt) {
1357: KSP ksp;
1358: PC pc;
1359: PetscBool isCHOL;
1360: PetscCall(SNESGetKSP(pdipm->snes, &ksp));
1361: PetscCall(KSPGetPC(ksp, &pc));
1362: PetscCall(PCSetPreSolve(pc, PCPreSolve_PDIPM));
1364: PetscCall(PetscObjectTypeCompare((PetscObject)pc, PCCHOLESKY, &isCHOL));
1365: if (isCHOL) {
1366: Mat Factor;
1367: PetscBool isMUMPS;
1368: PetscCall(PCFactorGetMatrix(pc, &Factor));
1369: PetscCall(PetscObjectTypeCompare((PetscObject)Factor, "mumps", &isMUMPS));
1370: if (isMUMPS) { /* must set mumps ICNTL(13)=1 and ICNTL(24)=1 to call MatGetInertia() */
1371: #if defined(PETSC_HAVE_MUMPS)
1372: PetscCall(MatMumpsSetIcntl(Factor, 24, 1)); /* detection of null pivot rows */
1373: if (size > 1) { PetscCall(MatMumpsSetIcntl(Factor, 13, 1)); /* parallelism of the root node (enable ScaLAPACK) and its splitting */ }
1374: #else
1375: SETERRQ(PetscObjectComm((PetscObject)tao), PETSC_ERR_SUP, "Requires external package MUMPS");
1376: #endif
1377: }
1378: }
1379: }
1380: PetscFunctionReturn(PETSC_SUCCESS);
1381: }
1383: /*
1384: TaoDestroy_PDIPM - Destroys the pdipm object
1386: Input:
1387: full pdipm
1389: Output:
1390: Destroyed pdipm
1391: */
1392: PetscErrorCode TaoDestroy_PDIPM(Tao tao)
1393: {
1394: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
1396: PetscFunctionBegin;
1397: /* Freeing Vectors assocaiated with KKT (X) */
1398: PetscCall(VecDestroy(&pdipm->x)); /* Solution x */
1399: PetscCall(VecDestroy(&pdipm->lambdae)); /* Equality constraints lagrangian multiplier*/
1400: PetscCall(VecDestroy(&pdipm->lambdai)); /* Inequality constraints lagrangian multiplier*/
1401: PetscCall(VecDestroy(&pdipm->z)); /* Slack variables */
1402: PetscCall(VecDestroy(&pdipm->X)); /* Big KKT system vector [x; lambdae; lambdai; z] */
1404: /* work vectors */
1405: PetscCall(VecDestroy(&pdipm->lambdae_xfixed));
1406: PetscCall(VecDestroy(&pdipm->lambdai_xb));
1408: /* Legrangian equality and inequality Vec */
1409: PetscCall(VecDestroy(&pdipm->ce)); /* Vec of equality constraints */
1410: PetscCall(VecDestroy(&pdipm->ci)); /* Vec of inequality constraints */
1412: /* Matrices */
1413: PetscCall(MatDestroy(&pdipm->Jce_xfixed));
1414: PetscCall(MatDestroy(&pdipm->Jci_xb)); /* Jacobian of inequality constraints Jci = [tao->jacobian_inequality ; J(nxub); J(nxlb); J(nxbx)] */
1415: PetscCall(MatDestroy(&pdipm->K));
1417: /* Index Sets */
1418: if (pdipm->Nxub) { PetscCall(ISDestroy(&pdipm->isxub)); /* Finite upper bound only -inf < x < ub */ }
1420: if (pdipm->Nxlb) { PetscCall(ISDestroy(&pdipm->isxlb)); /* Finite lower bound only lb <= x < inf */ }
1422: if (pdipm->Nxfixed) { PetscCall(ISDestroy(&pdipm->isxfixed)); /* Fixed variables lb = x = ub */ }
1424: if (pdipm->Nxbox) { PetscCall(ISDestroy(&pdipm->isxbox)); /* Boxed variables lb <= x <= ub */ }
1426: if (pdipm->Nxfree) { PetscCall(ISDestroy(&pdipm->isxfree)); /* Free variables -inf <= x <= inf */ }
1428: if (pdipm->solve_reduced_kkt) {
1429: PetscCall(ISDestroy(&pdipm->is1));
1430: PetscCall(ISDestroy(&pdipm->is2));
1431: }
1433: /* SNES */
1434: PetscCall(SNESDestroy(&pdipm->snes)); /* Nonlinear solver */
1435: PetscCall(PetscFree(pdipm->nce_all));
1436: PetscCall(MatDestroy(&pdipm->jac_equality_trans));
1437: PetscCall(MatDestroy(&pdipm->jac_inequality_trans));
1439: /* Destroy pdipm */
1440: PetscCall(PetscFree(tao->data)); /* Holding locations of pdipm */
1442: /* Destroy Dual */
1443: PetscCall(VecDestroy(&tao->DE)); /* equality dual */
1444: PetscCall(VecDestroy(&tao->DI)); /* dinequality dual */
1445: PetscFunctionReturn(PETSC_SUCCESS);
1446: }
1448: PetscErrorCode TaoSetFromOptions_PDIPM(Tao tao, PetscOptionItems *PetscOptionsObject)
1449: {
1450: TAO_PDIPM *pdipm = (TAO_PDIPM *)tao->data;
1452: PetscFunctionBegin;
1453: PetscOptionsHeadBegin(PetscOptionsObject, "PDIPM method for constrained optimization");
1454: PetscCall(PetscOptionsReal("-tao_pdipm_push_init_slack", "parameter to push initial slack variables away from bounds", NULL, pdipm->push_init_slack, &pdipm->push_init_slack, NULL));
1455: PetscCall(PetscOptionsReal("-tao_pdipm_push_init_lambdai", "parameter to push initial (inequality) dual variables away from bounds", NULL, pdipm->push_init_lambdai, &pdipm->push_init_lambdai, NULL));
1456: PetscCall(PetscOptionsBool("-tao_pdipm_solve_reduced_kkt", "Solve reduced KKT system using Schur-complement", NULL, pdipm->solve_reduced_kkt, &pdipm->solve_reduced_kkt, NULL));
1457: PetscCall(PetscOptionsReal("-tao_pdipm_mu_update_factor", "Update scalar for barrier parameter (mu) update", NULL, pdipm->mu_update_factor, &pdipm->mu_update_factor, NULL));
1458: PetscCall(PetscOptionsBool("-tao_pdipm_symmetric_kkt", "Solve non reduced symmetric KKT system", NULL, pdipm->solve_symmetric_kkt, &pdipm->solve_symmetric_kkt, NULL));
1459: PetscCall(PetscOptionsBool("-tao_pdipm_kkt_shift_pd", "Add shifts to make KKT matrix positive definite", NULL, pdipm->kkt_pd, &pdipm->kkt_pd, NULL));
1460: PetscOptionsHeadEnd();
1461: PetscFunctionReturn(PETSC_SUCCESS);
1462: }
1464: /*MC
1465: TAOPDIPM - Barrier-based primal-dual interior point algorithm for generally constrained optimization.
1467: Option Database Keys:
1468: + -tao_pdipm_push_init_lambdai - parameter to push initial dual variables away from bounds (> 0)
1469: . -tao_pdipm_push_init_slack - parameter to push initial slack variables away from bounds (> 0)
1470: . -tao_pdipm_mu_update_factor - update scalar for barrier parameter (mu) update (> 0)
1471: . -tao_pdipm_symmetric_kkt - Solve non-reduced symmetric KKT system
1472: - -tao_pdipm_kkt_shift_pd - Add shifts to make KKT matrix positive definite
1474: Level: beginner
1475: M*/
1476: PETSC_EXTERN PetscErrorCode TaoCreate_PDIPM(Tao tao)
1477: {
1478: TAO_PDIPM *pdipm;
1480: PetscFunctionBegin;
1481: tao->ops->setup = TaoSetup_PDIPM;
1482: tao->ops->solve = TaoSolve_PDIPM;
1483: tao->ops->setfromoptions = TaoSetFromOptions_PDIPM;
1484: tao->ops->view = TaoView_PDIPM;
1485: tao->ops->destroy = TaoDestroy_PDIPM;
1487: PetscCall(PetscNew(&pdipm));
1488: tao->data = (void *)pdipm;
1490: pdipm->nx = pdipm->Nx = 0;
1491: pdipm->nxfixed = pdipm->Nxfixed = 0;
1492: pdipm->nxlb = pdipm->Nxlb = 0;
1493: pdipm->nxub = pdipm->Nxub = 0;
1494: pdipm->nxbox = pdipm->Nxbox = 0;
1495: pdipm->nxfree = pdipm->Nxfree = 0;
1497: pdipm->ng = pdipm->Ng = pdipm->nce = pdipm->Nce = 0;
1498: pdipm->nh = pdipm->Nh = pdipm->nci = pdipm->Nci = 0;
1499: pdipm->n = pdipm->N = 0;
1500: pdipm->mu = 1.0;
1501: pdipm->mu_update_factor = 0.1;
1503: pdipm->deltaw = 0.0;
1504: pdipm->lastdeltaw = 3 * 1.e-4;
1505: pdipm->deltac = 0.0;
1506: pdipm->kkt_pd = PETSC_FALSE;
1508: pdipm->push_init_slack = 1.0;
1509: pdipm->push_init_lambdai = 1.0;
1510: pdipm->solve_reduced_kkt = PETSC_FALSE;
1511: pdipm->solve_symmetric_kkt = PETSC_TRUE;
1513: /* Override default settings (unless already changed) */
1514: if (!tao->max_it_changed) tao->max_it = 200;
1515: if (!tao->max_funcs_changed) tao->max_funcs = 500;
1517: PetscCall(SNESCreate(((PetscObject)tao)->comm, &pdipm->snes));
1518: PetscCall(SNESSetOptionsPrefix(pdipm->snes, tao->hdr.prefix));
1519: PetscCall(SNESGetKSP(pdipm->snes, &tao->ksp));
1520: PetscCall(PetscObjectReference((PetscObject)tao->ksp));
1521: PetscCall(KSPSetApplicationContext(tao->ksp, (void *)tao));
1522: PetscFunctionReturn(PETSC_SUCCESS);
1523: }